- UNUSED macro wasn't throwing an error with GCC if a var become used.
[blender.git] / source / blender / editors / interface / interface_draw.c
index 8be2084ab01c4007a612a0065df9cf6772b57b32..855ca45f61a44c86b00427d294b4930c76c876a6 100644 (file)
@@ -1,5 +1,5 @@
 /**
- * $Id: interface_draw.c 15733 2008-07-24 09:23:13Z aligorith $
+ * $Id$
  *
  * ***** BEGIN GPL LICENSE BLOCK *****
  *
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software Foundation,
- * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  *
  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
  * All rights reserved.
  *
- * The Original Code is: all of this file.
- *
- * Contributor(s): none yet.
+ * Contributor(s): Blender Foundation
  *
  * ***** END GPL LICENSE BLOCK *****
  */
 #include <string.h>
 
 #include "DNA_color_types.h"
-#include "DNA_listBase.h"
 #include "DNA_object_types.h"
 #include "DNA_screen_types.h"
-#include "DNA_texture_types.h"
-#include "DNA_userdef_types.h"
 
-#include "BLI_arithb.h"
+#include "BLI_math.h"
 
 #include "BKE_colortools.h"
 #include "BKE_texture.h"
 #include "BKE_utildefines.h"
 
+#include "IMB_imbuf.h"
+#include "IMB_imbuf_types.h"
+
 #include "BIF_gl.h"
 #include "BIF_glutil.h"
 
+#include "BLF_api.h"
+
 #include "UI_interface.h"
-#include "UI_interface_icons.h"
 
+/* own include */
 #include "interface_intern.h"
 
 #define UI_RB_ALPHA 16
@@ -77,10 +77,10 @@ int uiGetRoundBox(void)
        return roundboxtype;
 }
 
-void gl_round_box(int mode, float minx, float miny, float maxx, float maxy, float rad)
+void uiDrawBox(int mode, float minx, float miny, float maxx, float maxy, float rad)
 {
        float vec[7][2]= {{0.195, 0.02}, {0.383, 0.067}, {0.55, 0.169}, {0.707, 0.293},
-                         {0.831, 0.45}, {0.924, 0.617}, {0.98, 0.805}};
+                                         {0.831, 0.45}, {0.924, 0.617}, {0.98, 0.805}};
        int a;
        
        /* mult */
@@ -147,10 +147,10 @@ static void round_box_shade_col(float *col1, float *col2, float fac)
 
 /* linear horizontal shade within button or in outline */
 /* view2d scrollers use it */
-void gl_round_box_shade(int mode, float minx, float miny, float maxx, float maxy, float rad, float shadetop, float shadedown)
+void uiDrawBoxShade(int mode, float minx, float miny, float maxx, float maxy, float rad, float shadetop, float shadedown)
 {
        float vec[7][2]= {{0.195, 0.02}, {0.383, 0.067}, {0.55, 0.169}, {0.707, 0.293},
-                         {0.831, 0.45}, {0.924, 0.617}, {0.98, 0.805}};
+                                         {0.831, 0.45}, {0.924, 0.617}, {0.98, 0.805}};
        float div= maxy-miny;
        float coltop[3], coldown[3], color[4];
        int a;
@@ -254,10 +254,10 @@ void gl_round_box_shade(int mode, float minx, float miny, float maxx, float maxy
 
 /* linear vertical shade within button or in outline */
 /* view2d scrollers use it */
-void gl_round_box_vertical_shade(int mode, float minx, float miny, float maxx, float maxy, float rad, float shadeLeft, float shadeRight)
+void uiDrawBoxVerticalShade(int mode, float minx, float miny, float maxx, float maxy, float rad, float shadeLeft, float shadeRight)
 {
        float vec[7][2]= {{0.195, 0.02}, {0.383, 0.067}, {0.55, 0.169}, {0.707, 0.293},
-                         {0.831, 0.45}, {0.924, 0.617}, {0.98, 0.805}};
+                                         {0.831, 0.45}, {0.924, 0.617}, {0.98, 0.805}};
        float div= maxx-minx;
        float colLeft[3], colRight[3], color[4];
        int a;
@@ -372,7 +372,7 @@ void uiRoundRect(float minx, float miny, float maxx, float maxy, float rad)
        glEnable( GL_LINE_SMOOTH );
        glEnable( GL_BLEND );
 
-       gl_round_box(GL_LINE_LOOP, minx, miny, maxx, maxy, rad);
+       uiDrawBox(GL_LINE_LOOP, minx, miny, maxx, maxy, rad);
    
        glDisable( GL_BLEND );
        glDisable( GL_LINE_SMOOTH );
@@ -398,7 +398,7 @@ void uiRoundRectFakeAA(float minx, float miny, float maxx, float maxy, float rad
        
        /* draw lots of lines on top of each other */
        for (i=passes; i>=(-passes); i--) {
-               gl_round_box(GL_LINE_LOOP, minx, miny, maxx, maxy, rad+(i*raddiff));
+               uiDrawBox(GL_LINE_LOOP, minx, miny, maxx, maxy, rad+(i*raddiff));
        }
        
        glDisable( GL_BLEND );
@@ -420,13 +420,13 @@ void uiRoundBox(float minx, float miny, float maxx, float maxy, float rad)
        }
        
        /* solid part */
-       gl_round_box(GL_POLYGON, minx, miny, maxx, maxy, rad);
+       uiDrawBox(GL_POLYGON, minx, miny, maxx, maxy, rad);
        
        /* set antialias line */
        glEnable( GL_LINE_SMOOTH );
        glEnable( GL_BLEND );
        
-       gl_round_box(GL_LINE_LOOP, minx, miny, maxx, maxy, rad);
+       uiDrawBox(GL_LINE_LOOP, minx, miny, maxx, maxy, rad);
        
        glDisable( GL_BLEND );
        glDisable( GL_LINE_SMOOTH );
@@ -458,8 +458,47 @@ void uiEmboss(float x1, float y1, float x2, float y2, int sel)
        
 }
 
