自学教程：C++ CTX_data_edit_mask函数代码示例

/* ********* clear/set restrict view *********/static int mask_hide_view_clear_exec(bContext *C, wmOperator *UNUSED(op)){	Mask *mask = CTX_data_edit_mask(C);	MaskLayer *masklay;	bool changed = false;	for (masklay = mask->masklayers.first; masklay; masklay = masklay->next) {		if (masklay->restrictflag & OB_RESTRICT_VIEW) {			ED_mask_layer_select_set(masklay, TRUE);			masklay->restrictflag &= ~OB_RESTRICT_VIEW;			changed = true;		}	}	if (changed) {		WM_event_add_notifier(C, NC_MASK | ND_DRAW, mask);		DAG_id_tag_update(&mask->id, 0);		return OPERATOR_FINISHED;	}	else {		return OPERATOR_CANCELLED;	}}

static int mask_layer_move_exec(bContext *C, wmOperator *op){	Mask *mask = CTX_data_edit_mask(C);	MaskLayer *mask_layer = BLI_findlink(&mask->masklayers, mask->masklay_act);	MaskLayer *mask_layer_other;	int direction = RNA_enum_get(op->ptr, "direction");	if (!mask_layer)		return OPERATOR_CANCELLED;	if (direction == -1) {		mask_layer_other = mask_layer->prev;		if (!mask_layer_other)			return OPERATOR_CANCELLED;		BLI_remlink(&mask->masklayers, mask_layer);		BLI_insertlinkbefore(&mask->masklayers, mask_layer_other, mask_layer);		mask->masklay_act--;	}	else if (direction == 1) {		mask_layer_other = mask_layer->next;		if (!mask_layer_other)			return OPERATOR_CANCELLED;		BLI_remlink(&mask->masklayers, mask_layer);		BLI_insertlinkafter(&mask->masklayers, mask_layer_other, mask_layer);		mask->masklay_act++;	}	return OPERATOR_FINISHED;}

static int mask_select_linked_exec(bContext *C, wmOperator *UNUSED(op)){	Mask *mask = CTX_data_edit_mask(C);	MaskLayer *masklay;	bool changed = false;	/* do actual selection */	for (masklay = mask->masklayers.first; masklay; masklay = masklay->next) {		MaskSpline *spline;		if (masklay->restrictflag & (MASK_RESTRICT_VIEW | MASK_RESTRICT_SELECT)) {			continue;		}		for (spline = masklay->splines.first; spline; spline = spline->next) {			if (ED_mask_spline_select_check(spline)) {				ED_mask_spline_select_set(spline, true);				changed = true;			}		}	}	if (changed) {		ED_mask_select_flush_all(mask);		WM_event_add_notifier(C, NC_MASK | ND_SELECT, mask);		return OPERATOR_FINISHED;	}	return OPERATOR_CANCELLED;}

static int mask_shape_key_insert_exec(bContext *C, wmOperator *UNUSED(op)){	Scene *scene = CTX_data_scene(C);	const int frame = CFRA;	Mask *mask = CTX_data_edit_mask(C);	MaskLayer *masklay;	bool changed = false;	for (masklay = mask->masklayers.first; masklay; masklay = masklay->next) {		MaskLayerShape *masklay_shape;		if (!ED_mask_layer_select_check(masklay)) {			continue;		}		masklay_shape = BKE_mask_layer_shape_verify_frame(masklay, frame);		BKE_mask_layer_shape_from_mask(masklay, masklay_shape);		changed = true;	}	if (changed) {		WM_event_add_notifier(C, NC_MASK | ND_DATA, mask);		DAG_id_tag_update(&mask->id, 0);		return OPERATOR_FINISHED;	}	else {		return OPERATOR_CANCELLED;	}}

static int set_handle_type_exec(bContext *C, wmOperator *op){	Mask *mask = CTX_data_edit_mask(C);	MaskLayer *masklay;	int handle_type = RNA_enum_get(op->ptr, "type");	for (masklay = mask->masklayers.first; masklay; masklay = masklay->next) {		MaskSpline *spline;		int i;		if (masklay->restrictflag & (MASK_RESTRICT_VIEW | MASK_RESTRICT_SELECT)) {			continue;		}		for (spline = masklay->splines.first; spline; spline = spline->next) {			for (i = 0; i < spline->tot_point; i++) {				MaskSplinePoint *point = &spline->points[i];				if (MASKPOINT_ISSEL_ANY(point)) {					BezTriple *bezt = &point->bezt;					bezt->h1 = bezt->h2 = handle_type;				}			}		}	}	WM_event_add_notifier(C, NC_MASK | ND_DATA, mask);	DAG_id_tag_update(&mask->id, 0);	return OPERATOR_FINISHED;}

