Esempio n. 1
0
void ED_operatormacros_armature(void)
{
	wmOperatorType *ot;
	wmOperatorTypeMacro *otmacro;

	ot = WM_operatortype_append_macro("ARMATURE_OT_duplicate_move", "Duplicate",
	                                  "Make copies of the selected bones within the same armature and move them",
	                                  OPTYPE_UNDO | OPTYPE_REGISTER);
	WM_operatortype_macro_define(ot, "ARMATURE_OT_duplicate");
	otmacro = WM_operatortype_macro_define(ot, "TRANSFORM_OT_translate");
	RNA_enum_set(otmacro->ptr, "proportional", 0);

	ot = WM_operatortype_append_macro("ARMATURE_OT_extrude_move", "Extrude",
	                                  "Create new bones from the selected joints and move them",
	                                  OPTYPE_UNDO | OPTYPE_REGISTER);
	otmacro = WM_operatortype_macro_define(ot, "ARMATURE_OT_extrude");
	RNA_boolean_set(otmacro->ptr, "forked", FALSE);
	otmacro = WM_operatortype_macro_define(ot, "TRANSFORM_OT_translate");
	RNA_enum_set(otmacro->ptr, "proportional", 0);

	/* XXX would it be nicer to just be able to have standard extrude_move, but set the forked property separate?
	 * that would require fixing a properties bug 19733 */
	ot = WM_operatortype_append_macro("ARMATURE_OT_extrude_forked", "Extrude Forked",
	                                  "Create new bones from the selected joints and move them",
	                                  OPTYPE_UNDO | OPTYPE_REGISTER);
	otmacro = WM_operatortype_macro_define(ot, "ARMATURE_OT_extrude");
	RNA_boolean_set(otmacro->ptr, "forked", TRUE);
	otmacro = WM_operatortype_macro_define(ot, "TRANSFORM_OT_translate");
	RNA_enum_set(otmacro->ptr, "proportional", 0);
}
Esempio n. 2
0
void ED_operatormacros_object(void)
{
    wmOperatorType *ot;
    wmOperatorTypeMacro *otmacro;

    ot= WM_operatortype_append_macro("OBJECT_OT_duplicate_move", "Duplicate Objects", OPTYPE_UNDO|OPTYPE_REGISTER);
    if(ot) {
        WM_operatortype_macro_define(ot, "OBJECT_OT_duplicate");
        otmacro= WM_operatortype_macro_define(ot, "TRANSFORM_OT_translate");
        RNA_enum_set(otmacro->ptr, "proportional", PROP_EDIT_OFF);
    }

    /* grr, should be able to pass options on... */
    ot= WM_operatortype_append_macro("OBJECT_OT_duplicate_move_linked", "Duplicate Linked", OPTYPE_UNDO|OPTYPE_REGISTER);
    if(ot) {
        otmacro= WM_operatortype_macro_define(ot, "OBJECT_OT_duplicate");
        RNA_boolean_set(otmacro->ptr, "linked", 1);
        otmacro= WM_operatortype_macro_define(ot, "TRANSFORM_OT_translate");
        RNA_enum_set(otmacro->ptr, "proportional", PROP_EDIT_OFF);
    }

    /* XXX */
    ot= WM_operatortype_append_macro("OBJECT_OT_add_named_cursor", "Add named object at cursor", OPTYPE_UNDO|OPTYPE_REGISTER);
    if(ot) {
        RNA_def_string(ot->srna, "name", "Cube", 24, "Name", "Object name to add.");

        WM_operatortype_macro_define(ot, "VIEW3D_OT_cursor3d");
        WM_operatortype_macro_define(ot, "OBJECT_OT_add_named");
    }
}
Esempio n. 3
0
void ED_operatormacros_armature(void)
{
	wmOperatorType *ot;
	wmOperatorTypeMacro *otmacro;
	
	ot= WM_operatortype_append_macro("ARMATURE_OT_duplicate_move", "Duplicate", OPTYPE_UNDO|OPTYPE_REGISTER);
	if(ot) {
		WM_operatortype_macro_define(ot, "ARMATURE_OT_duplicate");
		otmacro= WM_operatortype_macro_define(ot, "TRANSFORM_OT_translate");
		RNA_enum_set(otmacro->ptr, "proportional", 0);
	}

	ot= WM_operatortype_append_macro("ARMATURE_OT_extrude_move", "Extrude", OPTYPE_UNDO|OPTYPE_REGISTER);
	if(ot) {
		otmacro=WM_operatortype_macro_define(ot, "ARMATURE_OT_extrude");
		RNA_boolean_set(otmacro->ptr, "forked", 0);
		otmacro= WM_operatortype_macro_define(ot, "TRANSFORM_OT_translate");
		RNA_enum_set(otmacro->ptr, "proportional", 0);
	}
	
	// XXX would it be nicer to just be able to have standard extrude_move, but set the forked property separate?
	// that would require fixing a properties bug 19733
	ot= WM_operatortype_append_macro("ARMATURE_OT_extrude_forked", "Extrude Forked", OPTYPE_UNDO|OPTYPE_REGISTER);
	if(ot) {
		otmacro=WM_operatortype_macro_define(ot, "ARMATURE_OT_extrude");
		RNA_boolean_set(otmacro->ptr, "forked", 1);
		otmacro= WM_operatortype_macro_define(ot, "TRANSFORM_OT_translate");
		RNA_enum_set(otmacro->ptr, "proportional", 0);
	}
}
Esempio n. 4
0
void ED_operatormacros_mask(void)
{
	wmOperatorType *ot;
	wmOperatorTypeMacro *otmacro;

	ot = WM_operatortype_append_macro("MASK_OT_add_vertex_slide", "Add Vertex and Slide",
	                                  "Add new vertex and slide it", OPTYPE_UNDO | OPTYPE_REGISTER);
	ot->description = "Add new vertex and slide it";
	WM_operatortype_macro_define(ot, "MASK_OT_add_vertex");
	otmacro = WM_operatortype_macro_define(ot, "TRANSFORM_OT_translate");
	RNA_boolean_set(otmacro->ptr, "release_confirm", TRUE);

	ot = WM_operatortype_append_macro("MASK_OT_add_feather_vertex_slide", "Add Feather Vertex and Slide",
	                                  "Add new vertex to feather and slide it", OPTYPE_UNDO | OPTYPE_REGISTER);
	ot->description = "Add new feather vertex and slide it";
	WM_operatortype_macro_define(ot, "MASK_OT_add_feather_vertex");
	otmacro = WM_operatortype_macro_define(ot, "MASK_OT_slide_point");
	RNA_boolean_set(otmacro->ptr, "slide_feather", TRUE);

	ot = WM_operatortype_append_macro("MASK_OT_duplicate_move", "Add Duplicate", "Duplicate mask and move",
	                                  OPTYPE_UNDO | OPTYPE_REGISTER);
	WM_operatortype_macro_define(ot, "MASK_OT_duplicate");
	otmacro = WM_operatortype_macro_define(ot, "TRANSFORM_OT_translate");
	RNA_enum_set(otmacro->ptr, "proportional", 0);
	RNA_boolean_set(otmacro->ptr, "mirror", FALSE);
}
Esempio n. 5
0
void ED_operatormacros_clip(void)
{
	wmOperatorType *ot;
	wmOperatorTypeMacro *otmacro;

	ot = WM_operatortype_append_macro("CLIP_OT_add_marker_move", "Add Marker and Move",
	                                  "Add new marker and move it on movie", OPTYPE_UNDO | OPTYPE_REGISTER);
	WM_operatortype_macro_define(ot, "CLIP_OT_add_marker");
	otmacro = WM_operatortype_macro_define(ot, "TRANSFORM_OT_translate");
	RNA_struct_idprops_unset(otmacro->ptr, "release_confirm");

	ot = WM_operatortype_append_macro("CLIP_OT_add_marker_slide", "Add Marker and Slide",
	                                  "Add new marker and slide it with mouse until mouse button release",
	                                  OPTYPE_UNDO | OPTYPE_REGISTER);
	WM_operatortype_macro_define(ot, "CLIP_OT_add_marker");
	otmacro = WM_operatortype_macro_define(ot, "TRANSFORM_OT_translate");
	RNA_boolean_set(otmacro->ptr, "release_confirm", TRUE);
}
Esempio n. 6
0
void ED_operatormacros_sequencer(void)
{
	wmOperatorType *ot;

	ot = WM_operatortype_append_macro("SEQUENCER_OT_duplicate_move", "Duplicate Strips",
	                                  "Duplicate selected strips and move them", OPTYPE_UNDO | OPTYPE_REGISTER);

	WM_operatortype_macro_define(ot, "SEQUENCER_OT_duplicate");
	WM_operatortype_macro_define(ot, "TRANSFORM_OT_seq_slide");
}
Esempio n. 7
0
void ED_operatormacros_curve(void)
{
	wmOperatorType *ot;
	wmOperatorTypeMacro *otmacro;

	ot = WM_operatortype_append_macro("CURVE_OT_duplicate_move", "Add Duplicate", "Duplicate curve and move",
	                                  OPTYPE_UNDO | OPTYPE_REGISTER);
	WM_operatortype_macro_define(ot, "CURVE_OT_duplicate");
	otmacro = WM_operatortype_macro_define(ot, "TRANSFORM_OT_translate");
	RNA_enum_set(otmacro->ptr, "proportional", 0);
	RNA_boolean_set(otmacro->ptr, "mirror", FALSE);

	ot = WM_operatortype_append_macro("CURVE_OT_extrude_move", "Extrude Curve and Move",
	                                  "Extrude curve and move result", OPTYPE_UNDO | OPTYPE_REGISTER);
	WM_operatortype_macro_define(ot, "CURVE_OT_extrude");
	otmacro = WM_operatortype_macro_define(ot, "TRANSFORM_OT_translate");
	RNA_enum_set(otmacro->ptr, "proportional", 0);
	RNA_boolean_set(otmacro->ptr, "mirror", FALSE);
}
Esempio n. 8
0
void ED_operatormacros_node(void)
{
	wmOperatorType *ot;
	wmOperatorTypeMacro *mot;
	
	ot= WM_operatortype_append_macro("NODE_OT_duplicate_move", "Duplicate", OPTYPE_UNDO|OPTYPE_REGISTER);
	WM_operatortype_macro_define(ot, "NODE_OT_duplicate");
	WM_operatortype_macro_define(ot, "TRANSFORM_OT_translate");

	/* modified operator call for duplicating with input links */
	ot= WM_operatortype_append_macro("NODE_OT_duplicate_move_keep_inputs", "Duplicate", OPTYPE_UNDO|OPTYPE_REGISTER);
	mot = WM_operatortype_macro_define(ot, "NODE_OT_duplicate");
		RNA_boolean_set(mot->ptr, "keep_inputs", 1);
	WM_operatortype_macro_define(ot, "TRANSFORM_OT_translate");

	ot= WM_operatortype_append_macro("NODE_OT_select_link_viewer", "Link Viewer", OPTYPE_UNDO);
	WM_operatortype_macro_define(ot, "NODE_OT_select");
	WM_operatortype_macro_define(ot, "NODE_OT_link_viewer");
	}