-/* ************** TEXT AND ICON DRAWING FUNCTIONS ************* */
+/* ************** SPECIAL BUTTON DRAWING FUNCTIONS ************* */
 
+void ui_draw_but_IMAGE(ARegion *UNUSED(ar), uiBut *UNUSED(but), uiWidgetColors *UNUSED(wcol), rcti *rect)
+{
+       extern char datatoc_splash_png[];
+       extern int datatoc_splash_png_size;
+       ImBuf *ibuf;
+       //GLint scissor[4];
+       //int w, h;
+       
+       /* hardcoded to splash, loading and freeing every draw, eek! */
+       ibuf= IMB_ibImageFromMemory((unsigned char*)datatoc_splash_png, datatoc_splash_png_size, IB_rect);
+
+       if (!ibuf) return;
+       
+       /* scissor doesn't seem to be doing the right thing...?
+       //glColor4f(1.0, 0.f, 0.f, 1.f);
+       //fdrawbox(rect->xmin, rect->ymin, rect->xmax, rect->ymax)
+
+       w = (rect->xmax - rect->xmin);
+       h = (rect->ymax - rect->ymin);
+       // prevent drawing outside widget area
+       glGetIntegerv(GL_SCISSOR_BOX, scissor);
+       glScissor(ar->winrct.xmin + rect->xmin, ar->winrct.ymin + rect->ymin, w, h);
+       */
+       
+       glEnable(GL_BLEND);
+       glColor4f(0.0, 0.0, 0.0, 0.0);
+       
+       glaDrawPixelsSafe((float)rect->xmin, (float)rect->ymin, ibuf->x, ibuf->y, ibuf->x, GL_RGBA, GL_UNSIGNED_BYTE, ibuf->rect);
+       //glaDrawPixelsTex((float)rect->xmin, (float)rect->ymin, ibuf->x, ibuf->y, GL_UNSIGNED_BYTE, ibuf->rect);
+       
+       glDisable(GL_BLEND);
+       
+       /* 
+       // restore scissortest
+       glScissor(scissor[0], scissor[1], scissor[2], scissor[3]);
+       */
+       
+       IMB_freeImBuf(ibuf);
+}
 
 #if 0
 #ifdef INTERNATIONAL
@@ -525,7 +564,7 @@ static void ui_draw_but_CHARTAB(uiBut *but)
                        int err;
 
                        strcpy(tmpStr, G.selfont->name);
-                       BLI_convertstringcode(tmpStr, G.sce);
+                       BLI_path_abs(tmpStr, G.sce);
                        err = FTF_SetFont((unsigned char *)tmpStr, 0, 14.0);
                }
        }
@@ -649,13 +688,431 @@ static void ui_draw_but_CHARTAB(uiBut *but)
 #endif // INTERNATIONAL
 #endif
 