static bool do_lasso_select_mask(bContext *C, const int mcords[][2], short moves, short select){	ScrArea *sa = CTX_wm_area(C);	ARegion *ar = CTX_wm_region(C);	Mask *mask = CTX_data_edit_mask(C);	MaskLayer *masklay;	int i;	rcti rect;	bool changed = false;	/* get rectangle from operator */	BLI_lasso_boundbox(&rect, mcords, moves);	/* do actual selection */	for (masklay = mask->masklayers.first; masklay; masklay = masklay->next) {		MaskSpline *spline;		if (masklay->restrictflag & (MASK_RESTRICT_VIEW | MASK_RESTRICT_SELECT)) {			continue;		}		for (spline = masklay->splines.first; spline; spline = spline->next) {			MaskSplinePoint *points_array = BKE_mask_spline_point_array(spline);			for (i = 0; i < spline->tot_point; i++) {				MaskSplinePoint *point = &spline->points[i];				MaskSplinePoint *point_deform = &points_array[i];				/* TODO: handles? */				/* TODO: uw? */				float screen_co[2];				/* point in screen coords */				ED_mask_point_pos__reverse(sa, ar,				                           point_deform->bezt.vec[1][0], point_deform->bezt.vec[1][1],				                           &screen_co[0], &screen_co[1]);				if (BLI_rcti_isect_pt(&rect, screen_co[0], screen_co[1]) &&				    BLI_lasso_is_point_inside(mcords, moves, screen_co[0], screen_co[1], INT_MAX))				{					BKE_mask_point_select_set(point, select);					BKE_mask_point_select_set_handle(point, MASK_WHICH_HANDLE_BOTH, select);				}				changed = true;			}		}	}	if (changed) {		ED_mask_select_flush_all(mask);		WM_event_add_notifier(C, NC_MASK | ND_SELECT, mask);	}	return changed;}

static int mask_parent_clear_exec(bContext *C, wmOperator *UNUSED(op)){	Mask *mask = CTX_data_edit_mask(C);	MaskLayer *masklay;	for (masklay = mask->masklayers.first; masklay; masklay = masklay->next) {		MaskSpline *spline;		int i;		if (masklay->restrictflag & (MASK_RESTRICT_VIEW | MASK_RESTRICT_SELECT)) {			continue;		}		for (spline = masklay->splines.first; spline; spline = spline->next) {			for (i = 0; i < spline->tot_point; i++) {				MaskSplinePoint *point = &spline->points[i];				if (MASKPOINT_ISSEL_ANY(point)) {					point->parent.id = NULL;				}			}		}	}	WM_event_add_notifier(C, NC_MASK | ND_DATA, mask);	DAG_id_tag_update(&mask->id, 0);	return OPERATOR_FINISHED;}

static int mask_shape_key_clear_exec(bContext *C, wmOperator *UNUSED(op)){	Scene *scene = CTX_data_scene(C);	const int frame = CFRA;	Mask *mask = CTX_data_edit_mask(C);	MaskLayer *masklay;	int change = FALSE;	for (masklay = mask->masklayers.first; masklay; masklay = masklay->next) {		MaskLayerShape *masklay_shape;		if (!ED_mask_layer_select_check(masklay)) {			continue;		}		masklay_shape = BKE_mask_layer_shape_find_frame(masklay, frame);		if (masklay_shape) {			BKE_mask_layer_shape_unlink(masklay, masklay_shape);			change = TRUE;		}	}	if (change) {		WM_event_add_notifier(C, NC_MASK | ND_DATA, mask);		DAG_id_tag_update(&mask->id, OB_RECALC_DATA);		return OPERATOR_FINISHED;	}	else {		return OPERATOR_CANCELLED;	}}

