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

static short paste_action_keys(bAnimContext *ac,                               const eKeyPasteOffset offset_mode, const eKeyMergeMode merge_mode, bool flip){		ListBase anim_data = {NULL, NULL};	int filter, ok = 0;		/* filter data 	 * - First time we try to filter more strictly, allowing only selected channels 	 *   to allow copying animation between channels	 * - Second time, we loosen things up if nothing was found the first time, allowing	 *   users to just paste keyframes back into the original curve again [#31670]	 */	filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE | ANIMFILTER_FOREDIT /*| ANIMFILTER_CURVESONLY*/ | ANIMFILTER_NODUPLIS);		if (ANIM_animdata_filter(ac, &anim_data, filter | ANIMFILTER_SEL, ac->data, ac->datatype) == 0)		ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);		/* paste keyframes */	ok = paste_animedit_keys(ac, &anim_data, offset_mode, merge_mode, flip);	/* clean up */	ANIM_animdata_freelist(&anim_data);	return ok;}

void ob_to_keylist(bDopeSheet *ads, Object *ob, DLRBT_Tree *keys, DLRBT_Tree *blocks){		bAnimContext ac = {NULL};	ListBase anim_data = {NULL, NULL};	bAnimListElem *ale;	int filter;		bAnimListElem dummychan = {NULL};	Base dummybase = {NULL};		if (ob == NULL)		return;		/* create a dummy wrapper data to work with */	dummybase.object = ob;		dummychan.type = ANIMTYPE_OBJECT;	dummychan.data = &dummybase;	dummychan.id = &ob->id;	dummychan.adt = ob->adt;		ac.ads = ads;	ac.data = &dummychan;	ac.datatype = ANIMCONT_CHANNEL;		/* get F-Curves to take keyframes from */	filter = ANIMFILTER_DATA_VISIBLE; // curves only	ANIM_animdata_filter(&ac, &anim_data, filter, ac.data, ac.datatype);		/* loop through each F-Curve, grabbing the keyframes */	for (ale = anim_data.first; ale; ale = ale->next)		fcurve_to_keylist(ale->adt, ale->data, keys, blocks);		ANIM_animdata_freelist(&anim_data);}

/* helper - add NLA Tracks to empty (and selected) AnimData blocks */bool nlaedit_add_tracks_empty(bAnimContext *ac){	ListBase anim_data = {NULL, NULL};	bAnimListElem *ale;	int filter;	bool added = false;		/* get a list of the selected AnimData blocks in the NLA */	filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE | ANIMFILTER_ANIMDATA | ANIMFILTER_SEL | ANIMFILTER_NODUPLIS);	ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);		/* check if selected AnimData blocks are empty, and add tracks if so... */	for (ale = anim_data.first; ale; ale = ale->next) {		AnimData *adt = ale->adt;				/* sanity check */		BLI_assert(adt->flag & ADT_UI_SELECTED);				/* ensure it is empty */		if (BLI_listbase_is_empty(&adt->nla_tracks)) {			/* add new track to this AnimData block then */			add_nlatrack(adt, NULL);			added = true;		}	}		/* cleanup */	ANIM_animdata_freelist(&anim_data);		return added;}

/* This function is used to loop over the keyframe data in a DopeSheet summary */static short summary_keyframes_loop(KeyframeEditData *ked, bAnimContext *ac, KeyframeEditFunc key_ok, KeyframeEditFunc key_cb, FcuEditFunc fcu_cb){	ListBase anim_data = {NULL, NULL};	bAnimListElem *ale;	int filter, ret_code = 0;		/* sanity check */	if (ac == NULL)		return 0;		/* get F-Curves to take keyframes from */	filter = ANIMFILTER_DATA_VISIBLE;	ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);		/* loop through each F-Curve, working on the keyframes until the first curve aborts */	for (ale = anim_data.first; ale; ale = ale->next) {		switch (ale->datatype) {			case ALE_MASKLAY:			case ALE_GPFRAME:				break;			default:				ret_code = ANIM_fcurve_keyframes_loop(ked, ale->data, key_ok, key_cb, fcu_cb);				break;		}				if (ret_code)			break;	}		ANIM_animdata_freelist(&anim_data);		return ret_code;}