-void ui_draw_but_COLORBAND(uiBut *but, uiWidgetColors *wcol, rcti *rect)
+static void draw_scope_end(rctf *rect, GLint *scissor)
+{
+       float scaler_x1, scaler_x2;
+       
+       /* restore scissortest */
+       glScissor(scissor[0], scissor[1], scissor[2], scissor[3]);
+       
+       glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
+       
+       /* scale widget */
+       scaler_x1 = rect->xmin + (rect->xmax - rect->xmin)/2 - SCOPE_RESIZE_PAD;
+       scaler_x2 = rect->xmin + (rect->xmax - rect->xmin)/2 + SCOPE_RESIZE_PAD;
+       
+       glColor4f(0.f, 0.f, 0.f, 0.25f);
+       fdrawline(scaler_x1, rect->ymin-4, scaler_x2, rect->ymin-4);
+       fdrawline(scaler_x1, rect->ymin-7, scaler_x2, rect->ymin-7);
+       glColor4f(1.f, 1.f, 1.f, 0.25f);
+       fdrawline(scaler_x1, rect->ymin-5, scaler_x2, rect->ymin-5);
+       fdrawline(scaler_x1, rect->ymin-8, scaler_x2, rect->ymin-8);
+       
+       /* outline */
+       glColor4f(0.f, 0.f, 0.f, 0.5f);
+       uiSetRoundBox(15);
+       uiDrawBox(GL_LINE_LOOP, rect->xmin-1, rect->ymin, rect->xmax+1, rect->ymax+1, 3.0f);
+}
+
+void histogram_draw_one(float r, float g, float b, float alpha, float x, float y, float w, float h, float *data, int res)
+{
+       int i;
+       
+       /* under the curve */
+       glBlendFunc(GL_SRC_ALPHA, GL_ONE);
+       glColor4f(r, g, b, alpha);
+       
+       glShadeModel(GL_FLAT);
+       glBegin(GL_QUAD_STRIP);
+       glVertex2f(x, y);
+       glVertex2f(x, y + (data[0]*h));
+       for (i=1; i < res; i++) {
+               float x2 = x + i * (w/(float)res);
+               glVertex2f(x2, y + (data[i]*h));
+               glVertex2f(x2, y);
+       }
+       glEnd();
+       
+       /* curve outline */
+       glColor4f(0.f, 0.f, 0.f, 0.25f);
+       
+       glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+       glEnable(GL_LINE_SMOOTH);
+       glBegin(GL_LINE_STRIP);
+       for (i=0; i < res; i++) {
+               float x2 = x + i * (w/(float)res);
+               glVertex2f(x2, y + (data[i]*h));
+       }
+       glEnd();
+       glDisable(GL_LINE_SMOOTH);
+}
+
+void ui_draw_but_HISTOGRAM(ARegion *ar, uiBut *but, uiWidgetColors *UNUSED(wcol), rcti *recti)
+{
+       Histogram *hist = (Histogram *)but->poin;
+       int res = hist->x_resolution;
+       rctf rect;
+       int i;
+       float w, h;
+       //float alpha;
+       GLint scissor[4];
+       
+       if (hist==NULL) { printf("hist is null \n"); return; }
+       
+       rect.xmin = (float)recti->xmin+1;
+       rect.xmax = (float)recti->xmax-1;
+       rect.ymin = (float)recti->ymin+SCOPE_RESIZE_PAD+2;
+       rect.ymax = (float)recti->ymax-1;
+       
+       w = rect.xmax - rect.xmin;
+       h = (rect.ymax - rect.ymin) * hist->ymax;
+       
+       glEnable(GL_BLEND);
+       glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
+       
+       glColor4f(0.f, 0.f, 0.f, 0.3f);
+       uiSetRoundBox(15);
+       uiDrawBox(GL_POLYGON, rect.xmin-1, rect.ymin-1, rect.xmax+1, rect.ymax+1, 3.0f);
+       
+       glColor4f(1.f, 1.f, 1.f, 0.08f);
+       /* draw grid lines here */
+       for (i=1; i<4; i++) {
+               fdrawline(rect.xmin, rect.ymin+(i/4.f)*h, rect.xmax, rect.ymin+(i/4.f)*h);
+               fdrawline(rect.xmin+(i/4.f)*w, rect.ymin, rect.xmin+(i/4.f)*w, rect.ymax);
+       }
+       
+       /* need scissor test, histogram can draw outside of boundary */
+       glGetIntegerv(GL_VIEWPORT, scissor);
+       glScissor(ar->winrct.xmin + (rect.xmin-1), ar->winrct.ymin+(rect.ymin-1), (rect.xmax+1)-(rect.xmin-1), (rect.ymax+1)-(rect.ymin-1));
+       
+       if (hist->mode == HISTO_MODE_LUMA)
+               histogram_draw_one(1.0, 1.0, 1.0, 0.75, rect.xmin, rect.ymin, w, h, hist->data_luma, res);
+       else {
+               if (hist->mode == HISTO_MODE_RGB || hist->mode == HISTO_MODE_R)
+                       histogram_draw_one(1.0, 0.0, 0.0, 0.75, rect.xmin, rect.ymin, w, h, hist->data_r, res);
+               if (hist->mode == HISTO_MODE_RGB || hist->mode == HISTO_MODE_G)
+                       histogram_draw_one(0.0, 1.0, 0.0, 0.75, rect.xmin, rect.ymin, w, h, hist->data_g, res);
+               if (hist->mode == HISTO_MODE_RGB || hist->mode == HISTO_MODE_B)
+                       histogram_draw_one(0.0, 0.0, 1.0, 0.75, rect.xmin, rect.ymin, w, h, hist->data_b, res);
+       }
+       
+       /* outline, scale gripper */
+       draw_scope_end(&rect, scissor);
+}
+
+void ui_draw_but_WAVEFORM(ARegion *ar, uiBut *but, uiWidgetColors *UNUSED(wcol), rcti *recti)
+{
+       Scopes *scopes = (Scopes *)but->poin;
+       rctf rect;
+       int i, c;
+       float w, w3, h, alpha, yofs;
+       GLint scissor[4];
+       float colors[3][3] = {{1,0,0},{0,1,0},{0,0,1}};
+       float colorsycc[3][3] = {{1,0,1},{1,1,0},{0,1,1}};
+       float colors_alpha[3][3], colorsycc_alpha[3][3]; /* colors  pre multiplied by alpha for speed up */
+       float min, max;
+       
+       if (scopes==NULL) return;
+       
+       rect.xmin = (float)recti->xmin+1;
+       rect.xmax = (float)recti->xmax-1;
+       rect.ymin = (float)recti->ymin+SCOPE_RESIZE_PAD+2;
+       rect.ymax = (float)recti->ymax-1;
+       
+       if (scopes->wavefrm_yfac < 0.5f )
+               scopes->wavefrm_yfac =0.98f;
+       w = rect.xmax - rect.xmin-7;
+       h = (rect.ymax - rect.ymin)*scopes->wavefrm_yfac;
+       yofs= rect.ymin + (rect.ymax - rect.ymin -h)/2.0f;
+       w3=w/3.0f;
+       
+       /* log scale for alpha */
+       alpha = scopes->wavefrm_alpha*scopes->wavefrm_alpha;
+       
+       for(c=0; c<3; c++) {
+               for(i=0; i<3; i++) {
+                       colors_alpha[c][i] = colors[c][i] * alpha;
+                       colorsycc_alpha[c][i] = colorsycc[c][i] * alpha;
+               }
+       }
+                       
+       glEnable(GL_BLEND);
+       glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
+       
+       glColor4f(0.f, 0.f, 0.f, 0.3f);
+       uiSetRoundBox(15);
+       uiDrawBox(GL_POLYGON, rect.xmin-1, rect.ymin-1, rect.xmax+1, rect.ymax+1, 3.0f);
+       
+
+       /* need scissor test, waveform can draw outside of boundary */
+       glGetIntegerv(GL_VIEWPORT, scissor);
+       glScissor(ar->winrct.xmin + (rect.xmin-1), ar->winrct.ymin+(rect.ymin-1), (rect.xmax+1)-(rect.xmin-1), (rect.ymax+1)-(rect.ymin-1));
+
+       glColor4f(1.f, 1.f, 1.f, 0.08f);
+       /* draw grid lines here */
+       for (i=0; i<6; i++) {
+               char str[4];
+               sprintf(str,"%-3d",i*20);
+               str[3]='\0';
+               fdrawline(rect.xmin+22, yofs+(i/5.f)*h, rect.xmax+1, yofs+(i/5.f)*h);
+               BLF_draw_default(rect.xmin+1, yofs-5+(i/5.f)*h, 0, str);
+               /* in the loop because blf_draw reset it */
+               glEnable(GL_BLEND);
+               glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
+       }
+       /* 3 vertical separation */
+       if (scopes->wavefrm_mode!= SCOPES_WAVEFRM_LUMA) {
+               for (i=1; i<3; i++) {
+                       fdrawline(rect.xmin+i*w3, rect.ymin, rect.xmin+i*w3, rect.ymax);
+               }
+       }
+       
+       /* separate min max zone on the right */
+       fdrawline(rect.xmin+w, rect.ymin, rect.xmin+w, rect.ymax);
+       /* 16-235-240 level in case of ITU-R BT601/709 */
+       glColor4f(1.f, 0.4f, 0.f, 0.2f);
+       if (ELEM(scopes->wavefrm_mode, SCOPES_WAVEFRM_YCC_601, SCOPES_WAVEFRM_YCC_709)){
+               fdrawline(rect.xmin+22, yofs+h*16.0f/255.0f, rect.xmax+1, yofs+h*16.0f/255.0f);
+               fdrawline(rect.xmin+22, yofs+h*235.0f/255.0f, rect.xmin+w3, yofs+h*235.0f/255.0f);
+               fdrawline(rect.xmin+3*w3, yofs+h*235.0f/255.0f, rect.xmax+1, yofs+h*235.0f/255.0f);
+               fdrawline(rect.xmin+w3, yofs+h*240.0f/255.0f, rect.xmax+1, yofs+h*240.0f/255.0f);
+       }
+       /* 7.5 IRE black point level for NTSC */
+       if (scopes->wavefrm_mode== SCOPES_WAVEFRM_LUMA)
+               fdrawline(rect.xmin, yofs+h*0.075f, rect.xmax+1, yofs+h*0.075f);
+
+       if (scopes->ok && scopes->waveform_1 != NULL) {
+               
+               /* LUMA (1 channel) */
+               glBlendFunc(GL_ONE,GL_ONE);
+               glColor3f(alpha, alpha, alpha);
+               if (scopes->wavefrm_mode == SCOPES_WAVEFRM_LUMA){
+
+                       glBlendFunc(GL_ONE,GL_ONE);
+                       
+                       glPushMatrix();
+                       glEnableClientState(GL_VERTEX_ARRAY);
+                       
+                       glTranslatef(rect.xmin, yofs, 0.f);
+                       glScalef(w, h, 0.f);
+                       glVertexPointer(2, GL_FLOAT, 0, scopes->waveform_1);
+                       glDrawArrays(GL_POINTS, 0, scopes->waveform_tot);
+                                       
+                       glDisableClientState(GL_VERTEX_ARRAY);
+                       glPopMatrix();
+
+                       /* min max */
+                       glColor3f(.5f, .5f, .5f);
+                       min= yofs+scopes->minmax[0][0]*h;
+                       max= yofs+scopes->minmax[0][1]*h;
+                       CLAMP(min, rect.ymin, rect.ymax);
+                       CLAMP(max, rect.ymin, rect.ymax);
+                       fdrawline(rect.xmax-3,min,rect.xmax-3,max);
+               }
+
+               /* RGB / YCC (3 channels) */
+               else if (ELEM4(scopes->wavefrm_mode, SCOPES_WAVEFRM_RGB, SCOPES_WAVEFRM_YCC_601, SCOPES_WAVEFRM_YCC_709, SCOPES_WAVEFRM_YCC_JPEG)) {
+                       int rgb = (scopes->wavefrm_mode == SCOPES_WAVEFRM_RGB);
+                       
+                       glBlendFunc(GL_ONE,GL_ONE);
+                       
+                       glPushMatrix();
+                       glEnableClientState(GL_VERTEX_ARRAY);
+                       
+                       glTranslatef(rect.xmin, yofs, 0.f);
+                       glScalef(w3, h, 0.f);
+                       
+                       glColor3fv((rgb)?colors_alpha[0]:colorsycc_alpha[0]);
+                       glVertexPointer(2, GL_FLOAT, 0, scopes->waveform_1);
+                       glDrawArrays(GL_POINTS, 0, scopes->waveform_tot);
+
+                       glTranslatef(1.f, 0.f, 0.f);
+                       glColor3fv((rgb)?colors_alpha[1]:colorsycc_alpha[1]);
+                       glVertexPointer(2, GL_FLOAT, 0, scopes->waveform_2);
+                       glDrawArrays(GL_POINTS, 0, scopes->waveform_tot);
+                       
+                       glTranslatef(1.f, 0.f, 0.f);
+                       glColor3fv((rgb)?colors_alpha[2]:colorsycc_alpha[2]);
+                       glVertexPointer(2, GL_FLOAT, 0, scopes->waveform_3);
+                       glDrawArrays(GL_POINTS, 0, scopes->waveform_tot);
+                       
+                       glDisableClientState(GL_VERTEX_ARRAY);
+                       glPopMatrix();
+
+                       
+                       /* min max */
+                       for (c=0; c<3; c++) {
+                               if (scopes->wavefrm_mode == SCOPES_WAVEFRM_RGB)
+                                       glColor3f(colors[c][0]*0.75, colors[c][1]*0.75, colors[c][2]*0.75);
+                               else
+                                       glColor3f(colorsycc[c][0]*0.75, colorsycc[c][1]*0.75, colorsycc[c][2]*0.75);
+                               min= yofs+scopes->minmax[c][0]*h;
+                               max= yofs+scopes->minmax[c][1]*h;
+                               CLAMP(min, rect.ymin, rect.ymax);
+                               CLAMP(max, rect.ymin, rect.ymax);
+                               fdrawline(rect.xmin+w+2+c*2,min,rect.xmin+w+2+c*2,max);
+                       }
+               }
+               
+       }
+       
+       /* outline, scale gripper */
+       draw_scope_end(&rect, scissor);
+}
+
+float polar_to_x(float center, float diam, float ampli, float angle)
+{
+       return center + diam * ampli * cosf(angle);
+}
+
+float polar_to_y(float center, float diam, float ampli, float angle)
+{
+       return center + diam * ampli * sinf(angle);
+}
+
+void vectorscope_draw_target(float centerx, float centery, float diam, float r, float g, float b)
+{
+       float y,u,v;
+       float tangle=0.f, tampli;
+       float dangle, dampli, dangle2, dampli2;
+
+       rgb_to_yuv(r,g,b, &y, &u, &v);
+       if (u>0 && v>=0) tangle=atanf(v/u);
+       else if (u>0 && v<0) tangle=atanf(v/u)+2*M_PI;
+       else if (u<0) tangle=atanf(v/u)+M_PI;
+       else if (u==0 && v>0) tangle=M_PI/2.0f;
+       else if (u==0 && v<0) tangle=-M_PI/2.0f;
+       tampli= sqrtf(u*u+v*v);
+
+       /* small target vary by 2.5 degree and 2.5 IRE unit */
+       glColor4f(1.0f, 1.0f, 1.0, 0.12f);
+       dangle= 2.5*M_PI/180.0f;
+       dampli= 2.5f/200.0f;
+       glBegin(GL_LINE_STRIP);
+       glVertex2f(polar_to_x(centerx,diam,tampli+dampli,tangle+dangle), polar_to_y(centery,diam,tampli+dampli,tangle+dangle));
+       glVertex2f(polar_to_x(centerx,diam,tampli-dampli,tangle+dangle), polar_to_y(centery,diam,tampli-dampli,tangle+dangle));
+       glVertex2f(polar_to_x(centerx,diam,tampli-dampli,tangle-dangle), polar_to_y(centery,diam,tampli-dampli,tangle-dangle));
+       glVertex2f(polar_to_x(centerx,diam,tampli+dampli,tangle-dangle), polar_to_y(centery,diam,tampli+dampli,tangle-dangle));
+       glVertex2f(polar_to_x(centerx,diam,tampli+dampli,tangle+dangle), polar_to_y(centery,diam,tampli+dampli,tangle+dangle));
+       glEnd();
+       /* big target vary by 10 degree and 20% amplitude */
+       glColor4f(1.0f, 1.0f, 1.0, 0.12f);
+       dangle= 10*M_PI/180.0f;
+       dampli= 0.2*tampli;
+       dangle2= 5.0f*M_PI/180.0f;
+       dampli2= 0.5f*dampli;
+       glBegin(GL_LINE_STRIP);
+       glVertex2f(polar_to_x(centerx,diam,tampli+dampli-dampli2,tangle+dangle), polar_to_y(centery,diam,tampli+dampli-dampli2,tangle+dangle));
+       glVertex2f(polar_to_x(centerx,diam,tampli+dampli,tangle+dangle), polar_to_y(centery,diam,tampli+dampli,tangle+dangle));
+       glVertex2f(polar_to_x(centerx,diam,tampli+dampli,tangle+dangle-dangle2), polar_to_y(centery,diam,tampli+dampli,tangle+dangle-dangle2));
+       glEnd();
+       glBegin(GL_LINE_STRIP);
+       glVertex2f(polar_to_x(centerx,diam,tampli-dampli+dampli2,tangle+dangle), polar_to_y(centery ,diam,tampli-dampli+dampli2,tangle+dangle));
+       glVertex2f(polar_to_x(centerx,diam,tampli-dampli,tangle+dangle), polar_to_y(centery,diam,tampli-dampli,tangle+dangle));
+       glVertex2f(polar_to_x(centerx,diam,tampli-dampli,tangle+dangle-dangle2), polar_to_y(centery,diam,tampli-dampli,tangle+dangle-dangle2));
+       glEnd();
+       glBegin(GL_LINE_STRIP);
+       glVertex2f(polar_to_x(centerx,diam,tampli-dampli+dampli2,tangle-dangle), polar_to_y(centery,diam,tampli-dampli+dampli2,tangle-dangle));
+       glVertex2f(polar_to_x(centerx,diam,tampli-dampli,tangle-dangle), polar_to_y(centery,diam,tampli-dampli,tangle-dangle));
+       glVertex2f(polar_to_x(centerx,diam,tampli-dampli,tangle-dangle+dangle2), polar_to_y(centery,diam,tampli-dampli,tangle-dangle+dangle2));
+       glEnd();
+       glBegin(GL_LINE_STRIP);
+       glVertex2f(polar_to_x(centerx,diam,tampli+dampli-dampli2,tangle-dangle), polar_to_y(centery,diam,tampli+dampli-dampli2,tangle-dangle));
+       glVertex2f(polar_to_x(centerx,diam,tampli+dampli,tangle-dangle), polar_to_y(centery,diam,tampli+dampli,tangle-dangle));
+       glVertex2f(polar_to_x(centerx,diam,tampli+dampli,tangle-dangle+dangle2), polar_to_y(centery,diam,tampli+dampli,tangle-dangle+dangle2));
+       glEnd();
+}
+
+void ui_draw_but_VECTORSCOPE(ARegion *ar, uiBut *but, uiWidgetColors *UNUSED(wcol), rcti *recti)
+{
+       Scopes *scopes = (Scopes *)but->poin;
+       rctf rect;
+       int i, j;
+       int skina= 123; /* angle in degree of the skin tone line */
+       float w, h, centerx, centery, diam;
+       float alpha;
+       float colors[6][3]={{.75,0,0},{.75,.75,0},{0,.75,0},{0,.75,.75},{0,0,.75},{.75,0,.75}};
+       GLint scissor[4];
+       
+       rect.xmin = (float)recti->xmin+1;
+       rect.xmax = (float)recti->xmax-1;
+       rect.ymin = (float)recti->ymin+SCOPE_RESIZE_PAD+2;
+       rect.ymax = (float)recti->ymax-1;
+       
+       w = rect.xmax - rect.xmin;
+       h = rect.ymax - rect.ymin;
+       centerx = rect.xmin + w/2;
+       centery = rect.ymin + h/2;
+       diam= (w<h)?w:h;
+       
+       alpha = scopes->vecscope_alpha*scopes->vecscope_alpha*scopes->vecscope_alpha;
+                       
+       glEnable(GL_BLEND);
+       glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
+       
+       glColor4f(0.f, 0.f, 0.f, 0.3f);
+       uiSetRoundBox(15);
+       uiDrawBox(GL_POLYGON, rect.xmin-1, rect.ymin-1, rect.xmax+1, rect.ymax+1, 3.0f);
+
+       /* need scissor test, hvectorscope can draw outside of boundary */
+       glGetIntegerv(GL_VIEWPORT, scissor);
+       glScissor(ar->winrct.xmin + (rect.xmin-1), ar->winrct.ymin+(rect.ymin-1), (rect.xmax+1)-(rect.xmin-1), (rect.ymax+1)-(rect.ymin-1));
+       
+       glColor4f(1.f, 1.f, 1.f, 0.08f);
+       /* draw grid elements */
+       /* cross */
+       fdrawline(centerx - (diam/2)-5, centery, centerx + (diam/2)+5, centery);
+       fdrawline(centerx, centery - (diam/2)-5, centerx, centery + (diam/2)+5);
+       /* circles */
+       for(j=0; j<5; j++) {
+               glBegin(GL_LINE_STRIP);
+               for(i=0; i<=360; i=i+15) {
+                       float a= i*M_PI/180.0;
+                       float r= (j+1)/10.0f;
+                       glVertex2f( polar_to_x(centerx,diam,r,a), polar_to_y(centery,diam,r,a));
+               }
+               glEnd();
+       }
+       /* skin tone line */
+       glColor4f(1.f, 0.4f, 0.f, 0.2f);
+       fdrawline(      polar_to_x(centerx, diam, 0.5f, skina*M_PI/180.0), polar_to_y(centery,diam,0.5,skina*M_PI/180.0),
+                               polar_to_x(centerx, diam, 0.1f, skina*M_PI/180.0), polar_to_y(centery,diam,0.1,skina*M_PI/180.0));
+       /* saturation points */
+       for(i=0; i<6; i++)
+               vectorscope_draw_target(centerx, centery, diam, colors[i][0], colors[i][1], colors[i][2]);
+       
+       if (scopes->ok && scopes->vecscope != NULL) {
+               /* pixel point cloud */
+               glBlendFunc(GL_ONE,GL_ONE);
+               glColor3f(alpha, alpha, alpha);
+
+               glPushMatrix();
+               glEnableClientState(GL_VERTEX_ARRAY);
+
+               glTranslatef(centerx, centery, 0.f);
+               glScalef(diam, diam, 0.f);
+
+               glVertexPointer(2, GL_FLOAT, 0, scopes->vecscope);
+               glDrawArrays(GL_POINTS, 0, scopes->waveform_tot);
+               
+               glDisableClientState(GL_VERTEX_ARRAY);
+               glPopMatrix();
+       }
+
+       /* outline, scale gripper */
+       draw_scope_end(&rect, scissor);
+               
+       glDisable(GL_BLEND);
+}
+
+void ui_draw_but_COLORBAND(uiBut *but, uiWidgetColors *UNUSED(wcol), rcti *rect)
 {
        ColorBand *coba;
        CBData *cbd;
        float x1, y1, sizex, sizey;
        float dx, v3[2], v1[2], v2[2], v1a[2], v2a[2];
        int a;
+       float pos, colf[4]= {0,0,0,0}; /* initialize incase the colorband isnt valid */
                
        coba= (ColorBand *)(but->editcoba? but->editcoba: but->poin);
        if(coba==NULL) return;
@@ -676,7 +1133,7 @@ void ui_draw_but_COLORBAND(uiBut *but, uiWidgetColors *wcol, rcti *rect)
                v1[0]+= dx;
        }
        
