ClangFormat: apply to source, most of intern
[blender.git] / source / blender / blenkernel / intern / icons.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2006-2007 Blender Foundation.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup bke
22  */
23
24 #include <math.h>
25 #include <stdlib.h>
26 #include <string.h>
27
28 #include "CLG_log.h"
29
30 #include "MEM_guardedalloc.h"
31
32 #include "DNA_brush_types.h"
33 #include "DNA_collection_types.h"
34 #include "DNA_gpencil_types.h"
35 #include "DNA_light_types.h"
36 #include "DNA_material_types.h"
37 #include "DNA_object_types.h"
38 #include "DNA_scene_types.h"
39 #include "DNA_screen_types.h"
40 #include "DNA_texture_types.h"
41 #include "DNA_world_types.h"
42
43 #include "BLI_utildefines.h"
44 #include "BLI_ghash.h"
45 #include "BLI_linklist_lockfree.h"
46 #include "BLI_string.h"
47 #include "BLI_fileops.h"
48 #include "BLI_threads.h"
49
50 #include "BKE_icons.h"
51 #include "BKE_global.h" /* only for G.background test */
52 #include "BKE_studiolight.h"
53
54 #include "BLI_sys_types.h"  // for intptr_t support
55
56 #include "GPU_texture.h"
57
58 #include "IMB_imbuf.h"
59 #include "IMB_imbuf_types.h"
60 #include "IMB_thumbs.h"
61
62 /**
63  * Only allow non-managed icons to be removed (by Python for eg).
64  * Previews & ID's have their own functions to remove icons.
65  */
66 enum {
67   ICON_FLAG_MANAGED = (1 << 0),
68 };
69
70 /* GLOBALS */
71
72 static CLG_LogRef LOG = {"bke.icons"};
73
74 static GHash *gIcons = NULL;
75
76 static int gNextIconId = 1;
77
78 static int gFirstIconId = 1;
79
80 static GHash *gCachedPreviews = NULL;
81
82 /* Queue of icons for deferred deletion. */
83 typedef struct DeferredIconDeleteNode {
84   struct DeferredIconDeleteNode *next;
85   int icon_id;
86 } DeferredIconDeleteNode;
87 static LockfreeLinkList g_icon_delete_queue;
88
89 static void icon_free(void *val)
90 {
91   Icon *icon = val;
92
93   if (icon) {
94     if (icon->obj_type == ICON_DATA_GEOM) {
95       struct Icon_Geom *obj = icon->obj;
96       if (obj->mem) {
97         /* coords & colors are part of this memory. */
98         MEM_freeN((void *)obj->mem);
99       }
100       else {
101         MEM_freeN((void *)obj->coords);
102         MEM_freeN((void *)obj->colors);
103       }
104       MEM_freeN(icon->obj);
105     }
106
107     if (icon->drawinfo_free) {
108       icon->drawinfo_free(icon->drawinfo);
109     }
110     else if (icon->drawinfo) {
111       MEM_freeN(icon->drawinfo);
112     }
113     MEM_freeN(icon);
114   }
115 }
116
117 static void icon_free_data(int icon_id, Icon *icon)
118 {
119   if (icon->obj_type == ICON_DATA_ID) {
120     ((ID *)(icon->obj))->icon_id = 0;
121   }
122   else if (icon->obj_type == ICON_DATA_PREVIEW) {
123     ((PreviewImage *)(icon->obj))->icon_id = 0;
124   }
125   else if (icon->obj_type == ICON_DATA_GPLAYER) {
126     ((bGPDlayer *)(icon->obj))->runtime.icon_id = 0;
127   }
128   else if (icon->obj_type == ICON_DATA_GEOM) {
129     ((struct Icon_Geom *)(icon->obj))->icon_id = 0;
130   }
131   else if (icon->obj_type == ICON_DATA_STUDIOLIGHT) {
132     StudioLight *sl = icon->obj;
133     if (sl != NULL) {
134       BKE_studiolight_unset_icon_id(sl, icon_id);
135     }
136   }
137   else {
138     BLI_assert(0);
139   }
140 }
141
142 /* create an id for a new icon and make sure that ids from deleted icons get reused
143  * after the integer number range is used up */
144 static int get_next_free_id(void)
145 {
146   BLI_assert(BLI_thread_is_main());
147   int startId = gFirstIconId;
148
149   /* if we haven't used up the int number range, we just return the next int */
150   if (gNextIconId >= gFirstIconId)
151     return gNextIconId++;
152
153   /* now we try to find the smallest icon id not stored in the gIcons hash */
154   while (BLI_ghash_lookup(gIcons, POINTER_FROM_INT(startId)) && startId >= gFirstIconId)
155     startId++;
156
157   /* if we found a suitable one that isn't used yet, return it */
158   if (startId >= gFirstIconId)
159     return startId;
160
161   /* fail */
162   return 0;
163 }
164
165 void BKE_icons_init(int first_dyn_id)
166 {
167   BLI_assert(BLI_thread_is_main());
168
169   gNextIconId = first_dyn_id;
170   gFirstIconId = first_dyn_id;
171
172   if (!gIcons) {
173     gIcons = BLI_ghash_int_new(__func__);
174     BLI_linklist_lockfree_init(&g_icon_delete_queue);
175   }
176
177   if (!gCachedPreviews) {
178     gCachedPreviews = BLI_ghash_str_new(__func__);
179   }
180 }
181
182 void BKE_icons_free(void)
183 {
184   BLI_assert(BLI_thread_is_main());
185
186   if (gIcons) {
187     BLI_ghash_free(gIcons, NULL, icon_free);
188     gIcons = NULL;
189   }
190
191   if (gCachedPreviews) {
192     BLI_ghash_free(gCachedPreviews, MEM_freeN, BKE_previewimg_freefunc);
193     gCachedPreviews = NULL;
194   }
195
196   BLI_linklist_lockfree_free(&g_icon_delete_queue, MEM_freeN);
197 }
198
199 void BKE_icons_deferred_free(void)
200 {
201   BLI_assert(BLI_thread_is_main());
202
203   for (DeferredIconDeleteNode *node =
204            (DeferredIconDeleteNode *)BLI_linklist_lockfree_begin(&g_icon_delete_queue);
205        node != NULL;
206        node = node->next) {
207     BLI_ghash_remove(gIcons, POINTER_FROM_INT(node->icon_id), NULL, icon_free);
208   }
209   BLI_linklist_lockfree_clear(&g_icon_delete_queue, MEM_freeN);
210 }
211
212 static PreviewImage *previewimg_create_ex(size_t deferred_data_size)
213 {
214   PreviewImage *prv_img = NULL;
215   int i;
216
217   prv_img = MEM_mallocN(sizeof(PreviewImage) + deferred_data_size, "img_prv");
218   memset(prv_img, 0, sizeof(*prv_img)); /* leave deferred data dirty */
219
220   if (deferred_data_size) {
221     prv_img->tag |= PRV_TAG_DEFFERED;
222   }
223
224   for (i = 0; i < NUM_ICON_SIZES; ++i) {
225     prv_img->flag[i] |= PRV_CHANGED;
226     prv_img->changed_timestamp[i] = 0;
227   }
228   return prv_img;
229 }
230
231 PreviewImage *BKE_previewimg_create(void)
232 {
233   return previewimg_create_ex(0);
234 }
235
236 void BKE_previewimg_freefunc(void *link)
237 {
238   PreviewImage *prv = (PreviewImage *)link;
239   if (prv) {
240     int i;
241
242     for (i = 0; i < NUM_ICON_SIZES; ++i) {
243       if (prv->rect[i]) {
244         MEM_freeN(prv->rect[i]);
245       }
246       if (prv->gputexture[i])
247         GPU_texture_free(prv->gputexture[i]);
248     }
249
250     MEM_freeN(prv);
251   }
252 }
253
254 void BKE_previewimg_free(PreviewImage **prv)
255 {
256   if (prv && (*prv)) {
257     BKE_previewimg_freefunc(*prv);
258     *prv = NULL;
259   }
260 }
261
262 void BKE_previewimg_clear_single(struct PreviewImage *prv, enum eIconSizes size)
263 {
264   MEM_SAFE_FREE(prv->rect[size]);
265   if (prv->gputexture[size]) {
266     GPU_texture_free(prv->gputexture[size]);
267   }
268   prv->h[size] = prv->w[size] = 0;
269   prv->flag[size] |= PRV_CHANGED;
270   prv->flag[size] &= ~PRV_USER_EDITED;
271   prv->changed_timestamp[size] = 0;
272 }
273
274 void BKE_previewimg_clear(struct PreviewImage *prv)
275 {
276   int i;
277   for (i = 0; i < NUM_ICON_SIZES; ++i) {
278     BKE_previewimg_clear_single(prv, i);
279   }
280 }
281
282 PreviewImage *BKE_previewimg_copy(const PreviewImage *prv)
283 {
284   PreviewImage *prv_img = NULL;
285   int i;
286
287   if (prv) {
288     prv_img = MEM_dupallocN(prv);
289     for (i = 0; i < NUM_ICON_SIZES; ++i) {
290       if (prv->rect[i]) {
291         prv_img->rect[i] = MEM_dupallocN(prv->rect[i]);
292       }
293       prv_img->gputexture[i] = NULL;
294     }
295   }
296   return prv_img;
297 }
298
299 /** Duplicate preview image from \a id and clear icon_id, to be used by datablock copy functions. */
300 void BKE_previewimg_id_copy(ID *new_id, const ID *old_id)
301 {
302   PreviewImage **old_prv_p = BKE_previewimg_id_get_p(old_id);
303   PreviewImage **new_prv_p = BKE_previewimg_id_get_p(new_id);
304
305   if (old_prv_p && *old_prv_p) {
306     BLI_assert(new_prv_p != NULL && ELEM(*new_prv_p, NULL, *old_prv_p));
307     //      const int new_icon_id = get_next_free_id();
308
309     //      if (new_icon_id == 0) {
310     //          return;  /* Failure. */
311     //      }
312     *new_prv_p = BKE_previewimg_copy(*old_prv_p);
313     new_id->icon_id = (*new_prv_p)->icon_id = 0;
314   }
315 }
316
317 PreviewImage **BKE_previewimg_id_get_p(const ID *id)
318 {
319   switch (GS(id->name)) {
320 #define ID_PRV_CASE(id_code, id_struct) \
321   case id_code: { \
322     return &((id_struct *)id)->preview; \
323   } \
324     ((void)0)
325     ID_PRV_CASE(ID_MA, Material);
326     ID_PRV_CASE(ID_TE, Tex);
327     ID_PRV_CASE(ID_WO, World);
328     ID_PRV_CASE(ID_LA, Light);
329     ID_PRV_CASE(ID_IM, Image);
330     ID_PRV_CASE(ID_BR, Brush);
331     ID_PRV_CASE(ID_OB, Object);
332     ID_PRV_CASE(ID_GR, Collection);
333     ID_PRV_CASE(ID_SCE, Scene);
334     ID_PRV_CASE(ID_SCR, bScreen);
335 #undef ID_PRV_CASE
336     default:
337       break;
338   }
339
340   return NULL;
341 }
342
343 void BKE_previewimg_id_free(ID *id)
344 {
345   PreviewImage **prv_p = BKE_previewimg_id_get_p(id);
346   if (prv_p) {
347     BKE_previewimg_free(prv_p);
348   }
349 }
350
351 PreviewImage *BKE_previewimg_id_ensure(ID *id)
352 {
353   PreviewImage **prv_p = BKE_previewimg_id_get_p(id);
354
355   if (prv_p) {
356     if (*prv_p == NULL) {
357       *prv_p = BKE_previewimg_create();
358     }
359     return *prv_p;
360   }
361
362   return NULL;
363 }
364
365 PreviewImage *BKE_previewimg_cached_get(const char *name)
366 {
367   return BLI_ghash_lookup(gCachedPreviews, name);
368 }
369
370 /**
371  * Generate an empty PreviewImage, if not yet existing.
372  */
373 PreviewImage *BKE_previewimg_cached_ensure(const char *name)
374 {
375   PreviewImage *prv = NULL;
376   void **key_p, **prv_p;
377
378   if (!BLI_ghash_ensure_p_ex(gCachedPreviews, name, &key_p, &prv_p)) {
379     *key_p = BLI_strdup(name);
380     *prv_p = BKE_previewimg_create();
381   }
382   prv = *prv_p;
383   BLI_assert(prv);
384
385   return prv;
386 }
387
388 /**
389  * Generate a PreviewImage from given file path, using thumbnails management, if not yet existing.
390  */
391 PreviewImage *BKE_previewimg_cached_thumbnail_read(const char *name,
392                                                    const char *path,
393                                                    const int source,
394                                                    bool force_update)
395 {
396   PreviewImage *prv = NULL;
397   void **prv_p;
398
399   prv_p = BLI_ghash_lookup_p(gCachedPreviews, name);
400
401   if (prv_p) {
402     prv = *prv_p;
403     BLI_assert(prv);
404   }
405
406   if (prv && force_update) {
407     const char *prv_deferred_data = PRV_DEFERRED_DATA(prv);
408     if (((int)prv_deferred_data[0] == source) && STREQ(&prv_deferred_data[1], path)) {
409       /* If same path, no need to re-allocate preview, just clear it up. */
410       BKE_previewimg_clear(prv);
411     }
412     else {
413       BKE_previewimg_free(&prv);
414     }
415   }
416
417   if (!prv) {
418     /* We pack needed data for lazy loading (source type, in a single char, and path). */
419     const size_t deferred_data_size = strlen(path) + 2;
420     char *deferred_data;
421
422     prv = previewimg_create_ex(deferred_data_size);
423     deferred_data = PRV_DEFERRED_DATA(prv);
424     deferred_data[0] = source;
425     memcpy(&deferred_data[1], path, deferred_data_size - 1);
426
427     force_update = true;
428   }
429
430   if (force_update) {
431     if (prv_p) {
432       *prv_p = prv;
433     }
434     else {
435       BLI_ghash_insert(gCachedPreviews, BLI_strdup(name), prv);
436     }
437   }
438
439   return prv;
440 }
441
442 void BKE_previewimg_cached_release_pointer(PreviewImage *prv)
443 {
444   if (prv) {
445     if (prv->tag & PRV_TAG_DEFFERED_RENDERING) {
446       /* We cannot delete the preview while it is being loaded in another thread... */
447       prv->tag |= PRV_TAG_DEFFERED_DELETE;
448       return;
449     }
450     if (prv->icon_id) {
451       BKE_icon_delete(prv->icon_id);
452     }
453     BKE_previewimg_freefunc(prv);
454   }
455 }
456
457 void BKE_previewimg_cached_release(const char *name)
458 {
459   PreviewImage *prv = BLI_ghash_popkey(gCachedPreviews, name, MEM_freeN);
460
461   BKE_previewimg_cached_release_pointer(prv);
462 }
463
464 /** Handle deferred (lazy) loading/generation of preview image, if needed.
465  * For now, only used with file thumbnails. */
466 void BKE_previewimg_ensure(PreviewImage *prv, const int size)
467 {
468   if ((prv->tag & PRV_TAG_DEFFERED) != 0) {
469     const bool do_icon = ((size == ICON_SIZE_ICON) && !prv->rect[ICON_SIZE_ICON]);
470     const bool do_preview = ((size == ICON_SIZE_PREVIEW) && !prv->rect[ICON_SIZE_PREVIEW]);
471
472     if (do_icon || do_preview) {
473       ImBuf *thumb;
474       char *prv_deferred_data = PRV_DEFERRED_DATA(prv);
475       int source = prv_deferred_data[0];
476       char *path = &prv_deferred_data[1];
477       int icon_w, icon_h;
478
479       thumb = IMB_thumb_manage(path, THB_LARGE, source);
480
481       if (thumb) {
482         /* PreviewImage assumes premultiplied alhpa... */
483         IMB_premultiply_alpha(thumb);
484
485         if (do_preview) {
486           prv->w[ICON_SIZE_PREVIEW] = thumb->x;
487           prv->h[ICON_SIZE_PREVIEW] = thumb->y;
488           prv->rect[ICON_SIZE_PREVIEW] = MEM_dupallocN(thumb->rect);
489           prv->flag[ICON_SIZE_PREVIEW] &= ~(PRV_CHANGED | PRV_USER_EDITED);
490         }
491         if (do_icon) {
492           if (thumb->x > thumb->y) {
493             icon_w = ICON_RENDER_DEFAULT_HEIGHT;
494             icon_h = (thumb->y * icon_w) / thumb->x + 1;
495           }
496           else if (thumb->x < thumb->y) {
497             icon_h = ICON_RENDER_DEFAULT_HEIGHT;
498             icon_w = (thumb->x * icon_h) / thumb->y + 1;
499           }
500           else {
501             icon_w = icon_h = ICON_RENDER_DEFAULT_HEIGHT;
502           }
503
504           IMB_scaleImBuf(thumb, icon_w, icon_h);
505           prv->w[ICON_SIZE_ICON] = icon_w;
506           prv->h[ICON_SIZE_ICON] = icon_h;
507           prv->rect[ICON_SIZE_ICON] = MEM_dupallocN(thumb->rect);
508           prv->flag[ICON_SIZE_ICON] &= ~(PRV_CHANGED | PRV_USER_EDITED);
509         }
510         IMB_freeImBuf(thumb);
511       }
512     }
513   }
514 }
515
516 void BKE_icon_changed(const int icon_id)
517 {
518   BLI_assert(BLI_thread_is_main());
519
520   Icon *icon = NULL;
521
522   if (!icon_id || G.background)
523     return;
524
525   icon = BLI_ghash_lookup(gIcons, POINTER_FROM_INT(icon_id));
526
527   if (icon) {
528     /* We *only* expect ID-tied icons here, not non-ID icon/preview! */
529     BLI_assert(icon->id_type != 0);
530     BLI_assert(icon->obj_type == ICON_DATA_ID);
531
532     /* Do not enforce creation of previews for valid ID types using BKE_previewimg_id_ensure() here ,
533      * we only want to ensure *existing* preview images are properly tagged as changed/invalid, that's all. */
534     PreviewImage **p_prv = BKE_previewimg_id_get_p((ID *)icon->obj);
535
536     /* If we have previews, they all are now invalid changed. */
537     if (p_prv && *p_prv) {
538       int i;
539       for (i = 0; i < NUM_ICON_SIZES; ++i) {
540         (*p_prv)->flag[i] |= PRV_CHANGED;
541         (*p_prv)->changed_timestamp[i]++;
542       }
543     }
544   }
545 }
546
547 static Icon *icon_create(int icon_id, int obj_type, void *obj)
548 {
549   Icon *new_icon = MEM_mallocN(sizeof(Icon), __func__);
550
551   new_icon->obj_type = obj_type;
552   new_icon->obj = obj;
553   new_icon->id_type = 0;
554   new_icon->flag = 0;
555
556   /* next two lines make sure image gets created */
557   new_icon->drawinfo = NULL;
558   new_icon->drawinfo_free = NULL;
559
560   BLI_ghash_insert(gIcons, POINTER_FROM_INT(icon_id), new_icon);
561
562   return new_icon;
563 }
564
565 static int icon_id_ensure_create_icon(struct ID *id)
566 {
567   BLI_assert(BLI_thread_is_main());
568
569   Icon *icon = icon_create(id->icon_id, ICON_DATA_ID, id);
570   icon->id_type = GS(id->name);
571   icon->flag = ICON_FLAG_MANAGED;
572
573   return id->icon_id;
574 }
575
576 int BKE_icon_id_ensure(struct ID *id)
577 {
578   /* Never handle icons in non-main thread! */
579   BLI_assert(BLI_thread_is_main());
580
581   if (!id || G.background) {
582     return 0;
583   }
584
585   if (id->icon_id)
586     return id->icon_id;
587
588   id->icon_id = get_next_free_id();
589
590   if (!id->icon_id) {
591     CLOG_ERROR(&LOG, "not enough IDs");
592     return 0;
593   }
594
595   /* Ensure we synchronize ID icon_id with its previewimage if it has one. */
596   PreviewImage **p_prv = BKE_previewimg_id_get_p(id);
597   if (p_prv && *p_prv) {
598     BLI_assert(ELEM((*p_prv)->icon_id, 0, id->icon_id));
599     (*p_prv)->icon_id = id->icon_id;
600   }
601
602   return icon_id_ensure_create_icon(id);
603 }
604
605 static int icon_gplayer_color_ensure_create_icon(bGPDlayer *gpl)
606 {
607   BLI_assert(BLI_thread_is_main());
608
609   /* NOTE: The color previews for GP Layers don't really need
610    * to be "rendered" to image per se (as it will just be a plain
611    * colored rectangle), we need to define icon data here so that
612    * we can store a pointer to the layer data in icon->obj.
613    */
614   Icon *icon = icon_create(gpl->runtime.icon_id, ICON_DATA_GPLAYER, gpl);
615   icon->flag = ICON_FLAG_MANAGED;
616
617   return gpl->runtime.icon_id;
618 }
619
620 int BKE_icon_gplayer_color_ensure(bGPDlayer *gpl)
621 {
622   /* Never handle icons in non-main thread! */
623   BLI_assert(BLI_thread_is_main());
624
625   if (!gpl || G.background) {
626     return 0;
627   }
628
629   if (gpl->runtime.icon_id)
630     return gpl->runtime.icon_id;
631
632   gpl->runtime.icon_id = get_next_free_id();
633
634   if (!gpl->runtime.icon_id) {
635     CLOG_ERROR(&LOG, "not enough IDs");
636     return 0;
637   }
638
639   return icon_gplayer_color_ensure_create_icon(gpl);
640 }
641
642 /**
643  * Return icon id of given preview, or create new icon if not found.
644  */
645 int BKE_icon_preview_ensure(ID *id, PreviewImage *preview)
646 {
647   if (!preview || G.background)
648     return 0;
649
650   if (id) {
651     BLI_assert(BKE_previewimg_id_ensure(id) == preview);
652   }
653
654   if (preview->icon_id) {
655     BLI_assert(!id || !id->icon_id || id->icon_id == preview->icon_id);
656     return preview->icon_id;
657   }
658
659   if (id && id->icon_id) {
660     preview->icon_id = id->icon_id;
661     return preview->icon_id;
662   }
663
664   preview->icon_id = get_next_free_id();
665
666   if (!preview->icon_id) {
667     CLOG_ERROR(&LOG, "not enough IDs");
668     return 0;
669   }
670
671   /* Ensure we synchronize ID icon_id with its previewimage if available, and generate suitable 'ID' icon. */
672   if (id) {
673     id->icon_id = preview->icon_id;
674     return icon_id_ensure_create_icon(id);
675   }
676
677   Icon *icon = icon_create(preview->icon_id, ICON_DATA_PREVIEW, preview);
678   icon->flag = ICON_FLAG_MANAGED;
679
680   return preview->icon_id;
681 }
682
683 Icon *BKE_icon_get(const int icon_id)
684 {
685   BLI_assert(BLI_thread_is_main());
686
687   Icon *icon = NULL;
688
689   icon = BLI_ghash_lookup(gIcons, POINTER_FROM_INT(icon_id));
690
691   if (!icon) {
692     CLOG_ERROR(&LOG, "no icon for icon ID: %d", icon_id);
693     return NULL;
694   }
695
696   return icon;
697 }
698
699 void BKE_icon_set(const int icon_id, struct Icon *icon)
700 {
701   BLI_assert(BLI_thread_is_main());
702
703   void **val_p;
704
705   if (BLI_ghash_ensure_p(gIcons, POINTER_FROM_INT(icon_id), &val_p)) {
706     CLOG_ERROR(&LOG, "icon already set: %d", icon_id);
707     return;
708   }
709
710   *val_p = icon;
711 }
712
713 static void icon_add_to_deferred_delete_queue(int icon_id)
714 {
715   DeferredIconDeleteNode *node = MEM_mallocN(sizeof(DeferredIconDeleteNode), __func__);
716   node->icon_id = icon_id;
717   BLI_linklist_lockfree_insert(&g_icon_delete_queue, (LockfreeLinkNode *)node);
718 }
719
720 void BKE_icon_id_delete(struct ID *id)
721 {
722   const int icon_id = id->icon_id;
723   if (!icon_id)
724     return; /* no icon defined for library object */
725   id->icon_id = 0;
726
727   if (!BLI_thread_is_main()) {
728     icon_add_to_deferred_delete_queue(icon_id);
729     return;
730   }
731
732   BKE_icons_deferred_free();
733   BLI_ghash_remove(gIcons, POINTER_FROM_INT(icon_id), NULL, icon_free);
734 }
735
736 /**
737  * Remove icon and free data.
738  */
739 bool BKE_icon_delete(const int icon_id)
740 {
741   if (icon_id == 0) {
742     /* no icon defined for library object */
743     return false;
744   }
745
746   Icon *icon = BLI_ghash_popkey(gIcons, POINTER_FROM_INT(icon_id), NULL);
747   if (icon) {
748     icon_free_data(icon_id, icon);
749     icon_free(icon);
750     return true;
751   }
752   else {
753     return false;
754   }
755 }
756
757 bool BKE_icon_delete_unmanaged(const int icon_id)
758 {
759   if (icon_id == 0) {
760     /* no icon defined for library object */
761     return false;
762   }
763
764   Icon *icon = BLI_ghash_popkey(gIcons, POINTER_FROM_INT(icon_id), NULL);
765   if (icon) {
766     if (UNLIKELY(icon->flag & ICON_FLAG_MANAGED)) {
767       BLI_ghash_insert(gIcons, POINTER_FROM_INT(icon_id), icon);
768       return false;
769     }
770     else {
771       icon_free_data(icon_id, icon);
772       icon_free(icon);
773       return true;
774     }
775   }
776   else {
777     return false;
778   }
779 }
780
781 /* -------------------------------------------------------------------- */
782 /** \name Geometry Icon
783  * \{ */
784
785 int BKE_icon_geom_ensure(struct Icon_Geom *geom)
786 {
787   BLI_assert(BLI_thread_is_main());
788
789   if (geom->icon_id) {
790     return geom->icon_id;
791   }
792
793   geom->icon_id = get_next_free_id();
794
795   icon_create(geom->icon_id, ICON_DATA_GEOM, geom);
796   /* Not managed for now, we may want this to be configurable per icon). */
797
798   return geom->icon_id;
799 }
800
801 struct Icon_Geom *BKE_icon_geom_from_memory(const uchar *data, size_t data_len)
802 {
803   BLI_assert(BLI_thread_is_main());
804   if (data_len <= 8) {
805     goto fail;
806   }
807   /* Skip the header. */
808   data_len -= 8;
809   const int div = 3 * 2 * 3;
810   const int coords_len = data_len / div;
811   if (coords_len * div != data_len) {
812     goto fail;
813   }
814
815   const uchar header[4] = {'V', 'C', 'O', 0};
816   const uchar *p = data;
817   if (memcmp(p, header, ARRAY_SIZE(header)) != 0) {
818     goto fail;
819   }
820   p += 4;
821
822   struct Icon_Geom *geom = MEM_mallocN(sizeof(*geom), __func__);
823   geom->coords_range[0] = (int)*p++;
824   geom->coords_range[1] = (int)*p++;
825   /* x, y ignored for now */
826   p += 2;
827
828   geom->coords_len = coords_len;
829   geom->coords = (const void *)p;
830   geom->colors = (const void *)(p + (data_len / 3));
831   geom->icon_id = 0;
832   geom->mem = data;
833   return geom;
834
835 fail:
836   MEM_freeN((void *)data);
837   return NULL;
838 }
839
840 struct Icon_Geom *BKE_icon_geom_from_file(const char *filename)
841 {
842   BLI_assert(BLI_thread_is_main());
843   size_t data_len;
844   uchar *data = BLI_file_read_binary_as_mem(filename, 0, &data_len);
845   if (data == NULL) {
846     return NULL;
847   }
848   return BKE_icon_geom_from_memory(data, data_len);
849 }
850
851 /** \} */
852
853 /** \name Studio Light Icon
854  * \{ */
855 int BKE_icon_ensure_studio_light(struct StudioLight *sl, int id_type)
856 {
857   int icon_id = get_next_free_id();
858   Icon *icon = icon_create(icon_id, ICON_DATA_STUDIOLIGHT, sl);
859   icon->id_type = id_type;
860   return icon_id;
861 }
862 /** \} */