static int create_primitive_from_points(bContext *C, wmOperator *op, const float (*points)[2],                                        int num_points, char handle_type){	ScrArea *sa = CTX_wm_area(C);	Scene *scene = CTX_data_scene(C);	Mask *mask;	MaskLayer *mask_layer;	MaskSpline *new_spline;	float scale, location[2], frame_size[2];	int i, width, height;	int size = RNA_float_get(op->ptr, "size");	ED_mask_get_size(sa, &width, &height);	scale = (float)size / max_ii(width, height);	/* Get location in mask space. */	frame_size[0] = width;	frame_size[1] = height;	RNA_float_get_array(op->ptr, "location", location);	location[0] /= width;	location[1] /= height;	BKE_mask_coord_from_frame(location, location, frame_size);	/* Make it so new primitive is centered to mouse location. */	location[0] -= 0.5f * scale;	location[1] -= 0.5f * scale;	mask_layer = ED_mask_layer_ensure(C);	mask = CTX_data_edit_mask(C);	ED_mask_select_toggle_all(mask, SEL_DESELECT);	new_spline = BKE_mask_spline_add(mask_layer);	new_spline->flag = MASK_SPLINE_CYCLIC | SELECT;	new_spline->tot_point = num_points;	new_spline->points = MEM_recallocN(new_spline->points,	                                   sizeof(MaskSplinePoint) * new_spline->tot_point);	mask_layer->act_spline = new_spline;	mask_layer->act_point = NULL;	for (i = 0; i < num_points; i++) {		MaskSplinePoint *new_point = &new_spline->points[i];		copy_v2_v2(new_point->bezt.vec[1], points[i]);		mul_v2_fl(new_point->bezt.vec[1], scale);		add_v2_v2(new_point->bezt.vec[1], location);		new_point->bezt.h1 = handle_type;		new_point->bezt.h2 = handle_type;		BKE_mask_point_select_set(new_point, true);	}	WM_event_add_notifier(C, NC_MASK | NA_EDITED, mask);	/* TODO: only update this spline */	BKE_mask_update_display(mask, CFRA);	return OPERATOR_FINISHED;}

static int copy_splines_exec(bContext *C, wmOperator *UNUSED(op)){	Mask *mask = CTX_data_edit_mask(C);	MaskLayer *mask_layer = BKE_mask_layer_active(mask);	BKE_mask_clipboard_copy_from_layer(mask_layer);	return OPERATOR_FINISHED;}

static int mask_layer_move_poll(bContext *C){	if (ED_maskedit_mask_poll(C)) {		Mask *mask = CTX_data_edit_mask(C);		return mask->masklay_tot > 0;	}	return FALSE;}

static int select_all_exec(bContext *C, wmOperator *op){	Mask *mask = CTX_data_edit_mask(C);	int action = RNA_enum_get(op->ptr, "action");	ED_mask_select_toggle_all(mask, action);	ED_mask_select_flush_all(mask);	WM_event_add_notifier(C, NC_MASK | ND_SELECT, mask);	return OPERATOR_FINISHED;}

static int masklay_remove_exec(bContext *C, wmOperator *UNUSED(op)){	Mask *mask = CTX_data_edit_mask(C);	MaskLayer *masklay = BKE_mask_layer_active(mask);	if (masklay) {		BKE_mask_layer_remove(mask, masklay);		WM_event_add_notifier(C, NC_MASK | NA_EDITED, mask);	}	return OPERATOR_FINISHED;}

static int masklay_new_exec(bContext *C, wmOperator *op){	Mask *mask = CTX_data_edit_mask(C);	char name[MAX_ID_NAME - 2];	RNA_string_get(op->ptr, "name", name);	BKE_mask_layer_new(mask, name);	mask->masklay_act = mask->masklay_tot - 1;	WM_event_add_notifier(C, NC_MASK | NA_EDITED, mask);	return OPERATOR_FINISHED;}

/* *** recalc normals *** */static int mask_normals_make_consistent_exec(bContext *C, wmOperator *UNUSED(op)){	Scene *scene = CTX_data_scene(C);	Mask *mask = CTX_data_edit_mask(C);	MaskLayer *masklay;	int i;	bool changed = false;	/* do actual selection */	for (masklay = mask->masklayers.first; masklay; masklay = masklay->next) {		MaskSpline *spline;		bool changed_layer = false;		if (masklay->restrictflag & (MASK_RESTRICT_VIEW | MASK_RESTRICT_SELECT)) {			continue;		}		for (spline = masklay->splines.first; spline; spline = spline->next) {			for (i = 0; i < spline->tot_point; i++) {				MaskSplinePoint *point = &spline->points[i];				if (MASKPOINT_ISSEL_ANY(point)) {					BKE_mask_calc_handle_point_auto(spline, point, FALSE);					changed = true;					changed_layer = true;				}			}		}		if (changed_layer) {			if (IS_AUTOKEY_ON(scene)) {				ED_mask_layer_shape_auto_key(masklay, CFRA);			}		}	}	if (changed) {		/* TODO: only update this spline */		BKE_mask_update_display(mask, CFRA);		WM_event_add_notifier(C, NC_MASK | ND_SELECT, mask);		WM_event_add_notifier(C, NC_MASK | NA_EDITED, mask);		return OPERATOR_FINISHED;	}	return OPERATOR_CANCELLED;}