-       glShadeModel(GL_SMOOTH);
+       glShadeModel(GL_FLAT);
        glEnable(GL_BLEND);
        
        cbd= coba->data;
@@ -690,35 +1147,25 @@ void ui_draw_but_COLORBAND(uiBut *but, uiWidgetColors *wcol, rcti *rect)
        glColor4fv( &cbd->r );
        glVertex2fv(v1); glVertex2fv(v2);
        
-       for(a=0; a<coba->tot; a++, cbd++) {
+       for( a = 1; a <= sizex; a++ ) {
+               pos = ((float)a) / (sizex-1);
+               do_colorband( coba, pos, colf );
+               if (but->block->color_profile != BLI_PR_NONE)
+                       linearrgb_to_srgb_v3_v3(colf, colf);
                
-               v1[0]=v2[0]= x1+ cbd->pos*sizex;
+               v1[0]=v2[0]= x1 + a;
                
-               glColor4fv( &cbd->r );
+               glColor4fv( colf );
                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();
-       
+       glColor4f(0.0, 0.0, 0.0, 1.0);
+       fdrawbox(x1, y1, x1+sizex, y1+sizey);
        
        /* help lines */
        v1[0]= v2[0]=v3[0]= x1;
@@ -774,6 +1221,7 @@ void ui_draw_but_COLORBAND(uiBut *but, uiWidgetColors *wcol, rcti *rect)
                }       
        }
        glEnd();
