diff options
Diffstat (limited to 'source/blender/windowmanager/gizmo')
11 files changed, 1041 insertions, 1018 deletions
diff --git a/source/blender/windowmanager/gizmo/WM_gizmo_api.h b/source/blender/windowmanager/gizmo/WM_gizmo_api.h index a93597d4f64..dd39cc96d6f 100644 --- a/source/blender/windowmanager/gizmo/WM_gizmo_api.h +++ b/source/blender/windowmanager/gizmo/WM_gizmo_api.h @@ -60,57 +60,57 @@ struct wmMsgSubscribeValue; /* wmGizmo */ struct wmGizmo *WM_gizmo_new_ptr( - const struct wmGizmoType *wt, struct wmGizmoGroup *mgroup, + const struct wmGizmoType *gzt, struct wmGizmoGroup *gzgroup, struct PointerRNA *properties); struct wmGizmo *WM_gizmo_new( - const char *idname, struct wmGizmoGroup *mgroup, + const char *idname, struct wmGizmoGroup *gzgroup, struct PointerRNA *properties); -void WM_gizmo_free(struct wmGizmo *mpr); +void WM_gizmo_free(struct wmGizmo *gz); void WM_gizmo_unlink( - ListBase *gizmolist, struct wmGizmoMap *mmap, struct wmGizmo *mpr, + ListBase *gizmolist, struct wmGizmoMap *gzmap, struct wmGizmo *gz, struct bContext *C); -void WM_gizmo_name_set(struct wmGizmoGroup *mgroup, struct wmGizmo *mpr, const char *name); +void WM_gizmo_name_set(struct wmGizmoGroup *gzgroup, struct wmGizmo *gz, const char *name); -bool WM_gizmo_select_unlink(struct wmGizmoMap *mmap, struct wmGizmo *mpr); -bool WM_gizmo_select_set(struct wmGizmoMap *mmap, struct wmGizmo *mpr, bool select); -void WM_gizmo_highlight_set(struct wmGizmoMap *mmap, struct wmGizmo *mpr); +bool WM_gizmo_select_unlink(struct wmGizmoMap *gzmap, struct wmGizmo *gz); +bool WM_gizmo_select_set(struct wmGizmoMap *gzmap, struct wmGizmo *gz, bool select); +void WM_gizmo_highlight_set(struct wmGizmoMap *gzmap, struct wmGizmo *gz); void WM_gizmo_modal_set_from_setup( - struct wmGizmoMap *mmap, struct bContext *C, - struct wmGizmo *mpr, int part_index, const struct wmEvent *event); + struct wmGizmoMap *gzmap, struct bContext *C, + struct wmGizmo *gz, int part_index, const struct wmEvent *event); struct wmGizmoOpElem *WM_gizmo_operator_get( - struct wmGizmo *mpr, int part_index); + struct wmGizmo *gz, int part_index); struct PointerRNA *WM_gizmo_operator_set( - struct wmGizmo *mpr, int part_index, + struct wmGizmo *gz, int part_index, struct wmOperatorType *ot, struct IDProperty *properties); /* callbacks */ -void WM_gizmo_set_fn_custom_modal(struct wmGizmo *mpr, wmGizmoFnModal fn); +void WM_gizmo_set_fn_custom_modal(struct wmGizmo *gz, wmGizmoFnModal fn); void WM_gizmo_set_matrix_location( - struct wmGizmo *mpr, const float origin[3]); + struct wmGizmo *gz, const float origin[3]); void WM_gizmo_set_matrix_rotation_from_z_axis( - struct wmGizmo *mpr, const float z_axis[3]); + struct wmGizmo *gz, const float z_axis[3]); void WM_gizmo_set_matrix_rotation_from_yz_axis( - struct wmGizmo *mpr, const float y_axis[3], const float z_axis[3]); + struct wmGizmo *gz, const float y_axis[3], const float z_axis[3]); void WM_gizmo_set_matrix_offset_location( - struct wmGizmo *mpr, const float origin[3]); + struct wmGizmo *gz, const float origin[3]); void WM_gizmo_set_matrix_offset_rotation_from_z_axis( - struct wmGizmo *mpr, const float z_axis[3]); + struct wmGizmo *gz, const float z_axis[3]); void WM_gizmo_set_matrix_offset_rotation_from_yz_axis( - struct wmGizmo *mpr, const float y_axis[3], const float z_axis[3]); + struct wmGizmo *gz, const float y_axis[3], const float z_axis[3]); -void WM_gizmo_set_flag(struct wmGizmo *mpr, const int flag, const bool enable); -void WM_gizmo_set_scale(struct wmGizmo *mpr, float scale); -void WM_gizmo_set_line_width(struct wmGizmo *mpr, const float line_width); +void WM_gizmo_set_flag(struct wmGizmo *gz, const int flag, const bool enable); +void WM_gizmo_set_scale(struct wmGizmo *gz, const float scale); +void WM_gizmo_set_line_width(struct wmGizmo *gz, const float line_width); -void WM_gizmo_get_color(const struct wmGizmo *mpr, float color[4]); -void WM_gizmo_set_color(struct wmGizmo *mpr, const float color[4]); -void WM_gizmo_get_color_highlight(const struct wmGizmo *mpr, float color_hi[4]); -void WM_gizmo_set_color_highlight(struct wmGizmo *mpr, const float color[4]); +void WM_gizmo_get_color(const struct wmGizmo *gz, float color[4]); +void WM_gizmo_set_color(struct wmGizmo *gz, const float color[4]); +void WM_gizmo_get_color_highlight(const struct wmGizmo *gz, float color_hi[4]); +void WM_gizmo_set_color_highlight(struct wmGizmo *gz, const float color[4]); /** * Leaving values NULL use values from #wmGizmo. @@ -123,16 +123,16 @@ struct WM_GizmoMatrixParams { }; void WM_gizmo_calc_matrix_final_params( - const struct wmGizmo *mpr, const struct WM_GizmoMatrixParams *params, + const struct wmGizmo *gz, const struct WM_GizmoMatrixParams *params, float r_mat[4][4]); void WM_gizmo_calc_matrix_final_no_offset( - const struct wmGizmo *mpr, float r_mat[4][4]); + const struct wmGizmo *gz, float r_mat[4][4]); void WM_gizmo_calc_matrix_final( - const struct wmGizmo *mpr, float r_mat[4][4]); + const struct wmGizmo *gz, float r_mat[4][4]); /* properties */ -void WM_gizmo_properties_create_ptr(struct PointerRNA *ptr, struct wmGizmoType *wt); +void WM_gizmo_properties_create_ptr(struct PointerRNA *ptr, struct wmGizmoType *gzt); void WM_gizmo_properties_create(struct PointerRNA *ptr, const char *opstring); void WM_gizmo_properties_alloc(struct PointerRNA **ptr, struct IDProperty **properties, const char *wtstring); void WM_gizmo_properties_sanitize(struct PointerRNA *ptr, const bool no_context); @@ -147,7 +147,7 @@ const struct wmGizmoType *WM_gizmotype_find(const char *idname, bool quiet); void WM_gizmotype_append(void (*wtfunc)(struct wmGizmoType *)); void WM_gizmotype_append_ptr(void (*mnpfunc)(struct wmGizmoType *, void *), void *userdata); bool WM_gizmotype_remove(struct bContext *C, struct Main *bmain, const char *idname); -void WM_gizmotype_remove_ptr(struct bContext *C, struct Main *bmain, struct wmGizmoType *wt); +void WM_gizmotype_remove_ptr(struct bContext *C, struct Main *bmain, struct wmGizmoType *gzt); void WM_gizmotype_iter(struct GHashIterator *ghi); /* wm_gizmo_group_type.c */ @@ -159,111 +159,111 @@ void WM_gizmogrouptype_free_ptr(struct wmGizmoGroupType *wt); void WM_gizmogrouptype_iter(struct GHashIterator *ghi); struct wmGizmoGroupTypeRef *WM_gizmogrouptype_append_and_link( - struct wmGizmoMapType *mmap_type, + struct wmGizmoMapType *gzmap_type, void (*wtfunc)(struct wmGizmoGroupType *)); /* wm_gizmo_map.c */ /* Dynamic Updates (for RNA runtime registration) */ -void WM_gizmoconfig_update_tag_init(struct wmGizmoMapType *mmap_type, struct wmGizmoGroupType *wgt); -void WM_gizmoconfig_update_tag_remove(struct wmGizmoMapType *mmap_type, struct wmGizmoGroupType *wgt); +void WM_gizmoconfig_update_tag_init(struct wmGizmoMapType *gzmap_type, struct wmGizmoGroupType *gzgt); +void WM_gizmoconfig_update_tag_remove(struct wmGizmoMapType *gzmap_type, struct wmGizmoGroupType *gzgt); void WM_gizmoconfig_update(struct Main *bmain); /* wm_maniulator_target_props.c */ -struct wmGizmoProperty *WM_gizmo_target_property_array(struct wmGizmo *mpr); +struct wmGizmoProperty *WM_gizmo_target_property_array(struct wmGizmo *gz); struct wmGizmoProperty *WM_gizmo_target_property_at_index( - struct wmGizmo *mpr, int index); + struct wmGizmo *gz, int index); struct wmGizmoProperty *WM_gizmo_target_property_find( - struct wmGizmo *mpr, const char *idname); + struct wmGizmo *gz, const char *idname); void WM_gizmo_target_property_def_rna_ptr( - struct wmGizmo *mpr, const struct wmGizmoPropertyType *mpr_prop_type, + struct wmGizmo *gz, const struct wmGizmoPropertyType *gz_prop_type, struct PointerRNA *ptr, struct PropertyRNA *prop, int index); void WM_gizmo_target_property_def_rna( - struct wmGizmo *mpr, const char *idname, + struct wmGizmo *gz, const char *idname, struct PointerRNA *ptr, const char *propname, int index); void WM_gizmo_target_property_def_func_ptr( - struct wmGizmo *mpr, const struct wmGizmoPropertyType *mpr_prop_type, + struct wmGizmo *gz, const struct wmGizmoPropertyType *gz_prop_type, const struct wmGizmoPropertyFnParams *params); void WM_gizmo_target_property_def_func( - struct wmGizmo *mpr, const char *idname, + struct wmGizmo *gz, const char *idname, const struct wmGizmoPropertyFnParams *params); void WM_gizmo_target_property_clear_rna_ptr( - struct wmGizmo *mpr, const struct wmGizmoPropertyType *mpr_prop_type); + struct wmGizmo *gz, const struct wmGizmoPropertyType *gz_prop_type); void WM_gizmo_target_property_clear_rna( - struct wmGizmo *mpr, const char *idname); + struct wmGizmo *gz, const char *idname); -bool WM_gizmo_target_property_is_valid_any(struct wmGizmo *mpr); +bool WM_gizmo_target_property_is_valid_any(struct wmGizmo *gz); bool WM_gizmo_target_property_is_valid( - const struct wmGizmoProperty *mpr_prop); + const struct wmGizmoProperty *gz_prop); float WM_gizmo_target_property_value_get( - const struct wmGizmo *mpr, struct wmGizmoProperty *mpr_prop); + const struct wmGizmo *gz, struct wmGizmoProperty *gz_prop); void WM_gizmo_target_property_value_set( - struct bContext *C, const struct wmGizmo *mpr, struct wmGizmoProperty *mpr_prop, + struct bContext *C, const struct wmGizmo *gz, struct wmGizmoProperty *gz_prop, const float value); void WM_gizmo_target_property_value_get_array( - const struct wmGizmo *mpr, struct wmGizmoProperty *mpr_prop, + const struct wmGizmo *gz, struct wmGizmoProperty *gz_prop, float *value); void WM_gizmo_target_property_value_set_array( - struct bContext *C, const struct wmGizmo *mpr, struct wmGizmoProperty *mpr_prop, + struct bContext *C, const struct wmGizmo *gz, struct wmGizmoProperty *gz_prop, const float *value); bool WM_gizmo_target_property_range_get( - const struct wmGizmo *mpr, struct wmGizmoProperty *mpr_prop, + const struct wmGizmo *gz, struct wmGizmoProperty *gz_prop, float range[2]); int WM_gizmo_target_property_array_length( - const struct wmGizmo *mpr, struct wmGizmoProperty *mpr_prop); + const struct wmGizmo *gz, struct wmGizmoProperty *gz_prop); /* definitions */ const struct wmGizmoPropertyType *WM_gizmotype_target_property_find( - const struct wmGizmoType *wt, const char *idname); + const struct wmGizmoType *gzt, const char *idname); void WM_gizmotype_target_property_def( - struct wmGizmoType *wt, const char *idname, int data_type, int array_length); + struct wmGizmoType *gzt, const char *idname, int data_type, int array_length); /* utilities */ void WM_gizmo_do_msg_notify_tag_refresh( struct bContext *C, struct wmMsgSubscribeKey *msg_key, struct wmMsgSubscribeValue *msg_val); void WM_gizmo_target_property_subscribe_all( - struct wmGizmo *mpr, struct wmMsgBus *mbus, struct ARegion *ar); + struct wmGizmo *gz, struct wmMsgBus *mbus, struct ARegion *ar); /* -------------------------------------------------------------------- */ /* wmGizmoGroup */ /* Callbacks for 'wmGizmoGroupType.setup_keymap' */ struct wmKeyMap *WM_gizmogroup_keymap_common( - const struct wmGizmoGroupType *wgt, struct wmKeyConfig *config); + const struct wmGizmoGroupType *gzgt, struct wmKeyConfig *config); struct wmKeyMap *WM_gizmogroup_keymap_common_select( - const struct wmGizmoGroupType *wgt, struct wmKeyConfig *config); + const struct wmGizmoGroupType *gzgt, struct wmKeyConfig *config); /* -------------------------------------------------------------------- */ /* wmGizmoMap */ struct wmGizmoMap *WM_gizmomap_new_from_type( - const struct wmGizmoMapType_Params *mmap_params); -const struct ListBase *WM_gizmomap_group_list(struct wmGizmoMap *mmap); + const struct wmGizmoMapType_Params *gzmap_params); +const struct ListBase *WM_gizmomap_group_list(struct wmGizmoMap *gzmap); struct wmGizmoGroup *WM_gizmomap_group_find( - struct wmGizmoMap *mmap, + struct wmGizmoMap *gzmap, const char *idname); struct wmGizmoGroup *WM_gizmomap_group_find_ptr( - struct wmGizmoMap *mmap, - const struct wmGizmoGroupType *wgt); -void WM_gizmomap_tag_refresh(struct wmGizmoMap *mmap); + struct wmGizmoMap *gzmap, + const struct wmGizmoGroupType *gzgt); +void WM_gizmomap_tag_refresh(struct wmGizmoMap *gzmap); void WM_gizmomap_draw( - struct wmGizmoMap *mmap, const struct bContext *C, const eWM_GizmoFlagMapDrawStep drawstep); -void WM_gizmomap_add_handlers(struct ARegion *ar, struct wmGizmoMap *mmap); -bool WM_gizmomap_select_all(struct bContext *C, struct wmGizmoMap *mmap, const int action); -bool WM_gizmomap_cursor_set(const struct wmGizmoMap *mmap, struct wmWindow *win); + struct wmGizmoMap *gzmap, const struct bContext *C, const eWM_GizmoFlagMapDrawStep drawstep); +void WM_gizmomap_add_handlers(struct ARegion *ar, struct wmGizmoMap *gzmap); +bool WM_gizmomap_select_all(struct bContext *C, struct wmGizmoMap *gzmap, const int action); +bool WM_gizmomap_cursor_set(const struct wmGizmoMap *gzmap, struct wmWindow *win); void WM_gizmomap_message_subscribe( - struct bContext *C, struct wmGizmoMap *mmap, struct ARegion *ar, struct wmMsgBus *mbus); -bool WM_gizmomap_is_any_selected(const struct wmGizmoMap *mmap); + struct bContext *C, struct wmGizmoMap *gzmap, struct ARegion *ar, struct wmMsgBus *mbus); +bool WM_gizmomap_is_any_selected(const struct wmGizmoMap *gzmap); bool WM_gizmomap_minmax( - const struct wmGizmoMap *mmap, bool use_hidden, bool use_select, + const struct wmGizmoMap *gzmap, bool use_hidden, bool use_select, float r_min[3], float r_max[3]); struct ARegion *WM_gizmomap_tooltip_init( @@ -273,34 +273,34 @@ struct ARegion *WM_gizmomap_tooltip_init( /* wmGizmoMapType */ struct wmGizmoMapType *WM_gizmomaptype_find( - const struct wmGizmoMapType_Params *mmap_params); + const struct wmGizmoMapType_Params *gzmap_params); struct wmGizmoMapType *WM_gizmomaptype_ensure( - const struct wmGizmoMapType_Params *mmap_params); + const struct wmGizmoMapType_Params *gzmap_params); struct wmGizmoGroupTypeRef *WM_gizmomaptype_group_find( - struct wmGizmoMapType *mmap_type, + struct wmGizmoMapType *gzmap_type, const char *idname); struct wmGizmoGroupTypeRef *WM_gizmomaptype_group_find_ptr( - struct wmGizmoMapType *mmap_type, - const struct wmGizmoGroupType *wgt); + struct wmGizmoMapType *gzmap_type, + const struct wmGizmoGroupType *gzgt); struct wmGizmoGroupTypeRef *WM_gizmomaptype_group_link( - struct wmGizmoMapType *mmap_type, + struct wmGizmoMapType *gzmap_type, const char *idname); struct wmGizmoGroupTypeRef *WM_gizmomaptype_group_link_ptr( - struct wmGizmoMapType *mmap_type, - struct wmGizmoGroupType *wgt); + struct wmGizmoMapType *gzmap_type, + struct wmGizmoGroupType *gzgt); void WM_gizmomaptype_group_init_runtime_keymap( const struct Main *bmain, - struct wmGizmoGroupType *wgt); + struct wmGizmoGroupType *gzgt); void WM_gizmomaptype_group_init_runtime( - const struct Main *bmain, struct wmGizmoMapType *mmap_type, - struct wmGizmoGroupType *wgt); + const struct Main *bmain, struct wmGizmoMapType *gzmap_type, + struct wmGizmoGroupType *gzgt); void WM_gizmomaptype_group_unlink( - struct bContext *C, struct Main *bmain, struct wmGizmoMapType *mmap_type, - const struct wmGizmoGroupType *wgt); + struct bContext *C, struct Main *bmain, struct wmGizmoMapType *gzmap_type, + const struct wmGizmoGroupType *gzgt); -void WM_gizmomaptype_group_free(struct wmGizmoGroupTypeRef *wgt); +void WM_gizmomaptype_group_free(struct wmGizmoGroupTypeRef *gzgt); /* -------------------------------------------------------------------- */ /* GizmoGroup */ @@ -308,36 +308,36 @@ void WM_gizmomaptype_group_free(struct wmGizmoGroupTypeRef *wgt); /* Add/Ensure/Remove (High level API) */ void WM_gizmo_group_type_add_ptr_ex( - struct wmGizmoGroupType *wgt, - struct wmGizmoMapType *mmap_type); + struct wmGizmoGroupType *gzgt, + struct wmGizmoMapType *gzmap_type); void WM_gizmo_group_type_add_ptr( - struct wmGizmoGroupType *wgt); + struct wmGizmoGroupType *gzgt); void WM_gizmo_group_type_add(const char *idname); void WM_gizmo_group_type_ensure_ptr_ex( - struct wmGizmoGroupType *wgt, - struct wmGizmoMapType *mmap_type); + struct wmGizmoGroupType *gzgt, + struct wmGizmoMapType *gzmap_type); void WM_gizmo_group_type_ensure_ptr( - struct wmGizmoGroupType *wgt); + struct wmGizmoGroupType *gzgt); void WM_gizmo_group_type_ensure(const char *idname); void WM_gizmo_group_type_remove_ptr_ex( - struct Main *bmain, struct wmGizmoGroupType *wgt, - struct wmGizmoMapType *mmap_type); + struct Main *bmain, struct wmGizmoGroupType *gzgt, + struct wmGizmoMapType *gzmap_type); void WM_gizmo_group_type_remove_ptr( - struct Main *bmain, struct wmGizmoGroupType *wgt); + struct Main *bmain, struct wmGizmoGroupType *gzgt); void WM_gizmo_group_type_remove(struct Main *bmain, const char *idname); void WM_gizmo_group_type_unlink_delayed_ptr_ex( - struct wmGizmoGroupType *wgt, - struct wmGizmoMapType *mmap_type); + struct wmGizmoGroupType *gzgt, + struct wmGizmoMapType *gzmap_type); void WM_gizmo_group_type_unlink_delayed_ptr( - struct wmGizmoGroupType *wgt); + struct wmGizmoGroupType *gzgt); void WM_gizmo_group_type_unlink_delayed(const char *idname); /* Utilities */ bool WM_gizmo_context_check_drawstep(const struct bContext *C, eWM_GizmoFlagMapDrawStep step); -bool WM_gizmo_group_type_poll(const struct bContext *C, const struct wmGizmoGroupType *wgt); +bool WM_gizmo_group_type_poll(const struct bContext *C, const struct wmGizmoGroupType *gzgt); #endif /* __WM_GIZMO_API_H__ */ diff --git a/source/blender/windowmanager/gizmo/WM_gizmo_types.h b/source/blender/windowmanager/gizmo/WM_gizmo_types.h index ecdda256306..2339523db5e 100644 --- a/source/blender/windowmanager/gizmo/WM_gizmo_types.h +++ b/source/blender/windowmanager/gizmo/WM_gizmo_types.h @@ -171,7 +171,7 @@ struct wmGizmo { wmGizmoFnModal custom_modal; /* pointer back to group this gizmo is in (just for quick access) */ - struct wmGizmoGroup *parent_mgroup; + struct wmGizmoGroup *parent_gzgroup; void *py_instance; @@ -385,7 +385,7 @@ typedef struct wmGizmoGroupType { eWM_GizmoFlagMapTypeUpdateFlag type_update_flag; /* same as gizmo-maps, so registering/unregistering goes to the correct region */ - struct wmGizmoMapType_Params mmap_params; + struct wmGizmoMapType_Params gzmap_params; } wmGizmoGroupType; @@ -395,7 +395,7 @@ typedef struct wmGizmoGroup { struct wmGizmoGroupType *type; ListBase gizmos; - struct wmGizmoMap *parent_mmap; + struct wmGizmoMap *parent_gzmap; void *py_instance; /* python stores the class instance here */ struct ReportList *reports; /* errors and warnings storage */ diff --git a/source/blender/windowmanager/gizmo/intern/wm_gizmo.c b/source/blender/windowmanager/gizmo/intern/wm_gizmo.c index da8b301b536..14deb0be725 100644 --- a/source/blender/windowmanager/gizmo/intern/wm_gizmo.c +++ b/source/blender/windowmanager/gizmo/intern/wm_gizmo.c @@ -67,98 +67,98 @@ #include "wm_gizmo_intern.h" static void wm_gizmo_register( - wmGizmoGroup *mgroup, wmGizmo *mpr); + wmGizmoGroup *gzgroup, wmGizmo *gz); /** * \note Follow #wm_operator_create convention. */ static wmGizmo *wm_gizmo_create( - const wmGizmoType *wt, + const wmGizmoType *gzt, PointerRNA *properties) { - BLI_assert(wt != NULL); - BLI_assert(wt->struct_size >= sizeof(wmGizmo)); + BLI_assert(gzt != NULL); + BLI_assert(gzt->struct_size >= sizeof(wmGizmo)); - wmGizmo *mpr = MEM_callocN( - wt->struct_size + (sizeof(wmGizmoProperty) * wt->target_property_defs_len), __func__); - mpr->type = wt; + wmGizmo *gz = MEM_callocN( + gzt->struct_size + (sizeof(wmGizmoProperty) * gzt->target_property_defs_len), __func__); + gz->type = gzt; /* initialize properties, either copy or create */ - mpr->ptr = MEM_callocN(sizeof(PointerRNA), "wmGizmoPtrRNA"); + gz->ptr = MEM_callocN(sizeof(PointerRNA), "wmGizmoPtrRNA"); if (properties && properties->data) { - mpr->properties = IDP_CopyProperty(properties->data); + gz->properties = IDP_CopyProperty(properties->data); } else { IDPropertyTemplate val = {0}; - mpr->properties = IDP_New(IDP_GROUP, &val, "wmGizmoProperties"); + gz->properties = IDP_New(IDP_GROUP, &val, "wmGizmoProperties"); } - RNA_pointer_create(G_MAIN->wm.first, wt->srna, mpr->properties, mpr->ptr); + RNA_pointer_create(G_MAIN->wm.first, gzt->srna, gz->properties, gz->ptr); - WM_gizmo_properties_sanitize(mpr->ptr, 0); + WM_gizmo_properties_sanitize(gz->ptr, 0); - unit_m4(mpr->matrix_space); - unit_m4(mpr->matrix_basis); - unit_m4(mpr->matrix_offset); + unit_m4(gz->matrix_space); + unit_m4(gz->matrix_basis); + unit_m4(gz->matrix_offset); - mpr->drag_part = -1; + gz->drag_part = -1; - return mpr; + return gz; } wmGizmo *WM_gizmo_new_ptr( - const wmGizmoType *wt, wmGizmoGroup *mgroup, + const wmGizmoType *gzt, wmGizmoGroup *gzgroup, PointerRNA *properties) { - wmGizmo *mpr = wm_gizmo_create(wt, properties); + wmGizmo *gz = wm_gizmo_create(gzt, properties); - wm_gizmo_register(mgroup, mpr); + wm_gizmo_register(gzgroup, gz); - if (mpr->type->setup != NULL) { - mpr->type->setup(mpr); + if (gz->type->setup != NULL) { + gz->type->setup(gz); } - return mpr; + return gz; } /** - * \param wt: Must be valid, + * \param gt: Must be valid, * if you need to check it exists use #WM_gizmo_new_ptr * because callers of this function don't NULL check the return value. */ wmGizmo *WM_gizmo_new( - const char *idname, wmGizmoGroup *mgroup, + const char *idname, wmGizmoGroup *gzgroup, PointerRNA *properties) { - const wmGizmoType *wt = WM_gizmotype_find(idname, false); - return WM_gizmo_new_ptr(wt, mgroup, properties); + const wmGizmoType *gzt = WM_gizmotype_find(idname, false); + return WM_gizmo_new_ptr(gzt, gzgroup, properties); } /** * Initialize default values and allocate needed memory for members. */ -static void gizmo_init(wmGizmo *mpr) +static void gizmo_init(wmGizmo *gz) { const float color_default[4] = {1.0f, 1.0f, 1.0f, 1.0f}; - mpr->scale_basis = 1.0f; - mpr->line_width = 1.0f; + gz->scale_basis = 1.0f; + gz->line_width = 1.0f; /* defaults */ - copy_v4_v4(mpr->color, color_default); - copy_v4_v4(mpr->color_hi, color_default); + copy_v4_v4(gz->color, color_default); + copy_v4_v4(gz->color_hi, color_default); } /** * Register \a gizmo. * - * \param name: name used to create a unique idname for \a gizmo in \a mgroup + * \param name: name used to create a unique idname for \a gizmo in \a gzgroup * * \note Not to be confused with type registration from RNA. */ -static void wm_gizmo_register(wmGizmoGroup *mgroup, wmGizmo *mpr) +static void wm_gizmo_register(wmGizmoGroup *gzgroup, wmGizmo *gz) { - gizmo_init(mpr); - wm_gizmogroup_gizmo_register(mgroup, mpr); + gizmo_init(gz); + wm_gizmogroup_gizmo_register(gzgroup, gz); } /** @@ -166,70 +166,70 @@ static void wm_gizmo_register(wmGizmoGroup *mgroup, wmGizmo *mpr) * Typical use is when freeing the windowing data, * where caller can manage clearing selection, highlight... etc. */ -void WM_gizmo_free(wmGizmo *mpr) +void WM_gizmo_free(wmGizmo *gz) { - if (mpr->type->free != NULL) { - mpr->type->free(mpr); + if (gz->type->free != NULL) { + gz->type->free(gz); } #ifdef WITH_PYTHON - if (mpr->py_instance) { + if (gz->py_instance) { /* do this first in case there are any __del__ functions or * similar that use properties */ - BPY_DECREF_RNA_INVALIDATE(mpr->py_instance); + BPY_DECREF_RNA_INVALIDATE(gz->py_instance); } #endif - if (mpr->op_data) { - for (int i = 0; i < mpr->op_data_len; i++) { - WM_operator_properties_free(&mpr->op_data[i].ptr); + if (gz->op_data) { + for (int i = 0; i < gz->op_data_len; i++) { + WM_operator_properties_free(&gz->op_data[i].ptr); } - MEM_freeN(mpr->op_data); + MEM_freeN(gz->op_data); } - if (mpr->ptr != NULL) { - WM_gizmo_properties_free(mpr->ptr); - MEM_freeN(mpr->ptr); + if (gz->ptr != NULL) { + WM_gizmo_properties_free(gz->ptr); + MEM_freeN(gz->ptr); } - if (mpr->type->target_property_defs_len != 0) { - wmGizmoProperty *mpr_prop_array = WM_gizmo_target_property_array(mpr); - for (int i = 0; i < mpr->type->target_property_defs_len; i++) { - wmGizmoProperty *mpr_prop = &mpr_prop_array[i]; - if (mpr_prop->custom_func.free_fn) { - mpr_prop->custom_func.free_fn(mpr, mpr_prop); + if (gz->type->target_property_defs_len != 0) { + wmGizmoProperty *gz_prop_array = WM_gizmo_target_property_array(gz); + for (int i = 0; i < gz->type->target_property_defs_len; i++) { + wmGizmoProperty *gz_prop = &gz_prop_array[i]; + if (gz_prop->custom_func.free_fn) { + gz_prop->custom_func.free_fn(gz, gz_prop); } } } - MEM_freeN(mpr); + MEM_freeN(gz); } /** * Free \a gizmo and unlink from \a gizmolist. * \a gizmolist is allowed to be NULL. */ -void WM_gizmo_unlink(ListBase *gizmolist, wmGizmoMap *mmap, wmGizmo *mpr, bContext *C) +void WM_gizmo_unlink(ListBase *gizmolist, wmGizmoMap *gzmap, wmGizmo *gz, bContext *C) { - if (mpr->state & WM_GIZMO_STATE_HIGHLIGHT) { - wm_gizmomap_highlight_set(mmap, C, NULL, 0); + if (gz->state & WM_GIZMO_STATE_HIGHLIGHT) { + wm_gizmomap_highlight_set(gzmap, C, NULL, 0); } - if (mpr->state & WM_GIZMO_STATE_MODAL) { - wm_gizmomap_modal_set(mmap, C, mpr, NULL, false); + if (gz->state & WM_GIZMO_STATE_MODAL) { + wm_gizmomap_modal_set(gzmap, C, gz, NULL, false); } /* Unlink instead of setting so we don't run callbacks. */ - if (mpr->state & WM_GIZMO_STATE_SELECT) { - WM_gizmo_select_unlink(mmap, mpr); + if (gz->state & WM_GIZMO_STATE_SELECT) { + WM_gizmo_select_unlink(gzmap, gz); } if (gizmolist) { - BLI_remlink(gizmolist, mpr); + BLI_remlink(gizmolist, gz); } - BLI_assert(mmap->mmap_context.highlight != mpr); - BLI_assert(mmap->mmap_context.modal != mpr); + BLI_assert(gzmap->gzmap_context.highlight != gz); + BLI_assert(gzmap->gzmap_context.modal != gz); - WM_gizmo_free(mpr); + WM_gizmo_free(gz); } /* -------------------------------------------------------------------- */ @@ -240,25 +240,25 @@ void WM_gizmo_unlink(ListBase *gizmolist, wmGizmoMap *mmap, wmGizmo *mpr, bConte * \{ */ struct wmGizmoOpElem *WM_gizmo_operator_get( - wmGizmo *mpr, int part_index) + wmGizmo *gz, int part_index) { - if (mpr->op_data && ((part_index >= 0) && (part_index < mpr->op_data_len))) { - return &mpr->op_data[part_index]; + if (gz->op_data && ((part_index >= 0) && (part_index < gz->op_data_len))) { + return &gz->op_data[part_index]; } return NULL; } PointerRNA *WM_gizmo_operator_set( - wmGizmo *mpr, int part_index, + wmGizmo *gz, int part_index, wmOperatorType *ot, IDProperty *properties) { BLI_assert(part_index < 255); /* We could pre-allocate these but using multiple is such a rare thing. */ - if (part_index >= mpr->op_data_len) { - mpr->op_data_len = part_index + 1; - mpr->op_data = MEM_recallocN(mpr->op_data, sizeof(*mpr->op_data) * mpr->op_data_len); + if (part_index >= gz->op_data_len) { + gz->op_data_len = part_index + 1; + gz->op_data = MEM_recallocN(gz->op_data, sizeof(*gz->op_data) * gz->op_data_len); } - wmGizmoOpElem *mpop = &mpr->op_data[part_index]; + wmGizmoOpElem *mpop = &gz->op_data[part_index]; mpop->type = ot; if (mpop->ptr.data) { @@ -305,56 +305,56 @@ static void wm_gizmo_set_matrix_rotation_from_yz_axis__internal( * wmGizmo.matrix utils. */ void WM_gizmo_set_matrix_rotation_from_z_axis( - wmGizmo *mpr, const float z_axis[3]) + wmGizmo *gz, const float z_axis[3]) { - wm_gizmo_set_matrix_rotation_from_z_axis__internal(mpr->matrix_basis, z_axis); + wm_gizmo_set_matrix_rotation_from_z_axis__internal(gz->matrix_basis, z_axis); } void WM_gizmo_set_matrix_rotation_from_yz_axis( - wmGizmo *mpr, const float y_axis[3], const float z_axis[3]) + wmGizmo *gz, const float y_axis[3], const float z_axis[3]) { - wm_gizmo_set_matrix_rotation_from_yz_axis__internal(mpr->matrix_basis, y_axis, z_axis); + wm_gizmo_set_matrix_rotation_from_yz_axis__internal(gz->matrix_basis, y_axis, z_axis); } -void WM_gizmo_set_matrix_location(wmGizmo *mpr, const float origin[3]) +void WM_gizmo_set_matrix_location(wmGizmo *gz, const float origin[3]) { - copy_v3_v3(mpr->matrix_basis[3], origin); + copy_v3_v3(gz->matrix_basis[3], origin); } /** * wmGizmo.matrix_offset utils. */ void WM_gizmo_set_matrix_offset_rotation_from_z_axis( - wmGizmo *mpr, const float z_axis[3]) + wmGizmo *gz, const float z_axis[3]) { - wm_gizmo_set_matrix_rotation_from_z_axis__internal(mpr->matrix_offset, z_axis); + wm_gizmo_set_matrix_rotation_from_z_axis__internal(gz->matrix_offset, z_axis); } void WM_gizmo_set_matrix_offset_rotation_from_yz_axis( - wmGizmo *mpr, const float y_axis[3], const float z_axis[3]) + wmGizmo *gz, const float y_axis[3], const float z_axis[3]) { - wm_gizmo_set_matrix_rotation_from_yz_axis__internal(mpr->matrix_offset, y_axis, z_axis); + wm_gizmo_set_matrix_rotation_from_yz_axis__internal(gz->matrix_offset, y_axis, z_axis); } -void WM_gizmo_set_matrix_offset_location(wmGizmo *mpr, const float offset[3]) +void WM_gizmo_set_matrix_offset_location(wmGizmo *gz, const float offset[3]) { - copy_v3_v3(mpr->matrix_offset[3], offset); + copy_v3_v3(gz->matrix_offset[3], offset); } -void WM_gizmo_set_flag(wmGizmo *mpr, const int flag, const bool enable) +void WM_gizmo_set_flag(wmGizmo *gz, const int flag, const bool enable) { if (enable) { - mpr->flag |= flag; + gz->flag |= flag; } else { - mpr->flag &= ~flag; + gz->flag &= ~flag; } } -void WM_gizmo_set_scale(wmGizmo *mpr, const float scale) +void WM_gizmo_set_scale(wmGizmo *gz, const float scale) { - mpr->scale_basis = scale; + gz->scale_basis = scale; } -void WM_gizmo_set_line_width(wmGizmo *mpr, const float line_width) +void WM_gizmo_set_line_width(wmGizmo *gz, const float line_width) { - mpr->line_width = line_width; + gz->line_width = line_width; } /** @@ -363,22 +363,22 @@ void WM_gizmo_set_line_width(wmGizmo *mpr, const float line_width) * \param col Normal state color. * \param col_hi Highlighted state color. */ -void WM_gizmo_get_color(const wmGizmo *mpr, float color[4]) +void WM_gizmo_get_color(const wmGizmo *gz, float color[4]) { - copy_v4_v4(color, mpr->color); + copy_v4_v4(color, gz->color); } -void WM_gizmo_set_color(wmGizmo *mpr, const float color[4]) +void WM_gizmo_set_color(wmGizmo *gz, const float color[4]) { - copy_v4_v4(mpr->color, color); + copy_v4_v4(gz->color, color); } -void WM_gizmo_get_color_highlight(const wmGizmo *mpr, float color_hi[4]) +void WM_gizmo_get_color_highlight(const wmGizmo *gz, float color_hi[4]) { - copy_v4_v4(color_hi, mpr->color_hi); + copy_v4_v4(color_hi, gz->color_hi); } -void WM_gizmo_set_color_highlight(wmGizmo *mpr, const float color_hi[4]) +void WM_gizmo_set_color_highlight(wmGizmo *gz, const float color_hi[4]) { - copy_v4_v4(mpr->color_hi, color_hi); + copy_v4_v4(gz->color_hi, color_hi); } @@ -390,9 +390,9 @@ void WM_gizmo_set_color_highlight(wmGizmo *mpr, const float color_hi[4]) * * \{ */ -void WM_gizmo_set_fn_custom_modal(struct wmGizmo *mpr, wmGizmoFnModal fn) +void WM_gizmo_set_fn_custom_modal(struct wmGizmo *gz, wmGizmoFnModal fn) { - mpr->custom_modal = fn; + gz->custom_modal = fn; } /** \} */ @@ -407,26 +407,26 @@ void WM_gizmo_set_fn_custom_modal(struct wmGizmo *mpr, wmGizmoFnModal fn) * \return if the selection has changed. */ bool wm_gizmo_select_set_ex( - wmGizmoMap *mmap, wmGizmo *mpr, bool select, + wmGizmoMap *gzmap, wmGizmo *gz, bool select, bool use_array, bool use_callback) { bool changed = false; if (select) { - if ((mpr->state & WM_GIZMO_STATE_SELECT) == 0) { + if ((gz->state & WM_GIZMO_STATE_SELECT) == 0) { if (use_array) { - wm_gizmomap_select_array_push_back(mmap, mpr); + wm_gizmomap_select_array_push_back(gzmap, gz); } - mpr->state |= WM_GIZMO_STATE_SELECT; + gz->state |= WM_GIZMO_STATE_SELECT; changed = true; } } else { - if (mpr->state & WM_GIZMO_STATE_SELECT) { + if (gz->state & WM_GIZMO_STATE_SELECT) { if (use_array) { - wm_gizmomap_select_array_remove(mmap, mpr); + wm_gizmomap_select_array_remove(gzmap, gz); } - mpr->state &= ~WM_GIZMO_STATE_SELECT; + gz->state &= ~WM_GIZMO_STATE_SELECT; changed = true; } } @@ -434,8 +434,8 @@ bool wm_gizmo_select_set_ex( /* In the case of unlinking we only want to remove from the array * and not write to the external state */ if (use_callback && changed) { - if (mpr->type->select_refresh) { - mpr->type->select_refresh(mpr); + if (gz->type->select_refresh) { + gz->type->select_refresh(gz); } } @@ -443,25 +443,25 @@ bool wm_gizmo_select_set_ex( } /* Remove from selection array without running callbacks. */ -bool WM_gizmo_select_unlink(wmGizmoMap *mmap, wmGizmo *mpr) +bool WM_gizmo_select_unlink(wmGizmoMap *gzmap, wmGizmo *gz) { - return wm_gizmo_select_set_ex(mmap, mpr, false, true, false); + return wm_gizmo_select_set_ex(gzmap, gz, false, true, false); } -bool WM_gizmo_select_set(wmGizmoMap *mmap, wmGizmo *mpr, bool select) +bool WM_gizmo_select_set(wmGizmoMap *gzmap, wmGizmo *gz, bool select) { - return wm_gizmo_select_set_ex(mmap, mpr, select, true, true); + return wm_gizmo_select_set_ex(gzmap, gz, select, true, true); } -void WM_gizmo_highlight_set(wmGizmoMap *mmap, wmGizmo *mpr) +void WM_gizmo_highlight_set(wmGizmoMap *gzmap, wmGizmo *gz) { - wm_gizmomap_highlight_set(mmap, NULL, mpr, mpr ? mpr->highlight_part : 0); + wm_gizmomap_highlight_set(gzmap, NULL, gz, gz ? gz->highlight_part : 0); } -bool wm_gizmo_select_and_highlight(bContext *C, wmGizmoMap *mmap, wmGizmo *mpr) +bool wm_gizmo_select_and_highlight(bContext *C, wmGizmoMap *gzmap, wmGizmo *gz) { - if (WM_gizmo_select_set(mmap, mpr, true)) { - wm_gizmomap_highlight_set(mmap, C, mpr, mpr->highlight_part); + if (WM_gizmo_select_set(gzmap, gz, true)) { + wm_gizmomap_highlight_set(gzmap, C, gz, gz->highlight_part); return true; } else { @@ -475,13 +475,13 @@ bool wm_gizmo_select_and_highlight(bContext *C, wmGizmoMap *mmap, wmGizmo *mpr) * We could do this when linking them, but this complicates things since the window update code needs to run first. */ void WM_gizmo_modal_set_from_setup( - struct wmGizmoMap *mmap, struct bContext *C, - struct wmGizmo *mpr, int part_index, const wmEvent *event) + struct wmGizmoMap *gzmap, struct bContext *C, + struct wmGizmo *gz, int part_index, const wmEvent *event) { - mpr->highlight_part = part_index; - WM_gizmo_highlight_set(mmap, mpr); + gz->highlight_part = part_index; + WM_gizmo_highlight_set(gzmap, gz); if (false) { - wm_gizmomap_modal_set(mmap, C, mpr, event, true); + wm_gizmomap_modal_set(gzmap, C, gz, event, true); } else { /* WEAK: but it works. */ @@ -489,23 +489,23 @@ void WM_gizmo_modal_set_from_setup( } } -void wm_gizmo_calculate_scale(wmGizmo *mpr, const bContext *C) +void wm_gizmo_calculate_scale(wmGizmo *gz, const bContext *C) { const RegionView3D *rv3d = CTX_wm_region_view3d(C); float scale = UI_DPI_FAC; - if ((mpr->parent_mgroup->type->flag & WM_GIZMOGROUPTYPE_SCALE) == 0) { + if ((gz->parent_gzgroup->type->flag & WM_GIZMOGROUPTYPE_SCALE) == 0) { scale *= U.gizmo_size; if (rv3d) { /* 'ED_view3d_pixel_size' includes 'U.pixelsize', remove it. */ float matrix_world[4][4]; - if (mpr->type->matrix_basis_get) { + if (gz->type->matrix_basis_get) { float matrix_basis[4][4]; - mpr->type->matrix_basis_get(mpr, matrix_basis); - mul_m4_m4m4(matrix_world, mpr->matrix_space, matrix_basis); + gz->type->matrix_basis_get(gz, matrix_basis); + mul_m4_m4m4(matrix_world, gz->matrix_space, matrix_basis); } else { - mul_m4_m4m4(matrix_world, mpr->matrix_space, mpr->matrix_basis); + mul_m4_m4m4(matrix_world, gz->matrix_space, gz->matrix_basis); } /* Exclude matrix_offset from scale. */ @@ -516,45 +516,45 @@ void wm_gizmo_calculate_scale(wmGizmo *mpr, const bContext *C) } } - mpr->scale_final = mpr->scale_basis * scale; + gz->scale_final = gz->scale_basis * scale; } -static void gizmo_update_prop_data(wmGizmo *mpr) +static void gizmo_update_prop_data(wmGizmo *gz) { /* gizmo property might have been changed, so update gizmo */ - if (mpr->type->property_update) { - wmGizmoProperty *mpr_prop_array = WM_gizmo_target_property_array(mpr); - for (int i = 0; i < mpr->type->target_property_defs_len; i++) { - wmGizmoProperty *mpr_prop = &mpr_prop_array[i]; - if (WM_gizmo_target_property_is_valid(mpr_prop)) { - mpr->type->property_update(mpr, mpr_prop); + if (gz->type->property_update) { + wmGizmoProperty *gz_prop_array = WM_gizmo_target_property_array(gz); + for (int i = 0; i < gz->type->target_property_defs_len; i++) { + wmGizmoProperty *gz_prop = &gz_prop_array[i]; + if (WM_gizmo_target_property_is_valid(gz_prop)) { + gz->type->property_update(gz, gz_prop); } } } } -void wm_gizmo_update(wmGizmo *mpr, const bContext *C, const bool refresh_map) +void wm_gizmo_update(wmGizmo *gz, const bContext *C, const bool refresh_map) { if (refresh_map) { - gizmo_update_prop_data(mpr); + gizmo_update_prop_data(gz); } - wm_gizmo_calculate_scale(mpr, C); + wm_gizmo_calculate_scale(gz, C); } -int wm_gizmo_is_visible(wmGizmo *mpr) +int wm_gizmo_is_visible(wmGizmo *gz) { - if (mpr->flag & WM_GIZMO_HIDDEN) { + if (gz->flag & WM_GIZMO_HIDDEN) { return 0; } - if ((mpr->state & WM_GIZMO_STATE_MODAL) && - !(mpr->flag & (WM_GIZMO_DRAW_MODAL | WM_GIZMO_DRAW_VALUE))) + if ((gz->state & WM_GIZMO_STATE_MODAL) && + !(gz->flag & (WM_GIZMO_DRAW_MODAL | WM_GIZMO_DRAW_VALUE))) { /* don't draw while modal (dragging) */ return 0; } - if ((mpr->flag & WM_GIZMO_DRAW_HOVER) && - !(mpr->state & WM_GIZMO_STATE_HIGHLIGHT) && - !(mpr->state & WM_GIZMO_STATE_SELECT)) /* still draw selected gizmos */ + if ((gz->flag & WM_GIZMO_DRAW_HOVER) && + !(gz->state & WM_GIZMO_STATE_HIGHLIGHT) && + !(gz->state & WM_GIZMO_STATE_SELECT)) /* still draw selected gizmos */ { /* update but don't draw */ return WM_GIZMO_IS_VISIBLE_UPDATE; @@ -564,28 +564,28 @@ int wm_gizmo_is_visible(wmGizmo *mpr) } void WM_gizmo_calc_matrix_final_params( - const wmGizmo *mpr, + const wmGizmo *gz, const struct WM_GizmoMatrixParams *params, float r_mat[4][4]) { - const float (* const matrix_space)[4] = params->matrix_space ? params->matrix_space : mpr->matrix_space; - const float (* const matrix_basis)[4] = params->matrix_basis ? params->matrix_basis : mpr->matrix_basis; - const float (* const matrix_offset)[4] = params->matrix_offset ? params->matrix_offset : mpr->matrix_offset; - const float *scale_final = params->scale_final ? params->scale_final : &mpr->scale_final; + const float (* const matrix_space)[4] = params->matrix_space ? params->matrix_space : gz->matrix_space; + const float (* const matrix_basis)[4] = params->matrix_basis ? params->matrix_basis : gz->matrix_basis; + const float (* const matrix_offset)[4] = params->matrix_offset ? params->matrix_offset : gz->matrix_offset; + const float *scale_final = params->scale_final ? params->scale_final : &gz->scale_final; float final_matrix[4][4]; - if (params->matrix_basis == NULL && mpr->type->matrix_basis_get) { - mpr->type->matrix_basis_get(mpr, final_matrix); + if (params->matrix_basis == NULL && gz->type->matrix_basis_get) { + gz->type->matrix_basis_get(gz, final_matrix); } else { copy_m4_m4(final_matrix, matrix_basis); } - if (mpr->flag & WM_GIZMO_DRAW_NO_SCALE) { + if (gz->flag & WM_GIZMO_DRAW_NO_SCALE) { mul_m4_m4m4(final_matrix, final_matrix, matrix_offset); } else { - if (mpr->flag & WM_GIZMO_DRAW_OFFSET_SCALE) { + if (gz->flag & WM_GIZMO_DRAW_OFFSET_SCALE) { mul_mat3_m4_fl(final_matrix, *scale_final); mul_m4_m4m4(final_matrix, final_matrix, matrix_offset); } @@ -598,13 +598,13 @@ void WM_gizmo_calc_matrix_final_params( mul_m4_m4m4(r_mat, matrix_space, final_matrix); } -void WM_gizmo_calc_matrix_final_no_offset(const wmGizmo *mpr, float r_mat[4][4]) +void WM_gizmo_calc_matrix_final_no_offset(const wmGizmo *gz, float r_mat[4][4]) { float mat_identity[4][4]; unit_m4(mat_identity); WM_gizmo_calc_matrix_final_params( - mpr, + gz, &((struct WM_GizmoMatrixParams) { .matrix_space = NULL, .matrix_basis = NULL, @@ -614,10 +614,10 @@ void WM_gizmo_calc_matrix_final_no_offset(const wmGizmo *mpr, float r_mat[4][4]) ); } -void WM_gizmo_calc_matrix_final(const wmGizmo *mpr, float r_mat[4][4]) +void WM_gizmo_calc_matrix_final(const wmGizmo *gz, float r_mat[4][4]) { WM_gizmo_calc_matrix_final_params( - mpr, + gz, &((struct WM_GizmoMatrixParams) { .matrix_space = NULL, .matrix_basis = NULL, @@ -634,24 +634,24 @@ void WM_gizmo_calc_matrix_final(const wmGizmo *mpr, float r_mat[4][4]) * \{ */ -void WM_gizmo_properties_create_ptr(PointerRNA *ptr, wmGizmoType *wt) +void WM_gizmo_properties_create_ptr(PointerRNA *ptr, wmGizmoType *gzt) { - RNA_pointer_create(NULL, wt->srna, NULL, ptr); + RNA_pointer_create(NULL, gzt->srna, NULL, ptr); } -void WM_gizmo_properties_create(PointerRNA *ptr, const char *wtstring) +void WM_gizmo_properties_create(PointerRNA *ptr, const char *gtstring) { - const wmGizmoType *wt = WM_gizmotype_find(wtstring, false); + const wmGizmoType *gzt = WM_gizmotype_find(gtstring, false); - if (wt) - WM_gizmo_properties_create_ptr(ptr, (wmGizmoType *)wt); + if (gzt) + WM_gizmo_properties_create_ptr(ptr, (wmGizmoType *)gzt); else RNA_pointer_create(NULL, &RNA_GizmoProperties, NULL, ptr); } /* similar to the function above except its uses ID properties * used for keymaps and macros */ -void WM_gizmo_properties_alloc(PointerRNA **ptr, IDProperty **properties, const char *wtstring) +void WM_gizmo_properties_alloc(PointerRNA **ptr, IDProperty **properties, const char *gtstring) { if (*properties == NULL) { IDPropertyTemplate val = {0}; @@ -660,7 +660,7 @@ void WM_gizmo_properties_alloc(PointerRNA **ptr, IDProperty **properties, const if (*ptr == NULL) { *ptr = MEM_callocN(sizeof(PointerRNA), "wmOpItemPtr"); - WM_gizmo_properties_create(*ptr, wtstring); + WM_gizmo_properties_create(*ptr, gtstring); } (*ptr)->data = *properties; @@ -733,19 +733,19 @@ bool WM_gizmo_properties_default(PointerRNA *ptr, const bool do_update) } /* remove all props without PROP_SKIP_SAVE */ -void WM_gizmo_properties_reset(wmGizmo *mpr) +void WM_gizmo_properties_reset(wmGizmo *gz) { - if (mpr->ptr->data) { + if (gz->ptr->data) { PropertyRNA *iterprop; - iterprop = RNA_struct_iterator_property(mpr->type->srna); + iterprop = RNA_struct_iterator_property(gz->type->srna); - RNA_PROP_BEGIN (mpr->ptr, itemptr, iterprop) + RNA_PROP_BEGIN (gz->ptr, itemptr, iterprop) { PropertyRNA *prop = itemptr.data; if ((RNA_property_flag(prop) & PROP_SKIP_SAVE) == 0) { const char *identifier = RNA_property_identifier(prop); - RNA_struct_idprops_unset(mpr->ptr, identifier); + RNA_struct_idprops_unset(gz->ptr, identifier); } } RNA_PROP_END; diff --git a/source/blender/windowmanager/gizmo/intern/wm_gizmo_group.c b/source/blender/windowmanager/gizmo/intern/wm_gizmo_group.c index f30744859aa..3ba9fa71601 100644 --- a/source/blender/windowmanager/gizmo/intern/wm_gizmo_group.c +++ b/source/blender/windowmanager/gizmo/intern/wm_gizmo_group.c @@ -74,87 +74,87 @@ * \{ */ /** - * Create a new gizmo-group from \a wgt. + * Create a new gizmo-group from \a gzgt. */ wmGizmoGroup *wm_gizmogroup_new_from_type( - wmGizmoMap *mmap, wmGizmoGroupType *wgt) + wmGizmoMap *gzmap, wmGizmoGroupType *gzgt) { - wmGizmoGroup *mgroup = MEM_callocN(sizeof(*mgroup), "gizmo-group"); - mgroup->type = wgt; + wmGizmoGroup *gzgroup = MEM_callocN(sizeof(*gzgroup), "gizmo-group"); + gzgroup->type = gzgt; /* keep back-link */ - mgroup->parent_mmap = mmap; + gzgroup->parent_gzmap = gzmap; - BLI_addtail(&mmap->groups, mgroup); + BLI_addtail(&gzmap->groups, gzgroup); - return mgroup; + return gzgroup; } -void wm_gizmogroup_free(bContext *C, wmGizmoGroup *mgroup) +void wm_gizmogroup_free(bContext *C, wmGizmoGroup *gzgroup) { - wmGizmoMap *mmap = mgroup->parent_mmap; + wmGizmoMap *gzmap = gzgroup->parent_gzmap; - /* Similar to WM_gizmo_unlink, but only to keep mmap state correct, + /* Similar to WM_gizmo_unlink, but only to keep gzmap state correct, * we don't want to run callbacks. */ - if (mmap->mmap_context.highlight && mmap->mmap_context.highlight->parent_mgroup == mgroup) { - wm_gizmomap_highlight_set(mmap, C, NULL, 0); + if (gzmap->gzmap_context.highlight && gzmap->gzmap_context.highlight->parent_gzgroup == gzgroup) { + wm_gizmomap_highlight_set(gzmap, C, NULL, 0); } - if (mmap->mmap_context.modal && mmap->mmap_context.modal->parent_mgroup == mgroup) { - wm_gizmomap_modal_set(mmap, C, mmap->mmap_context.modal, NULL, false); + if (gzmap->gzmap_context.modal && gzmap->gzmap_context.modal->parent_gzgroup == gzgroup) { + wm_gizmomap_modal_set(gzmap, C, gzmap->gzmap_context.modal, NULL, false); } - for (wmGizmo *mpr = mgroup->gizmos.first, *mpr_next; mpr; mpr = mpr_next) { - mpr_next = mpr->next; - if (mmap->mmap_context.select.len) { - WM_gizmo_select_unlink(mmap, mpr); + for (wmGizmo *gz = gzgroup->gizmos.first, *gz_next; gz; gz = gz_next) { + gz_next = gz->next; + if (gzmap->gzmap_context.select.len) { + WM_gizmo_select_unlink(gzmap, gz); } - WM_gizmo_free(mpr); + WM_gizmo_free(gz); } - BLI_listbase_clear(&mgroup->gizmos); + BLI_listbase_clear(&gzgroup->gizmos); #ifdef WITH_PYTHON - if (mgroup->py_instance) { + if (gzgroup->py_instance) { /* do this first in case there are any __del__ functions or * similar that use properties */ - BPY_DECREF_RNA_INVALIDATE(mgroup->py_instance); + BPY_DECREF_RNA_INVALIDATE(gzgroup->py_instance); } #endif - if (mgroup->reports && (mgroup->reports->flag & RPT_FREE)) { - BKE_reports_clear(mgroup->reports); - MEM_freeN(mgroup->reports); + if (gzgroup->reports && (gzgroup->reports->flag & RPT_FREE)) { + BKE_reports_clear(gzgroup->reports); + MEM_freeN(gzgroup->reports); } - if (mgroup->customdata_free) { - mgroup->customdata_free(mgroup->customdata); + if (gzgroup->customdata_free) { + gzgroup->customdata_free(gzgroup->customdata); } else { - MEM_SAFE_FREE(mgroup->customdata); + MEM_SAFE_FREE(gzgroup->customdata); } - BLI_remlink(&mmap->groups, mgroup); + BLI_remlink(&gzmap->groups, gzgroup); - MEM_freeN(mgroup); + MEM_freeN(gzgroup); } /** - * Add \a gizmo to \a mgroup and make sure its name is unique within the group. + * Add \a gizmo to \a gzgroup and make sure its name is unique within the group. */ -void wm_gizmogroup_gizmo_register(wmGizmoGroup *mgroup, wmGizmo *mpr) +void wm_gizmogroup_gizmo_register(wmGizmoGroup *gzgroup, wmGizmo *gz) { - BLI_assert(BLI_findindex(&mgroup->gizmos, mpr) == -1); - BLI_addtail(&mgroup->gizmos, mpr); - mpr->parent_mgroup = mgroup; + BLI_assert(BLI_findindex(&gzgroup->gizmos, gz) == -1); + BLI_addtail(&gzgroup->gizmos, gz); + gz->parent_gzgroup = gzgroup; } wmGizmo *wm_gizmogroup_find_intersected_gizmo( - const wmGizmoGroup *mgroup, bContext *C, const wmEvent *event, + const wmGizmoGroup *gzgroup, bContext *C, const wmEvent *event, int *r_part) { - for (wmGizmo *mpr = mgroup->gizmos.first; mpr; mpr = mpr->next) { - if (mpr->type->test_select && (mpr->flag & WM_GIZMO_HIDDEN) == 0) { - if ((*r_part = mpr->type->test_select(C, mpr, event)) != -1) { - return mpr; + for (wmGizmo *gz = gzgroup->gizmos.first; gz; gz = gz->next) { + if (gz->type->test_select && (gz->flag & WM_GIZMO_HIDDEN) == 0) { + if ((*r_part = gz->type->test_select(C, gz, event->mval)) != -1) { + return gz; } } } @@ -163,78 +163,78 @@ wmGizmo *wm_gizmogroup_find_intersected_gizmo( } /** - * Adds all gizmos of \a mgroup that can be selected to the head of \a listbase. Added items need freeing! + * Adds all gizmos of \a gzgroup that can be selected to the head of \a listbase. Added items need freeing! */ -void wm_gizmogroup_intersectable_gizmos_to_list(const wmGizmoGroup *mgroup, ListBase *listbase) +void wm_gizmogroup_intersectable_gizmos_to_list(const wmGizmoGroup *gzgroup, ListBase *listbase) { - for (wmGizmo *mpr = mgroup->gizmos.first; mpr; mpr = mpr->next) { - if ((mpr->flag & WM_GIZMO_HIDDEN) == 0) { - if (((mgroup->type->flag & WM_GIZMOGROUPTYPE_3D) && mpr->type->draw_select) || - ((mgroup->type->flag & WM_GIZMOGROUPTYPE_3D) == 0 && mpr->type->test_select)) + for (wmGizmo *gz = gzgroup->gizmos.first; gz; gz = gz->next) { + if ((gz->flag & WM_GIZMO_HIDDEN) == 0) { + if (((gzgroup->type->flag & WM_GIZMOGROUPTYPE_3D) && (gz->type->draw_select || gz->type->test_select)) || + ((gzgroup->type->flag & WM_GIZMOGROUPTYPE_3D) == 0 && gz->type->test_select)) { - BLI_addhead(listbase, BLI_genericNodeN(mpr)); + BLI_addhead(listbase, BLI_genericNodeN(gz)); } } } } -void wm_gizmogroup_ensure_initialized(wmGizmoGroup *mgroup, const bContext *C) +void wm_gizmogroup_ensure_initialized(wmGizmoGroup *gzgroup, const bContext *C) { /* prepare for first draw */ - if (UNLIKELY((mgroup->init_flag & WM_GIZMOGROUP_INIT_SETUP) == 0)) { - mgroup->type->setup(C, mgroup); + if (UNLIKELY((gzgroup->init_flag & WM_GIZMOGROUP_INIT_SETUP) == 0)) { + gzgroup->type->setup(C, gzgroup); /* Not ideal, initialize keymap here, needed for RNA runtime generated gizmos. */ - wmGizmoGroupType *wgt = mgroup->type; - if (wgt->keymap == NULL) { + wmGizmoGroupType *gzgt = gzgroup->type; + if (gzgt->keymap == NULL) { wmWindowManager *wm = CTX_wm_manager(C); - wm_gizmogrouptype_setup_keymap(wgt, wm->defaultconf); - BLI_assert(wgt->keymap != NULL); + wm_gizmogrouptype_setup_keymap(gzgt, wm->defaultconf); + BLI_assert(gzgt->keymap != NULL); } - mgroup->init_flag |= WM_GIZMOGROUP_INIT_SETUP; + gzgroup->init_flag |= WM_GIZMOGROUP_INIT_SETUP; } /* refresh may be called multiple times, this just ensures its called at least once before we draw. */ - if (UNLIKELY((mgroup->init_flag & WM_GIZMOGROUP_INIT_REFRESH) == 0)) { - if (mgroup->type->refresh) { - mgroup->type->refresh(C, mgroup); + if (UNLIKELY((gzgroup->init_flag & WM_GIZMOGROUP_INIT_REFRESH) == 0)) { + if (gzgroup->type->refresh) { + gzgroup->type->refresh(C, gzgroup); } - mgroup->init_flag |= WM_GIZMOGROUP_INIT_REFRESH; + gzgroup->init_flag |= WM_GIZMOGROUP_INIT_REFRESH; } } -bool WM_gizmo_group_type_poll(const bContext *C, const struct wmGizmoGroupType *wgt) +bool WM_gizmo_group_type_poll(const bContext *C, const struct wmGizmoGroupType *gzgt) { /* If we're tagged, only use compatible. */ - if (wgt->owner_id[0] != '\0') { + if (gzgt->owner_id[0] != '\0') { const WorkSpace *workspace = CTX_wm_workspace(C); - if (BKE_workspace_owner_id_check(workspace, wgt->owner_id) == false) { + if (BKE_workspace_owner_id_check(workspace, gzgt->owner_id) == false) { return false; } } /* Check for poll function, if gizmo-group belongs to an operator, also check if the operator is running. */ - return (!wgt->poll || wgt->poll(C, (wmGizmoGroupType *)wgt)); + return (!gzgt->poll || gzgt->poll(C, (wmGizmoGroupType *)gzgt)); } bool wm_gizmogroup_is_visible_in_drawstep( - const wmGizmoGroup *mgroup, const eWM_GizmoFlagMapDrawStep drawstep) + const wmGizmoGroup *gzgroup, const eWM_GizmoFlagMapDrawStep drawstep) { switch (drawstep) { case WM_GIZMOMAP_DRAWSTEP_2D: - return (mgroup->type->flag & WM_GIZMOGROUPTYPE_3D) == 0; + return (gzgroup->type->flag & WM_GIZMOGROUPTYPE_3D) == 0; case WM_GIZMOMAP_DRAWSTEP_3D: - return (mgroup->type->flag & WM_GIZMOGROUPTYPE_3D); + return (gzgroup->type->flag & WM_GIZMOGROUPTYPE_3D); default: BLI_assert(0); return false; } } -bool wm_gizmogroup_is_any_selected(const wmGizmoGroup *mgroup) +bool wm_gizmogroup_is_any_selected(const wmGizmoGroup *gzgroup) { - if (mgroup->type->flag & WM_GIZMOGROUPTYPE_SELECT) { - for (const wmGizmo *mpr = mgroup->gizmos.first; mpr; mpr = mpr->next) { - if (mpr->state & WM_GIZMO_STATE_SELECT) { + if (gzgroup->type->flag & WM_GIZMOGROUPTYPE_SELECT) { + for (const wmGizmo *gz = gzgroup->gizmos.first; gz; gz = gz->next) { + if (gz->state & WM_GIZMO_STATE_SELECT) { return true; } } @@ -253,9 +253,9 @@ bool wm_gizmogroup_is_any_selected(const wmGizmoGroup *mgroup) static int gizmo_select_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event)) { ARegion *ar = CTX_wm_region(C); - wmGizmoMap *mmap = ar->gizmo_map; - wmGizmoMapSelectState *msel = &mmap->mmap_context.select; - wmGizmo *highlight = mmap->mmap_context.highlight; + wmGizmoMap *gzmap = ar->gizmo_map; + wmGizmoMapSelectState *msel = &gzmap->gzmap_context.select; + wmGizmo *highlight = gzmap->gzmap_context.highlight; bool extend = RNA_boolean_get(op->ptr, "extend"); bool deselect = RNA_boolean_get(op->ptr, "deselect"); @@ -263,7 +263,7 @@ static int gizmo_select_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSE /* deselect all first */ if (extend == false && deselect == false && toggle == false) { - wm_gizmomap_deselect_all(mmap); + wm_gizmomap_deselect_all(gzmap); BLI_assert(msel->items == NULL && msel->len == 0); UNUSED_VARS_NDEBUG(msel); } @@ -278,11 +278,11 @@ static int gizmo_select_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSE } if (deselect) { - if (is_selected && WM_gizmo_select_set(mmap, highlight, false)) { + if (is_selected && WM_gizmo_select_set(gzmap, highlight, false)) { redraw = true; } } - else if (wm_gizmo_select_and_highlight(C, mmap, highlight)) { + else if (wm_gizmo_select_and_highlight(C, gzmap, highlight)) { redraw = true; } @@ -296,8 +296,6 @@ static int gizmo_select_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSE BLI_assert(0); return (OPERATOR_CANCELLED | OPERATOR_PASS_THROUGH); } - - return OPERATOR_PASS_THROUGH; } void GIZMOGROUP_OT_gizmo_select(wmOperatorType *ot) @@ -316,9 +314,9 @@ void GIZMOGROUP_OT_gizmo_select(wmOperatorType *ot) } typedef struct GizmoTweakData { - wmGizmoMap *mmap; - wmGizmoGroup *mgroup; - wmGizmo *mpr_modal; + wmGizmoMap *gzmap; + wmGizmoGroup *gzgroup; + wmGizmo *gz_modal; int init_event; /* initial event type */ int flag; /* tweak flags */ @@ -342,18 +340,18 @@ typedef struct GizmoTweakData { } GizmoTweakData; static bool gizmo_tweak_start( - bContext *C, wmGizmoMap *mmap, wmGizmo *mpr, const wmEvent *event) + bContext *C, wmGizmoMap *gzmap, wmGizmo *gz, const wmEvent *event) { /* activate highlighted gizmo */ - wm_gizmomap_modal_set(mmap, C, mpr, event, true); + wm_gizmomap_modal_set(gzmap, C, gz, event, true); - return (mpr->state & WM_GIZMO_STATE_MODAL); + return (gz->state & WM_GIZMO_STATE_MODAL); } static bool gizmo_tweak_start_and_finish( - bContext *C, wmGizmoMap *mmap, wmGizmo *mpr, const wmEvent *event, bool *r_is_modal) + bContext *C, wmGizmoMap *gzmap, wmGizmo *gz, const wmEvent *event, bool *r_is_modal) { - wmGizmoOpElem *mpop = WM_gizmo_operator_get(mpr, mpr->highlight_part); + wmGizmoOpElem *mpop = WM_gizmo_operator_get(gz, gz->highlight_part); if (r_is_modal) { *r_is_modal = false; } @@ -377,7 +375,7 @@ static bool gizmo_tweak_start_and_finish( * conflicting with modal operator attached to gizmo */ if (mpop->type->modal) { /* activate highlighted gizmo */ - wm_gizmomap_modal_set(mmap, C, mpr, event, true); + wm_gizmomap_modal_set(gzmap, C, gz, event, true); if (r_is_modal) { *r_is_modal = true; } @@ -396,15 +394,15 @@ static bool gizmo_tweak_start_and_finish( static void gizmo_tweak_finish(bContext *C, wmOperator *op, const bool cancel, bool clear_modal) { GizmoTweakData *mtweak = op->customdata; - if (mtweak->mpr_modal->type->exit) { - mtweak->mpr_modal->type->exit(C, mtweak->mpr_modal, cancel); + if (mtweak->gz_modal->type->exit) { + mtweak->gz_modal->type->exit(C, mtweak->gz_modal, cancel); } if (clear_modal) { /* The gizmo may have been removed. */ - if ((BLI_findindex(&mtweak->mmap->groups, mtweak->mgroup) != -1) && - (BLI_findindex(&mtweak->mgroup->gizmos, mtweak->mpr_modal) != -1)) + if ((BLI_findindex(&mtweak->gzmap->groups, mtweak->gzgroup) != -1) && + (BLI_findindex(&mtweak->gzgroup->gizmos, mtweak->gz_modal) != -1)) { - wm_gizmomap_modal_set(mtweak->mmap, C, mtweak->mpr_modal, NULL, false); + wm_gizmomap_modal_set(mtweak->gzmap, C, mtweak->gz_modal, NULL, false); } } MEM_freeN(mtweak); @@ -413,22 +411,22 @@ static void gizmo_tweak_finish(bContext *C, wmOperator *op, const bool cancel, b static int gizmo_tweak_modal(bContext *C, wmOperator *op, const wmEvent *event) { GizmoTweakData *mtweak = op->customdata; - wmGizmo *mpr = mtweak->mpr_modal; + wmGizmo *gz = mtweak->gz_modal; int retval = OPERATOR_PASS_THROUGH; bool clear_modal = true; - if (mpr == NULL) { + if (gz == NULL) { BLI_assert(0); return (OPERATOR_CANCELLED | OPERATOR_PASS_THROUGH); } #ifdef USE_DRAG_DETECT - wmGizmoMap *mmap = mtweak->mmap; + wmGizmoMap *gzmap = mtweak->gzmap; if (mtweak->drag_state == DRAG_DETECT) { if (ELEM(event->type, MOUSEMOVE, INBETWEEN_MOUSEMOVE)) { - if (len_manhattan_v2v2_int(&event->x, mmap->mmap_context.event_xy) > 2) { + if (len_manhattan_v2v2_int(&event->x, gzmap->gzmap_context.event_xy) > 2) { mtweak->drag_state = DRAG_IDLE; - mpr->highlight_part = mpr->drag_part; + gz->highlight_part = gz->drag_part; } } else if (event->type == mtweak->init_event && event->val == KM_RELEASE) { @@ -439,20 +437,20 @@ static int gizmo_tweak_modal(bContext *C, wmOperator *op, const wmEvent *event) if (mtweak->drag_state != DRAG_DETECT) { /* Follow logic in 'gizmo_tweak_invoke' */ bool is_modal = false; - if (gizmo_tweak_start_and_finish(C, mmap, mpr, event, &is_modal)) { + if (gizmo_tweak_start_and_finish(C, gzmap, gz, event, &is_modal)) { if (is_modal) { clear_modal = false; } } else { - if (!gizmo_tweak_start(C, mmap, mpr, event)) { + if (!gizmo_tweak_start(C, gzmap, gz, event)) { retval = OPERATOR_FINISHED; } } } } if (mtweak->drag_state == DRAG_IDLE) { - if (mmap->mmap_context.modal != NULL) { + if (gzmap->gzmap_context.modal != NULL) { return OPERATOR_PASS_THROUGH; } else { @@ -498,9 +496,9 @@ static int gizmo_tweak_modal(bContext *C, wmOperator *op, const wmEvent *event) } /* handle gizmo */ - wmGizmoFnModal modal_fn = mpr->custom_modal ? mpr->custom_modal : mpr->type->modal; + wmGizmoFnModal modal_fn = gz->custom_modal ? gz->custom_modal : gz->type->modal; if (modal_fn) { - int modal_retval = modal_fn(C, mpr, event, mtweak->flag); + int modal_retval = modal_fn(C, gz, event, mtweak->flag); if ((modal_retval & OPERATOR_RUNNING_MODAL) == 0) { gizmo_tweak_finish(C, op, (modal_retval & OPERATOR_CANCELLED) != 0, true); @@ -520,13 +518,13 @@ static int gizmo_tweak_modal(bContext *C, wmOperator *op, const wmEvent *event) static int gizmo_tweak_invoke(bContext *C, wmOperator *op, const wmEvent *event) { ARegion *ar = CTX_wm_region(C); - wmGizmoMap *mmap = ar->gizmo_map; - wmGizmo *mpr = mmap->mmap_context.highlight; + wmGizmoMap *gzmap = ar->gizmo_map; + wmGizmo *gz = gzmap->gzmap_context.highlight; /* Needed for single click actions which don't enter modal state. */ WM_tooltip_clear(C, CTX_wm_window(C)); - if (!mpr) { + if (!gz) { /* wm_handlers_do_intern shouldn't let this happen */ BLI_assert(0); return (OPERATOR_CANCELLED | OPERATOR_PASS_THROUGH); @@ -535,11 +533,11 @@ static int gizmo_tweak_invoke(bContext *C, wmOperator *op, const wmEvent *event) bool use_drag_fallback = false; #ifdef USE_DRAG_DETECT - use_drag_fallback = !ELEM(mpr->drag_part, -1, mpr->highlight_part); + use_drag_fallback = !ELEM(gz->drag_part, -1, gz->highlight_part); #endif if (use_drag_fallback == false) { - if (gizmo_tweak_start_and_finish(C, mmap, mpr, event, NULL)) { + if (gizmo_tweak_start_and_finish(C, gzmap, gz, event, NULL)) { return OPERATOR_FINISHED; } } @@ -547,7 +545,7 @@ static int gizmo_tweak_invoke(bContext *C, wmOperator *op, const wmEvent *event) bool use_drag_detect = false; #ifdef USE_DRAG_DETECT if (use_drag_fallback) { - wmGizmoOpElem *mpop = WM_gizmo_operator_get(mpr, mpr->highlight_part); + wmGizmoOpElem *mpop = WM_gizmo_operator_get(gz, gz->highlight_part); if (mpop && mpop->type) { if (mpop->type->modal == NULL) { use_drag_detect = true; @@ -557,7 +555,7 @@ static int gizmo_tweak_invoke(bContext *C, wmOperator *op, const wmEvent *event) #endif if (use_drag_detect == false) { - if (!gizmo_tweak_start(C, mmap, mpr, event)) { + if (!gizmo_tweak_start(C, gzmap, gz, event)) { /* failed to start */ return OPERATOR_PASS_THROUGH; } @@ -566,9 +564,9 @@ static int gizmo_tweak_invoke(bContext *C, wmOperator *op, const wmEvent *event) GizmoTweakData *mtweak = MEM_mallocN(sizeof(GizmoTweakData), __func__); mtweak->init_event = WM_userdef_event_type_from_keymap_type(event->type); - mtweak->mpr_modal = mmap->mmap_context.highlight; - mtweak->mgroup = mtweak->mpr_modal->parent_mgroup; - mtweak->mmap = mmap; + mtweak->gz_modal = gzmap->gzmap_context.highlight; + mtweak->gzgroup = mtweak->gz_modal->parent_gzgroup; + mtweak->gzmap = gzmap; mtweak->flag = 0; #ifdef USE_DRAG_DETECT @@ -603,7 +601,7 @@ void GIZMOGROUP_OT_gizmo_tweak(wmOperatorType *ot) /** \} */ -static wmKeyMap *gizmogroup_tweak_modal_keymap(wmKeyConfig *keyconf, const char *mgroupname) +static wmKeyMap *gizmogroup_tweak_modal_keymap(wmKeyConfig *keyconf, const char *gzgroupname) { wmKeyMap *keymap; char name[KMAP_MAX_NAME]; @@ -619,7 +617,7 @@ static wmKeyMap *gizmogroup_tweak_modal_keymap(wmKeyConfig *keyconf, const char }; - BLI_snprintf(name, sizeof(name), "%s Tweak Modal Map", mgroupname); + BLI_snprintf(name, sizeof(name), "%s Tweak Modal Map", gzgroupname); keymap = WM_modalkeymap_get(keyconf, name); /* this function is called for each spacetype, only needs to add map once */ @@ -655,13 +653,13 @@ static wmKeyMap *gizmogroup_tweak_modal_keymap(wmKeyConfig *keyconf, const char * Common default keymap for gizmo groups */ wmKeyMap *WM_gizmogroup_keymap_common( - const wmGizmoGroupType *wgt, wmKeyConfig *config) + const wmGizmoGroupType *gzgt, wmKeyConfig *config) { /* Use area and region id since we might have multiple gizmos with the same name in different areas/regions */ - wmKeyMap *km = WM_keymap_find(config, wgt->name, wgt->mmap_params.spaceid, wgt->mmap_params.regionid); + wmKeyMap *km = WM_keymap_find(config, gzgt->name, gzgt->gzmap_params.spaceid, gzgt->gzmap_params.regionid); WM_keymap_add_item(km, "GIZMOGROUP_OT_gizmo_tweak", LEFTMOUSE, KM_PRESS, KM_ANY, 0); - gizmogroup_tweak_modal_keymap(config, wgt->name); + gizmogroup_tweak_modal_keymap(config, gzgt->name); return km; } @@ -670,14 +668,14 @@ wmKeyMap *WM_gizmogroup_keymap_common( * Variation of #WM_gizmogroup_keymap_common but with keymap items for selection */ wmKeyMap *WM_gizmogroup_keymap_common_select( - const wmGizmoGroupType *wgt, wmKeyConfig *config) + const wmGizmoGroupType *gzgt, wmKeyConfig *config) { /* Use area and region id since we might have multiple gizmos with the same name in different areas/regions */ - wmKeyMap *km = WM_keymap_find(config, wgt->name, wgt->mmap_params.spaceid, wgt->mmap_params.regionid); + wmKeyMap *km = WM_keymap_find(config, gzgt->name, gzgt->gzmap_params.spaceid, gzgt->gzmap_params.regionid); WM_keymap_add_item(km, "GIZMOGROUP_OT_gizmo_tweak", ACTIONMOUSE, KM_PRESS, KM_ANY, 0); WM_keymap_add_item(km, "GIZMOGROUP_OT_gizmo_tweak", EVT_TWEAK_S, KM_ANY, 0, 0); - gizmogroup_tweak_modal_keymap(config, wgt->name); + gizmogroup_tweak_modal_keymap(config, gzgt->name); wmKeyMapItem *kmi = WM_keymap_add_item(km, "GIZMOGROUP_OT_gizmo_select", SELECTMOUSE, KM_PRESS, 0, 0); RNA_boolean_set(kmi->ptr, "extend", false); @@ -699,32 +697,32 @@ wmKeyMap *WM_gizmogroup_keymap_common_select( * \{ */ struct wmGizmoGroupTypeRef *WM_gizmomaptype_group_find_ptr( - struct wmGizmoMapType *mmap_type, - const wmGizmoGroupType *wgt) + struct wmGizmoMapType *gzmap_type, + const wmGizmoGroupType *gzgt) { /* could use hash lookups as operator types do, for now simple search. */ - for (wmGizmoGroupTypeRef *wgt_ref = mmap_type->grouptype_refs.first; - wgt_ref; - wgt_ref = wgt_ref->next) + for (wmGizmoGroupTypeRef *gzgt_ref = gzmap_type->grouptype_refs.first; + gzgt_ref; + gzgt_ref = gzgt_ref->next) { - if (wgt_ref->type == wgt) { - return wgt_ref; + if (gzgt_ref->type == gzgt) { + return gzgt_ref; } } return NULL; } struct wmGizmoGroupTypeRef *WM_gizmomaptype_group_find( - struct wmGizmoMapType *mmap_type, + struct wmGizmoMapType *gzmap_type, const char *idname) { /* could use hash lookups as operator types do, for now simple search. */ - for (wmGizmoGroupTypeRef *wgt_ref = mmap_type->grouptype_refs.first; - wgt_ref; - wgt_ref = wgt_ref->next) + for (wmGizmoGroupTypeRef *gzgt_ref = gzmap_type->grouptype_refs.first; + gzgt_ref; + gzgt_ref = gzgt_ref->next) { - if (STREQ(idname, wgt_ref->type->idname)) { - return wgt_ref; + if (STREQ(idname, gzgt_ref->type->idname)) { + return gzgt_ref; } } return NULL; @@ -734,33 +732,33 @@ struct wmGizmoGroupTypeRef *WM_gizmomaptype_group_find( * Use this for registering gizmos on startup. For runtime, use #WM_gizmomaptype_group_link_runtime. */ wmGizmoGroupTypeRef *WM_gizmomaptype_group_link( - wmGizmoMapType *mmap_type, const char *idname) + wmGizmoMapType *gzmap_type, const char *idname) { - wmGizmoGroupType *wgt = WM_gizmogrouptype_find(idname, false); - BLI_assert(wgt != NULL); - return WM_gizmomaptype_group_link_ptr(mmap_type, wgt); + wmGizmoGroupType *gzgt = WM_gizmogrouptype_find(idname, false); + BLI_assert(gzgt != NULL); + return WM_gizmomaptype_group_link_ptr(gzmap_type, gzgt); } wmGizmoGroupTypeRef *WM_gizmomaptype_group_link_ptr( - wmGizmoMapType *mmap_type, wmGizmoGroupType *wgt) + wmGizmoMapType *gzmap_type, wmGizmoGroupType *gzgt) { - wmGizmoGroupTypeRef *wgt_ref = MEM_callocN(sizeof(wmGizmoGroupTypeRef), "gizmo-group-ref"); - wgt_ref->type = wgt; - BLI_addtail(&mmap_type->grouptype_refs, wgt_ref); - return wgt_ref; + wmGizmoGroupTypeRef *gzgt_ref = MEM_callocN(sizeof(wmGizmoGroupTypeRef), "gizmo-group-ref"); + gzgt_ref->type = gzgt; + BLI_addtail(&gzmap_type->grouptype_refs, gzgt_ref); + return gzgt_ref; } void WM_gizmomaptype_group_init_runtime_keymap( const Main *bmain, - wmGizmoGroupType *wgt) + wmGizmoGroupType *gzgt) { /* init keymap - on startup there's an extra call to init keymaps for 'permanent' gizmo-groups */ - wm_gizmogrouptype_setup_keymap(wgt, ((wmWindowManager *)bmain->wm.first)->defaultconf); + wm_gizmogrouptype_setup_keymap(gzgt, ((wmWindowManager *)bmain->wm.first)->defaultconf); } void WM_gizmomaptype_group_init_runtime( - const Main *bmain, wmGizmoMapType *mmap_type, - wmGizmoGroupType *wgt) + const Main *bmain, wmGizmoMapType *gzmap_type, + wmGizmoGroupType *gzgt) { /* now create a gizmo for all existing areas */ for (bScreen *sc = bmain->screen.first; sc; sc = sc->id.next) { @@ -768,12 +766,12 @@ void WM_gizmomaptype_group_init_runtime( for (SpaceLink *sl = sa->spacedata.first; sl; sl = sl->next) { ListBase *lb = (sl == sa->spacedata.first) ? &sa->regionbase : &sl->regionbase; for (ARegion *ar = lb->first; ar; ar = ar->next) { - wmGizmoMap *mmap = ar->gizmo_map; - if (mmap && mmap->type == mmap_type) { - wm_gizmogroup_new_from_type(mmap, wgt); + wmGizmoMap *gzmap = ar->gizmo_map; + if (gzmap && gzmap->type == gzmap_type) { + wm_gizmogroup_new_from_type(gzmap, gzgt); /* just add here, drawing will occur on next update */ - wm_gizmomap_highlight_set(mmap, NULL, NULL, 0); + wm_gizmomap_highlight_set(gzmap, NULL, NULL, 0); ED_region_tag_redraw(ar); } } @@ -786,14 +784,14 @@ void WM_gizmomaptype_group_init_runtime( /** * Unlike #WM_gizmomaptype_group_unlink this doesn't maintain correct state, simply free. */ -void WM_gizmomaptype_group_free(wmGizmoGroupTypeRef *wgt_ref) +void WM_gizmomaptype_group_free(wmGizmoGroupTypeRef *gzgt_ref) { - MEM_freeN(wgt_ref); + MEM_freeN(gzgt_ref); } void WM_gizmomaptype_group_unlink( - bContext *C, Main *bmain, wmGizmoMapType *mmap_type, - const wmGizmoGroupType *wgt) + bContext *C, Main *bmain, wmGizmoMapType *gzmap_type, + const wmGizmoGroupType *gzgt) { /* Free instances. */ for (bScreen *sc = bmain->screen.first; sc; sc = sc->id.next) { @@ -801,14 +799,14 @@ void WM_gizmomaptype_group_unlink( for (SpaceLink *sl = sa->spacedata.first; sl; sl = sl->next) { ListBase *lb = (sl == sa->spacedata.first) ? &sa->regionbase : &sl->regionbase; for (ARegion *ar = lb->first; ar; ar = ar->next) { - wmGizmoMap *mmap = ar->gizmo_map; - if (mmap && mmap->type == mmap_type) { - wmGizmoGroup *mgroup, *mgroup_next; - for (mgroup = mmap->groups.first; mgroup; mgroup = mgroup_next) { - mgroup_next = mgroup->next; - if (mgroup->type == wgt) { - BLI_assert(mgroup->parent_mmap == mmap); - wm_gizmogroup_free(C, mgroup); + wmGizmoMap *gzmap = ar->gizmo_map; + if (gzmap && gzmap->type == gzmap_type) { + wmGizmoGroup *gzgroup, *gzgroup_next; + for (gzgroup = gzmap->groups.first; gzgroup; gzgroup = gzgroup_next) { + gzgroup_next = gzgroup->next; + if (gzgroup->type == gzgt) { + BLI_assert(gzgroup->parent_gzmap == gzmap); + wm_gizmogroup_free(C, gzgroup); ED_region_tag_redraw(ar); } } @@ -819,27 +817,27 @@ void WM_gizmomaptype_group_unlink( } /* Free types. */ - wmGizmoGroupTypeRef *wgt_ref = WM_gizmomaptype_group_find_ptr(mmap_type, wgt); - if (wgt_ref) { - BLI_remlink(&mmap_type->grouptype_refs, wgt_ref); - WM_gizmomaptype_group_free(wgt_ref); + wmGizmoGroupTypeRef *gzgt_ref = WM_gizmomaptype_group_find_ptr(gzmap_type, gzgt); + if (gzgt_ref) { + BLI_remlink(&gzmap_type->grouptype_refs, gzgt_ref); + WM_gizmomaptype_group_free(gzgt_ref); } /* Note, we may want to keep this keymap for editing */ - WM_keymap_remove(wgt->keyconf, wgt->keymap); + WM_keymap_remove(gzgt->keyconf, gzgt->keymap); - BLI_assert(WM_gizmomaptype_group_find_ptr(mmap_type, wgt) == NULL); + BLI_assert(WM_gizmomaptype_group_find_ptr(gzmap_type, gzgt) == NULL); } void wm_gizmogrouptype_setup_keymap( - wmGizmoGroupType *wgt, wmKeyConfig *keyconf) + wmGizmoGroupType *gzgt, wmKeyConfig *keyconf) { /* Use flag since setup_keymap may return NULL, * in that case we better not keep calling it. */ - if (wgt->type_update_flag & WM_GIZMOMAPTYPE_KEYMAP_INIT) { - wgt->keymap = wgt->setup_keymap(wgt, keyconf); - wgt->keyconf = keyconf; - wgt->type_update_flag &= ~WM_GIZMOMAPTYPE_KEYMAP_INIT; + if (gzgt->type_update_flag & WM_GIZMOMAPTYPE_KEYMAP_INIT) { + gzgt->keymap = gzgt->setup_keymap(gzgt, keyconf); + gzgt->keyconf = keyconf; + gzgt->type_update_flag &= ~WM_GIZMOMAPTYPE_KEYMAP_INIT; } } @@ -861,89 +859,89 @@ void wm_gizmogrouptype_setup_keymap( * \{ */ void WM_gizmo_group_type_add_ptr_ex( - wmGizmoGroupType *wgt, - wmGizmoMapType *mmap_type) + wmGizmoGroupType *gzgt, + wmGizmoMapType *gzmap_type) { - WM_gizmomaptype_group_link_ptr(mmap_type, wgt); + WM_gizmomaptype_group_link_ptr(gzmap_type, gzgt); - WM_gizmoconfig_update_tag_init(mmap_type, wgt); + WM_gizmoconfig_update_tag_init(gzmap_type, gzgt); } void WM_gizmo_group_type_add_ptr( - wmGizmoGroupType *wgt) + wmGizmoGroupType *gzgt) { - wmGizmoMapType *mmap_type = WM_gizmomaptype_ensure(&wgt->mmap_params); - WM_gizmo_group_type_add_ptr_ex(wgt, mmap_type); + wmGizmoMapType *gzmap_type = WM_gizmomaptype_ensure(&gzgt->gzmap_params); + WM_gizmo_group_type_add_ptr_ex(gzgt, gzmap_type); } void WM_gizmo_group_type_add(const char *idname) { - wmGizmoGroupType *wgt = WM_gizmogrouptype_find(idname, false); - BLI_assert(wgt != NULL); - WM_gizmo_group_type_add_ptr(wgt); + wmGizmoGroupType *gzgt = WM_gizmogrouptype_find(idname, false); + BLI_assert(gzgt != NULL); + WM_gizmo_group_type_add_ptr(gzgt); } void WM_gizmo_group_type_ensure_ptr_ex( - wmGizmoGroupType *wgt, - wmGizmoMapType *mmap_type) + wmGizmoGroupType *gzgt, + wmGizmoMapType *gzmap_type) { - wmGizmoGroupTypeRef *wgt_ref = WM_gizmomaptype_group_find_ptr(mmap_type, wgt); - if (wgt_ref == NULL) { - WM_gizmo_group_type_add_ptr_ex(wgt, mmap_type); + wmGizmoGroupTypeRef *gzgt_ref = WM_gizmomaptype_group_find_ptr(gzmap_type, gzgt); + if (gzgt_ref == NULL) { + WM_gizmo_group_type_add_ptr_ex(gzgt, gzmap_type); } } void WM_gizmo_group_type_ensure_ptr( - wmGizmoGroupType *wgt) + wmGizmoGroupType *gzgt) { - wmGizmoMapType *mmap_type = WM_gizmomaptype_ensure(&wgt->mmap_params); - WM_gizmo_group_type_ensure_ptr_ex(wgt, mmap_type); + wmGizmoMapType *gzmap_type = WM_gizmomaptype_ensure(&gzgt->gzmap_params); + WM_gizmo_group_type_ensure_ptr_ex(gzgt, gzmap_type); } void WM_gizmo_group_type_ensure(const char *idname) { - wmGizmoGroupType *wgt = WM_gizmogrouptype_find(idname, false); - BLI_assert(wgt != NULL); - WM_gizmo_group_type_ensure_ptr(wgt); + wmGizmoGroupType *gzgt = WM_gizmogrouptype_find(idname, false); + BLI_assert(gzgt != NULL); + WM_gizmo_group_type_ensure_ptr(gzgt); } void WM_gizmo_group_type_remove_ptr_ex( - struct Main *bmain, wmGizmoGroupType *wgt, - wmGizmoMapType *mmap_type) + struct Main *bmain, wmGizmoGroupType *gzgt, + wmGizmoMapType *gzmap_type) { - WM_gizmomaptype_group_unlink(NULL, bmain, mmap_type, wgt); - WM_gizmogrouptype_free_ptr(wgt); + WM_gizmomaptype_group_unlink(NULL, bmain, gzmap_type, gzgt); + WM_gizmogrouptype_free_ptr(gzgt); } void WM_gizmo_group_type_remove_ptr( - struct Main *bmain, wmGizmoGroupType *wgt) + struct Main *bmain, wmGizmoGroupType *gzgt) { - wmGizmoMapType *mmap_type = WM_gizmomaptype_ensure(&wgt->mmap_params); - WM_gizmo_group_type_remove_ptr_ex(bmain, wgt, mmap_type); + wmGizmoMapType *gzmap_type = WM_gizmomaptype_ensure(&gzgt->gzmap_params); + WM_gizmo_group_type_remove_ptr_ex(bmain, gzgt, gzmap_type); } void WM_gizmo_group_type_remove(struct Main *bmain, const char *idname) { - wmGizmoGroupType *wgt = WM_gizmogrouptype_find(idname, false); - BLI_assert(wgt != NULL); - WM_gizmo_group_type_remove_ptr(bmain, wgt); + wmGizmoGroupType *gzgt = WM_gizmogrouptype_find(idname, false); + BLI_assert(gzgt != NULL); + WM_gizmo_group_type_remove_ptr(bmain, gzgt); } /* delayed versions */ void WM_gizmo_group_type_unlink_delayed_ptr_ex( - wmGizmoGroupType *wgt, - wmGizmoMapType *mmap_type) + wmGizmoGroupType *gzgt, + wmGizmoMapType *gzmap_type) { - WM_gizmoconfig_update_tag_remove(mmap_type, wgt); + WM_gizmoconfig_update_tag_remove(gzmap_type, gzgt); } void WM_gizmo_group_type_unlink_delayed_ptr( - wmGizmoGroupType *wgt) + wmGizmoGroupType *gzgt) { - wmGizmoMapType *mmap_type = WM_gizmomaptype_ensure(&wgt->mmap_params); - WM_gizmo_group_type_unlink_delayed_ptr_ex(wgt, mmap_type); + wmGizmoMapType *gzmap_type = WM_gizmomaptype_ensure(&gzgt->gzmap_params); + WM_gizmo_group_type_unlink_delayed_ptr_ex(gzgt, gzmap_type); } void WM_gizmo_group_type_unlink_delayed(const char *idname) { - wmGizmoGroupType *wgt = WM_gizmogrouptype_find(idname, false); - BLI_assert(wgt != NULL); - WM_gizmo_group_type_unlink_delayed_ptr(wgt); + wmGizmoGroupType *gzgt = WM_gizmogrouptype_find(idname, false); + BLI_assert(gzgt != NULL); + WM_gizmo_group_type_unlink_delayed_ptr(gzgt); } /** \} */ diff --git a/source/blender/windowmanager/gizmo/intern/wm_gizmo_group_type.c b/source/blender/windowmanager/gizmo/intern/wm_gizmo_group_type.c index 44f5fac4cd4..a44005a7d28 100644 --- a/source/blender/windowmanager/gizmo/intern/wm_gizmo_group_type.c +++ b/source/blender/windowmanager/gizmo/intern/wm_gizmo_group_type.c @@ -54,11 +54,11 @@ static GHash *global_gizmogrouptype_hash = NULL; wmGizmoGroupType *WM_gizmogrouptype_find(const char *idname, bool quiet) { if (idname[0]) { - wmGizmoGroupType *wgt; + wmGizmoGroupType *gzgt; - wgt = BLI_ghash_lookup(global_gizmogrouptype_hash, idname); - if (wgt) { - return wgt; + gzgt = BLI_ghash_lookup(global_gizmogrouptype_hash, idname); + if (gzgt) { + return gzgt; } if (!quiet) { @@ -82,46 +82,46 @@ void WM_gizmogrouptype_iter(GHashIterator *ghi) static wmGizmoGroupType *wm_gizmogrouptype_append__begin(void) { - wmGizmoGroupType *wgt = MEM_callocN(sizeof(wmGizmoGroupType), "gizmogrouptype"); + wmGizmoGroupType *gzgt = MEM_callocN(sizeof(wmGizmoGroupType), "gizmogrouptype"); - return wgt; + return gzgt; } -static void wm_gizmogrouptype_append__end(wmGizmoGroupType *wgt) +static void wm_gizmogrouptype_append__end(wmGizmoGroupType *gzgt) { - BLI_assert(wgt->name != NULL); - BLI_assert(wgt->idname != NULL); + BLI_assert(gzgt->name != NULL); + BLI_assert(gzgt->idname != NULL); - wgt->type_update_flag |= WM_GIZMOMAPTYPE_KEYMAP_INIT; + gzgt->type_update_flag |= WM_GIZMOMAPTYPE_KEYMAP_INIT; /* if not set, use default */ - if (wgt->setup_keymap == NULL) { - if (wgt->flag & WM_GIZMOGROUPTYPE_SELECT) { - wgt->setup_keymap = WM_gizmogroup_keymap_common_select; + if (gzgt->setup_keymap == NULL) { + if (gzgt->flag & WM_GIZMOGROUPTYPE_SELECT) { + gzgt->setup_keymap = WM_gizmogroup_keymap_common_select; } else { - wgt->setup_keymap = WM_gizmogroup_keymap_common; + gzgt->setup_keymap = WM_gizmogroup_keymap_common; } } - BLI_ghash_insert(global_gizmogrouptype_hash, (void *)wgt->idname, wgt); + BLI_ghash_insert(global_gizmogrouptype_hash, (void *)gzgt->idname, gzgt); } wmGizmoGroupType *WM_gizmogrouptype_append( void (*wtfunc)(struct wmGizmoGroupType *)) { - wmGizmoGroupType *wgt = wm_gizmogrouptype_append__begin(); - wtfunc(wgt); - wm_gizmogrouptype_append__end(wgt); - return wgt; + wmGizmoGroupType *gzgt = wm_gizmogrouptype_append__begin(); + wtfunc(gzgt); + wm_gizmogrouptype_append__end(gzgt); + return gzgt; } wmGizmoGroupType *WM_gizmogrouptype_append_ptr( void (*wtfunc)(struct wmGizmoGroupType *, void *), void *userdata) { - wmGizmoGroupType *wgt = wm_gizmogrouptype_append__begin(); - wtfunc(wgt, userdata); - wm_gizmogrouptype_append__end(wgt); - return wgt; + wmGizmoGroupType *gzgt = wm_gizmogrouptype_append__begin(); + wtfunc(gzgt, userdata); + wm_gizmogrouptype_append__end(gzgt); + return gzgt; } /** @@ -129,56 +129,56 @@ wmGizmoGroupType *WM_gizmogrouptype_append_ptr( * This is most common for C gizmos which are enabled by default. */ wmGizmoGroupTypeRef *WM_gizmogrouptype_append_and_link( - wmGizmoMapType *mmap_type, + wmGizmoMapType *gzmap_type, void (*wtfunc)(struct wmGizmoGroupType *)) { - wmGizmoGroupType *wgt = WM_gizmogrouptype_append(wtfunc); + wmGizmoGroupType *gzgt = WM_gizmogrouptype_append(wtfunc); - wgt->mmap_params.spaceid = mmap_type->spaceid; - wgt->mmap_params.regionid = mmap_type->regionid; + gzgt->gzmap_params.spaceid = gzmap_type->spaceid; + gzgt->gzmap_params.regionid = gzmap_type->regionid; - return WM_gizmomaptype_group_link_ptr(mmap_type, wgt); + return WM_gizmomaptype_group_link_ptr(gzmap_type, gzgt); } /** * Free but don't remove from ghash. */ -static void gizmogrouptype_free(wmGizmoGroupType *wgt) +static void gizmogrouptype_free(wmGizmoGroupType *gzgt) { - if (wgt->ext.srna) { /* python gizmo group, allocs own string */ - MEM_freeN((void *)wgt->idname); + if (gzgt->ext.srna) { /* python gizmo group, allocs own string */ + MEM_freeN((void *)gzgt->idname); } - MEM_freeN(wgt); + MEM_freeN(gzgt); } -void WM_gizmogrouptype_free_ptr(wmGizmoGroupType *wgt) +void WM_gizmogrouptype_free_ptr(wmGizmoGroupType *gzgt) { - BLI_assert(wgt == WM_gizmogrouptype_find(wgt->idname, false)); + BLI_assert(gzgt == WM_gizmogrouptype_find(gzgt->idname, false)); - BLI_ghash_remove(global_gizmogrouptype_hash, wgt->idname, NULL, NULL); + BLI_ghash_remove(global_gizmogrouptype_hash, gzgt->idname, NULL, NULL); - gizmogrouptype_free(wgt); + gizmogrouptype_free(gzgt); /* XXX, TODO, update the world! */ } bool WM_gizmogrouptype_free(const char *idname) { - wmGizmoGroupType *wgt = BLI_ghash_lookup(global_gizmogrouptype_hash, idname); + wmGizmoGroupType *gzgt = BLI_ghash_lookup(global_gizmogrouptype_hash, idname); - if (wgt == NULL) { + if (gzgt == NULL) { return false; } - WM_gizmogrouptype_free_ptr(wgt); + WM_gizmogrouptype_free_ptr(gzgt); return true; } -static void wm_gizmogrouptype_ghash_free_cb(wmGizmoGroupType *wgt) +static void wm_gizmogrouptype_ghash_free_cb(wmGizmoGroupType *gzgt) { - gizmogrouptype_free(wgt); + gizmogrouptype_free(gzgt); } void wm_gizmogrouptype_free(void) diff --git a/source/blender/windowmanager/gizmo/intern/wm_gizmo_intern.h b/source/blender/windowmanager/gizmo/intern/wm_gizmo_intern.h index 5eed4f2bda2..d4a9dc4f54c 100644 --- a/source/blender/windowmanager/gizmo/intern/wm_gizmo_intern.h +++ b/source/blender/windowmanager/gizmo/intern/wm_gizmo_intern.h @@ -40,14 +40,14 @@ struct GHashIterator; bool wm_gizmo_select_set_ex( - struct wmGizmoMap *mmap, struct wmGizmo *mpr, bool select, + struct wmGizmoMap *gzmap, struct wmGizmo *gz, bool select, bool use_array, bool use_callback); -bool wm_gizmo_select_and_highlight(bContext *C, struct wmGizmoMap *mmap, struct wmGizmo *mpr); +bool wm_gizmo_select_and_highlight(bContext *C, struct wmGizmoMap *gzmap, struct wmGizmo *gz); -void wm_gizmo_calculate_scale(struct wmGizmo *mpr, const bContext *C); -void wm_gizmo_update(struct wmGizmo *mpr, const bContext *C, const bool refresh_map); +void wm_gizmo_calculate_scale(struct wmGizmo *gz, const bContext *C); +void wm_gizmo_update(struct wmGizmo *gz, const bContext *C, const bool refresh_map); -int wm_gizmo_is_visible(struct wmGizmo *mpr); +int wm_gizmo_is_visible(struct wmGizmo *gz); enum { WM_GIZMO_IS_VISIBLE_UPDATE = (1 << 0), WM_GIZMO_IS_VISIBLE_DRAW = (1 << 1), @@ -66,20 +66,20 @@ enum { }; struct wmGizmoGroup *wm_gizmogroup_new_from_type( - struct wmGizmoMap *mmap, struct wmGizmoGroupType *wgt); -void wm_gizmogroup_free(bContext *C, struct wmGizmoGroup *mgroup); -void wm_gizmogroup_gizmo_register(struct wmGizmoGroup *mgroup, struct wmGizmo *mpr); + struct wmGizmoMap *gzmap, struct wmGizmoGroupType *gzgt); +void wm_gizmogroup_free(bContext *C, struct wmGizmoGroup *gzgroup); +void wm_gizmogroup_gizmo_register(struct wmGizmoGroup *gzgroup, struct wmGizmo *gz); struct wmGizmo *wm_gizmogroup_find_intersected_gizmo( - const struct wmGizmoGroup *mgroup, struct bContext *C, const struct wmEvent *event, + const struct wmGizmoGroup *gzgroup, struct bContext *C, const struct wmEvent *event, int *r_part); void wm_gizmogroup_intersectable_gizmos_to_list( - const struct wmGizmoGroup *mgroup, struct ListBase *listbase); -void wm_gizmogroup_ensure_initialized(struct wmGizmoGroup *mgroup, const struct bContext *C); + const struct wmGizmoGroup *gzgroup, struct ListBase *listbase); +void wm_gizmogroup_ensure_initialized(struct wmGizmoGroup *gzgroup, const struct bContext *C); bool wm_gizmogroup_is_visible_in_drawstep( - const struct wmGizmoGroup *mgroup, const eWM_GizmoFlagMapDrawStep drawstep); + const struct wmGizmoGroup *gzgroup, const eWM_GizmoFlagMapDrawStep drawstep); void wm_gizmogrouptype_setup_keymap( - struct wmGizmoGroupType *wgt, struct wmKeyConfig *keyconf); + struct wmGizmoGroupType *gzgt, struct wmKeyConfig *keyconf); /* -------------------------------------------------------------------- */ @@ -116,7 +116,7 @@ struct wmGizmoMap { short event_grabcursor; /* until we have nice cursor push/pop API. */ int last_cursor; - } mmap_context; + } gzmap_context; }; /** @@ -135,10 +135,10 @@ struct wmGizmoMapType { eWM_GizmoFlagMapTypeUpdateFlag type_update_flag; }; -void wm_gizmomap_select_array_clear(struct wmGizmoMap *mmap); -bool wm_gizmomap_deselect_all(struct wmGizmoMap *mmap); -void wm_gizmomap_select_array_shrink(struct wmGizmoMap *mmap, int len_subtract); -void wm_gizmomap_select_array_push_back(struct wmGizmoMap *mmap, wmGizmo *mpr); -void wm_gizmomap_select_array_remove(struct wmGizmoMap *mmap, wmGizmo *mpr); +void wm_gizmomap_select_array_clear(struct wmGizmoMap *gzmap); +bool wm_gizmomap_deselect_all(struct wmGizmoMap *gzmap); +void wm_gizmomap_select_array_shrink(struct wmGizmoMap *gzmap, int len_subtract); +void wm_gizmomap_select_array_push_back(struct wmGizmoMap *gzmap, wmGizmo *gz); +void wm_gizmomap_select_array_remove(struct wmGizmoMap *gzmap, wmGizmo *gz); #endif diff --git a/source/blender/windowmanager/gizmo/intern/wm_gizmo_map.c b/source/blender/windowmanager/gizmo/intern/wm_gizmo_map.c index 9da1591d535..0b54f0cbec1 100644 --- a/source/blender/windowmanager/gizmo/intern/wm_gizmo_map.c +++ b/source/blender/windowmanager/gizmo/intern/wm_gizmo_map.c @@ -75,7 +75,7 @@ typedef enum eWM_GizmoFlagGroupTypeGlobalFlag { WM_GIZMOMAPTYPE_GLOBAL_UPDATE_REMOVE = (1 << 1), } eWM_GizmoFlagGroupTypeGlobalFlag; -static eWM_GizmoFlagGroupTypeGlobalFlag wm_mmap_type_update_flag = 0; +static eWM_GizmoFlagGroupTypeGlobalFlag wm_gzmap_type_update_flag = 0; /** * Gizmo-map update tagging. @@ -94,9 +94,9 @@ enum { * * \{ */ -static void wm_gizmomap_select_array_ensure_len_alloc(wmGizmoMap *mmap, int len) +static void wm_gizmomap_select_array_ensure_len_alloc(wmGizmoMap *gzmap, int len) { - wmGizmoMapSelectState *msel = &mmap->mmap_context.select; + wmGizmoMapSelectState *msel = &gzmap->gzmap_context.select; if (len <= msel->len_alloc) { return; } @@ -104,20 +104,20 @@ static void wm_gizmomap_select_array_ensure_len_alloc(wmGizmoMap *mmap, int len) msel->len_alloc = len; } -void wm_gizmomap_select_array_clear(wmGizmoMap *mmap) +void wm_gizmomap_select_array_clear(wmGizmoMap *gzmap) { - wmGizmoMapSelectState *msel = &mmap->mmap_context.select; + wmGizmoMapSelectState *msel = &gzmap->gzmap_context.select; MEM_SAFE_FREE(msel->items); msel->len = 0; msel->len_alloc = 0; } -void wm_gizmomap_select_array_shrink(wmGizmoMap *mmap, int len_subtract) +void wm_gizmomap_select_array_shrink(wmGizmoMap *gzmap, int len_subtract) { - wmGizmoMapSelectState *msel = &mmap->mmap_context.select; + wmGizmoMapSelectState *msel = &gzmap->gzmap_context.select; msel->len -= len_subtract; if (msel->len <= 0) { - wm_gizmomap_select_array_clear(mmap); + wm_gizmomap_select_array_clear(gzmap); } else { if (msel->len < msel->len_alloc / 2) { @@ -127,27 +127,27 @@ void wm_gizmomap_select_array_shrink(wmGizmoMap *mmap, int len_subtract) } } -void wm_gizmomap_select_array_push_back(wmGizmoMap *mmap, wmGizmo *mpr) +void wm_gizmomap_select_array_push_back(wmGizmoMap *gzmap, wmGizmo *gz) { - wmGizmoMapSelectState *msel = &mmap->mmap_context.select; + wmGizmoMapSelectState *msel = &gzmap->gzmap_context.select; BLI_assert(msel->len <= msel->len_alloc); if (msel->len == msel->len_alloc) { msel->len_alloc = (msel->len + 1) * 2; msel->items = MEM_reallocN(msel->items, sizeof(*msel->items) * msel->len_alloc); } - msel->items[msel->len++] = mpr; + msel->items[msel->len++] = gz; } -void wm_gizmomap_select_array_remove(wmGizmoMap *mmap, wmGizmo *mpr) +void wm_gizmomap_select_array_remove(wmGizmoMap *gzmap, wmGizmo *gz) { - wmGizmoMapSelectState *msel = &mmap->mmap_context.select; + wmGizmoMapSelectState *msel = &gzmap->gzmap_context.select; /* remove gizmo from selected_gizmos array */ for (int i = 0; i < msel->len; i++) { - if (msel->items[i] == mpr) { + if (msel->items[i] == gz) { for (int j = i; j < (msel->len - 1); j++) { msel->items[j] = msel->items[j + 1]; } - wm_gizmomap_select_array_shrink(mmap, 1); + wm_gizmomap_select_array_shrink(gzmap, 1); break; } } @@ -166,84 +166,84 @@ void wm_gizmomap_select_array_remove(wmGizmoMap *mmap, wmGizmo *mpr) * Creates a gizmo-map with all registered gizmos for that type */ wmGizmoMap *WM_gizmomap_new_from_type( - const struct wmGizmoMapType_Params *mmap_params) + const struct wmGizmoMapType_Params *gzmap_params) { - wmGizmoMapType *mmap_type = WM_gizmomaptype_ensure(mmap_params); - wmGizmoMap *mmap; + wmGizmoMapType *gzmap_type = WM_gizmomaptype_ensure(gzmap_params); + wmGizmoMap *gzmap; - mmap = MEM_callocN(sizeof(wmGizmoMap), "GizmoMap"); - mmap->type = mmap_type; - WM_gizmomap_tag_refresh(mmap); + gzmap = MEM_callocN(sizeof(wmGizmoMap), "GizmoMap"); + gzmap->type = gzmap_type; + WM_gizmomap_tag_refresh(gzmap); /* create all gizmo-groups for this gizmo-map. We may create an empty one * too in anticipation of gizmos from operators etc */ - for (wmGizmoGroupTypeRef *wgt_ref = mmap_type->grouptype_refs.first; wgt_ref; wgt_ref = wgt_ref->next) { - wm_gizmogroup_new_from_type(mmap, wgt_ref->type); + for (wmGizmoGroupTypeRef *gzgt_ref = gzmap_type->grouptype_refs.first; gzgt_ref; gzgt_ref = gzgt_ref->next) { + wm_gizmogroup_new_from_type(gzmap, gzgt_ref->type); } - return mmap; + return gzmap; } -void wm_gizmomap_remove(wmGizmoMap *mmap) +void wm_gizmomap_remove(wmGizmoMap *gzmap) { /* Clear first so further calls don't waste time trying to maintain correct array state. */ - wm_gizmomap_select_array_clear(mmap); + wm_gizmomap_select_array_clear(gzmap); - for (wmGizmoGroup *mgroup = mmap->groups.first, *mgroup_next; mgroup; mgroup = mgroup_next) { - mgroup_next = mgroup->next; - BLI_assert(mgroup->parent_mmap == mmap); - wm_gizmogroup_free(NULL, mgroup); + for (wmGizmoGroup *gzgroup = gzmap->groups.first, *gzgroup_next; gzgroup; gzgroup = gzgroup_next) { + gzgroup_next = gzgroup->next; + BLI_assert(gzgroup->parent_gzmap == gzmap); + wm_gizmogroup_free(NULL, gzgroup); } - BLI_assert(BLI_listbase_is_empty(&mmap->groups)); + BLI_assert(BLI_listbase_is_empty(&gzmap->groups)); - MEM_freeN(mmap); + MEM_freeN(gzmap); } wmGizmoGroup *WM_gizmomap_group_find( - struct wmGizmoMap *mmap, + struct wmGizmoMap *gzmap, const char *idname) { - wmGizmoGroupType *wgt = WM_gizmogrouptype_find(idname, false); - if (wgt) { - return WM_gizmomap_group_find_ptr(mmap, wgt); + wmGizmoGroupType *gzgt = WM_gizmogrouptype_find(idname, false); + if (gzgt) { + return WM_gizmomap_group_find_ptr(gzmap, gzgt); } return NULL; } wmGizmoGroup *WM_gizmomap_group_find_ptr( - struct wmGizmoMap *mmap, - const struct wmGizmoGroupType *wgt) + struct wmGizmoMap *gzmap, + const struct wmGizmoGroupType *gzgt) { - for (wmGizmoGroup *mgroup = mmap->groups.first; mgroup; mgroup = mgroup->next) { - if (mgroup->type == wgt) { - return mgroup; + for (wmGizmoGroup *gzgroup = gzmap->groups.first; gzgroup; gzgroup = gzgroup->next) { + if (gzgroup->type == gzgt) { + return gzgroup; } } return NULL; } -const ListBase *WM_gizmomap_group_list(wmGizmoMap *mmap) +const ListBase *WM_gizmomap_group_list(wmGizmoMap *gzmap) { - return &mmap->groups; + return &gzmap->groups; } -bool WM_gizmomap_is_any_selected(const wmGizmoMap *mmap) +bool WM_gizmomap_is_any_selected(const wmGizmoMap *gzmap) { - return mmap->mmap_context.select.len != 0; + return gzmap->gzmap_context.select.len != 0; } /** * \note We could use a callback to define bounds, for now just use matrix location. */ bool WM_gizmomap_minmax( - const wmGizmoMap *mmap, bool UNUSED(use_hidden), bool use_select, + const wmGizmoMap *gzmap, bool UNUSED(use_hidden), bool use_select, float r_min[3], float r_max[3]) { if (use_select) { int i; - for (i = 0; i < mmap->mmap_context.select.len; i++) { - minmax_v3v3_v3(r_min, r_max, mmap->mmap_context.select.items[i]->matrix_basis[3]); + for (i = 0; i < gzmap->gzmap_context.select.len; i++) { + minmax_v3v3_v3(r_min, r_max, gzmap->gzmap_context.select.items[i]->matrix_basis[3]); } return i != 0; } @@ -255,7 +255,7 @@ bool WM_gizmomap_minmax( } /** - * Creates and returns idname hash table for (visible) gizmos in \a mmap + * Creates and returns idname hash table for (visible) gizmos in \a gzmap * * \param poll Polling function for excluding gizmos. * \param data Custom data passed to \a poll @@ -264,20 +264,20 @@ bool WM_gizmomap_minmax( * best we use an iterator function instead of a hash. */ static GHash *WM_gizmomap_gizmo_hash_new( - const bContext *C, wmGizmoMap *mmap, + const bContext *C, wmGizmoMap *gzmap, bool (*poll)(const wmGizmo *, void *), void *data, const bool include_hidden) { GHash *hash = BLI_ghash_ptr_new(__func__); /* collect gizmos */ - for (wmGizmoGroup *mgroup = mmap->groups.first; mgroup; mgroup = mgroup->next) { - if (WM_gizmo_group_type_poll(C, mgroup->type)) { - for (wmGizmo *mpr = mgroup->gizmos.first; mpr; mpr = mpr->next) { - if ((include_hidden || (mpr->flag & WM_GIZMO_HIDDEN) == 0) && - (!poll || poll(mpr, data))) + for (wmGizmoGroup *gzgroup = gzmap->groups.first; gzgroup; gzgroup = gzgroup->next) { + if (WM_gizmo_group_type_poll(C, gzgroup->type)) { + for (wmGizmo *gz = gzgroup->gizmos.first; gz; gz = gz->next) { + if ((include_hidden || (gz->flag & WM_GIZMO_HIDDEN) == 0) && + (!poll || poll(gz, data))) { - BLI_ghash_insert(hash, mpr, mpr); + BLI_ghash_insert(hash, gz, gz); } } } @@ -286,12 +286,12 @@ static GHash *WM_gizmomap_gizmo_hash_new( return hash; } -void WM_gizmomap_tag_refresh(wmGizmoMap *mmap) +void WM_gizmomap_tag_refresh(wmGizmoMap *gzmap) { - if (mmap) { + if (gzmap) { /* We might want only to refresh some, for tag all steps. */ for (int i = 0; i < WM_GIZMOMAP_DRAWSTEP_MAX; i++) { - mmap->update_flag[i] |= ( + gzmap->update_flag[i] |= ( GIZMOMAP_IS_PREPARE_DRAW | GIZMOMAP_IS_REFRESH_CALLBACK); } @@ -299,11 +299,11 @@ void WM_gizmomap_tag_refresh(wmGizmoMap *mmap) } static bool gizmo_prepare_drawing( - wmGizmoMap *mmap, wmGizmo *mpr, + wmGizmoMap *gzmap, wmGizmo *gz, const bContext *C, ListBase *draw_gizmos, const eWM_GizmoFlagMapDrawStep drawstep) { - int do_draw = wm_gizmo_is_visible(mpr); + int do_draw = wm_gizmo_is_visible(gz); if (do_draw == 0) { /* skip */ } @@ -311,10 +311,10 @@ static bool gizmo_prepare_drawing( /* Ensure we get RNA updates */ if (do_draw & WM_GIZMO_IS_VISIBLE_UPDATE) { /* hover gizmos need updating, even if we don't draw them */ - wm_gizmo_update(mpr, C, (mmap->update_flag[drawstep] & GIZMOMAP_IS_PREPARE_DRAW) != 0); + wm_gizmo_update(gz, C, (gzmap->update_flag[drawstep] & GIZMOMAP_IS_PREPARE_DRAW) != 0); } if (do_draw & WM_GIZMO_IS_VISIBLE_DRAW) { - BLI_addhead(draw_gizmos, BLI_genericNodeN(mpr)); + BLI_addhead(draw_gizmos, BLI_genericNodeN(gz)); } return true; } @@ -323,23 +323,23 @@ static bool gizmo_prepare_drawing( } /** - * Update gizmos of \a mmap to prepare for drawing. Adds all gizmos that + * Update gizmos of \a gzmap to prepare for drawing. Adds all gizmos that * should be drawn to list \a draw_gizmos, note that added items need freeing. */ static void gizmomap_prepare_drawing( - wmGizmoMap *mmap, const bContext *C, ListBase *draw_gizmos, + wmGizmoMap *gzmap, const bContext *C, ListBase *draw_gizmos, const eWM_GizmoFlagMapDrawStep drawstep) { - if (!mmap || BLI_listbase_is_empty(&mmap->groups)) + if (!gzmap || BLI_listbase_is_empty(&gzmap->groups)) return; - wmGizmo *mpr_modal = mmap->mmap_context.modal; + wmGizmo *gz_modal = gzmap->gzmap_context.modal; /* only active gizmo needs updating */ - if (mpr_modal) { - if ((mpr_modal->parent_mgroup->type->flag & WM_GIZMOGROUPTYPE_DRAW_MODAL_ALL) == 0) { - if (wm_gizmogroup_is_visible_in_drawstep(mpr_modal->parent_mgroup, drawstep)) { - if (gizmo_prepare_drawing(mmap, mpr_modal, C, draw_gizmos, drawstep)) { - mmap->update_flag[drawstep] &= ~GIZMOMAP_IS_PREPARE_DRAW; + if (gz_modal) { + if ((gz_modal->parent_gzgroup->type->flag & WM_GIZMOGROUPTYPE_DRAW_MODAL_ALL) == 0) { + if (wm_gizmogroup_is_visible_in_drawstep(gz_modal->parent_gzgroup, drawstep)) { + if (gizmo_prepare_drawing(gzmap, gz_modal, C, draw_gizmos, drawstep)) { + gzmap->update_flag[drawstep] &= ~GIZMOMAP_IS_PREPARE_DRAW; } } /* don't draw any other gizmos */ @@ -347,46 +347,46 @@ static void gizmomap_prepare_drawing( } } - for (wmGizmoGroup *mgroup = mmap->groups.first; mgroup; mgroup = mgroup->next) { + for (wmGizmoGroup *gzgroup = gzmap->groups.first; gzgroup; gzgroup = gzgroup->next) { /* check group visibility - drawstep first to avoid unnecessary call of group poll callback */ - if (!wm_gizmogroup_is_visible_in_drawstep(mgroup, drawstep) || - !WM_gizmo_group_type_poll(C, mgroup->type)) + if (!wm_gizmogroup_is_visible_in_drawstep(gzgroup, drawstep) || + !WM_gizmo_group_type_poll(C, gzgroup->type)) { continue; } /* needs to be initialized on first draw */ /* XXX weak: Gizmo-group may skip refreshing if it's invisible (map gets untagged nevertheless) */ - if (mmap->update_flag[drawstep] & GIZMOMAP_IS_REFRESH_CALLBACK) { + if (gzmap->update_flag[drawstep] & GIZMOMAP_IS_REFRESH_CALLBACK) { /* force refresh again. */ - mgroup->init_flag &= ~WM_GIZMOGROUP_INIT_REFRESH; + gzgroup->init_flag &= ~WM_GIZMOGROUP_INIT_REFRESH; } /* Calls `setup`, `setup_keymap` and `refresh` if they're defined. */ - wm_gizmogroup_ensure_initialized(mgroup, C); + wm_gizmogroup_ensure_initialized(gzgroup, C); /* prepare drawing */ - if (mgroup->type->draw_prepare) { - mgroup->type->draw_prepare(C, mgroup); + if (gzgroup->type->draw_prepare) { + gzgroup->type->draw_prepare(C, gzgroup); } - for (wmGizmo *mpr = mgroup->gizmos.first; mpr; mpr = mpr->next) { - gizmo_prepare_drawing(mmap, mpr, C, draw_gizmos, drawstep); + for (wmGizmo *gz = gzgroup->gizmos.first; gz; gz = gz->next) { + gizmo_prepare_drawing(gzmap, gz, C, draw_gizmos, drawstep); } } - mmap->update_flag[drawstep] &= + gzmap->update_flag[drawstep] &= ~(GIZMOMAP_IS_REFRESH_CALLBACK | GIZMOMAP_IS_PREPARE_DRAW); } /** - * Draw all visible gizmos in \a mmap. + * Draw all visible gizmos in \a gzmap. * Uses global draw_gizmos listbase. */ -static void gizmos_draw_list(const wmGizmoMap *mmap, const bContext *C, ListBase *draw_gizmos) +static void gizmos_draw_list(const wmGizmoMap *gzmap, const bContext *C, ListBase *draw_gizmos) { /* Can be empty if we're dynamically added and removed. */ - if ((mmap == NULL) || BLI_listbase_is_empty(&mmap->groups)) { + if ((gzmap == NULL) || BLI_listbase_is_empty(&gzmap->groups)) { return; } @@ -397,13 +397,13 @@ static void gizmos_draw_list(const wmGizmoMap *mmap, const bContext *C, ListBase /* draw_gizmos contains all visible gizmos - draw them */ for (LinkData *link = draw_gizmos->first, *link_next; link; link = link_next) { - wmGizmo *mpr = link->data; + wmGizmo *gz = link->data; link_next = link->next; - bool is_depth = (mpr->parent_mgroup->type->flag & WM_GIZMOGROUPTYPE_DEPTH_3D) != 0; + bool is_depth = (gz->parent_gzgroup->type->flag & WM_GIZMOGROUPTYPE_DEPTH_3D) != 0; /* Weak! since we don't 100% support depth yet (select ignores depth) always show highlighted */ - if (is_depth && (mpr->state & WM_GIZMO_STATE_HIGHLIGHT)) { + if (is_depth && (gz->state & WM_GIZMO_STATE_HIGHLIGHT)) { is_depth = false; } @@ -424,7 +424,7 @@ static void gizmos_draw_list(const wmGizmoMap *mmap, const bContext *C, ListBase glEnable(GL_LINE_SMOOTH); glEnable(GL_POLYGON_SMOOTH); - mpr->type->draw(C, mpr); + gz->type->draw(C, gz); glDisable(GL_LINE_SMOOTH); glDisable(GL_POLYGON_SMOOTH); @@ -439,7 +439,7 @@ static void gizmos_draw_list(const wmGizmoMap *mmap, const bContext *C, ListBase } void WM_gizmomap_draw( - wmGizmoMap *mmap, const bContext *C, + wmGizmoMap *gzmap, const bContext *C, const eWM_GizmoFlagMapDrawStep drawstep) { if (!WM_gizmo_context_check_drawstep(C, drawstep)) { @@ -448,24 +448,32 @@ void WM_gizmomap_draw( ListBase draw_gizmos = {NULL}; - gizmomap_prepare_drawing(mmap, C, &draw_gizmos, drawstep); - gizmos_draw_list(mmap, C, &draw_gizmos); + gizmomap_prepare_drawing(gzmap, C, &draw_gizmos, drawstep); + gizmos_draw_list(gzmap, C, &draw_gizmos); BLI_assert(BLI_listbase_is_empty(&draw_gizmos)); } -static void gizmo_draw_select_3D_loop(const bContext *C, ListBase *visible_gizmos) +static void gizmo_draw_select_3D_loop( + const bContext *C, ListBase *visible_gizmos, + const wmGizmo *gz_stop) { int select_id = 0; - wmGizmo *mpr; + wmGizmo *gz; /* TODO(campbell): this depends on depth buffer being written to, currently broken for the 3D view. */ bool is_depth_prev = false; bool is_depth_skip_prev = false; - for (LinkData *link = visible_gizmos->first; link; link = link->next) { - mpr = link->data; + for (LinkData *link = visible_gizmos->first; link; link = link->next, select_id++) { + gz = link->data; + if (gz == gz_stop) { + break; + } + if (gz->type->draw_select == NULL) { + continue; + } - bool is_depth = (mpr->parent_mgroup->type->flag & WM_GIZMOGROUPTYPE_DEPTH_3D) != 0; + bool is_depth = (gz->parent_gzgroup->type->flag & WM_GIZMOGROUPTYPE_DEPTH_3D) != 0; if (is_depth == is_depth_prev) { /* pass */ } @@ -478,7 +486,7 @@ static void gizmo_draw_select_3D_loop(const bContext *C, ListBase *visible_gizmo } is_depth_prev = is_depth; } - bool is_depth_skip = (mpr->flag & WM_GIZMO_SELECT_BACKGROUND) != 0; + bool is_depth_skip = (gz->flag & WM_GIZMO_SELECT_BACKGROUND) != 0; if (is_depth_skip == is_depth_skip_prev) { /* pass */ } @@ -489,10 +497,7 @@ static void gizmo_draw_select_3D_loop(const bContext *C, ListBase *visible_gizmo /* pass the selection id shifted by 8 bits. Last 8 bits are used for selected gizmo part id */ - mpr->type->draw_select(C, mpr, select_id << 8); - - - select_id++; + gz->type->draw_select(C, gz, select_id << 8); } if (is_depth_prev) { @@ -505,7 +510,7 @@ static void gizmo_draw_select_3D_loop(const bContext *C, ListBase *visible_gizmo static int gizmo_find_intersected_3d_intern( ListBase *visible_gizmos, const bContext *C, const int co[2], - const int hotspot) + const int hotspot, const wmGizmo *gz_stop) { ScrArea *sa = CTX_wm_area(C); ARegion *ar = CTX_wm_region(C); @@ -525,13 +530,13 @@ static int gizmo_find_intersected_3d_intern( else GPU_select_begin(buffer, ARRAY_SIZE(buffer), &rect, GPU_SELECT_ALL, 0); /* do the drawing */ - gizmo_draw_select_3D_loop(C, visible_gizmos); + gizmo_draw_select_3D_loop(C, visible_gizmos, gz_stop); hits = GPU_select_end(); if (do_passes && (hits > 0)) { GPU_select_begin(buffer, ARRAY_SIZE(buffer), &rect, GPU_SELECT_NEAREST_SECOND_PASS, hits); - gizmo_draw_select_3D_loop(C, visible_gizmos); + gizmo_draw_select_3D_loop(C, visible_gizmos, gz_stop); GPU_select_end(); } @@ -552,36 +557,56 @@ static wmGizmo *gizmo_find_intersected_3d( wmGizmo *result = NULL; int hit = -1; - int hotspot_radii[] = { - 3 * U.pixelsize, - /* This runs on mouse move, careful doing too many tests! */ - 10 * U.pixelsize, - }; - *r_part = 0; /* set up view matrices */ view3d_operator_needs_opengl(C); - hit = -1; - - for (int i = 0; i < ARRAY_SIZE(hotspot_radii); i++) { - hit = gizmo_find_intersected_3d_intern(visible_gizmos, C, co, hotspot_radii[i]); - if (hit != -1) { - break; + /* Search for 3D gizmo's that use the 2D callback for checking intersections. */ + bool has_3d = false; + { + int select_id = 0; + for (LinkData *link = visible_gizmos->first; link; link = link->next, select_id++) { + wmGizmo *gz = link->data; + if (gz->type->test_select) { + if ((*r_part = gz->type->test_select(C, gz, co)) != -1) { + hit = select_id; + result = gz; + break; + } + } + else { + has_3d = true; + } } } - if (hit != -1) { - LinkData *link = BLI_findlink(visible_gizmos, hit >> 8); - if (link != NULL) { - *r_part = hit & 255; - result = link->data; + /* Search for 3D intersections if they're before 2D that have been found (if any). + * This way we always use the first hit. */ + if (has_3d) { + const int hotspot_radii[] = { + 3 * U.pixelsize, + /* This runs on mouse move, careful doing too many tests! */ + 10 * U.pixelsize, + }; + for (int i = 0; i < ARRAY_SIZE(hotspot_radii); i++) { + hit = gizmo_find_intersected_3d_intern(visible_gizmos, C, co, hotspot_radii[i], result); + if (hit != -1) { + break; + } } - else { - /* All gizmos should use selection ID they're given as part of the callback, - * if they don't it will attempt tp lookup non-existing index. */ - BLI_assert(0); + + if (hit != -1) { + LinkData *link = BLI_findlink(visible_gizmos, hit >> 8); + if (link != NULL) { + *r_part = hit & 255; + result = link->data; + } + else { + /* All gizmos should use selection ID they're given as part of the callback, + * if they don't it will attempt tp lookup non-existing index. */ + BLI_assert(0); + } } } @@ -593,10 +618,10 @@ static wmGizmo *gizmo_find_intersected_3d( * 3D ones (could check for smallest screen-space distance but not needed right now). */ wmGizmo *wm_gizmomap_highlight_find( - wmGizmoMap *mmap, bContext *C, const wmEvent *event, + wmGizmoMap *gzmap, bContext *C, const wmEvent *event, int *r_part) { - wmGizmo *mpr = NULL; + wmGizmo *gz = NULL; ListBase visible_3d_gizmos = {NULL}; bool do_step[WM_GIZMOMAP_DRAWSTEP_MAX]; @@ -604,18 +629,18 @@ wmGizmo *wm_gizmomap_highlight_find( do_step[i] = WM_gizmo_context_check_drawstep(C, i); } - for (wmGizmoGroup *mgroup = mmap->groups.first; mgroup; mgroup = mgroup->next) { + for (wmGizmoGroup *gzgroup = gzmap->groups.first; gzgroup; gzgroup = gzgroup->next) { /* If it were important we could initialize here, * but this only happens when events are handled before drawing, * just skip to keep code-path for initializing gizmos simple. */ - if ((mgroup->init_flag & WM_GIZMOGROUP_INIT_SETUP) == 0) { + if ((gzgroup->init_flag & WM_GIZMOGROUP_INIT_SETUP) == 0) { continue; } - if (WM_gizmo_group_type_poll(C, mgroup->type)) { + if (WM_gizmo_group_type_poll(C, gzgroup->type)) { eWM_GizmoFlagMapDrawStep step; - if (mgroup->type->flag & WM_GIZMOGROUPTYPE_3D) { + if (gzgroup->type->flag & WM_GIZMOGROUPTYPE_3D) { step = WM_GIZMOMAP_DRAWSTEP_3D; } else { @@ -623,17 +648,17 @@ wmGizmo *wm_gizmomap_highlight_find( } if (do_step[step]) { - if ((mmap->update_flag[step] & GIZMOMAP_IS_REFRESH_CALLBACK) && - (mgroup->type->refresh != NULL)) + if ((gzmap->update_flag[step] & GIZMOMAP_IS_REFRESH_CALLBACK) && + (gzgroup->type->refresh != NULL)) { - mgroup->type->refresh(C, mgroup); + gzgroup->type->refresh(C, gzgroup); /* cleared below */ } if (step == WM_GIZMOMAP_DRAWSTEP_3D) { - wm_gizmogroup_intersectable_gizmos_to_list(mgroup, &visible_3d_gizmos); + wm_gizmogroup_intersectable_gizmos_to_list(gzgroup, &visible_3d_gizmos); } else if (step == WM_GIZMOMAP_DRAWSTEP_2D) { - if ((mpr = wm_gizmogroup_find_intersected_gizmo(mgroup, C, event, r_part))) { + if ((gz = wm_gizmogroup_find_intersected_gizmo(gzgroup, C, event, r_part))) { break; } } @@ -643,32 +668,32 @@ wmGizmo *wm_gizmomap_highlight_find( if (!BLI_listbase_is_empty(&visible_3d_gizmos)) { /* 2D gizmos get priority. */ - if (mpr == NULL) { - mpr = gizmo_find_intersected_3d(C, event->mval, &visible_3d_gizmos, r_part); + if (gz == NULL) { + gz = gizmo_find_intersected_3d(C, event->mval, &visible_3d_gizmos, r_part); } BLI_freelistN(&visible_3d_gizmos); } - mmap->update_flag[WM_GIZMOMAP_DRAWSTEP_3D] &= ~GIZMOMAP_IS_REFRESH_CALLBACK; - mmap->update_flag[WM_GIZMOMAP_DRAWSTEP_2D] &= ~GIZMOMAP_IS_REFRESH_CALLBACK; + gzmap->update_flag[WM_GIZMOMAP_DRAWSTEP_3D] &= ~GIZMOMAP_IS_REFRESH_CALLBACK; + gzmap->update_flag[WM_GIZMOMAP_DRAWSTEP_2D] &= ~GIZMOMAP_IS_REFRESH_CALLBACK; - return mpr; + return gz; } -void WM_gizmomap_add_handlers(ARegion *ar, wmGizmoMap *mmap) +void WM_gizmomap_add_handlers(ARegion *ar, wmGizmoMap *gzmap) { wmEventHandler *handler; for (handler = ar->handlers.first; handler; handler = handler->next) { - if (handler->gizmo_map == mmap) { + if (handler->gizmo_map == gzmap) { return; } } handler = MEM_callocN(sizeof(wmEventHandler), "gizmo handler"); - BLI_assert(mmap == ar->gizmo_map); - handler->gizmo_map = mmap; + BLI_assert(gzmap == ar->gizmo_map); + handler->gizmo_map = gzmap; BLI_addtail(&ar->handlers, handler); } @@ -682,8 +707,8 @@ void wm_gizmomaps_handled_modal_update( return; } - wmGizmoMap *mmap = handler->op_region->gizmo_map; - wmGizmo *mpr = wm_gizmomap_modal_get(mmap); + wmGizmoMap *gzmap = handler->op_region->gizmo_map; + wmGizmo *gz = wm_gizmomap_modal_get(gzmap); ScrArea *area = CTX_wm_area(C); ARegion *region = CTX_wm_region(C); @@ -691,11 +716,11 @@ void wm_gizmomaps_handled_modal_update( /* regular update for running operator */ if (modal_running) { - wmGizmoOpElem *mpop = mpr ? WM_gizmo_operator_get(mpr, mpr->highlight_part) : NULL; - if (mpr && mpop && (mpop->type != NULL) && (mpop->type == handler->op->type)) { - wmGizmoFnModal modal_fn = mpr->custom_modal ? mpr->custom_modal : mpr->type->modal; + wmGizmoOpElem *mpop = gz ? WM_gizmo_operator_get(gz, gz->highlight_part) : NULL; + if (gz && mpop && (mpop->type != NULL) && (mpop->type == handler->op->type)) { + wmGizmoFnModal modal_fn = gz->custom_modal ? gz->custom_modal : gz->type->modal; if (modal_fn != NULL) { - int retval = modal_fn(C, mpr, event, 0); + int retval = modal_fn(C, gz, event, 0); /* The gizmo is tried to the operator, we can't choose when to exit. */ BLI_assert(retval & OPERATOR_RUNNING_MODAL); UNUSED_VARS_NDEBUG(retval); @@ -704,14 +729,14 @@ void wm_gizmomaps_handled_modal_update( } /* operator not running anymore */ else { - wm_gizmomap_highlight_set(mmap, C, NULL, 0); - if (mpr) { + wm_gizmomap_highlight_set(gzmap, C, NULL, 0); + if (gz) { /* This isn't defined if it ends because of success of cancel, we may want to change. */ bool cancel = true; - if (mpr->type->exit) { - mpr->type->exit(C, mpr, cancel); + if (gz->type->exit) { + gz->type->exit(C, gz, cancel); } - wm_gizmomap_modal_set(mmap, C, mpr, NULL, false); + wm_gizmomap_modal_set(gzmap, C, gz, NULL, false); } } @@ -721,58 +746,58 @@ void wm_gizmomaps_handled_modal_update( } /** - * Deselect all selected gizmos in \a mmap. + * Deselect all selected gizmos in \a gzmap. * \return if selection has changed. */ -bool wm_gizmomap_deselect_all(wmGizmoMap *mmap) +bool wm_gizmomap_deselect_all(wmGizmoMap *gzmap) { - wmGizmoMapSelectState *msel = &mmap->mmap_context.select; + wmGizmoMapSelectState *msel = &gzmap->gzmap_context.select; if (msel->items == NULL || msel->len == 0) { return false; } for (int i = 0; i < msel->len; i++) { - wm_gizmo_select_set_ex(mmap, msel->items[i], false, false, true); + wm_gizmo_select_set_ex(gzmap, msel->items[i], false, false, true); } - wm_gizmomap_select_array_clear(mmap); + wm_gizmomap_select_array_clear(gzmap); /* always return true, we already checked * if there's anything to deselect */ return true; } -BLI_INLINE bool gizmo_selectable_poll(const wmGizmo *mpr, void *UNUSED(data)) +BLI_INLINE bool gizmo_selectable_poll(const wmGizmo *gz, void *UNUSED(data)) { - return (mpr->parent_mgroup->type->flag & WM_GIZMOGROUPTYPE_SELECT); + return (gz->parent_gzgroup->type->flag & WM_GIZMOGROUPTYPE_SELECT); } /** - * Select all selectable gizmos in \a mmap. + * Select all selectable gizmos in \a gzmap. * \return if selection has changed. */ static bool wm_gizmomap_select_all_intern( - bContext *C, wmGizmoMap *mmap) + bContext *C, wmGizmoMap *gzmap) { - wmGizmoMapSelectState *msel = &mmap->mmap_context.select; + wmGizmoMapSelectState *msel = &gzmap->gzmap_context.select; /* GHash is used here to avoid having to loop over all gizmos twice (once to * get tot_sel for allocating, once for actually selecting). Instead we collect * selectable gizmos in hash table and use this to get tot_sel and do selection */ - GHash *hash = WM_gizmomap_gizmo_hash_new(C, mmap, gizmo_selectable_poll, NULL, true); + GHash *hash = WM_gizmomap_gizmo_hash_new(C, gzmap, gizmo_selectable_poll, NULL, true); GHashIterator gh_iter; int i; bool changed = false; - wm_gizmomap_select_array_ensure_len_alloc(mmap, BLI_ghash_len(hash)); + wm_gizmomap_select_array_ensure_len_alloc(gzmap, BLI_ghash_len(hash)); GHASH_ITER_INDEX (gh_iter, hash, i) { - wmGizmo *mpr_iter = BLI_ghashIterator_getValue(&gh_iter); - WM_gizmo_select_set(mmap, mpr_iter, true); + wmGizmo *gz_iter = BLI_ghashIterator_getValue(&gh_iter); + WM_gizmo_select_set(gzmap, gz_iter, true); } /* highlight first gizmo */ - wm_gizmomap_highlight_set(mmap, C, msel->items[0], msel->items[0]->highlight_part); + wm_gizmomap_highlight_set(gzmap, C, msel->items[0], msel->items[0]->highlight_part); BLI_assert(BLI_ghash_len(hash) == msel->len); @@ -781,21 +806,21 @@ static bool wm_gizmomap_select_all_intern( } /** - * Select/Deselect all selectable gizmos in \a mmap. + * Select/Deselect all selectable gizmos in \a gzmap. * \return if selection has changed. * * TODO select all by type */ -bool WM_gizmomap_select_all(bContext *C, wmGizmoMap *mmap, const int action) +bool WM_gizmomap_select_all(bContext *C, wmGizmoMap *gzmap, const int action) { bool changed = false; switch (action) { case SEL_SELECT: - changed = wm_gizmomap_select_all_intern(C, mmap); + changed = wm_gizmomap_select_all_intern(C, gzmap); break; case SEL_DESELECT: - changed = wm_gizmomap_deselect_all(mmap); + changed = wm_gizmomap_deselect_all(gzmap); break; default: BLI_assert(0); @@ -846,11 +871,11 @@ void wm_gizmomap_handler_context(bContext *C, wmEventHandler *handler) } } -bool WM_gizmomap_cursor_set(const wmGizmoMap *mmap, wmWindow *win) +bool WM_gizmomap_cursor_set(const wmGizmoMap *gzmap, wmWindow *win) { - wmGizmo *mpr = mmap->mmap_context.highlight; - if (mpr && mpr->type->cursor_get) { - WM_cursor_set(win, mpr->type->cursor_get(mpr)); + wmGizmo *gz = gzmap->gzmap_context.highlight; + if (gz && gz->type->cursor_get) { + WM_cursor_set(win, gz->type->cursor_get(gz)); return true; } @@ -858,33 +883,33 @@ bool WM_gizmomap_cursor_set(const wmGizmoMap *mmap, wmWindow *win) } bool wm_gizmomap_highlight_set( - wmGizmoMap *mmap, const bContext *C, wmGizmo *mpr, int part) + wmGizmoMap *gzmap, const bContext *C, wmGizmo *gz, int part) { - if ((mpr != mmap->mmap_context.highlight) || - (mpr && part != mpr->highlight_part)) + if ((gz != gzmap->gzmap_context.highlight) || + (gz && part != gz->highlight_part)) { - if (mmap->mmap_context.highlight) { - mmap->mmap_context.highlight->state &= ~WM_GIZMO_STATE_HIGHLIGHT; - mmap->mmap_context.highlight->highlight_part = -1; + if (gzmap->gzmap_context.highlight) { + gzmap->gzmap_context.highlight->state &= ~WM_GIZMO_STATE_HIGHLIGHT; + gzmap->gzmap_context.highlight->highlight_part = -1; } - mmap->mmap_context.highlight = mpr; + gzmap->gzmap_context.highlight = gz; - if (mpr) { - mpr->state |= WM_GIZMO_STATE_HIGHLIGHT; - mpr->highlight_part = part; - mmap->mmap_context.last_cursor = -1; + if (gz) { + gz->state |= WM_GIZMO_STATE_HIGHLIGHT; + gz->highlight_part = part; + gzmap->gzmap_context.last_cursor = -1; - if (C && mpr->type->cursor_get) { + if (C && gz->type->cursor_get) { wmWindow *win = CTX_wm_window(C); - mmap->mmap_context.last_cursor = win->cursor; - WM_cursor_set(win, mpr->type->cursor_get(mpr)); + gzmap->gzmap_context.last_cursor = win->cursor; + WM_cursor_set(win, gz->type->cursor_get(gz)); } } else { - if (C && mmap->mmap_context.last_cursor != -1) { + if (C && gzmap->gzmap_context.last_cursor != -1) { wmWindow *win = CTX_wm_window(C); - WM_cursor_set(win, mmap->mmap_context.last_cursor); + WM_cursor_set(win, gzmap->gzmap_context.last_cursor); } } @@ -900,123 +925,123 @@ bool wm_gizmomap_highlight_set( return false; } -wmGizmo *wm_gizmomap_highlight_get(wmGizmoMap *mmap) +wmGizmo *wm_gizmomap_highlight_get(wmGizmoMap *gzmap) { - return mmap->mmap_context.highlight; + return gzmap->gzmap_context.highlight; } /** * Caller should call exit when (enable == False). */ void wm_gizmomap_modal_set( - wmGizmoMap *mmap, bContext *C, wmGizmo *mpr, const wmEvent *event, bool enable) + wmGizmoMap *gzmap, bContext *C, wmGizmo *gz, const wmEvent *event, bool enable) { if (enable) { - BLI_assert(mmap->mmap_context.modal == NULL); + BLI_assert(gzmap->gzmap_context.modal == NULL); wmWindow *win = CTX_wm_window(C); WM_tooltip_clear(C, win); - if (mpr->type->invoke && - (mpr->type->modal || mpr->custom_modal)) + if (gz->type->invoke && + (gz->type->modal || gz->custom_modal)) { - const int retval = mpr->type->invoke(C, mpr, event); + const int retval = gz->type->invoke(C, gz, event); if ((retval & OPERATOR_RUNNING_MODAL) == 0) { return; } } - mpr->state |= WM_GIZMO_STATE_MODAL; - mmap->mmap_context.modal = mpr; + gz->state |= WM_GIZMO_STATE_MODAL; + gzmap->gzmap_context.modal = gz; - if ((mpr->flag & WM_GIZMO_GRAB_CURSOR) && + if ((gz->flag & WM_GIZMO_GRAB_CURSOR) && (event->is_motion_absolute == false)) { WM_cursor_grab_enable(win, true, true, NULL); - copy_v2_v2_int(mmap->mmap_context.event_xy, &event->x); - mmap->mmap_context.event_grabcursor = win->grabcursor; + copy_v2_v2_int(gzmap->gzmap_context.event_xy, &event->x); + gzmap->gzmap_context.event_grabcursor = win->grabcursor; } else { - mmap->mmap_context.event_xy[0] = INT_MAX; + gzmap->gzmap_context.event_xy[0] = INT_MAX; } - struct wmGizmoOpElem *mpop = WM_gizmo_operator_get(mpr, mpr->highlight_part); + struct wmGizmoOpElem *mpop = WM_gizmo_operator_get(gz, gz->highlight_part); if (mpop && mpop->type) { const int retval = WM_operator_name_call_ptr(C, mpop->type, WM_OP_INVOKE_DEFAULT, &mpop->ptr); if ((retval & OPERATOR_RUNNING_MODAL) == 0) { - wm_gizmomap_modal_set(mmap, C, mpr, event, false); + wm_gizmomap_modal_set(gzmap, C, gz, event, false); } /* we failed to hook the gizmo to the operator handler or operator was cancelled, return */ - if (!mmap->mmap_context.modal) { - mpr->state &= ~WM_GIZMO_STATE_MODAL; - MEM_SAFE_FREE(mpr->interaction_data); + if (!gzmap->gzmap_context.modal) { + gz->state &= ~WM_GIZMO_STATE_MODAL; + MEM_SAFE_FREE(gz->interaction_data); } return; } } else { - BLI_assert(ELEM(mmap->mmap_context.modal, NULL, mpr)); + BLI_assert(ELEM(gzmap->gzmap_context.modal, NULL, gz)); /* deactivate, gizmo but first take care of some stuff */ - if (mpr) { - mpr->state &= ~WM_GIZMO_STATE_MODAL; - MEM_SAFE_FREE(mpr->interaction_data); + if (gz) { + gz->state &= ~WM_GIZMO_STATE_MODAL; + MEM_SAFE_FREE(gz->interaction_data); } - mmap->mmap_context.modal = NULL; + gzmap->gzmap_context.modal = NULL; if (C) { wmWindow *win = CTX_wm_window(C); - if (mmap->mmap_context.event_xy[0] != INT_MAX) { + if (gzmap->gzmap_context.event_xy[0] != INT_MAX) { /* Check if some other part of Blender (typically operators) * have adjusted the grab mode since it was set. * If so: warp, so we have a predictable outcome. */ - if (mmap->mmap_context.event_grabcursor == win->grabcursor) { - WM_cursor_grab_disable(win, mmap->mmap_context.event_xy); + if (gzmap->gzmap_context.event_grabcursor == win->grabcursor) { + WM_cursor_grab_disable(win, gzmap->gzmap_context.event_xy); } else { - WM_cursor_warp(win, UNPACK2(mmap->mmap_context.event_xy)); + WM_cursor_warp(win, UNPACK2(gzmap->gzmap_context.event_xy)); } } ED_region_tag_redraw(CTX_wm_region(C)); WM_event_add_mousemove(C); } - mmap->mmap_context.event_xy[0] = INT_MAX; + gzmap->gzmap_context.event_xy[0] = INT_MAX; } } -wmGizmo *wm_gizmomap_modal_get(wmGizmoMap *mmap) +wmGizmo *wm_gizmomap_modal_get(wmGizmoMap *gzmap) { - return mmap->mmap_context.modal; + return gzmap->gzmap_context.modal; } -wmGizmo **wm_gizmomap_selected_get(wmGizmoMap *mmap, int *r_selected_len) +wmGizmo **wm_gizmomap_selected_get(wmGizmoMap *gzmap, int *r_selected_len) { - *r_selected_len = mmap->mmap_context.select.len; - return mmap->mmap_context.select.items; + *r_selected_len = gzmap->gzmap_context.select.len; + return gzmap->gzmap_context.select.items; } -ListBase *wm_gizmomap_groups_get(wmGizmoMap *mmap) +ListBase *wm_gizmomap_groups_get(wmGizmoMap *gzmap) { - return &mmap->groups; + return &gzmap->groups; } void WM_gizmomap_message_subscribe( - bContext *C, wmGizmoMap *mmap, ARegion *ar, struct wmMsgBus *mbus) + bContext *C, wmGizmoMap *gzmap, ARegion *ar, struct wmMsgBus *mbus) { - for (wmGizmoGroup *mgroup = mmap->groups.first; mgroup; mgroup = mgroup->next) { - if (!WM_gizmo_group_type_poll(C, mgroup->type)) { + for (wmGizmoGroup *gzgroup = gzmap->groups.first; gzgroup; gzgroup = gzgroup->next) { + if (!WM_gizmo_group_type_poll(C, gzgroup->type)) { continue; } - for (wmGizmo *mpr = mgroup->gizmos.first; mpr; mpr = mpr->next) { - if (mpr->flag & WM_GIZMO_HIDDEN) { + for (wmGizmo *gz = gzgroup->gizmos.first; gz; gz = gz->next) { + if (gz->flag & WM_GIZMO_HIDDEN) { continue; } - WM_gizmo_target_property_subscribe_all(mpr, mbus, ar); + WM_gizmo_target_property_subscribe_all(gz, mbus, ar); } - if (mgroup->type->message_subscribe != NULL) { - mgroup->type->message_subscribe(C, mgroup, mbus); + if (gzgroup->type->message_subscribe != NULL) { + gzgroup->type->message_subscribe(C, gzgroup, mbus); } } } @@ -1032,12 +1057,12 @@ void WM_gizmomap_message_subscribe( struct ARegion *WM_gizmomap_tooltip_init( struct bContext *C, struct ARegion *ar, bool *r_exit_on_event) { - wmGizmoMap *mmap = ar->gizmo_map; + wmGizmoMap *gzmap = ar->gizmo_map; *r_exit_on_event = true; - if (mmap) { - wmGizmo *mpr = mmap->mmap_context.highlight; - if (mpr) { - return UI_tooltip_create_from_gizmo(C, mpr); + if (gzmap) { + wmGizmo *gz = gzmap->gzmap_context.highlight; + if (gz) { + return UI_tooltip_create_from_gizmo(C, gz); } } return NULL; @@ -1051,13 +1076,13 @@ struct ARegion *WM_gizmomap_tooltip_init( * \{ */ wmGizmoMapType *WM_gizmomaptype_find( - const struct wmGizmoMapType_Params *mmap_params) + const struct wmGizmoMapType_Params *gzmap_params) { - for (wmGizmoMapType *mmap_type = gizmomaptypes.first; mmap_type; mmap_type = mmap_type->next) { - if (mmap_type->spaceid == mmap_params->spaceid && - mmap_type->regionid == mmap_params->regionid) + for (wmGizmoMapType *gzmap_type = gizmomaptypes.first; gzmap_type; gzmap_type = gzmap_type->next) { + if (gzmap_type->spaceid == gzmap_params->spaceid && + gzmap_type->regionid == gzmap_params->regionid) { - return mmap_type; + return gzmap_type; } } @@ -1065,37 +1090,37 @@ wmGizmoMapType *WM_gizmomaptype_find( } wmGizmoMapType *WM_gizmomaptype_ensure( - const struct wmGizmoMapType_Params *mmap_params) + const struct wmGizmoMapType_Params *gzmap_params) { - wmGizmoMapType *mmap_type = WM_gizmomaptype_find(mmap_params); + wmGizmoMapType *gzmap_type = WM_gizmomaptype_find(gzmap_params); - if (mmap_type) { - return mmap_type; + if (gzmap_type) { + return gzmap_type; } - mmap_type = MEM_callocN(sizeof(wmGizmoMapType), "gizmotype list"); - mmap_type->spaceid = mmap_params->spaceid; - mmap_type->regionid = mmap_params->regionid; - BLI_addhead(&gizmomaptypes, mmap_type); + gzmap_type = MEM_callocN(sizeof(wmGizmoMapType), "gizmotype list"); + gzmap_type->spaceid = gzmap_params->spaceid; + gzmap_type->regionid = gzmap_params->regionid; + BLI_addhead(&gizmomaptypes, gzmap_type); - return mmap_type; + return gzmap_type; } void wm_gizmomaptypes_free(void) { - for (wmGizmoMapType *mmap_type = gizmomaptypes.first, *mmap_type_next; - mmap_type; - mmap_type = mmap_type_next) + for (wmGizmoMapType *gzmap_type = gizmomaptypes.first, *gzmap_type_next; + gzmap_type; + gzmap_type = gzmap_type_next) { - mmap_type_next = mmap_type->next; - for (wmGizmoGroupTypeRef *wgt_ref = mmap_type->grouptype_refs.first, *wgt_next; - wgt_ref; - wgt_ref = wgt_next) + gzmap_type_next = gzmap_type->next; + for (wmGizmoGroupTypeRef *gzgt_ref = gzmap_type->grouptype_refs.first, *gzgt_next; + gzgt_ref; + gzgt_ref = gzgt_next) { - wgt_next = wgt_ref->next; - WM_gizmomaptype_group_free(wgt_ref); + gzgt_next = gzgt_ref->next; + WM_gizmomaptype_group_free(gzgt_ref); } - MEM_freeN(mmap_type); + MEM_freeN(gzmap_type); } } @@ -1107,9 +1132,9 @@ void wm_gizmos_keymap(wmKeyConfig *keyconf) /* we add this item-less keymap once and use it to group gizmo-group keymaps into it */ WM_keymap_find(keyconf, "Gizmos", 0, 0); - for (wmGizmoMapType *mmap_type = gizmomaptypes.first; mmap_type; mmap_type = mmap_type->next) { - for (wmGizmoGroupTypeRef *wgt_ref = mmap_type->grouptype_refs.first; wgt_ref; wgt_ref = wgt_ref->next) { - wm_gizmogrouptype_setup_keymap(wgt_ref->type, keyconf); + for (wmGizmoMapType *gzmap_type = gizmomaptypes.first; gzmap_type; gzmap_type = gzmap_type->next) { + for (wmGizmoGroupTypeRef *gzgt_ref = gzmap_type->grouptype_refs.first; gzgt_ref; gzgt_ref = gzgt_ref->next) { + wm_gizmogrouptype_setup_keymap(gzgt_ref->type, keyconf); } } } @@ -1123,23 +1148,23 @@ void wm_gizmos_keymap(wmKeyConfig *keyconf) void WM_gizmoconfig_update_tag_init( - wmGizmoMapType *mmap_type, wmGizmoGroupType *wgt) + wmGizmoMapType *gzmap_type, wmGizmoGroupType *gzgt) { /* tag for update on next use */ - mmap_type->type_update_flag |= (WM_GIZMOMAPTYPE_UPDATE_INIT | WM_GIZMOMAPTYPE_KEYMAP_INIT); - wgt->type_update_flag |= (WM_GIZMOMAPTYPE_UPDATE_INIT | WM_GIZMOMAPTYPE_KEYMAP_INIT); + gzmap_type->type_update_flag |= (WM_GIZMOMAPTYPE_UPDATE_INIT | WM_GIZMOMAPTYPE_KEYMAP_INIT); + gzgt->type_update_flag |= (WM_GIZMOMAPTYPE_UPDATE_INIT | WM_GIZMOMAPTYPE_KEYMAP_INIT); - wm_mmap_type_update_flag |= WM_GIZMOMAPTYPE_GLOBAL_UPDATE_INIT; + wm_gzmap_type_update_flag |= WM_GIZMOMAPTYPE_GLOBAL_UPDATE_INIT; } void WM_gizmoconfig_update_tag_remove( - wmGizmoMapType *mmap_type, wmGizmoGroupType *wgt) + wmGizmoMapType *gzmap_type, wmGizmoGroupType *gzgt) { /* tag for update on next use */ - mmap_type->type_update_flag |= WM_GIZMOMAPTYPE_UPDATE_REMOVE; - wgt->type_update_flag |= WM_GIZMOMAPTYPE_UPDATE_REMOVE; + gzmap_type->type_update_flag |= WM_GIZMOMAPTYPE_UPDATE_REMOVE; + gzgt->type_update_flag |= WM_GIZMOMAPTYPE_UPDATE_REMOVE; - wm_mmap_type_update_flag |= WM_GIZMOMAPTYPE_GLOBAL_UPDATE_REMOVE; + wm_gzmap_type_update_flag |= WM_GIZMOMAPTYPE_GLOBAL_UPDATE_REMOVE; } /** @@ -1151,58 +1176,58 @@ void WM_gizmoconfig_update(struct Main *bmain) if (G.background) return; - if (wm_mmap_type_update_flag == 0) + if (wm_gzmap_type_update_flag == 0) return; - if (wm_mmap_type_update_flag & WM_GIZMOMAPTYPE_GLOBAL_UPDATE_REMOVE) { - for (wmGizmoMapType *mmap_type = gizmomaptypes.first; - mmap_type; - mmap_type = mmap_type->next) + if (wm_gzmap_type_update_flag & WM_GIZMOMAPTYPE_GLOBAL_UPDATE_REMOVE) { + for (wmGizmoMapType *gzmap_type = gizmomaptypes.first; + gzmap_type; + gzmap_type = gzmap_type->next) { - if (mmap_type->type_update_flag & WM_GIZMOMAPTYPE_GLOBAL_UPDATE_REMOVE) { - mmap_type->type_update_flag &= ~WM_GIZMOMAPTYPE_UPDATE_REMOVE; - for (wmGizmoGroupTypeRef *wgt_ref = mmap_type->grouptype_refs.first, *wgt_ref_next; - wgt_ref; - wgt_ref = wgt_ref_next) + if (gzmap_type->type_update_flag & WM_GIZMOMAPTYPE_GLOBAL_UPDATE_REMOVE) { + gzmap_type->type_update_flag &= ~WM_GIZMOMAPTYPE_UPDATE_REMOVE; + for (wmGizmoGroupTypeRef *gzgt_ref = gzmap_type->grouptype_refs.first, *gzgt_ref_next; + gzgt_ref; + gzgt_ref = gzgt_ref_next) { - wgt_ref_next = wgt_ref->next; - if (wgt_ref->type->type_update_flag & WM_GIZMOMAPTYPE_UPDATE_REMOVE) { - wgt_ref->type->type_update_flag &= ~WM_GIZMOMAPTYPE_UPDATE_REMOVE; - WM_gizmomaptype_group_unlink(NULL, bmain, mmap_type, wgt_ref->type); + gzgt_ref_next = gzgt_ref->next; + if (gzgt_ref->type->type_update_flag & WM_GIZMOMAPTYPE_UPDATE_REMOVE) { + gzgt_ref->type->type_update_flag &= ~WM_GIZMOMAPTYPE_UPDATE_REMOVE; + WM_gizmomaptype_group_unlink(NULL, bmain, gzmap_type, gzgt_ref->type); } } } } - wm_mmap_type_update_flag &= ~WM_GIZMOMAPTYPE_GLOBAL_UPDATE_REMOVE; + wm_gzmap_type_update_flag &= ~WM_GIZMOMAPTYPE_GLOBAL_UPDATE_REMOVE; } - if (wm_mmap_type_update_flag & WM_GIZMOMAPTYPE_GLOBAL_UPDATE_INIT) { - for (wmGizmoMapType *mmap_type = gizmomaptypes.first; - mmap_type; - mmap_type = mmap_type->next) + if (wm_gzmap_type_update_flag & WM_GIZMOMAPTYPE_GLOBAL_UPDATE_INIT) { + for (wmGizmoMapType *gzmap_type = gizmomaptypes.first; + gzmap_type; + gzmap_type = gzmap_type->next) { const uchar type_update_all = WM_GIZMOMAPTYPE_UPDATE_INIT | WM_GIZMOMAPTYPE_KEYMAP_INIT; - if (mmap_type->type_update_flag & type_update_all) { - mmap_type->type_update_flag &= ~type_update_all; - for (wmGizmoGroupTypeRef *wgt_ref = mmap_type->grouptype_refs.first; - wgt_ref; - wgt_ref = wgt_ref->next) + if (gzmap_type->type_update_flag & type_update_all) { + gzmap_type->type_update_flag &= ~type_update_all; + for (wmGizmoGroupTypeRef *gzgt_ref = gzmap_type->grouptype_refs.first; + gzgt_ref; + gzgt_ref = gzgt_ref->next) { - if (wgt_ref->type->type_update_flag & WM_GIZMOMAPTYPE_KEYMAP_INIT) { - WM_gizmomaptype_group_init_runtime_keymap(bmain, wgt_ref->type); - wgt_ref->type->type_update_flag &= ~WM_GIZMOMAPTYPE_KEYMAP_INIT; + if (gzgt_ref->type->type_update_flag & WM_GIZMOMAPTYPE_KEYMAP_INIT) { + WM_gizmomaptype_group_init_runtime_keymap(bmain, gzgt_ref->type); + gzgt_ref->type->type_update_flag &= ~WM_GIZMOMAPTYPE_KEYMAP_INIT; } - if (wgt_ref->type->type_update_flag & WM_GIZMOMAPTYPE_UPDATE_INIT) { - WM_gizmomaptype_group_init_runtime(bmain, mmap_type, wgt_ref->type); - wgt_ref->type->type_update_flag &= ~WM_GIZMOMAPTYPE_UPDATE_INIT; + if (gzgt_ref->type->type_update_flag & WM_GIZMOMAPTYPE_UPDATE_INIT) { + WM_gizmomaptype_group_init_runtime(bmain, gzmap_type, gzgt_ref->type); + gzgt_ref->type->type_update_flag &= ~WM_GIZMOMAPTYPE_UPDATE_INIT; } } } } - wm_mmap_type_update_flag &= ~WM_GIZMOMAPTYPE_GLOBAL_UPDATE_INIT; + wm_gzmap_type_update_flag &= ~WM_GIZMOMAPTYPE_GLOBAL_UPDATE_INIT; } } diff --git a/source/blender/windowmanager/gizmo/intern/wm_gizmo_target_props.c b/source/blender/windowmanager/gizmo/intern/wm_gizmo_target_props.c index f3df001af55..601c54b8be5 100644 --- a/source/blender/windowmanager/gizmo/intern/wm_gizmo_target_props.c +++ b/source/blender/windowmanager/gizmo/intern/wm_gizmo_target_props.c @@ -51,30 +51,30 @@ /** \name Property Definition * \{ */ -BLI_INLINE wmGizmoProperty *wm_gizmo_target_property_array(wmGizmo *mpr) +BLI_INLINE wmGizmoProperty *wm_gizmo_target_property_array(wmGizmo *gz) { - return (wmGizmoProperty *)(POINTER_OFFSET(mpr, mpr->type->struct_size)); + return (wmGizmoProperty *)(POINTER_OFFSET(gz, gz->type->struct_size)); } -wmGizmoProperty *WM_gizmo_target_property_array(wmGizmo *mpr) +wmGizmoProperty *WM_gizmo_target_property_array(wmGizmo *gz) { - return wm_gizmo_target_property_array(mpr); + return wm_gizmo_target_property_array(gz); } -wmGizmoProperty *WM_gizmo_target_property_at_index(wmGizmo *mpr, int index) +wmGizmoProperty *WM_gizmo_target_property_at_index(wmGizmo *gz, int index) { - BLI_assert(index < mpr->type->target_property_defs_len); + BLI_assert(index < gz->type->target_property_defs_len); BLI_assert(index != -1); - wmGizmoProperty *mpr_prop_array = wm_gizmo_target_property_array(mpr); - return &mpr_prop_array[index]; + wmGizmoProperty *gz_prop_array = wm_gizmo_target_property_array(gz); + return &gz_prop_array[index]; } -wmGizmoProperty *WM_gizmo_target_property_find(wmGizmo *mpr, const char *idname) +wmGizmoProperty *WM_gizmo_target_property_find(wmGizmo *gz, const char *idname) { int index = BLI_findstringindex( - &mpr->type->target_property_defs, idname, offsetof(wmGizmoPropertyType, idname)); + &gz->type->target_property_defs, idname, offsetof(wmGizmoPropertyType, idname)); if (index != -1) { - return WM_gizmo_target_property_at_index(mpr, index); + return WM_gizmo_target_property_at_index(gz, index); } else { return NULL; @@ -82,84 +82,84 @@ wmGizmoProperty *WM_gizmo_target_property_find(wmGizmo *mpr, const char *idname) } void WM_gizmo_target_property_def_rna_ptr( - wmGizmo *mpr, const wmGizmoPropertyType *mpr_prop_type, + wmGizmo *gz, const wmGizmoPropertyType *gz_prop_type, PointerRNA *ptr, PropertyRNA *prop, int index) { - wmGizmoProperty *mpr_prop = WM_gizmo_target_property_at_index(mpr, mpr_prop_type->index_in_type); + wmGizmoProperty *gz_prop = WM_gizmo_target_property_at_index(gz, gz_prop_type->index_in_type); /* if gizmo evokes an operator we cannot use it for property manipulation */ - BLI_assert(mpr->op_data == NULL); + BLI_assert(gz->op_data == NULL); - mpr_prop->type = mpr_prop_type; + gz_prop->type = gz_prop_type; - mpr_prop->ptr = *ptr; - mpr_prop->prop = prop; - mpr_prop->index = index; + gz_prop->ptr = *ptr; + gz_prop->prop = prop; + gz_prop->index = index; - if (mpr->type->property_update) { - mpr->type->property_update(mpr, mpr_prop); + if (gz->type->property_update) { + gz->type->property_update(gz, gz_prop); } } void WM_gizmo_target_property_def_rna( - wmGizmo *mpr, const char *idname, + wmGizmo *gz, const char *idname, PointerRNA *ptr, const char *propname, int index) { - const wmGizmoPropertyType *mpr_prop_type = WM_gizmotype_target_property_find(mpr->type, idname); + const wmGizmoPropertyType *gz_prop_type = WM_gizmotype_target_property_find(gz->type, idname); PropertyRNA *prop = RNA_struct_find_property(ptr, propname); - WM_gizmo_target_property_def_rna_ptr(mpr, mpr_prop_type, ptr, prop, index); + WM_gizmo_target_property_def_rna_ptr(gz, gz_prop_type, ptr, prop, index); } void WM_gizmo_target_property_def_func_ptr( - wmGizmo *mpr, const wmGizmoPropertyType *mpr_prop_type, + wmGizmo *gz, const wmGizmoPropertyType *gz_prop_type, const wmGizmoPropertyFnParams *params) { - wmGizmoProperty *mpr_prop = WM_gizmo_target_property_at_index(mpr, mpr_prop_type->index_in_type); + wmGizmoProperty *gz_prop = WM_gizmo_target_property_at_index(gz, gz_prop_type->index_in_type); /* if gizmo evokes an operator we cannot use it for property manipulation */ - BLI_assert(mpr->op_data == NULL); + BLI_assert(gz->op_data == NULL); - mpr_prop->type = mpr_prop_type; + gz_prop->type = gz_prop_type; - mpr_prop->custom_func.value_get_fn = params->value_get_fn; - mpr_prop->custom_func.value_set_fn = params->value_set_fn; - mpr_prop->custom_func.range_get_fn = params->range_get_fn; - mpr_prop->custom_func.free_fn = params->free_fn; - mpr_prop->custom_func.user_data = params->user_data; + gz_prop->custom_func.value_get_fn = params->value_get_fn; + gz_prop->custom_func.value_set_fn = params->value_set_fn; + gz_prop->custom_func.range_get_fn = params->range_get_fn; + gz_prop->custom_func.free_fn = params->free_fn; + gz_prop->custom_func.user_data = params->user_data; - if (mpr->type->property_update) { - mpr->type->property_update(mpr, mpr_prop); + if (gz->type->property_update) { + gz->type->property_update(gz, gz_prop); } } void WM_gizmo_target_property_def_func( - wmGizmo *mpr, const char *idname, + wmGizmo *gz, const char *idname, const wmGizmoPropertyFnParams *params) { - const wmGizmoPropertyType *mpr_prop_type = WM_gizmotype_target_property_find(mpr->type, idname); - WM_gizmo_target_property_def_func_ptr(mpr, mpr_prop_type, params); + const wmGizmoPropertyType *gz_prop_type = WM_gizmotype_target_property_find(gz->type, idname); + WM_gizmo_target_property_def_func_ptr(gz, gz_prop_type, params); } void WM_gizmo_target_property_clear_rna_ptr( - wmGizmo *mpr, const wmGizmoPropertyType *mpr_prop_type) + wmGizmo *gz, const wmGizmoPropertyType *gz_prop_type) { - wmGizmoProperty *mpr_prop = WM_gizmo_target_property_at_index(mpr, mpr_prop_type->index_in_type); + wmGizmoProperty *gz_prop = WM_gizmo_target_property_at_index(gz, gz_prop_type->index_in_type); /* if gizmo evokes an operator we cannot use it for property manipulation */ - BLI_assert(mpr->op_data == NULL); + BLI_assert(gz->op_data == NULL); - mpr_prop->type = NULL; + gz_prop->type = NULL; - mpr_prop->ptr = PointerRNA_NULL; - mpr_prop->prop = NULL; - mpr_prop->index = -1; + gz_prop->ptr = PointerRNA_NULL; + gz_prop->prop = NULL; + gz_prop->index = -1; } void WM_gizmo_target_property_clear_rna( - wmGizmo *mpr, const char *idname) + wmGizmo *gz, const char *idname) { - const wmGizmoPropertyType *mpr_prop_type = WM_gizmotype_target_property_find(mpr->type, idname); - WM_gizmo_target_property_clear_rna_ptr(mpr, mpr_prop_type); + const wmGizmoPropertyType *gz_prop_type = WM_gizmotype_target_property_find(gz->type, idname); + WM_gizmo_target_property_clear_rna_ptr(gz, gz_prop_type); } @@ -171,93 +171,93 @@ void WM_gizmo_target_property_clear_rna( /** \name Property Access * \{ */ -bool WM_gizmo_target_property_is_valid_any(wmGizmo *mpr) +bool WM_gizmo_target_property_is_valid_any(wmGizmo *gz) { - wmGizmoProperty *mpr_prop_array = wm_gizmo_target_property_array(mpr); - for (int i = 0; i < mpr->type->target_property_defs_len; i++) { - wmGizmoProperty *mpr_prop = &mpr_prop_array[i]; - if (WM_gizmo_target_property_is_valid(mpr_prop)) { + wmGizmoProperty *gz_prop_array = wm_gizmo_target_property_array(gz); + for (int i = 0; i < gz->type->target_property_defs_len; i++) { + wmGizmoProperty *gz_prop = &gz_prop_array[i]; + if (WM_gizmo_target_property_is_valid(gz_prop)) { return true; } } return false; } -bool WM_gizmo_target_property_is_valid(const wmGizmoProperty *mpr_prop) +bool WM_gizmo_target_property_is_valid(const wmGizmoProperty *gz_prop) { - return ((mpr_prop->prop != NULL) || - (mpr_prop->custom_func.value_get_fn && mpr_prop->custom_func.value_set_fn)); + return ((gz_prop->prop != NULL) || + (gz_prop->custom_func.value_get_fn && gz_prop->custom_func.value_set_fn)); } float WM_gizmo_target_property_value_get( - const wmGizmo *mpr, wmGizmoProperty *mpr_prop) + const wmGizmo *gz, wmGizmoProperty *gz_prop) { - if (mpr_prop->custom_func.value_get_fn) { + if (gz_prop->custom_func.value_get_fn) { float value = 0.0f; - BLI_assert(mpr_prop->type->array_length == 1); - mpr_prop->custom_func.value_get_fn(mpr, mpr_prop, &value); + BLI_assert(gz_prop->type->array_length == 1); + gz_prop->custom_func.value_get_fn(gz, gz_prop, &value); return value; } - if (mpr_prop->index == -1) { - return RNA_property_float_get(&mpr_prop->ptr, mpr_prop->prop); + if (gz_prop->index == -1) { + return RNA_property_float_get(&gz_prop->ptr, gz_prop->prop); } else { - return RNA_property_float_get_index(&mpr_prop->ptr, mpr_prop->prop, mpr_prop->index); + return RNA_property_float_get_index(&gz_prop->ptr, gz_prop->prop, gz_prop->index); } } void WM_gizmo_target_property_value_set( - bContext *C, const wmGizmo *mpr, - wmGizmoProperty *mpr_prop, const float value) + bContext *C, const wmGizmo *gz, + wmGizmoProperty *gz_prop, const float value) { - if (mpr_prop->custom_func.value_set_fn) { - BLI_assert(mpr_prop->type->array_length == 1); - mpr_prop->custom_func.value_set_fn(mpr, mpr_prop, &value); + if (gz_prop->custom_func.value_set_fn) { + BLI_assert(gz_prop->type->array_length == 1); + gz_prop->custom_func.value_set_fn(gz, gz_prop, &value); return; } /* reset property */ - if (mpr_prop->index == -1) { - RNA_property_float_set(&mpr_prop->ptr, mpr_prop->prop, value); + if (gz_prop->index == -1) { + RNA_property_float_set(&gz_prop->ptr, gz_prop->prop, value); } else { - RNA_property_float_set_index(&mpr_prop->ptr, mpr_prop->prop, mpr_prop->index, value); + RNA_property_float_set_index(&gz_prop->ptr, gz_prop->prop, gz_prop->index, value); } - RNA_property_update(C, &mpr_prop->ptr, mpr_prop->prop); + RNA_property_update(C, &gz_prop->ptr, gz_prop->prop); } void WM_gizmo_target_property_value_get_array( - const wmGizmo *mpr, wmGizmoProperty *mpr_prop, + const wmGizmo *gz, wmGizmoProperty *gz_prop, float *value) { - if (mpr_prop->custom_func.value_get_fn) { - mpr_prop->custom_func.value_get_fn(mpr, mpr_prop, value); + if (gz_prop->custom_func.value_get_fn) { + gz_prop->custom_func.value_get_fn(gz, gz_prop, value); return; } - RNA_property_float_get_array(&mpr_prop->ptr, mpr_prop->prop, value); + RNA_property_float_get_array(&gz_prop->ptr, gz_prop->prop, value); } void WM_gizmo_target_property_value_set_array( - bContext *C, const wmGizmo *mpr, wmGizmoProperty *mpr_prop, + bContext *C, const wmGizmo *gz, wmGizmoProperty *gz_prop, const float *value) { - if (mpr_prop->custom_func.value_set_fn) { - mpr_prop->custom_func.value_set_fn(mpr, mpr_prop, value); + if (gz_prop->custom_func.value_set_fn) { + gz_prop->custom_func.value_set_fn(gz, gz_prop, value); return; } - RNA_property_float_set_array(&mpr_prop->ptr, mpr_prop->prop, value); + RNA_property_float_set_array(&gz_prop->ptr, gz_prop->prop, value); - RNA_property_update(C, &mpr_prop->ptr, mpr_prop->prop); + RNA_property_update(C, &gz_prop->ptr, gz_prop->prop); } bool WM_gizmo_target_property_range_get( - const wmGizmo *mpr, wmGizmoProperty *mpr_prop, + const wmGizmo *gz, wmGizmoProperty *gz_prop, float range[2]) { - if (mpr_prop->custom_func.value_get_fn) { - if (mpr_prop->custom_func.range_get_fn) { - mpr_prop->custom_func.range_get_fn(mpr, mpr_prop, range); + if (gz_prop->custom_func.value_get_fn) { + if (gz_prop->custom_func.range_get_fn) { + gz_prop->custom_func.range_get_fn(gz, gz_prop, range); return true; } else { @@ -267,17 +267,17 @@ bool WM_gizmo_target_property_range_get( } float step, precision; - RNA_property_float_ui_range(&mpr_prop->ptr, mpr_prop->prop, &range[0], &range[1], &step, &precision); + RNA_property_float_ui_range(&gz_prop->ptr, gz_prop->prop, &range[0], &range[1], &step, &precision); return true; } int WM_gizmo_target_property_array_length( - const wmGizmo *UNUSED(mpr), wmGizmoProperty *mpr_prop) + const wmGizmo *UNUSED(gz), wmGizmoProperty *gz_prop) { - if (mpr_prop->custom_func.value_get_fn) { - return mpr_prop->type->array_length; + if (gz_prop->custom_func.value_get_fn) { + return gz_prop->type->array_length; } - return RNA_property_array_length(&mpr_prop->ptr, mpr_prop->prop); + return RNA_property_array_length(&gz_prop->ptr, gz_prop->prop); } /** \} */ @@ -289,26 +289,26 @@ int WM_gizmo_target_property_array_length( * \{ */ const wmGizmoPropertyType *WM_gizmotype_target_property_find( - const wmGizmoType *wt, const char *idname) + const wmGizmoType *gzt, const char *idname) { - return BLI_findstring(&wt->target_property_defs, idname, offsetof(wmGizmoPropertyType, idname)); + return BLI_findstring(&gzt->target_property_defs, idname, offsetof(wmGizmoPropertyType, idname)); } void WM_gizmotype_target_property_def( - wmGizmoType *wt, const char *idname, int data_type, int array_length) + wmGizmoType *gzt, const char *idname, int data_type, int array_length) { wmGizmoPropertyType *mpt; - BLI_assert(WM_gizmotype_target_property_find(wt, idname) == NULL); + BLI_assert(WM_gizmotype_target_property_find(gzt, idname) == NULL); const uint idname_size = strlen(idname) + 1; mpt = MEM_callocN(sizeof(wmGizmoPropertyType) + idname_size, __func__); memcpy(mpt->idname, idname, idname_size); mpt->data_type = data_type; mpt->array_length = array_length; - mpt->index_in_type = wt->target_property_defs_len; - wt->target_property_defs_len += 1; - BLI_addtail(&wt->target_property_defs, mpt); + mpt->index_in_type = gzt->target_property_defs_len; + gzt->target_property_defs_len += 1; + BLI_addtail(&gzt->target_property_defs, mpt); } /** \} */ @@ -322,10 +322,10 @@ void WM_gizmo_do_msg_notify_tag_refresh( bContext *UNUSED(C), wmMsgSubscribeKey *UNUSED(msg_key), wmMsgSubscribeValue *msg_val) { ARegion *ar = msg_val->owner; - wmGizmoMap *mmap = msg_val->user_data; + wmGizmoMap *gzmap = msg_val->user_data; ED_region_tag_redraw(ar); - WM_gizmomap_tag_refresh(mmap); + WM_gizmomap_tag_refresh(gzmap); } /** @@ -333,26 +333,26 @@ void WM_gizmo_do_msg_notify_tag_refresh( * drawing the region clears. */ void WM_gizmo_target_property_subscribe_all( - wmGizmo *mpr, struct wmMsgBus *mbus, ARegion *ar) + wmGizmo *gz, struct wmMsgBus *mbus, ARegion *ar) { - if (mpr->type->target_property_defs_len) { - wmGizmoProperty *mpr_prop_array = WM_gizmo_target_property_array(mpr); - for (int i = 0; i < mpr->type->target_property_defs_len; i++) { - wmGizmoProperty *mpr_prop = &mpr_prop_array[i]; - if (WM_gizmo_target_property_is_valid(mpr_prop)) { - if (mpr_prop->prop) { + if (gz->type->target_property_defs_len) { + wmGizmoProperty *gz_prop_array = WM_gizmo_target_property_array(gz); + for (int i = 0; i < gz->type->target_property_defs_len; i++) { + wmGizmoProperty *gz_prop = &gz_prop_array[i]; + if (WM_gizmo_target_property_is_valid(gz_prop)) { + if (gz_prop->prop) { WM_msg_subscribe_rna( - mbus, &mpr_prop->ptr, mpr_prop->prop, + mbus, &gz_prop->ptr, gz_prop->prop, &(const wmMsgSubscribeValue){ .owner = ar, .user_data = ar, .notify = ED_region_do_msg_notify_tag_redraw, }, __func__); WM_msg_subscribe_rna( - mbus, &mpr_prop->ptr, mpr_prop->prop, + mbus, &gz_prop->ptr, gz_prop->prop, &(const wmMsgSubscribeValue){ .owner = ar, - .user_data = mpr->parent_mgroup->parent_mmap, + .user_data = gz->parent_gzgroup->parent_gzmap, .notify = WM_gizmo_do_msg_notify_tag_refresh, }, __func__); } diff --git a/source/blender/windowmanager/gizmo/intern/wm_gizmo_type.c b/source/blender/windowmanager/gizmo/intern/wm_gizmo_type.c index ba145af9582..2ff0148044c 100644 --- a/source/blender/windowmanager/gizmo/intern/wm_gizmo_type.c +++ b/source/blender/windowmanager/gizmo/intern/wm_gizmo_type.c @@ -62,11 +62,11 @@ static GHash *global_gizmotype_hash = NULL; const wmGizmoType *WM_gizmotype_find(const char *idname, bool quiet) { if (idname[0]) { - wmGizmoType *wt; + wmGizmoType *gzt; - wt = BLI_ghash_lookup(global_gizmotype_hash, idname); - if (wt) { - return wt; + gzt = BLI_ghash_lookup(global_gizmotype_hash, idname); + if (gzt) { + return gzt; } if (!quiet) { @@ -90,56 +90,56 @@ void WM_gizmotype_iter(GHashIterator *ghi) static wmGizmoType *wm_gizmotype_append__begin(void) { - wmGizmoType *wt = MEM_callocN(sizeof(wmGizmoType), "gizmotype"); - wt->srna = RNA_def_struct_ptr(&BLENDER_RNA, "", &RNA_GizmoProperties); + wmGizmoType *gzt = MEM_callocN(sizeof(wmGizmoType), "gizmotype"); + gzt->srna = RNA_def_struct_ptr(&BLENDER_RNA, "", &RNA_GizmoProperties); #if 0 /* Set the default i18n context now, so that opfunc can redefine it if needed! */ RNA_def_struct_translation_context(ot->srna, BLT_I18NCONTEXT_OPERATOR_DEFAULT); ot->translation_context = BLT_I18NCONTEXT_OPERATOR_DEFAULT; #endif - return wt; + return gzt; } -static void wm_gizmotype_append__end(wmGizmoType *wt) +static void wm_gizmotype_append__end(wmGizmoType *gzt) { - BLI_assert(wt->struct_size >= sizeof(wmGizmo)); + BLI_assert(gzt->struct_size >= sizeof(wmGizmo)); - RNA_def_struct_identifier(&BLENDER_RNA, wt->srna, wt->idname); + RNA_def_struct_identifier(&BLENDER_RNA, gzt->srna, gzt->idname); - BLI_ghash_insert(global_gizmotype_hash, (void *)wt->idname, wt); + BLI_ghash_insert(global_gizmotype_hash, (void *)gzt->idname, gzt); } -void WM_gizmotype_append(void (*wtfunc)(struct wmGizmoType *)) +void WM_gizmotype_append(void (*gtfunc)(struct wmGizmoType *)) { - wmGizmoType *wt = wm_gizmotype_append__begin(); - wtfunc(wt); - wm_gizmotype_append__end(wt); + wmGizmoType *gzt = wm_gizmotype_append__begin(); + gtfunc(gzt); + wm_gizmotype_append__end(gzt); } -void WM_gizmotype_append_ptr(void (*wtfunc)(struct wmGizmoType *, void *), void *userdata) +void WM_gizmotype_append_ptr(void (*gtfunc)(struct wmGizmoType *, void *), void *userdata) { wmGizmoType *mt = wm_gizmotype_append__begin(); - wtfunc(mt, userdata); + gtfunc(mt, userdata); wm_gizmotype_append__end(mt); } /** * Free but don't remove from ghash. */ -static void gizmotype_free(wmGizmoType *wt) +static void gizmotype_free(wmGizmoType *gzt) { - if (wt->ext.srna) { /* python gizmo, allocs own string */ - MEM_freeN((void *)wt->idname); + if (gzt->ext.srna) { /* python gizmo, allocs own string */ + MEM_freeN((void *)gzt->idname); } - BLI_freelistN(&wt->target_property_defs); - MEM_freeN(wt); + BLI_freelistN(&gzt->target_property_defs); + MEM_freeN(gzt); } /** * \param C: May be NULL. */ static void gizmotype_unlink( - bContext *C, Main *bmain, wmGizmoType *wt) + bContext *C, Main *bmain, wmGizmoType *gzt) { /* Free instances. */ for (bScreen *sc = bmain->screen.first; sc; sc = sc->id.next) { @@ -147,15 +147,15 @@ static void gizmotype_unlink( for (SpaceLink *sl = sa->spacedata.first; sl; sl = sl->next) { ListBase *lb = (sl == sa->spacedata.first) ? &sa->regionbase : &sl->regionbase; for (ARegion *ar = lb->first; ar; ar = ar->next) { - wmGizmoMap *mmap = ar->gizmo_map; - if (mmap) { - wmGizmoGroup *mgroup; - for (mgroup = mmap->groups.first; mgroup; mgroup = mgroup->next) { - for (wmGizmo *mpr = mgroup->gizmos.first, *mpr_next; mpr; mpr = mpr_next) { - mpr_next = mpr->next; - BLI_assert(mgroup->parent_mmap == mmap); - if (mpr->type == wt) { - WM_gizmo_unlink(&mgroup->gizmos, mgroup->parent_mmap, mpr, C); + wmGizmoMap *gzmap = ar->gizmo_map; + if (gzmap) { + wmGizmoGroup *gzgroup; + for (gzgroup = gzmap->groups.first; gzgroup; gzgroup = gzgroup->next) { + for (wmGizmo *gz = gzgroup->gizmos.first, *gz_next; gz; gz = gz_next) { + gz_next = gz->next; + BLI_assert(gzgroup->parent_gzmap == gzmap); + if (gz->type == gzt) { + WM_gizmo_unlink(&gzgroup->gizmos, gzgroup->parent_gzmap, gz, C); ED_region_tag_redraw(ar); } } @@ -167,26 +167,26 @@ static void gizmotype_unlink( } } -void WM_gizmotype_remove_ptr(bContext *C, Main *bmain, wmGizmoType *wt) +void WM_gizmotype_remove_ptr(bContext *C, Main *bmain, wmGizmoType *gzt) { - BLI_assert(wt == WM_gizmotype_find(wt->idname, false)); + BLI_assert(gzt == WM_gizmotype_find(gzt->idname, false)); - BLI_ghash_remove(global_gizmotype_hash, wt->idname, NULL, NULL); + BLI_ghash_remove(global_gizmotype_hash, gzt->idname, NULL, NULL); - gizmotype_unlink(C, bmain, wt); + gizmotype_unlink(C, bmain, gzt); - gizmotype_free(wt); + gizmotype_free(gzt); } bool WM_gizmotype_remove(bContext *C, Main *bmain, const char *idname) { - wmGizmoType *wt = BLI_ghash_lookup(global_gizmotype_hash, idname); + wmGizmoType *gzt = BLI_ghash_lookup(global_gizmotype_hash, idname); - if (wt == NULL) { + if (gzt == NULL) { return false; } - WM_gizmotype_remove_ptr(C, bmain, wt); + WM_gizmotype_remove_ptr(C, bmain, gzt); return true; } diff --git a/source/blender/windowmanager/gizmo/wm_gizmo_fn.h b/source/blender/windowmanager/gizmo/wm_gizmo_fn.h index a94f1e994e9..88065a0fcd5 100644 --- a/source/blender/windowmanager/gizmo/wm_gizmo_fn.h +++ b/source/blender/windowmanager/gizmo/wm_gizmo_fn.h @@ -51,7 +51,7 @@ typedef void (*wmGizmoGroupFnMsgBusSubscribe)( typedef void (*wmGizmoFnSetup)(struct wmGizmo *); typedef void (*wmGizmoFnDraw)(const struct bContext *, struct wmGizmo *); typedef void (*wmGizmoFnDrawSelect)(const struct bContext *, struct wmGizmo *, int); -typedef int (*wmGizmoFnTestSelect)(struct bContext *, struct wmGizmo *, const struct wmEvent *); +typedef int (*wmGizmoFnTestSelect)(struct bContext *, struct wmGizmo *, const int mval[2]); typedef int (*wmGizmoFnModal)(struct bContext *, struct wmGizmo *, const struct wmEvent *, eWM_GizmoFlagTweak); typedef void (*wmGizmoFnPropertyUpdate)(struct wmGizmo *, struct wmGizmoProperty *); typedef void (*wmGizmoFnMatrixBasisGet)(const struct wmGizmo *, float[4][4]); diff --git a/source/blender/windowmanager/gizmo/wm_gizmo_wmapi.h b/source/blender/windowmanager/gizmo/wm_gizmo_wmapi.h index 5b1085db4a1..414109e89e5 100644 --- a/source/blender/windowmanager/gizmo/wm_gizmo_wmapi.h +++ b/source/blender/windowmanager/gizmo/wm_gizmo_wmapi.h @@ -61,12 +61,12 @@ void wm_gizmogrouptype_init(void); void GIZMOGROUP_OT_gizmo_select(struct wmOperatorType *ot); void GIZMOGROUP_OT_gizmo_tweak(struct wmOperatorType *ot); -bool wm_gizmogroup_is_any_selected(const struct wmGizmoGroup *mgroup); +bool wm_gizmogroup_is_any_selected(const struct wmGizmoGroup *gzgroup); /* -------------------------------------------------------------------- */ /* wmGizmoMap */ -void wm_gizmomap_remove(struct wmGizmoMap *mmap); +void wm_gizmomap_remove(struct wmGizmoMap *gzmap); void wm_gizmos_keymap(struct wmKeyConfig *keyconf); @@ -75,19 +75,19 @@ void wm_gizmomaps_handled_modal_update( void wm_gizmomap_handler_context(bContext *C, struct wmEventHandler *handler); struct wmGizmo *wm_gizmomap_highlight_find( - struct wmGizmoMap *mmap, bContext *C, const struct wmEvent *event, + struct wmGizmoMap *gzmap, bContext *C, const struct wmEvent *event, int *r_part); bool wm_gizmomap_highlight_set( - struct wmGizmoMap *mmap, const bContext *C, - struct wmGizmo *mpr, int part); -struct wmGizmo *wm_gizmomap_highlight_get(struct wmGizmoMap *mmap); + struct wmGizmoMap *gzmap, const bContext *C, + struct wmGizmo *gz, int part); +struct wmGizmo *wm_gizmomap_highlight_get(struct wmGizmoMap *gzmap); void wm_gizmomap_modal_set( - struct wmGizmoMap *mmap, bContext *C, struct wmGizmo *mpr, + struct wmGizmoMap *gzmap, bContext *C, struct wmGizmo *gz, const struct wmEvent *event, bool enable); -struct wmGizmo *wm_gizmomap_modal_get(struct wmGizmoMap *mmap); -struct wmGizmo **wm_gizmomap_selected_get(wmGizmoMap *mmap, int *r_selected_len); -struct ListBase *wm_gizmomap_groups_get(wmGizmoMap *mmap); +struct wmGizmo *wm_gizmomap_modal_get(struct wmGizmoMap *gzmap); +struct wmGizmo **wm_gizmomap_selected_get(wmGizmoMap *gzmap, int *r_selected_len); +struct ListBase *wm_gizmomap_groups_get(wmGizmoMap *gzmap); /* -------------------------------------------------------------------- */ /* wmGizmoMapType */ |