void cachefile_to_keylist(bDopeSheet *ads, CacheFile *cache_file, DLRBT_Tree *keys, DLRBT_Tree *blocks){	if (cache_file == NULL) {		return;	}	/* create a dummy wrapper data to work with */	bAnimListElem dummychan = {NULL};	dummychan.type = ANIMTYPE_DSCACHEFILE;	dummychan.data = cache_file;	dummychan.id = &cache_file->id;	dummychan.adt = cache_file->adt;	bAnimContext ac = {NULL};	ac.ads = ads;	ac.data = &dummychan;	ac.datatype = ANIMCONT_CHANNEL;	/* get F-Curves to take keyframes from */	ListBase anim_data = { NULL, NULL };	int filter = ANIMFILTER_DATA_VISIBLE; // curves only	ANIM_animdata_filter(&ac, &anim_data, filter, ac.data, ac.datatype);	/* loop through each F-Curve, grabbing the keyframes */	for (bAnimListElem *ale = anim_data.first; ale; ale = ale->next) {		fcurve_to_keylist(ale->adt, ale->data, keys, blocks);	}	ANIM_animdata_freelist(&anim_data);}

/* Deselects keyframes in the Graph Editor *	- This is called by the deselect all operator, as well as other ones! * *  - test: check if select or deselect all *	- sel: how to select keyframes  *		0 = deselect *		1 = select *		2 = invert *	- do_channels: whether to affect selection status of channels */static void deselect_graph_keys(bAnimContext *ac, short test, short sel, short do_channels){	ListBase anim_data = {NULL, NULL};	bAnimListElem *ale;	int filter;		SpaceIpo *sipo = (SpaceIpo *)ac->sl;	KeyframeEditData ked = {{NULL}};	KeyframeEditFunc test_cb, sel_cb;		/* determine type-based settings */	filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_CURVE_VISIBLE | ANIMFILTER_NODUPLIS);		/* filter data */	ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);		/* init BezTriple looping data */	test_cb = ANIM_editkeyframes_ok(BEZT_OK_SELECTED);		/* See if we should be selecting or deselecting */	if (test) {		for (ale = anim_data.first; ale; ale = ale->next) {			if (ANIM_fcurve_keyframes_loop(&ked, ale->key_data, NULL, test_cb, NULL)) {				sel = SELECT_SUBTRACT;				break;			}		}	}		/* convert sel to selectmode, and use that to get editor */	sel_cb = ANIM_editkeyframes_select(sel);		/* Now set the flags */	for (ale = anim_data.first; ale; ale = ale->next) {		FCurve *fcu = (FCurve *)ale->key_data;				/* Keyframes First */		ANIM_fcurve_keyframes_loop(&ked, ale->key_data, NULL, sel_cb, NULL);				/* affect channel selection status? */		if (do_channels) {			/* only change selection of channel when the visibility of keyframes doesn't depend on this */			if ((sipo->flag & SIPO_SELCUVERTSONLY) == 0) {				/* deactivate the F-Curve, and deselect if deselecting keyframes.				 * otherwise select the F-Curve too since we've selected all the keyframes				 */				if (sel == SELECT_SUBTRACT) 					fcu->flag &= ~FCURVE_SELECTED;				else					fcu->flag |= FCURVE_SELECTED;			}						/* always deactivate all F-Curves if we perform batch ops for selection */			fcu->flag &= ~FCURVE_ACTIVE;		}	}		/* Cleanup */	ANIM_animdata_freelist(&anim_data);}

/* this function is responsible for setting handle-type of selected keyframes */static void sethandles_action_keys(bAnimContext *ac, short mode) {	ListBase anim_data = {NULL, NULL};	bAnimListElem *ale;	int filter;		KeyframeEditFunc edit_cb = ANIM_editkeyframes_handles(mode);	KeyframeEditFunc sel_cb = ANIM_editkeyframes_ok(BEZT_OK_SELECTED);		/* filter data */	filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE | ANIMFILTER_FOREDIT /*| ANIMFILTER_CURVESONLY*/ | ANIMFILTER_NODUPLIS);	ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);		/* loop through setting flags for handles 	 * Note: we do not supply KeyframeEditData to the looper yet. Currently that's not necessary here...	 */	for (ale = anim_data.first; ale; ale = ale->next) {		FCurve *fcu = (FCurve *)ale->key_data;				/* any selected keyframes for editing? */		if (ANIM_fcurve_keyframes_loop(NULL, fcu, NULL, sel_cb, NULL)) {			/* change type of selected handles */			ANIM_fcurve_keyframes_loop(NULL, fcu, NULL, edit_cb, calchandles_fcurve);			ale->update |= ANIM_UPDATE_DEFAULT;		}	}	ANIM_animdata_update(ac, &anim_data);	ANIM_animdata_freelist(&anim_data);}

static void duplicate_action_keys(bAnimContext *ac){	ListBase anim_data = {NULL, NULL};	bAnimListElem *ale;	int filter;		/* filter data */	if (ELEM(ac->datatype, ANIMCONT_GPENCIL, ANIMCONT_MASK))		filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_NODUPLIS);	else		filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE | ANIMFILTER_FOREDIT /*| ANIMFILTER_CURVESONLY*/ | ANIMFILTER_NODUPLIS);	ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);		/* loop through filtered data and delete selected keys */	for (ale = anim_data.first; ale; ale = ale->next) {		if (ELEM(ale->type, ANIMTYPE_FCURVE, ANIMTYPE_NLACURVE))			duplicate_fcurve_keys((FCurve *)ale->key_data);		else if (ale->type == ANIMTYPE_GPLAYER)			ED_gplayer_frames_duplicate((bGPDlayer *)ale->data);		else if (ale->type == ANIMTYPE_MASKLAYER)			ED_masklayer_frames_duplicate((MaskLayer *)ale->data);		else			BLI_assert(0);		ale->update |= ANIM_UPDATE_DEFAULT;	}	ANIM_animdata_update(ac, &anim_data);	ANIM_animdata_freelist(&anim_data);}

static void borderselect_nla_strips(bAnimContext *ac, rcti rect, short mode, short selectmode){	ListBase anim_data = {NULL, NULL};	bAnimListElem *ale;	int filter;		SpaceNla *snla = (SpaceNla *)ac->sl;	View2D *v2d = &ac->ar->v2d;	rctf rectf;	float ymin /* =(float)(-NLACHANNEL_HEIGHT(snla)) */ /* UNUSED */, ymax = 0;		/* convert border-region to view coordinates */	UI_view2d_region_to_view(v2d, rect.xmin, rect.ymin + 2, &rectf.xmin, &rectf.ymin);	UI_view2d_region_to_view(v2d, rect.xmax, rect.ymax - 2, &rectf.xmax, &rectf.ymax);		/* filter data */	filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE | ANIMFILTER_LIST_CHANNELS);	ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);		/* convert selection modes to selection modes */	selectmode = selmodes_to_flagmodes(selectmode);		/* loop over data, doing border select */	for (ale = anim_data.first; ale; ale = ale->next) {		ymin = ymax - NLACHANNEL_STEP(snla);				/* perform vertical suitability check (if applicable) */		if ((mode == NLA_BORDERSEL_FRAMERANGE) ||		    !((ymax < rectf.ymin) || (ymin > rectf.ymax)))		{			/* loop over data selecting (only if NLA-Track) */			if (ale->type == ANIMTYPE_NLATRACK) {				NlaTrack *nlt = (NlaTrack *)ale->data;				NlaStrip *strip;								/* only select strips if they fall within the required ranges (if applicable) */				for (strip = nlt->strips.first; strip; strip = strip->next) {					if ((mode == NLA_BORDERSEL_CHANNELS) ||					    BKE_nlastrip_within_bounds(strip, rectf.xmin, rectf.xmax))					{						/* set selection */						ACHANNEL_SET_FLAG(strip, selectmode, NLASTRIP_FLAG_SELECT);												/* clear active flag */						strip->flag &= ~NLASTRIP_FLAG_ACTIVE;					}				}			}		}				/* set minimum extent to be the maximum of the next channel */		ymax = ymin;	}		/* cleanup */	ANIM_animdata_freelist(&anim_data);}