static int paste_splines_exec(bContext *C, wmOperator *UNUSED(op)){	Scene *scene = CTX_data_scene(C);	Mask *mask = CTX_data_edit_mask(C);	MaskLayer *mask_layer = BKE_mask_layer_active(mask);	BKE_mask_clipboard_paste_to_layer(CTX_data_main(C), mask_layer);	/* TODO: only update edited splines */	BKE_mask_update_display(mask, CFRA);	WM_event_add_notifier(C, NC_MASK | NA_EDITED, mask);	return OPERATOR_FINISHED;}

void ED_mask_draw(const bContext *C,                  const char draw_flag, const char draw_type){	ScrArea *sa = CTX_wm_area(C);	Mask *mask = CTX_data_edit_mask(C);	int width, height;	if (!mask)		return;	ED_mask_get_size(sa, &width, &height);	draw_masklays(C, mask, draw_flag, draw_type, width, height);}

static int mask_hide_view_set_exec(bContext *C, wmOperator *op){	Mask *mask = CTX_data_edit_mask(C);	MaskLayer *masklay;	const int unselected = RNA_boolean_get(op->ptr, "unselected");	bool changed = false;	for (masklay = mask->masklayers.first; masklay; masklay = masklay->next) {		if (masklay->restrictflag & MASK_RESTRICT_SELECT) {			continue;		}		if (!unselected) {			if (ED_mask_layer_select_check(masklay)) {				ED_mask_layer_select_set(masklay, FALSE);				masklay->restrictflag |= OB_RESTRICT_VIEW;				changed = true;				if (masklay == BKE_mask_layer_active(mask)) {					BKE_mask_layer_active_set(mask, NULL);				}			}		}		else {			if (!ED_mask_layer_select_check(masklay)) {				masklay->restrictflag |= OB_RESTRICT_VIEW;				changed = true;				if (masklay == BKE_mask_layer_active(mask)) {					BKE_mask_layer_active_set(mask, NULL);				}			}		}	}	if (changed) {		WM_event_add_notifier(C, NC_MASK | ND_DRAW, mask);		DAG_id_tag_update(&mask->id, 0);		return OPERATOR_FINISHED;	}	else {		return OPERATOR_CANCELLED;	}}

/* Get ative layer. Will create mask/layer to be sure there's an active layer.  */MaskLayer *ED_mask_layer_ensure(bContext *C){	Mask *mask = CTX_data_edit_mask(C);	MaskLayer *mask_layer;	if (mask == NULL) {		/* If there's no active mask, create one. */		mask = ED_mask_new(C, NULL);	}	mask_layer = BKE_mask_layer_active(mask);	if (mask_layer == NULL) {		/* If there's no active mask layer, create one. */		mask_layer = BKE_mask_layer_new(mask, "");	}	return mask_layer;}

/* *** switch direction *** */static int mask_switch_direction_exec(bContext *C, wmOperator *UNUSED(op)){	Scene *scene = CTX_data_scene(C);	Mask *mask = CTX_data_edit_mask(C);	MaskLayer *masklay;	bool changed = false;	/* do actual selection */	for (masklay = mask->masklayers.first; masklay; masklay = masklay->next) {		MaskSpline *spline;		bool changed_layer = false;		if (masklay->restrictflag & (MASK_RESTRICT_VIEW | MASK_RESTRICT_SELECT)) {			continue;		}		for (spline = masklay->splines.first; spline; spline = spline->next) {			if (ED_mask_spline_select_check(spline)) {				BKE_mask_spline_direction_switch(masklay, spline);				changed = true;				changed_layer = true;			}		}		if (changed_layer) {			if (IS_AUTOKEY_ON(scene)) {				ED_mask_layer_shape_auto_key(masklay, CFRA);			}		}	}	if (changed) {		/* TODO: only update this spline */		BKE_mask_update_display(mask, CFRA);		WM_event_add_notifier(C, NC_MASK | ND_SELECT, mask);		WM_event_add_notifier(C, NC_MASK | NA_EDITED, mask);		return OPERATOR_FINISHED;	}	return OPERATOR_CANCELLED;}