+
 }
 
 void ui_draw_but_NORMAL(uiBut *but, uiWidgetColors *wcol, rcti *rect)
@@ -788,9 +1236,9 @@ void ui_draw_but_NORMAL(uiBut *but, uiWidgetColors *wcol, rcti *rect)
        glGetMaterialfv(GL_FRONT, GL_DIFFUSE, diff);
                
        /* backdrop */
-       glColor3ubv(wcol->inner);
+       glColor3ubv((unsigned char*)wcol->inner);
        uiSetRoundBox(15);
-       gl_round_box(GL_POLYGON, rect->xmin, rect->ymin, rect->xmax, rect->ymax, 5.0f);
+       uiDrawBox(GL_POLYGON, rect->xmin, rect->ymin, rect->xmax, rect->ymax, 5.0f);
        
        /* sphere color */
        glMaterialfv(GL_FRONT, GL_DIFFUSE, diffn);
@@ -806,7 +1254,8 @@ void ui_draw_but_NORMAL(uiBut *but, uiWidgetColors *wcol, rcti *rect)
        glEnable(GL_LIGHT7);
        glEnable(GL_LIGHTING);
        
-       VECCOPY(dir, (float *)but->poin);
+       ui_get_but_vectorf(but, dir);
+
        dir[3]= 0.0f;   /* glLight needs 4 args, 0.0 is sun */
        glLightfv(GL_LIGHT7, GL_POSITION, dir); 
        glLightfv(GL_LIGHT7, GL_DIFFUSE, diffn); 