/* Deselects strips in the NLA Editor *	- This is called by the deselect all operator, as well as other ones! * *  - test: check if select or deselect all (1) or clear all active (2) *	- sel: how to select keyframes  *		0 = deselect *		1 = select *		2 = invert */static void deselect_nla_strips(bAnimContext *ac, short test, short sel){	ListBase anim_data = {NULL, NULL};	bAnimListElem *ale;	int filter;	short smode;		/* determine type-based settings */	// FIXME: double check whether ANIMFILTER_LIST_VISIBLE is needed!	filter = (ANIMFILTER_DATA_VISIBLE);		/* filter data */	ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);		/* See if we should be selecting or deselecting */	if (test == DESELECT_STRIPS_TEST) {		for (ale = anim_data.first; ale; ale = ale->next) {			NlaTrack *nlt = (NlaTrack *)ale->data;			NlaStrip *strip;						/* if any strip is selected, break out, since we should now be deselecting */			for (strip = nlt->strips.first; strip; strip = strip->next) {				if (strip->flag & NLASTRIP_FLAG_SELECT) {					sel = SELECT_SUBTRACT;					break;				}			}						if (sel == SELECT_SUBTRACT)				break;		}	}		/* convert selection modes to selection modes */	smode = selmodes_to_flagmodes(sel);		/* Now set the flags */	for (ale = anim_data.first; ale; ale = ale->next) {		NlaTrack *nlt = (NlaTrack *)ale->data;		NlaStrip *strip;				/* apply same selection to all strips */		for (strip = nlt->strips.first; strip; strip = strip->next) {			/* set selection */			if (test != DESELECT_STRIPS_CLEARACTIVE)				ACHANNEL_SET_FLAG(strip, smode, NLASTRIP_FLAG_SELECT);						/* clear active flag */			// TODO: for clear active, do we want to limit this to only doing this on a certain set of tracks though?			strip->flag &= ~NLASTRIP_FLAG_ACTIVE;		}	}		/* Cleanup */	ANIM_animdata_freelist(&anim_data);}

static void nlaedit_select_leftright(bContext *C, bAnimContext *ac, short leftright, short select_mode){	ListBase anim_data = {NULL, NULL};	bAnimListElem *ale;	int filter;		Scene *scene = ac->scene;	float xmin, xmax;		/* if currently in tweakmode, exit tweakmode first */	if (scene->flag & SCE_NLA_EDIT_ON)		WM_operator_name_call(C, "NLA_OT_tweakmode_exit", WM_OP_EXEC_DEFAULT, NULL);		/* if select mode is replace, deselect all keyframes (and channels) first */	if (select_mode == SELECT_REPLACE) {		select_mode = SELECT_ADD;				/* - deselect all other keyframes, so that just the newly selected remain		 * - channels aren't deselected, since we don't re-select any as a consequence		 */		deselect_nla_strips(ac, 0, SELECT_SUBTRACT);	}		/* get range, and get the right flag-setting mode */	if (leftright == NLAEDIT_LRSEL_LEFT) {		xmin = MINAFRAMEF;		xmax = (float)(CFRA + 0.1f);	}	else {		xmin = (float)(CFRA - 0.1f);		xmax = MAXFRAMEF;	}		select_mode = selmodes_to_flagmodes(select_mode);			/* filter data */	filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE);	ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);		/* select strips on the side where most data occurs */	for (ale = anim_data.first; ale; ale = ale->next) {		NlaTrack *nlt = (NlaTrack *)ale->data;		NlaStrip *strip;				/* check each strip to see if it is appropriate */		for (strip = nlt->strips.first; strip; strip = strip->next) {			if (BKE_nlastrip_within_bounds(strip, xmin, xmax)) {				ACHANNEL_SET_FLAG(strip, select_mode, NLASTRIP_FLAG_SELECT);			}		}	}		/* Cleanup */	ANIM_animdata_freelist(&anim_data);}