Esempio n. 9
0
void ED_operatormacros_mesh(void)
{
    wmOperatorType *ot;
    wmOperatorTypeMacro *otmacro;

    ot= WM_operatortype_append_macro("MESH_OT_loopcut_slide", "Loop Cut and Slide", OPTYPE_UNDO|OPTYPE_REGISTER);
    ot->description = "Cut mesh loop and slide it";
    WM_operatortype_macro_define(ot, "MESH_OT_loopcut");
    otmacro= WM_operatortype_macro_define(ot, "TRANSFORM_OT_edge_slide");
    RNA_struct_idprops_unset(otmacro->ptr, "release_confirm");

    ot= WM_operatortype_append_macro("MESH_OT_duplicate_move", "Add Duplicate", OPTYPE_UNDO|OPTYPE_REGISTER);
    ot->description = "Duplicate mesh and move";
    WM_operatortype_macro_define(ot, "MESH_OT_duplicate");
    otmacro= WM_operatortype_macro_define(ot, "TRANSFORM_OT_translate");
    RNA_enum_set(otmacro->ptr, "proportional", 0);
    RNA_boolean_set(otmacro->ptr, "mirror", 0);

    ot= WM_operatortype_append_macro("MESH_OT_rip_move", "Rip", OPTYPE_UNDO|OPTYPE_REGISTER);
    ot->description = "Rip polygons and move the result";
    WM_operatortype_macro_define(ot, "MESH_OT_rip");
    otmacro= WM_operatortype_macro_define(ot, "TRANSFORM_OT_translate");
    RNA_enum_set(otmacro->ptr, "proportional", 0);
    RNA_boolean_set(otmacro->ptr, "mirror", 0);

    ot= WM_operatortype_append_macro("MESH_OT_extrude_region_move", "Extrude Region and Move", OPTYPE_UNDO|OPTYPE_REGISTER);
    ot->description = "Extrude region and move result";
    otmacro= WM_operatortype_macro_define(ot, "MESH_OT_extrude");
    RNA_enum_set(otmacro->ptr, "type", 1);
    otmacro= WM_operatortype_macro_define(ot, "TRANSFORM_OT_translate");
    RNA_enum_set(otmacro->ptr, "proportional", 0);
    RNA_boolean_set(otmacro->ptr, "mirror", 0);

    ot= WM_operatortype_append_macro("MESH_OT_extrude_faces_move", "Extrude Individual Faces and Move", OPTYPE_UNDO|OPTYPE_REGISTER);
    ot->description = "Extrude faces and move result";
    otmacro= WM_operatortype_macro_define(ot, "MESH_OT_extrude");
    RNA_enum_set(otmacro->ptr, "type", 2);
    otmacro= WM_operatortype_macro_define(ot, "TRANSFORM_OT_shrink_fatten");
    RNA_enum_set(otmacro->ptr, "proportional", 0);
    RNA_boolean_set(otmacro->ptr, "mirror", 0);

    ot= WM_operatortype_append_macro("MESH_OT_extrude_edges_move", "Extrude Only Edges and Move", OPTYPE_UNDO|OPTYPE_REGISTER);
    ot->description = "Extrude edges and move result";
    otmacro= WM_operatortype_macro_define(ot, "MESH_OT_extrude");
    RNA_enum_set(otmacro->ptr, "type", 3);
    otmacro= WM_operatortype_macro_define(ot, "TRANSFORM_OT_translate");
    RNA_enum_set(otmacro->ptr, "proportional", 0);
    RNA_boolean_set(otmacro->ptr, "mirror", 0);

    ot= WM_operatortype_append_macro("MESH_OT_extrude_vertices_move", "Extrude Only Vertices and Move", OPTYPE_UNDO|OPTYPE_REGISTER);
    ot->description = "Extrude vertices and move result";
    otmacro= WM_operatortype_macro_define(ot, "MESH_OT_extrude");
    RNA_enum_set(otmacro->ptr, "type", 4);
    otmacro= WM_operatortype_macro_define(ot, "TRANSFORM_OT_translate");
    RNA_enum_set(otmacro->ptr, "proportional", 0);
    RNA_boolean_set(otmacro->ptr, "mirror", 0);
}
Esempio n. 10
0
void ED_operatormacros_graph(void)
{
	wmOperatorType *ot;
	wmOperatorTypeMacro *otmacro;
	
	ot = WM_operatortype_append_macro("GRAPH_OT_duplicate_move", "Duplicate",
	                                  "Make a copy of all selected keyframes and move them",
	                                  OPTYPE_UNDO | OPTYPE_REGISTER);
	WM_operatortype_macro_define(ot, "GRAPH_OT_duplicate");
	otmacro = WM_operatortype_macro_define(ot, "TRANSFORM_OT_transform");
	RNA_enum_set(otmacro->ptr, "mode", TFM_TIME_DUPLICATE);
}
Esempio n. 11
0
void ED_operatormacros_metaball(void)
{
    wmOperatorType *ot;
    wmOperatorTypeMacro *otmacro;

    ot = WM_operatortype_append_macro("MBALL_OT_duplicate_move", "Duplicate",
                                      "Make copies of the selected bones within the same armature and move them",
                                      OPTYPE_UNDO | OPTYPE_REGISTER);
    WM_operatortype_macro_define(ot, "MBALL_OT_duplicate_metaelems");
    otmacro = WM_operatortype_macro_define(ot, "TRANSFORM_OT_translate");
    RNA_enum_set(otmacro->ptr, "proportional", 0);
}
Esempio n. 12
0
void ED_operatormacros_gpencil(void)
{
	wmOperatorType *ot;
	wmOperatorTypeMacro *otmacro;
	
	ot = WM_operatortype_append_macro("GPENCIL_OT_duplicate_move", "Duplicate Strokes",
	                                  "Duplicate Strokes\nMake copies of the selected Grease Pencil strokes and move them",
	                                  OPTYPE_UNDO | OPTYPE_REGISTER);
	WM_operatortype_macro_define(ot, "GPENCIL_OT_duplicate");
	otmacro = WM_operatortype_macro_define(ot, "TRANSFORM_OT_translate");
	RNA_boolean_set(otmacro->ptr, "gpencil_strokes", true);
}
Esempio n. 13
0
void ED_operatormacros_paint(void)
{
	wmOperatorType *ot;
	wmOperatorTypeMacro *otmacro;

	ot = WM_operatortype_append_macro("PAINTCURVE_OT_add_point_slide", "Add Curve Point and Slide",
	                                  "Add new curve point and slide it", OPTYPE_UNDO);
	ot->description = "Add new curve point and slide it";
	WM_operatortype_macro_define(ot, "PAINTCURVE_OT_add_point");
	otmacro = WM_operatortype_macro_define(ot, "PAINTCURVE_OT_slide");
	RNA_boolean_set(otmacro->ptr, "align", true);
	RNA_boolean_set(otmacro->ptr, "select", false);
}
Esempio n. 14
0
void ED_operatormacros_action(void)
{
	wmOperatorType *ot;
	wmOperatorTypeMacro *otmacro;
	
	ot = WM_operatortype_append_macro("ACTION_OT_duplicate_move", "Duplicate",
	                                  "Duplicate\nMake a copy of all selected keyframes and move them",
	                                  OPTYPE_UNDO | OPTYPE_REGISTER);
	WM_operatortype_macro_define(ot, "ACTION_OT_duplicate");
	otmacro = WM_operatortype_macro_define(ot, "TRANSFORM_OT_transform");
	RNA_enum_set(otmacro->ptr, "mode", TFM_TIME_DUPLICATE);
	RNA_enum_set(otmacro->ptr, "proportional", PROP_EDIT_OFF);
}
Esempio n. 15
0
void ED_operatormacros_node(void)
{
	wmOperatorType *ot;
	wmOperatorTypeMacro *mot;
	
	ot= WM_operatortype_append_macro("NODE_OT_duplicate_move", "Duplicate", OPTYPE_UNDO|OPTYPE_REGISTER);
	ot->description = "Duplicate selected nodes and move them";
	WM_operatortype_macro_define(ot, "NODE_OT_duplicate");
	WM_operatortype_macro_define(ot, "TRANSFORM_OT_translate");

	/* modified operator call for duplicating with input links */
	ot= WM_operatortype_append_macro("NODE_OT_duplicate_move_keep_inputs", "Duplicate", OPTYPE_UNDO|OPTYPE_REGISTER);
	ot->description = "Duplicate selected nodes keeping input links and move them";

	mot = WM_operatortype_macro_define(ot, "NODE_OT_duplicate");
	RNA_boolean_set(mot->ptr, "keep_inputs", TRUE);

	WM_operatortype_macro_define(ot, "TRANSFORM_OT_translate");

	ot= WM_operatortype_append_macro("NODE_OT_select_link_viewer", "Link Viewer", OPTYPE_UNDO);
	ot->description = "Select node and link it to a viewer node";
	WM_operatortype_macro_define(ot, "NODE_OT_select");
	WM_operatortype_macro_define(ot, "NODE_OT_link_viewer");
}
Esempio n. 16
0
void ED_operatormacros_object(void)
{
	wmOperatorType *ot;
	wmOperatorTypeMacro *otmacro;
	
	ot = WM_operatortype_append_macro("OBJECT_OT_duplicate_move", "Duplicate Objects",
	                                  "Duplicate selected objects and move them", OPTYPE_UNDO | OPTYPE_REGISTER);
	if (ot) {
		WM_operatortype_macro_define(ot, "OBJECT_OT_duplicate");
		otmacro = WM_operatortype_macro_define(ot, "TRANSFORM_OT_translate");
		RNA_enum_set(otmacro->ptr, "proportional", PROP_EDIT_OFF);
	}

	/* grr, should be able to pass options on... */
	ot = WM_operatortype_append_macro("OBJECT_OT_duplicate_move_linked", "Duplicate Linked",
	                                  "Duplicate selected objects and move them", OPTYPE_UNDO | OPTYPE_REGISTER);
	if (ot) {
		otmacro = WM_operatortype_macro_define(ot, "OBJECT_OT_duplicate");
		RNA_boolean_set(otmacro->ptr, "linked", true);
		otmacro = WM_operatortype_macro_define(ot, "TRANSFORM_OT_translate");
		RNA_enum_set(otmacro->ptr, "proportional", PROP_EDIT_OFF);
	}
	
}
Esempio n. 17
0
void ED_operatormacros_node(void)
{
	wmOperatorType *ot;
	wmOperatorTypeMacro *mot;
	
	ot = WM_operatortype_append_macro("NODE_OT_select_link_viewer", "Link Viewer",
	                                  "Select node and link it to a viewer node",
	                                  OPTYPE_UNDO);
	WM_operatortype_macro_define(ot, "NODE_OT_select");
	WM_operatortype_macro_define(ot, "NODE_OT_link_viewer");

	ot = WM_operatortype_append_macro("NODE_OT_translate_attach", "Move and Attach",
	                                  "Move nodes and attach to frame",
	                                  OPTYPE_UNDO | OPTYPE_REGISTER);
	mot = WM_operatortype_macro_define(ot, "TRANSFORM_OT_translate");
	RNA_boolean_set(mot->ptr, "release_confirm", TRUE);
	WM_operatortype_macro_define(ot, "NODE_OT_attach");

	ot = WM_operatortype_append_macro("NODE_OT_detach_translate_attach", "Detach and Move",
	                                  "Detach nodes, move and attach to frame",
	                                  OPTYPE_UNDO | OPTYPE_REGISTER);
	WM_operatortype_macro_define(ot, "NODE_OT_detach");
	mot = WM_operatortype_macro_define(ot, "TRANSFORM_OT_translate");
	RNA_boolean_set(mot->ptr, "release_confirm", TRUE);
	WM_operatortype_macro_define(ot, "NODE_OT_attach");

	ot = WM_operatortype_append_macro("NODE_OT_duplicate_move", "Duplicate",
	                                  "Duplicate selected nodes and move them",
	                                  OPTYPE_UNDO | OPTYPE_REGISTER);
	WM_operatortype_macro_define(ot, "NODE_OT_duplicate");
	WM_operatortype_macro_define(ot, "NODE_OT_translate_attach");

	/* modified operator call for duplicating with input links */
	ot = WM_operatortype_append_macro("NODE_OT_duplicate_move_keep_inputs", "Duplicate",
	                                  "Duplicate selected nodes keeping input links and move them",
	                                  OPTYPE_UNDO | OPTYPE_REGISTER);
	mot = WM_operatortype_macro_define(ot, "NODE_OT_duplicate");
	RNA_boolean_set(mot->ptr, "keep_inputs", TRUE);
	WM_operatortype_macro_define(ot, "NODE_OT_translate_attach");

	ot = WM_operatortype_append_macro("NODE_OT_move_detach_links", "Detach", "Move a node to detach links",
	                                  OPTYPE_UNDO | OPTYPE_REGISTER);
	WM_operatortype_macro_define(ot, "NODE_OT_links_detach");
	WM_operatortype_macro_define(ot, "TRANSFORM_OT_translate");

	ot = WM_operatortype_append_macro("NODE_OT_move_detach_links_release", "Detach", "Move a node to detach links",
	                                  OPTYPE_UNDO | OPTYPE_REGISTER);
	WM_operatortype_macro_define(ot, "NODE_OT_links_detach");
	WM_operatortype_macro_define(ot, "NODE_OT_translate_attach");
}
Esempio n. 18
0
void ED_operatormacros_mesh(void)
{
	wmOperatorType *ot;
	wmOperatorTypeMacro *otmacro;
	
	ot = WM_operatortype_append_macro("MESH_OT_loopcut_slide", "Loop Cut and Slide", "Cut mesh loop and slide it",
	                                  OPTYPE_UNDO | OPTYPE_REGISTER);
	WM_operatortype_macro_define(ot, "MESH_OT_loopcut");
	otmacro = WM_operatortype_macro_define(ot, "TRANSFORM_OT_edge_slide");
	RNA_boolean_set(otmacro->ptr, "release_confirm", false);

	ot = WM_operatortype_append_macro("MESH_OT_offset_edge_loops_slide", "Offset Edge Slide", "Offset edge loop slide",
	                                  OPTYPE_UNDO | OPTYPE_REGISTER);
	WM_operatortype_macro_define(ot, "MESH_OT_offset_edge_loops");
	otmacro = WM_operatortype_macro_define(ot, "TRANSFORM_OT_edge_slide");
	RNA_boolean_set(otmacro->ptr, "release_confirm", false);
	RNA_boolean_set(otmacro->ptr, "single_side", true);

	ot = WM_operatortype_append_macro("MESH_OT_duplicate_move", "Add Duplicate", "Duplicate mesh and move",
	                                  OPTYPE_UNDO | OPTYPE_REGISTER);
	WM_operatortype_macro_define(ot, "MESH_OT_duplicate");
	otmacro = WM_operatortype_macro_define(ot, "TRANSFORM_OT_translate");
	RNA_enum_set(otmacro->ptr, "proportional", 0);
	RNA_boolean_set(otmacro->ptr, "mirror", false);

	ot = WM_operatortype_append_macro("MESH_OT_rip_move", "Rip", "Rip polygons and move the result",
	                                  OPTYPE_UNDO | OPTYPE_REGISTER);
	otmacro = WM_operatortype_macro_define(ot, "MESH_OT_rip");
	RNA_boolean_set(otmacro->ptr, "use_fill", false);
	otmacro = WM_operatortype_macro_define(ot, "TRANSFORM_OT_translate");
	RNA_enum_set(otmacro->ptr, "proportional", 0);
	RNA_boolean_set(otmacro->ptr, "mirror", false);

	/* annoying we can't pass 'use_fill' through the macro */
	ot = WM_operatortype_append_macro("MESH_OT_rip_move_fill", "Rip Fill", "Rip-fill polygons and move the result",
	                                  OPTYPE_UNDO | OPTYPE_REGISTER);
	otmacro = WM_operatortype_macro_define(ot, "MESH_OT_rip");
	RNA_boolean_set(otmacro->ptr, "use_fill", true);
	otmacro = WM_operatortype_macro_define(ot, "TRANSFORM_OT_translate");
	RNA_enum_set(otmacro->ptr, "proportional", 0);
	RNA_boolean_set(otmacro->ptr, "mirror", false);

	ot = WM_operatortype_append_macro("MESH_OT_rip_edge_move", "Extend Vertices", "Extend vertices and move the result",
	                                  OPTYPE_UNDO | OPTYPE_REGISTER);
	WM_operatortype_macro_define(ot, "MESH_OT_rip_edge");
	otmacro = WM_operatortype_macro_define(ot, "TRANSFORM_OT_translate");
	RNA_enum_set(otmacro->ptr, "proportional", 0);
	RNA_boolean_set(otmacro->ptr, "mirror", false);

	ot = WM_operatortype_append_macro("MESH_OT_extrude_region_move", "Extrude Region and Move",
	                                  "Extrude region and move result", OPTYPE_UNDO | OPTYPE_REGISTER);
	otmacro = WM_operatortype_macro_define(ot, "MESH_OT_extrude_region");
	otmacro = WM_operatortype_macro_define(ot, "TRANSFORM_OT_translate");
	RNA_enum_set(otmacro->ptr, "proportional", 0);
	RNA_boolean_set(otmacro->ptr, "mirror", false);

	ot = WM_operatortype_append_macro("MESH_OT_extrude_region_shrink_fatten", "Extrude Region and Shrink/Fatten",
	                                  "Extrude region and move result", OPTYPE_UNDO | OPTYPE_REGISTER);
	otmacro = WM_operatortype_macro_define(ot, "MESH_OT_extrude_region");
	otmacro = WM_operatortype_macro_define(ot, "TRANSFORM_OT_shrink_fatten");
	RNA_enum_set(otmacro->ptr, "proportional", 0);
	RNA_boolean_set(otmacro->ptr, "mirror", false);

	ot = WM_operatortype_append_macro("MESH_OT_extrude_faces_move", "Extrude Individual Faces and Move",
	                                  "Extrude faces and move result", OPTYPE_UNDO | OPTYPE_REGISTER);
	otmacro = WM_operatortype_macro_define(ot, "MESH_OT_extrude_faces_indiv");
	otmacro = WM_operatortype_macro_define(ot, "TRANSFORM_OT_shrink_fatten");
	RNA_enum_set(otmacro->ptr, "proportional", 0);
	RNA_boolean_set(otmacro->ptr, "mirror", false);

	ot = WM_operatortype_append_macro("MESH_OT_extrude_edges_move", "Extrude Only Edges and Move",
	                                  "Extrude edges and move result", OPTYPE_UNDO | OPTYPE_REGISTER);
	otmacro = WM_operatortype_macro_define(ot, "MESH_OT_extrude_edges_indiv");
	otmacro = WM_operatortype_macro_define(ot, "TRANSFORM_OT_translate");
	RNA_enum_set(otmacro->ptr, "proportional", 0);
	RNA_boolean_set(otmacro->ptr, "mirror", false);

	ot = WM_operatortype_append_macro("MESH_OT_extrude_vertices_move", "Extrude Only Vertices and Move",
	                                  "Extrude vertices and move result", OPTYPE_UNDO | OPTYPE_REGISTER);
	otmacro = WM_operatortype_macro_define(ot, "MESH_OT_extrude_verts_indiv");
	otmacro = WM_operatortype_macro_define(ot, "TRANSFORM_OT_translate");
	RNA_enum_set(otmacro->ptr, "proportional", 0);
	RNA_boolean_set(otmacro->ptr, "mirror", false);
}
Esempio n. 19
0
void ED_operatormacros_node(void)
{
    wmOperatorType *ot;
    wmOperatorTypeMacro *mot;

    ot = WM_operatortype_append_macro("NODE_OT_select_link_viewer", "Link Viewer",
                                      "Select node and link it to a viewer node",
                                      OPTYPE_UNDO);
    WM_operatortype_macro_define(ot, "NODE_OT_select");
    WM_operatortype_macro_define(ot, "NODE_OT_link_viewer");

    ot = WM_operatortype_append_macro("NODE_OT_translate_attach", "Move and Attach",
                                      "Move nodes and attach to frame",
                                      OPTYPE_UNDO | OPTYPE_REGISTER);
    mot = WM_operatortype_macro_define(ot, "TRANSFORM_OT_translate");
    RNA_boolean_set(mot->ptr, "release_confirm", true);
    WM_operatortype_macro_define(ot, "NODE_OT_attach");
    WM_operatortype_macro_define(ot, "NODE_OT_insert_offset");

    /* NODE_OT_translate_attach with remove_on_canel set to true */
    ot = WM_operatortype_append_macro("NODE_OT_translate_attach_remove_on_cancel", "Move and Attach",
                                      "Move nodes and attach to frame",
                                      OPTYPE_UNDO | OPTYPE_REGISTER);
    mot = WM_operatortype_macro_define(ot, "TRANSFORM_OT_translate");
    RNA_boolean_set(mot->ptr, "release_confirm", true);
    RNA_boolean_set(mot->ptr, "remove_on_cancel", true);
    WM_operatortype_macro_define(ot, "NODE_OT_attach");
    WM_operatortype_macro_define(ot, "NODE_OT_insert_offset");

    /* Note: Currently not in a default keymap or menu due to messy keymaps
     * and tricky invoke functionality.
     * Kept around in case users want to make own shortcuts.
     */
    ot = WM_operatortype_append_macro("NODE_OT_detach_translate_attach", "Detach and Move",
                                      "Detach nodes, move and attach to frame",
                                      OPTYPE_UNDO | OPTYPE_REGISTER);
    WM_operatortype_macro_define(ot, "NODE_OT_detach");
    mot = WM_operatortype_macro_define(ot, "TRANSFORM_OT_translate");
    RNA_boolean_set(mot->ptr, "release_confirm", true);
    WM_operatortype_macro_define(ot, "NODE_OT_attach");

    ot = WM_operatortype_append_macro("NODE_OT_duplicate_move", "Duplicate",
                                      "Duplicate selected nodes and move them",
                                      OPTYPE_UNDO | OPTYPE_REGISTER);
    WM_operatortype_macro_define(ot, "NODE_OT_duplicate");
    WM_operatortype_macro_define(ot, "NODE_OT_translate_attach");

    /* modified operator call for duplicating with input links */
    ot = WM_operatortype_append_macro("NODE_OT_duplicate_move_keep_inputs", "Duplicate",
                                      "Duplicate selected nodes keeping input links and move them",
                                      OPTYPE_UNDO | OPTYPE_REGISTER);
    mot = WM_operatortype_macro_define(ot, "NODE_OT_duplicate");
    RNA_boolean_set(mot->ptr, "keep_inputs", true);
    WM_operatortype_macro_define(ot, "NODE_OT_translate_attach");

    ot = WM_operatortype_append_macro("NODE_OT_move_detach_links", "Detach", "Move a node to detach links",
                                      OPTYPE_UNDO | OPTYPE_REGISTER);
    WM_operatortype_macro_define(ot, "NODE_OT_links_detach");
    WM_operatortype_macro_define(ot, "TRANSFORM_OT_translate");
    WM_operatortype_macro_define(ot, "NODE_OT_insert_offset");

    ot = WM_operatortype_append_macro("NODE_OT_move_detach_links_release", "Detach", "Move a node to detach links",
                                      OPTYPE_UNDO | OPTYPE_REGISTER);
    WM_operatortype_macro_define(ot, "NODE_OT_links_detach");
    WM_operatortype_macro_define(ot, "NODE_OT_translate_attach");
}