svn merge -r 15392:15551 https://svn.blender.org/svnroot/bf-blender/trunk/blender
[blender.git] / source / blender / src / interface_draw.c
index b93658c7a00d114440acec24e04641f712123468..e7041e6000373b2433e278780822dc7eb9d01aba 100644 (file)
@@ -1,15 +1,13 @@
+
 /**
  * $Id$
  *
- * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
+ * ***** BEGIN GPL LICENSE BLOCK *****
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
  * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version. The Blender
- * Foundation also sells licenses for use in proprietary software under
- * the Blender License.  See http://www.blender.org/BL/ for information
- * about this.
+ * of the License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -27,7 +25,7 @@
  *
  * Contributor(s): none yet.
  *
- * ***** END GPL/BL DUAL LICENSE BLOCK *****
+ * ***** END GPL LICENSE BLOCK *****
  */
 
 /* 
 #include <string.h>
 #include <ctype.h>
 
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
 #ifndef WIN32
 #include <unistd.h>
 #else
 #include <io.h>
-#include "BLI_winstuff.h"
 #endif   
 
 #include "MEM_guardedalloc.h"
 #include "BLI_blenlib.h"
 #include "BLI_arithb.h"
 
+#include "DNA_color_types.h"
+#include "DNA_key_types.h"
+#include "DNA_packedFile_types.h"
 #include "DNA_screen_types.h"
 #include "DNA_space_types.h"
+#include "DNA_texture_types.h"
 #include "DNA_userdef_types.h"
 #include "DNA_vec_types.h"
+#include "DNA_vfont_types.h"
 
 #include "BKE_blender.h"
-#include "BKE_utildefines.h"
+#include "BKE_colortools.h"
+#include "BKE_font.h"
 #include "BKE_global.h"
+#include "BKE_key.h"
+#include "BKE_utildefines.h"
+
+#include "datatoc.h"            /* std font */
 
 #include "BIF_gl.h"
 #include "BIF_graphics.h"
 #include "BIF_space.h"
 #include "BIF_glutil.h"
 #include "BIF_interface.h"
+#include "BIF_interface_icons.h"
 #include "BIF_butspace.h"
 #include "BIF_language.h"
 
 #include "BSE_view.h"
 
+#ifdef INTERNATIONAL
+#include "FTF_Api.h"
+#endif
+
 #include "mydevice.h"
 #include "interface.h"
 #include "blendef.h"
 extern float UIwinmat[4][4];
 
 
+/* ************** safe rasterpos for pixmap alignment with pixels ************* */
+
+void ui_rasterpos_safe(float x, float y, float aspect)
+{
+       float vals[4], remainder;
+       int doit=0;
+       
+       glRasterPos2f(x, y);
+       glGetFloatv(GL_CURRENT_RASTER_POSITION, vals);
+
+       remainder= vals[0] - floor(vals[0]);
+       if(remainder > 0.4 && remainder < 0.6) {
+               if(remainder < 0.5) x -= 0.1*aspect;
+               else x += 0.1*aspect;
+               doit= 1;
+       }
+       remainder= vals[1] - floor(vals[1]);
+       if(remainder > 0.4 && remainder < 0.6) {
+               if(remainder < 0.5) y -= 0.1*aspect;
+               else y += 0.1*aspect;
+               doit= 1;
+       }
+       
+       if(doit) glRasterPos2f(x, y);
+
+       BIF_RasterPos(x, y);
+       BIF_SetScale(aspect);
+}
 
 /* ************** generic embossed rect, for window sliders etc ************* */
 
@@ -118,70 +154,71 @@ void uiEmboss(float x1, float y1, float x2, float y2, int sel)
 
 /* ************** GENERIC ICON DRAW, NO THEME HERE ************* */
 
