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