Merging r41158 through r41175 from trunk into soc-2011-tomato
[blender.git] / source / blender / editors / interface / interface_icons.c
1 /*
2  * $Id$
3  *
4  * ***** BEGIN GPL LICENSE BLOCK *****
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software Foundation,
18  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
19  *
20  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
21  * All rights reserved.
22  *
23  * Contributors: Blender Foundation, full recode
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27
28 /** \file blender/editors/interface/interface_icons.c
29  *  \ingroup edinterface
30  */
31
32
33 #include <math.h>
34 #include <stdlib.h>
35 #include <string.h>
36
37 #ifndef WIN32
38 #include <unistd.h>
39 #else
40 #include <io.h>
41 #include <direct.h>
42 #include "BLI_winstuff.h"
43 #endif   
44 #include "MEM_guardedalloc.h"
45
46 #include "GPU_extensions.h"
47
48 #include "BLI_math.h"
49 #include "BLI_blenlib.h"
50 #include "BLI_storage_types.h"
51 #include "BLI_utildefines.h"
52
53 #include "DNA_brush_types.h"
54 #include "DNA_object_types.h"
55 #include "DNA_screen_types.h"
56 #include "DNA_space_types.h"
57
58 #include "RNA_access.h"
59 #include "RNA_enum_types.h"
60
61 #include "BKE_context.h"
62 #include "BKE_global.h"
63 #include "BKE_icons.h"
64 #include "BKE_utildefines.h"
65
66 #include "IMB_imbuf.h"
67 #include "IMB_imbuf_types.h"
68
69 #include "BIF_gl.h"
70 #include "BIF_glutil.h"
71
72 #include "ED_datafiles.h"
73 #include "ED_render.h"
74
75 #include "UI_interface.h"
76 #include "UI_interface_icons.h"
77
78 #include "interface_intern.h"
79
80
81 #define ICON_IMAGE_W            600
82 #define ICON_IMAGE_H            640
83
84 #define ICON_GRID_COLS          26
85 #define ICON_GRID_ROWS          30
86
87 #define ICON_GRID_MARGIN        5
88 #define ICON_GRID_W             16
89 #define ICON_GRID_H             16
90
91 typedef struct IconImage {
92         int w;
93         int h;
94         unsigned int *rect; 
95 } IconImage;
96
97 typedef void (*VectorDrawFunc)(int x, int y, int w, int h, float alpha);
98
99 #define ICON_TYPE_PREVIEW       0
100 #define ICON_TYPE_TEXTURE       1
101 #define ICON_TYPE_BUFFER        2
102 #define ICON_TYPE_VECTOR        3
103
104 typedef struct DrawInfo {
105         int type;
106
107         union {
108                 /* type specific data */
109                 struct {
110                         VectorDrawFunc func;
111                 } vector;
112                 struct {
113                         IconImage* image;
114                 } buffer;
115                 struct {
116                         int x, y, w, h;
117                 } texture;
118         } data;
119 } DrawInfo;
120
121 typedef struct IconTexture {
122         GLuint id;
123         int w;
124         int h;
125         float invw;
126         float invh;
127 } IconTexture;
128
129 /* ******************* STATIC LOCAL VARS ******************* */
130 /* static here to cache results of icon directory scan, so it's not 
131  * scanning the filesystem each time the menu is drawn */
132 static struct ListBase iconfilelist = {NULL, NULL};
133 static IconTexture icongltex = {0, 0, 0, 0.0f, 0.0f};
134
135 /* **************************************************** */
136
137 static void def_internal_icon(ImBuf *bbuf, int icon_id, int xofs, int yofs, int size, int type)
138 {
139         Icon *new_icon = NULL;
140         IconImage *iimg = NULL;
141         DrawInfo *di;
142         int y = 0;
143         int imgsize = 0;
144
145         new_icon = MEM_callocN(sizeof(Icon), "texicon");
146
147         new_icon->obj = NULL; /* icon is not for library object */
148         new_icon->type = 0;     
149
150         di = MEM_callocN(sizeof(DrawInfo), "drawinfo");
151         di->type= type;
152
153         if(type == ICON_TYPE_TEXTURE) {
154                 di->data.texture.x= xofs;
155                 di->data.texture.y= yofs;
156                 di->data.texture.w= size;
157                 di->data.texture.h= size;
158         }
159         else if(type == ICON_TYPE_BUFFER) {
160                 iimg = MEM_mallocN(sizeof(IconImage), "icon_img");
161                 iimg->rect = MEM_mallocN(size*size*sizeof(unsigned int), "icon_rect");
162                 iimg->w = size;
163                 iimg->h = size;
164
165                 /* Here we store the rect in the icon - same as before */
166                 imgsize = bbuf->x;
167                 for (y=0; y<size; y++) {
168                         memcpy(&iimg->rect[y*size], &bbuf->rect[(y+yofs)*imgsize+xofs], size*sizeof(int));
169                 }
170
171                 di->data.buffer.image = iimg;
172         }
173
174         new_icon->drawinfo_free = UI_icons_free_drawinfo;
175         new_icon->drawinfo = di;
176
177         BKE_icon_set(icon_id, new_icon);
178 }
179
180 static void def_internal_vicon( int icon_id, VectorDrawFunc drawFunc)
181 {
182         Icon *new_icon = NULL;
183         DrawInfo* di;
184
185         new_icon = MEM_callocN(sizeof(Icon), "texicon");
186
187         new_icon->obj = NULL; /* icon is not for library object */
188         new_icon->type = 0;
189
190         di = MEM_callocN(sizeof(DrawInfo), "drawinfo");
191         di->type= ICON_TYPE_VECTOR;
192         di->data.vector.func =drawFunc;
193
194         new_icon->drawinfo_free = NULL;
195         new_icon->drawinfo = di;
196
197         BKE_icon_set(icon_id, new_icon);
198 }
199
200 /* Vector Icon Drawing Routines */
201
202         /* Utilities */
203
204 static void viconutil_set_point(GLint pt[2], int x, int y)
205 {
206         pt[0] = x;
207         pt[1] = y;
208 }
209
210 static void viconutil_draw_tri(GLint (*pts)[2])
211 {
212         glBegin(GL_TRIANGLES);
213         glVertex2iv(pts[0]);
214         glVertex2iv(pts[1]);
215         glVertex2iv(pts[2]);
216         glEnd();
217 }
218
219 static void viconutil_draw_lineloop(GLint (*pts)[2], int numPoints)
220 {
221         int i;
222
223         glBegin(GL_LINE_LOOP);
224         for (i=0; i<numPoints; i++) {
225                 glVertex2iv(pts[i]);
226         }
227         glEnd();
228 }
229
230 static void viconutil_draw_lineloop_smooth(GLint (*pts)[2], int numPoints)
231 {
232         glEnable(GL_LINE_SMOOTH);
233         viconutil_draw_lineloop(pts, numPoints);
234         glDisable(GL_LINE_SMOOTH);
235 }
236
237 static void viconutil_draw_points(GLint (*pts)[2], int numPoints, int pointSize)
238 {
239         int i;
240
241         glBegin(GL_QUADS);
242         for (i=0; i<numPoints; i++) {
243                 int x = pts[i][0], y = pts[i][1];
244
245                 glVertex2i(x-pointSize,y-pointSize);
246                 glVertex2i(x+pointSize,y-pointSize);
247                 glVertex2i(x+pointSize,y+pointSize);
248                 glVertex2i(x-pointSize,y+pointSize);
249         }
250         glEnd();
251 }
252
253         /* Drawing functions */
254
255 static void vicon_x_draw(int x, int y, int w, int h, float alpha)
256 {
257         x += 3;
258         y += 3;
259         w -= 6;
260         h -= 6;
261
262         glEnable( GL_LINE_SMOOTH );
263
264         glLineWidth(2.5);
265         
266         glColor4f(0.0, 0.0, 0.0, alpha);
267         glBegin(GL_LINES);
268         glVertex2i(x  ,y  );
269         glVertex2i(x+w,y+h);
270         glVertex2i(x+w,y  );
271         glVertex2i(x  ,y+h);
272         glEnd();
273
274         glLineWidth(1.0);
275         
276         glDisable( GL_LINE_SMOOTH );
277 }
278
279 static void vicon_view3d_draw(int x, int y, int w, int h, float alpha)
280 {
281         int cx = x + w/2;
282         int cy = y + h/2;
283         int d = MAX2(2, h/3);
284
285         glColor4f(0.5, 0.5, 0.5, alpha);
286         glBegin(GL_LINES);
287         glVertex2i(x  , cy-d);
288         glVertex2i(x+w, cy-d);
289         glVertex2i(x  , cy+d);
290         glVertex2i(x+w, cy+d);
291
292         glVertex2i(cx-d, y  );
293         glVertex2i(cx-d, y+h);
294         glVertex2i(cx+d, y  );
295         glVertex2i(cx+d, y+h);
296         glEnd();
297         
298         glColor4f(0.0, 0.0, 0.0, alpha);
299         glBegin(GL_LINES);
300         glVertex2i(x  , cy);
301         glVertex2i(x+w, cy);
302         glVertex2i(cx, y  );
303         glVertex2i(cx, y+h);
304         glEnd();
305 }
306
307 static void vicon_edit_draw(int x, int y, int w, int h, float alpha)
308 {
309         GLint pts[4][2];
310
311         viconutil_set_point(pts[0], x+3  , y+3  );
312         viconutil_set_point(pts[1], x+w-3, y+3  );
313         viconutil_set_point(pts[2], x+w-3, y+h-3);
314         viconutil_set_point(pts[3], x+3  , y+h-3);
315
316         glColor4f(0.0, 0.0, 0.0, alpha);
317         viconutil_draw_lineloop(pts, 4);
318
319         glColor3f(1, 1, 0.0);
320         viconutil_draw_points(pts, 4, 1);
321 }
322
323 static void vicon_editmode_hlt_draw(int x, int y, int w, int h, float alpha)
324 {
325         GLint pts[3][2];
326
327         viconutil_set_point(pts[0], x+w/2, y+h-2);
328         viconutil_set_point(pts[1], x+3, y+4);
329         viconutil_set_point(pts[2], x+w-3, y+4);
330
331         glColor4f(0.5, 0.5, 0.5, alpha);
332         viconutil_draw_tri(pts);
333
334         glColor4f(0.0, 0.0, 0.0, 1);
335         viconutil_draw_lineloop_smooth(pts, 3);
336
337         glColor3f(1, 1, 0.0);
338         viconutil_draw_points(pts, 3, 1);
339 }
340
341 static void vicon_editmode_dehlt_draw(int x, int y, int w, int h, float UNUSED(alpha))
342 {
343         GLint pts[3][2];
344
345         viconutil_set_point(pts[0], x+w/2, y+h-2);
346         viconutil_set_point(pts[1], x+3, y+4);
347         viconutil_set_point(pts[2], x+w-3, y+4);
348
349         glColor4f(0.0f, 0.0f, 0.0f, 1);
350         viconutil_draw_lineloop_smooth(pts, 3);
351
352         glColor3f(.9f, .9f, .9f);
353         viconutil_draw_points(pts, 3, 1);
354 }
355
356 static void vicon_disclosure_tri_right_draw(int x, int y, int w, int UNUSED(h), float alpha)
357 {
358         GLint pts[3][2];
359         int cx = x+w/2;
360         int cy = y+w/2;
361         int d = w/3, d2 = w/5;
362
363         viconutil_set_point(pts[0], cx-d2, cy+d);
364         viconutil_set_point(pts[1], cx-d2, cy-d);
365         viconutil_set_point(pts[2], cx+d2, cy);
366
367         glShadeModel(GL_SMOOTH);
368         glBegin(GL_TRIANGLES);
369         glColor4f(0.8f, 0.8f, 0.8f, alpha);
370         glVertex2iv(pts[0]);
371         glVertex2iv(pts[1]);
372         glColor4f(0.3f, 0.3f, 0.3f, alpha);
373         glVertex2iv(pts[2]);
374         glEnd();
375         glShadeModel(GL_FLAT);
376
377         glColor4f(0.0f, 0.0f, 0.0f, 1);
378         viconutil_draw_lineloop_smooth(pts, 3);
379 }
380
381 static void vicon_small_tri_right_draw(int x, int y, int w, int UNUSED(h), float alpha)
382 {
383         GLint pts[3][2];
384         int cx = x+w/2-4;
385         int cy = y+w/2;
386         int d = w/5, d2 = w/7;
387
388         viconutil_set_point(pts[0], cx-d2, cy+d);
389         viconutil_set_point(pts[1], cx-d2, cy-d);
390         viconutil_set_point(pts[2], cx+d2, cy);
391
392         glColor4f(0.2f, 0.2f, 0.2f, alpha);
393
394         glShadeModel(GL_SMOOTH);
395         glBegin(GL_TRIANGLES);
396         glVertex2iv(pts[0]);
397         glVertex2iv(pts[1]);
398         glVertex2iv(pts[2]);
399         glEnd();
400         glShadeModel(GL_FLAT);
401 }
402
403 static void vicon_disclosure_tri_down_draw(int x, int y, int w, int UNUSED(h), float alpha)
404 {
405         GLint pts[3][2];
406         int cx = x+w/2;
407         int cy = y+w/2;
408         int d = w/3, d2 = w/5;
409
410         viconutil_set_point(pts[0], cx+d, cy+d2);
411         viconutil_set_point(pts[1], cx-d, cy+d2);
412         viconutil_set_point(pts[2], cx, cy-d2);
413
414         glShadeModel(GL_SMOOTH);
415         glBegin(GL_TRIANGLES);
416         glColor4f(0.8f, 0.8f, 0.8f, alpha);
417         glVertex2iv(pts[0]);
418         glVertex2iv(pts[1]);
419         glColor4f(0.3f, 0.3f, 0.3f, alpha);
420         glVertex2iv(pts[2]);
421         glEnd();
422         glShadeModel(GL_FLAT);
423
424         glColor4f(0.0f, 0.0f, 0.0f, 1);
425         viconutil_draw_lineloop_smooth(pts, 3);
426 }
427
428 static void vicon_move_up_draw(int x, int y, int w, int h, float UNUSED(alpha))
429 {
430         int d=-2;
431
432         glEnable(GL_LINE_SMOOTH);
433         glLineWidth(1);
434         glColor3f(0.0, 0.0, 0.0);
435
436         glBegin(GL_LINE_STRIP);
437         glVertex2i(x+w/2-d*2, y+h/2+d);
438         glVertex2i(x+w/2, y+h/2-d + 1);
439         glVertex2i(x+w/2+d*2, y+h/2+d);
440         glEnd();
441
442         glLineWidth(1.0);
443         glDisable(GL_LINE_SMOOTH);
444 }
445
446 static void vicon_move_down_draw(int x, int y, int w, int h, float UNUSED(alpha))
447 {
448         int d=2;
449
450         glEnable(GL_LINE_SMOOTH);
451         glLineWidth(1);
452         glColor3f(0.0, 0.0, 0.0);
453
454         glBegin(GL_LINE_STRIP);
455         glVertex2i(x+w/2-d*2, y+h/2+d);
456         glVertex2i(x+w/2, y+h/2-d - 1);
457         glVertex2i(x+w/2+d*2, y+h/2+d);
458         glEnd();
459
460         glLineWidth(1.0);
461         glDisable(GL_LINE_SMOOTH);
462 }
463
464 #ifndef WITH_HEADLESS
465 static void init_brush_icons(void)
466 {
467
468 #define INIT_BRUSH_ICON(icon_id, name)                                       \
469         bbuf = IMB_ibImageFromMemory((unsigned char*)datatoc_ ##name## _png, \
470                                      datatoc_ ##name## _png_size, IB_rect);  \
471         def_internal_icon(bbuf, icon_id, 0, 0, w, ICON_TYPE_BUFFER);         \
472         IMB_freeImBuf(bbuf);
473         // end INIT_BRUSH_ICON
474
475         ImBuf *bbuf;
476         const int w = 96;
477
478         INIT_BRUSH_ICON(ICON_BRUSH_ADD, add);
479         INIT_BRUSH_ICON(ICON_BRUSH_BLOB, blob);
480         INIT_BRUSH_ICON(ICON_BRUSH_BLUR, blur);
481         INIT_BRUSH_ICON(ICON_BRUSH_CLAY, clay);
482         INIT_BRUSH_ICON(ICON_BRUSH_CLONE, clone);
483         INIT_BRUSH_ICON(ICON_BRUSH_CREASE, crease);
484         INIT_BRUSH_ICON(ICON_BRUSH_DARKEN, darken);
485         INIT_BRUSH_ICON(ICON_BRUSH_SCULPT_DRAW, draw);
486         INIT_BRUSH_ICON(ICON_BRUSH_FILL, fill);
487         INIT_BRUSH_ICON(ICON_BRUSH_FLATTEN, flatten);
488         INIT_BRUSH_ICON(ICON_BRUSH_GRAB, grab);
489         INIT_BRUSH_ICON(ICON_BRUSH_INFLATE, inflate);
490         INIT_BRUSH_ICON(ICON_BRUSH_LAYER, layer);
491         INIT_BRUSH_ICON(ICON_BRUSH_LIGHTEN, lighten);
492         INIT_BRUSH_ICON(ICON_BRUSH_MIX, mix);
493         INIT_BRUSH_ICON(ICON_BRUSH_MULTIPLY, multiply);
494         INIT_BRUSH_ICON(ICON_BRUSH_NUDGE, nudge);
495         INIT_BRUSH_ICON(ICON_BRUSH_PINCH, pinch);
496         INIT_BRUSH_ICON(ICON_BRUSH_SCRAPE, scrape);
497         INIT_BRUSH_ICON(ICON_BRUSH_SMEAR, smear);
498         INIT_BRUSH_ICON(ICON_BRUSH_SMOOTH, smooth);
499         INIT_BRUSH_ICON(ICON_BRUSH_SNAKE_HOOK, snake_hook);
500         INIT_BRUSH_ICON(ICON_BRUSH_SOFTEN, soften);
501         INIT_BRUSH_ICON(ICON_BRUSH_SUBTRACT, subtract);
502         INIT_BRUSH_ICON(ICON_BRUSH_TEXDRAW, texdraw);
503         INIT_BRUSH_ICON(ICON_BRUSH_THUMB, thumb);
504         INIT_BRUSH_ICON(ICON_BRUSH_ROTATE, twist);
505         INIT_BRUSH_ICON(ICON_BRUSH_VERTEXDRAW, vertexdraw);
506
507 #undef INIT_BRUSH_ICON
508 }
509
510 static void init_internal_icons(void)
511 {
512         bTheme *btheme= U.themes.first;
513         ImBuf *bbuf= NULL;
514         int x, y, icontype;
515         char iconfilestr[FILE_MAXDIR+FILE_MAXFILE];
516         
517         if ((btheme!=NULL) && btheme->tui.iconfile[0]) {
518                 char *icondir= BLI_get_folder(BLENDER_DATAFILES, "icons");
519                 if (icondir) {
520                         BLI_join_dirfile(iconfilestr, sizeof(iconfilestr), icondir, btheme->tui.iconfile);
521                         bbuf = IMB_loadiffname(iconfilestr, IB_rect); /* if the image is missing bbuf will just be NULL */
522                         if(bbuf && (bbuf->x < ICON_IMAGE_W || bbuf->y < ICON_IMAGE_H)) {
523                                 printf("\n***WARNING***\nIcons file %s too small.\nUsing built-in Icons instead\n", iconfilestr);
524                                 IMB_freeImBuf(bbuf);
525                                 bbuf= NULL;
526                         }
527                 }
528                 else {
529                         printf("%s: 'icons' data path not found, continuing\n", __func__);
530                 }
531         }
532         if(bbuf==NULL)
533                 bbuf = IMB_ibImageFromMemory((unsigned char*)datatoc_blenderbuttons, datatoc_blenderbuttons_size, IB_rect);
534
535         if(bbuf) {
536                 /* free existing texture if any */
537                 if(icongltex.id) {
538                         glDeleteTextures(1, &icongltex.id);
539                         icongltex.id= 0;
540                 }
541
542                 /* we only use a texture for cards with non-power of two */
543                 if(GPU_non_power_of_two_support()) {
544                         glGenTextures(1, &icongltex.id);
545
546                         if(icongltex.id) {
547                                 icongltex.w = bbuf->x;
548                                 icongltex.h = bbuf->y;
549                                 icongltex.invw = 1.0f/bbuf->x;
550                                 icongltex.invh = 1.0f/bbuf->y;
551
552                                 glBindTexture(GL_TEXTURE_2D, icongltex.id);
553                                 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, bbuf->x, bbuf->y, 0, GL_RGBA, GL_UNSIGNED_BYTE, bbuf->rect);
554                                 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
555                                 glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
556                                 glBindTexture(GL_TEXTURE_2D, 0);
557
558                                 if(glGetError() == GL_OUT_OF_MEMORY) {
559                                         glDeleteTextures(1, &icongltex.id);
560                                         icongltex.id= 0;
561                                 }
562                         }
563                 }
564         }
565
566         if(icongltex.id)
567                 icontype= ICON_TYPE_TEXTURE;
568         else
569                 icontype= ICON_TYPE_BUFFER;
570         
571         if(bbuf) {
572                 for (y=0; y<ICON_GRID_ROWS; y++) {
573                         for (x=0; x<ICON_GRID_COLS; x++) {
574                                 def_internal_icon(bbuf, BIFICONID_FIRST + y*ICON_GRID_COLS + x,
575                                         x*(ICON_GRID_W+ICON_GRID_MARGIN)+ICON_GRID_MARGIN,
576                                         y*(ICON_GRID_H+ICON_GRID_MARGIN)+ICON_GRID_MARGIN, ICON_GRID_W,
577                                         icontype);
578                         }
579                 }
580         }
581
582         def_internal_vicon(VICO_VIEW3D_VEC, vicon_view3d_draw);
583         def_internal_vicon(VICO_EDIT_VEC, vicon_edit_draw);
584         def_internal_vicon(VICO_EDITMODE_DEHLT, vicon_editmode_dehlt_draw);
585         def_internal_vicon(VICO_EDITMODE_HLT, vicon_editmode_hlt_draw);
586         def_internal_vicon(VICO_DISCLOSURE_TRI_RIGHT_VEC, vicon_disclosure_tri_right_draw);
587         def_internal_vicon(VICO_DISCLOSURE_TRI_DOWN_VEC, vicon_disclosure_tri_down_draw);
588         def_internal_vicon(VICO_MOVE_UP_VEC, vicon_move_up_draw);
589         def_internal_vicon(VICO_MOVE_DOWN_VEC, vicon_move_down_draw);
590         def_internal_vicon(VICO_X_VEC, vicon_x_draw);
591         def_internal_vicon(VICO_SMALL_TRI_RIGHT_VEC, vicon_small_tri_right_draw);
592
593         IMB_freeImBuf(bbuf);
594 }
595 #endif // WITH_HEADLESS
596
597 static void init_iconfile_list(struct ListBase *list)
598 {
599         IconFile *ifile;
600         struct direntry *dir;
601         int restoredir = 1; /* restore to current directory */
602         int totfile, i, index=1;
603         const char *icondir;
604         char olddir[FILE_MAX];
605
606         list->first = list->last = NULL;
607         icondir = BLI_get_folder(BLENDER_DATAFILES, "icons");
608
609         if(icondir==NULL)
610                 return;
611         
612         /* since BLI_getdir changes the current working directory, restore it 
613            back to old value afterwards */
614         if(!BLI_getwdN(olddir, sizeof(olddir))) 
615                 restoredir = 0;
616         totfile = BLI_getdir(icondir, &dir);
617         if (restoredir && !chdir(olddir)) {} /* fix warning about checking return value */
618
619         for(i=0; i<totfile; i++) {
620                 if( (dir[i].type & S_IFREG) ) {
621                         char *filename = dir[i].relname;
622                         
623                         if(BLI_testextensie(filename, ".png")) {
624                                 /* loading all icons on file start is overkill & slows startup
625                                  * its possible they change size after blender load anyway. */
626 #if 0
627                                 int ifilex, ifiley;
628                                 char iconfilestr[FILE_MAX+16]; /* allow 256 chars for file+dir */
629                                 ImBuf *bbuf= NULL;
630                                 /* check to see if the image is the right size, continue if not */
631                                 /* copying strings here should go ok, assuming that we never get back
632                                    a complete path to file longer than 256 chars */
633                                 BLI_join_dirfile(iconfilestr, sizeof(iconfilestr), icondir, filename);
634                                 bbuf= IMB_loadiffname(iconfilestr, IB_rect);
635
636                                 if(bbuf) {
637                                         ifilex = bbuf->x;
638                                         ifiley = bbuf->y;
639                                         IMB_freeImBuf(bbuf);
640                                 }
641                                 else {
642                                         ifilex= ifiley= 0;
643                                 }
644                                 
645                                 /* bad size or failed to load */
646                                 if ((ifilex != ICON_IMAGE_W) || (ifiley != ICON_IMAGE_H)) {
647                                         printf("icon '%s' is wrong size %dx%d\n", iconfilestr, ifilex, ifiley);
648                                         continue;
649                                 }
650 #endif                  /* removed */
651
652                                 /* found a potential icon file, so make an entry for it in the cache list */
653                                 ifile = MEM_callocN(sizeof(IconFile), "IconFile");
654                                 
655                                 BLI_strncpy(ifile->filename, filename, sizeof(ifile->filename));
656                                 ifile->index = index;
657
658                                 BLI_addtail(list, ifile);
659                                 
660                                 index++;
661                         }
662                 }
663         }
664         
665         /* free temporary direntry structure that's been created by BLI_getdir() */
666         i= totfile-1;
667         
668         for(; i>=0; i--){
669                 MEM_freeN(dir[i].relname);
670                 MEM_freeN(dir[i].path);
671                 if (dir[i].string) MEM_freeN(dir[i].string);
672         }
673         free(dir);
674         dir= NULL;
675 }
676
677 static void free_iconfile_list(struct ListBase *list)
678 {
679         IconFile *ifile=NULL, *next_ifile=NULL;
680         
681         for(ifile=list->first; ifile; ifile=next_ifile) {
682                 next_ifile = ifile->next;
683                 BLI_freelinkN(list, ifile);
684         }
685 }
686
687 int UI_iconfile_get_index(const char *filename)
688 {
689         IconFile *ifile;
690         ListBase *list=&(iconfilelist);
691         
692         for(ifile=list->first; ifile; ifile=ifile->next) {
693                 if (BLI_path_cmp(filename, ifile->filename) == 0) {
694                         return ifile->index;
695                 }
696         }
697         
698         return 0;
699 }
700
701 ListBase *UI_iconfile_list(void)
702 {
703         ListBase *list=&(iconfilelist);
704         
705         return list;
706 }
707
708
709 void UI_icons_free(void)
710 {
711 #ifndef WITH_HEADLESS
712         if(icongltex.id) {
713                 glDeleteTextures(1, &icongltex.id);
714                 icongltex.id= 0;
715         }
716
717         free_iconfile_list(&iconfilelist);
718         BKE_icons_free();
719 #endif
720 }
721
722 void UI_icons_free_drawinfo(void *drawinfo)
723 {
724         DrawInfo *di = drawinfo;
725
726         if(di) {
727                 if(di->type == ICON_TYPE_BUFFER) {
728                         if(di->data.buffer.image) {
729                                 MEM_freeN(di->data.buffer.image->rect);
730                                 MEM_freeN(di->data.buffer.image);
731                         }
732                 }
733
734                 MEM_freeN(di);
735         }
736 }
737
738 static DrawInfo *icon_create_drawinfo(void)
739 {
740         DrawInfo *di = NULL;
741
742         di = MEM_callocN(sizeof(DrawInfo), "di_icon");
743         di->type= ICON_TYPE_PREVIEW;
744
745         return di;
746 }
747
748 /* note!, returns unscaled by DPI, may need to multiply result by UI_DPI_ICON_FAC */
749 int UI_icon_get_width(int icon_id)
750 {
751         Icon *icon = NULL;
752         DrawInfo *di = NULL;
753
754         icon = BKE_icon_get(icon_id);
755         
756         if (icon==NULL) {
757                 if (G.f & G_DEBUG)
758                         printf("%s: Internal error, no icon for icon ID: %d\n", __func__, icon_id);
759                 return 0;
760         }
761         
762         di = (DrawInfo *)icon->drawinfo;
763         if (!di) {
764                 di = icon_create_drawinfo();
765                 icon->drawinfo = di;
766         }
767
768         if (di)
769                 return ICON_DEFAULT_WIDTH;
770
771         return 0;
772 }
773
774 int UI_icon_get_height(int icon_id)
775 {
776         Icon *icon = NULL;
777         DrawInfo *di = NULL;
778
779         icon = BKE_icon_get(icon_id);
780         
781         if (icon==NULL) {
782                 if (G.f & G_DEBUG)
783                         printf("%s: Internal error, no icon for icon ID: %d\n", __func__, icon_id);
784                 return 0;
785         }
786         
787         di = (DrawInfo*)icon->drawinfo;
788
789         if (!di) {
790                 di = icon_create_drawinfo();
791                 icon->drawinfo = di;
792         }
793         
794         if (di)
795                 return ICON_DEFAULT_HEIGHT;
796
797         return 0;
798 }
799
800 void UI_icons_init(int first_dyn_id)
801 {
802 #ifdef WITH_HEADLESS
803         (void)first_dyn_id;
804 #else
805         init_iconfile_list(&iconfilelist);
806         BKE_icons_init(first_dyn_id);
807         init_internal_icons();
808         init_brush_icons();
809 #endif
810 }
811
812 /* Render size for preview images and icons
813  */
814 static int preview_render_size(enum eIconSizes size)
815 {
816         switch (size) {
817                 case ICON_SIZE_ICON:    return 32;
818                 case ICON_SIZE_PREVIEW: return PREVIEW_DEFAULT_HEIGHT;
819         }
820         return 0;
821 }
822
823 /* Create rect for the icon
824  */
825 static void icon_create_rect(struct PreviewImage* prv_img, enum eIconSizes size) 
826 {
827         unsigned int render_size = preview_render_size(size);
828
829         if (!prv_img) {
830                 if (G.f & G_DEBUG)
831                         printf("%s, error: requested preview image does not exist", __func__);
832         }
833         if (!prv_img->rect[size]) {
834                 prv_img->w[size] = render_size;
835                 prv_img->h[size] = render_size;
836                 prv_img->changed[size] = 1;
837                 prv_img->changed_timestamp[size] = 0;
838                 prv_img->rect[size] = MEM_callocN(render_size*render_size*sizeof(unsigned int), "prv_rect"); 
839         }
840 }
841
842 /* only called when icon has changed */
843 /* only call with valid pointer from UI_icon_draw */
844 static void icon_set_image(bContext *C, ID *id, PreviewImage* prv_img, enum eIconSizes size)
845 {
846         if (!prv_img) {
847                 if (G.f & G_DEBUG)
848                         printf("%s: no preview image for this ID: %s\n", __func__, id->name);
849                 return;
850         }       
851
852         icon_create_rect(prv_img, size);
853
854         ED_preview_icon_job(C, prv_img, id, prv_img->rect[size],
855                 prv_img->w[size], prv_img->h[size]);
856 }
857
858 static void icon_draw_rect(float x, float y, int w, int h, float UNUSED(aspect), int rw, int rh, unsigned int *rect, float alpha, float *rgb, short is_preview)
859 {
860         ImBuf *ima= NULL;
861
862         /* sanity check */
863         if(w<=0 || h<=0 || w>2000 || h>2000) {
864                 printf("%s: icons are %i x %i pixels?\n", __func__, w, h);
865                 BLI_assert(!"invalid icon size");
866                 return;
867         }
868
869         /* modulate color */
870         if(alpha != 1.0f)
871                 glPixelTransferf(GL_ALPHA_SCALE, alpha);
872
873         if(rgb) {
874                 glPixelTransferf(GL_RED_SCALE, rgb[0]);
875                 glPixelTransferf(GL_GREEN_SCALE, rgb[1]);
876                 glPixelTransferf(GL_BLUE_SCALE, rgb[2]);
877         }
878
879         /* rect contains image in 'rendersize', we only scale if needed */
880         if(rw!=w && rh!=h) {
881                 /* first allocate imbuf for scaling and copy preview into it */
882                 ima = IMB_allocImBuf(rw, rh, 32, IB_rect);
883                 memcpy(ima->rect, rect, rw*rh*sizeof(unsigned int));    
884                 IMB_scaleImBuf(ima, w, h); /* scale it */
885                 rect= ima->rect;
886         }
887
888         /* draw */
889         if(is_preview) {
890                 glaDrawPixelsSafe(x, y, w, h, w, GL_RGBA, GL_UNSIGNED_BYTE, rect);
891         }
892         else {
893                 glRasterPos2f(x, y);
894                 glDrawPixels(w, h, GL_RGBA, GL_UNSIGNED_BYTE, rect);
895         }
896
897         if(ima)
898                 IMB_freeImBuf(ima);
899
900         /* restore color */
901         if(alpha != 0.0f)
902                 glPixelTransferf(GL_ALPHA_SCALE, 1.0f);
903         
904         if(rgb) {
905                 glPixelTransferf(GL_RED_SCALE, 1.0f);
906                 glPixelTransferf(GL_GREEN_SCALE, 1.0f);
907                 glPixelTransferf(GL_BLUE_SCALE, 1.0f);
908         }
909 }
910
911 static void icon_draw_texture(float x, float y, float w, float h, int ix, int iy, int UNUSED(iw), int ih, float alpha, float *rgb)
912 {
913         float x1, x2, y1, y2;
914
915         if(rgb) glColor4f(rgb[0], rgb[1], rgb[2], alpha);
916         else glColor4f(1.0f, 1.0f, 1.0f, alpha);
917
918         x1= ix*icongltex.invw;
919         x2= (ix + ih)*icongltex.invw;
920         y1= iy*icongltex.invh;
921         y2= (iy + ih)*icongltex.invh;
922
923         glEnable(GL_TEXTURE_2D);
924         glBindTexture(GL_TEXTURE_2D, icongltex.id);
925
926         glBegin(GL_QUADS);
927         glTexCoord2f(x1, y1);
928         glVertex2f(x, y);
929
930         glTexCoord2f(x2, y1);
931         glVertex2f(x+w, y);
932
933         glTexCoord2f(x2, y2);
934         glVertex2f(x+w, y+h);
935
936         glTexCoord2f(x1, y2);
937         glVertex2f(x, y+h);
938         glEnd();
939
940         glBindTexture(GL_TEXTURE_2D, 0);
941         glDisable(GL_TEXTURE_2D);
942 }
943
944 /* Drawing size for preview images */
945 static int get_draw_size(enum eIconSizes size)
946 {
947         switch (size) {
948                 case ICON_SIZE_ICON: return ICON_DEFAULT_HEIGHT;
949                 case ICON_SIZE_PREVIEW: return PREVIEW_DEFAULT_HEIGHT;
950         }
951         return 0;
952 }
953
954 static void icon_draw_size(float x, float y, int icon_id, float aspect, float alpha, float *rgb, enum eIconSizes size, int draw_size, int UNUSED(nocreate), short is_preview)
955 {
956         Icon *icon = NULL;
957         DrawInfo *di = NULL;
958         IconImage *iimg;
959         float fdraw_size= is_preview ? draw_size : (draw_size * UI_DPI_ICON_FAC);
960         int w, h;
961         
962         icon = BKE_icon_get(icon_id);
963         
964         if (icon==NULL) {
965                 if (G.f & G_DEBUG)
966                         printf("%s: Internal error, no icon for icon ID: %d\n", __func__, icon_id);
967                 return;
968         }
969
970         di = (DrawInfo*)icon->drawinfo;
971         
972         if (!di) {
973                 di = icon_create_drawinfo();
974         
975                 icon->drawinfo = di;            
976                 icon->drawinfo_free = UI_icons_free_drawinfo;           
977         }
978         
979         /* scale width and height according to aspect */
980         w = (int)(fdraw_size/aspect + 0.5f);
981         h = (int)(fdraw_size/aspect + 0.5f);
982         
983         if(di->type == ICON_TYPE_VECTOR) {
984                 /* vector icons use the uiBlock transformation, they are not drawn
985                 with untransformed coordinates like the other icons */
986                 di->data.vector.func((int)x, (int)y, ICON_DEFAULT_HEIGHT, ICON_DEFAULT_HEIGHT, 1.0f); 
987         } 
988         else if(di->type == ICON_TYPE_TEXTURE) {
989                 icon_draw_texture(x, y, (float)w, (float)h, di->data.texture.x, di->data.texture.y,
990                         di->data.texture.w, di->data.texture.h, alpha, rgb);
991         }
992         else if(di->type == ICON_TYPE_BUFFER) {
993                 /* it is a builtin icon */              
994                 iimg= di->data.buffer.image;
995
996                 if(!iimg->rect) return; /* something has gone wrong! */
997
998                 icon_draw_rect(x, y, w, h, aspect, iimg->w, iimg->h, iimg->rect, alpha, rgb, is_preview);
999         }
1000         else if(di->type == ICON_TYPE_PREVIEW) {
1001                 PreviewImage* pi = BKE_previewimg_get((ID*)icon->obj); 
1002
1003                 if(pi) {                        
1004                         /* no create icon on this level in code */
1005                         if(!pi->rect[size]) return; /* something has gone wrong! */
1006                         
1007                         /* preview images use premul alpha ... */
1008                         glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
1009                         icon_draw_rect(x, y, w, h, aspect, pi->w[size], pi->h[size], pi->rect[size], 1.0f, NULL, is_preview);
1010                         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1011                 }
1012         }
1013 }
1014
1015 static void ui_id_icon_render(bContext *C, ID *id, int big)
1016 {
1017         PreviewImage *pi = BKE_previewimg_get(id); 
1018         
1019         if (pi) {                       
1020                 if ((pi->changed[0] ||!pi->rect[0])) /* changed only ever set by dynamic icons */
1021                 {
1022                         /* create the rect if necessary */                              
1023                         
1024                         icon_set_image(C, id, pi, ICON_SIZE_ICON);              /* icon size */
1025                         if (big)
1026                                 icon_set_image(C, id, pi, ICON_SIZE_PREVIEW);   /* bigger preview size */
1027                         
1028                         pi->changed[0] = 0;
1029                 }
1030         }
1031 }
1032
1033 static void ui_id_brush_render(bContext *C, ID *id)
1034 {
1035         PreviewImage *pi = BKE_previewimg_get(id); 
1036         enum eIconSizes i;
1037         
1038         if(!pi)
1039                 return;
1040         
1041         for(i = 0; i < NUM_ICON_SIZES; i++) {
1042                 /* check if rect needs to be created; changed
1043                  only set by dynamic icons */
1044                 if((pi->changed[i] || !pi->rect[i])) {
1045                         icon_set_image(C, id, pi, i);
1046                         pi->changed[i] = 0;
1047                 }
1048         }
1049 }
1050
1051
1052 static int ui_id_brush_get_icon(bContext *C, ID *id)
1053 {
1054         Brush *br = (Brush*)id;
1055
1056         if(br->flag & BRUSH_CUSTOM_ICON) {
1057                 BKE_icon_getid(id);
1058                 ui_id_brush_render(C, id);
1059         }
1060         else {
1061                 Object *ob = CTX_data_active_object(C);
1062                 SpaceImage *sima;
1063                 EnumPropertyItem *items = NULL;
1064                 int tool, mode = 0;
1065
1066                 /* XXX: this is not nice, should probably make brushes
1067                    be strictly in one paint mode only to avoid
1068                    checking various context stuff here */
1069
1070                 if(CTX_wm_view3d(C) && ob) {
1071                         if(ob->mode & OB_MODE_SCULPT)
1072                                 mode = OB_MODE_SCULPT;
1073                         else if(ob->mode & (OB_MODE_VERTEX_PAINT|OB_MODE_WEIGHT_PAINT))
1074                                 mode = OB_MODE_VERTEX_PAINT;
1075                         else if(ob->mode & OB_MODE_TEXTURE_PAINT)
1076                                 mode = OB_MODE_TEXTURE_PAINT;
1077                 }
1078                 else if((sima = CTX_wm_space_image(C)) &&
1079                         (sima->flag & SI_DRAWTOOL)) {
1080                         mode = OB_MODE_TEXTURE_PAINT;
1081                 }
1082
1083                 /* reset the icon */
1084                 if(mode == OB_MODE_SCULPT) {
1085                         items = brush_sculpt_tool_items;
1086                         tool = br->sculpt_tool;
1087                 }
1088                 else if(mode == OB_MODE_VERTEX_PAINT) {
1089                         items = brush_vertex_tool_items;
1090                         tool = br->vertexpaint_tool;
1091                 }
1092                 else if(mode == OB_MODE_TEXTURE_PAINT) {
1093                         items = brush_image_tool_items;
1094                         tool = br->imagepaint_tool;
1095                 }
1096
1097                 if(!items || !RNA_enum_icon_from_value(items, tool, &id->icon_id))
1098                         id->icon_id = 0;
1099         }
1100
1101         return id->icon_id;
1102 }
1103
1104 int ui_id_icon_get(bContext *C, ID *id, int big)
1105 {
1106         int iconid= 0;
1107         
1108         /* icon */
1109         switch(GS(id->name)) {
1110                 case ID_BR:
1111                         iconid= ui_id_brush_get_icon(C, id);
1112                         break;
1113                 case ID_MA: /* fall through */
1114                 case ID_TE: /* fall through */
1115                 case ID_IM: /* fall through */
1116                 case ID_WO: /* fall through */
1117                 case ID_LA: /* fall through */
1118                         iconid= BKE_icon_getid(id);
1119                         /* checks if not exists, or changed */
1120                         ui_id_icon_render(C, id, big);
1121                         break;
1122                 default:
1123                         break;
1124         }
1125
1126         return iconid;
1127 }
1128
1129 static void icon_draw_at_size(float x, float y, int icon_id, float aspect, float alpha, enum eIconSizes size, int nocreate)
1130 {
1131         int draw_size = get_draw_size(size);
1132         icon_draw_size(x, y, icon_id, aspect, alpha, NULL, size, draw_size, nocreate, FALSE);
1133 }
1134
1135 void UI_icon_draw_aspect(float x, float y, int icon_id, float aspect, float alpha)
1136 {
1137         icon_draw_at_size(x, y, icon_id, aspect, alpha, ICON_SIZE_ICON, 0);
1138 }
1139
1140 void UI_icon_draw_aspect_color(float x, float y, int icon_id, float aspect, float *rgb)
1141 {
1142         int draw_size = get_draw_size(ICON_SIZE_ICON);
1143         icon_draw_size(x, y, icon_id, aspect, 1.0f, rgb, ICON_SIZE_ICON, draw_size, FALSE, FALSE);
1144 }
1145
1146 void UI_icon_draw(float x, float y, int icon_id)
1147 {
1148         UI_icon_draw_aspect(x, y, icon_id, 1.0f, 1.0f);
1149 }
1150
1151 void UI_icon_draw_size(float x, float y, int size, int icon_id, float alpha)
1152 {
1153         icon_draw_size(x, y, icon_id, 1.0f, alpha, NULL, ICON_SIZE_ICON, size, TRUE, FALSE);
1154 }
1155
1156 void UI_icon_draw_preview(float x, float y, int icon_id)
1157 {
1158         icon_draw_at_size(x, y, icon_id, 1.0f, 1.0f, ICON_SIZE_PREVIEW, 0);
1159 }
1160
1161 void UI_icon_draw_preview_aspect(float x, float y, int icon_id, float aspect)
1162 {
1163         icon_draw_at_size(x, y, icon_id, aspect, 1.0f, ICON_SIZE_PREVIEW, 0);
1164 }
1165
1166 void UI_icon_draw_preview_aspect_size(float x, float y, int icon_id, float aspect, int size)
1167 {
1168         icon_draw_size(x, y, icon_id, aspect, 1.0f, NULL, ICON_SIZE_PREVIEW, size, FALSE, TRUE);
1169 }
1170