-static void ui_draw_icon(uiBut *but, BIFIconID icon)
-{
-       int blend= 0;
-       float xs=0, ys=0;
+/* icons have been standardized... and this call draws in untransformed coordinates */
+#define ICON_HEIGHT            16.0f
 
+static void ui_draw_icon(uiBut *but, BIFIconID icon, int blend)
+{
+       float xs=0, ys=0, aspect, height;
+
+       /* this icon doesn't need draw... */
+       if(icon==ICON_BLANK1) return;
+       
+       /* we need aspect from block, for menus... these buttons are scaled in uiPositionBlock() */
+       aspect= but->block->aspect;
+       if(aspect != but->aspect) {
+               /* prevent scaling up icon in pupmenu */
+               if (aspect < 1.0f) {                    
+                       height= ICON_HEIGHT;
+                       aspect = 1.0f;
+                       
+               }
+               else 
+                       height= ICON_HEIGHT/aspect;
+       }
+       else
+               height= ICON_HEIGHT;
+       
        if(but->flag & UI_ICON_LEFT) {
-               if (but->type==BUTM) {
+               if (but->type==BUT_TOGDUAL) {
+                       if (but->drawstr[0]) {
+                               xs= but->x1-1.0;
+                       } else {
+                               xs= (but->x1+but->x2- height)/2.0;
+                       }
+               }
+               else if (but->type==BUTM ) {
                        xs= but->x1+1.0;
                }
                else if ((but->type==ICONROW) || (but->type==ICONTEXTROW)) {
-                       xs= but->x1+4.0;
+                       xs= but->x1+3.0;
                }
                else {
-                       xs= but->x1+6.0;
+                       xs= but->x1+4.0;
                }
-               ys= (but->y1+but->y2- BIF_get_icon_height(icon))/2.0;
+               ys= (but->y1+but->y2- height)/2.0;
        }
        if(but->flag & UI_ICON_RIGHT) {
                xs= but->x2-17.0;
-               ys= (but->y1+but->y2- BIF_get_icon_height(icon))/2.0;
+               ys= (but->y1+but->y2- height)/2.0;
        }
        if (!((but->flag & UI_ICON_RIGHT) || (but->flag & UI_ICON_LEFT))) {
-               xs= (but->x1+but->x2- BIF_get_icon_width(icon))/2.0;
-               ys= (but->y1+but->y2- BIF_get_icon_height(icon))/2.0;
+               xs= (but->x1+but->x2- height)/2.0;
+               ys= (but->y1+but->y2- height)/2.0;
        }
 
-       glRasterPos2f(xs, ys);
-
-       if(but->aspect>1.1) glPixelZoom(1.0/but->aspect, 1.0/but->aspect);
-       else if(but->aspect<0.9) glPixelZoom(1.0/but->aspect, 1.0/but->aspect);
-
        glEnable(GL_BLEND);
-       glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
        /* calculate blend color */
-       if ELEM4(but->type, ICONTOG, TOG, ROW, TOGN) {
+       if ELEM3(but->type, TOG, ROW, TOGN) {
                if(but->flag & UI_SELECT);
                else if(but->flag & UI_ACTIVE);
                else blend= -60;
        }
-       BIF_draw_icon_blended(icon, but->themecol, blend);
+       BIF_icon_draw_aspect_blended(xs, ys, icon, aspect, blend);
        
-/* old blending method... hrums */
-/*     if(but->flag & UI_SELECT) {
-               if(but->flag & UI_ACTIVE) {
-                       BIF_draw_icon_blended(icon, but->themecol, -80);
-               } else {
-                       BIF_draw_icon_blended(icon, but->themecol, -45);
-               }
-       }
-       else {
-               if ((but->flag & UI_ACTIVE) && but->type==BUTM) {
-                       BIF_draw_icon_blended(icon, but->themecol, 0);
-               } else if (but->flag & UI_ACTIVE) {
-                       BIF_draw_icon_blended(icon, but->themecol, 25);
-               } else {
-                       BIF_draw_icon_blended(icon, but->themecol, 45);
-               }
-       }
-*/
-       glBlendFunc(GL_ONE, GL_ZERO);
        glDisable(GL_BLEND);
 
-       glPixelZoom(1.0, 1.0);
 }
 
 
@@ -338,9 +375,7 @@ static void shaded_button(float x1, float y1, float x2, float y2, float asp, int
                fdrawline(x1, y1, x2, y1); 
        } else {
                MM_DARK;
-               glBegin(GL_LINE_LOOP);
-               gl_round_box(x1, y1, x2, y2, 1.5);
-               glEnd();
+               gl_round_box(GL_LINE_LOOP, x1, y1, x2, y2, 1.5);
        }
        /* END OUTER OUTLINE */
 }
@@ -381,9 +416,7 @@ static void flat_button(float x1, float y1, float x2, float y2, float asp, int c
                fdrawline(x1, y1, x2, y1); 
        } else {
                MM_DARK;
-               glBegin(GL_LINE_LOOP);
-               gl_round_box(x1, y1, x2, y2, 1.5);
-               glEnd();
+               gl_round_box(GL_LINE_LOOP, x1, y1, x2, y2, 1.5);
        }
        /* END OUTER OUTLINE */
 }
@@ -393,7 +426,6 @@ static void ui_default_iconrow_arrows(float x1, float y1, float x2, float y2)
 {
        glEnable( GL_POLYGON_SMOOTH );
        glEnable( GL_BLEND );
-       glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
        
        glShadeModel(GL_FLAT);
        glBegin(GL_TRIANGLES);
@@ -417,7 +449,6 @@ static void ui_default_menu_arrows(float x1, float y1, float x2, float y2)
 {
        glEnable( GL_POLYGON_SMOOTH );
        glEnable( GL_BLEND );
-       glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
        
        glShadeModel(GL_FLAT);
        glBegin(GL_TRIANGLES);
@@ -439,29 +470,31 @@ static void ui_default_menu_arrows(float x1, float y1, float x2, float y2)
 /* left/right arrows for number fields */
 static void ui_default_num_arrows(float x1, float y1, float x2, float y2)
 {
-       glEnable( GL_POLYGON_SMOOTH );
-       glEnable( GL_BLEND );
-       glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
-       
-       glShadeModel(GL_FLAT);
-       glBegin(GL_TRIANGLES);
-       
-       glVertex2f((short)x1+5,(short)(y2-(y2-y1)/2));
-       glVertex2f((short)x1+10,(short)(y2-(y2-y1)/2)+4);
-       glVertex2f((short)x1+10,(short)(y2-(y2-y1)/2)-4);
-       glEnd();
+       if( x2-x1 > 25) {       // 25 is a bit arbitrary, but small buttons cant have arrows
 
-       /* right */
-       glShadeModel(GL_FLAT);
-       glBegin(GL_TRIANGLES);
+               glEnable( GL_POLYGON_SMOOTH );
+               glEnable( GL_BLEND );
+               
+               glShadeModel(GL_FLAT);
+               glBegin(GL_TRIANGLES);
+               
+               glVertex2f((short)x1+5,(short)(y2-(y2-y1)/2));
+               glVertex2f((short)x1+10,(short)(y2-(y2-y1)/2)+4);
+               glVertex2f((short)x1+10,(short)(y2-(y2-y1)/2)-4);
+               glEnd();
 
-       glVertex2f((short)x2-5,(short)(y2-(y2-y1)/2));
-       glVertex2f((short)x2-10,(short)(y2-(y2-y1)/2)-4);
-       glVertex2f((short)x2-10,(short)(y2-(y2-y1)/2)+4);
-       glEnd();
-       
-       glDisable( GL_BLEND );
-       glDisable( GL_POLYGON_SMOOTH );
+               /* right */
+               glShadeModel(GL_FLAT);
+               glBegin(GL_TRIANGLES);
+
+               glVertex2f((short)x2-5,(short)(y2-(y2-y1)/2));
+               glVertex2f((short)x2-10,(short)(y2-(y2-y1)/2)-4);
+               glVertex2f((short)x2-10,(short)(y2-(y2-y1)/2)+4);
+               glEnd();
+               
+               glDisable( GL_BLEND );
+               glDisable( GL_POLYGON_SMOOTH );
+       }
 }
 
 /* changing black/white for TOG3 buts */
@@ -470,7 +503,6 @@ static void ui_tog3_invert(float x1, float y1, float x2, float y2, int seltype)
        short alpha = 30;
        
        if (seltype == 0) {
-               glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
                glEnable(GL_BLEND);
                
                glColor4ub(0, 0, 0, alpha);
@@ -481,7 +513,6 @@ static void ui_tog3_invert(float x1, float y1, float x2, float y2, int seltype)
                
                glDisable(GL_BLEND);
        } else {
-               glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
                glEnable(GL_BLEND);
                
                glColor4ub(255, 255, 255, alpha);
@@ -505,7 +536,6 @@ static void ui_default_button(int type, int colorid, float asp, float x1, float
                if (!((align == UI_BUT_ALIGN_DOWN) ||
                        (align == (UI_BUT_ALIGN_DOWN|UI_BUT_ALIGN_RIGHT)) ||
                        (align == (UI_BUT_ALIGN_DOWN|UI_BUT_ALIGN_LEFT)))) {
-                       glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
                        glEnable(GL_BLEND);
                        MM_WHITE_OP;
                        fdrawline(x1, y1-1, x2, y1-1);  
@@ -531,7 +561,6 @@ static void ui_default_button(int type, int colorid, float asp, float x1, float
                case UI_BUT_ALIGN_LEFT:
                        
                        /* RIGHT OUTER SUNKEN EFFECT */
-                       glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
                        glEnable(GL_BLEND);
                        glShadeModel(GL_SMOOTH);
                        glBegin(GL_LINES);
@@ -548,7 +577,6 @@ static void ui_default_button(int type, int colorid, float asp, float x1, float
                case UI_BUT_ALIGN_RIGHT:
                
                        /* LEFT OUTER SUNKEN EFFECT */
-                       glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
                        glEnable(GL_BLEND);
                        glShadeModel(GL_SMOOTH);
                        glBegin(GL_LINES);
@@ -574,7 +602,6 @@ static void ui_default_button(int type, int colorid, float asp, float x1, float
                case UI_BUT_ALIGN_TOP|UI_BUT_ALIGN_RIGHT:
                
                        /* LEFT OUTER SUNKEN EFFECT */
-                       glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
                        glEnable(GL_BLEND);
                        glShadeModel(GL_SMOOTH);
                        glBegin(GL_LINES);
@@ -591,7 +618,6 @@ static void ui_default_button(int type, int colorid, float asp, float x1, float
                case UI_BUT_ALIGN_TOP|UI_BUT_ALIGN_LEFT:
                
                        /* RIGHT OUTER SUNKEN EFFECT */
-                       glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
                        glEnable(GL_BLEND);
                        glShadeModel(GL_SMOOTH);
                        glBegin(GL_LINES);
@@ -612,7 +638,6 @@ static void ui_default_button(int type, int colorid, float asp, float x1, float
                }
        } 
        else {  
-               glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
                glEnable(GL_BLEND);
                glShadeModel(GL_SMOOTH);
                
@@ -647,7 +672,6 @@ static void ui_default_button(int type, int colorid, float asp, float x1, float
        case ICONROW:
        case ICONTEXTROW:
                /* DARKENED AREA */
-               glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
                glEnable(GL_BLEND);
                
                glColor4ub(0, 0, 0, 30);
@@ -663,7 +687,6 @@ static void ui_default_button(int type, int colorid, float asp, float x1, float
                break;
        case MENU:
                /* DARKENED AREA */
-               glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
                glEnable(GL_BLEND);
                
                glColor4ub(0, 0, 0, 30);
@@ -692,7 +715,6 @@ static void ui_default_flat(int type, int colorid, float asp, float x1, float y1
                if (!((align == UI_BUT_ALIGN_DOWN) ||
                        (align == (UI_BUT_ALIGN_DOWN|UI_BUT_ALIGN_RIGHT)) ||
                        (align == (UI_BUT_ALIGN_DOWN|UI_BUT_ALIGN_LEFT)))) {
-                       glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
                        glEnable(GL_BLEND);
                        MM_WHITE_OP;
                        fdrawline(x1, y1-1, x2, y1-1);  
@@ -718,7 +740,6 @@ static void ui_default_flat(int type, int colorid, float asp, float x1, float y1
                case UI_BUT_ALIGN_LEFT:
                        
                        /* RIGHT OUTER SUNKEN EFFECT */
-                       glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
                        glEnable(GL_BLEND);
                        glShadeModel(GL_SMOOTH);
                        glBegin(GL_LINES);
@@ -735,7 +756,6 @@ static void ui_default_flat(int type, int colorid, float asp, float x1, float y1
                case UI_BUT_ALIGN_RIGHT:
                
                        /* LEFT OUTER SUNKEN EFFECT */
-                       glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
                        glEnable(GL_BLEND);
                        glShadeModel(GL_SMOOTH);
                        glBegin(GL_LINES);
@@ -761,7 +781,6 @@ static void ui_default_flat(int type, int colorid, float asp, float x1, float y1
                case UI_BUT_ALIGN_TOP|UI_BUT_ALIGN_RIGHT:
                
                        /* LEFT OUTER SUNKEN EFFECT */
-                       glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
                        glEnable(GL_BLEND);
                        glShadeModel(GL_SMOOTH);
                        glBegin(GL_LINES);
@@ -778,7 +797,6 @@ static void ui_default_flat(int type, int colorid, float asp, float x1, float y1
                case UI_BUT_ALIGN_TOP|UI_BUT_ALIGN_LEFT:
                
                        /* RIGHT OUTER SUNKEN EFFECT */
-                       glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
                        glEnable(GL_BLEND);
                        glShadeModel(GL_SMOOTH);
                        glBegin(GL_LINES);
@@ -800,7 +818,6 @@ static void ui_default_flat(int type, int colorid, float asp, float x1, float y1
        } 
        else {
        
-               glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
                glEnable(GL_BLEND);
                glShadeModel(GL_SMOOTH);
                
@@ -833,6 +850,7 @@ static void ui_default_flat(int type, int colorid, float asp, float x1, float y1
        /* *** EXTRA DRAWING FOR SPECIFIC CONTROL TYPES *** */
        switch(type) {
        case NUM:
+       case NUMABS:
                /* SIDE ARROWS */
                /* left */
                if(flag & UI_SELECT) {
@@ -859,11 +877,12 @@ static void ui_default_slider(int colorid, float fac, float aspect, float x1, fl
        
        if(flag & UI_SELECT) 
                        BIF_ThemeColorShade(TH_BUT_NUM, -5);
-       else
+       else {
                if(flag & UI_ACTIVE) 
                        BIF_ThemeColorShade(TH_BUT_NUM, +35); 
                else
                        BIF_ThemeColorShade(TH_BUT_NUM, +25); 
+       }
 
        glRectf(x1, ymid-yc, x2, ymid+yc);
        
@@ -930,6 +949,7 @@ static void ui_draw_default(int type, int colorid, float aspect, float x1, float
        case TEX:
        case IDPOIN:
        case NUM:
+       case NUMABS:
                ui_default_flat(type, colorid, aspect, x1, y1, x2, y2, flag);
                break;
        case ICONROW: 
@@ -1013,6 +1033,7 @@ static void ui_draw_oldskool(int type, int colorid, float asp, float x1, float y
        /* special type decorations */
        switch(type) {
        case NUM:
+       case NUMABS:
                if(flag & UI_SELECT) BIF_ThemeColorShade(colorid, -60);
                else BIF_ThemeColorShade(colorid, -30);
                ui_default_num_arrows(x1, y1, x2, y2);
@@ -1042,29 +1063,55 @@ static void ui_draw_oldskool(int type, int colorid, float asp, float x1, float y
 
 /* *************** BASIC ROUNDED THEME ***************** */
 
-static void round_button(float x1, float y1, float x2, float y2, float asp, int colorid)
+static void round_button(float x1, float y1, float x2, float y2, float asp, 
+                                                int colorid, int round, int menudeco, int curshade)
 {
        float rad;
+       char col[4];
        
        rad= (y2-y1)/2.0;
        if(rad>7.0) rad= 7.0;
        
-       glBegin(GL_POLYGON);
-       gl_round_box(x1, y1, x2, y2, rad);
-       glEnd();
-       
-       BIF_ThemeColorBlendShade(colorid, TH_BACK, 0.5, -70);
+       uiSetRoundBox(round);
+       gl_round_box(GL_POLYGON, x1, y1, x2, y2, rad);
+
+       if(menudeco) {
+               uiSetRoundBox(round & ~9);
+               BIF_ThemeColorShade(colorid, curshade-20);
+               gl_round_box(GL_POLYGON, x2-menudeco, y1, x2, y2, rad);
+       }
        
-       glBegin(GL_LINE_LOOP);
-       gl_round_box(x1, y1, x2, y2, rad);
-       glEnd();
+       /* fake AA */
+       uiSetRoundBox(round);
+       glEnable( GL_BLEND );
+
+       BIF_GetThemeColor3ubv(colorid, col);
+               
+       if(col[0]<100) col[0]= 0; else col[0]-= 100;
+       if(col[1]<100) col[1]= 0; else col[1]-= 100;
+       if(col[2]<100) col[2]= 0; else col[2]-= 100;
+       col[3]= 80;
+       glColor4ubv((GLubyte *)col);
+       gl_round_box(GL_LINE_LOOP, x1, y1, x2, y2, rad - asp);
+       gl_round_box(GL_LINE_LOOP, x1, y1, x2, y2, rad + asp);
+       col[3]= 180;
+       glColor4ubv((GLubyte *)col);
+       gl_round_box(GL_LINE_LOOP, x1, y1, x2, y2, rad);
+
+       glDisable( GL_BLEND );
 }
 
 /* button in midst of alignment row */
-static void round_button_mid(float x1, float y1, float x2, float y2, float asp, int colorid, int align)
+static void round_button_mid(float x1, float y1, float x2, float y2, float asp, 
+                                                        int colorid, int align, int menudeco, int curshade)
 {
        glRectf(x1, y1, x2, y2);
        
+       if(menudeco) {
+               BIF_ThemeColorShade(colorid, curshade-20);
+               glRectf(x2-menudeco, y1, x2, y2);
+       }
+       
        BIF_ThemeColorBlendShade(colorid, TH_BACK, 0.5, -70);
        // we draw full outline, its not AA, and it works better button mouse-over hilite
        
@@ -1080,107 +1127,77 @@ static void round_button_mid(float x1, float y1, float x2, float y2, float asp,
 static void ui_draw_round(int type, int colorid, float asp, float x1, float y1, float x2, float y2, int flag)
 {
        int align= (flag & UI_BUT_ALIGN);
-       int round_align_fix= 0;
+       int curshade= 0, menudeco= 0;
+       
+       if(type==ICONROW || type==ICONTEXTROW) menudeco= 9;
+       else if((type==MENU || type==BLOCK) && x2-x1>24) menudeco= 16;
        
        /* paper */
        if(flag & UI_SELECT) {
-               if(flag & UI_ACTIVE) BIF_ThemeColorShade(colorid, -40);
-               else BIF_ThemeColorShade(colorid, -30);
+               if(flag & UI_ACTIVE) curshade= -40;
+               else curshade= -30;
        }
        else {
-               if(flag & UI_ACTIVE) BIF_ThemeColorShade(colorid, +30);
-               else BIF_ThemeColorShade(colorid, +20);
+               if(flag & UI_ACTIVE) curshade= 30;
+               else curshade= +20;
        }
        
+       BIF_ThemeColorShade(colorid, curshade);
+
        if(align) {
                switch(align) {
                case UI_BUT_ALIGN_TOP:
-                       uiSetRoundBox(12);
-                       round_align_fix= 4;
-                       round_button(x1, y1, x2, y2, asp, colorid);
+                       round_button(x1, y1, x2, y2, asp, colorid, 12, menudeco, curshade);
                        break;
                case UI_BUT_ALIGN_DOWN:
-                       uiSetRoundBox(3);
-                       round_align_fix= 2;
-                       round_button(x1, y1, x2, y2, asp, colorid);
+                       round_button(x1, y1, x2, y2, asp, colorid, 3, menudeco, curshade);
                        break;
                case UI_BUT_ALIGN_LEFT:
-                       uiSetRoundBox(6);
-                       round_align_fix= 6;
-                       round_button(x1, y1, x2, y2, asp, colorid);
+                       round_button(x1, y1, x2, y2, asp, colorid, 6, menudeco, curshade);
                        break;
                case UI_BUT_ALIGN_RIGHT:
-                       uiSetRoundBox(9);
-                       round_align_fix= 0;
-                       round_button(x1, y1, x2, y2, asp, colorid);
+                       round_button(x1, y1, x2, y2, asp, colorid, 9, menudeco, curshade);
                        break;
                        
                case UI_BUT_ALIGN_DOWN|UI_BUT_ALIGN_RIGHT:
-                       uiSetRoundBox(1);
-                       round_align_fix= 0;
-                       round_button(x1, y1, x2, y2, asp, colorid);
+                       round_button(x1, y1, x2, y2, asp, colorid, 1, menudeco, curshade);
                        break;
                case UI_BUT_ALIGN_DOWN|UI_BUT_ALIGN_LEFT:
-                       uiSetRoundBox(2);
-                       round_align_fix= 2;
-                       round_button(x1, y1, x2, y2, asp, colorid);
+                       round_button(x1, y1, x2, y2, asp, colorid, 2, menudeco, curshade);
                        break;
                case UI_BUT_ALIGN_TOP|UI_BUT_ALIGN_RIGHT:
-                       uiSetRoundBox(8);
-                       round_align_fix= 0;
-                       round_button(x1, y1, x2, y2, asp, colorid);
+                       round_button(x1, y1, x2, y2, asp, colorid, 8, menudeco, curshade);
                        break;
                case UI_BUT_ALIGN_TOP|UI_BUT_ALIGN_LEFT:
-                       uiSetRoundBox(4);
-                       round_align_fix= 4;
-                       round_button(x1, y1, x2, y2, asp, colorid);
+                       round_button(x1, y1, x2, y2, asp, colorid, 4, menudeco, curshade);
                        break;
                        
                default:
-                       round_align_fix= 0;
-                       round_button_mid(x1, y1, x2, y2, asp, colorid, align);
+                       round_button_mid(x1, y1, x2, y2, asp, colorid, align, menudeco, curshade);
                        break;
                }
        } 
        else {
-               uiSetRoundBox(15);
-               round_align_fix= 6;
-               round_button(x1, y1, x2, y2, asp, colorid);
+               round_button(x1, y1, x2, y2, asp, colorid, 15, menudeco, curshade);
        }
-       
+
        /* special type decorations */
        switch(type) {
        case NUM:
-               if(flag & UI_SELECT) BIF_ThemeColorShade(colorid, -60);
-               else BIF_ThemeColorShade(colorid, -30);
+       case NUMABS:
+               BIF_ThemeColorShade(colorid, curshade-60);
                ui_default_num_arrows(x1, y1, x2, y2);
                break;
 
        case ICONROW: 
        case ICONTEXTROW: 
-               if(flag & UI_ACTIVE) BIF_ThemeColorShade(colorid, 0);
-               else BIF_ThemeColorShade(colorid, -10);
-               // assuming its not inside alignment...
-               uiSetRoundBox(6);
-               glBegin(GL_POLYGON);
-               gl_round_box(x2-9, y1+asp, x2-asp, y2-asp, 7.0);
-               glEnd();
-
-               BIF_ThemeColorShade(colorid, -60);
+               BIF_ThemeColorShade(colorid, curshade-60);
                ui_default_iconrow_arrows(x1, y1, x2, y2);
                break;
                
        case MENU: 
-               if(flag & UI_ACTIVE) BIF_ThemeColorShade(colorid, 0);
-               else BIF_ThemeColorShade(colorid, -10);
-               // assuming its not inside alignment...
-               if(x2-x1 > 24) {
-                       uiSetRoundBox(round_align_fix);
-                       glBegin(GL_POLYGON);
-                       gl_round_box(x2-16, y1+asp, x2-asp, y2-asp, 7.0);
-                       glEnd();
-               }
-               BIF_ThemeColorShade(colorid, -60);
+       case BLOCK: 
+               BIF_ThemeColorShade(colorid, curshade-60);
                ui_default_menu_arrows(x1, y1, x2, y2);
                break;
        }
@@ -1195,12 +1212,19 @@ static void ui_draw_round(int type, int colorid, float asp, float x1, float y1,
 /* super minimal button as used in logic menu */
 static void ui_draw_minimal(int type, int colorid, float asp, float x1, float y1, float x2, float y2, int flag)
 {
+       /* too much space between buttons */
+       
+       if (type==TEX || type==IDPOIN) {
+               x1+= asp;
+               x2-= (asp*2);
+               //y1+= asp;
+               y2-= asp;
+       } else {
+               /* Less space between buttons looks nicer */
+               y2-= asp;
+               x2-= asp;
+       }
        
-       x1+= asp;
-       x2-= asp;
-       y1+= asp;
-       y2-= asp;
-
        /* paper */
        if(flag & UI_SELECT) {
                if(flag & UI_ACTIVE) BIF_ThemeColorShade(colorid, -40);
@@ -1212,39 +1236,65 @@ static void ui_draw_minimal(int type, int colorid, float asp, float x1, float y1
        }
        
        glRectf(x1, y1, x2, y2);
-
-       if(flag & UI_SELECT) {
+       
+       if (type==TEX || type==IDPOIN) {
                BIF_ThemeColorShade(colorid, -60);
 
-               /* top */
-               fdrawline(x1, y2, x2, y2);
-               /* left */
-               fdrawline(x1, y1, x1, y2);
-               BIF_ThemeColorShade(colorid, +40);
-
-               /* below */
-               fdrawline(x1, y1, x2, y1);
-               /* right */
-               fdrawline(x2, y1, x2, y2);
-       }
-       else {
-               BIF_ThemeColorShade(colorid, +40);
-
                /* top */
                fdrawline(x1, y2, x2, y2);
                /* left */
                fdrawline(x1, y1, x1, y2);
                
-               BIF_ThemeColorShade(colorid, -60);
+               
+               /* text underline, some  */ 
+               BIF_ThemeColorShade(colorid, +50);
+               glEnable(GL_LINE_STIPPLE);
+               glLineStipple(1, 0x8888);
+               fdrawline(x1+(asp*2), y1+(asp*3), x2-(asp*2), y1+(asp*3));
+               glDisable(GL_LINE_STIPPLE);
+               
+               
+               BIF_ThemeColorShade(colorid, +60);
                /* below */
                fdrawline(x1, y1, x2, y1);
                /* right */
                fdrawline(x2, y1, x2, y2);
+               
+       } else {
+               if(flag & UI_SELECT) {
+                       BIF_ThemeColorShade(colorid, -60);
+
+                       /* top */
+                       fdrawline(x1, y2, x2, y2);
+                       /* left */
+                       fdrawline(x1, y1, x1, y2);
+                       BIF_ThemeColorShade(colorid, +40);
+
+                       /* below */
+                       fdrawline(x1, y1, x2, y1);
+                       /* right */
+                       fdrawline(x2, y1, x2, y2);
+               }
+               else {
+                       BIF_ThemeColorShade(colorid, +40);
+
+                       /* top */
+                       fdrawline(x1, y2, x2, y2);
+                       /* left */
+                       fdrawline(x1, y1, x1, y2);
+                       
+                       BIF_ThemeColorShade(colorid, -60);
+                       /* below */
+                       fdrawline(x1, y1, x2, y1);
+                       /* right */
+                       fdrawline(x2, y1, x2, y2);
+               }
        }
        
        /* special type decorations */
        switch(type) {
        case NUM:
+       case NUMABS:
                if(flag & UI_SELECT) BIF_ThemeColorShade(colorid, -60);
                else BIF_ThemeColorShade(colorid, -30);
                ui_default_num_arrows(x1, y1, x2, y2);
@@ -1261,6 +1311,7 @@ static void ui_draw_minimal(int type, int colorid, float asp, float x1, float y1
                break;
                
        case MENU: 
+       case BLOCK: 
                if(flag & UI_ACTIVE) BIF_ThemeColorShade(colorid, 0);
                else BIF_ThemeColorShade(colorid, -10);
                glRectf(x2-17, y1+asp, x2-asp, y2-asp);
@@ -1300,70 +1351,130 @@ static void ui_draw_slider(int colorid, float fac, float aspect, float x1, float
 
 }
 
-/* ************** STANDARD MENU DRAWING FUNCTION (no callback yet) ************* */
+/* ************** STANDARD MENU DRAWING FUNCTION ************* */
 
 
-// background for pulldowns, pullups, and other frontbuffer drawing temporal menus....
+static void ui_shadowbox(float minx, float miny, float maxx, float maxy, float shadsize, unsigned char alpha)
+{
+       glEnable(GL_BLEND);
+       glShadeModel(GL_SMOOTH);
+       
+       /* right quad */
+       glBegin(GL_POLYGON);
+       glColor4ub(0, 0, 0, alpha);
+       glVertex2f(maxx, miny);
+       glVertex2f(maxx, maxy-shadsize);
+       glColor4ub(0, 0, 0, 0);
+       glVertex2f(maxx+shadsize, maxy-shadsize-shadsize);
+       glVertex2f(maxx+shadsize, miny);
+       glEnd();
+       
+       /* corner shape */
+       glBegin(GL_POLYGON);
+       glColor4ub(0, 0, 0, alpha);
+       glVertex2f(maxx, miny);
+       glColor4ub(0, 0, 0, 0);
+       glVertex2f(maxx+shadsize, miny);
+       glVertex2f(maxx+0.7*shadsize, miny-0.7*shadsize);
+       glVertex2f(maxx, miny-shadsize);
+       glEnd();
+       
+       /* bottom quad */               
+       glBegin(GL_POLYGON);
+       glColor4ub(0, 0, 0, alpha);
+       glVertex2f(minx+shadsize, miny);
+       glVertex2f(maxx, miny);
+       glColor4ub(0, 0, 0, 0);
+       glVertex2f(maxx, miny-shadsize);
+       glVertex2f(minx+shadsize+shadsize, miny-shadsize);
+       glEnd();
+       
+       glDisable(GL_BLEND);
+       glShadeModel(GL_FLAT);
+}
+
+void uiDrawBoxShadow(unsigned char alpha, float minx, float miny, float maxx, float maxy)
+{
+       /* accumulated outline boxes to make shade not linear, is more pleasant */
+       ui_shadowbox(minx, miny, maxx, maxy, 6.0, (30*alpha)>>8);
+       ui_shadowbox(minx, miny, maxx, maxy, 4.0, (70*alpha)>>8);
+       ui_shadowbox(minx, miny, maxx, maxy, 2.0, (100*alpha)>>8);
+       
+}
+
+// background for pulldowns, pullups, and other drawing temporal menus....
 // has to be made themable still (now only color)
 
 void uiDrawMenuBox(float minx, float miny, float maxx, float maxy, short flag)
 {
-
+       char col[4];
+       BIF_GetThemeColor4ubv(TH_MENU_BACK, col);
+       
        if( (flag & UI_BLOCK_NOSHADOW)==0) {
-               glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-               glEnable(GL_BLEND);
-               
-               glColor4ub(0, 0, 0, 20);
-               
-               /* to prevent gaps being drawn between box and shadow (rounding errors?) */
-               fdrawline(minx+3, miny+0.25, maxx+0.25, miny+0.25);
-               fdrawline(maxx+0.25, miny+0.25, maxx+0.25, maxy-3);
+               /* accumulated outline boxes to make shade not linear, is more pleasant */
+               ui_shadowbox(minx, miny, maxx, maxy, 6.0, (30*col[3])>>8);
+               ui_shadowbox(minx, miny, maxx, maxy, 4.0, (70*col[3])>>8);
+               ui_shadowbox(minx, miny, maxx, maxy, 2.0, (100*col[3])>>8);
                
-               glColor4ub(0, 0, 0, 70);
-               fdrawline(minx+3, miny, maxx+1, miny);
-               fdrawline(maxx+1, miny, maxx+1, maxy-3);
-               
-               glColor4ub(0, 0, 0, 70);
-               fdrawline(minx+3, miny-1, maxx+1, miny-1);
-               fdrawline(maxx+1, miny-1, maxx+1, maxy-3);
+               glEnable(GL_BLEND);
+               glColor4ubv((GLubyte *)col);
+               glRectf(minx-1, miny, minx, maxy);      // 1 pixel on left, to distinguish sublevel menus
+       }
+       glEnable(GL_BLEND);
+       glColor4ubv((GLubyte *)col);
+       glRectf(minx, miny, maxx, maxy);
+       glDisable(GL_BLEND);
+}
+
+
+
+/* pulldown menu item */
+static void ui_draw_pulldown_item(int type, int colorid, float asp, float x1, float y1, float x2, float y2, int flag)
+{
+       char col[4];
        
-               glColor4ub(0, 0, 0, 55);
-               fdrawline(minx+3, miny-2, maxx+2, miny-2);
-               fdrawline(maxx+2, miny-2, maxx+2, maxy-3);
+       BIF_GetThemeColor4ubv(TH_MENU_BACK, col);
+       if(col[3]!=255) {
+               glEnable(GL_BLEND);
+       }
        
-               glColor4ub(0, 0, 0, 35);
-               fdrawline(minx+3, miny-3, maxx+3, miny-3);
-               fdrawline(maxx+3, miny-3, maxx+3, maxy-3);
+       if((flag & UI_ACTIVE) && type!=LABEL) {
+               BIF_ThemeColor4(TH_MENU_HILITE);
+               glRectf(x1, y1, x2, y2);
        
-               glColor4ub(0, 0, 0, 20);
-               fdrawline(minx+3, miny-4, maxx+4, miny-4);
-               fdrawline(maxx+4, miny-4, maxx+4, maxy-3);
-               
-               glDisable(GL_BLEND);
+
+       } else {
+               BIF_ThemeColor4(colorid);       // is set at TH_MENU_ITEM when pulldown opened.
+               glRectf(x1, y1, x2, y2);
        }
-       BIF_ThemeColor(TH_MENU_BACK);
 
-       glRectf(minx, miny, maxx, maxy);
+       glDisable(GL_BLEND);
 }
 
-/* pulldown menu */
-static void ui_draw_pulldown(int type, int colorid, float asp, float x1, float y1, float x2, float y2, int flag)
+/* pulldown menu calling button */
+static void ui_draw_pulldown_round(int type, int colorid, float asp, float x1, float y1, float x2, float y2, int flag)
 {
-
+       
        if(flag & UI_ACTIVE) {
                BIF_ThemeColor(TH_MENU_HILITE);
-               glRectf(x1-1, y1, x2+2, y2);
 
+               uiSetRoundBox(15);
+               gl_round_box(GL_POLYGON, x1, y1+3, x2, y2-3, 7.0);
+
+               glEnable( GL_LINE_SMOOTH );
+               glEnable( GL_BLEND );
+               gl_round_box(GL_LINE_LOOP, x1, y1+3, x2, y2-3, 7.0);
+               glDisable( GL_LINE_SMOOTH );
+               glDisable( GL_BLEND );
+               
        } else {
                BIF_ThemeColor(colorid);        // is set at TH_MENU_ITEM when pulldown opened.
-               glRectf(x1-1, y1, x2+2, y2);
+               glRectf(x1-1, y1+2, x2+1, y2-2);
        }
-
+       
 }
 
 
-
-
 /* ************** TEXT AND ICON DRAWING FUNCTIONS ************* */
 
 
@@ -1374,99 +1485,155 @@ static void ui_draw_text_icon(uiBut *but)
        float x;
        int len;
        char *cpoin;
+       short t, pos, ch;
+       short selsta_tmp, selend_tmp, selsta_draw, selwidth_draw;
        
        /* check for button text label */
        if (but->type == ICONTEXTROW) {
-               ui_draw_icon(but, (BIFIconID) (but->icon+but->iconadd));
+               ui_draw_icon(but, (BIFIconID) (but->icon+but->iconadd), 0);
        }
-       else if(but->drawstr[0]!=0) {
-               
-               // text button cursor
+       else {
+
+               /* text button selection and cursor */
                if(but->pos != -1) {
-                       short t, pos, ch;
+               
+                       if ((but->selend - but->selsta) > 0) {
+                               /* text button selection */
+                               selsta_tmp = but->selsta + strlen(but->str);
+                               selend_tmp = but->selend + strlen(but->str);
+                                       
+                               if(but->drawstr[0]!=0) {
+                                       ch= but->drawstr[selsta_tmp];
+                                       but->drawstr[selsta_tmp]= 0;
+                                       
+                                       selsta_draw = but->aspect*BIF_GetStringWidth(but->font, but->drawstr+but->ofs, (U.transopts & USER_TR_BUTTONS)) + 3;
+                                       
+                                       but->drawstr[selsta_tmp]= ch;
+                                       
+                                       
+                                       ch= but->drawstr[selend_tmp];
+                                       but->drawstr[selend_tmp]= 0;
+                                       
+                                       selwidth_draw = but->aspect*BIF_GetStringWidth(but->font, but->drawstr+but->ofs, (U.transopts & USER_TR_BUTTONS)) + 3;
+                                       
+                                       but->drawstr[selend_tmp]= ch;
+                                       
+                                       BIF_ThemeColor(TH_BUT_TEXTFIELD_HI);
+                                       glRects(but->x1+selsta_draw+1, but->y1+2, but->x1+selwidth_draw+1, but->y2-2);
+                               }
+                       } else {
+                               /* text cursor */
+                               pos= but->pos+strlen(but->str);
+                               if(pos >= but->ofs) {
+                                       if(but->drawstr[0]!=0) {
+                                               ch= but->drawstr[pos];
+                                               but->drawstr[pos]= 0;
                        
-                       pos= but->pos+strlen(but->str);
-                       if(pos >= but->ofs) {
-                               ch= but->drawstr[pos];
-                               but->drawstr[pos]= 0;
-       
-                               t= but->aspect*BIF_GetStringWidth(but->font, but->drawstr+but->ofs, (U.transopts & USER_TR_BUTTONS)) + 3;
-       
-                               but->drawstr[pos]= ch;
-                               glColor3ub(255,0,0);
-       
-                               glRects(but->x1+t, but->y1+2, but->x1+t+3, but->y2-2);
-                       }       
+                                               t= but->aspect*BIF_GetStringWidth(but->font, but->drawstr+but->ofs, (U.transopts & USER_TR_BUTTONS)) + 3;
+                                               
+                                               but->drawstr[pos]= ch;
+                                       }
+                                       else t= 3;
+                                       
+                                       glColor3ub(255,0,0);
+                                       glRects(but->x1+t, but->y1+2, but->x1+t+2, but->y2-2);
+                               }
+                       }
                }
-               // cut string in 2 parts
-               cpoin= strchr(but->drawstr, '|');
-               if(cpoin) *cpoin= 0;
-
-               /* If there's an icon too (made with uiDefIconTextBut) then draw the icon
-               and offset the text label to accomodate it */
                
-               if ( (but->flag & UI_HAS_ICON) && (but->flag & UI_ICON_LEFT) ) {
-                       ui_draw_icon(but, but->icon);
-
-                       if(but->flag & UI_TEXT_LEFT) x= but->x1+24.0;
-                       else x= (but->x1+but->x2-but->strwidth+1)/2.0;
-               }
-               else {
-                       if(but->flag & UI_TEXT_LEFT) x= but->x1+4.0;
-                       else x= (but->x1+but->x2-but->strwidth+1)/2.0;
+               if(but->type==BUT_TOGDUAL) {
+                       int dualset= 0;
+                       if(but->pointype==SHO)
+                               dualset= BTST( *(((short *)but->poin)+1), but->bitnr);
+                       else if(but->pointype==INT)
+                               dualset= BTST( *(((int *)but->poin)+1), but->bitnr);
+                       
+                       ui_draw_icon(but, ICON_DOT, dualset?0:-100);
                }
                
-               /* text color, with pulldown item exception */
-               if(but->embossfunc==ui_draw_pulldown) {
-                       if(but->flag & (UI_SELECT|UI_ACTIVE)) {         
-                               BIF_ThemeColor(TH_MENU_TEXT_HI);
-                       } else {
-                               BIF_ThemeColor(TH_MENU_TEXT);
+               if(but->drawstr[0]!=0) {
+                       int transopts;
+                       int tog3= 0;
+                       
+                       // cut string in 2 parts
+                       cpoin= strchr(but->drawstr, '|');
+                       if(cpoin) *cpoin= 0;
+
+                       /* If there's an icon too (made with uiDefIconTextBut) then draw the icon
+                       and offset the text label to accomodate it */
+                       
+                       if ( (but->flag & UI_HAS_ICON) && (but->flag & UI_ICON_LEFT) ) {
+                               ui_draw_icon(but, but->icon, 0);
+
+                               if(but->flag & UI_TEXT_LEFT) x= but->x1 + but->aspect*BIF_icon_get_width(but->icon)+5.0;
+                               else x= (but->x1+but->x2-but->strwidth+1)/2.0;
                        }
-               }
-               else {
-                       if(but->flag & UI_SELECT) {             
-                               BIF_ThemeColor(TH_BUT_TEXT_HI);
-                       } else {
-                               BIF_ThemeColor(TH_BUT_TEXT);
+                       else {
+                               if(but->flag & UI_TEXT_LEFT) x= but->x1+4.0;
+                               else x= (but->x1+but->x2-but->strwidth+1)/2.0;
+                       }
+                       
+                       /* tog3 button exception; draws with glColor! */
+                       if(but->type==TOG3 && (but->flag & UI_SELECT)) {
+                               
+                               if( but->pointype==CHA ) {
+                                       if( BTST( *(but->poin+2), but->bitnr )) tog3= 1;
+                               }
+                               else if( but->pointype ==SHO ) {
+                                       short *sp= (short *)but->poin;
+                                       if( BTST( sp[1], but->bitnr )) tog3= 1;
+                               }
+                               
+                               ui_tog3_invert(but->x1,but->y1,but->x2,but->y2, tog3);
+                               if (tog3) glColor3ub(255, 255, 0);
                        }
-               }
-
-               /* tog3 button exception */
-               if(but->type==TOG3 && (but->flag & UI_SELECT)) {
-                       int ok= 0;
                        
-                       if( but->pointype==CHA ) {
-                               if( BTST( *(but->poin+2), but->bitnr )) ok= 1;
+                       /* text color, with pulldown item exception */
+                       if(tog3);       // color already set
+                       else if(but->dt==UI_EMBOSSP) {
+                               if((but->flag & (UI_SELECT|UI_ACTIVE)) && but->type!=LABEL) {   // LABEL = title in pulldowns
+                                       BIF_ThemeColor(TH_MENU_TEXT_HI);
+                               } else {
+                                       BIF_ThemeColor(TH_MENU_TEXT);
+                               }
                        }
-                       else if( but->pointype ==SHO ) {
-                               short *sp= (short *)but->poin;
-                               if( BTST( sp[1], but->bitnr )) ok= 1;
+                       else {
+                               if(but->flag & UI_SELECT) {             
+                                       BIF_ThemeColor(TH_BUT_TEXT_HI);
+                               } else {
+                                       BIF_ThemeColor(TH_BUT_TEXT);
+                               }
                        }
+
+                       /* LABEL button exception */
+                       if(but->type==LABEL && but->min!=0.0) BIF_ThemeColor(TH_BUT_TEXT_HI);
+               
+                       ui_rasterpos_safe(x, (but->y1+but->y2- 9.0)/2.0, but->aspect);
+                       if(but->type==IDPOIN) transopts= 0;     // no translation, of course!
+                       else transopts= (U.transopts & USER_TR_BUTTONS);
                        
-                       ui_tog3_invert(but->x1,but->y1,but->x2,but->y2, ok);
-                       if (ok) glColor3ub(255, 255, 0);
+               #ifdef INTERNATIONAL
+                       if (but->type == FTPREVIEW)
+                               FTF_DrawNewFontString (but->drawstr+but->ofs, FTF_INPUT_UTF8);
+                       else
+                               BIF_DrawString(but->font, but->drawstr+but->ofs, transopts);
+               #else
+                       BIF_DrawString(but->font, but->drawstr+but->ofs, transopts);
+               #endif
+
+                       /* part text right aligned */
+                       if(cpoin) {
+                               len= BIF_GetStringWidth(but->font, cpoin+1, (U.transopts & USER_TR_BUTTONS));
+                               ui_rasterpos_safe( but->x2 - len*but->aspect-3, (but->y1+but->y2- 9.0)/2.0, but->aspect);
+                               BIF_DrawString(but->font, cpoin+1, (U.transopts & USER_TR_BUTTONS));
+                               *cpoin= '|';
+                       }
                }
-               
-               /* LABEL button exception */
-               if(but->type==LABEL && but->min!=0.0) BIF_ThemeColor(TH_BUT_TEXT_HI);
-               
-               glRasterPos2f( 0.375+floor(x), 0.375+floor((but->y1+but->y2- 9.0)/2.0));
-               BIF_DrawString(but->font, but->drawstr+but->ofs, (U.transopts & USER_TR_BUTTONS));
-
-               /* part text right aligned */
-               if(cpoin) {
-                       len= BIF_GetStringWidth(but->font, cpoin+1, (U.transopts & USER_TR_BUTTONS));
-                       glRasterPos2f( but->x2 - len*but->aspect-3, (but->y1+but->y2- 9.0)/2.0);
-                       BIF_DrawString(but->font, cpoin+1, (U.transopts & USER_TR_BUTTONS));
-                       *cpoin= '|';
+               /* if there's no text label, then check to see if there's an icon only and draw it */
+               else if( but->flag & UI_HAS_ICON ) {
+                       ui_draw_icon(but, (BIFIconID) (but->icon+but->iconadd), 0);
                }
        }
-       /* if there's no text label, then check to see if there's an icon only and draw it */
-       else if( but->flag & UI_HAS_ICON ) {
-               ui_draw_icon(but, (BIFIconID) (but->icon+but->iconadd));
-       }
-
 }
 
 static void ui_draw_but_COL(uiBut *but)
@@ -1508,13 +1675,14 @@ static void ui_draw_but_COL(uiBut *but)
 static void ui_draw_but_HSVCUBE(uiBut *but)
 {
        int a;
-       float col[3], h,s,v;
+       float h,s,v;
        float dx, dy, sx1, sx2, sy, x, y;
        float col0[4][3];       // left half, rect bottom to top
        float col1[4][3];       // right half, rect bottom to top
        
-       ui_get_but_vectorf(but, col);
-       rgb_to_hsv(col[0], col[1], col[2], &h, &s, &v);
+       h= but->hsv[0];
+       s= but->hsv[1];
+       v= but->hsv[2];
        
        /* draw series of gouraud rects */
        glShadeModel(GL_SMOOTH);
@@ -1619,6 +1787,579 @@ static void ui_draw_but_HSVCUBE(uiBut *but)
        fdrawbox((but->x1), (but->y1), (but->x2), (but->y2));
 }
 
+#ifdef INTERNATIONAL
+static void ui_draw_but_CHARTAB(uiBut *but)
+{
+       /* Some local variables */
+       float sx, sy, ex, ey;
+       float width, height;
+       float butw, buth;
+       int x, y, cs;
+       wchar_t wstr[2];
+       unsigned char ustr[16];
+       PackedFile *pf;
+       int result = 0;
+       int charmax = G.charmax;
+       
+       /* <builtin> font in use. There are TTF <builtin> and non-TTF <builtin> fonts */
+       if(!strcmp(G.selfont->name, "<builtin>"))
+       {
+               if(G.ui_international == TRUE)
+               {
+                       charmax = 0xff;
+               }
+               else
+               {
+                       charmax = 0xff;
+               }
+       }
+
+       /* Category list exited without selecting the area */
+       if(G.charmax == 0)
+               charmax = G.charmax = 0xffff;
+
+       /* Calculate the size of the button */
+       width = abs(but->x2 - but->x1);
+       height = abs(but->y2 - but->y1);
+       
+       butw = floor(width / 12);
+       buth = floor(height / 6);
+       
+       /* Initialize variables */
+       sx = but->x1;
+       ex = but->x1 + butw;
+       sy = but->y1 + height - buth;
+       ey = but->y1 + height;
+
+       cs = G.charstart;
+
+       /* Set the font, in case it is not <builtin> font */
+       if(G.selfont && strcmp(G.selfont->name, "<builtin>"))
+       {
+               char tmpStr[256];
+
+               // Is the font file packed, if so then use the packed file
+               if(G.selfont->packedfile)
+               {
+                       pf = G.selfont->packedfile;             
+                       FTF_SetFont(pf->data, pf->size, 14.0);
+               }
+               else
+               {
+                       int err;
+
+                       strcpy(tmpStr, G.selfont->name);
+                       BLI_convertstringcode(tmpStr, G.sce);
+                       err = FTF_SetFont((unsigned char *)tmpStr, 0, 14.0);
+               }
+       }
+       else
+       {
+               if(G.ui_international == TRUE)
+               {
+                       FTF_SetFont((unsigned char *) datatoc_bfont_ttf, datatoc_bfont_ttf_size, 14.0);
+               }
+       }
+
+       /* Start drawing the button itself */
+       glShadeModel(GL_SMOOTH);
+
+       glColor3ub(200,  200,  200);
+       glRectf((but->x1), (but->y1), (but->x2), (but->y2));
+
+       glColor3ub(0,  0,  0);
+       for(y = 0; y < 6; y++)
+       {
+               // Do not draw more than the category allows
+               if(cs > charmax) break;
+
+               for(x = 0; x < 12; x++)
+               {
+                       // Do not draw more than the category allows
+                       if(cs > charmax) break;
+
+                       // Draw one grid cell
+                       glBegin(GL_LINE_LOOP);
+                               glVertex2f(sx, sy);
+                               glVertex2f(ex, sy);
+                               glVertex2f(ex, ey);
+                               glVertex2f(sx, ey);                             
+                       glEnd();        
+
+                       // Draw character inside the cell
+                       memset(wstr, 0, sizeof(wchar_t)*2);
+                       memset(ustr, 0, 16);
+
+                       // Set the font to be either unicode or <builtin>                               
+                       wstr[0] = cs;
+                       if(strcmp(G.selfont->name, "<builtin>"))
+                       {
+                               wcs2utf8s((char *)ustr, (wchar_t *)wstr);
+                       }
+                       else
+                       {
+                               if(G.ui_international == TRUE)
+                               {
+                                       wcs2utf8s((char *)ustr, (wchar_t *)wstr);
+                               }
+                               else
+                               {
+                                       ustr[0] = cs;
+                                       ustr[1] = 0;
+                               }
+                       }
+
+                       if((G.selfont && strcmp(G.selfont->name, "<builtin>")) || (G.selfont && !strcmp(G.selfont->name, "<builtin>") && G.ui_international == TRUE))
+                       {
+                               float wid;
+                               float llx, lly, llz, urx, ury, urz;
+                               float dx, dy;
+                               float px, py;
+       
+                               // Calculate the position
+                               wid = FTF_GetStringWidth((char *) ustr, FTF_USE_GETTEXT | FTF_INPUT_UTF8);
+                               FTF_GetBoundingBox((char *) ustr, &llx,&lly,&llz,&urx,&ury,&urz, FTF_USE_GETTEXT | FTF_INPUT_UTF8);
+                               dx = urx-llx;
+                               dy = ury-lly;
+
+                               // This isn't fully functional since the but->aspect isn't working like I suspected
+                               px = sx + ((butw/but->aspect)-dx)/2;
+                               py = sy + ((buth/but->aspect)-dy)/2;
+
+                               // Set the position and draw the character
+                               ui_rasterpos_safe(px, py, but->aspect);
+                               FTF_DrawString((char *) ustr, FTF_USE_GETTEXT | FTF_INPUT_UTF8);
+                       }
+                       else
+                       {
+                               ui_rasterpos_safe(sx + butw/2, sy + buth/2, but->aspect);
+                               BIF_DrawString(but->font, (char *) ustr, 0);
+                       }
+       
+                       // Calculate the next position and character
+                       sx += butw; ex +=butw;
+                       cs++;
+               }
+               /* Add the y position and reset x position */
+               sy -= buth; 
+               ey -= buth;
+               sx = but->x1;
+               ex = but->x1 + butw;
+       }       
+       glShadeModel(GL_FLAT);
+
+       /* Return Font Settings to original */
+       if(U.fontsize && U.fontname[0])
+       {
+               result = FTF_SetFont((unsigned char *)U.fontname, 0, U.fontsize);
+       }
+       else if (U.fontsize)
+       {
+               result = FTF_SetFont((unsigned char *) datatoc_bfont_ttf, datatoc_bfont_ttf_size, U.fontsize);
+       }
+
+       if (result == 0)
+       {
+               result = FTF_SetFont((unsigned char *) datatoc_bfont_ttf, datatoc_bfont_ttf_size, 11);
+       }
+       
+       /* resets the font size */
+       if(G.ui_international == TRUE)
+       {
+               uiSetCurFont(but->block, UI_HELV);
+       }
+}
+
+#endif // INTERNATIONAL
+
+static void ui_draw_but_COLORBAND(uiBut *but)
+{
+       ColorBand *coba= (ColorBand *)but->poin;
+       CBData *cbd;
+       float x1, y1, sizex, sizey;
+       float dx, v3[2], v1[2], v2[2], v1a[2], v2a[2];
+       int a;
+               
+       if(coba==NULL) return;
+       
+       x1= but->x1;
+       y1= but->y1;
+       sizex= but->x2-x1;
+       sizey= but->y2-y1;
+       
+       /* first background, to show tranparency */
+       dx= sizex/12.0;
+       v1[0]= x1;
+       for(a=0; a<12; a++) {
+               if(a & 1) glColor3f(0.3, 0.3, 0.3); else glColor3f(0.8, 0.8, 0.8);
+               glRectf(v1[0], y1, v1[0]+dx, y1+0.5*sizey);
+               if(a & 1) glColor3f(0.8, 0.8, 0.8); else glColor3f(0.3, 0.3, 0.3);
+               glRectf(v1[0], y1+0.5*sizey, v1[0]+dx, y1+sizey);
+               v1[0]+= dx;
+       }
+       
+       glShadeModel(GL_SMOOTH);
+       glEnable(GL_BLEND);
+       
+       cbd= coba->data;
+       
+       v1[0]= v2[0]= x1;
+       v1[1]= y1;
+       v2[1]= y1+sizey;
+       
+       glBegin(GL_QUAD_STRIP);
+       
+       glColor4fv( &cbd->r );
+       glVertex2fv(v1); glVertex2fv(v2);
+       
+       for(a=0; a<coba->tot; a++, cbd++) {
+               
+               v1[0]=v2[0]= x1+ cbd->pos*sizex;
+               
+               glColor4fv( &cbd->r );
+               glVertex2fv(v1); glVertex2fv(v2);
+       }
+       
+       v1[0]=v2[0]= x1+ sizex;
+       glVertex2fv(v1); glVertex2fv(v2);
+       
+       glEnd();
+       glShadeModel(GL_FLAT);
+       glDisable(GL_BLEND);
+       
+       /* outline */
+       v1[0]= x1; v1[1]= y1;
+       
+       cpack(0x0);
+       glBegin(GL_LINE_LOOP);
+       glVertex2fv(v1);
+       v1[0]+= sizex;
+       glVertex2fv(v1);
+       v1[1]+= sizey;
+       glVertex2fv(v1);
+       v1[0]-= sizex;
+       glVertex2fv(v1);
+       glEnd();
+       
+       
+       /* help lines */
+       v1[0]= v2[0]=v3[0]= x1;
+       v1[1]= y1;
+       v1a[1]= y1+0.25*sizey;
+       v2[1]= y1+0.5*sizey;
+       v2a[1]= y1+0.75*sizey;
+       v3[1]= y1+sizey;
+       
+       
+       cbd= coba->data;
+       glBegin(GL_LINES);
+       for(a=0; a<coba->tot; a++, cbd++) {
+               v1[0]=v2[0]=v3[0]=v1a[0]=v2a[0]= x1+ cbd->pos*sizex;
+               
+               if(a==coba->cur) {
+                       glColor3ub(0, 0, 0);
+                       glVertex2fv(v1);
+                       glVertex2fv(v3);
+                       glEnd();
+                       
+                       setlinestyle(2);
+                       glBegin(GL_LINES);
+                       glColor3ub(255, 255, 255);
+                       glVertex2fv(v1);
+                       glVertex2fv(v3);
+                       glEnd();
+                       setlinestyle(0);
+                       glBegin(GL_LINES);
+                       
+                       /* glColor3ub(0, 0, 0);
+                       glVertex2fv(v1);
+                       glVertex2fv(v1a);
+                       glColor3ub(255, 255, 255);
+                       glVertex2fv(v1a);
+                       glVertex2fv(v2);
+                       glColor3ub(0, 0, 0);
+                       glVertex2fv(v2);
+                       glVertex2fv(v2a);
+                       glColor3ub(255, 255, 255);
+                       glVertex2fv(v2a);
+                       glVertex2fv(v3);
+                       */
+               }
+               else {
+                       glColor3ub(0, 0, 0);
+                       glVertex2fv(v1);
+                       glVertex2fv(v2);
+                       
+                       glColor3ub(255, 255, 255);
+                       glVertex2fv(v2);
+                       glVertex2fv(v3);
+               }       
+       }
+       glEnd();
+}
+
+static void ui_draw_but_NORMAL(uiBut *but)
+{
+       static GLuint displist=0;
+       int a, old[8];
+       GLfloat diff[4], diffn[4]={1.0f, 1.0f, 1.0f, 1.0f};
+       float vec0[4]={0.0f, 0.0f, 0.0f, 0.0f};
+       float dir[4], size;
+       
+       /* store stuff */
+       glGetMaterialfv(GL_FRONT, GL_DIFFUSE, diff);
+               
+       /* backdrop */
+       BIF_ThemeColor(TH_BUT_NEUTRAL);
+       uiSetRoundBox(15);
+       gl_round_box(GL_POLYGON, but->x1, but->y1, but->x2, but->y2, 5.0f);
+       
+       /* sphere color */
+       glMaterialfv(GL_FRONT, GL_DIFFUSE, diffn);
+       glCullFace(GL_BACK); glEnable(GL_CULL_FACE);
+       
+       /* disable blender light */
+       for(a=0; a<8; a++) {
+               old[a]= glIsEnabled(GL_LIGHT0+a);
+               glDisable(GL_LIGHT0+a);
+       }
+       
+       /* own light */
+       glEnable(GL_LIGHT7);
+       glEnable(GL_LIGHTING);
+       
+       VECCOPY(dir, (float *)but->poin);
+       dir[3]= 0.0f;   /* glLight needs 4 args, 0.0 is sun */
+       glLightfv(GL_LIGHT7, GL_POSITION, dir); 
+       glLightfv(GL_LIGHT7, GL_DIFFUSE, diffn); 
+       glLightfv(GL_LIGHT7, GL_SPECULAR, vec0); 
+       glLightf(GL_LIGHT7, GL_CONSTANT_ATTENUATION, 1.0f);
+       glLightf(GL_LIGHT7, GL_LINEAR_ATTENUATION, 0.0f);
+       
+       /* transform to button */
+       glPushMatrix();
+       glTranslatef(but->x1 + 0.5f*(but->x2-but->x1), but->y1+ 0.5f*(but->y2-but->y1), 0.0f);
+       size= (but->x2-but->x1)/200.f;
+       glScalef(size, size, size);
+                        
+       if(displist==0) {
+               GLUquadricObj   *qobj;
+               
+               displist= glGenLists(1);
+               glNewList(displist, GL_COMPILE_AND_EXECUTE);
+               
+               qobj= gluNewQuadric();
+               gluQuadricDrawStyle(qobj, GLU_FILL); 
+               glShadeModel(GL_SMOOTH);
+               gluSphere( qobj, 100.0, 32, 24);
+               glShadeModel(GL_FLAT);
+               gluDeleteQuadric(qobj);  
+               
+               glEndList();
+       }
+       else glCallList(displist);
+       
+       /* restore */
+       glPopMatrix();
+       glDisable(GL_LIGHTING);
+       glDisable(GL_CULL_FACE);
+       glMaterialfv(GL_FRONT, GL_DIFFUSE, diff); 
+       
+       glDisable(GL_LIGHT7);
+       
+       /* enable blender light */
+       for(a=0; a<8; a++) {
+               if(old[a])
+                       glEnable(GL_LIGHT0+a);
+       }
+}
+
+static void ui_draw_but_curve_grid(uiBut *but, float zoomx, float zoomy, float offsx, float offsy, float step)
+{
+       float dx, dy, fx, fy;
+       
+       glBegin(GL_LINES);
+       dx= step*zoomx;
+       fx= but->x1 + zoomx*(-offsx);
+       if(fx > but->x1) fx -= dx*( floor(fx-but->x1));
+       while(fx < but->x2) {
+               glVertex2f(fx, but->y1); 
+               glVertex2f(fx, but->y2);
+               fx+= dx;
+       }
+       
+       dy= step*zoomy;
+       fy= but->y1 + zoomy*(-offsy);
+       if(fy > but->y1) fy -= dy*( floor(fy-but->y1));
+       while(fy < but->y2) {
+               glVertex2f(but->x1, fy); 
+               glVertex2f(but->x2, fy);
+               fy+= dy;
+       }
+       glEnd();
+       
+}
+
+static void ui_draw_but_CURVE(uiBut *but)
+{
+       CurveMapping *cumap= (CurveMapping *)but->poin;
+       CurveMap *cuma= cumap->cm+cumap->cur;
+       CurveMapPoint *cmp;
+       float fx, fy, dx, dy, fac[2], zoomx, zoomy, offsx, offsy;
+       GLint scissor[4];
+       int a;
+       
+       /* need scissor test, curve can draw outside of boundary */
+       glGetIntegerv(GL_VIEWPORT, scissor);
+       fx= but->x1; fy= but->y1;
+       ui_graphics_to_window(but->win, &fx, &fy);
+       dx= but->x2; dy= but->y2;
+       ui_graphics_to_window(but->win, &dx, &dy);
+       glScissor((int)floor(fx), (int)floor(fy), (int)ceil(dx-fx), (int)ceil(dy-fy));
+       
+       /* calculate offset and zoom */
+       zoomx= (but->x2-but->x1-2.0*but->aspect)/(cumap->curr.xmax - cumap->curr.xmin);
+       zoomy= (but->y2-but->y1-2.0*but->aspect)/(cumap->curr.ymax - cumap->curr.ymin);
+       offsx= cumap->curr.xmin-but->aspect/zoomx;
+       offsy= cumap->curr.ymin-but->aspect/zoomy;
+       
+       /* backdrop */
+       if(cumap->flag & CUMA_DO_CLIP) {
+               BIF_ThemeColorShade(TH_BUT_NEUTRAL, -20);
+               glRectf(but->x1, but->y1, but->x2, but->y2);
+               BIF_ThemeColor(TH_BUT_NEUTRAL);
+               glRectf(but->x1 + zoomx*(cumap->clipr.xmin-offsx),
+                               but->y1 + zoomy*(cumap->clipr.ymin-offsy),
+                               but->x1 + zoomx*(cumap->clipr.xmax-offsx),
+                               but->y1 + zoomy*(cumap->clipr.ymax-offsy));
+       }
+       else {
+               BIF_ThemeColor(TH_BUT_NEUTRAL);
+               glRectf(but->x1, but->y1, but->x2, but->y2);
+       }
+       
+       /* grid, every .25 step */
+       BIF_ThemeColorShade(TH_BUT_NEUTRAL, -16);
+       ui_draw_but_curve_grid(but, zoomx, zoomy, offsx, offsy, 0.25f);
+       /* grid, every 1.0 step */
+       BIF_ThemeColorShade(TH_BUT_NEUTRAL, -24);
+       ui_draw_but_curve_grid(but, zoomx, zoomy, offsx, offsy, 1.0f);
+       /* axes */
+       BIF_ThemeColorShade(TH_BUT_NEUTRAL, -50);
+       glBegin(GL_LINES);
+       glVertex2f(but->x1, but->y1 + zoomy*(-offsy));
+       glVertex2f(but->x2, but->y1 + zoomy*(-offsy));
+       glVertex2f(but->x1 + zoomx*(-offsx), but->y1);
+       glVertex2f(but->x1 + zoomx*(-offsx), but->y2);
+       glEnd();
+       
+       /* cfra option */
+       if(cumap->flag & CUMA_DRAW_CFRA) {
+               glColor3ub(0x60, 0xc0, 0x40);
+               glBegin(GL_LINES);
+               glVertex2f(but->x1 + zoomx*(cumap->sample[0]-offsx), but->y1);
+               glVertex2f(but->x1 + zoomx*(cumap->sample[0]-offsx), but->y2);
+               glEnd();
+       }
+       /* sample option */
+       if(cumap->flag & CUMA_DRAW_SAMPLE) {
+               if(cumap->cur==3) {
+                       float lum= cumap->sample[0]*0.35f + cumap->sample[1]*0.45f + cumap->sample[2]*0.2f;
+                       glColor3ub(240, 240, 240);
+                       
+                       glBegin(GL_LINES);
+                       glVertex2f(but->x1 + zoomx*(lum-offsx), but->y1);
+                       glVertex2f(but->x1 + zoomx*(lum-offsx), but->y2);
+                       glEnd();
+               }
+               else {
+                       if(cumap->cur==0)
+                               glColor3ub(240, 100, 100);
+                       else if(cumap->cur==1)
+                               glColor3ub(100, 240, 100);
+                       else
+                               glColor3ub(100, 100, 240);
+                       
+                       glBegin(GL_LINES);
+                       glVertex2f(but->x1 + zoomx*(cumap->sample[cumap->cur]-offsx), but->y1);
+                       glVertex2f(but->x1 + zoomx*(cumap->sample[cumap->cur]-offsx), but->y2);
+                       glEnd();
+               }
+       }
+       
+       /* the curve */
+       BIF_ThemeColorBlend(TH_TEXT, TH_BUT_NEUTRAL, 0.35);
+       glEnable(GL_LINE_SMOOTH);
+       glEnable(GL_BLEND);
+       glBegin(GL_LINE_STRIP);
+       
+       if(cuma->table==NULL)
+               curvemapping_changed(cumap, 0); /* 0 = no remove doubles */
+       cmp= cuma->table;
+       
+       /* first point */
+       if((cuma->flag & CUMA_EXTEND_EXTRAPOLATE)==0)
+               glVertex2f(but->x1, but->y1 + zoomy*(cmp[0].y-offsy));
+       else {
+               fx= but->x1 + zoomx*(cmp[0].x-offsx + cuma->ext_in[0]);
+               fy= but->y1 + zoomy*(cmp[0].y-offsy + cuma->ext_in[1]);
+               glVertex2f(fx, fy);
+       }
+       for(a=0; a<=CM_TABLE; a++) {
+               fx= but->x1 + zoomx*(cmp[a].x-offsx);
+               fy= but->y1 + zoomy*(cmp[a].y-offsy);
+               glVertex2f(fx, fy);
+       }
+       /* last point */
+       if((cuma->flag & CUMA_EXTEND_EXTRAPOLATE)==0)
+               glVertex2f(but->x2, but->y1 + zoomy*(cmp[CM_TABLE].y-offsy));   
+       else {
+               fx= but->x1 + zoomx*(cmp[CM_TABLE].x-offsx - cuma->ext_out[0]);
+               fy= but->y1 + zoomy*(cmp[CM_TABLE].y-offsy - cuma->ext_out[1]);
+               glVertex2f(fx, fy);
+       }
+       glEnd();
+       glDisable(GL_LINE_SMOOTH);
+       glDisable(GL_BLEND);
+
+       /* the points, use aspect to make them visible on edges */
+       cmp= cuma->curve;
+       glPointSize(3.0f);
+       bglBegin(GL_POINTS);
+       for(a=0; a<cuma->totpoint; a++) {
+               if(cmp[a].flag & SELECT)
+                       BIF_ThemeColor(TH_TEXT_HI);
+               else
+                       BIF_ThemeColor(TH_TEXT);
+               fac[0]= but->x1 + zoomx*(cmp[a].x-offsx);
+               fac[1]= but->y1 + zoomy*(cmp[a].y-offsy);
+               bglVertex2fv(fac);
+       }
+       bglEnd();
+       glPointSize(1.0f);
+       
+       /* restore scissortest */
+       glScissor(scissor[0], scissor[1], scissor[2], scissor[3]);
+
+       /* outline */
+       BIF_ThemeColor(TH_BUT_OUTLINE);
+       fdrawbox(but->x1, but->y1, but->x2, but->y2);
+
+}
+
+static void ui_draw_roundbox(uiBut *but)
+{
+       glEnable(GL_BLEND);
+       
+       BIF_ThemeColorShadeAlpha(TH_PANEL, but->a2, but->a2);
+
+       uiSetRoundBox(but->a1);
+       gl_round_box(GL_POLYGON, but->x1, but->y1, but->x2, but->y2, but->min);
+
+       glDisable(GL_BLEND);
+}
+
+
 /* nothing! */
 static void ui_draw_nothing(int type, int colorid, float asp, float x1, float y1, float x2, float y2, int flag)
 {
@@ -1630,53 +2371,54 @@ static void ui_draw_nothing(int type, int colorid, float asp, float x1, float y1
 
 void ui_set_embossfunc(uiBut *but, int drawtype)
 {
-
+       // this aded for evaluating textcolor for example
+       but->dt= drawtype;
+       
        // not really part of standard minimal themes, just make sure it is set
        but->sliderfunc= ui_draw_slider;
 
        // standard builtin first:
-       if(but->type==LABEL) but->embossfunc= ui_draw_nothing;
+       if(but->type==LABEL || but->type==ROUNDBOX) but->embossfunc= ui_draw_nothing;
+       else if(but->type==PULLDOWN) but->embossfunc= ui_draw_pulldown_round;
        else if(drawtype==UI_EMBOSSM) but->embossfunc= ui_draw_minimal;
        else if(drawtype==UI_EMBOSSN) but->embossfunc= ui_draw_nothing;
-       else if(drawtype==UI_EMBOSSP) but->embossfunc= ui_draw_pulldown;
+       else if(drawtype==UI_EMBOSSP) but->embossfunc= ui_draw_pulldown_item;
+       else if(drawtype==UI_EMBOSSR) but->embossfunc= ui_draw_round;
        else {
                int theme= BIF_GetThemeValue(TH_BUT_DRAWTYPE);
                
-               // and the themes
-               if(theme==1) {
-                       but->embossfunc= ui_draw_default;
-                       but->sliderfunc= ui_default_slider;
-               }
-               else if(theme==2) {
+               switch(theme) {
+               
+               case TH_ROUNDED:
                        but->embossfunc= ui_draw_round;
-               }
-               else if(theme==3) {
+                       break;
+               case TH_OLDSKOOL:
                        but->embossfunc= ui_draw_oldskool;
-               }
-               else {
+                       break;
+               case TH_MINIMAL:
                        but->embossfunc= ui_draw_minimal;
+                       break;
+               case TH_SHADED:
+               default:
+                       but->embossfunc= ui_draw_default;
+                       but->sliderfunc= ui_default_slider;
+                       break;
                }
        }
        
        // note: if you want aligning, adapt the call uiBlockEndAlign in interface.c 
 }
 
-
 void ui_draw_but(uiBut *but)
 {
        double value;
        float x1, x2, y1, y2, fac;
        
-       if(but==0) return;
+       if(but==NULL) return;
 
-       if(but->block->frontbuf==UI_NEED_DRAW_FRONT) {
-               but->block->frontbuf= UI_HAS_DRAW_FRONT;
-       
-               glDrawBuffer(GL_FRONT);
-               if(but->win==curarea->headwin) curarea->head_swap= WIN_FRONT_OK;
-               else curarea->win_swap= WIN_FRONT_OK;
-       }
-       
+       /* signal for frontbuf flush buttons and menus, not when normal drawing */
+       if(but->block->in_use) ui_block_set_flush(but->block, but);
+               
        switch (but->type) {
 
        case NUMSLI:
@@ -1708,11 +2450,32 @@ void ui_draw_but(uiBut *but)
                ui_draw_but_HSVCUBE(but);  // box for colorpicker, three types
                break;
 
+#ifdef INTERNATIONAL
+       case CHARTAB:
+               value= ui_get_but_val(but);
+               ui_draw_but_CHARTAB(but);
+               break;
+#endif
+
        case LINK:
        case INLINK:
-               ui_draw_icon(but, but->icon);
+               ui_draw_icon(but, but->icon, 0);
                break;
-
+               
+       case ROUNDBOX:
+               ui_draw_roundbox(but);
+               break;
+               
+       case BUT_COLORBAND:
+               ui_draw_but_COLORBAND(but);
+               break;
+       case BUT_NORMAL:
+               ui_draw_but_NORMAL(but);
+               break;
+       case BUT_CURVE:
+               ui_draw_but_CURVE(but);
+               break;
+               
        default:
                but->embossfunc(but->type, but->themecol, but->aspect, but->x1, but->y1, but->x2, but->y2, but->flag);
                ui_draw_text_icon(but);
@@ -1720,3 +2483,33 @@ void ui_draw_but(uiBut *but)
        }
 }
 
+void ui_dropshadow(rctf *rct, float radius, float aspect, int select)
+{
+       float rad;
+       float a;
+       char alpha= 2;
+       
+       glEnable(GL_BLEND);
+       
+       if(radius > (rct->ymax-rct->ymin-10.0f)/2.0f)
+               rad= (rct->ymax-rct->ymin-10.0f)/2.0f;
+       else
+               rad= radius;
+       
+       if(select) a= 12.0f*aspect; else a= 12.0f*aspect;
+       for(; a>0.0f; a-=aspect) {
+               /* alpha ranges from 2 to 20 or so */
+               glColor4ub(0, 0, 0, alpha);
+               alpha+= 2;
+               
+               gl_round_box(GL_POLYGON, rct->xmin - a, rct->ymin - a, rct->xmax + a, rct->ymax-10.0f + a, rad+a);
+       }
+       
+       /* outline emphasis */
+       glEnable( GL_LINE_SMOOTH );
+       glColor4ub(0, 0, 0, 100);
+       gl_round_box(GL_LINE_LOOP, rct->xmin-0.5f, rct->ymin-0.5f, rct->xmax+0.5f, rct->ymax+0.5f, radius);
+       glDisable( GL_LINE_SMOOTH );
+       
+       glDisable(GL_BLEND);
+}