void ED_mask_draw(const bContext *C,                  const char draw_flag, const char draw_type){	ScrArea *sa = CTX_wm_area(C);	ARegion *ar = CTX_wm_region(C);	Mask *mask = CTX_data_edit_mask(C);	int width, height;	float aspx, aspy;	float xscale, yscale;	if (!mask)		return;	ED_mask_get_size(sa, &width, &height);	ED_mask_get_aspect(sa, ar, &aspx, &aspy);	UI_view2d_scale_get(&ar->v2d, &xscale, &yscale);	draw_masklays(C, mask, draw_flag, draw_type, width, height, xscale * aspx, yscale * aspy);}

static int mask_feather_weight_clear_exec(bContext *C, wmOperator *UNUSED(op)){	Scene *scene = CTX_data_scene(C);	Mask *mask = CTX_data_edit_mask(C);	MaskLayer *masklay;	bool changed = false;	int i;	for (masklay = mask->masklayers.first; masklay; masklay = masklay->next) {		MaskSpline *spline;		if (masklay->restrictflag & (MASK_RESTRICT_SELECT | MASK_RESTRICT_VIEW)) {			continue;		}		for (spline = masklay->splines.first; spline; spline = spline->next) {			for (i = 0; i < spline->tot_point; i++) {				MaskSplinePoint *point = &spline->points[i];				if (MASKPOINT_ISSEL_ANY(point)) {					BezTriple *bezt = &point->bezt;					bezt->weight = 0.0f;					changed = true;				}			}		}	}	if (changed) {		/* TODO: only update edited splines */		BKE_mask_update_display(mask, CFRA);		WM_event_add_notifier(C, NC_MASK | ND_DRAW, mask);		DAG_id_tag_update(&mask->id, 0);		return OPERATOR_FINISHED;	}	else {		return OPERATOR_CANCELLED;	}}

