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

void VideoFFmpeg::stopCache(){	if (m_cacheStarted)	{		m_stopThread = true;		BLI_end_threads(&m_thread);		// now delete the cache		CacheFrame *frame;		CachePacket *packet;		while ((frame = (CacheFrame *)m_frameCacheBase.first) != NULL)		{			BLI_remlink(&m_frameCacheBase, frame);			MEM_freeN(frame->frame->data[0]);			av_free(frame->frame);			delete frame;		}		while ((frame = (CacheFrame *)m_frameCacheFree.first) != NULL)		{			BLI_remlink(&m_frameCacheFree, frame);			MEM_freeN(frame->frame->data[0]);			av_free(frame->frame);			delete frame;		}		while ((packet = (CachePacket *)m_packetCacheBase.first) != NULL)		{			BLI_remlink(&m_packetCacheBase, packet);			av_free_packet(&packet->packet);			delete packet;		}		while ((packet = (CachePacket *)m_packetCacheFree.first) != NULL)		{			BLI_remlink(&m_packetCacheFree, packet);			delete packet;		}		m_cacheStarted = false;	}}

/* this is event from ghost, or exit-blender op */void wm_window_close(bContext *C, wmWindowManager *wm, wmWindow *win){	wmWindow *tmpwin;	bScreen *screen = win->screen;		/* first check if we have any non-temp remaining windows */	if ((U.uiflag & USER_QUIT_PROMPT) && !wm->file_saved) {		if (wm->windows.first) {			for (tmpwin = wm->windows.first; tmpwin; tmpwin = tmpwin->next) {				if (tmpwin == win)					continue;				if (tmpwin->screen->temp == 0)					break;			}			if (tmpwin == NULL) {				if (!GHOST_confirmQuit(win->ghostwin))					return;			}		}	}	BLI_remlink(&wm->windows, win);		wm_draw_window_clear(win);	CTX_wm_window_set(C, win);  /* needed by handlers */	WM_event_remove_handlers(C, &win->handlers);	WM_event_remove_handlers(C, &win->modalhandlers);	ED_screen_exit(C, win, win->screen); 		wm_window_free(C, wm, win);		/* if temp screen, delete it after window free (it stops jobs that can access it) */	if (screen->temp) {		Main *bmain = CTX_data_main(C);		BKE_libblock_free(&bmain->screen, screen);	}		/* check remaining windows */	if (wm->windows.first) {		for (win = wm->windows.first; win; win = win->next)			if (win->screen->temp == 0)				break;		/* in this case we close all */		if (win == NULL)			WM_exit(C);	}	else		WM_exit(C);}

void VideoFFmpeg::releaseFrame(AVFrame *frame){	if (frame == m_frameRGB)	{		// this is not a frame from the cache, ignore		return;	}	// this frame MUST be the first one of the queue	pthread_mutex_lock(&m_cacheMutex);	CacheFrame *cacheFrame = (CacheFrame *)m_frameCacheBase.first;	assert (cacheFrame != NULL && cacheFrame->frame == frame);	BLI_remlink(&m_frameCacheBase, cacheFrame);	BLI_addtail(&m_frameCacheFree, cacheFrame);	pthread_mutex_unlock(&m_cacheMutex);}

static int sensor_remove_exec(bContext *C, wmOperator *op){    Object *ob = NULL;    bSensor *sens = edit_sensor_property_get(C, op, &ob);    if (!sens)        return OPERATOR_CANCELLED;    BLI_remlink(&(ob->sensors), sens);    free_sensor(sens);    WM_event_add_notifier(C, NC_LOGIC, NULL);    return OPERATOR_FINISHED;}

/* this is event from ghost, or exit-blender op */void wm_window_close(bContext *C, wmWindowManager *wm, wmWindow *win){    wmWindow *tmpwin;    bool do_exit = false;    /* first check if we have to quit (there are non-temp remaining windows) */    for (tmpwin = wm->windows.first; tmpwin; tmpwin = tmpwin->next) {        if (tmpwin == win)            continue;        if (tmpwin->screen->temp == 0)            break;    }    if (tmpwin == NULL)        do_exit = 1;    if ((U.uiflag & USER_QUIT_PROMPT) && !wm->file_saved) {        if (do_exit) {            if (!GHOST_confirmQuit(win->ghostwin))                return;        }    }    /* let WM_exit do all freeing, for correct quit.blend save */    if (do_exit) {        WM_exit(C);    }    else {        bScreen *screen = win->screen;        BLI_remlink(&wm->windows, win);        wm_draw_window_clear(win);        CTX_wm_window_set(C, win);  /* needed by handlers */        WM_event_remove_handlers(C, &win->handlers);        WM_event_remove_handlers(C, &win->modalhandlers);        ED_screen_exit(C, win, win->screen);        wm_window_free(C, wm, win);        /* if temp screen, delete it after window free (it stops jobs that can access it) */        if (screen->temp) {            Main *bmain = CTX_data_main(C);            BKE_libblock_free(bmain, screen);        }    }}

static int controller_remove_exec(bContext *C, wmOperator *op){    Object *ob = NULL;    bController *cont = edit_controller_property_get(C, op, &ob);    if (!cont)        return OPERATOR_CANCELLED;    BLI_remlink(&(ob->controllers), cont);    unlink_controller(cont);    free_controller(cont);    WM_event_add_notifier(C, NC_LOGIC, NULL);    return OPERATOR_FINISHED;}

static int actuator_remove_exec(bContext *C, wmOperator *op){    Object *ob = NULL;    bActuator *act = edit_actuator_property_get(C, op, &ob);    if (!act)        return OPERATOR_CANCELLED;    BLI_remlink(&(ob->actuators), act);    unlink_actuator(act);    free_actuator(act);    WM_event_add_notifier(C, NC_LOGIC, NULL);    return OPERATOR_FINISHED;}

/* call on application exit */void BLI_callback_global_finalize(void){	eCbEvent evt;	for (evt = 0; evt < BLI_CB_EVT_TOT; evt++) {		ListBase *lb = &callback_slots[evt];		bCallbackFuncStore *funcstore;		bCallbackFuncStore *funcstore_next;		for (funcstore = (bCallbackFuncStore *)lb->first; funcstore; funcstore = funcstore_next) {			funcstore_next = (bCallbackFuncStore *)funcstore->next;			BLI_remlink(lb, funcstore);			if (funcstore->alloc) {				MEM_freeN(funcstore);			}		}	}}

/* free all MetaElems from ListBase */static void freeMetaElemlist(ListBase *lb){	MetaElem *ml, *next;	if (lb == NULL) return;	ml = lb->first;	while (ml) {		next = ml->next;		BLI_remlink(lb, ml);		MEM_freeN(ml);		ml = next;	}	lb->first = lb->last = NULL;}

int unpackImage(ReportList *reports, Image *ima, int how){	int ret_value = RET_ERROR;	if (ima != NULL) {		while (ima->packedfiles.last) {			char localname[FILE_MAX], absname[FILE_MAX];			char *newname;			ImagePackedFile *imapf = ima->packedfiles.last;			unpack_generate_paths(imapf->filepath, (ID *)ima, absname, localname, sizeof(absname), sizeof(localname));			newname = unpackFile(reports, absname, localname, imapf->packedfile, how);			if (newname != NULL) {				ImageView *iv;				ret_value = ret_value == RET_ERROR ? RET_ERROR : RET_OK;				freePackedFile(imapf->packedfile);				imapf->packedfile = NULL;				/* update the new corresponding view filepath */				iv = BLI_findstring(&ima->views, imapf->filepath, offsetof(ImageView, filepath));				if (iv) {					BLI_strncpy(iv->filepath, newname, sizeof(imapf->filepath));				}				/* keep the new name in the image for non-pack specific reasons */				if (how != PF_REMOVE) {					BLI_strncpy(ima->name, newname, sizeof(imapf->filepath));				}				MEM_freeN(newname);			}			else {				ret_value = RET_ERROR;			}			BLI_remlink(&ima->packedfiles, imapf);			MEM_freeN(imapf);		}	}	if (ret_value == RET_OK) {		BKE_image_signal(ima, NULL, IMA_SIGNAL_RELOAD);	}	return(ret_value);}

void RE_engines_exit(void){	RenderEngineType *type, *next;	for (type = R_engines.first; type; type = next) {		next = type->next;		BLI_remlink(&R_engines, type);		if (!(type->flag & RE_INTERNAL)) {			if (type->ext.free)				type->ext.free(type->ext.data);			MEM_freeN(type);		}	}}

/* To be able to read files without windows closing, opening, moving * we try to prepare for worst case: * - active window gets active screen from file * - restoring the screens from non-active windows * Best case is all screens match, in that case they get assigned to proper window */static void wm_window_match_init(bContext *C, ListBase *wmlist){	wmWindowManager *wm;	wmWindow *win, *active_win;		*wmlist = G.main->wm;	BLI_listbase_clear(&G.main->wm);		active_win = CTX_wm_window(C);	/* first wrap up running stuff */	/* code copied from wm_init_exit.c */	for (wm = wmlist->first; wm; wm = wm->id.next) {				WM_jobs_kill_all(wm);				for (win = wm->windows.first; win; win = win->next) {					CTX_wm_window_set(C, win);  /* needed by operator close callbacks */			WM_event_remove_handlers(C, &win->handlers);			WM_event_remove_handlers(C, &win->modalhandlers);			ED_screen_exit(C, win, win->screen);		}	}		/* reset active window */	CTX_wm_window_set(C, active_win);	ED_editors_exit(C);	/* just had return; here from r12991, this code could just get removed?*/#if 0	if (wm == NULL) return;	if (G.fileflags & G_FILE_NO_UI) return;		/* we take apart the used screens from non-active window */	for (win = wm->windows.first; win; win = win->next) {		BLI_strncpy(win->screenname, win->screen->id.name, MAX_ID_NAME);		if (win != wm->winactive) {			BLI_remlink(&G.main->screen, win->screen);			//BLI_addtail(screenbase, win->screen);		}	}#endif}

void blf_font_free(FontBLF *font){	GlyphCacheBLF *gc;	font->glyph_cache = NULL;	while (font->cache.first) {		gc = font->cache.first;		BLI_remlink(&font->cache, gc);		blf_glyph_cache_free(gc);	}	FT_Done_Face(font->face);	if (font->filename)		MEM_freeN(font->filename);	if (font->name)		MEM_freeN(font->name);	MEM_freeN(font);}

void blf_glyph_cache_clear(FontBLF *font){	GlyphCacheBLF *gc;	GlyphBLF *g;	int i;	for (gc = font->cache.first; gc; gc = gc->next) {		for (i = 0; i < 257; i++) {			while (gc->bucket[i].first) {				g = gc->bucket[i].first;				BLI_remlink(&(gc->bucket[i]), g);				blf_glyph_free(g);			}		}		memset(gc->glyph_ascii_table, 0, sizeof(gc->glyph_ascii_table));	}}

void blf_glyph_cache_free(GlyphCacheBLF *gc){	GlyphBLF *g;	int i;	for (i = 0; i < 257; i++) {		while (gc->bucket[i].first) {			g = gc->bucket[i].first;			BLI_remlink(&(gc->bucket[i]), g);			blf_glyph_free(g);		}	}	if (gc->cur_tex+1 > 0)		glDeleteTextures(gc->cur_tex+1, gc->textures);	free((void *)gc->textures);	MEM_freeN(gc);}

static void render_result_views_free(RenderResult *res){	while (res->views.first) {		RenderView *rv = res->views.first;		BLI_remlink(&res->views, rv);		if (rv->rect32)			MEM_freeN(rv->rect32);		if (rv->rectz)			MEM_freeN(rv->rectz);		if (rv->rectf)			MEM_freeN(rv->rectf);		MEM_freeN(rv);	}}

void WM_event_remove_timer(wmWindowManager *wm, wmWindow *UNUSED(win), wmTimer *timer){	wmTimer *wt;		/* extra security check */	for (wt = wm->timers.first; wt; wt = wt->next)		if (wt == timer)			break;	if (wt) {		if (wm->reports.reporttimer == wt)			wm->reports.reporttimer = NULL;				BLI_remlink(&wm->timers, wt);		if (wt->customdata)			MEM_freeN(wt->customdata);		MEM_freeN(wt);	}}

/* also used for ob==NULL */int rem_from_group(Group *group, Object *ob){	GroupObject *go, *gon;	int removed = 0;	if(group==NULL) return 0;		go= group->gobject.first;	while(go) {		gon= go->next;		if(go->ob==ob) {			BLI_remlink(&group->gobject, go);			free_group_object(go);			removed = 1;			/* should break here since an object being in a group twice cant happen? */		}		go= gon;	}	return removed;}

/* called on event handling by event_system.c */void wm_operator_register(bContext *C, wmOperator *op){	wmWindowManager *wm= CTX_wm_manager(C);	int tot;	BLI_addtail(&wm->operators, op);	tot= BLI_countlist(&wm->operators);		while(tot>MAX_OP_REGISTERED) {		wmOperator *opt= wm->operators.first;		BLI_remlink(&wm->operators, opt);		WM_operator_free(opt);		tot--;	}		/* so the console is redrawn */	WM_event_add_notifier(C, NC_SPACE|ND_SPACE_INFO_REPORT, NULL);	WM_event_add_notifier(C, NC_WM|ND_HISTORY, NULL);}

void RE_engine_end_result(RenderEngine *engine, RenderResult *result, int cancel, int merge_results){	Render *re = engine->re;	if (!result) {		return;	}	/* merge. on break, don't merge in result for preview renders, looks nicer */	if (!cancel) {		/* for exr tile render, detect tiles that are done */		RenderPart *pa = get_part_from_result(re, result);		if (pa) {			pa->status = PART_STATUS_READY;		}		else if (re->result->do_exr_tile) {			/* if written result does not match any tile and we are using save			 * buffers, we are going to get openexr save errors */			fprintf(stderr, "RenderEngine.end_result: dimensions do not match any OpenEXR tile./n");		}	}	if (!cancel || merge_results) {		if (re->result->do_exr_tile) {			if (!cancel) {				render_result_exr_file_merge(re->result, result);			}		}		else if (!(re->test_break(re->tbh) && (re->r.scemode & R_BUTS_PREVIEW)))			render_result_merge(re->result, result);		/* draw */		if (!re->test_break(re->tbh)) {			result->renlay = result->layers.first; /* weak, draws first layer always */			re->display_update(re->duh, result, NULL);		}	}	/* free */	BLI_remlink(&engine->fullresult, result);	render_result_free(result);}

static bool task_scheduler_thread_wait_pop(TaskScheduler *scheduler, Task **task){	BLI_mutex_lock(&scheduler->queue_mutex);	while (!scheduler->queue.first && !scheduler->do_exit)		BLI_condition_wait(&scheduler->queue_cond, &scheduler->queue_mutex);	if (!scheduler->queue.first) {		BLI_mutex_unlock(&scheduler->queue_mutex);		BLI_assert(scheduler->do_exit);		return false;	}		*task = scheduler->queue.first;	BLI_remlink(&scheduler->queue, *task);	BLI_mutex_unlock(&scheduler->queue_mutex);	return true;}

static bool gpencil_object_modifier_remove(Main *bmain,                                           Object *ob,                                           GpencilModifierData *md,                                           bool *UNUSED(r_sort_depsgraph)){  /* It seems on rapid delete it is possible to   * get called twice on same modifier, so make   * sure it is in list. */  if (BLI_findindex(&ob->greasepencil_modifiers, md) == -1) {    return 0;  }  DEG_relations_tag_update(bmain);  BLI_remlink(&ob->greasepencil_modifiers, md);  BKE_gpencil_modifier_free(md);  BKE_object_free_derived_caches(ob);  return 1;}

static wmKeyMapItem *rna_KeyMap_item_new_from_item(wmKeyMap *km,                                                   ReportList *reports,                                                   wmKeyMapItem *kmi_src,                                                   bool head){  /*  wmWindowManager *wm = CTX_wm_manager(C); */  if ((km->flag & KEYMAP_MODAL) == (kmi_src->idname[0] != '/0')) {    BKE_report(reports, RPT_ERROR, "Can not mix modal/non-modal items");    return NULL;  }  /* create keymap item */  wmKeyMapItem *kmi = WM_keymap_add_item_copy(km, kmi_src);  if (head) {    BLI_remlink(&km->items, kmi);    BLI_addhead(&km->items, kmi);  }  return kmi;}

int ED_object_modifier_move_down(ReportList *reports, Object *ob, ModifierData *md){	if(md->next) {		ModifierTypeInfo *mti = modifierType_getInfo(md->type);		if(mti->flags&eModifierTypeFlag_RequiresOriginalData) {			ModifierTypeInfo *nmti = modifierType_getInfo(md->next->type);			if(nmti->type!=eModifierTypeType_OnlyDeform) {				BKE_report(reports, RPT_WARNING, "Cannot move beyond a non-deforming modifier");				return 0;			}		}		BLI_remlink(&ob->modifiers, md);		BLI_insertlink(&ob->modifiers, md->next, md);	}	return 1;}

int ED_object_modifier_move_up(ReportList *reports, Object *ob, ModifierData *md){	if(md->prev) {		ModifierTypeInfo *mti = modifierType_getInfo(md->type);		if(mti->type!=eModifierTypeType_OnlyDeform) {			ModifierTypeInfo *nmti = modifierType_getInfo(md->prev->type);			if(nmti->flags&eModifierTypeFlag_RequiresOriginalData) {				BKE_report(reports, RPT_WARNING, "Cannot move above a modifier requiring original data");				return 0;			}		}		BLI_remlink(&ob->modifiers, md);		BLI_insertlink(&ob->modifiers, md->prev->prev, md);	}	return 1;}

static int state_del_exec(bContext *C, wmOperator *UNUSED(op)){	Main *bmain = CTX_data_main(C);	Scene *scene = CTX_data_scene(C);	PointerRNA ptr = CTX_data_pointer_get_type(C, "particle_system", &RNA_ParticleSystem);	ParticleSystem *psys= ptr.data;	Object *ob = ptr.id.data;	ParticleSettings *part;	BoidState *state;	if(!psys || !psys->part || psys->part->phystype != PART_PHYS_BOIDS)		return OPERATOR_CANCELLED;	part = psys->part;		for(state=part->boids->states.first; state; state=state->next) {		if(state->flag & BOIDSTATE_CURRENT) {			BLI_remlink(&part->boids->states, state);			MEM_freeN(state);			break;		}	}	/* there must be at least one state */	if(!part->boids->states.first) {		state = boid_new_state(part->boids);		BLI_addtail(&part->boids->states, state);		}	else		state = part->boids->states.first;	state->flag |= BOIDSTATE_CURRENT;	DAG_scene_sort(bmain, scene);	DAG_id_tag_update(&psys->part->id, OB_RECALC_DATA|PSYS_RECALC_RESET);	WM_event_add_notifier(C, NC_OBJECT|ND_DRAW, ob);		return OPERATOR_FINISHED;}

void BLI_sortlist_r(ListBase *listbase, void *thunk, int (*cmp)(void *, void *, void *)){	Link *current = NULL;	Link *previous = NULL;	Link *next = NULL;	if (listbase->first != listbase->last) {		for (previous = listbase->first, current = previous->next; current; current = next) {			next = current->next;			previous = current->prev;			BLI_remlink(listbase, current);			while (previous && cmp(thunk, previous, current) == 1) {				previous = previous->prev;			}			BLI_insertlinkafter(listbase, previous, current);		}	}}