@@ -817,9 +1266,14 @@ void ui_draw_but_NORMAL(uiBut *but, uiWidgetColors *wcol, rcti *rect)
        /* transform to button */
        glPushMatrix();
        glTranslatef(rect->xmin + 0.5f*(rect->xmax-rect->xmin), rect->ymin+ 0.5f*(rect->ymax-rect->ymin), 0.0f);
-       size= (rect->xmax-rect->xmin)/200.f;
+       
+       if( rect->xmax-rect->xmin < rect->ymax-rect->ymin)
+               size= (rect->xmax-rect->xmin)/200.f;
+       else
+               size= (rect->ymax-rect->ymin)/200.f;
+       
        glScalef(size, size, size);
-                        
+       
        if(displist==0) {
                GLUquadricObj   *qobj;
                
@@ -838,13 +1292,22 @@ void ui_draw_but_NORMAL(uiBut *but, uiWidgetColors *wcol, rcti *rect)
        else glCallList(displist);
        
        /* restore */
-       glPopMatrix();
        glDisable(GL_LIGHTING);
        glDisable(GL_CULL_FACE);
        glMaterialfv(GL_FRONT, GL_DIFFUSE, diff); 
-       
        glDisable(GL_LIGHT7);
        
+       /* AA circle */
+       glEnable(GL_BLEND);
+       glEnable(GL_LINE_SMOOTH );
+       glColor3ubv((unsigned char*)wcol->inner);
+       glutil_draw_lined_arc(0.0f, M_PI*2.0, 100.0f, 32);
+       glDisable(GL_BLEND);
+       glDisable(GL_LINE_SMOOTH );
+
+       /* matrix after circle */
+       glPopMatrix();
+
        /* enable blender light */
        for(a=0; a<8; a++) {
                if(old[a])
@@ -911,17 +1374,17 @@ void ui_draw_but_CURVE(ARegion *ar, uiBut *but, uiWidgetColors *wcol, rcti *rect
        if(cumap->flag & CUMA_DO_CLIP) {
                glColor3ubvShade(wcol->inner, -20);
                glRectf(rect->xmin, rect->ymin, rect->xmax, rect->ymax);
-               glColor3ubv(wcol->inner);
+               glColor3ubv((unsigned char*)wcol->inner);
                glRectf(rect->xmin + zoomx*(cumap->clipr.xmin-offsx),
                                rect->ymin + zoomy*(cumap->clipr.ymin-offsy),
                                rect->xmin + zoomx*(cumap->clipr.xmax-offsx),
                                rect->ymin + zoomy*(cumap->clipr.ymax-offsy));
        }
        else {
-               glColor3ubv(wcol->inner);
+               glColor3ubv((unsigned char*)wcol->inner);
                glRectf(rect->xmin, rect->ymin, rect->xmax, rect->ymax);
        }
-       
+               
        /* grid, every .25 step */
        glColor3ubvShade(wcol->inner, -16);
        ui_draw_but_curve_grid(rect, zoomx, zoomy, offsx, offsy, 0.25f);
@@ -937,6 +1400,24 @@ void ui_draw_but_CURVE(ARegion *ar, uiBut *but, uiWidgetColors *wcol, rcti *rect
        glVertex2f(rect->xmin + zoomx*(-offsx), rect->ymax);
        glEnd();
        
+       /* magic trigger for curve backgrounds */
+       if (but->a1 != -1) {
+               if (but->a1 == UI_GRAD_H) {
+                       rcti grid;
+                       float col[3]= {0.0f, 0.0f, 0.0f}; /* dummy arg */
+                       
+                       grid.xmin = rect->xmin + zoomx*(-offsx);
+                       grid.xmax = rect->xmax + zoomx*(-offsx);
+                       grid.ymin = rect->ymin + zoomy*(-offsy);
+                       grid.ymax = rect->ymax + zoomy*(-offsy);
+                       
+                       glEnable(GL_BLEND);
+                       ui_draw_gradient(&grid, col, UI_GRAD_H, 0.5f);
+                       glDisable(GL_BLEND);
+               }
+       }
+       
+       
        /* cfra option */
        /* XXX 2.48
        if(cumap->flag & CUMA_DRAW_CFRA) {
@@ -974,7 +1455,7 @@ void ui_draw_but_CURVE(ARegion *ar, uiBut *but, uiWidgetColors *wcol, rcti *rect
        }*/
        
        /* the curve */
-       glColor3ubv(wcol->item);
+       glColor3ubv((unsigned char*)wcol->item);
        glEnable(GL_LINE_SMOOTH);
        glEnable(GL_BLEND);
        glBegin(GL_LINE_STRIP);
@@ -1028,7 +1509,7 @@ void ui_draw_but_CURVE(ARegion *ar, uiBut *but, uiWidgetColors *wcol, rcti *rect
        glScissor(scissor[0], scissor[1], scissor[2], scissor[3]);
 
        /* outline */
-       glColor3ubv(wcol->outline);
+       glColor3ubv((unsigned char*)wcol->outline);
        fdrawbox(rect->xmin, rect->ymin, rect->xmax, rect->ymax);
 }
 
@@ -1104,13 +1585,13 @@ void ui_dropshadow(rctf *rct, float radius, float aspect, int select)
                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);
+               uiDrawBox(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);
+       uiDrawBox(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);