static int graphview_curves_reveal_exec(bContext *C, wmOperator *op){	bAnimContext ac;	ListBase anim_data = {NULL, NULL};	ListBase all_data = {NULL, NULL};	bAnimListElem *ale;	int filter;	const bool select = RNA_boolean_get(op->ptr, "select");		/* get editor data */	if (ANIM_animdata_get_context(C, &ac) == 0)		return OPERATOR_CANCELLED;			/* get list of all channels that selection may need to be flushed to 	 * - hierarchy must not affect what we have access to here...	 */	filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_CHANNELS | ANIMFILTER_NODUPLIS);	ANIM_animdata_filter(&ac, &all_data, filter, ac.data, ac.datatype);		/* filter data	 * - just go through all visible channels, ensuring that everything is set to be curve-visible	 */	filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE | ANIMFILTER_NODUPLIS);	ANIM_animdata_filter(&ac, &anim_data, filter, ac.data, ac.datatype);		for (ale = anim_data.first; ale; ale = ale->next) {		/* hack: skip object channels for now, since flushing those will always flush everything, but they are always included */		/* TODO: find out why this is the case, and fix that */		if (ale->type == ANIMTYPE_OBJECT)			continue;				/* select if it is not visible */		if (ANIM_channel_setting_get(&ac, ale, ACHANNEL_SETTING_VISIBLE) == 0) {			ANIM_channel_setting_set(			        &ac, ale, ACHANNEL_SETTING_SELECT,			        select ? ACHANNEL_SETFLAG_ADD : ACHANNEL_SETFLAG_CLEAR);		}				/* change the visibility setting */		ANIM_channel_setting_set(&ac, ale, ACHANNEL_SETTING_VISIBLE, ACHANNEL_SETFLAG_ADD);				/* now, also flush selection status up/down as appropriate */		ANIM_flush_setting_anim_channels(&ac, &all_data, ale, ACHANNEL_SETTING_VISIBLE, true);	}		/* cleanup */	ANIM_animdata_freelist(&anim_data);	BLI_freelistN(&all_data);		/* send notifier that things have changed */	WM_event_add_notifier(C, NC_ANIMATION | ND_ANIMCHAN | NA_EDITED, NULL);		return OPERATOR_FINISHED;}

static void graphkeys_select_leftright(bAnimContext *ac, short leftright, short select_mode){	ListBase anim_data = {NULL, NULL};	bAnimListElem *ale;	int filter;		KeyframeEditFunc ok_cb, select_cb;	KeyframeEditData ked = {{NULL}};	Scene *scene = ac->scene;		/* if select mode is replace, deselect all keyframes (and channels) first */	if (select_mode == SELECT_REPLACE) {		select_mode = SELECT_ADD;				/* - deselect all other keyframes, so that just the newly selected remain		 * - channels aren't deselected, since we don't re-select any as a consequence		 */		deselect_graph_keys(ac, 0, SELECT_SUBTRACT, false);	}		/* set callbacks and editing data */	ok_cb = ANIM_editkeyframes_ok(BEZT_OK_FRAMERANGE);	select_cb = ANIM_editkeyframes_select(select_mode);		if (leftright == GRAPHKEYS_LRSEL_LEFT) {		ked.f1 = MINAFRAMEF;		ked.f2 = (float)(CFRA + 0.1f);	}	else {		ked.f1 = (float)(CFRA - 0.1f);		ked.f2 = MAXFRAMEF;	}		/* filter data */	filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_NODUPLIS);	ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);			/* select keys */	for (ale = anim_data.first; ale; ale = ale->next) {		AnimData *adt = ANIM_nla_mapping_get(ac, ale);				if (adt) {			ANIM_nla_mapping_apply_fcurve(adt, ale->key_data, 0, 1);			ANIM_fcurve_keyframes_loop(&ked, ale->key_data, ok_cb, select_cb, NULL);			ANIM_nla_mapping_apply_fcurve(adt, ale->key_data, 1, 1);		}		else			ANIM_fcurve_keyframes_loop(&ked, ale->key_data, ok_cb, select_cb, NULL);	}	/* Cleanup */	ANIM_animdata_freelist(&anim_data);}

/* this function is responsible for mirroring keyframes */static void mirror_action_keys(bAnimContext *ac, short mode) {	ListBase anim_data = {NULL, NULL};	bAnimListElem *ale;	int filter;		KeyframeEditData ked = {{NULL}};	KeyframeEditFunc edit_cb;		/* get beztriple editing callbacks */	edit_cb = ANIM_editkeyframes_mirror(mode);	ked.scene = ac->scene;		/* for 'first selected marker' mode, need to find first selected marker first! */	/* XXX should this be made into a helper func in the API? */	if (mode == ACTKEYS_MIRROR_MARKER) {		TimeMarker *marker = ED_markers_get_first_selected(ac->markers);				if (marker)			ked.f1 = (float)marker->frame;		else			return;	}		/* filter data */	if (ELEM(ac->datatype, ANIMCONT_GPENCIL, ANIMCONT_MASK))		filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_NODUPLIS);	else		filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE | ANIMFILTER_FOREDIT /*| ANIMFILTER_CURVESONLY*/ | ANIMFILTER_NODUPLIS);	ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);		/* mirror keyframes */	for (ale = anim_data.first; ale; ale = ale->next) {		AnimData *adt = ANIM_nla_mapping_get(ac, ale);				if (adt) {			ANIM_nla_mapping_apply_fcurve(adt, ale->key_data, 0, 1); 			ANIM_fcurve_keyframes_loop(&ked, ale->key_data, NULL, edit_cb, calchandles_fcurve);			ANIM_nla_mapping_apply_fcurve(adt, ale->key_data, 1, 1);		}		//else if (ale->type == ACTTYPE_GPLAYER)		//	snap_gplayer_frames(ale->data, mode);		else 			ANIM_fcurve_keyframes_loop(&ked, ale->key_data, NULL, edit_cb, calchandles_fcurve);		ale->update |= ANIM_UPDATE_DEFAULT;	}	ANIM_animdata_update(ac, &anim_data);	ANIM_animdata_freelist(&anim_data);}

/* this function is responsible for snapping keyframes to frame-times */static void snap_action_keys(bAnimContext *ac, short mode) {	ListBase anim_data = {NULL, NULL};	bAnimListElem *ale;	int filter;		KeyframeEditData ked = {{NULL}};	KeyframeEditFunc edit_cb;		/* filter data */	if (ELEM(ac->datatype, ANIMCONT_GPENCIL, ANIMCONT_MASK))		filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE | ANIMFILTER_FOREDIT);	else		filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE | ANIMFILTER_FOREDIT /*| ANIMFILTER_CURVESONLY*/ | ANIMFILTER_NODUPLIS);	ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);		/* get beztriple editing callbacks */	edit_cb = ANIM_editkeyframes_snap(mode);	ked.scene = ac->scene;	if (mode == ACTKEYS_SNAP_NEAREST_MARKER) {		ked.list.first = (ac->markers) ? ac->markers->first : NULL;		ked.list.last = (ac->markers) ? ac->markers->last : NULL;	}		/* snap keyframes */	for (ale = anim_data.first; ale; ale = ale->next) {		AnimData *adt = ANIM_nla_mapping_get(ac, ale);				if (ale->type == ANIMTYPE_GPLAYER) {			ED_gplayer_snap_frames(ale->data, ac->scene, mode);		}		else if (ale->type == ANIMTYPE_MASKLAYER) {			ED_masklayer_snap_frames(ale->data, ac->scene, mode);		}		else if (adt) {			ANIM_nla_mapping_apply_fcurve(adt, ale->key_data, 0, 1); 			ANIM_fcurve_keyframes_loop(&ked, ale->key_data, NULL, edit_cb, calchandles_fcurve);			ANIM_nla_mapping_apply_fcurve(adt, ale->key_data, 1, 1);		}		else {			ANIM_fcurve_keyframes_loop(&ked, ale->key_data, NULL, edit_cb, calchandles_fcurve);		}		ale->update |= ANIM_UPDATE_DEFAULT;	}	ANIM_animdata_update(ac, &anim_data);	ANIM_animdata_freelist(&anim_data);}

