- Added button align code:
[blender.git] / source / blender / src / interface_draw.c
1 /**
2  * $Id$
3  *
4  * ***** BEGIN GPL/BL DUAL 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. The Blender
10  * Foundation also sells licenses for use in proprietary software under
11  * the Blender License.  See http://www.blender.org/BL/ for information
12  * about this.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software Foundation,
21  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
22  *
23  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
24  * All rights reserved.
25  *
26  * The Original Code is: all of this file.
27  *
28  * Contributor(s): none yet.
29  *
30  * ***** END GPL/BL DUAL LICENSE BLOCK *****
31  */
32
33 /* 
34      a full doc with API notes can be found in bf-blender/blender/doc/interface_API.txt
35
36  */
37  
38
39 #include <math.h>
40 #include <stdlib.h>
41 #include <string.h>
42 #include <ctype.h>
43
44 #ifdef HAVE_CONFIG_H
45 #include <config.h>
46 #endif
47
48 #ifndef WIN32
49 #include <unistd.h>
50 #else
51 #include <io.h>
52 #include "BLI_winstuff.h"
53 #endif   
54
55 #include "MEM_guardedalloc.h"
56
57 #include "PIL_time.h"
58
59 #include "BLI_blenlib.h"
60 #include "BLI_arithb.h"
61
62 #include "DNA_screen_types.h"
63 #include "DNA_space_types.h"
64 #include "DNA_userdef_types.h"
65 #include "DNA_vec_types.h"
66
67 #include "BKE_blender.h"
68 #include "BKE_utildefines.h"
69 #include "BKE_global.h"
70
71 #include "BIF_gl.h"
72 #include "BIF_graphics.h"
73 #include "BIF_keyval.h"
74 #include "BIF_mainqueue.h"
75
76 #include "BIF_screen.h"
77 #include "BIF_toolbox.h"
78 #include "BIF_mywindow.h"
79 #include "BIF_space.h"
80 #include "BIF_glutil.h"
81 #include "BIF_interface.h"
82 #include "BIF_butspace.h"
83 #include "BIF_language.h"
84
85 #include "BSE_view.h"
86
87 #include "mydevice.h"
88 #include "interface.h"
89 #include "blendef.h"
90
91 // globals
92 extern float UIwinmat[4][4];
93
94
95
96 /* ************** generic embossed rect, for window sliders etc ************* */
97
98 void uiEmboss(float x1, float y1, float x2, float y2, int sel)
99 {
100         
101         /* below */
102         if(sel) glColor3ub(200,200,200);
103         else glColor3ub(50,50,50);
104         fdrawline(x1, y1, x2, y1);
105
106         /* right */
107         fdrawline(x2, y1, x2, y2);
108         
109         /* top */
110         if(sel) glColor3ub(50,50,50);
111         else glColor3ub(200,200,200);
112         fdrawline(x1, y2, x2, y2);
113
114         /* left */
115         fdrawline(x1, y1, x1, y2);
116         
117 }
118
119 /* ************** GENERIC ICON DRAW, NO THEME HERE ************* */
120
121 static void ui_draw_icon(uiBut *but, BIFIconID icon)
122 {
123         int blend= 0;
124         float xs=0, ys=0;
125
126         if(but->flag & UI_ICON_LEFT) {
127                 if (but->type==BUTM) {
128                         xs= but->x1+1.0;
129                 }
130                 else if ((but->type==ICONROW) || (but->type==ICONTEXTROW)) {
131                         xs= but->x1+4.0;
132                 }
133                 else {
134                         xs= but->x1+6.0;
135                 }
136                 ys= (but->y1+but->y2- BIF_get_icon_height(icon))/2.0;
137         }
138         if(but->flag & UI_ICON_RIGHT) {
139                 xs= but->x2-17.0;
140                 ys= (but->y1+but->y2- BIF_get_icon_height(icon))/2.0;
141         }
142         if (!((but->flag & UI_ICON_RIGHT) || (but->flag & UI_ICON_LEFT))) {
143                 xs= (but->x1+but->x2- BIF_get_icon_width(icon))/2.0;
144                 ys= (but->y1+but->y2- BIF_get_icon_height(icon))/2.0;
145         }
146
147         glRasterPos2f(xs, ys);
148
149         if(but->aspect>1.1) glPixelZoom(1.0/but->aspect, 1.0/but->aspect);
150
151         glEnable(GL_BLEND);
152         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
153
154         /* calculate blend color */
155         if ELEM4(but->type, ICONTOG, TOG, ROW, TOGN) {
156                 if(but->flag & UI_SELECT);
157                 else if(but->flag & UI_ACTIVE);
158                 else blend= -60;
159         }
160         BIF_draw_icon_blended(icon, but->themecol, blend);
161         
162 /* old blending method... hrums */
163 /*      if(but->flag & UI_SELECT) {
164                 if(but->flag & UI_ACTIVE) {
165                         BIF_draw_icon_blended(icon, but->themecol, -80);
166                 } else {
167                         BIF_draw_icon_blended(icon, but->themecol, -45);
168                 }
169         }
170         else {
171                 if ((but->flag & UI_ACTIVE) && but->type==BUTM) {
172                         BIF_draw_icon_blended(icon, but->themecol, 0);
173                 } else if (but->flag & UI_ACTIVE) {
174                         BIF_draw_icon_blended(icon, but->themecol, 25);
175                 } else {
176                         BIF_draw_icon_blended(icon, but->themecol, 45);
177                 }
178         }
179 */
180         glBlendFunc(GL_ONE, GL_ZERO);
181         glDisable(GL_BLEND);
182
183         glPixelZoom(1.0, 1.0);
184 }
185
186 /* ************** DEFAULT THEME, SHADED BUTTONS ************* */
187
188
189 #define M_WHITE         BIF_ThemeColorShade(bc, 80)
190
191 #define M_ACT_LIGHT     BIF_ThemeColorShade(bc, 55)
192 #define M_LIGHT         BIF_ThemeColorShade(bc, 45)
193 #define M_HILITE        BIF_ThemeColorShade(bc, 25)
194 #define M_LMEDIUM       BIF_ThemeColorShade(bc, 10)
195 #define M_MEDIUM        BIF_ThemeColor(bc)
196 #define M_LGREY         BIF_ThemeColorShade(bc, -20)
197 #define M_GREY          BIF_ThemeColorShade(bc, -45)
198 #define M_DARK          BIF_ThemeColorShade(bc, -80)
199
200 #define M_NUMTEXT                                                       BIF_ThemeColorShade(bc, 25)
201 #define M_NUMTEXT_ACT_LIGHT             BIF_ThemeColorShade(bc, 35)
202
203 #define MM_WHITE        BIF_ThemeColorShade(TH_BUT_NEUTRAL, 120)
204 #define MM_WHITE_OP     BIF_ThemeColorShadeAlpha(TH_BACK, 65, -100)
205 #define MM_WHITE_TR     BIF_ThemeColorShadeAlpha(TH_BACK, 65, -255)
206 #define MM_LIGHT        BIF_ThemeColorShade(TH_BUT_NEUTRAL, 45)
207 #define MM_MEDIUM       BIF_ThemeColor(TH_BUT_NEUTRAL)
208 #define MM_GREY         BIF_ThemeColorShade(TH_BUT_NEUTRAL, -45)
209 #define MM_DARK         BIF_ThemeColorShade(TH_BUT_NEUTRAL, -80)
210
211
212 static void ui_default_button(int bc, float asp, float x1, float y1, float x2, float y2, int flag)
213 {
214
215         float asp1;
216         
217         asp1= asp;
218
219         /*x1+= asp1;*/
220         x2-= asp1;      
221         /*y1+= asp1;*/
222         y2-= asp1;
223
224         /* SHADED BUTTON */
225         glShadeModel(GL_SMOOTH);
226         glBegin(GL_QUADS);
227         
228         if(flag & UI_SELECT) {
229                 if(flag & UI_ACTIVE) M_MEDIUM;
230                 else M_LGREY;
231         }
232         else {
233                 if(flag & UI_ACTIVE) M_LIGHT;
234                 else M_HILITE;
235         }
236
237         glVertex2f(x1,y1);
238         glVertex2f(x2,y1);
239
240         if(flag & UI_SELECT) {
241                 if(flag & UI_ACTIVE) M_LGREY;
242                 else M_GREY;
243         }
244         else {
245                 if(flag & UI_ACTIVE) M_ACT_LIGHT;
246                 else M_LIGHT;
247         }
248
249         glVertex2f(x2,(y2-(y2-y1)/3));
250         glVertex2f(x1,(y2-(y2-y1)/3));
251         glEnd();
252         
253
254         glShadeModel(GL_FLAT);
255         glBegin(GL_QUADS);
256         
257         if(flag & UI_SELECT) {
258                 if(flag & UI_ACTIVE) M_LGREY;
259                 else M_GREY;
260         }
261         else {
262                 if(flag & UI_ACTIVE) M_ACT_LIGHT;
263                 else M_LIGHT;
264         }
265         
266         glVertex2f(x1,(y2-(y2-y1)/3));
267         glVertex2f(x2,(y2-(y2-y1)/3));
268         glVertex2f(x2,y2);
269         glVertex2f(x1,y2);
270
271         glEnd();
272
273         /* END SHADED BUTTON */
274
275         /* OUTER SUNKEN EFFECT */
276         /* left */
277         
278         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
279         glEnable(GL_BLEND);
280
281         glShadeModel(GL_SMOOTH);
282         glBegin(GL_LINES);
283         MM_WHITE_OP;
284         glVertex2f(x1-1,y1);
285         MM_WHITE_TR;
286         glVertex2f(x1-1,y2);
287         glEnd();
288         
289         /* right */
290         glShadeModel(GL_SMOOTH);
291         glBegin(GL_LINES);
292         MM_WHITE_OP;
293         glVertex2f(x2+1,y1);
294         MM_WHITE_TR;
295         glVertex2f(x2+1,y2);
296         glEnd();
297
298         /* bottom */
299         MM_WHITE_OP;
300         fdrawline(x1, y1-1, x2, y1-1);
301         
302         glDisable(GL_BLEND);
303         /* END OUTER SUNKEN EFFECT */
304         
305         /* INNER OUTLINE */
306         glShadeModel(GL_FLAT);
307         
308         /* top */
309         if(flag & UI_SELECT) {
310                 if(flag & UI_ACTIVE) M_LGREY;
311                 else M_GREY;
312         }
313         else {
314                 if(flag & UI_ACTIVE) M_WHITE;
315                 else M_WHITE;
316         }
317
318         fdrawline(x1, (y2-1), x2, y2-1);
319         
320         /* bottom */
321         
322         if(flag & UI_SELECT) {
323                 if(flag & UI_ACTIVE) M_MEDIUM;
324                 else M_LGREY;
325         }
326         else {
327                 if(flag & UI_ACTIVE) M_LMEDIUM;
328                 else M_LMEDIUM;
329         }
330         fdrawline(x1, (y1+1), x2, y1+1);
331
332         /* left */
333         if(!(flag & UI_SELECT)) {
334                                         
335         glShadeModel(GL_SMOOTH);
336         glBegin(GL_LINES);
337         M_WHITE;
338         glVertex2f(x1+1,y1+2);
339         M_LGREY;
340         glVertex2f(x1+1,y2);
341         glEnd();
342         
343         }
344         
345         /* right */
346         if(!(flag & UI_SELECT)) {
347
348         glShadeModel(GL_SMOOTH);
349         glBegin(GL_LINES);
350         M_LGREY;
351         glVertex2f(x2-1,y1+2);
352         M_WHITE;
353         glVertex2f(x2-1,y2);
354         glEnd();
355         
356         }
357         /* END INNER OUTLINE */
358         
359         /* OUTER OUTLINE */
360         glShadeModel(GL_FLAT);
361         
362         /* underneath semi-fake-AA */
363         MM_GREY;
364         fdrawline(x1, y2, x2, y2);
365         MM_MEDIUM;
366         fdrawline(x1, y1, x2, y1);
367
368         /* top */
369         MM_DARK;
370         fdrawline(x1+1, y2, x2, y2);
371
372         /* left */
373         fdrawline(x1, y1+1, x1, y2);
374
375         /* right */
376         fdrawline(x2, y1+1, x2, y2);
377         
378         /* bottom */
379         MM_DARK;
380         fdrawline(x1+1, y1, x2, y1);
381         /* END OUTER OUTLINE */
382         
383 }
384
385 static void ui_default_text(int bc, float asp, float x1, float y1, float x2, float y2, int flag)
386 {
387
388         float asp1;
389         
390         asp1= asp;
391
392         /*x1+= asp1;*/
393         x2-= asp1;      
394         /*y1+= asp1;*/
395         y2-= asp1;
396
397         /* FLAT TEXT/NUM FIELD */
398         glShadeModel(GL_FLAT);
399         glBegin(GL_QUADS);
400
401         if(flag & UI_SELECT) {
402                 if(flag & UI_ACTIVE) M_LGREY;
403                 else M_GREY;
404         }
405         else {
406                 if(flag & UI_ACTIVE) M_NUMTEXT_ACT_LIGHT;
407                 else M_NUMTEXT;
408         }
409
410
411         glVertex2f(x1,y1);
412         glVertex2f(x2,y1);
413         glVertex2f(x2,y2);
414         glVertex2f(x1,y2);
415
416         glEnd();
417         /* END FLAT TEXT/NUM FIELD */
418         
419         /* OUTER SUNKEN EFFECT */
420         /* left */
421         
422         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
423         glEnable(GL_BLEND);
424
425         glShadeModel(GL_SMOOTH);
426         glBegin(GL_LINES);
427         MM_WHITE_OP;
428         glVertex2f(x1-1,y1);
429         MM_WHITE_TR;
430         glVertex2f(x1-1,y2);
431         glEnd();
432         
433         /* right */
434         glShadeModel(GL_SMOOTH);
435         glBegin(GL_LINES);
436         MM_WHITE_OP;
437         glVertex2f(x2+1,y1);
438         MM_WHITE_TR;
439         glVertex2f(x2+1,y2);
440         glEnd();
441
442         /* bottom */
443         MM_WHITE_OP;
444         fdrawline(x1, y1-1, x2, y1-1);
445         
446         glDisable(GL_BLEND);
447         /* END OUTER SUNKEN EFFECT */
448         
449
450         /* OUTER OUTLINE */
451         glShadeModel(GL_FLAT);
452         
453         /* underneath semi-fake-AA */
454         MM_GREY;
455         fdrawline(x1, y2, x2, y2);
456         MM_MEDIUM;
457         fdrawline(x1, y1, x2, y1);
458
459         /* top */
460         MM_DARK;
461         fdrawline(x1+1, y2, x2, y2);
462
463         /* left */
464         fdrawline(x1, y1+1, x1, y2);
465
466         /* right */
467         fdrawline(x2, y1+1, x2, y2);
468         
469         /* bottom */
470         MM_DARK;
471         fdrawline(x1+1, y1, x2, y1);
472         /* END OUTER OUTLINE */
473 }
474
475
476 static void ui_default_num_arrows(float x1, float y1, float x2, float y2)
477 {
478         glEnable( GL_POLYGON_SMOOTH );
479         glEnable( GL_BLEND );
480         glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
481         
482         glShadeModel(GL_FLAT);
483         glBegin(GL_TRIANGLES);
484         
485         glVertex2f((short)x1+5,(short)(y2-(y2-y1)/2));
486         glVertex2f((short)x1+10,(short)(y2-(y2-y1)/2)+4);
487         glVertex2f((short)x1+10,(short)(y2-(y2-y1)/2)-4);
488         glEnd();
489
490         /* right */
491         glShadeModel(GL_FLAT);
492         glBegin(GL_TRIANGLES);
493
494         glVertex2f((short)x2-5,(short)(y2-(y2-y1)/2));
495         glVertex2f((short)x2-10,(short)(y2-(y2-y1)/2)-4);
496         glVertex2f((short)x2-10,(short)(y2-(y2-y1)/2)+4);
497         glEnd();
498         
499         glDisable( GL_BLEND );
500         glDisable( GL_POLYGON_SMOOTH );
501
502 }
503
504 static void ui_default_num(int bc, float asp, float x1, float y1, float x2, float y2, int flag)
505 {
506
507         float asp1;
508
509         asp1= asp;
510
511         /*x1+= asp1;*/
512         x2-= asp1;      
513         /*y1+= asp1;*/
514         y2-= asp1;
515
516         /* FLAT TEXT/NUM FIELD */
517         glShadeModel(GL_FLAT);
518         glBegin(GL_QUADS);
519
520         if(flag & UI_SELECT) {
521                 if(flag & UI_ACTIVE) M_LGREY;
522                 else M_GREY;
523         }
524         else {
525                 if(flag & UI_ACTIVE) M_NUMTEXT_ACT_LIGHT;
526                 else M_NUMTEXT;
527         }
528
529         glVertex2f(x1,y1);
530         glVertex2f(x2,y1);
531         glVertex2f(x2,y2);
532         glVertex2f(x1,y2);
533
534         glEnd();
535         /* END FLAT TEXT/NUM FIELD */
536         
537         /* OUTER SUNKEN EFFECT */
538         /* left */
539         
540         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
541         glEnable(GL_BLEND);
542
543         glShadeModel(GL_SMOOTH);
544         glBegin(GL_LINES);
545         MM_WHITE_OP;
546         glVertex2f(x1-1,y1);
547         MM_WHITE_TR;
548         glVertex2f(x1-1,y2);
549         glEnd();
550         
551         /* right */
552         glShadeModel(GL_SMOOTH);
553         glBegin(GL_LINES);
554         MM_WHITE_OP;
555         glVertex2f(x2+1,y1);
556         MM_WHITE_TR;
557         glVertex2f(x2+1,y2);
558         glEnd();
559
560         /* bottom */
561         MM_WHITE_OP;
562         fdrawline(x1, y1-1, x2, y1-1);
563         
564         glDisable(GL_BLEND);
565         /* END OUTER SUNKEN EFFECT */
566         
567
568         /* OUTER OUTLINE */
569         glShadeModel(GL_FLAT);
570         
571         /* underneath semi-fake-AA */
572         MM_GREY;
573         fdrawline(x1, y2, x2, y2);
574         MM_MEDIUM;
575         fdrawline(x1, y1, x2, y1);
576
577         /* top */
578         MM_DARK;
579         fdrawline(x1+1, y2, x2, y2);
580
581         /* left */
582         fdrawline(x1, y1+1, x1, y2);
583
584         /* right */
585         fdrawline(x2, y1+1, x2, y2);
586         
587         /* bottom */
588         MM_DARK;
589         fdrawline(x1+1, y1, x2, y1);
590         /* END OUTER OUTLINE */
591
592         /* SIDE ARROWS */
593         /* left */
594         
595         if(flag & UI_SELECT) {
596                 if(flag & UI_ACTIVE) M_DARK;
597                 else M_DARK;
598         }
599         else {
600                 if(flag & UI_ACTIVE) M_GREY;
601                 else M_LGREY;
602         }
603         
604         ui_default_num_arrows(x1, y1, x2, y2);
605         /* END SIDE ARROWS */
606 }
607
608 static void ui_default_menu_arrows(float x1, float y1, float x2, float y2)
609 {
610         glEnable( GL_POLYGON_SMOOTH );
611         glEnable( GL_BLEND );
612         glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
613         
614         glShadeModel(GL_FLAT);
615         glBegin(GL_TRIANGLES);
616         glVertex2f((short)x2-4,(short)(y2-(y2-y1)/2)+1);
617         glVertex2f((short)x2-12,(short)(y2-(y2-y1)/2)+1);
618         glVertex2f((short)x2-8,(short)(y2-(y2-y1)/2)+4);
619         glEnd();
620                 
621         glBegin(GL_TRIANGLES);
622         glVertex2f((short)x2-4,(short)(y2-(y2-y1)/2) -1);
623         glVertex2f((short)x2-12,(short)(y2-(y2-y1)/2) -1);
624         glVertex2f((short)x2-8,(short)(y2-(y2-y1)/2) -4);
625         glEnd();
626         
627         glDisable( GL_BLEND );
628         glDisable( GL_POLYGON_SMOOTH );
629 }
630
631 static void ui_default_menu(int bc, float asp, float x1, float y1, float x2, float y2, int flag)
632 {
633
634         float asp1;
635         
636         asp1= asp;
637
638         /*x1+= asp1;*/
639         x2-= asp1;      
640         /*y1+= asp1;*/
641         y2-= asp1;
642
643         /* SHADED BUTTON */
644         glShadeModel(GL_SMOOTH);
645         glBegin(GL_QUADS);
646         
647
648         if(flag & UI_SELECT) {
649                 if(flag & UI_ACTIVE) M_LGREY;
650                 else M_GREY;
651         }
652         else {
653                 if(flag & UI_ACTIVE) M_LIGHT;
654                 else M_HILITE;
655         }
656
657         glVertex2f(x1,y1);
658         glVertex2f(x2,y1);
659
660         if(flag & UI_SELECT) {
661                 if(flag & UI_ACTIVE) M_GREY;
662                 else M_DARK;
663         }
664         else {
665                 if(flag & UI_ACTIVE) M_ACT_LIGHT;
666                 else M_LIGHT;
667         }
668
669         glVertex2f(x2,(y2-(y2-y1)/3));
670         glVertex2f(x1,(y2-(y2-y1)/3));
671         glEnd();
672         
673
674         glShadeModel(GL_FLAT);
675         glBegin(GL_QUADS);
676         
677         if(flag & UI_SELECT) {
678                 if(flag & UI_ACTIVE) M_GREY;
679                 else M_DARK;
680         }
681         else {
682                 if(flag & UI_ACTIVE) M_ACT_LIGHT;
683                 else M_LIGHT;
684         }
685
686         glVertex2f(x1,(y2-(y2-y1)/3));
687         glVertex2f(x2,(y2-(y2-y1)/3));
688         glVertex2f(x2,y2);
689         glVertex2f(x1,y2);
690
691         glEnd();
692         /* END SHADED BUTTON */
693
694         /* OUTER SUNKEN EFFECT */
695         /* left */
696         
697         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
698         glEnable(GL_BLEND);
699
700         glShadeModel(GL_SMOOTH);
701         glBegin(GL_LINES);
702         MM_WHITE_OP;
703         glVertex2f(x1-1,y1);
704         MM_WHITE_TR;
705         glVertex2f(x1-1,y2);
706         glEnd();
707         
708         /* right */
709         glShadeModel(GL_SMOOTH);
710         glBegin(GL_LINES);
711         MM_WHITE_OP;
712         glVertex2f(x2+1,y1);
713         MM_WHITE_TR;
714         glVertex2f(x2+1,y2);
715         glEnd();
716
717         /* bottom */
718         MM_WHITE_OP;
719         fdrawline(x1, y1-1, x2, y1-1);
720         
721         glDisable(GL_BLEND);
722         /* END OUTER SUNKEN EFFECT */
723         
724         
725         /* INNER OUTLINE */
726         glShadeModel(GL_FLAT);
727         
728         /* top */
729         if(flag & UI_SELECT) {
730                 if(flag & UI_ACTIVE) M_GREY;
731                 else M_GREY;
732         }
733         else {
734                 if(flag & UI_ACTIVE) M_WHITE;
735                 else M_WHITE;
736         }
737
738         fdrawline(x1, (y2-1), x2, y2-1);
739         
740         /* bottom */
741         
742         if(flag & UI_SELECT) {
743                 if(flag & UI_ACTIVE) M_LGREY;
744                 else M_LGREY;
745         }
746         else {
747                 if(flag & UI_ACTIVE) M_LMEDIUM;
748                 else M_LMEDIUM;
749         }
750         fdrawline(x1, (y1+1), x2, y1+1);
751
752         /* left */
753         if(!(flag & UI_SELECT)) {
754                                         
755         glShadeModel(GL_SMOOTH);
756         glBegin(GL_LINES);
757         M_WHITE;
758         glVertex2f(x1+1,y1+2);
759         M_LGREY;
760         glVertex2f(x1+1,y2);
761         glEnd();
762         
763         }
764         
765         /* right */
766         if(!(flag & UI_SELECT)) {
767
768         glShadeModel(GL_SMOOTH);
769         glBegin(GL_LINES);
770         M_LGREY;
771         glVertex2f(x2-1,y1+2);
772         M_WHITE;
773         glVertex2f(x2-1,y2);
774         glEnd();
775         
776         }
777         /* END INNER OUTLINE */
778         
779         /* OUTER OUTLINE */
780         glShadeModel(GL_FLAT);
781         
782         /* underneath semi-fake-AA */
783         MM_GREY;
784         fdrawline(x1, y2, x2, y2);
785         MM_MEDIUM;
786         fdrawline(x1, y1, x2, y1);
787
788         /* top */
789         MM_DARK;
790         fdrawline(x1+1, y2, x2, y2);
791
792         /* left */
793         fdrawline(x1, y1+1, x1, y2);
794
795         /* right */
796         fdrawline(x2, y1+1, x2, y2);
797         
798         /* bottom */
799         MM_DARK;
800         fdrawline(x1+1, y1, x2, y1);
801         /* END OUTER OUTLINE */
802
803         /* DARKENED AREA */
804         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
805         glEnable(GL_BLEND);
806         
807         glColor4ub(0, 0, 0, 30);
808         glRectf(x2-18, y1, x2, y2);
809
810         glDisable(GL_BLEND);
811         /* END DARKENED AREA */
812
813         /* MENU DOUBLE-ARROW  */
814         
815         /* set antialias line */
816         M_DARK;
817         ui_default_menu_arrows(x1, y1, x2, y2);
818         /* MENU DOUBLE-ARROW */
819
820 }
821
822 static void ui_default_iconrow_arrows(float x1, float y1, float x2, float y2)
823 {
824         glEnable( GL_POLYGON_SMOOTH );
825         glEnable( GL_BLEND );
826         glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
827         
828         glShadeModel(GL_FLAT);
829         glBegin(GL_TRIANGLES);
830         glVertex2f((short)x2-2,(short)(y2-(y2-y1)/2)+1);
831         glVertex2f((short)x2-6,(short)(y2-(y2-y1)/2)+1);
832         glVertex2f((short)x2-4,(short)(y2-(y2-y1)/2)+4);
833         glEnd();
834                 
835         glBegin(GL_TRIANGLES);
836         glVertex2f((short)x2-2,(short)(y2-(y2-y1)/2) -1);
837         glVertex2f((short)x2-6,(short)(y2-(y2-y1)/2) -1);
838         glVertex2f((short)x2-4,(short)(y2-(y2-y1)/2) -4);
839         glEnd();
840         
841         glDisable( GL_BLEND );
842         glDisable( GL_POLYGON_SMOOTH );
843 }
844
845 static void ui_default_iconrow(int bc, float asp, float x1, float y1, float x2, float y2, int flag)
846 {
847
848         float asp1;
849         
850         asp1= asp;
851
852         /*x1+= asp1;*/
853         x2-= asp1;      
854         /*y1+= asp1;*/
855         y2-= asp1;
856
857         /* SHADED BUTTON */
858         glShadeModel(GL_SMOOTH);
859         glBegin(GL_QUADS);
860         
861
862         if(flag & UI_SELECT) {
863                 if(flag & UI_ACTIVE) M_LGREY;
864                 else M_GREY;
865         }
866         else {
867                 if(flag & UI_ACTIVE) M_LIGHT;
868                 else M_HILITE;
869         }
870
871         glVertex2f(x1,y1);
872         glVertex2f(x2,y1);
873
874         if(flag & UI_SELECT) {
875                 if(flag & UI_ACTIVE) M_GREY;
876                 else M_DARK;
877         }
878         else {
879                 if(flag & UI_ACTIVE) M_ACT_LIGHT;
880                 else M_LIGHT;
881         }
882
883         glVertex2f(x2,(y2-(y2-y1)/3));
884         glVertex2f(x1,(y2-(y2-y1)/3));
885         glEnd();
886         
887
888         glShadeModel(GL_FLAT);
889         glBegin(GL_QUADS);
890         
891         if(flag & UI_SELECT) {
892                 if(flag & UI_ACTIVE) M_GREY;
893                 else M_DARK;
894         }
895         else {
896                 if(flag & UI_ACTIVE) M_ACT_LIGHT;
897                 else M_LIGHT;
898         }
899
900         glVertex2f(x1,(y2-(y2-y1)/3));
901         glVertex2f(x2,(y2-(y2-y1)/3));
902         glVertex2f(x2,y2);
903         glVertex2f(x1,y2);
904
905         glEnd();
906         /* END SHADED BUTTON */
907
908         /* OUTER SUNKEN EFFECT */
909         /* left */
910         
911         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
912         glEnable(GL_BLEND);
913
914         glShadeModel(GL_SMOOTH);
915         glBegin(GL_LINES);
916         MM_WHITE_OP;
917         glVertex2f(x1-1,y1);
918         MM_WHITE_TR;
919         glVertex2f(x1-1,y2);
920         glEnd();
921         
922         /* right */
923         glShadeModel(GL_SMOOTH);
924         glBegin(GL_LINES);
925         MM_WHITE_OP;
926         glVertex2f(x2+1,y1);
927         MM_WHITE_TR;
928         glVertex2f(x2+1,y2);
929         glEnd();
930
931         /* bottom */
932         MM_WHITE_OP;
933         fdrawline(x1, y1-1, x2, y1-1);
934         
935         glDisable(GL_BLEND);
936         /* END OUTER SUNKEN EFFECT */
937         
938         
939         /* INNER OUTLINE */
940         glShadeModel(GL_FLAT);
941         
942         /* top */
943         if(flag & UI_SELECT) {
944                 if(flag & UI_ACTIVE) M_GREY;
945                 else M_GREY;
946         }
947         else {
948                 if(flag & UI_ACTIVE) M_WHITE;
949                 else M_WHITE;
950         }
951
952         fdrawline(x1, (y2-1), x2, y2-1);
953         
954         /* bottom */
955         
956         if(flag & UI_SELECT) {
957                 if(flag & UI_ACTIVE) M_LGREY;
958                 else M_LGREY;
959         }
960         else {
961                 if(flag & UI_ACTIVE) M_LMEDIUM;
962                 else M_LMEDIUM;
963         }
964         fdrawline(x1, (y1+1), x2, y1+1);
965
966         /* left */
967         if(!(flag & UI_SELECT)) {
968                                         
969         glShadeModel(GL_SMOOTH);
970         glBegin(GL_LINES);
971         M_WHITE;
972         glVertex2f(x1+1,y1+2);
973         M_LGREY;
974         glVertex2f(x1+1,y2);
975         glEnd();
976         
977         }
978         
979         /* right */
980         if(!(flag & UI_SELECT)) {
981
982         glShadeModel(GL_SMOOTH);
983         glBegin(GL_LINES);
984         M_LGREY;
985         glVertex2f(x2-1,y1+2);
986         M_WHITE;
987         glVertex2f(x2-1,y2);
988         glEnd();
989         
990         }
991         /* END INNER OUTLINE */
992         
993         /* OUTER OUTLINE */
994         glShadeModel(GL_FLAT);
995         
996         /* underneath semi-fake-AA */
997         MM_GREY;
998         fdrawline(x1, y2, x2, y2);
999         MM_MEDIUM;
1000         fdrawline(x1, y1, x2, y1);
1001
1002         /* top */
1003         MM_DARK;
1004         fdrawline(x1+1, y2, x2, y2);
1005
1006         /* left */
1007         fdrawline(x1, y1+1, x1, y2);
1008
1009         /* right */
1010         fdrawline(x2, y1+1, x2, y2);
1011         
1012         /* bottom */
1013         MM_DARK;
1014         fdrawline(x1+1, y1, x2, y1);
1015         /* END OUTER OUTLINE */
1016
1017         /* DARKENED AREA */
1018         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1019         glEnable(GL_BLEND);
1020         
1021         glColor4ub(0, 0, 0, 30);
1022         glRectf(x2-9, y1, x2, y2);
1023
1024         glDisable(GL_BLEND);
1025         /* END DARKENED AREA */
1026
1027         /* MENU DOUBLE-ARROW  */
1028         
1029         M_DARK;
1030         ui_default_iconrow_arrows(x1, y1, x2, y2);
1031
1032         /* END MENU DOUBLE-ARROW */
1033
1034 }
1035
1036 static void ui_default_slider(int colorid, float fac, float aspect, float x1, float y1, float x2, float y2, int flag)
1037 {
1038         float ymid, yc;
1039
1040         /* the slider background line */
1041         ymid= (y1+y2)/2.0;
1042         yc= 1.7*aspect; // height of center line
1043
1044         glShadeModel(GL_SMOOTH);
1045         glBegin(GL_QUADS);
1046
1047         if(flag & UI_ACTIVE) 
1048                 BIF_ThemeColorShade(TH_BUT_NUM, +10); 
1049         else 
1050                 BIF_ThemeColor(TH_BUT_NUM); 
1051         
1052         
1053         glVertex2f(x1,   ymid-yc);
1054         glVertex2f(x2, ymid-yc);
1055
1056         if(flag & UI_ACTIVE) 
1057                 BIF_ThemeColorShade(TH_BUT_NUM, +45); 
1058         else 
1059                 BIF_ThemeColorShade(TH_BUT_NUM, +10); 
1060
1061         glVertex2f(x2, ymid+yc);
1062         glVertex2f(x1,   ymid+yc);
1063
1064         glEnd();
1065
1066         BIF_ThemeColorShade(TH_BUT_NUM, -80); 
1067         fdrawline(x1+1, ymid-yc, x2, ymid-yc);
1068         
1069         /* the movable slider */
1070         if(flag & UI_SELECT) BIF_ThemeColorShade(TH_BUT_NUM, +80); 
1071         else BIF_ThemeColorShade(TH_BUT_NUM, -45); 
1072
1073         glShadeModel(GL_SMOOTH);
1074         glBegin(GL_QUADS);
1075
1076         BIF_ThemeColorShade(TH_BUT_NUM, -45); 
1077
1078         glVertex2f(x1,     y1+2.5);
1079         glVertex2f(x1+fac, y1+2.5);
1080
1081         BIF_ThemeColor(TH_BUT_NUM); 
1082
1083         glVertex2f(x1+fac, y2-2.5);
1084         glVertex2f(x1,     y2-2.5);
1085
1086         glEnd();
1087         
1088
1089         /* slider handle center */
1090         glShadeModel(GL_SMOOTH);
1091         glBegin(GL_QUADS);
1092
1093         BIF_ThemeColor(TH_BUT_NUM); 
1094         glVertex2f(x1+fac-3, y1+2);
1095         glVertex2f(x1+fac, y1+4);
1096         BIF_ThemeColorShade(TH_BUT_NUM, +80); 
1097         glVertex2f(x1+fac, y2-2);
1098         glVertex2f(x1+fac-3, y2-2);
1099
1100         glEnd();
1101         
1102         /* slider handle left bevel */
1103         BIF_ThemeColorShade(TH_BUT_NUM, +80); 
1104         fdrawline(x1+fac-3, y2-2, x1+fac-3, y1+2);
1105         
1106         /* slider handle right bevel */
1107         BIF_ThemeColorShade(TH_BUT_NUM, -45); 
1108         fdrawline(x1+fac, y2-2, x1+fac, y1+2);
1109
1110         glShadeModel(GL_FLAT);
1111 }
1112
1113 /* default theme callback */
1114 static void ui_draw_default(int type, int colorid, float aspect, float x1, float y1, float x2, float y2, int flag)
1115 {
1116
1117         switch(type) {
1118         case NUM:
1119                 ui_default_num(colorid, aspect, x1, y1, x2, y2, flag);
1120                 break;
1121         case TEX: 
1122                 ui_default_text(colorid, aspect, x1, y1, x2, y2, flag);
1123                 break;
1124         case ICONROW: 
1125         case ICONTEXTROW: 
1126                 ui_default_iconrow(colorid, aspect, x1, y1, x2, y2, flag);
1127                 break;
1128         case MENU: 
1129                 ui_default_menu(colorid, aspect, x1, y1, x2, y2, flag);
1130                 break;
1131         default: 
1132                 ui_default_button(colorid, aspect, x1, y1, x2, y2, flag);
1133         }
1134
1135 }
1136
1137
1138 /* *************** OLDSKOOL THEME ***************** */
1139
1140 static void ui_draw_outlineX(float x1, float y1, float x2, float y2, float asp1)
1141 {
1142         float vec[2];
1143         
1144         glBegin(GL_LINE_LOOP);
1145         vec[0]= x1+asp1; vec[1]= y1-asp1;
1146         glVertex2fv(vec);
1147         vec[0]= x2-asp1; 
1148         glVertex2fv(vec);
1149         vec[0]= x2+asp1; vec[1]= y1+asp1;
1150         glVertex2fv(vec);
1151         vec[1]= y2-asp1;
1152         glVertex2fv(vec);
1153         vec[0]= x2-asp1; vec[1]= y2+asp1;
1154         glVertex2fv(vec);
1155         vec[0]= x1+asp1;
1156         glVertex2fv(vec);
1157         vec[0]= x1-asp1; vec[1]= y2-asp1;
1158         glVertex2fv(vec);
1159         vec[1]= y1+asp1;
1160         glVertex2fv(vec);
1161         glEnd();                
1162         
1163 }
1164
1165
1166 static void ui_draw_oldskool(int type, int colorid, float asp, float x1, float y1, float x2, float y2, int flag)
1167 {
1168         /* paper */
1169         if(flag & UI_SELECT) {
1170                 if(flag & UI_ACTIVE) BIF_ThemeColorShade(colorid, -40);
1171                 else BIF_ThemeColorShade(colorid, -30);
1172         }
1173         else {
1174                 if(flag & UI_ACTIVE) BIF_ThemeColorShade(colorid, +30);
1175                 else BIF_ThemeColorShade(colorid, +20);
1176         }
1177         
1178         glRectf(x1+1, y1+1, x2-1, y2-1);
1179
1180         x1+= asp;
1181         x2-= asp;
1182         y1+= asp;
1183         y2-= asp;
1184
1185         /* below */
1186         if(flag & UI_SELECT) BIF_ThemeColorShade(colorid, 0);
1187         else BIF_ThemeColorShade(colorid, -30);
1188         fdrawline(x1, y1, x2, y1);
1189
1190         /* right */
1191         fdrawline(x2, y1, x2, y2);
1192         
1193         /* top */
1194         if(flag & UI_SELECT) BIF_ThemeColorShade(colorid, -30);
1195         else BIF_ThemeColorShade(colorid, 0);
1196         fdrawline(x1, y2, x2, y2);
1197
1198         /* left */
1199         fdrawline(x1, y1, x1, y2);
1200         
1201         /* outline */
1202         glColor3ub(0,0,0);
1203         ui_draw_outlineX(x1, y1, x2, y2, asp);
1204         
1205         
1206         /* special type decorations */
1207         switch(type) {
1208         case NUM:
1209                 if(flag & UI_SELECT) BIF_ThemeColorShade(colorid, -60);
1210                 else BIF_ThemeColorShade(colorid, -30);
1211                 ui_default_num_arrows(x1, y1, x2, y2);
1212                 break;
1213
1214         case ICONROW: 
1215         case ICONTEXTROW: 
1216                 if(flag & UI_ACTIVE) BIF_ThemeColorShade(colorid, 0);
1217                 else BIF_ThemeColorShade(colorid, -10);
1218                 glRectf(x2-9, y1+asp, x2-asp, y2-asp);
1219
1220                 BIF_ThemeColorShade(colorid, -50);
1221                 ui_default_iconrow_arrows(x1, y1, x2, y2);
1222                 break;
1223                 
1224         case MENU: 
1225                 if(flag & UI_ACTIVE) BIF_ThemeColorShade(colorid, 0);
1226                 else BIF_ThemeColorShade(colorid, -10);
1227                 glRectf(x2-17, y1+asp, x2-asp, y2-asp);
1228
1229                 BIF_ThemeColorShade(colorid, -50);
1230                 ui_default_menu_arrows(x1, y1, x2, y2);
1231                 break;
1232         }
1233         
1234 }
1235
1236 /* *************** BASIC ROUNDED THEME ***************** */
1237
1238 static void round_button(float x1, float y1, float x2, float y2, float asp, int colorid)
1239 {
1240         float rad;
1241         
1242         rad= (y2-y1)/2.0;
1243         if(rad>7.0) rad= 7.0;
1244         
1245         glBegin(GL_POLYGON);
1246         gl_round_box(x1, y1, x2, y2, rad);
1247         glEnd();
1248         
1249         BIF_ThemeColorShade(colorid, -70);
1250         
1251         glBegin(GL_LINE_LOOP);
1252         gl_round_box(x1, y1, x2, y2, rad);
1253         glEnd();
1254    
1255         
1256 }
1257
1258 /* button in midst of alignment row */
1259 static void round_button_mid(float x1, float y1, float x2, float y2, float asp, int colorid, int align)
1260 {
1261         glRectf(x1, y1, x2, y2);
1262         
1263         BIF_ThemeColorShade(colorid, -70);
1264         // we draw full outline, its not AA, and it works better button mouse-over hilite
1265         
1266         // left right
1267         fdrawline(x1, y1, x1, y2);
1268         fdrawline(x2, y1, x2, y2);
1269
1270         // top down
1271         fdrawline(x1, y2, x2, y2);
1272         fdrawline(x1, y1, x2, y1);
1273            
1274 }
1275
1276
1277 static void ui_draw_round(int type, int colorid, float asp, float x1, float y1, float x2, float y2, int flag)
1278 {
1279         int align= (flag & UI_BUT_ALIGN);
1280         
1281         /* paper */
1282         if(flag & UI_SELECT) {
1283                 if(flag & UI_ACTIVE) BIF_ThemeColorShade(colorid, -40);
1284                 else BIF_ThemeColorShade(colorid, -30);
1285         }
1286         else {
1287                 if(flag & UI_ACTIVE) BIF_ThemeColorShade(colorid, +30);
1288                 else BIF_ThemeColorShade(colorid, +20);
1289         }
1290         
1291         if(align) {
1292                 if(align==UI_BUT_ALIGN_TOP) {
1293                         uiSetRoundBox(12);
1294                         round_button(x1, y1, x2, y2, asp, colorid);
1295                 }
1296                 else if(align==UI_BUT_ALIGN_DOWN) {
1297                         uiSetRoundBox(3);
1298                         round_button(x1, y1, x2, y2, asp, colorid);
1299                 }
1300                 else if(align==UI_BUT_ALIGN_LEFT) {
1301                         uiSetRoundBox(6);
1302                         round_button(x1, y1, x2, y2, asp, colorid);
1303                 }
1304                 else if(align==UI_BUT_ALIGN_RIGHT) {
1305                         uiSetRoundBox(9);
1306                         round_button(x1, y1, x2, y2, asp, colorid);
1307                 }
1308                 else {
1309                         round_button_mid(x1, y1, x2, y2, asp, colorid, align);
1310                 }
1311         } 
1312         else {
1313                 uiSetRoundBox(15);
1314                 round_button(x1, y1, x2, y2, asp, colorid);
1315         }
1316         
1317         /* special type decorations */
1318         switch(type) {
1319         case NUM:
1320                 if(flag & UI_SELECT) BIF_ThemeColorShade(colorid, -60);
1321                 else BIF_ThemeColorShade(colorid, -30);
1322                 ui_default_num_arrows(x1, y1, x2, y2);
1323                 break;
1324
1325         case ICONROW: 
1326         case ICONTEXTROW: 
1327                 if(flag & UI_ACTIVE) BIF_ThemeColorShade(colorid, 0);
1328                 else BIF_ThemeColorShade(colorid, -10);
1329                 // assuming its not inside alignment...
1330                 uiSetRoundBox(6);
1331                 glBegin(GL_POLYGON);
1332                 gl_round_box(x2-9, y1+asp, x2-asp, y2-asp, 7.0);
1333                 glEnd();
1334
1335                 BIF_ThemeColorShade(colorid, -60);
1336                 ui_default_iconrow_arrows(x1, y1, x2, y2);
1337                 break;
1338                 
1339         case MENU: 
1340                 if(flag & UI_ACTIVE) BIF_ThemeColorShade(colorid, 0);
1341                 else BIF_ThemeColorShade(colorid, -10);
1342                 // assuming its not inside alignment...
1343                 if(x2-x1 > 24) {
1344                         uiSetRoundBox(6);
1345                         glBegin(GL_POLYGON);
1346                         gl_round_box(x2-16, y1+asp, x2-asp, y2-asp, 7.0);
1347                         glEnd();
1348                 }
1349                 BIF_ThemeColorShade(colorid, -60);
1350                 ui_default_menu_arrows(x1, y1, x2, y2);
1351                 break;
1352         }
1353 }
1354
1355 /* *************** MINIMAL THEME ***************** */
1356
1357 // theme can define an embosfunc and sliderfunc, text+icon drawing is standard, no theme.
1358
1359
1360
1361 /* super minimal button as used in logic menu */
1362 static void ui_draw_minimal(int type, int colorid, float asp, float x1, float y1, float x2, float y2, int flag)
1363 {
1364         
1365         x1+= asp;
1366         x2-= asp;
1367         y1+= asp;
1368         y2-= asp;
1369
1370         /* paper */
1371         if(flag & UI_SELECT) {
1372                 if(flag & UI_ACTIVE) BIF_ThemeColorShade(colorid, -40);
1373                 else BIF_ThemeColorShade(colorid, -30);
1374         }
1375         else {
1376                 if(flag & UI_ACTIVE) BIF_ThemeColorShade(colorid, +20);
1377                 else BIF_ThemeColorShade(colorid, +10);
1378         }
1379         
1380         glRectf(x1, y1, x2, y2);
1381
1382         if(flag & UI_SELECT) {
1383                 BIF_ThemeColorShade(colorid, -60);
1384
1385                 /* top */
1386                 fdrawline(x1, y2, x2, y2);
1387                 /* left */
1388                 fdrawline(x1, y1, x1, y2);
1389                 BIF_ThemeColorShade(colorid, +40);
1390
1391                 /* below */
1392                 fdrawline(x1, y1, x2, y1);
1393                 /* right */
1394                 fdrawline(x2, y1, x2, y2);
1395         }
1396         else {
1397                 BIF_ThemeColorShade(colorid, +40);
1398
1399                 /* top */
1400                 fdrawline(x1, y2, x2, y2);
1401                 /* left */
1402                 fdrawline(x1, y1, x1, y2);
1403                 
1404                 BIF_ThemeColorShade(colorid, -60);
1405                 /* below */
1406                 fdrawline(x1, y1, x2, y1);
1407                 /* right */
1408                 fdrawline(x2, y1, x2, y2);
1409         }
1410         
1411         /* special type decorations */
1412         switch(type) {
1413         case NUM:
1414                 if(flag & UI_SELECT) BIF_ThemeColorShade(colorid, -60);
1415                 else BIF_ThemeColorShade(colorid, -30);
1416                 ui_default_num_arrows(x1, y1, x2, y2);
1417                 break;
1418
1419         case ICONROW: 
1420         case ICONTEXTROW: 
1421                 if(flag & UI_ACTIVE) BIF_ThemeColorShade(colorid, 0);
1422                 else BIF_ThemeColorShade(colorid, -10);
1423                 glRectf(x2-9, y1+asp, x2-asp, y2-asp);
1424
1425                 BIF_ThemeColorShade(colorid, -50);
1426                 ui_default_iconrow_arrows(x1, y1, x2, y2);
1427                 break;
1428                 
1429         case MENU: 
1430                 if(flag & UI_ACTIVE) BIF_ThemeColorShade(colorid, 0);
1431                 else BIF_ThemeColorShade(colorid, -10);
1432                 glRectf(x2-17, y1+asp, x2-asp, y2-asp);
1433
1434                 BIF_ThemeColorShade(colorid, -50);
1435                 ui_default_menu_arrows(x1, y1, x2, y2);
1436                 break;
1437         }
1438         
1439         
1440 }
1441
1442
1443 /* fac is the slider handle position between x1 and x2 */
1444 static void ui_draw_slider(int colorid, float fac, float aspect, float x1, float y1, float x2, float y2, int flag)
1445 {
1446         float ymid, yc;
1447
1448         /* the slider background line */
1449         ymid= (y1+y2)/2.0;
1450         yc= 1.7*aspect; 
1451
1452         if(flag & UI_ACTIVE) 
1453                 BIF_ThemeColorShade(colorid, -50); 
1454         else 
1455                 BIF_ThemeColorShade(colorid, -40); 
1456
1457         glRectf(x1, ymid-yc, x2, ymid+yc);
1458
1459
1460         /* the movable slider */
1461         if(flag & UI_ACTIVE) 
1462                 BIF_ThemeColorShade(colorid, +50); 
1463         else 
1464                 BIF_ThemeColorShade(colorid, +40); 
1465
1466         glRectf(x1+fac-aspect, ymid-yc, x1+fac+aspect, ymid+yc);
1467
1468 }
1469
1470 /* ************** STANDARD MENU DRAWING FUNCTION (no callback yet) ************* */
1471
1472
1473 // background for pulldowns, pullups, and other frontbuffer drawing temporal menus....
1474 // has to be made themable still (now only color)
1475
1476 void uiDrawMenuBox(float minx, float miny, float maxx, float maxy)
1477 {
1478         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1479         glEnable(GL_BLEND);
1480         
1481         glColor4ub(0, 0, 0, 20);
1482         
1483         /* to prevent gaps being drawn between box and shadow (rounding errors?) */
1484         fdrawline(minx+3, miny+0.25, maxx+0.25, miny+0.25);
1485         fdrawline(maxx+0.25, miny+0.25, maxx+0.25, maxy-3);
1486         
1487         glColor4ub(0, 0, 0, 70);
1488         fdrawline(minx+3, miny, maxx+1, miny);
1489         fdrawline(maxx+1, miny, maxx+1, maxy-3);
1490         
1491         glColor4ub(0, 0, 0, 70);
1492         fdrawline(minx+3, miny-1, maxx+1, miny-1);
1493         fdrawline(maxx+1, miny-1, maxx+1, maxy-3);
1494
1495         glColor4ub(0, 0, 0, 55);
1496         fdrawline(minx+3, miny-2, maxx+2, miny-2);
1497         fdrawline(maxx+2, miny-2, maxx+2, maxy-3);
1498
1499         glColor4ub(0, 0, 0, 35);
1500         fdrawline(minx+3, miny-3, maxx+3, miny-3);
1501         fdrawline(maxx+3, miny-3, maxx+3, maxy-3);
1502
1503         glColor4ub(0, 0, 0, 20);
1504         fdrawline(minx+3, miny-4, maxx+4, miny-4);
1505         fdrawline(maxx+4, miny-4, maxx+4, maxy-3);
1506         
1507         glDisable(GL_BLEND);
1508         
1509         BIF_ThemeColor(TH_MENU_BACK);
1510
1511         glRectf(minx, miny, maxx, maxy);
1512 }
1513
1514 /* pulldown menu */
1515 static void ui_draw_pulldown(int type, int colorid, float asp, float x1, float y1, float x2, float y2, int flag)
1516 {
1517
1518         if(flag & UI_ACTIVE) {
1519                 BIF_ThemeColor(TH_MENU_HILITE);
1520                 glRectf(x1-1, y1, x2+2, y2);
1521
1522         } else {
1523                 BIF_ThemeColor(colorid);        // is set at TH_MENU_ITEM when pulldown opened.
1524                 glRectf(x1-1, y1, x2+2, y2);
1525         }
1526
1527 }
1528
1529
1530
1531
1532 /* ************** TEXT AND ICON DRAWING FUNCTIONS ************* */
1533
1534
1535
1536 /* draws text and icons for buttons */
1537 static void ui_draw_text_icon(uiBut *but)
1538 {
1539         float x;
1540         int len;
1541         char *cpoin;
1542         
1543         /* check for button text label */
1544         if (but->type == ICONTEXTROW) {
1545                 ui_draw_icon(but, (BIFIconID) (but->icon+but->iconadd));
1546         }
1547         else if(but->drawstr[0]!=0) {
1548                 
1549                 // text button cursor
1550                 if(but->pos != -1) {
1551                         short t, pos, ch;
1552                         
1553                         pos= but->pos+strlen(but->str);
1554                         if(pos >= but->ofs) {
1555                                 ch= but->drawstr[pos];
1556                                 but->drawstr[pos]= 0;
1557         
1558                                 t= but->aspect*BIF_GetStringWidth(but->font, but->drawstr+but->ofs, (U.transopts & TR_BUTTONS)) + 3;
1559         
1560                                 but->drawstr[pos]= ch;
1561                                 glColor3ub(255,0,0);
1562         
1563                                 glRects(but->x1+t, but->y1+2, but->x1+t+3, but->y2-2);
1564                         }       
1565                 }
1566                 // cut string in 2 parts
1567                 cpoin= strchr(but->drawstr, '|');
1568                 if(cpoin) *cpoin= 0;
1569
1570                 /* If there's an icon too (made with uiDefIconTextBut) then draw the icon
1571                 and offset the text label to accomodate it */
1572                 
1573                 if ( (but->flag & UI_HAS_ICON) && (but->flag & UI_ICON_LEFT) ) {
1574                         ui_draw_icon(but, but->icon);
1575
1576                         if(but->flag & UI_TEXT_LEFT) x= but->x1+24.0;
1577                         else x= (but->x1+but->x2-but->strwidth+1)/2.0;
1578                 }
1579                 else {
1580                         if(but->flag & UI_TEXT_LEFT) x= but->x1+4.0;
1581                         else x= (but->x1+but->x2-but->strwidth+1)/2.0;
1582                 }
1583                 
1584                 /* text color, with pulldown item exception */
1585                 if(but->embossfunc==ui_draw_pulldown) {
1586                         if(but->flag & (UI_SELECT|UI_ACTIVE)) {         
1587                                 BIF_ThemeColor(TH_MENU_TEXT_HI);
1588                         } else {
1589                                 BIF_ThemeColor(TH_MENU_TEXT);
1590                         }
1591                 }
1592                 else {
1593                         if(but->flag & UI_SELECT) {             
1594                                 BIF_ThemeColor(TH_BUT_TEXT_HI);
1595                         } else {
1596                                 BIF_ThemeColor(TH_BUT_TEXT);
1597                         }
1598                 }
1599
1600                 /* tog3 button exception */
1601                 if(but->type==TOG3 && (but->flag & UI_SELECT)) {
1602                         int ok= 0;
1603                         
1604                         if( but->pointype==CHA ) {
1605                                 if( BTST( *(but->poin+2), but->bitnr )) ok= 1;
1606                         }
1607                         else if( but->pointype ==SHO ) {
1608                                 short *sp= (short *)but->poin;
1609                                 if( BTST( sp[1], but->bitnr )) ok= 1;
1610                         }
1611                         
1612                         if (ok) glColor3ub(255, 255, 0);
1613                 }
1614                 
1615                 glRasterPos2f( x, (but->y1+but->y2- 9.0)/2.0);
1616                 BIF_DrawString(but->font, but->drawstr+but->ofs, (U.transopts & TR_BUTTONS));
1617
1618                 /* part text right aligned */
1619                 if(cpoin) {
1620                         len= BIF_GetStringWidth(but->font, cpoin+1, (U.transopts & TR_BUTTONS));
1621                         glRasterPos2f( but->x2 - len*but->aspect-3, (but->y1+but->y2- 9.0)/2.0);
1622                         BIF_DrawString(but->font, cpoin+1, (U.transopts & TR_BUTTONS));
1623                         *cpoin= '|';
1624                 }
1625         }
1626         /* if there's no text label, then check to see if there's an icon only and draw it */
1627         else if( but->flag & UI_HAS_ICON ) {
1628                 ui_draw_icon(but, (BIFIconID) (but->icon+but->iconadd));
1629         }
1630
1631 }
1632
1633 static void ui_draw_but_COL(uiBut *but)
1634 {
1635         float *fp;
1636         char colr, colg, colb;
1637         
1638         if( but->pointype==FLO ) {
1639                 fp= (float *)but->poin;
1640                 colr= floor(255.0*fp[0]+0.5);
1641                 colg= floor(255.0*fp[1]+0.5);
1642                 colb= floor(255.0*fp[2]+0.5);
1643         }
1644         else {
1645                 char *cp= (char *)but->poin;
1646                 colr= cp[0];
1647                 colg= cp[1];
1648                 colb= cp[2];
1649         }
1650         glColor3ub(colr,  colg,  colb);
1651         glRectf((but->x1), (but->y1), (but->x2), (but->y2));
1652         glColor3ub(0,  0,  0);
1653         fdrawbox((but->x1), (but->y1), (but->x2), (but->y2));
1654
1655 }
1656
1657
1658
1659 /* nothing! */
1660 static void ui_draw_nothing(int type, int colorid, float asp, float x1, float y1, float x2, float y2, int flag)
1661 {
1662 }
1663
1664
1665 /* ************** EXTERN, called from interface.c ************* */
1666 /* ************** MAIN CALLBACK FUNCTION          ************* */
1667
1668 void ui_set_embossfunc(uiBut *but, int drawtype)
1669 {
1670
1671         // not really part of standard minimal themes, just make sure it is set
1672         but->sliderfunc= ui_draw_slider;
1673
1674         // standard builtin first:
1675         if(but->type==LABEL) but->embossfunc= ui_draw_nothing;
1676         else if(drawtype==UI_EMBOSSM) but->embossfunc= ui_draw_minimal;
1677         else if(drawtype==UI_EMBOSSN) but->embossfunc= ui_draw_nothing;
1678         else if(drawtype==UI_EMBOSSP) but->embossfunc= ui_draw_pulldown;
1679         else {
1680                 int theme= BIF_GetThemeValue(TH_BUT_DRAWTYPE);
1681                 
1682                 // and the themes
1683                 if(theme==1) {
1684                         but->embossfunc= ui_draw_default;
1685                         but->sliderfunc= ui_default_slider;
1686                 }
1687                 else if(theme==2) {
1688                         but->embossfunc= ui_draw_round;
1689                         but->sliderfunc= ui_default_slider;
1690                 }
1691                 else if(theme==3) {
1692                         but->embossfunc= ui_draw_oldskool;
1693                         but->sliderfunc= ui_default_slider;     // should be oldskool.... later
1694                 }
1695                 else {
1696                         but->embossfunc= ui_draw_minimal;
1697                 }
1698         }
1699 }
1700
1701
1702 void ui_draw_but(uiBut *but)
1703 {
1704         double value;
1705         float x1, x2, y1, y2, fac;
1706         
1707         if(but==0) return;
1708
1709         if(but->block->frontbuf==UI_NEED_DRAW_FRONT) {
1710                 but->block->frontbuf= UI_HAS_DRAW_FRONT;
1711         
1712                 glDrawBuffer(GL_FRONT);
1713                 if(but->win==curarea->headwin) curarea->head_swap= WIN_FRONT_OK;
1714                 else curarea->win_swap= WIN_FRONT_OK;
1715         }
1716         
1717         switch (but->type) {
1718
1719         case NUMSLI:
1720         case HSVSLI:
1721         
1722                 but->embossfunc(but->type, but->themecol, but->aspect, but->x1, but->y1, but->x2, but->y2, but->flag);
1723                 ui_draw_text_icon(but);
1724
1725                 x1= (but->x1+but->x2)/2;
1726                 x2= but->x2 - 5.0*but->aspect;
1727                 y1= but->y1 + 2.0*but->aspect;
1728                 y2= but->y2 - 2.0*but->aspect;
1729                 
1730                 value= ui_get_but_val(but);
1731                 fac= (value-but->min)*(x2-x1)/(but->max - but->min);
1732                 
1733                 but->sliderfunc(but->themecol, fac, but->aspect, x1, y1, x2, y2, but->flag);
1734                 break;
1735                 
1736         case SEPR:
1737                 //  only background
1738                 break;
1739                 
1740         case COL:
1741                 ui_draw_but_COL(but);  // black box with color
1742                 break;
1743
1744         case LINK:
1745         case INLINK:
1746                 ui_draw_icon(but, but->icon);
1747                 break;
1748
1749         default:
1750                 but->embossfunc(but->type, but->themecol, but->aspect, but->x1, but->y1, but->x2, but->y2, but->flag);
1751                 ui_draw_text_icon(but);
1752         
1753         }
1754 }
1755
1756
1757
1758