2.5: fix compile error on mac, and a few warnings.
[blender-staging.git] / source / blender / editors / interface / interface.c
1 /**
2  * $Id: interface.c 16882 2008-10-02 12:29:45Z ton $
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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
19  *
20  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
21  * All rights reserved.
22  *
23  * Contributor(s): Blender Foundation 2002-2008, full recode.
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27
28 #include <float.h>
29 #include <math.h>
30 #include <string.h>
31  
32 #include "MEM_guardedalloc.h"
33
34 #include "DNA_ID.h"
35 #include "DNA_listBase.h"
36 #include "DNA_screen_types.h"
37 #include "DNA_texture_types.h"
38 #include "DNA_userdef_types.h"
39
40 #include "BLI_arithb.h"
41 #include "BLI_blenlib.h"
42 #include "BLI_dynstr.h"
43
44 #include "BKE_context.h"
45 #include "BKE_idprop.h"
46 #include "BKE_library.h"
47 #include "BKE_screen.h"
48 #include "BKE_texture.h"
49 #include "BKE_utildefines.h"
50
51 #include "BIF_gl.h"
52 #include "BIF_glutil.h"
53
54 #include "UI_interface.h"
55 #include "UI_text.h"
56
57 #include "BMF_Api.h"
58 #ifdef INTERNATIONAL
59 #include "FTF_Api.h"
60 #endif
61
62 #include "ED_screen.h"
63
64 #include "WM_api.h"
65 #include "WM_types.h"
66 #include "wm_subwindow.h"
67 #include "wm_window.h"
68
69 #include "RNA_access.h"
70 #include "RNA_types.h"
71
72 #include "interface_intern.h"
73
74 /* 
75  * a full doc with API notes can be found in bf-blender/blender/doc/interface_API.txt
76  * 
77  * uiBlahBlah()         external function
78  * ui_blah_blah()       internal function
79  */
80
81 static void ui_free_but(const bContext *C, uiBut *but);
82
83 /* ************ GLOBALS ************* */
84
85 static uiFont UIfont[UI_ARRAY];  // no init needed
86
87 /* ************* translation ************** */
88
89 int ui_translate_buttons()
90 {
91         return (U.transopts & USER_TR_BUTTONS);
92 }
93
94 int ui_translate_menus()
95 {
96         return (U.transopts & USER_TR_MENUS);
97 }
98
99 int ui_translate_tooltips()
100 {
101         return (U.transopts & USER_TR_TOOLTIPS);
102 }
103
104 /* ************* window matrix ************** */
105
106 void ui_block_to_window_fl(const ARegion *ar, uiBlock *block, float *x, float *y)
107 {
108         float gx, gy;
109         int sx, sy, getsizex, getsizey;
110
111         getsizex= ar->winrct.xmax-ar->winrct.xmin+1;
112         getsizey= ar->winrct.ymax-ar->winrct.ymin+1;
113         sx= ar->winrct.xmin;
114         sy= ar->winrct.ymin;
115
116         gx= *x;
117         gy= *y;
118
119         if(block->panel) {
120                 gx += block->panel->ofsx;
121                 gy += block->panel->ofsy;
122         }
123
124         *x= ((float)sx) + ((float)getsizex)*(0.5+ 0.5*(gx*block->winmat[0][0]+ gy*block->winmat[1][0]+ block->winmat[3][0]));
125         *y= ((float)sy) + ((float)getsizey)*(0.5+ 0.5*(gx*block->winmat[0][1]+ gy*block->winmat[1][1]+ block->winmat[3][1]));
126 }
127
128 void ui_block_to_window(const ARegion *ar, uiBlock *block, int *x, int *y)
129 {
130         float fx, fy;
131
132         fx= *x;
133         fy= *y;
134
135         ui_block_to_window_fl(ar, block, &fx, &fy);
136
137         *x= (int)(fx+0.5f);
138         *y= (int)(fy+0.5f);
139 }
140
141 void ui_block_to_window_rct(const ARegion *ar, uiBlock *block, rctf *graph, rcti *winr)
142 {
143         rctf tmpr;
144
145         tmpr= *graph;
146         ui_block_to_window_fl(ar, block, &tmpr.xmin, &tmpr.ymin);
147         ui_block_to_window_fl(ar, block, &tmpr.xmax, &tmpr.ymax);
148
149         winr->xmin= tmpr.xmin;
150         winr->ymin= tmpr.ymin;
151         winr->xmax= tmpr.xmax;
152         winr->ymax= tmpr.ymax;
153 }
154
155 void ui_window_to_block_fl(const ARegion *ar, uiBlock *block, float *x, float *y)       /* for mouse cursor */
156 {
157         float a, b, c, d, e, f, px, py;
158         int sx, sy, getsizex, getsizey;
159
160         getsizex= ar->winrct.xmax-ar->winrct.xmin+1;
161         getsizey= ar->winrct.ymax-ar->winrct.ymin+1;
162         sx= ar->winrct.xmin;
163         sy= ar->winrct.ymin;
164
165         a= .5*((float)getsizex)*block->winmat[0][0];
166         b= .5*((float)getsizex)*block->winmat[1][0];
167         c= .5*((float)getsizex)*(1.0+block->winmat[3][0]);
168
169         d= .5*((float)getsizey)*block->winmat[0][1];
170         e= .5*((float)getsizey)*block->winmat[1][1];
171         f= .5*((float)getsizey)*(1.0+block->winmat[3][1]);
172
173         px= *x - sx;
174         py= *y - sy;
175
176         *y=  (a*(py-f) + d*(c-px))/(a*e-d*b);
177         *x= (px- b*(*y)- c)/a;
178
179         if(block->panel) {
180                 *x -= block->panel->ofsx;
181                 *y -= block->panel->ofsy;
182         }
183 }
184
185 void ui_window_to_block(const ARegion *ar, uiBlock *block, int *x, int *y)
186 {
187         float fx, fy;
188
189         fx= *x;
190         fy= *y;
191
192         ui_window_to_block_fl(ar, block, &fx, &fy);
193
194         *x= (int)(fx+0.5f);
195         *y= (int)(fy+0.5f);
196 }
197
198 void ui_window_to_region(const ARegion *ar, int *x, int *y)
199 {
200         *x-= ar->winrct.xmin;
201         *y-= ar->winrct.ymin;
202 }
203
204 /* ******************* block calc ************************* */
205
206 /* only for pulldowns */
207 void uiTextBoundsBlock(uiBlock *block, int addval)
208 {
209         uiBut *bt;
210         int i = 0, j, x1addval= 0, nextcol;
211         
212         bt= block->buttons.first;
213         while(bt) {
214                 if(bt->type!=SEPR) {
215                         int transopts= ui_translate_buttons();
216                         if(bt->type==TEX || bt->type==IDPOIN) transopts= 0;
217                         j= UI_GetStringWidth(bt->font, bt->drawstr, transopts);
218
219                         if(j > i) i = j;
220                 }
221                 bt= bt->next;
222         }
223
224         /* cope with multi collumns */
225         bt= block->buttons.first;
226         while(bt) {
227                 if(bt->next && bt->x1 < bt->next->x1)
228                         nextcol= 1;
229                 else nextcol= 0;
230                 
231                 bt->x1 = x1addval;
232                 bt->x2 = bt->x1 + i + addval;
233                 
234                 ui_check_but(bt);       // clips text again
235                 
236                 if(nextcol)
237                         x1addval+= i + addval;
238                 
239                 bt= bt->next;
240         }
241 }
242
243 void uiBoundsBlock(uiBlock *block, int addval)
244 {
245         uiBut *bt;
246         int xof;
247         
248         if(block==NULL)
249                 return;
250         
251         if(block->buttons.first==NULL) {
252                 if(block->panel) {
253                         block->minx= 0.0; block->maxx= block->panel->sizex;
254                         block->miny= 0.0; block->maxy= block->panel->sizey;
255                 }
256         }
257         else {
258         
259                 block->minx= block->miny= 10000;
260                 block->maxx= block->maxy= -10000;
261                 
262                 bt= block->buttons.first;
263                 while(bt) {
264                         if(bt->x1 < block->minx) block->minx= bt->x1;
265                         if(bt->y1 < block->miny) block->miny= bt->y1;
266         
267                         if(bt->x2 > block->maxx) block->maxx= bt->x2;
268                         if(bt->y2 > block->maxy) block->maxy= bt->y2;
269                         
270                         bt= bt->next;
271                 }
272                 
273                 block->minx -= addval;
274                 block->miny -= addval;
275                 block->maxx += addval;
276                 block->maxy += addval;
277         }
278
279         /* hardcoded exception... but that one is annoying with larger safety */ 
280         bt= block->buttons.first;
281         if(bt && strncmp(bt->str, "ERROR", 5)==0) xof= 10;
282         else xof= 40;
283         
284         block->safety.xmin= block->minx-xof;
285         block->safety.ymin= block->miny-xof;
286         block->safety.xmax= block->maxx+xof;
287         block->safety.ymax= block->maxy+xof;
288 }
289
290 void uiBlockTranslate(uiBlock *block, int x, int y)
291 {
292         uiBut *bt;
293
294         for(bt= block->buttons.first; bt; bt=bt->next) {
295                 bt->x1 += x;
296                 bt->y1 += y;
297                 bt->x2 += x;
298                 bt->y2 += y;
299         }
300
301         block->minx += x;
302         block->miny += y;
303         block->maxx += x;
304         block->maxy += y;
305 }
306
307 void uiBlockOrigin(uiBlock *block)
308 {
309         uiBut *bt;
310         int minx= 10000, miny= 10000;
311
312         for(bt= block->buttons.first; bt; bt=bt->next) {
313                 if(bt->x1 < minx) minx= bt->x1;
314                 if(bt->y1 < miny) miny= bt->y1;
315         }
316
317         uiBlockTranslate(block, -minx, -miny);
318 }
319
320 void ui_autofill(uiBlock *block)
321 {
322         uiBut *but;
323         float *maxw, *maxh, startx = 0, starty, height = 0;
324         float totmaxh;
325         int rows=0, /*  cols=0, */ i, lasti;
326         
327         /* first count rows */
328         but= block->buttons.last;
329         rows= but->x1+1;
330
331         /* calculate max width / height for each row */
332         maxw= MEM_callocN(sizeof(float)*rows, "maxw");
333         maxh= MEM_callocN(sizeof(float)*rows, "maxh");
334         but= block->buttons.first;
335         while(but) {
336                 i= but->x1;
337                 if( maxh[i] < but->y2) maxh[i]= but->y2;
338                 maxw[i] += but->x2;
339                 but= but->next;
340         }
341         
342         totmaxh= 0.0;
343         for(i=0; i<rows; i++) totmaxh+= maxh[i];
344         
345         /* apply widths/heights */
346         starty= block->maxy;
347         but= block->buttons.first;
348         lasti= -1;
349         while(but) {
350                 // signal for aligning code
351                 but->flag |= UI_BUT_ALIGN_DOWN;
352                 
353                 i= but->x1;
354
355                 if(i!=lasti) {
356                         startx= block->minx;
357                         height= (maxh[i]*(block->maxy-block->miny))/totmaxh;
358                         starty-= height;
359                         lasti= i;
360                 }
361                 
362                 but->y1= starty+but->aspect;
363                 but->y2= but->y1+height-but->aspect;
364                 
365                 but->x2= (but->x2*(block->maxx-block->minx))/maxw[i];
366                 but->x1= startx+but->aspect;
367                 
368                 startx+= but->x2;
369                 but->x2+= but->x1-but->aspect;
370                 
371                 ui_check_but(but);
372                 
373                 but= but->next;
374         }
375         
376         uiBlockEndAlign(block);
377         
378         MEM_freeN(maxw); MEM_freeN(maxh);       
379         block->autofill= 0;
380 }
381
382 /* ************** LINK LINE DRAWING  ************* */
383
384 /* link line drawing is not part of buttons or theme.. so we stick with it here */
385
386 static void ui_draw_linkline(uiBut *but, uiLinkLine *line)
387 {
388         float vec1[2], vec2[2];
389
390         if(line->from==NULL || line->to==NULL) return;
391         
392         vec1[0]= (line->from->x1+line->from->x2)/2.0;
393         vec1[1]= (line->from->y1+line->from->y2)/2.0;
394         vec2[0]= (line->to->x1+line->to->x2)/2.0;
395         vec2[1]= (line->to->y1+line->to->y2)/2.0;
396         
397         if(line->flag & UI_SELECT) UI_ThemeColorShade(but->themecol, 80);
398         else glColor3ub(0,0,0);
399         fdrawline(vec1[0], vec1[1], vec2[0], vec2[1]);
400 }
401
402 static void ui_draw_links(uiBlock *block)
403 {
404         uiBut *but;
405         uiLinkLine *line;
406         
407         but= block->buttons.first;
408         while(but) {
409                 if(but->type==LINK && but->link) {
410                         line= but->link->lines.first;
411                         while(line) {
412                                 ui_draw_linkline(but, line);
413                                 line= line->next;
414                         }
415                 }
416                 but= but->next;
417         }       
418 }
419
420 /* ************** BLOCK ENDING FUNCTION ************* */
421
422 static int ui_but_equals_old(uiBut *but, uiBut *oldbut)
423 {
424         /* various properties are being compared here, hopfully sufficient
425          * to catch all cases, but it is simple to add more checks later */
426         if(but->retval != oldbut->retval) return 0;
427         if(but->poin != oldbut->poin || but->pointype != oldbut->pointype) return 0;
428         if(but->rnapoin.data != oldbut->rnapoin.data) return 0;
429         if(but->rnaprop != oldbut->rnaprop)
430         if(but->rnaindex != oldbut->rnaindex) return 0;
431         if(but->func != oldbut->func) return 0;
432         if(but->func_arg1 != oldbut->func_arg1) return 0;
433         if(but->func_arg2 != oldbut->func_arg2) return 0;
434
435         return 1;
436 }
437
438 static int ui_but_update_from_old_block(const bContext *C, uiBlock *block, uiBut *but)
439 {
440         uiBlock *oldblock;
441         uiBut *oldbut;
442         int found= 0;
443
444         oldblock= block->oldblock;
445         if(!oldblock)
446                 return found;
447
448         for(oldbut=oldblock->buttons.first; oldbut; oldbut=oldbut->next) {
449                 if(ui_but_equals_old(oldbut, but)) {
450                         if(oldbut->active) {
451                                 but->flag= oldbut->flag;
452                                 but->active= oldbut->active;
453                                 but->pos= oldbut->pos;
454                                 but->editstr= oldbut->editstr;
455                                 but->editval= oldbut->editval;
456                                 but->editvec= oldbut->editvec;
457                                 but->editcoba= oldbut->editcoba;
458                                 but->editcumap= oldbut->editcumap;
459                                 but->selsta= oldbut->selsta;
460                                 but->selend= oldbut->selend;
461                                 found= 1;
462
463                                 oldbut->active= NULL;
464                         }
465
466                         /* ensures one button can get activated, and in case the buttons
467                          * draw are the same this gives O(1) lookup for each button */
468                         BLI_remlink(&oldblock->buttons, oldbut);
469                         ui_free_but(C, oldbut);
470                         
471                         break;
472                 }
473         }
474         
475         return found;
476 }
477
478 void uiEndBlock(const bContext *C, uiBlock *block)
479 {
480         uiBut *but;
481
482         /* inherit flags from 'old' buttons that was drawn here previous, based
483          * on matching buttons, we need this to make button event handling non
484          * blocking, while still alowing buttons to be remade each redraw as it
485          * is expected by blender code */
486         for(but=block->buttons.first; but; but=but->next)
487                 if(ui_but_update_from_old_block(C, block, but))
488                         ui_check_but(but);
489
490         if(block->oldblock) {
491                 block->auto_open= block->oldblock->auto_open;
492                 block->auto_open_last= block->oldblock->auto_open_last;
493                 block->tooltipdisabled= block->oldblock->tooltipdisabled;
494
495                 block->oldblock= NULL;
496         }
497         
498         /* handle pending stuff */
499         if(block->autofill) ui_autofill(block);
500         if(block->minx==0.0 && block->maxx==0.0) uiBoundsBlock(block, 0);
501         if(block->flag & UI_BUT_ALIGN) uiBlockEndAlign(block);
502 }
503
504 /* ************** BLOCK DRAWING FUNCTION ************* */
505
506 void uiDrawBlock(const bContext *C, uiBlock *block)
507 {
508         uiBut *but;
509
510         /* we set this only once */
511         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
512         
513         if(block->flag & UI_BLOCK_LOOP)
514                 uiDrawMenuBox(block->minx, block->miny, block->maxx, block->maxy, block->flag);
515         else if(block->panel)
516                 ui_draw_panel(CTX_wm_region(C), block);
517
518         if(block->drawextra) block->drawextra(C, block);
519
520         for (but= block->buttons.first; but; but= but->next)
521                 ui_draw_but(but);
522
523         ui_draw_links(block);
524 }
525
526 /* ************* EVENTS ************* */
527
528 static void ui_is_but_sel(uiBut *but)
529 {
530         double value;
531         int lvalue;
532         short push=0, true=1;
533
534         value= ui_get_but_val(but);
535
536         if( but->type==TOGN  || but->type==ICONTOGN) true= 0;
537
538         if( but->bit ) {
539                 lvalue= (int)value;
540                 if( BTST(lvalue, (but->bitnr)) ) push= true;
541                 else push= !true;
542         }
543         else {
544                 switch(but->type) {
545                 case BUT:
546                         push= 2;
547                         break;
548                 case KEYEVT:
549                         if (value==-1) push= 1;
550                         break;
551                 case TOG:
552                 case TOGR:
553                 case TOG3:
554                 case BUT_TOGDUAL:
555                 case ICONTOG:
556                         if(value!=but->min) push= 1;
557                         break;
558                 case ICONTOGN:
559                 case TOGN:
560                         if(value==0.0) push= 1;
561                         break;
562                 case ROW:
563                         if(value == but->max) push= 1;
564                         break;
565                 case COL:
566                         push= 1;
567                         break;
568                 default:
569                         push= 2;
570                         break;
571                 }
572         }
573         
574         if(push==2);
575         else if(push==1) but->flag |= UI_SELECT;
576         else but->flag &= ~UI_SELECT;
577 }
578
579 /* XXX 2.50 no links supported yet */
580
581 #if 0
582 static uiBut *ui_get_valid_link_button(uiBlock *block, uiBut *but, short *mval)
583 {
584         uiBut *bt;
585         
586                 /* find button to link to */
587         for (bt= block->buttons.first; bt; bt= bt->next)
588                 if(bt!=but && uibut_contains_pt(bt, mval))
589                         break;
590
591         if (bt) {
592                 if (but->type==LINK && bt->type==INLINK) {
593                         if( but->link->tocode == (int)bt->min ) {
594                                 return bt;
595                         }
596                 }
597                 else if(but->type==INLINK && bt->type==LINK) {
598                         if( bt->link->tocode == (int)but->min ) {
599                                 return bt;
600                         }
601                 }
602         }
603
604         return NULL;
605 }
606
607 static int ui_is_a_link(uiBut *from, uiBut *to)
608 {
609         uiLinkLine *line;
610         uiLink *link;
611         
612         link= from->link;
613         if(link) {
614                 line= link->lines.first;
615                 while(line) {
616                         if(line->from==from && line->to==to) return 1;
617                         line= line->next;
618                 }
619         }
620         return 0;
621 }
622
623 static uiBut *ui_find_inlink(uiBlock *block, void *poin)
624 {
625         uiBut *but;
626         
627         but= block->buttons.first;
628         while(but) {
629                 if(but->type==INLINK) {
630                         if(but->poin == poin) return but;
631                 }
632                 but= but->next;
633         }
634         return NULL;
635 }
636
637 static void ui_add_link_line(ListBase *listb, uiBut *but, uiBut *bt)
638 {
639         uiLinkLine *line;
640         
641         line= MEM_callocN(sizeof(uiLinkLine), "linkline");
642         BLI_addtail(listb, line);
643         line->from= but;
644         line->to= bt;
645 }
646
647 uiBut *uiFindInlink(uiBlock *block, void *poin)
648 {
649         return ui_find_inlink(block, poin);
650 }
651
652 void uiComposeLinks(uiBlock *block)
653 {
654         uiBut *but, *bt;
655         uiLink *link;
656         void ***ppoin;
657         int a;
658         
659         but= block->buttons.first;
660         while(but) {
661                 if(but->type==LINK) {
662                         link= but->link;
663                         
664                         /* for all pointers in the array */
665                         if(link) {
666                                 if(link->ppoin) {
667                                         ppoin= link->ppoin;
668                                         for(a=0; a < *(link->totlink); a++) {
669                                                 bt= ui_find_inlink(block, (*ppoin)[a] );
670                                                 if(bt) {
671                                                         ui_add_link_line(&link->lines, but, bt);
672                                                 }
673                                         }
674                                 }
675                                 else if(link->poin) {
676                                         bt= ui_find_inlink(block, *(link->poin) );
677                                         if(bt) {
678                                                 ui_add_link_line(&link->lines, but, bt);
679                                         }
680                                 }
681                         }
682                 }
683                 but= but->next;
684         }
685 }
686
687 static void ui_add_link(uiBut *from, uiBut *to)
688 {
689         /* in 'from' we have to add a link to 'to' */
690         uiLink *link;
691         void **oldppoin;
692         int a;
693         
694         if(ui_is_a_link(from, to)) {
695                 printf("already exists\n");
696                 return;
697         }
698         
699         link= from->link;
700
701         /* are there more pointers allowed? */
702         if(link->ppoin) {
703                 oldppoin= *(link->ppoin);
704                 
705                 (*(link->totlink))++;
706                 *(link->ppoin)= MEM_callocN( *(link->totlink)*sizeof(void *), "new link");
707
708                 for(a=0; a< (*(link->totlink))-1; a++) {
709                         (*(link->ppoin))[a]= oldppoin[a];
710                 }
711                 (*(link->ppoin))[a]= to->poin;
712                 
713                 if(oldppoin) MEM_freeN(oldppoin);
714         }
715         else {
716                 *(link->poin)= to->poin;
717         }
718         
719 }
720
721 static int ui_do_but_LINK(uiBlock *block, uiBut *but)
722 {
723         /* 
724          * This button only visualizes, the dobutton mode
725          * can add a new link, but then the whole system
726          * should be redrawn/initialized. 
727          * 
728          */
729         uiBut *bt=0, *bto=NULL;
730         short sval[2], mval[2], mvalo[2], first= 1;
731
732         uiGetMouse(curarea->win, sval);
733         mvalo[0]= sval[0];
734         mvalo[1]= sval[1];
735         
736         while (get_mbut() & L_MOUSE) {
737                 uiGetMouse(curarea->win, mval);
738
739                 if(mval[0]!=mvalo[0] || mval[1]!=mvalo[1] || first) {                   
740                                 /* clear completely, because of drawbuttons */
741                         bt= ui_get_valid_link_button(block, but, mval);
742                         if(bt) {
743                                 bt->flag |= UI_ACTIVE;
744                                 ui_draw_but(bt);
745                         }
746                         if(bto && bto!=bt) {
747                                 bto->flag &= ~UI_ACTIVE;
748                                 ui_draw_but(bto);
749                         }
750                         bto= bt;
751
752                         if (!first) {
753                                 glutil_draw_front_xor_line(sval[0], sval[1], mvalo[0], mvalo[1]);
754                         }
755                         glutil_draw_front_xor_line(sval[0], sval[1], mval[0], mval[1]);
756
757                         mvalo[0]= mval[0];
758                         mvalo[1]= mval[1];
759
760                         first= 0;
761                 }
762                 else UI_wait_for_statechange();         
763         }
764         
765         if (!first) {
766                 glutil_draw_front_xor_line(sval[0], sval[1], mvalo[0], mvalo[1]);
767         }
768
769         if(bt) {
770                 if(but->type==LINK) ui_add_link(but, bt);
771                 else ui_add_link(bt, but);
772
773                 scrarea_queue_winredraw(curarea);
774         }
775
776         return 0;
777 }
778 #endif
779
780 /* ************************************************ */
781
782 void uiBlockSetButLock(uiBlock *block, int val, char *lockstr)
783 {
784         block->lock |= val;
785         if(val) block->lockstr= lockstr;
786 }
787
788 void uiBlockClearButLock(uiBlock *block)
789 {
790         block->lock= 0;
791         block->lockstr= NULL;
792 }
793
794 /* *************************************************************** */
795
796 /* XXX 2.50 no button editing */
797
798 #if 0
799 static void setup_file(uiBlock *block)
800 {
801         uiBut *but;
802         FILE *fp;
803
804         fp= fopen("butsetup","w");
805         if(fp==NULL);
806         else {
807                 but= block->buttons.first;
808                 while(but) {
809                         ui_check_but(but);
810                         fprintf(fp,"%d,%d,%d,%d   %s %s\n", (int)but->x1, (int)but->y1, (int)( but->x2-but->x1), (int)(but->y2-but->y1), but->str, but->tip);
811                         but= but->next;
812                 }
813                 fclose(fp);
814         }
815 }
816
817
818 static void edit_but(uiBlock *block, uiBut *but, uiEvent *uevent)
819 {
820         short dx, dy, mval[2], mvalo[2], didit=0;
821         
822         getmouseco_sc(mvalo);
823         while(TRUE) {
824                 if( !(get_mbut() & L_MOUSE) ) break;    
825         
826                 getmouseco_sc(mval);
827                 dx= (mval[0]-mvalo[0]);
828                 dy= (mval[1]-mvalo[1]);
829                 
830                 if(dx!=0 || dy!=0) {
831                         mvalo[0]= mval[0];
832                         mvalo[1]= mval[1];
833                         
834                         cpack(0xc0c0c0);
835                         glRectf(but->x1-2, but->y1-2, but->x2+2, but->y2+2); 
836                         
837                         if((uevent->qual & LR_SHIFTKEY)==0) {
838                                 but->x1 += dx;
839                                 but->y1 += dy;
840                         }
841                         but->x2 += dx;
842                         but->y2 += dy;
843                         
844                         ui_draw_but(but);
845                         ui_block_flush_back(but->block);
846                         didit= 1;
847
848                 }
849                 /* idle for this poor code */
850                 else PIL_sleep_ms(30);
851         }
852         if(didit) setup_file(block);
853 }
854 #endif
855
856 /* XXX 2.50 no links supported yet */
857 #if 0
858 static void ui_delete_active_linkline(uiBlock *block)
859 {
860         uiBut *but;
861         uiLink *link;
862         uiLinkLine *line, *nline;
863         int a, b;
864         
865         but= block->buttons.first;
866         while(but) {
867                 if(but->type==LINK && but->link) {
868                         line= but->link->lines.first;
869                         while(line) {
870                                 
871                                 nline= line->next;
872                                 
873                                 if(line->flag & UI_SELECT) {
874                                         BLI_remlink(&but->link->lines, line);
875
876                                         link= line->from->link;
877
878                                         /* are there more pointers allowed? */
879                                         if(link->ppoin) {
880                                                 
881                                                 if(*(link->totlink)==1) {
882                                                         *(link->totlink)= 0;
883                                                         MEM_freeN(*(link->ppoin));
884                                                         *(link->ppoin)= NULL;
885                                                 }
886                                                 else {
887                                                         b= 0;
888                                                         for(a=0; a< (*(link->totlink)); a++) {
889                                                                 
890                                                                 if( (*(link->ppoin))[a] != line->to->poin ) {
891                                                                         (*(link->ppoin))[b]= (*(link->ppoin))[a];
892                                                                         b++;
893                                                                 }
894                                                         }       
895                                                         (*(link->totlink))--;
896                                                 }
897                                         }
898                                         else {
899                                                 *(link->poin)= NULL;
900                                         }
901
902                                         MEM_freeN(line);
903                                 }
904                                 line= nline;
905                         }
906                 }
907                 but= but->next;
908         }
909         
910         /* temporal! these buttons can be everywhere... */
911         allqueue(REDRAWBUTSLOGIC, 0);
912 }
913
914 static void ui_do_active_linklines(uiBlock *block, short *mval)
915 {
916         uiBut *but;
917         uiLinkLine *line, *act= NULL;
918         float mindist= 12.0, fac, v1[2], v2[2], v3[3];
919         int foundone= 0; 
920         
921         if(mval) {
922                 v1[0]= mval[0];
923                 v1[1]= mval[1];
924                 
925                 /* find a line close to the mouse */
926                 but= block->buttons.first;
927                 while(but) {
928                         if(but->type==LINK && but->link) {
929                                 foundone= 1;
930                                 line= but->link->lines.first;
931                                 while(line) {
932                                         v2[0]= line->from->x2;
933                                         v2[1]= (line->from->y1+line->from->y2)/2.0;
934                                         v3[0]= line->to->x1;
935                                         v3[1]= (line->to->y1+line->to->y2)/2.0;
936                                         
937                                         fac= PdistVL2Dfl(v1, v2, v3);
938                                         if(fac < mindist) {
939                                                 mindist= fac;
940                                                 act= line;
941                                         }
942                                         line= line->next;
943                                 }
944                         }
945                         but= but->next;
946                 }
947         }
948
949         /* check for a 'found one' to prevent going to 'frontbuffer' mode.
950                 this slows done gfx quite some, and at OSX the 'finish' forces a swapbuffer */
951         if(foundone) {
952                 glDrawBuffer(GL_FRONT);
953                 
954                 /* draw */
955                 but= block->buttons.first;
956                 while(but) {
957                         if(but->type==LINK && but->link) {
958                                 line= but->link->lines.first;
959                                 while(line) {
960                                         if(line==act) {
961                                                 if((line->flag & UI_SELECT)==0) {
962                                                         line->flag |= UI_SELECT;
963                                                         ui_draw_linkline(but, line);
964                                                 }
965                                         }
966                                         else if(line->flag & UI_SELECT) {
967                                                 line->flag &= ~UI_SELECT;
968                                                 ui_draw_linkline(but, line);
969                                         }
970                                         line= line->next;
971                                 }
972                         }
973                         but= but->next;
974                 }
975                 bglFlush();
976                 glDrawBuffer(GL_BACK);
977         }
978 }
979 #endif
980
981 /* ******************************************************* */
982
983 /* XXX 2.50 no screendump supported yet */
984
985 #if 0
986 /* nasty but safe way to store screendump rect */
987 static int scr_x=0, scr_y=0, scr_sizex=0, scr_sizey=0;
988
989 static void ui_set_screendump_bbox(uiBlock *block)
990 {
991         if(block) {
992                 scr_x= block->minx;
993                 scr_y= block->miny;
994                 scr_sizex= block->maxx - block->minx;
995                 scr_sizey= block->maxy - block->miny;
996         }
997         else {
998                 scr_sizex= scr_sizey= 0;
999         }
1000 }
1001
1002 /* used for making screenshots for menus, called in screendump.c */
1003 int uiIsMenu(int *x, int *y, int *sizex, int *sizey)
1004 {
1005         if(scr_sizex!=0 && scr_sizey!=0) {
1006                 *x= scr_x;
1007                 *y= scr_y;
1008                 *sizex= scr_sizex;
1009                 *sizey= scr_sizey;
1010                 return 1;
1011         }
1012         
1013         return 0;
1014 }
1015 #endif
1016
1017 /* *********************** data get/set ***********************
1018  * this either works with the pointed to data, or can work with
1019  * an edit override pointer while dragging for example */
1020
1021 /* for buttons pointing to color for example */
1022 void ui_get_but_vectorf(uiBut *but, float *vec)
1023 {
1024         void *poin;
1025         int pointype;
1026
1027         poin= (but->editvec)? (void*)but->editvec: but->poin;
1028         pointype= (but->editvec)? FLO: but->pointype;
1029
1030         if(!but->editvec && pointype == CHA) {
1031                 char *cp= (char *)poin;
1032                 vec[0]= ((float)cp[0])/255.0;
1033                 vec[1]= ((float)cp[1])/255.0;
1034                 vec[2]= ((float)cp[2])/255.0;
1035         }
1036         else if(pointype == FLO) {
1037                 float *fp= (float *)poin;
1038                 VECCOPY(vec, fp);
1039         }
1040 }
1041
1042 /* for buttons pointing to color for example */
1043 void ui_set_but_vectorf(uiBut *but, float *vec)
1044 {
1045         void *poin;
1046         int pointype;
1047
1048         poin= (but->editvec)? (void*)but->editvec: but->poin;
1049         pointype= (but->editvec)? FLO: but->pointype;
1050
1051         if(!but->editvec && but->pointype == CHA) {
1052                 char *cp= (char *)poin;
1053                 cp[0]= (char)(0.5 +vec[0]*255.0);
1054                 cp[1]= (char)(0.5 +vec[1]*255.0);
1055                 cp[2]= (char)(0.5 +vec[2]*255.0);
1056         }
1057         else if( but->pointype == FLO ) {
1058                 float *fp= (float *)poin;
1059                 VECCOPY(fp, vec);
1060         }
1061 }
1062
1063 int ui_is_but_float(uiBut *but)
1064 {
1065         if(but->pointype==FLO && but->poin)
1066                 return 1;
1067         
1068         if(but->rnaprop && RNA_property_type(&but->rnapoin, but->rnaprop) == PROP_FLOAT)
1069                 return 1;
1070         
1071         return 0;
1072 }
1073
1074 double ui_get_but_val(uiBut *but)
1075 {
1076         PropertyRNA *prop;
1077         double value = 0.0;
1078
1079         if(but->editval) { return *(but->editval); }
1080         if(but->poin==NULL && but->rnapoin.data==NULL) return 0.0;
1081
1082         if(but->rnaprop) {
1083                 prop= but->rnaprop;
1084
1085                 switch(RNA_property_type(&but->rnapoin, prop)) {
1086                         case PROP_BOOLEAN:
1087                                 if(RNA_property_array_length(&but->rnapoin, prop))
1088                                         value= RNA_property_boolean_get_array(&but->rnapoin, prop, but->rnaindex);
1089                                 else
1090                                         value= RNA_property_boolean_get(&but->rnapoin, prop);
1091                                 break;
1092                         case PROP_INT:
1093                                 if(RNA_property_array_length(&but->rnapoin, prop))
1094                                         value= RNA_property_int_get_array(&but->rnapoin, prop, but->rnaindex);
1095                                 else
1096                                         value= RNA_property_int_get(&but->rnapoin, prop);
1097                                 break;
1098                         case PROP_FLOAT:
1099                                 if(RNA_property_array_length(&but->rnapoin, prop))
1100                                         value= RNA_property_float_get_array(&but->rnapoin, prop, but->rnaindex);
1101                                 else
1102                                         value= RNA_property_float_get(&but->rnapoin, prop);
1103                                 break;
1104                         case PROP_ENUM:
1105                                 value= RNA_property_enum_get(&but->rnapoin, prop);
1106                                 break;
1107                         default:
1108                                 value= 0.0;
1109                                 break;
1110                 }
1111         }
1112         else if(but->type== HSVSLI) {
1113                 float h, s, v, *fp;
1114                 
1115                 fp= (but->editvec)? but->editvec: (float *)but->poin;
1116                 rgb_to_hsv(fp[0], fp[1], fp[2], &h, &s, &v);
1117
1118                 switch(but->str[0]) {
1119                         case 'H': value= h; break;
1120                         case 'S': value= s; break;
1121                         case 'V': value= v; break;
1122                 }
1123         } 
1124         else if( but->pointype == CHA ) {
1125                 value= *(char *)but->poin;
1126         }
1127         else if( but->pointype == SHO ) {
1128                 value= *(short *)but->poin;
1129         } 
1130         else if( but->pointype == INT ) {
1131                 value= *(int *)but->poin;
1132         } 
1133         else if( but->pointype == FLO ) {
1134                 value= *(float *)but->poin;
1135         }
1136     
1137         return value;
1138 }
1139
1140 void ui_set_but_val(uiBut *but, double value)
1141 {
1142         PropertyRNA *prop;
1143
1144         /* value is a hsv value: convert to rgb */
1145         if(but->rnaprop) {
1146                 prop= but->rnaprop;
1147
1148                 if(RNA_property_editable(&but->rnapoin, prop)) {
1149                         switch(RNA_property_type(&but->rnapoin, prop)) {
1150                                 case PROP_BOOLEAN:
1151                                         if(RNA_property_array_length(&but->rnapoin, prop))
1152                                                 RNA_property_boolean_set_array(&but->rnapoin, prop, but->rnaindex, value);
1153                                         else
1154                                                 RNA_property_boolean_set(&but->rnapoin, prop, value);
1155                                         break;
1156                                 case PROP_INT:
1157                                         if(RNA_property_array_length(&but->rnapoin, prop))
1158                                                 RNA_property_int_set_array(&but->rnapoin, prop, but->rnaindex, value);
1159                                         else
1160                                                 RNA_property_int_set(&but->rnapoin, prop, value);
1161                                         break;
1162                                 case PROP_FLOAT:
1163                                         if(RNA_property_array_length(&but->rnapoin, prop))
1164                                                 RNA_property_float_set_array(&but->rnapoin, prop, but->rnaindex, value);
1165                                         else
1166                                                 RNA_property_float_set(&but->rnapoin, prop, value);
1167                                         break;
1168                                 case PROP_ENUM:
1169                                         RNA_property_enum_set(&but->rnapoin, prop, value);
1170                                         break;
1171                                 default:
1172                                         break;
1173                         }
1174                 }
1175         }
1176         else if(but->pointype==0);
1177         else if(but->type==HSVSLI ) {
1178                 float h, s, v, *fp;
1179                 
1180                 fp= (but->editvec)? but->editvec: (float *)but->poin;
1181                 rgb_to_hsv(fp[0], fp[1], fp[2], &h, &s, &v);
1182                 
1183                 switch(but->str[0]) {
1184                 case 'H': h= value; break;
1185                 case 'S': s= value; break;
1186                 case 'V': v= value; break;
1187                 }
1188                 
1189                 hsv_to_rgb(h, s, v, fp, fp+1, fp+2);
1190                 
1191         }
1192         else {
1193                 /* first do rounding */
1194                 if(but->pointype==CHA)
1195                         value= (char)floor(value+0.5);
1196                 else if(but->pointype==SHO ) {
1197                         /* gcc 3.2.1 seems to have problems 
1198                          * casting a double like 32772.0 to
1199                          * a short so we cast to an int, then 
1200                          to a short */
1201                         int gcckludge;
1202                         gcckludge = (int) floor(value+0.5);
1203                         value= (short)gcckludge;
1204                 }
1205                 else if(but->pointype==INT )
1206                         value= (int)floor(value+0.5);
1207                 else if(but->pointype==FLO ) {
1208                         float fval= (float)value;
1209                         if(fval>= -0.00001f && fval<= 0.00001f) fval= 0.0f;     /* prevent negative zero */
1210                         value= fval;
1211                 }
1212                 
1213                 /* then set value with possible edit override */
1214                 if(but->editval)
1215                         *but->editval= value;
1216                 else if(but->pointype==CHA)
1217                         *((char *)but->poin)= (char)value;
1218                 else if(but->pointype==SHO)
1219                         *((short *)but->poin)= (short)value;
1220                 else if(but->pointype==INT)
1221                         *((int *)but->poin)= (int)value;
1222                 else if(but->pointype==FLO)
1223                         *((float *)but->poin)= (float)value;
1224         }
1225
1226         /* update select flag */
1227         ui_is_but_sel(but);
1228 }
1229
1230 void ui_get_but_string(uiBut *but, char *str, int maxlen)
1231 {
1232         if(but->rnaprop) {
1233                 char *buf;
1234                 
1235                 buf= RNA_property_string_get_alloc(&but->rnapoin, but->rnaprop, str, maxlen);
1236
1237                 if(buf != str) {
1238                         /* string was too long, we have to truncate */
1239                         BLI_strncpy(str, buf, maxlen);
1240                         MEM_freeN(buf);
1241                 }
1242         }
1243         else
1244                 BLI_strncpy(str, but->poin, maxlen);
1245
1246 }
1247
1248 void ui_set_but_string(uiBut *but, const char *str)
1249 {
1250         if(but->rnaprop) {
1251                 if(RNA_property_editable(&but->rnapoin, but->rnaprop))
1252                         RNA_property_string_set(&but->rnapoin, but->rnaprop, str);
1253         }
1254         else
1255                 BLI_strncpy(but->poin, str, but->max);
1256 }
1257
1258 /* ******************* Font ********************/
1259
1260 static void ui_set_ftf_font(float aspect)
1261 {
1262 #ifdef INTERNATIONAL
1263         if(aspect<1.15) {
1264                 FTF_SetFontSize('l');
1265         }
1266         else if(aspect<1.59) {
1267                 FTF_SetFontSize('m');
1268         }
1269         else {
1270                 FTF_SetFontSize('s');
1271         }
1272 #endif
1273 }
1274
1275 void uiSetCurFont(uiBlock *block, int index)
1276 {
1277         ui_set_ftf_font(block->aspect);
1278         
1279         if(block->aspect<0.60) {
1280                 block->curfont= UIfont[index].xl;
1281         }
1282         else if(block->aspect<1.15) {
1283                 block->curfont= UIfont[index].large;
1284         }
1285         else if(block->aspect<1.59) {
1286                 block->curfont= UIfont[index].medium;           
1287         }
1288         else {
1289                 block->curfont= UIfont[index].small;            
1290         }
1291
1292         if(block->curfont==NULL) block->curfont= UIfont[index].large;   
1293         if(block->curfont==NULL) block->curfont= UIfont[index].medium;  
1294         if(block->curfont==NULL) printf("error block no font %s\n", block->name);
1295         
1296 }
1297
1298 /* called by node editor */
1299 void *uiSetCurFont_ext(float aspect)
1300 {
1301         void *curfont;
1302         
1303         ui_set_ftf_font(aspect);
1304         
1305         if(aspect<0.60) {
1306                 curfont= UIfont[0].xl;
1307         }
1308         else if(aspect<1.15) {
1309                 curfont= UIfont[0].large;
1310         }
1311         else if(aspect<1.59) {
1312                 curfont= UIfont[0].medium;              
1313         }
1314         else {
1315                 curfont= UIfont[0].small;               
1316         }
1317         
1318         if(curfont==NULL) curfont= UIfont[0].large;     
1319         if(curfont==NULL) curfont= UIfont[0].medium;    
1320         
1321         return curfont;
1322 }
1323
1324 void uiDefFont(unsigned int index, void *xl, void *large, void *medium, void *small)
1325 {
1326         if(index>=UI_ARRAY) return;
1327         
1328         UIfont[index].xl= xl;
1329         UIfont[index].large= large;
1330         UIfont[index].medium= medium;
1331         UIfont[index].small= small;
1332 }
1333
1334 /* ******************* Free ********************/
1335
1336 static void ui_free_link(uiLink *link)
1337 {
1338         if(link) {      
1339                 BLI_freelistN(&link->lines);
1340                 MEM_freeN(link);
1341         }
1342 }
1343
1344 static void ui_free_but(const bContext *C, uiBut *but)
1345 {
1346         if(but->opproperties) {
1347                 IDP_FreeProperty(but->opproperties);
1348                 MEM_freeN(but->opproperties);
1349         }
1350         if(but->opptr) MEM_freeN(but->opptr);
1351         if(but->active) ui_button_active_cancel(C, but);
1352         if(but->str && but->str != but->strdata) MEM_freeN(but->str);
1353         ui_free_link(but->link);
1354
1355         MEM_freeN(but);
1356 }
1357
1358 void uiFreeBlock(const bContext *C, uiBlock *block)
1359 {
1360         uiBut *but;
1361
1362         while( (but= block->buttons.first) ) {
1363                 BLI_remlink(&block->buttons, but);      
1364                 ui_free_but(C, but);
1365         }
1366
1367         if(block->panel) {
1368                 block->panel->active= 0;
1369         }
1370         BLI_freelistN(&block->saferct);
1371         
1372         MEM_freeN(block);
1373 }
1374
1375 void uiFreeBlocks(const bContext *C, ListBase *lb)
1376 {
1377         uiBlock *block;
1378         
1379         while( (block= lb->first) ) {
1380                 BLI_remlink(lb, block);
1381                 uiFreeBlock(C, block);
1382         }
1383 }
1384
1385 void uiFreeInactiveBlocks(const bContext *C, ListBase *lb)
1386 {
1387         uiBlock *block, *nextblock;
1388
1389         for(block=lb->first; block; block=nextblock) {
1390                 nextblock= block->next;
1391         
1392                 if(!block->handle) {
1393                         if(!block->active) {
1394                                 BLI_remlink(lb, block);
1395                                 uiFreeBlock(C, block);
1396                         }
1397                         else
1398                                 block->active= 0;
1399                 }
1400         }
1401 }
1402
1403 uiBlock *uiBeginBlock(const bContext *C, ARegion *region, char *name, short dt, short font)
1404 {
1405         ListBase *lb;
1406         uiBlock *block, *oldblock= NULL;
1407         wmWindow *window;
1408         int getsizex, getsizey;
1409
1410         window= CTX_wm_window(C);
1411         lb= &region->uiblocks;
1412         
1413         /* each listbase only has one block with this name, free block
1414          * if is already there so it can be rebuilt from scratch */
1415         if(lb) {
1416                 for (oldblock= lb->first; oldblock; oldblock= oldblock->next)
1417                         if (BLI_streq(oldblock->name, name))
1418                                 break;
1419
1420                 if (oldblock) {
1421                         oldblock->active= 0;
1422                         oldblock->panel= NULL;
1423                 }
1424         }
1425         
1426         block= MEM_callocN(sizeof(uiBlock), "uiBlock");
1427         block->oldblock= oldblock;
1428         block->active= 1;
1429
1430         /* at the beginning of the list! for dynamical menus/blocks */
1431         if(lb)
1432                 BLI_addhead(lb, block);
1433
1434         BLI_strncpy(block->name, name, sizeof(block->name));
1435
1436 #if 0
1437         /* draw win */
1438         block->win= win;
1439         /* window where queue event should be added, pretty weak this way!
1440            this is because the 'mainwin' pup menu's */
1441         block->winq= mywinget();
1442 #endif
1443
1444         block->dt= dt;
1445         block->themecol= TH_AUTO;
1446
1447         /* window matrix and aspect */
1448         if(region->swinid) {
1449                 wm_subwindow_getmatrix(window, region->swinid, block->winmat);
1450                 wm_subwindow_getsize(window, region->swinid, &getsizex, &getsizey);
1451
1452                 /* TODO - investigate why block->winmat[0][0] is negative
1453                  * in the image view when viewRedrawForce is called */
1454                 block->aspect= 2.0/fabs( (getsizex)*block->winmat[0][0]);
1455         }
1456         else {
1457                 /* no subwindow created yet, for menus for example, so we
1458                  * use the main window instead, since buttons are created
1459                  * there anyway */
1460                 wm_subwindow_getmatrix(window, window->winid, block->winmat);
1461                 wm_subwindow_getsize(window, window->winid, &getsizex, &getsizey);
1462
1463                 block->aspect= 2.0/fabs(getsizex*block->winmat[0][0]);
1464                 block->auto_open= 2;
1465         }
1466
1467         uiSetCurFont(block, font);
1468
1469         return block;
1470 }
1471
1472 uiBlock *uiGetBlock(char *name, ARegion *ar)
1473 {
1474         uiBlock *block= ar->uiblocks.first;
1475         
1476         while(block) {
1477                 if( strcmp(name, block->name)==0 ) return block;
1478                 block= block->next;
1479         }
1480         
1481         return NULL;
1482 }
1483
1484 void ui_check_but(uiBut *but)
1485 {
1486         /* if something changed in the button */
1487         ID *id;
1488         double value;
1489         float okwidth;
1490         int transopts= ui_translate_buttons();
1491         short pos;
1492         
1493         ui_is_but_sel(but);
1494         
1495         if(but->type==TEX || but->type==IDPOIN) transopts= 0;
1496
1497         /* test for min and max, icon sliders, etc */
1498         switch( but->type ) {
1499                 case NUM:
1500                 case SLI:
1501                 case SCROLL:
1502                 case NUMSLI:
1503                 case HSVSLI:
1504                         value= ui_get_but_val(but);
1505                         if(value < but->min) ui_set_but_val(but, but->min);
1506                         else if(value > but->max) ui_set_but_val(but, but->max);
1507                         break;
1508                         
1509                 case NUMABS:
1510                         value= fabs( ui_get_but_val(but) );
1511                         if(value < but->min) ui_set_but_val(but, but->min);
1512                         else if(value > but->max) ui_set_but_val(but, but->max);
1513                         break;
1514                         
1515                 case ICONTOG: 
1516                 case ICONTOGN:
1517                         if(but->flag & UI_SELECT) but->iconadd= 1;
1518                         else but->iconadd= 0;
1519                         break;
1520                         
1521                 case ICONROW:
1522                         value= ui_get_but_val(but);
1523                         but->iconadd= (int)value- (int)(but->min);
1524                         break;
1525                         
1526                 case ICONTEXTROW:
1527                         value= ui_get_but_val(but);
1528                         but->iconadd= (int)value- (int)(but->min);
1529                         break;
1530         }
1531         
1532         
1533         /* safety is 4 to enable small number buttons (like 'users') */
1534         if(but->type==NUMSLI || but->type==HSVSLI) 
1535                 okwidth= -4 + (but->x2 - but->x1)/2.0;
1536         else 
1537                 okwidth= -4 + (but->x2 - but->x1); 
1538         
1539         /* name: */
1540         switch( but->type ) {
1541         
1542         case MENU:
1543         case ICONTEXTROW:
1544                 
1545                 if(but->x2 - but->x1 > 24) {
1546                         value= ui_get_but_val(but);
1547                         ui_set_name_menu(but, (int)value);
1548                 }
1549                 break;
1550         
1551         case NUM:
1552         case NUMSLI:
1553         case HSVSLI:
1554         case NUMABS:
1555
1556                 value= ui_get_but_val(but);
1557
1558                 if(ui_is_but_float(but)) {
1559                         if(value == FLT_MAX) sprintf(but->drawstr, "%sFLT_MAX", but->str);
1560                         else if(value == -FLT_MAX) sprintf(but->drawstr, "%s-FLT_MAX", but->str);
1561                         else if(but->a2) { /* amount of digits defined */
1562                                 if(but->a2==1) sprintf(but->drawstr, "%s%.1f", but->str, value);
1563                                 else if(but->a2==2) sprintf(but->drawstr, "%s%.2f", but->str, value);
1564                                 else if(but->a2==3) sprintf(but->drawstr, "%s%.3f", but->str, value);
1565                                 else sprintf(but->drawstr, "%s%.4f", but->str, value);
1566                         }
1567                         else {
1568                                 if(but->max<10.001) sprintf(but->drawstr, "%s%.3f", but->str, value);
1569                                 else sprintf(but->drawstr, "%s%.2f", but->str, value);
1570                         }
1571                 }
1572                 else {
1573                         sprintf(but->drawstr, "%s%d", but->str, (int)value);
1574                 }
1575                 break;
1576
1577         case LABEL:
1578                 if(ui_is_but_float(but)) {
1579                         value= ui_get_but_val(but);
1580                         if(but->a2) { /* amount of digits defined */
1581                                 if(but->a2==1) sprintf(but->drawstr, "%s%.1f", but->str, value);
1582                                 else if(but->a2==2) sprintf(but->drawstr, "%s%.2f", but->str, value);
1583                                 else if(but->a2==3) sprintf(but->drawstr, "%s%.3f", but->str, value);
1584                                 else sprintf(but->drawstr, "%s%.4f", but->str, value);
1585                         }
1586                         else {
1587                                 sprintf(but->drawstr, "%s%.2f", but->str, value);
1588                         }
1589                 }
1590                 else strcpy(but->drawstr, but->str);
1591                 
1592                 break;
1593
1594         case IDPOIN:
1595                 id= *(but->idpoin_idpp);
1596                 strcpy(but->drawstr, but->str);
1597                 if(id) strcat(but->drawstr, id->name+2);
1598                 break;
1599         
1600         case TEX:
1601                 if(!but->editstr) {
1602                         char str[UI_MAX_DRAW_STR];
1603
1604                         ui_get_but_string(but, str, UI_MAX_DRAW_STR-strlen(but->str));
1605
1606                         strcpy(but->drawstr, but->str);
1607                         strcat(but->drawstr, str);
1608                 }
1609                 break;
1610         
1611         case KEYEVT:
1612                 strcpy(but->drawstr, but->str);
1613                 if (but->flag & UI_SELECT) {
1614                         strcat(but->drawstr, "Press a key");
1615                 } else {
1616                         strcat(but->drawstr, WM_key_event_string((short) ui_get_but_val(but)));
1617                 }
1618                 break;
1619
1620         case BUT_TOGDUAL:
1621                 /* trying to get the dual-icon to left of text... not very nice */
1622                 if(but->str[0]) {
1623                         strcpy(but->drawstr, "  ");
1624                         strcpy(but->drawstr+2, but->str);
1625                 }
1626                 break;
1627         default:
1628                 strcpy(but->drawstr, but->str);
1629                 
1630         }
1631
1632         /* if we are doing text editing, this will override the drawstr */
1633         if(but->editstr) {
1634                 strcpy(but->drawstr, but->str);
1635                 strcat(but->drawstr, but->editstr);
1636         }
1637
1638         if(but->drawstr[0]) {
1639                 but->strwidth= but->aspect*UI_GetStringWidth(but->font, but->drawstr, transopts);
1640                 // here should be check for less space for icon offsets...
1641                 if(but->type==MENU) okwidth -= 15;
1642         }
1643         else
1644                 but->strwidth= 0;
1645
1646                 /* automatic width */
1647         if(but->x2==0.0f && but->x1 > 0.0f) {
1648                 but->x2= (but->x1+but->strwidth+6); 
1649         }
1650
1651         if(but->strwidth==0) but->drawstr[0]= 0;
1652         else if(but->type==BUTM || but->type==BLOCK);   // no clip string, uiTextBoundsBlock is used (hack!)
1653         else {
1654
1655                 /* calc but->ofs, to draw the string shorter if too long */
1656                 but->ofs= 0;
1657
1658                 while(but->strwidth > (int)okwidth ) {
1659         
1660                         if ELEM3(but->type, NUM, NUMABS, TEX) { // only these cut off left
1661                                 but->ofs++;
1662                                 but->strwidth= but->aspect*UI_GetStringWidth(but->font, but->drawstr+but->ofs, transopts);
1663                                 
1664                                 /* textbut exception */
1665                                 if(but->editstr && but->pos != -1) {
1666                                         pos= but->pos+strlen(but->str);
1667                                         if(pos-1 < but->ofs) {
1668                                                 pos= but->ofs-pos+1;
1669                                                 but->ofs -= pos;
1670                                                 if(but->ofs<0) {
1671                                                         but->ofs= 0;
1672                                                         pos--;
1673                                                 }
1674                                                 but->drawstr[ strlen(but->drawstr)-pos ]= 0;
1675                                         }
1676                                 }
1677                         }
1678                         else {
1679                                 but->drawstr[ strlen(but->drawstr)-1 ]= 0;
1680                                 but->strwidth= but->aspect*UI_GetStringWidth(but->font, but->drawstr, transopts);
1681                         }
1682                         
1683                         if(but->strwidth < 10) break;
1684                 }
1685         }
1686 }
1687
1688 static int ui_auto_themecol(uiBut *but)
1689 {
1690
1691         switch(but->type) {
1692         case BUT:
1693                 return TH_BUT_ACTION;
1694         case ROW:
1695         case TOG:
1696         case TOG3:
1697         case TOGR:
1698         case TOGN:
1699         case BUT_TOGDUAL:
1700                 return TH_BUT_SETTING;
1701         case SLI:
1702         case NUM:
1703         case NUMSLI:
1704         case NUMABS:
1705         case HSVSLI:
1706                 return TH_BUT_NUM;
1707         case TEX:
1708                 return TH_BUT_TEXTFIELD;
1709         case PULLDOWN:
1710         case BLOCK:
1711         case MENU:
1712         case BUTM:
1713                 // (weak!) detect if it is a blockloop
1714                 if(but->block->dt == UI_EMBOSSP) return TH_MENU_ITEM;
1715                 return TH_BUT_POPUP;
1716         case ROUNDBOX:
1717                 return TH_PANEL;
1718         default:
1719                 return TH_BUT_NEUTRAL;
1720         }
1721 }
1722
1723 void uiBlockBeginAlign(uiBlock *block)
1724 {
1725         /* if other align was active, end it */
1726         if(block->flag & UI_BUT_ALIGN) uiBlockEndAlign(block);
1727
1728         block->flag |= UI_BUT_ALIGN_DOWN;       
1729         /* buttons declared after this call will this align flag */
1730 }
1731
1732 static int buts_are_horiz(uiBut *but1, uiBut *but2)
1733 {
1734         float dx, dy;
1735         
1736         dx= fabs( but1->x2 - but2->x1);
1737         dy= fabs( but1->y1 - but2->y2);
1738         
1739         if(dx > dy) return 0;
1740         return 1;
1741 }
1742
1743 void uiBlockEndAlign(uiBlock *block)
1744 {
1745         uiBut *prev, *but=NULL, *next;
1746         int flag= 0, cols=0, rows=0;
1747         int theme= UI_GetThemeValue(TH_BUT_DRAWTYPE);
1748         
1749         if ( !(ELEM4(theme, TH_MINIMAL, TH_SHADED, TH_ROUNDED, TH_ROUNDSHADED)) ) {
1750                 block->flag &= ~UI_BUT_ALIGN;   // all 4 flags
1751                 return;
1752         }
1753         
1754         /* auto align:
1755                 - go back to first button of align start (ALIGN_DOWN)
1756                 - compare triples, and define flags
1757         */
1758         prev= block->buttons.last;
1759         while(prev) {
1760                 if( (prev->flag & UI_BUT_ALIGN_DOWN)) but= prev;
1761                 else break;
1762                 
1763                 if(but && but->next) {
1764                         if(buts_are_horiz(but, but->next)) cols++;
1765                         else rows++;
1766                 }
1767                 
1768                 prev= prev->prev;
1769         }
1770         if(but==NULL) return;
1771         
1772         /* rows==0: 1 row, cols==0: 1 collumn */
1773         
1774         /* note;  how it uses 'flag' in loop below (either set it, or OR it) is confusing */
1775         prev= NULL;
1776         while(but) {
1777                 next= but->next;
1778                 
1779                 /* clear old flag */
1780                 but->flag &= ~UI_BUT_ALIGN_DOWN;
1781                 
1782                 if(flag==0) {   /* first case */
1783                         if(next) {
1784                                 if(buts_are_horiz(but, next)) {
1785                                         if(rows==0)
1786                                                 flag= UI_BUT_ALIGN_RIGHT;
1787                                         else 
1788                                                 flag= UI_BUT_ALIGN_DOWN|UI_BUT_ALIGN_RIGHT;
1789                                 }
1790                                 else {
1791                                         flag= UI_BUT_ALIGN_DOWN;
1792                                 }
1793                         }
1794                 }
1795                 else if(next==NULL) {   /* last case */
1796                         if(prev) {
1797                                 if(buts_are_horiz(prev, but)) {
1798                                         if(rows==0) 
1799                                                 flag= UI_BUT_ALIGN_LEFT;
1800                                         else
1801                                                 flag= UI_BUT_ALIGN_TOP|UI_BUT_ALIGN_LEFT;
1802                                 }
1803                                 else flag= UI_BUT_ALIGN_TOP;
1804                         }
1805                 }
1806                 else if(buts_are_horiz(but, next)) {
1807                         /* check if this is already second row */
1808                         if( prev && buts_are_horiz(prev, but)==0) {
1809                                 flag |= UI_BUT_ALIGN_TOP;
1810                                 /* exception case: bottom row */
1811                                 if(rows>0) {
1812                                         uiBut *bt= but;
1813                                         while(bt) {
1814                                                 if(bt->next && buts_are_horiz(bt, bt->next)==0 ) break; 
1815                                                 bt= bt->next;
1816                                         }
1817                                         if(bt==0) flag= UI_BUT_ALIGN_TOP|UI_BUT_ALIGN_RIGHT;
1818                                 }
1819                         }
1820                         else flag |= UI_BUT_ALIGN_LEFT;
1821                 }
1822                 else {
1823                         if(cols==0) {
1824                                 flag |= UI_BUT_ALIGN_TOP;
1825                         }
1826                         else {  /* next button switches to new row */
1827                                 if( (flag & UI_BUT_ALIGN_TOP)==0) {     /* stil top row */
1828                                         if(prev)
1829                                                 flag= UI_BUT_ALIGN_DOWN|UI_BUT_ALIGN_LEFT;
1830                                         else 
1831                                                 flag |= UI_BUT_ALIGN_DOWN;
1832                                 }
1833                                 else 
1834                                         flag |= UI_BUT_ALIGN_TOP;
1835                         }
1836                 }
1837                 
1838                 but->flag |= flag;
1839                 
1840                 /* merge coordinates */
1841                 if(prev) {
1842                         // simple cases 
1843                         if(rows==0) {
1844                                 but->x1= (prev->x2+but->x1)/2.0;
1845                                 prev->x2= but->x1;
1846                         }
1847                         else if(cols==0) {
1848                                 but->y2= (prev->y1+but->y2)/2.0;
1849                                 prev->y1= but->y2;
1850                         }
1851                         else {
1852                                 if(buts_are_horiz(prev, but)) {
1853                                         but->x1= (prev->x2+but->x1)/2.0;
1854                                         prev->x2= but->x1;
1855                                         /* copy height too */
1856                                         but->y2= prev->y2;
1857                                 }
1858                                 else if(prev->prev && buts_are_horiz(prev->prev, prev)==0) {
1859                                         /* the previous button is a single one in its row */
1860                                         but->y2= (prev->y1+but->y2)/2.0;
1861                                         prev->y1= but->y2;
1862                                 }
1863                                 else {
1864                                         /* the previous button is not a single one in its row */
1865                                         but->y2= prev->y1;
1866                                 }
1867                         }
1868                 }
1869                 
1870                 prev= but;
1871                 but= next;
1872         }
1873         
1874         block->flag &= ~UI_BUT_ALIGN;   // all 4 flags
1875 }
1876
1877 #if 0
1878 static void uiBlockEndAligno(uiBlock *block)
1879 {
1880         uiBut *but;
1881         
1882         /* correct last defined button */
1883         but= block->buttons.last;
1884         if(but) {
1885                 /* vertical align case */
1886                 if( (block->flag & UI_BUT_ALIGN) == (UI_BUT_ALIGN_TOP|UI_BUT_ALIGN_DOWN) ) {
1887                         but->flag &= ~UI_BUT_ALIGN_DOWN;
1888                 }
1889                 /* horizontal align case */
1890                 if( (block->flag & UI_BUT_ALIGN) == (UI_BUT_ALIGN_LEFT|UI_BUT_ALIGN_RIGHT) ) {
1891                         but->flag &= ~UI_BUT_ALIGN_RIGHT;
1892                 }
1893                 /* else do nothing, manually provided flags */
1894         }
1895         block->flag &= ~UI_BUT_ALIGN;   // all 4 flags
1896 }
1897 #endif
1898
1899 /*
1900 ui_def_but is the function that draws many button types
1901
1902 for float buttons:
1903         "a1" Click Step (how much to change the value each click)
1904         "a2" Number of decimal point values to display. 0 defaults to 3 (0.000) 1,2,3, and a maximum of 4,
1905        all greater values will be clamped to 4.
1906
1907 */
1908 static uiBut *ui_def_but(uiBlock *block, int type, int retval, char *str, short x1, short y1, short x2, short y2, void *poin, float min, float max, float a1, float a2,  char *tip)
1909 {
1910         uiBut *but;
1911         short slen;
1912         
1913         if(type & BUTPOIN) {            /* a pointer is required */
1914                 if(poin==NULL) {
1915                         /* if pointer is zero, button is removed and not drawn */
1916                         UI_ThemeColor(block->themecol);
1917                         glRects(x1,  y1,  x1+x2,  y1+y2);
1918                         return NULL;
1919                 }
1920         }
1921
1922         but= MEM_callocN(sizeof(uiBut), "uiBut");
1923
1924         but->type= type & BUTTYPE;
1925         but->pointype= type & BUTPOIN;
1926         but->bit= type & BIT;
1927         but->bitnr= type & 31;
1928         but->icon = 0;
1929
1930         BLI_addtail(&block->buttons, but);
1931
1932         but->retval= retval;
1933         if( strlen(str)>=UI_MAX_NAME_STR-1 ) {
1934                 but->str= MEM_callocN( strlen(str)+2, "uiDefBut");
1935                 strcpy(but->str, str);
1936         }
1937         else {
1938                 but->str= but->strdata;
1939                 strcpy(but->str, str);
1940         }
1941         but->x1= x1; 
1942         but->y1= y1;
1943         if(block->autofill) {
1944                 but->x2= x2; 
1945                 but->y2= y2;
1946         }
1947         else {
1948                 but->x2= (x1+x2); 
1949                 but->y2= (y1+y2);
1950         }
1951         but->poin= poin;
1952         but->min= min; 
1953         but->max= max;
1954         but->a1= a1; 
1955         but->a2= a2;
1956         but->tip= tip;
1957         
1958         but->font= block->curfont;
1959         
1960         but->lock= block->lock;
1961         but->lockstr= block->lockstr;
1962
1963         but->aspect= block->aspect;
1964         but->win= block->win;
1965         but->block= block;              // pointer back, used for frontbuffer status, and picker
1966
1967         if(block->themecol==TH_AUTO) but->themecol= ui_auto_themecol(but);
1968         else but->themecol= block->themecol;
1969
1970         if(but->type != BUTM) {
1971                 but->func= block->func;
1972                 but->func_arg1= block->func_arg1;
1973                 but->func_arg2= block->func_arg2;
1974         }
1975         
1976         ui_set_embossfunc(but, block->dt);
1977         
1978         but->pos= -1;   /* cursor invisible */
1979
1980         if(ELEM(but->type, NUM, NUMABS)) {      /* add a space to name */
1981                 slen= strlen(but->str);
1982                 if(slen>0 && slen<UI_MAX_NAME_STR-2) {
1983                         if(but->str[slen-1]!=' ') {
1984                                 but->str[slen]= ' ';
1985                                 but->str[slen+1]= 0;
1986                         }
1987                 }
1988         }
1989         
1990         if(but->type==HSVCUBE) { /* hsv buttons temp storage */
1991                 float rgb[3];
1992                 ui_get_but_vectorf(but, rgb);
1993                 rgb_to_hsv(rgb[0], rgb[1], rgb[2], but->hsv, but->hsv+1, but->hsv+2);
1994         }
1995
1996         if ELEM8(but->type, HSVSLI , NUMSLI, MENU, TEX, LABEL, IDPOIN, BLOCK, BUTM) {
1997                 but->flag |= UI_TEXT_LEFT;
1998         }
1999         
2000         if(but->type==BUT_TOGDUAL) {
2001                 but->flag |= UI_ICON_LEFT;
2002         }
2003
2004         if(but->type==ROUNDBOX)
2005                 but->flag |= UI_NO_HILITE;
2006
2007         but->flag |= (block->flag & UI_BUT_ALIGN);
2008         if(block->flag & UI_BLOCK_NO_HILITE)
2009                 but->flag |= UI_NO_HILITE;
2010
2011         return but;
2012 }
2013
2014 uiBut *ui_def_but_rna(uiBlock *block, int type, int retval, char *str, short x1, short y1, short x2, short y2, PointerRNA *ptr, const char *propname, int index, float min, float max, float a1, float a2,  char *tip)
2015 {
2016         uiBut *but;
2017         PropertyRNA *prop;
2018         PropertyType proptype;
2019         int freestr= 0;
2020
2021         prop= RNA_struct_find_property(ptr, propname);
2022         if(!prop)
2023                 return NULL;
2024
2025         proptype= RNA_property_type(ptr, prop);
2026
2027         /* use rna values if parameters are not specified */
2028         if(!str) {
2029                 if(type == MENU && proptype == PROP_ENUM) {
2030                         const EnumPropertyItem *item;
2031                         DynStr *dynstr;
2032                         int i, totitem;
2033
2034                         RNA_property_enum_items(ptr, prop, &item, &totitem);
2035
2036                         dynstr= BLI_dynstr_new();
2037                         BLI_dynstr_appendf(dynstr, "%s%%t", RNA_property_ui_name(ptr, prop));
2038                         for(i=0; i<totitem; i++)
2039                                 BLI_dynstr_appendf(dynstr, "|%s %%x%d", item[i].name, item[i].value);
2040                         str= BLI_dynstr_get_cstring(dynstr);
2041                         BLI_dynstr_free(dynstr);
2042
2043                         freestr= 1;
2044                 }
2045                 else
2046                         str= (char*)RNA_property_ui_name(ptr, prop);
2047         }
2048
2049         if(!tip)
2050                 tip= (char*)RNA_property_ui_description(ptr, prop);
2051
2052         if(min == max || a1 == -1 || a2 == -1) {
2053                 if(proptype == PROP_INT) {
2054                         int softmin, softmax, step;
2055
2056                         RNA_property_int_ui_range(ptr, prop, &softmin, &softmax, &step);
2057
2058                         if(min == max) {
2059                                 min= softmin;
2060                                 max= softmax;
2061                         }
2062                         if(a1 == -1)
2063                                 a1= step;
2064                         if(a2 == -1)
2065                                 a2= 0;
2066                 }
2067                 else if(proptype == PROP_FLOAT) {
2068                         float softmin, softmax, step, precision;
2069
2070                         RNA_property_float_ui_range(ptr, prop, &softmin, &softmax, &step, &precision);
2071
2072                         if(min == max) {
2073                                 min= softmin;
2074                                 max= softmax;
2075                         }
2076                         if(a1 == -1)
2077                                 a1= step;
2078                         if(a2 == -1)
2079                                 a2= precision;
2080                 }
2081                 else if(proptype == PROP_STRING) {
2082                         min= 0;
2083                         max= RNA_property_string_maxlength(ptr, prop);
2084                         if(max == 0) /* interface code should ideally support unlimited length */
2085                                 max= UI_MAX_DRAW_STR; 
2086                 }
2087         }
2088
2089         /* now create button */
2090         but= ui_def_but(block, type, retval, str, x1, y1, x2, y2, NULL, min, max, a1, a2, tip);
2091         but->rnapoin= *ptr;
2092         but->rnaprop= prop;
2093         but->rnaindex= index;
2094
2095         if(freestr)
2096                 MEM_freeN(str);
2097         
2098         return but;
2099 }
2100
2101 uiBut *ui_def_but_operator(bContext *C, uiBlock *block, int type, char *opname, int opcontext, char *str, short x1, short y1, short x2, short y2, char *tip)
2102 {
2103         uiBut *but;
2104         char buf[100], *butstr;
2105
2106         if(!str) {
2107                 wmOperatorType *ot= WM_operatortype_find(opname);
2108                 str= (ot)? ot->name: "";
2109         }
2110
2111         butstr= str;
2112
2113         if(type == BUTM) {
2114                 if(WM_key_event_operator_string(C, opname, opcontext, buf, sizeof(buf))) {
2115                         butstr= MEM_mallocN(strlen(str)+strlen(buf)+2, "ui_def_but_operator");
2116                         strcpy(butstr, str);
2117                         strcat(butstr, "|");
2118                         strcat(butstr, buf);
2119                 }
2120         }
2121
2122         but= ui_def_but(block, type, -1, butstr, x1, y1, x2, y2, NULL, 0, 0, 0, 0, tip);
2123         but->opname= opname;
2124         but->opcontext= opcontext;
2125
2126         if(butstr != str)
2127                 MEM_freeN(butstr);
2128
2129         return but;
2130 }
2131
2132 uiBut *uiDefBut(uiBlock *block, int type, int retval, char *str, short x1, short y1, short x2, short y2, void *poin, float min, float max, float a1, float a2,  char *tip)
2133 {
2134         uiBut *but= ui_def_but(block, type, retval, str, x1, y1, x2, y2, poin, min, max, a1, a2, tip);
2135
2136         ui_check_but(but);
2137         
2138         return but;
2139 }
2140
2141         /* if _x_ is a power of two (only one bit) return the power,
2142          * otherwise return -1. 
2143          * (1<<findBitIndex(x))==x for powers of two.
2144          */
2145 static int findBitIndex(unsigned int x) {
2146         if (!x || (x&(x-1))!=0) {       /* x&(x-1) strips lowest bit */
2147                 return -1;
2148         } else {
2149                 int idx= 0;
2150
2151                 if (x&0xFFFF0000)       idx+=16, x>>=16;
2152                 if (x&0xFF00)           idx+=8, x>>=8;
2153                 if (x&0xF0)                     idx+=4, x>>=4;
2154                 if (x&0xC)                      idx+=2, x>>=2;
2155                 if (x&0x2)                      idx+=1;
2156
2157                 return idx;
2158         }
2159 }
2160
2161 /* autocomplete helper functions */
2162 struct AutoComplete {
2163         int maxlen;
2164         char *truncate;
2165         char *startname;
2166 };
2167
2168 AutoComplete *autocomplete_begin(char *startname, int maxlen)
2169 {
2170         AutoComplete *autocpl;
2171         
2172         autocpl= MEM_callocN(sizeof(AutoComplete), "AutoComplete");
2173         autocpl->maxlen= maxlen;
2174         autocpl->truncate= MEM_callocN(sizeof(char)*maxlen, "AutoCompleteTruncate");
2175         autocpl->startname= startname;
2176
2177         return autocpl;
2178 }
2179
2180 void autocomplete_do_name(AutoComplete *autocpl, const char *name)
2181 {
2182         char *truncate= autocpl->truncate;
2183         char *startname= autocpl->startname;
2184         int a;
2185
2186         for(a=0; a<autocpl->maxlen-1; a++) {
2187                 if(startname[a]==0 || startname[a]!=name[a])
2188                         break;
2189         }
2190         /* found a match */
2191         if(startname[a]==0) {
2192                 /* first match */
2193                 if(truncate[0]==0)
2194                         BLI_strncpy(truncate, name, autocpl->maxlen);
2195                 else {
2196                         /* remove from truncate what is not in bone->name */
2197                         for(a=0; a<autocpl->maxlen-1; a++) {
2198                                 if(truncate[a]!=name[a])
2199                                         truncate[a]= 0;
2200                         }
2201                 }
2202         }
2203 }
2204
2205 void autocomplete_end(AutoComplete *autocpl, char *autoname)
2206 {
2207         if(autocpl->truncate[0])
2208                 BLI_strncpy(autoname, autocpl->truncate, autocpl->maxlen);
2209         else
2210                 BLI_strncpy(autoname, autocpl->startname, autocpl->maxlen);
2211
2212         MEM_freeN(autocpl->truncate);
2213         MEM_freeN(autocpl);
2214 }
2215
2216 /* autocomplete callback for ID buttons */
2217 static void autocomplete_id(bContext *C, char *str, void *arg_v)
2218 {
2219         int blocktype= (intptr_t)arg_v;
2220         ListBase *listb= wich_libbase(CTX_data_main(C), blocktype);
2221         
2222         if(listb==NULL) return;
2223         
2224         /* search if str matches the beginning of an ID struct */
2225         if(str[0]) {
2226                 AutoComplete *autocpl= autocomplete_begin(str, 22);
2227                 ID *id;
2228                 
2229                 for(id= listb->first; id; id= id->next)
2230                         autocomplete_do_name(autocpl, id->name+2);
2231
2232                 autocomplete_end(autocpl, str);
2233         }
2234 }
2235
2236 static uiBut *uiDefButBit(uiBlock *block, int type, int bit, int retval, char *str, short x1, short y1, short x2, short y2, void *poin, float min, float max, float a1, float a2,  char *tip)
2237 {
2238         int bitIdx= findBitIndex(bit);
2239         if (bitIdx==-1) {
2240                 return NULL;
2241         } else {
2242                 return uiDefBut(block, type|BIT|bitIdx, retval, str, x1, y1, x2, y2, poin, min, max, a1, a2, tip);
2243         }
2244 }
2245 uiBut *uiDefButF(uiBlock *block, int type, int retval, char *str, short x1, short y1, short x2, short y2, float *poin, float min, float max, float a1, float a2,  char *tip)
2246 {
2247         return uiDefBut(block, type|FLO, retval, str, x1, y1, x2, y2, (void*) poin, min, max, a1, a2, tip);
2248 }
2249 uiBut *uiDefButBitF(uiBlock *block, int type, int bit, int retval, char *str, short x1, short y1, short x2, short y2, float *poin, float min, float max, float a1, float a2,  char *tip)
2250 {
2251         return uiDefButBit(block, type|FLO, bit, retval, str, x1, y1, x2, y2, (void*) poin, min, max, a1, a2, tip);
2252 }
2253 uiBut *uiDefButI(uiBlock *block, int type, int retval, char *str, short x1, short y1, short x2, short y2, int *poin, float min, float max, float a1, float a2,  char *tip)
2254 {
2255         return uiDefBut(block, type|INT, retval, str, x1, y1, x2, y2, (void*) poin, min, max, a1, a2, tip);
2256 }
2257 uiBut *uiDefButBitI(uiBlock *block, int type, int bit, int retval, char *str, short x1, short y1, short x2, short y2, int *poin, float min, float max, float a1, float a2,  char *tip)
2258 {
2259         return uiDefButBit(block, type|INT, bit, retval, str, x1, y1, x2, y2, (void*) poin, min, max, a1, a2, tip);
2260 }
2261 uiBut *uiDefButS(uiBlock *block, int type, int retval, char *str, short x1, short y1, short x2, short y2, short *poin, float min, float max, float a1, float a2,  char *tip)
2262 {
2263         return uiDefBut(block, type|SHO, retval, str, x1, y1, x2, y2, (void*) poin, min, max, a1, a2, tip);
2264 }
2265 uiBut *uiDefButBitS(uiBlock *block, int type, int bit, int retval, char *str, short x1, short y1, short x2, short y2, short *poin, float min, float max, float a1, float a2,  char *tip)
2266 {
2267         return uiDefButBit(block, type|SHO, bit, retval, str, x1, y1, x2, y2, (void*) poin, min, max, a1, a2, tip);
2268 }
2269 uiBut *uiDefButC(uiBlock *block, int type, int retval, char *str, short x1, short y1, short x2, short y2, char *poin, float min, float max, float a1, float a2,  char *tip)
2270 {
2271         return uiDefBut(block, type|CHA, retval, str, x1, y1, x2, y2, (void*) poin, min, max, a1, a2, tip);
2272 }
2273 uiBut *uiDefButBitC(uiBlock *block, int type, int bit, int retval, char *str, short x1, short y1, short x2, short y2, char *poin, float min, float max, float a1, float a2,  char *tip)
2274 {
2275         return uiDefButBit(block, type|CHA, bit, retval, str, x1, y1, x2, y2, (void*) poin, min, max, a1, a2, tip);
2276 }
2277 uiBut *uiDefButR(uiBlock *block, int type, int retval, char *str, short x1, short y1, short x2, short y2, PointerRNA *ptr, const char *propname, int index, float min, float max, float a1, float a2,  char *tip)
2278 {
2279         uiBut *but;
2280
2281         but= ui_def_but_rna(block, type, retval, str, x1, y1, x2, y2, ptr, propname, index, min, max, a1, a2, tip);
2282         if(but)
2283                 ui_check_but(but);
2284
2285         return but;
2286 }
2287 uiBut *uiDefButO(bContext *C, uiBlock *block, int type, char *opname, int opcontext, char *str, short x1, short y1, short x2, short y2, char *tip)
2288 {
2289         uiBut *but;
2290
2291         but= ui_def_but_operator(C, block, type, opname, opcontext, str, x1, y1, x2, y2, tip);
2292         if(but)
2293                 ui_check_but(but);
2294
2295         return but;
2296 }
2297
2298 uiBut *uiDefIconBut(uiBlock *block, int type, int retval, int icon, short x1, short y1, short x2, short y2, void *poin, float min, float max, float a1, float a2,  char *tip)
2299 {
2300         uiBut *but= ui_def_but(block, type, retval, "", x1, y1, x2, y2, poin, min, max, a1, a2, tip);
2301         
2302         but->icon= (BIFIconID) icon;
2303         but->flag|= UI_HAS_ICON;
2304
2305         ui_check_but(but);
2306         
2307         return but;
2308 }
2309 static uiBut *uiDefIconButBit(uiBlock *block, int type, int bit, int retval, int icon, short x1, short y1, short x2, short y2, void *poin, float min, float max, float a1, float a2,  char *tip)
2310 {
2311         int bitIdx= findBitIndex(bit);
2312         if (bitIdx==-1) {
2313                 return NULL;
2314         } else {
2315                 return uiDefIconBut(block, type|BIT|bitIdx, retval, icon, x1, y1, x2, y2, poin, min, max, a1, a2, tip);
2316         }
2317 }
2318
2319 uiBut *uiDefIconButF(uiBlock *block, int type, int retval, int icon, short x1, short y1, short x2, short y2, float *poin, float min, float max, float a1, float a2,  char *tip)
2320 {
2321         return uiDefIconBut(block, type|FLO, retval, icon, x1, y1, x2, y2, (void*) poin, min, max, a1, a2, tip);
2322 }
2323 uiBut *uiDefIconButBitF(uiBlock *block, int type, int bit, int retval, int icon, short x1, short y1, short x2, short y2, float *poin, float min, float max, float a1, float a2,  char *tip)
2324 {
2325         return uiDefIconButBit(block, type|FLO, bit, retval, icon, x1, y1, x2, y2, (void*) poin, min, max, a1, a2, tip);
2326 }
2327 uiBut *uiDefIconButI(uiBlock *block, int type, int retval, int icon, short x1, short y1, short x2, short y2, int *poin, float min, float max, float a1, float a2,  char *tip)
2328 {
2329         return uiDefIconBut(block, type|INT, retval, icon, x1, y1, x2, y2, (void*) poin, min, max, a1, a2, tip);
2330 }
2331 uiBut *uiDefIconButBitI(uiBlock *block, int type, int bit, int retval, int icon, short x1, short y1, short x2, short y2, int *poin, float min, float max, float a1, float a2,  char *tip)
2332 {
2333         return uiDefIconButBit(block, type|INT, bit, retval, icon, x1, y1, x2, y2, (void*) poin, min, max, a1, a2, tip);
2334 }
2335 uiBut *uiDefIconButS(uiBlock *block, int type, int retval, int icon, short x1, short y1, short x2, short y2, short *poin, float min, float max, float a1, float a2,  char *tip)
2336 {
2337         return uiDefIconBut(block, type|SHO, retval, icon, x1, y1, x2, y2, (void*) poin, min, max, a1, a2, tip);
2338 }
2339 uiBut *uiDefIconButBitS(uiBlock *block, int type, int bit, int retval, int icon, short x1, short y1, short x2, short y2, short *poin, float min, float max, float a1, float a2,  char *tip)
2340 {
2341         return uiDefIconButBit(block, type|SHO, bit, retval, icon, x1, y1, x2, y2, (void*) poin, min, max, a1, a2, tip);
2342 }
2343 uiBut *uiDefIconButC(uiBlock *block, int type, int retval, int icon, short x1, short y1, short x2, short y2, char *poin, float min, float max, float a1, float a2,  char *tip)
2344 {
2345         return uiDefIconBut(block, type|CHA, retval, icon, x1, y1, x2, y2, (void*) poin, min, max, a1, a2, tip);
2346 }
2347 uiBut *uiDefIconButBitC(uiBlock *block, int type, int bit, int retval, int icon, short x1, short y1, short x2, short y2, char *poin, float min, float max, float a1, float a2,  char *tip)
2348 {
2349         return uiDefIconButBit(block, type|CHA, bit, retval, icon, x1, y1, x2, y2, (void*) poin, min, max, a1, a2, tip);
2350 }
2351 uiBut *uiDefIconButR(uiBlock *block, int type, int retval, int icon, short x1, short y1, short x2, short y2, PointerRNA *ptr, const char *propname, int index, float min, float max, float a1, float a2,  char *tip)
2352 {
2353         uiBut *but;
2354
2355         but= ui_def_but_rna(block, type, retval, "", x1, y1, x2, y2, ptr, propname, index, min, max, a1, a2, tip);
2356         if(but) {
2357                 but->icon= (BIFIconID) icon;
2358                 but->flag|= UI_HAS_ICON;
2359                 ui_check_but(but);
2360         }
2361
2362         return but;
2363 }
2364 uiBut *uiDefIconButO(bContext *C, uiBlock *block, int type, char *opname, int opcontext, int icon, short x1, short y1, short x2, short y2, char *tip)
2365 {
2366         uiBut *but;
2367
2368         but= ui_def_but_operator(C, block, type, opname, opcontext, "", x1, y1, x2, y2, tip);
2369         if(but) {
2370                 but->icon= (BIFIconID) icon;
2371                 but->flag|= UI_HAS_ICON;
2372                 ui_check_but(but);
2373         }
2374
2375         return but;
2376 }
2377
2378 /* Button containing both string label and icon */
2379 uiBut *uiDefIconTextBut(uiBlock *block, int type, int retval, int icon, char *str, short x1, short y1, short x2, short y2, void *poin, float min, float max, float a1, float a2,  char *tip)
2380 {
2381         uiBut *but= ui_def_but(block, type, retval, str, x1, y1, x2, y2, poin, min, max, a1, a2, tip);
2382
2383         but->icon= (BIFIconID) icon;
2384         but->flag|= UI_HAS_ICON;
2385
2386         but->flag|= UI_ICON_LEFT;
2387
2388         ui_check_but(but);
2389
2390         return but;
2391 }
2392 static uiBut *uiDefIconTextButBit(uiBlock *block, int type, int bit, int retval, int icon, char *str, short x1, short y1, short x2, short y2, void *poin, float min, float max, float a1, float a2,  char *tip)
2393 {
2394         int bitIdx= findBitIndex(bit);
2395         if (bitIdx==-1) {
2396                 return NULL;
2397         } else {
2398                 return uiDefIconTextBut(block, type|BIT|bitIdx, retval, icon, str, x1, y1, x2, y2, poin, min, max, a1, a2, tip);
2399         }
2400 }
2401
2402 uiBut *uiDefIconTextButF(uiBlock *block, int type, int retval, int icon, char *str, short x1, short y1, short x2, short y2, float *poin, float min, float max, float a1, float a2,  char *tip)
2403 {
2404         return uiDefIconTextBut(block, type|FLO, retval, icon, str, x1, y1, x2, y2, (void*) poin, min, max, a1, a2, tip);
2405 }
2406 uiBut *uiDefIconTextButBitF(uiBlock *block, int type, int bit, int retval, int icon, char *str, short x1, short y1, short x2, short y2, float *poin, float min, float max, float a1, float a2,  char *tip)
2407 {
2408         return uiDefIconTextButBit(block, type|FLO, bit, retval, icon, str, x1, y1, x2, y2, (void*) poin, min, max, a1, a2, tip);
2409 }
2410 uiBut *uiDefIconTextButI(uiBlock *block, int type, int retval, int icon, char *str, short x1, short y1, short x2, short y2, int *poin, float min, float max, float a1, float a2,  char *tip)
2411 {
2412         return uiDefIconTextBut(block, type|INT, retval, icon, str, x1, y1, x2, y2, (void*) poin, min, max, a1, a2, tip);
2413 }
2414 uiBut *uiDefIconTextButBitI(uiBlock *block, int type, int bit, int retval, int icon, char *str, short x1, short y1, short x2, short y2, int *poin, float min, float max, float a1, float a2,  char *tip)
2415 {
2416         return uiDefIconTextButBit(block, type|INT, bit, retval, icon, str, x1, y1, x2, y2, (void*) poin, min, max, a1, a2, tip);
2417 }
2418 uiBut *uiDefIconTextButS(uiBlock *block, int type, int retval, int icon, char *str, short x1, short y1, short x2, short y2, short *poin, float min, float max, float a1, float a2,  char *tip)
2419 {
2420         return uiDefIconTextBut(block, type|SHO, retval, icon, str, x1, y1, x2, y2, (void*) poin, min, max, a1, a2, tip);
2421 }
2422 uiBut *uiDefIconTextButBitS(uiBlock *block, int type, int bit, int retval, int icon, char *str, short x1, short y1, short x2, short y2, short *poin, float min, float max, float a1, float a2,  char *tip)
2423 {
2424         return uiDefIconTextButBit(block, type|SHO, bit, retval, icon, str, x1, y1, x2, y2, (void*) poin, min, max, a1, a2, tip);
2425 }
2426 uiBut *uiDefIconTextButC(uiBlock *block, int type, int retval, int icon, char *str, short x1, short y1, short x2, short y2, char *poin, float min, float max, float a1, float a2,  char *tip)
2427 {
2428         return uiDefIconTextBut(block, type|CHA, retval, icon, str, x1, y1, x2, y2, (void*) poin, min, max, a1, a2, tip);
2429 }
2430 uiBut *uiDefIconTextButBitC(uiBlock *block, int type, int bit, int retval, int icon, char *str, short x1, short y1, short x2, short y2, char *poin, float min, float max, float a1, float a2,  char *tip)
2431 {
2432         return uiDefIconTextButBit(block, type|CHA, bit, retval, icon, str, x1, y1, x2, y2, (void*) poin, min, max, a1, a2, tip);
2433 }
2434 uiBut *uiDefIconTextButR(uiBlock *block, int type, int retval, int icon, char *str, short x1, short y1, short x2, short y2, PointerRNA *ptr, const char *propname, int index, float min, float max, float a1, float a2,  char *tip)
2435 {
2436         uiBut *but;
2437
2438         but= ui_def_but_rna(block, type, retval, str, x1, y1, x2, y2, ptr, propname, index, min, max, a1, a2, tip);
2439         if(but) {
2440                 but->icon= (BIFIconID) icon;
2441                 but->flag|= UI_HAS_ICON;
2442                 but->flag|= UI_ICON_LEFT;
2443                 ui_check_but(but);
2444         }
2445
2446         return but;
2447 }
2448 uiBut *uiDefIconTextButO(bContext *C, uiBlock *block, int type, char *opname, int opcontext, int icon, char *str, short x1, short y1, short x2, short y2, char *tip)
2449 {
2450         uiBut *but;
2451
2452         but= ui_def_but_operator(C, block, type, opname, opcontext, str, x1, y1, x2, y2, tip);
2453         if(but) {
2454                 but->icon= (BIFIconID) icon;
2455                 but->flag|= UI_HAS_ICON;
2456                 but->flag|= UI_ICON_LEFT;
2457                 ui_check_but(but);
2458         }
2459
2460         return but;
2461 }
2462
2463 /* END Button containing both string label and icon */
2464
2465 void uiAutoBlock(uiBlock *block, float minx, float miny, float sizex, float sizey, int flag)
2466 {
2467         block->minx= minx;
2468         block->maxx= minx+sizex;
2469         block->miny= miny;
2470         block->maxy= miny+sizey;
2471         
2472         block->autofill= flag;  /* also check for if it has to be done */
2473
2474 }
2475
2476 void uiSetButLink(uiBut *but, void **poin, void ***ppoin, short *tot, int from, int to)
2477 {
2478         uiLink *link;
2479         
2480         link= but->link= MEM_callocN(sizeof(uiLink), "new uilink");
2481         
2482         link->poin= poin;
2483         link->ppoin= ppoin;
2484         link->totlink= tot;
2485         link->fromcode= from;
2486         link->tocode= to;
2487 }
2488
2489 /* cruft to make uiBlock and uiBut private */
2490
2491 int uiBlocksGetYMin(ListBase *lb)
2492 {
2493         uiBlock *block;
2494         int min= 0;
2495         
2496         for (block= lb->first; block; block= block->next)
2497                 if (block==lb->first || block->miny<min)
2498                         min= block->miny;
2499                         
2500         return min;
2501 }
2502
2503 int uiBlockGetCol(uiBlock *block)
2504 {
2505         return block->themecol;
2506 }
2507 void uiBlockSetCol(uiBlock *block, int col)
2508 {
2509         block->themecol= col;
2510 }
2511 void uiBlockSetEmboss(uiBlock *block, int emboss)
2512 {
2513         block->dt= emboss;
2514 }
2515 void uiBlockSetDirection(uiBlock *block, int direction)
2516 {
2517         block->direction= direction;
2518 }
2519
2520 /* this call escapes if there's alignment flags */
2521 void uiBlockFlipOrder(uiBlock *block)
2522 {
2523         ListBase lb;
2524         uiBut *but, *next;
2525         float centy, miny=10000, maxy= -10000;
2526
2527 //      if(U.uiflag & USER_PLAINMENUS)
2528 //              return;
2529         
2530         for(but= block->buttons.first; but; but= but->next) {
2531                 if(but->flag & UI_BUT_ALIGN) return;
2532                 if(but->y1 < miny) miny= but->y1;
2533                 if(but->y2 > maxy) maxy= but->y2;
2534         }
2535         /* mirror trick */
2536         centy= (miny+maxy)/2.0;
2537         for(but= block->buttons.first; but; but= but->next) {
2538                 but->y1 = centy-(but->y1-centy);
2539                 but->y2 = centy-(but->y2-centy);
2540                 SWAP(float, but->y1, but->y2);
2541         }
2542         
2543         /* also flip order in block itself, for example for arrowkey */
2544         lb.first= lb.last= NULL;
2545         but= block->buttons.first;
2546         while(but) {
2547                 next= but->next;
2548                 BLI_remlink(&block->buttons, but);
2549                 BLI_addtail(&lb, but);
2550                 but= next;
2551         }
2552         block->buttons= lb;
2553 }
2554
2555
2556 void uiBlockSetFlag(uiBlock *block, int flag)
2557 {
2558         block->flag= flag;
2559 }
2560 void uiBlockSetXOfs(uiBlock *block, int xofs)
2561 {
2562         block->xofs= xofs;
2563 }
2564 void* uiBlockGetCurFont(uiBlock *block)
2565 {
2566         return block->curfont;
2567 }
2568
2569 void uiButSetFlag(uiBut *but, int flag)
2570 {
2571         but->flag|= flag;
2572 }
2573 void uiButClearFlag(uiBut *but, int flag)
2574 {
2575         but->flag&= ~flag;
2576 }
2577
2578 int uiButGetRetVal(uiBut *but)
2579 {
2580         return but->retval;
2581 }
2582
2583 PointerRNA *uiButGetOperatorPtrRNA(uiBut *but)
2584 {
2585         wmOperatorType *ot;
2586         
2587         if(but->opname && !but->opptr) {
2588                 ot= WM_operatortype_find(but->opname);
2589
2590                 if(ot) {
2591                         but->opptr= MEM_callocN(sizeof(PointerRNA), "uiButOpPtr");
2592                         RNA_pointer_create(NULL, NULL, ot->srna, &but->opproperties, but->opptr);
2593                 }
2594         }
2595
2596         return but->opptr;
2597 }
2598
2599 void uiBlockSetHandleFunc(uiBlock *block, void (*func)(struct bContext *C, void *arg, int event), void *arg)
2600 {
2601         block->handle_func= func;
2602         block->handle_func_arg= arg;
2603 }
2604
2605 void uiBlockSetButmFunc(uiBlock *block, void (*func)(struct bContext *C, void *arg, int but_a2), void *arg)
2606 {
2607         block->butm_func= func;
2608         block->butm_func_arg= arg;
2609 }
2610
2611 void uiBlockSetFunc(uiBlock *block, void (*func)(struct bContext *C, void *arg1, void *arg2), void *arg1, void *arg2)
2612 {
2613         block->func= func;
2614         block->func_arg1= arg1;
2615         block->func_arg2= arg2;
2616 }
2617
2618 void uiBlockSetDrawExtraFunc(uiBlock *block, void (*func)())
2619 {
2620         block->drawextra= func;
2621 }
2622
2623 void uiButSetFunc(uiBut *but, void (*func)(struct bContext *C, void *arg1, void *arg2), void *arg1, void *arg2)
2624 {
2625         but->func= func;
2626         but->func_arg1= arg1;
2627         but->func_arg2= arg2;
2628 }
2629
2630 void uiButSetCompleteFunc(uiBut *but, void (*func)(struct bContext *C, char *str, void *arg), void *arg)
2631 {
2632         but->autocomplete_func= func;
2633         but->autofunc_arg= arg;
2634 }
2635
2636 uiBut *uiDefIDPoinBut(uiBlock *block, uiIDPoinFuncFP func, short blocktype, int retval, char *str, short x1, short y1, short x2, short y2, void *idpp, char *tip)
2637 {
2638         uiBut *but= ui_def_but(block, IDPOIN, retval, str, x1, y1, x2, y2, NULL, 0.0, 0.0, 0.0, 0.0, tip);
2639         but->idpoin_func= func;
2640         but->idpoin_idpp= (ID**) idpp;
2641         ui_check_but(but);
2642         
2643         if(blocktype)
2644                 uiButSetCompleteFunc(but, autocomplete_id, (void *)(intptr_t)blocktype);
2645
2646         return but;
2647 }
2648
2649 uiBut *uiDefBlockBut(uiBlock *block, uiBlockFuncFP func, void *arg, char *str, short x1, short y1, short x2, short y2, char *tip)
2650 {
2651         uiBut *but= ui_def_but(block, BLOCK, 0, str, x1, y1, x2, y2, arg, 0.0, 0.0, 0.0, 0.0, tip);
2652         but->block_func= func;
2653         ui_check_but(but);
2654         return but;
2655 }
2656
2657 uiBut *uiDefPulldownBut(uiBlock *block, uiBlockFuncFP func, void *arg, char *str, short x1, short y1, short x2, short y2, char *tip)
2658 {
2659         uiBut *but= ui_def_but(block, PULLDOWN, 0, str, x1, y1, x2, y2, arg, 0.0, 0.0, 0.0, 0.0, tip);
2660         but->block_func= func;
2661         ui_check_but(but);
2662         return but;
2663 }
2664
2665 /* Block button containing both string label and icon */
2666 uiBut *uiDefIconTextBlockBut(uiBlock *block, uiBlockFuncFP func, void *arg, int icon, char *str, short x1, short y1, short x2, short y2, char *tip)
2667 {
2668         uiBut *but= ui_def_but(block, BLOCK, 0, str, x1, y1, x2, y2, arg, 0.0, 0.0, 0.0, 0.0, tip);
2669         
2670         but->icon= (BIFIconID) icon;
2671         but->flag|= UI_HAS_ICON;
2672
2673         but->flag|= UI_ICON_LEFT;
2674         but->flag|= UI_ICON_RIGHT;
2675
2676         but->block_func= func;
2677         ui_check_but(but);
2678         
2679         return but;
2680 }
2681
2682 /* Block button containing icon */
2683 uiBut *uiDefIconBlockBut(uiBlock *block, uiBlockFuncFP func, void *arg, int retval, int icon, short x1, short y1, short x2, short y2, char *tip)
2684 {
2685         uiBut *but= ui_def_but(block, BLOCK, retval, "", x1, y1, x2, y2, arg, 0.0, 0.0, 0.0, 0.0, tip);
2686         
2687         but->icon= (BIFIconID) icon;
2688         but->flag|= UI_HAS_ICON;
2689         
2690         but->flag|= UI_ICON_LEFT;
2691         but->flag|= UI_ICON_RIGHT;
2692         
2693         but->block_func= func;
2694         ui_check_but(but);
2695         
2696         return but;
2697 }
2698
2699 void uiDefKeyevtButS(uiBlock *block, int retval, char *str, short x1, short y1, short x2, short y2, short *spoin, char *tip)
2700 {
2701         uiBut *but= ui_def_but(block, KEYEVT|SHO, retval, str, x1, y1, x2, y2, spoin, 0.0, 0.0, 0.0, 0.0, tip);
2702         ui_check_but(but);
2703 }
2704
2705 /* Program Init/Exit */
2706
2707 void UI_init(void)
2708 {
2709         uiDefFont(UI_HELVB,
2710                                 BMF_GetFont(BMF_kHelveticaBold14),
2711                                 BMF_GetFont(BMF_kHelveticaBold12),
2712                                 BMF_GetFont(BMF_kHelveticaBold10),
2713                                 BMF_GetFont(BMF_kHelveticaBold8));
2714         uiDefFont(UI_HELV,
2715                                 BMF_GetFont(BMF_kHelvetica12),
2716                                 BMF_GetFont(BMF_kHelvetica12),
2717                                 BMF_GetFont(BMF_kHelvetica10),
2718                                 BMF_GetFont(BMF_kHelveticaBold8));
2719
2720         ui_resources_init();
2721 }
2722
2723 void UI_init_userdef()
2724 {
2725         ui_text_init_userdef();
2726         ui_theme_init_userdef();
2727 }
2728
2729 void UI_exit(void)
2730 {
2731         ui_resources_free();
2732 }
2733