/* this function is responsible for snapping keyframes to frame-times */static void insert_action_keys(bAnimContext *ac, short mode) {	ListBase anim_data = {NULL, NULL};	bAnimListElem *ale;	int filter;		ReportList *reports = ac->reports;	Scene *scene = ac->scene;	short flag = 0;		/* filter data */	filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE | ANIMFILTER_FOREDIT /*| ANIMFILTER_CURVESONLY*/ | ANIMFILTER_NODUPLIS);	if (mode == 2) filter |= ANIMFILTER_SEL;	else if (mode == 3) filter |= ANIMFILTER_ACTGROUPED;		ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);		/* init keyframing flag */	flag = ANIM_get_keyframing_flags(scene, 1);		/* insert keyframes */	for (ale = anim_data.first; ale; ale = ale->next) {		AnimData *adt = ANIM_nla_mapping_get(ac, ale);		FCurve *fcu = (FCurve *)ale->key_data;		float cfra;				/* adjust current frame for NLA-scaling */		if (adt)			cfra = BKE_nla_tweakedit_remap(adt, (float)CFRA, NLATIME_CONVERT_UNMAP);		else 			cfra = (float)CFRA;					/* read value from property the F-Curve represents, or from the curve only?		 * - ale->id != NULL:    Typically, this means that we have enough info to try resolving the path		 * - ale->owner != NULL: If this is set, then the path may not be resolvable from the ID alone,		 *                       so it's easier for now to just read the F-Curve directly.		 *                       (TODO: add the full-blown PointerRNA relative parsing case here...)		 */		if (ale->id && !ale->owner)			insert_keyframe(reports, ale->id, NULL, ((fcu->grp) ? (fcu->grp->name) : (NULL)), fcu->rna_path, fcu->array_index, cfra, flag);		else			insert_vert_fcurve(fcu, cfra, fcu->curval, 0);		ale->update |= ANIM_UPDATE_DEFAULT;	}	ANIM_animdata_update(ac, &anim_data);	ANIM_animdata_freelist(&anim_data);}

/* TODO, this is almost an _exact_ duplicate of a function of the same name in graph_select.c * should de-duplicate - campbell */static void markers_selectkeys_between(bAnimContext *ac){	ListBase anim_data = {NULL, NULL};	bAnimListElem *ale;	int filter;		KeyframeEditFunc ok_cb, select_cb;	KeyframeEditData ked = {{NULL}};	float min, max;		/* get extreme markers */	ED_markers_get_minmax(ac->markers, 1, &min, &max);	min -= 0.5f;	max += 0.5f;		/* get editing funcs + data */	ok_cb = ANIM_editkeyframes_ok(BEZT_OK_FRAMERANGE);	select_cb = ANIM_editkeyframes_select(SELECT_ADD);	ked.f1 = min;	ked.f2 = max;		/* filter data */	filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE /*| ANIMFILTER_CURVESONLY */ | ANIMFILTER_NODUPLIS);	ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);		/* select keys in-between */	for (ale = anim_data.first; ale; ale = ale->next) {		AnimData *adt = ANIM_nla_mapping_get(ac, ale);				if (adt) {			ANIM_nla_mapping_apply_fcurve(adt, ale->key_data, 0, 1);			ANIM_fcurve_keyframes_loop(&ked, ale->key_data, ok_cb, select_cb, NULL);			ANIM_nla_mapping_apply_fcurve(adt, ale->key_data, 1, 1);		}		else if (ale->type == ANIMTYPE_GPLAYER) {			ED_gplayer_frames_select_border(ale->data, min, max, SELECT_ADD);		}		else if (ale->type == ANIMTYPE_MASKLAYER) {			ED_masklayer_frames_select_border(ale->data, min, max, SELECT_ADD);		}		else {			ANIM_fcurve_keyframes_loop(&ked, ale->key_data, ok_cb, select_cb, NULL);		}	}		/* Cleanup */	ANIM_animdata_freelist(&anim_data);}