static int slide_point_invoke(bContext *C, wmOperator *op, const wmEvent *event){	SlidePointData *slidedata = slide_point_customdata(C, op, event);	if (slidedata) {		Mask *mask = CTX_data_edit_mask(C);		op->customdata = slidedata;		WM_event_add_modal_handler(C, op);#if 0		if (slidedata->uw) {			if ((slidedata->uw->flag & SELECT) == 0) {				ED_mask_select_toggle_all(mask, SEL_DESELECT);				slidedata->uw->flag |= SELECT;				ED_mask_select_flush_all(mask);			}		}		else if (!MASKPOINT_ISSEL_ANY(slidedata->point)) {			ED_mask_select_toggle_all(mask, SEL_DESELECT);			BKE_mask_point_select_set(slidedata->point, TRUE);			ED_mask_select_flush_all(mask);		}#endif		slidedata->masklay->act_spline = slidedata->spline;		slidedata->masklay->act_point = slidedata->point;		WM_event_add_notifier(C, NC_MASK | ND_SELECT, mask);		return OPERATOR_RUNNING_MODAL;	}	return OPERATOR_PASS_THROUGH;}

static int add_feather_vertex_exec(bContext *C, wmOperator *op){	Mask *mask = CTX_data_edit_mask(C);	MaskLayer *masklay;	MaskSpline *spline;	MaskSplinePoint *point = NULL;	const float threshold = 9;	float co[2], u;	RNA_float_get_array(op->ptr, "location", co);	point = ED_mask_point_find_nearest(C, mask, co, threshold, NULL, NULL, NULL, NULL);	if (point)		return OPERATOR_FINISHED;	if (ED_mask_find_nearest_diff_point(C, mask, co, threshold, true, NULL, true, true,	                                    &masklay, &spline, &point, &u, NULL))	{		Scene *scene = CTX_data_scene(C);		float w = BKE_mask_point_weight(spline, point, u);		float weight_scalar = BKE_mask_point_weight_scalar(spline, point, u);		if (weight_scalar != 0.0f) {			w = w / weight_scalar;		}		BKE_mask_point_add_uw(point, u, w);		BKE_mask_update_display(mask, scene->r.cfra);		WM_event_add_notifier(C, NC_MASK | NA_EDITED, mask);		DAG_id_tag_update(&mask->id, 0);		return OPERATOR_FINISHED;	}	return OPERATOR_CANCELLED;}

static int mask_select_linked_pick_invoke(bContext *C, wmOperator *op, wmEvent *event){	ScrArea *sa = CTX_wm_area(C);	ARegion *ar = CTX_wm_region(C);	Mask *mask = CTX_data_edit_mask(C);	MaskLayer *masklay;	MaskSpline *spline;	MaskSplinePoint *point = NULL;	float co[2];	int do_select = !RNA_boolean_get(op->ptr, "deselect");	int is_handle = 0;	const float threshold = 19;	int change = FALSE;	ED_mask_mouse_pos(sa, ar, event->mval, co);	point = ED_mask_point_find_nearest(C, mask, co, threshold, &masklay, &spline, &is_handle, NULL);	if (point) {		ED_mask_spline_select_set(spline, do_select);		masklay->act_spline = spline;		masklay->act_point = point;		change = TRUE;	}	if (change) {		ED_mask_select_flush_all(mask);		WM_event_add_notifier(C, NC_MASK | ND_SELECT, mask);		return OPERATOR_FINISHED;	}	return OPERATOR_CANCELLED;}

static int cyclic_toggle_exec(bContext *C, wmOperator *UNUSED(op)){	Mask *mask = CTX_data_edit_mask(C);	MaskLayer *masklay;	for (masklay = mask->masklayers.first; masklay; masklay = masklay->next) {		MaskSpline *spline;		if (masklay->restrictflag & (MASK_RESTRICT_VIEW | MASK_RESTRICT_SELECT)) {			continue;		}		for (spline = masklay->splines.first; spline; spline = spline->next) {			if (ED_mask_spline_select_check(spline)) {				spline->flag ^= MASK_SPLINE_CYCLIC;			}		}	}	WM_event_add_notifier(C, NC_MASK | NA_EDITED, mask);	return OPERATOR_FINISHED;}

static int mask_parent_set_exec(bContext *C, wmOperator *UNUSED(op)){	Mask *mask = CTX_data_edit_mask(C);	MaskLayer *masklay;	/* parent info */	SpaceClip *sc = CTX_wm_space_clip(C);	MovieClip *clip = ED_space_clip_get_clip(sc);	MovieTracking *tracking;	MovieTrackingTrack *track;	MovieTrackingPlaneTrack *plane_track;	MovieTrackingObject *tracking_object;	/* done */	int framenr, parent_type;	float parmask_pos[2], orig_corners[4][2];	char *sub_parent_name;	if (ELEM(NULL, sc, clip)) {		return OPERATOR_CANCELLED;	}	framenr = ED_space_clip_get_clip_frame_number(sc);	tracking = &clip->tracking;	tracking_object = BKE_tracking_object_get_active(&clip->tracking);	if (tracking_object == NULL) {		return OPERATOR_CANCELLED;	}	if ((track = BKE_tracking_track_get_active(tracking)) != NULL) {		MovieTrackingMarker *marker = BKE_tracking_marker_get(track, framenr);		float marker_pos_ofs[2];		add_v2_v2v2(marker_pos_ofs, marker->pos, track->offset);		BKE_mask_coord_from_movieclip(clip, &sc->user, parmask_pos, marker_pos_ofs);		sub_parent_name = track->name;		parent_type = MASK_PARENT_POINT_TRACK;		memset(orig_corners, 0, sizeof(orig_corners));	}	else if ((plane_track = BKE_tracking_plane_track_get_active(tracking)) != NULL) {		MovieTrackingPlaneMarker *plane_marker = BKE_tracking_plane_marker_get(plane_track, framenr);		zero_v2(parmask_pos);		sub_parent_name = plane_track->name;		parent_type = MASK_PARENT_PLANE_TRACK;		memcpy(orig_corners, plane_marker->corners, sizeof(orig_corners));	}	else {		return OPERATOR_CANCELLED;	}	for (masklay = mask->masklayers.first; masklay; masklay = masklay->next) {		MaskSpline *spline;		int i;		if (masklay->restrictflag & (MASK_RESTRICT_VIEW | MASK_RESTRICT_SELECT)) {			continue;		}		for (spline = masklay->splines.first; spline; spline = spline->next) {			for (i = 0; i < spline->tot_point; i++) {				MaskSplinePoint *point = &spline->points[i];				if (MASKPOINT_ISSEL_ANY(point)) {					point->parent.id_type = ID_MC;					point->parent.id = &clip->id;					point->parent.type = parent_type;					BLI_strncpy(point->parent.parent, tracking_object->name, sizeof(point->parent.parent));					BLI_strncpy(point->parent.sub_parent, sub_parent_name, sizeof(point->parent.sub_parent));					copy_v2_v2(point->parent.parent_orig, parmask_pos);					memcpy(point->parent.parent_corners_orig, orig_corners, sizeof(point->parent.parent_corners_orig));				}			}		}	}	WM_event_add_notifier(C, NC_MASK | ND_DATA, mask);	DAG_id_tag_update(&mask->id, 0);	return OPERATOR_FINISHED;}

static int delete_exec(bContext *C, wmOperator *UNUSED(op)){	Scene *scene = CTX_data_scene(C);	Mask *mask = CTX_data_edit_mask(C);	MaskLayer *masklay;	bool changed = false;	for (masklay = mask->masklayers.first; masklay; masklay = masklay->next) {		MaskSpline *spline;		int mask_layer_shape_ofs = 0;		if (masklay->restrictflag & (MASK_RESTRICT_VIEW | MASK_RESTRICT_SELECT)) {			continue;		}		spline = masklay->splines.first;		while (spline) {			const int tot_point_orig = spline->tot_point;			int i, count = 0;			MaskSpline *next_spline = spline->next;			/* count unselected points */			for (i = 0; i < spline->tot_point; i++) {				MaskSplinePoint *point = &spline->points[i];				if (!MASKPOINT_ISSEL_ANY(point))					count++;			}			if (count == 0) {				/* delete the whole spline */				BLI_remlink(&masklay->splines, spline);				BKE_mask_spline_free(spline);				if (spline == masklay->act_spline) {					masklay->act_spline = NULL;					masklay->act_point = NULL;				}				BKE_mask_layer_shape_changed_remove(masklay, mask_layer_shape_ofs, tot_point_orig);			}			else {				MaskSplinePoint *new_points;				int j;				new_points = MEM_callocN(count * sizeof(MaskSplinePoint), "deleteMaskPoints");				for (i = 0, j = 0; i < tot_point_orig; i++) {					MaskSplinePoint *point = &spline->points[i];					if (!MASKPOINT_ISSEL_ANY(point)) {						if (point == masklay->act_point)							masklay->act_point = &new_points[j];						delete_feather_points(point);						new_points[j] = *point;						j++;					}					else {						if (point == masklay->act_point)							masklay->act_point = NULL;						BKE_mask_point_free(point);						spline->tot_point--;						BKE_mask_layer_shape_changed_remove(masklay, mask_layer_shape_ofs + j, 1);					}				}				mask_layer_shape_ofs += spline->tot_point;				MEM_freeN(spline->points);				spline->points = new_points;				ED_mask_select_flush_all(mask);			}			changed = true;			spline = next_spline;		}		/* not essential but confuses users when there are keys with no data!		 * assume if they delete all data from the layer they also dont care about keys */		if (masklay->splines.first == NULL) {			BKE_mask_layer_free_shapes(masklay);		}	}	if (!changed) {		return OPERATOR_CANCELLED;	}	/* TODO: only update edited splines */	BKE_mask_update_display(mask, CFRA);	WM_event_add_notifier(C, NC_MASK | NA_EDITED, mask);	return OPERATOR_FINISHED;//.........这里部分代码省略.........

static void *slide_point_customdata(bContext *C, wmOperator *op, const wmEvent *event){	ScrArea *sa = CTX_wm_area(C);	ARegion *ar = CTX_wm_region(C);	Mask *mask = CTX_data_edit_mask(C);	SlidePointData *customdata = NULL;	MaskLayer *masklay, *cv_masklay, *feather_masklay;	MaskSpline *spline, *cv_spline, *feather_spline;	MaskSplinePoint *point, *cv_point, *feather_point;	MaskSplinePointUW *uw = NULL;	int width, height, action = SLIDE_ACTION_NONE;	bool is_handle = false;	const bool slide_feather = RNA_boolean_get(op->ptr, "slide_feather");	float co[2], cv_score, feather_score;	const float threshold = 19;	ED_mask_mouse_pos(sa, ar, event->mval, co);	ED_mask_get_size(sa, &width, &height);	cv_point = ED_mask_point_find_nearest(C, mask, co, threshold, &cv_masklay, &cv_spline, &is_handle, &cv_score);	if (ED_mask_feather_find_nearest(C, mask, co, threshold, &feather_masklay, &feather_spline, &feather_point, &uw, &feather_score)) {		if (slide_feather || !cv_point || feather_score < cv_score) {			action = SLIDE_ACTION_FEATHER;			masklay = feather_masklay;			spline = feather_spline;			point = feather_point;		}	}	if (cv_point && action == SLIDE_ACTION_NONE) {		if (is_handle)			action = SLIDE_ACTION_HANDLE;		else			action = SLIDE_ACTION_POINT;		masklay = cv_masklay;		spline = cv_spline;		point = cv_point;	}	if (action != SLIDE_ACTION_NONE) {		customdata = MEM_callocN(sizeof(SlidePointData), "mask slide point data");		customdata->mask = mask;		customdata->masklay = masklay;		customdata->spline = spline;		customdata->point = point;		customdata->width = width;		customdata->height = height;		customdata->action = action;		customdata->uw = uw;		if (uw) {			float co_uw[2];			float weight_scalar = BKE_mask_point_weight_scalar(spline, point, uw->u);			customdata->weight = uw->w;			customdata->weight_scalar = weight_scalar;			BKE_mask_point_segment_co(spline, point, uw->u, co_uw);			BKE_mask_point_normal(spline, point, uw->u, customdata->no);			madd_v2_v2v2fl(customdata->feather, co_uw, customdata->no, uw->w * weight_scalar);		}		else {			BezTriple *bezt = &point->bezt;			customdata->weight = bezt->weight;			customdata->weight_scalar = 1.0f;			BKE_mask_point_normal(spline, point, 0.0f, customdata->no);			madd_v2_v2v2fl(customdata->feather, bezt->vec[1], customdata->no, bezt->weight);		}		if (customdata->action == SLIDE_ACTION_FEATHER)			customdata->initial_feather = slide_point_check_initial_feather(spline);		copy_m3_m3(customdata->vec, point->bezt.vec);		if (BKE_mask_point_has_handle(point))			BKE_mask_point_handle(point, customdata->handle);		ED_mask_mouse_pos(sa, ar, event->mval, customdata->co);	}	return customdata;}

static int mask_duplicate_exec(bContext *C, wmOperator *UNUSED(op)){	Scene *scene = CTX_data_scene(C);	Mask *mask = CTX_data_edit_mask(C);	MaskLayer *mask_layer = BKE_mask_layer_active(mask);	MaskSpline *spline;	if (mask_layer == NULL) {		return OPERATOR_CANCELLED;	}	for (spline = mask_layer->splines.last;	     spline;	     spline = spline->prev)	{		MaskSplinePoint *point = spline->points;		int i = 0;		while (i < spline->tot_point) {			int start = i, end = -1;			/* Find next selected segment. */			while (MASKPOINT_ISSEL_ANY(point)) {				BKE_mask_point_select_set(point, false);				end = i;				if (i >= spline->tot_point - 1) {					break;				}				i++;				point++;			}			if (end >= start) {				MaskSpline *new_spline = BKE_mask_spline_add(mask_layer);				MaskSplinePoint *new_point;				int b;				/* BKE_mask_spline_add might allocate the points, need to free them in this case. */				if (new_spline->points) {					MEM_freeN(new_spline->points);				}				/* Copy options from old spline. */				new_spline->flag = spline->flag;				new_spline->offset_mode = spline->offset_mode;				new_spline->weight_interp = spline->weight_interp;				new_spline->parent = spline->parent;				/* Allocate new points and copy them from old spline. */				new_spline->tot_point = end - start + 1;				new_spline->points = MEM_mallocN(sizeof(MaskSplinePoint) * new_spline->tot_point,				                                 "duplicated mask points");				memcpy(new_spline->points, spline->points + start,				       new_spline->tot_point * sizeof(MaskSplinePoint));				/* Select points and duplicate their UWs (if needed). */				for (b = 0, new_point = new_spline->points;				     b < new_spline->tot_point;				     b++, new_point++)				{					if (new_point->uw) {						new_point->uw = MEM_dupallocN(new_point->uw);					}					BKE_mask_point_select_set(new_point, true);				}				/* Clear cyclic flag if we didn't copy the whole spline. */				if (new_spline->flag & MASK_SPLINE_CYCLIC) {					if (start != 0 || end != spline->tot_point - 1) {						new_spline->flag &= ~MASK_SPLINE_CYCLIC;					}				}				/* Flush selection to splines. */				new_spline->flag |= SELECT;				spline->flag &= ~SELECT;				mask_layer->act_spline = new_spline;			}			i++;			point++;		}	}	/* TODO: only update edited splines */	BKE_mask_update_display(mask, CFRA);	WM_event_add_notifier(C, NC_MASK | NA_EDITED, mask);	return OPERATOR_FINISHED;}