static bool delete_action_keys(bAnimContext *ac){	ListBase anim_data = {NULL, NULL};	bAnimListElem *ale;	int filter;	bool changed_final = false;	/* filter data */	if (ELEM(ac->datatype, ANIMCONT_GPENCIL, ANIMCONT_MASK))		filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_NODUPLIS);	else		filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE | ANIMFILTER_FOREDIT /*| ANIMFILTER_CURVESONLY*/ | ANIMFILTER_NODUPLIS);	ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);	/* loop through filtered data and delete selected keys */	for (ale = anim_data.first; ale; ale = ale->next) {		bool changed = false;		if (ale->type == ANIMTYPE_GPLAYER) {			changed = ED_gplayer_frames_delete((bGPDlayer *)ale->data);		}		else if (ale->type == ANIMTYPE_MASKLAYER) {			changed = ED_masklayer_frames_delete((MaskLayer *)ale->data);		}		else {			FCurve *fcu = (FCurve *)ale->key_data;			AnimData *adt = ale->adt;						/* delete selected keyframes only */			changed = delete_fcurve_keys(fcu);						/* Only delete curve too if it won't be doing anything anymore */			if ((fcu->totvert == 0) && (list_has_suitable_fmodifier(&fcu->modifiers, 0, FMI_TYPE_GENERATE_CURVE) == 0)) {				ANIM_fcurve_delete_from_animdata(ac, adt, fcu);				ale->key_data = NULL;			}		}		if (changed) {			ale->update |= ANIM_UPDATE_DEFAULT;			changed_final = true;		}	}	ANIM_animdata_update(ac, &anim_data);	ANIM_animdata_freelist(&anim_data);	return changed_final;}

/* this function is responsible for setting extrapolation mode for keyframes */static void setexpo_action_keys(bAnimContext *ac, short mode) {	ListBase anim_data = {NULL, NULL};	bAnimListElem *ale;	int filter;		/* filter data */	filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_SEL /*| ANIMFILTER_CURVESONLY*/ | ANIMFILTER_NODUPLIS);	ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);		/* loop through setting mode per F-Curve */	for (ale = anim_data.first; ale; ale = ale->next) {		FCurve *fcu = (FCurve *)ale->data;				if (mode >= 0) {			/* just set mode setting */			fcu->extend = mode;		}		else {			/* shortcuts for managing Cycles F-Modifiers to make it easier to toggle cyclic animation 			 * without having to go through FModifier UI in Graph Editor to do so			 */			if (mode == MAKE_CYCLIC_EXPO) {				/* only add if one doesn't exist */				if (list_has_suitable_fmodifier(&fcu->modifiers, FMODIFIER_TYPE_CYCLES, -1) == 0) {					/* TODO: add some more preset versions which set different extrapolation options? */					add_fmodifier(&fcu->modifiers, FMODIFIER_TYPE_CYCLES);				}			}			else if (mode == CLEAR_CYCLIC_EXPO) {				/* remove all the modifiers fitting this description */				FModifier *fcm, *fcn = NULL;								for (fcm = fcu->modifiers.first; fcm; fcm = fcn) {					fcn = fcm->next;										if (fcm->type == FMODIFIER_TYPE_CYCLES)						remove_fmodifier(&fcu->modifiers, fcm);				}			}		}		ale->update |= ANIM_UPDATE_DEFAULT;	}	ANIM_animdata_update(ac, &anim_data);	ANIM_animdata_freelist(&anim_data);}

/** * Find the extents of the active channel * * /param[out] min Bottom y-extent of channel * /param[out] max Top y-extent of channel * /return Success of finding a selected channel */static bool actkeys_channels_get_selected_extents(bAnimContext *ac, float *min, float *max){	ListBase anim_data = {NULL, NULL};	bAnimListElem *ale;	int filter;		short found = 0; /* NOTE: not bool, since we want prioritise individual channels over expanders */	float y;		/* get all items - we need to do it this way */	filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE | ANIMFILTER_LIST_CHANNELS);	ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);		/* loop through all channels, finding the first one that's selected */	y = (float)ACHANNEL_FIRST;		for (ale = anim_data.first; ale; ale = ale->next) {		const bAnimChannelType *acf = ANIM_channel_get_typeinfo(ale);				/* must be selected... */		if (acf && acf->has_setting(ac, ale, ACHANNEL_SETTING_SELECT) && 		    ANIM_channel_setting_get(ac, ale, ACHANNEL_SETTING_SELECT))		{			/* update best estimate */			*min = (float)(y - ACHANNEL_HEIGHT_HALF);			*max = (float)(y + ACHANNEL_HEIGHT_HALF);						/* is this high enough priority yet? */			found = acf->channel_role;						/* only stop our search when we've found an actual channel			 * - datablock expanders get less priority so that we don't abort prematurely			 */			if (found == ACHANNEL_ROLE_CHANNEL) {				break;			}		}				/* adjust y-position for next one */		y -= ACHANNEL_STEP;	}		/* free all temp data */	ANIM_animdata_freelist(&anim_data);		return (found != 0);}

/* Option 3) Selects all visible keyframes in the same frame as the mouse click */static void actkeys_mselect_column(bAnimContext *ac, short select_mode, float selx){	ListBase anim_data = {NULL, NULL};	bAnimListElem *ale;	int filter;		KeyframeEditFunc select_cb, ok_cb;	KeyframeEditData ked = {{NULL}};		/* set up BezTriple edit callbacks */	select_cb = ANIM_editkeyframes_select(select_mode);	ok_cb = ANIM_editkeyframes_ok(BEZT_OK_FRAME);		/* loop through all of the keys and select additional keyframes	 * based on the keys found to be selected above	 */	if (ELEM(ac->datatype, ANIMCONT_GPENCIL, ANIMCONT_MASK))		filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE /*| ANIMFILTER_CURVESONLY */ | ANIMFILTER_NODUPLIS);	else		filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE | ANIMFILTER_NODUPLIS);	ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);		for (ale = anim_data.first; ale; ale = ale->next) {		AnimData *adt = ANIM_nla_mapping_get(ac, ale);				/* set frame for validation callback to refer to */		if (adt)			ked.f1 = BKE_nla_tweakedit_remap(adt, selx, NLATIME_CONVERT_UNMAP);		else			ked.f1 = selx;				/* select elements with frame number matching cfra */		if (ale->type == ANIMTYPE_GPLAYER)			ED_gpencil_select_frame(ale->key_data, selx, select_mode);		else if (ale->type == ANIMTYPE_MASKLAYER)			ED_mask_select_frame(ale->key_data, selx, select_mode);		else			ANIM_fcurve_keyframes_loop(&ked, ale->key_data, ok_cb, select_cb, NULL);	}		/* free elements */	BLI_freelistN(&ked.list);	ANIM_animdata_freelist(&anim_data);}

/* option 1) select keyframe directly under mouse */static void actkeys_mselect_single(bAnimContext *ac, bAnimListElem *ale, short select_mode, float selx){	KeyframeEditData ked = {{NULL}};	KeyframeEditFunc select_cb, ok_cb;		/* get functions for selecting keyframes */	select_cb = ANIM_editkeyframes_select(select_mode);	ok_cb = ANIM_editkeyframes_ok(BEZT_OK_FRAME);	ked.f1 = selx;	ked.iterflags |= KED_F1_NLA_UNMAP;		/* select the nominated keyframe on the given frame */	if (ale->type == ANIMTYPE_GPLAYER) {		ED_gpencil_select_frame(ale->data, selx, select_mode);	}	else if (ale->type == ANIMTYPE_MASKLAYER) {		ED_mask_select_frame(ale->data, selx, select_mode);	}	else {		if (ELEM(ac->datatype, ANIMCONT_GPENCIL, ANIMCONT_MASK) &&		    (ale->type == ANIMTYPE_SUMMARY) && (ale->datatype == ALE_ALL))		{			ListBase anim_data = {NULL, NULL};			int filter;						filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE /*| ANIMFILTER_CURVESONLY */ | ANIMFILTER_NODUPLIS);			ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);						for (ale = anim_data.first; ale; ale = ale->next) {				if (ale->type == ANIMTYPE_GPLAYER) {					ED_gpencil_select_frame(ale->data, selx, select_mode);				}				else if (ale->type == ANIMTYPE_MASKLAYER) {					ED_mask_select_frame(ale->data, selx, select_mode);				}			}						ANIM_animdata_freelist(&anim_data);		}		else {			ANIM_animchannel_keyframes_loop(&ked, ac->ads, ale, ok_cb, select_cb, NULL);		}	}}

/* This function is used to loop over the keyframe data in an Object */static short ob_keyframes_loop(KeyframeEditData *ked, bDopeSheet *ads, Object *ob, KeyframeEditFunc key_ok, KeyframeEditFunc key_cb, FcuEditFunc fcu_cb){	bAnimContext ac = {NULL};	ListBase anim_data = {NULL, NULL};	bAnimListElem *ale;	int filter;	int ret = 0;		bAnimListElem dummychan = {NULL};	Base dummybase = {NULL};		if (ob == NULL)		return 0;		/* create a dummy wrapper data to work with */	dummybase.object = ob;		dummychan.type = ANIMTYPE_OBJECT;	dummychan.data = &dummybase;	dummychan.id = &ob->id;	dummychan.adt = ob->adt;		ac.ads = ads;	ac.data = &dummychan;	ac.datatype = ANIMCONT_CHANNEL;		/* get F-Curves to take keyframes from */	filter = ANIMFILTER_DATA_VISIBLE; // curves only	ANIM_animdata_filter(&ac, &anim_data, filter, ac.data, ac.datatype);		/* loop through each F-Curve, applying the operation as required, but stopping on the first one */	for (ale = anim_data.first; ale; ale = ale->next) {		if (ANIM_fcurve_keyframes_loop(ked, (FCurve *)ale->data, key_ok, key_cb, fcu_cb)) {			ret = 1;			break;		}	}		ANIM_animdata_freelist(&anim_data);		/* return return code - defaults to zero if nothing happened */	return ret;}

/* snap current-frame indicator to 'average time' of selected keyframe */static int actkeys_framejump_exec(bContext *C, wmOperator *UNUSED(op)){	bAnimContext ac;	ListBase anim_data = {NULL, NULL};	bAnimListElem *ale;	int filter;	KeyframeEditData ked = {{NULL}};		/* get editor data */	if (ANIM_animdata_get_context(C, &ac) == 0)		return OPERATOR_CANCELLED;		/* init edit data */	/* loop over action data, averaging values */	filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE /*| ANIMFILTER_CURVESONLY */ | ANIMFILTER_NODUPLIS);	ANIM_animdata_filter(&ac, &anim_data, filter, ac.data, ac.datatype);		for (ale = anim_data.first; ale; ale = ale->next) {		AnimData *adt = ANIM_nla_mapping_get(&ac, ale);		if (adt) {			ANIM_nla_mapping_apply_fcurve(adt, ale->key_data, 0, 1); 			ANIM_fcurve_keyframes_loop(&ked, ale->key_data, NULL, bezt_calc_average, NULL);			ANIM_nla_mapping_apply_fcurve(adt, ale->key_data, 1, 1);		}		else			ANIM_fcurve_keyframes_loop(&ked, ale->key_data, NULL, bezt_calc_average, NULL);	}		ANIM_animdata_freelist(&anim_data);		/* set the new current frame value, based on the average time */	if (ked.i1) {		Scene *scene = ac.scene;		CFRA = iroundf(ked.f1 / ked.i1);		SUBFRA = 0.f;	}		/* set notifier that things have changed */	WM_event_add_notifier(C, NC_SCENE | ND_FRAME, ac.scene);		return OPERATOR_FINISHED;}

static int nlaedit_delete_tracks_exec(bContext *C, wmOperator *UNUSED(op)){	bAnimContext ac;		ListBase anim_data = {NULL, NULL};	bAnimListElem *ale;	int filter;		/* get editor data */	if (ANIM_animdata_get_context(C, &ac) == 0)		return OPERATOR_CANCELLED;			/* get a list of the AnimData blocks being shown in the NLA */	filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE | ANIMFILTER_SEL | ANIMFILTER_NODUPLIS);	ANIM_animdata_filter(&ac, &anim_data, filter, ac.data, ac.datatype);		/* delete tracks */	for (ale = anim_data.first; ale; ale = ale->next) {		if (ale->type == ANIMTYPE_NLATRACK) {			NlaTrack *nlt = (NlaTrack *)ale->data;			AnimData *adt = ale->adt;						/* if track is currently 'solo', then AnimData should have its			 * 'has solo' flag disabled			 */			if (nlt->flag & NLATRACK_SOLO)				adt->flag &= ~ADT_NLA_SOLO_TRACK;						/* call delete on this track - deletes all strips too */			free_nlatrack(&adt->nla_tracks, nlt);		}	}		/* free temp data */	ANIM_animdata_freelist(&anim_data);		/* set notifier that things have changed */	WM_event_add_notifier(C, NC_ANIMATION | ND_NLA | NA_EDITED, NULL);		/* done */	return OPERATOR_FINISHED;}

static void clean_action_keys(bAnimContext *ac, float thresh, bool clean_chan){		ListBase anim_data = {NULL, NULL};	bAnimListElem *ale;	int filter;		/* filter data */	filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_SEL /*| ANIMFILTER_CURVESONLY*/ | ANIMFILTER_NODUPLIS);	ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);		/* loop through filtered data and clean curves */	for (ale = anim_data.first; ale; ale = ale->next) {		clean_fcurve(ac, ale, thresh, clean_chan);		ale->update |= ANIM_UPDATE_DEFAULT;	}	ANIM_animdata_update(ac, &anim_data);	ANIM_animdata_freelist(&anim_data);}

static short copy_action_keys(bAnimContext *ac){		ListBase anim_data = {NULL, NULL};	int filter, ok = 0;		/* clear buffer first */	free_anim_copybuf();		/* filter data */	filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE /*| ANIMFILTER_CURVESONLY*/ | ANIMFILTER_NODUPLIS);	ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);		/* copy keyframes */	ok = copy_animedit_keys(ac, &anim_data);		/* clean up */	ANIM_animdata_freelist(&anim_data);	return ok;}

/* Evaluates the curves between each selected keyframe on each frame, and keys the value  */static void sample_action_keys(bAnimContext *ac){		ListBase anim_data = {NULL, NULL};	bAnimListElem *ale;	int filter;		/* filter data */	filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE | ANIMFILTER_FOREDIT /*| ANIMFILTER_CURVESONLY*/ | ANIMFILTER_NODUPLIS);	ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);		/* loop through filtered data and add keys between selected keyframes on every frame  */	for (ale = anim_data.first; ale; ale = ale->next) {		sample_fcurve((FCurve *)ale->key_data);		ale->update |= ANIM_UPDATE_DEPS;	}	ANIM_animdata_update(ac, &anim_data);	ANIM_animdata_freelist(&anim_data);}

/* this function is responsible for setting the keyframe type for Grease Pencil frames */static void setkeytype_gpencil_keys(bAnimContext *ac, short mode){	ListBase anim_data = {NULL, NULL};	bAnimListElem *ale;	int filter;		/* filter data */	filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE | ANIMFILTER_FOREDIT | ANIMFILTER_NODUPLIS);	ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);		/* loop through each layer */	for (ale = anim_data.first; ale; ale = ale->next) {		if (ale->type == ANIMTYPE_GPLAYER) {			ED_gplayer_frames_keytype_set(ale->data, mode);			ale->update |= ANIM_UPDATE_DEPS;		}	}	ANIM_animdata_update(ac, &anim_data);	ANIM_animdata_freelist(&anim_data);}

/* option 4) select all keyframes in same channel */static void actkeys_mselect_channel_only(bAnimContext *ac, bAnimListElem *ale, short select_mode){	KeyframeEditFunc select_cb;		/* get functions for selecting keyframes */	select_cb = ANIM_editkeyframes_select(select_mode);		/* select all keyframes in this channel */	if (ale->type == ANIMTYPE_GPLAYER) {		ED_gpencil_select_frames(ale->data, select_mode);	}	else if (ale->type == ANIMTYPE_MASKLAYER) {		ED_mask_select_frames(ale->data, select_mode);	}	else {		if (ELEM(ac->datatype, ANIMCONT_GPENCIL, ANIMCONT_MASK) &&		    (ale->type == ANIMTYPE_SUMMARY) && (ale->datatype == ALE_ALL))		{			ListBase anim_data = {NULL, NULL};			int filter;						filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_LIST_VISIBLE /*| ANIMFILTER_CURVESONLY */ | ANIMFILTER_NODUPLIS);			ANIM_animdata_filter(ac, &anim_data, filter, ac->data, ac->datatype);						for (ale = anim_data.first; ale; ale = ale->next) {				if (ale->type == ANIMTYPE_GPLAYER) {					ED_gpencil_select_frames(ale->data, select_mode);				}				else if (ale->type == ANIMTYPE_MASKLAYER) {					ED_mask_select_frames(ale->data, select_mode);				}			}						ANIM_animdata_freelist(&anim_data);		}		else {			ANIM_animchannel_keyframes_loop(NULL, ac->ads, ale, NULL, select_cb, NULL);		}	}}