Ton Roosendaal
17b2e0e6f6
Bugfix: reading iconfile (~/.blender/icons/xxxx.png) didn't work. Note: go to the outliner, user preferences, first theme, User Inteface, and fill in name of the png file in "Icon File" text button. Save prefs, start Blender, and it shows. This whole process can be optimized once, indeed :)
2203 lines
50 KiB
C
2203 lines
50 KiB
C
/**
|
|
* ***** 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.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* 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.
|
|
*
|
|
* The Original Code is Copyright (C) 2009 Blender Foundation.
|
|
* All rights reserved.
|
|
*
|
|
* Contributor(s): Blender Foundation
|
|
*
|
|
* ***** END GPL LICENSE BLOCK *****
|
|
*/
|
|
|
|
#include <limits.h>
|
|
#include <math.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#include "MEM_guardedalloc.h"
|
|
|
|
#include "DNA_ID.h"
|
|
#include "DNA_screen_types.h"
|
|
#include "DNA_userdef_types.h"
|
|
#include "DNA_windowmanager_types.h"
|
|
|
|
#include "BLI_arithb.h"
|
|
#include "BLI_listbase.h"
|
|
#include "BLI_rect.h"
|
|
|
|
#include "BKE_context.h"
|
|
#include "BKE_global.h"
|
|
#include "BKE_utildefines.h"
|
|
|
|
#include "BIF_gl.h"
|
|
#include "BIF_glutil.h"
|
|
|
|
#include "BLF_api.h"
|
|
|
|
#include "UI_interface.h"
|
|
#include "UI_interface_icons.h"
|
|
#include "UI_resources.h"
|
|
#include "UI_view2d.h"
|
|
|
|
#include "ED_util.h"
|
|
#include "ED_types.h"
|
|
|
|
#include "interface_intern.h"
|
|
|
|
/* ************** widget base functions ************** */
|
|
/*
|
|
- in: roundbox codes for corner types and radius
|
|
- return: array of [size][2][x,y] points, the edges of the roundbox, + UV coords
|
|
|
|
- draw black box with alpha 0 on exact button boundbox
|
|
- for ever AA step:
|
|
- draw the inner part for a round filled box, with color blend codes or texture coords
|
|
- draw outline in outline color
|
|
- draw outer part, bottom half, extruded 1 pixel to bottom, for emboss shadow
|
|
- draw extra decorations
|
|
- draw background color box with alpha 1 on exact button boundbox
|
|
|
|
*/
|
|
|
|
/* fill this struct with polygon info to draw AA'ed */
|
|
/* it has outline, back, and two optional tria meshes */
|
|
|
|
typedef struct uiWidgetTrias {
|
|
int tot;
|
|
|
|
float vec[32][2];
|
|
int (*index)[3];
|
|
|
|
} uiWidgetTrias;
|
|
|
|
typedef struct uiWidgetStateColors {
|
|
char inner_anim[4];
|
|
char inner_anim_sel[4];
|
|
char inner_key[4];
|
|
char inner_key_sel[4];
|
|
char inner_driven[4];
|
|
char inner_driven_sel[4];
|
|
} uiWidgetStateColors;
|
|
|
|
typedef struct uiWidgetBase {
|
|
|
|
int totvert, halfwayvert;
|
|
float outer_v[64][2];
|
|
float inner_v[64][2];
|
|
float inner_uv[64][2];
|
|
|
|
short inner, outline, emboss; /* set on/off */
|
|
|
|
uiWidgetTrias tria1;
|
|
uiWidgetTrias tria2;
|
|
|
|
} uiWidgetBase;
|
|
|
|
/* uiWidgetType: for time being only for visual appearance,
|
|
later, a handling callback can be added too
|
|
*/
|
|
typedef struct uiWidgetType {
|
|
|
|
/* pointer to theme color definition */
|
|
uiWidgetColors *wcol_theme;
|
|
|
|
/* converted colors for state */
|
|
uiWidgetColors wcol;
|
|
|
|
void (*state)(struct uiWidgetType *, int state);
|
|
void (*draw)(uiWidgetColors *, rcti *, int state, int roundboxalign);
|
|
void (*custom)(uiBut *, uiWidgetColors *, rcti *, int state, int roundboxalign);
|
|
void (*text)(uiFontStyle *, uiWidgetColors *, uiBut *, rcti *);
|
|
|
|
} uiWidgetType;
|
|
|
|
|
|
/* *********************** draw data ************************** */
|
|
|
|
static float cornervec[9][2]= {{0.0, 0.0}, {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}, {1.0, 1.0}};
|
|
|
|
static float jit[8][2]= {{0.468813 , -0.481430}, {-0.155755 , -0.352820},
|
|
{0.219306 , -0.238501}, {-0.393286 , -0.110949}, {-0.024699 , 0.013908},
|
|
{0.343805 , 0.147431}, {-0.272855 , 0.269918}, {0.095909 , 0.388710}};
|
|
|
|
static float num_tria_vert[19][2]= {
|
|
{0.382684, 0.923879}, {0.000001, 1.000000}, {-0.382683, 0.923880}, {-0.707107, 0.707107},
|
|
{-0.923879, 0.382684}, {-1.000000, 0.000000}, {-0.923880, -0.382684}, {-0.707107, -0.707107},
|
|
{-0.382683, -0.923880}, {0.000000, -1.000000}, {0.382684, -0.923880}, {0.707107, -0.707107},
|
|
{0.923880, -0.382684}, {1.000000, -0.000000}, {0.923880, 0.382683}, {0.707107, 0.707107},
|
|
{-0.352077, 0.532607}, {-0.352077, -0.549313}, {0.729843, -0.008353}};
|
|
|
|
static int num_tria_face[19][3]= {
|
|
{13, 14, 18}, {17, 5, 6}, {12, 13, 18}, {17, 6, 7}, {15, 18, 14}, {16, 4, 5}, {16, 5, 17}, {18, 11, 12},
|
|
{18, 17, 10}, {18, 10, 11}, {17, 9, 10}, {15, 0, 18}, {18, 0, 16}, {3, 4, 16}, {8, 9, 17}, {8, 17, 7},
|
|
{2, 3, 16}, {1, 2, 16}, {16, 0, 1}};
|
|
|
|
static float menu_tria_vert[6][2]= {
|
|
{-0.41, 0.16}, {0.41, 0.16}, {0, 0.82},
|
|
{0, -0.82}, {-0.41, -0.16}, {0.41, -0.16}};
|
|
|
|
static int menu_tria_face[2][3]= {{2, 0, 1}, {3, 5, 4}};
|
|
|
|
static float check_tria_vert[6][2]= {
|
|
{-0.578579, 0.253369}, {-0.392773, 0.412794}, {-0.004241, -0.328551},
|
|
{-0.003001, 0.034320}, {1.055313, 0.864744}, {0.866408, 1.026895}};
|
|
|
|
static int check_tria_face[4][3]= {
|
|
{3, 2, 4}, {3, 4, 5}, {1, 0, 3}, {0, 2, 3}};
|
|
|
|
/* ************************************************* */
|
|
|
|
void ui_draw_anti_tria(float x1, float y1, float x2, float y2, float x3, float y3)
|
|
{
|
|
float color[4];
|
|
int j;
|
|
|
|
glEnable(GL_BLEND);
|
|
glGetFloatv(GL_CURRENT_COLOR, color);
|
|
color[3]= 0.125;
|
|
glColor4fv(color);
|
|
|
|
/* for each AA step */
|
|
for(j=0; j<8; j++) {
|
|
glTranslatef(1.0*jit[j][0], 1.0*jit[j][1], 0.0f);
|
|
|
|
glBegin(GL_POLYGON);
|
|
glVertex2f(x1, y1);
|
|
glVertex2f(x2, y2);
|
|
glVertex2f(x3, y3);
|
|
glEnd();
|
|
|
|
glTranslatef(-1.0*jit[j][0], -1.0*jit[j][1], 0.0f);
|
|
}
|
|
|
|
glDisable(GL_BLEND);
|
|
|
|
}
|
|
|
|
static void widget_init(uiWidgetBase *wtb)
|
|
{
|
|
wtb->totvert= wtb->halfwayvert= 0;
|
|
wtb->tria1.tot= 0;
|
|
wtb->tria2.tot= 0;
|
|
|
|
wtb->inner= 1;
|
|
wtb->outline= 1;
|
|
wtb->emboss= 1;
|
|
}
|
|
|
|
/* helper call, makes shadow rect, with 'sun' above menu, so only shadow to left/right/bottom */
|
|
/* return tot */
|
|
static int round_box_shadow_edges(float (*vert)[2], rcti *rect, float rad, int roundboxalign, float step)
|
|
{
|
|
float vec[9][2];
|
|
float minx, miny, maxx, maxy;
|
|
int a, tot= 0;
|
|
|
|
rad+= step;
|
|
|
|
if(2.0f*rad > rect->ymax-rect->ymin)
|
|
rad= 0.5f*(rect->ymax-rect->ymin);
|
|
|
|
minx= rect->xmin-step;
|
|
miny= rect->ymin-step;
|
|
maxx= rect->xmax+step;
|
|
maxy= rect->ymax+step;
|
|
|
|
/* mult */
|
|
for(a=0; a<9; a++) {
|
|
vec[a][0]= rad*cornervec[a][0];
|
|
vec[a][1]= rad*cornervec[a][1];
|
|
}
|
|
|
|
/* start with left-top, anti clockwise */
|
|
if(roundboxalign & 1) {
|
|
for(a=0; a<9; a++, tot++) {
|
|
vert[tot][0]= minx+rad-vec[a][0];
|
|
vert[tot][1]= maxy-vec[a][1];
|
|
}
|
|
}
|
|
else {
|
|
for(a=0; a<9; a++, tot++) {
|
|
vert[tot][0]= minx;
|
|
vert[tot][1]= maxy;
|
|
}
|
|
}
|
|
|
|
if(roundboxalign & 8) {
|
|
for(a=0; a<9; a++, tot++) {
|
|
vert[tot][0]= minx+vec[a][1];
|
|
vert[tot][1]= miny+rad-vec[a][0];
|
|
}
|
|
}
|
|
else {
|
|
for(a=0; a<9; a++, tot++) {
|
|
vert[tot][0]= minx;
|
|
vert[tot][1]= miny;
|
|
}
|
|
}
|
|
|
|
if(roundboxalign & 4) {
|
|
for(a=0; a<9; a++, tot++) {
|
|
vert[tot][0]= maxx-rad+vec[a][0];
|
|
vert[tot][1]= miny+vec[a][1];
|
|
}
|
|
}
|
|
else {
|
|
for(a=0; a<9; a++, tot++) {
|
|
vert[tot][0]= maxx;
|
|
vert[tot][1]= miny;
|
|
}
|
|
}
|
|
|
|
if(roundboxalign & 2) {
|
|
for(a=0; a<9; a++, tot++) {
|
|
vert[tot][0]= maxx-vec[a][1];
|
|
vert[tot][1]= maxy-rad+vec[a][0];
|
|
}
|
|
}
|
|
else {
|
|
for(a=0; a<9; a++, tot++) {
|
|
vert[tot][0]= maxx;
|
|
vert[tot][1]= maxy;
|
|
}
|
|
}
|
|
return tot;
|
|
}
|
|
|
|
/* this call has 1 extra arg to allow mask outline */
|
|
static void round_box__edges(uiWidgetBase *wt, int roundboxalign, rcti *rect, float rad, float radi)
|
|
{
|
|
float vec[9][2], veci[9][2];
|
|
float minx= rect->xmin, miny= rect->ymin, maxx= rect->xmax, maxy= rect->ymax;
|
|
float minxi= minx + 1.0f; /* boundbox inner */
|
|
float maxxi= maxx - 1.0f;
|
|
float minyi= miny + 1.0f;
|
|
float maxyi= maxy - 1.0f;
|
|
float facxi= 1.0f/(maxxi-minxi); /* for uv */
|
|
float facyi= 1.0f/(maxyi-minyi);
|
|
int a, tot= 0;
|
|
|
|
if(2.0f*rad > rect->ymax-rect->ymin)
|
|
rad= 0.5f*(rect->ymax-rect->ymin);
|
|
|
|
if(2.0f*(radi+1.0f) > rect->ymax-rect->ymin)
|
|
radi= 0.5f*(rect->ymax-rect->ymin) - 1.0f;
|
|
|
|
/* mult */
|
|
for(a=0; a<9; a++) {
|
|
veci[a][0]= radi*cornervec[a][0];
|
|
veci[a][1]= radi*cornervec[a][1];
|
|
vec[a][0]= rad*cornervec[a][0];
|
|
vec[a][1]= rad*cornervec[a][1];
|
|
}
|
|
|
|
/* corner left-bottom */
|
|
if(roundboxalign & 8) {
|
|
|
|
for(a=0; a<9; a++, tot++) {
|
|
wt->inner_v[tot][0]= minxi+veci[a][1];
|
|
wt->inner_v[tot][1]= minyi+radi-veci[a][0];
|
|
|
|
wt->outer_v[tot][0]= minx+vec[a][1];
|
|
wt->outer_v[tot][1]= miny+rad-vec[a][0];
|
|
|
|
wt->inner_uv[tot][0]= facxi*(wt->inner_v[tot][0] - minxi);
|
|
wt->inner_uv[tot][1]= facyi*(wt->inner_v[tot][1] - minyi);
|
|
}
|
|
}
|
|
else {
|
|
wt->inner_v[tot][0]= minxi;
|
|
wt->inner_v[tot][1]= minyi;
|
|
|
|
wt->outer_v[tot][0]= minx;
|
|
wt->outer_v[tot][1]= miny;
|
|
|
|
wt->inner_uv[tot][0]= 0.0f;
|
|
wt->inner_uv[tot][1]= 0.0f;
|
|
|
|
tot++;
|
|
}
|
|
|
|
/* corner right-bottom */
|
|
if(roundboxalign & 4) {
|
|
|
|
for(a=0; a<9; a++, tot++) {
|
|
wt->inner_v[tot][0]= maxxi-radi+veci[a][0];
|
|
wt->inner_v[tot][1]= minyi+veci[a][1];
|
|
|
|
wt->outer_v[tot][0]= maxx-rad+vec[a][0];
|
|
wt->outer_v[tot][1]= miny+vec[a][1];
|
|
|
|
wt->inner_uv[tot][0]= facxi*(wt->inner_v[tot][0] - minxi);
|
|
wt->inner_uv[tot][1]= facyi*(wt->inner_v[tot][1] - minyi);
|
|
}
|
|
}
|
|
else {
|
|
wt->inner_v[tot][0]= maxxi;
|
|
wt->inner_v[tot][1]= minyi;
|
|
|
|
wt->outer_v[tot][0]= maxx;
|
|
wt->outer_v[tot][1]= miny;
|
|
|
|
wt->inner_uv[tot][0]= 1.0f;
|
|
wt->inner_uv[tot][1]= 0.0f;
|
|
|
|
tot++;
|
|
}
|
|
|
|
wt->halfwayvert= tot;
|
|
|
|
/* corner right-top */
|
|
if(roundboxalign & 2) {
|
|
|
|
for(a=0; a<9; a++, tot++) {
|
|
wt->inner_v[tot][0]= maxxi-veci[a][1];
|
|
wt->inner_v[tot][1]= maxyi-radi+veci[a][0];
|
|
|
|
wt->outer_v[tot][0]= maxx-vec[a][1];
|
|
wt->outer_v[tot][1]= maxy-rad+vec[a][0];
|
|
|
|
wt->inner_uv[tot][0]= facxi*(wt->inner_v[tot][0] - minxi);
|
|
wt->inner_uv[tot][1]= facyi*(wt->inner_v[tot][1] - minyi);
|
|
}
|
|
}
|
|
else {
|
|
wt->inner_v[tot][0]= maxxi;
|
|
wt->inner_v[tot][1]= maxyi;
|
|
|
|
wt->outer_v[tot][0]= maxx;
|
|
wt->outer_v[tot][1]= maxy;
|
|
|
|
wt->inner_uv[tot][0]= 1.0f;
|
|
wt->inner_uv[tot][1]= 1.0f;
|
|
|
|
tot++;
|
|
}
|
|
|
|
/* corner left-top */
|
|
if(roundboxalign & 1) {
|
|
|
|
for(a=0; a<9; a++, tot++) {
|
|
wt->inner_v[tot][0]= minxi+radi-veci[a][0];
|
|
wt->inner_v[tot][1]= maxyi-veci[a][1];
|
|
|
|
wt->outer_v[tot][0]= minx+rad-vec[a][0];
|
|
wt->outer_v[tot][1]= maxy-vec[a][1];
|
|
|
|
wt->inner_uv[tot][0]= facxi*(wt->inner_v[tot][0] - minxi);
|
|
wt->inner_uv[tot][1]= facyi*(wt->inner_v[tot][1] - minyi);
|
|
}
|
|
|
|
}
|
|
else {
|
|
|
|
wt->inner_v[tot][0]= minxi;
|
|
wt->inner_v[tot][1]= maxyi;
|
|
|
|
wt->outer_v[tot][0]= minx;
|
|
wt->outer_v[tot][1]= maxy;
|
|
|
|
wt->inner_uv[tot][0]= 0.0f;
|
|
wt->inner_uv[tot][1]= 1.0f;
|
|
|
|
tot++;
|
|
}
|
|
|
|
wt->totvert= tot;
|
|
}
|
|
|
|
static void round_box_edges(uiWidgetBase *wt, int roundboxalign, rcti *rect, float rad)
|
|
{
|
|
round_box__edges(wt, roundboxalign, rect, rad, rad-1.0f);
|
|
}
|
|
|
|
|
|
/* based on button rect, return scaled array of triangles */
|
|
static void widget_num_tria(uiWidgetTrias *tria, rcti *rect, float triasize, char where)
|
|
{
|
|
float centx, centy, size;
|
|
int a;
|
|
|
|
/* center position and size */
|
|
centx= (float)rect->xmin + 0.5f*(rect->ymax-rect->ymin);
|
|
centy= (float)rect->ymin + 0.5f*(rect->ymax-rect->ymin);
|
|
size= -0.5f*triasize*(rect->ymax-rect->ymin);
|
|
|
|
if(where=='r') {
|
|
centx= (float)rect->xmax - 0.5f*(rect->ymax-rect->ymin);
|
|
size= -size;
|
|
}
|
|
|
|
for(a=0; a<19; a++) {
|
|
tria->vec[a][0]= size*num_tria_vert[a][0] + centx;
|
|
tria->vec[a][1]= size*num_tria_vert[a][1] + centy;
|
|
}
|
|
|
|
tria->tot= 19;
|
|
tria->index= num_tria_face;
|
|
}
|
|
|
|
static void widget_trias_draw(uiWidgetTrias *tria)
|
|
{
|
|
int a;
|
|
|
|
glBegin(GL_TRIANGLES);
|
|
for(a=0; a<tria->tot; a++) {
|
|
glVertex2fv(tria->vec[ tria->index[a][0] ]);
|
|
glVertex2fv(tria->vec[ tria->index[a][1] ]);
|
|
glVertex2fv(tria->vec[ tria->index[a][2] ]);
|
|
}
|
|
glEnd();
|
|
|
|
}
|
|
|
|
static void widget_menu_trias(uiWidgetTrias *tria, rcti *rect)
|
|
{
|
|
float centx, centy, size, asp;
|
|
int a;
|
|
|
|
/* center position and size */
|
|
centx= rect->xmax - 0.5f*(rect->ymax-rect->ymin);
|
|
centy= rect->ymin + 0.5f*(rect->ymax-rect->ymin);
|
|
size= 0.4f*(rect->ymax-rect->ymin);
|
|
|
|
/* XXX exception */
|
|
asp= ((float)rect->xmax-rect->xmin)/((float)rect->ymax-rect->ymin);
|
|
if(asp > 1.2f && asp < 2.6f)
|
|
centx= rect->xmax - 0.3f*(rect->ymax-rect->ymin);
|
|
|
|
for(a=0; a<6; a++) {
|
|
tria->vec[a][0]= size*menu_tria_vert[a][0] + centx;
|
|
tria->vec[a][1]= size*menu_tria_vert[a][1] + centy;
|
|
}
|
|
|
|
tria->tot= 2;
|
|
tria->index= menu_tria_face;
|
|
}
|
|
|
|
static void widget_check_trias(uiWidgetTrias *tria, rcti *rect)
|
|
{
|
|
float centx, centy, size;
|
|
int a;
|
|
|
|
/* center position and size */
|
|
centx= rect->xmin + 0.5f*(rect->ymax-rect->ymin);
|
|
centy= rect->ymin + 0.5f*(rect->ymax-rect->ymin);
|
|
size= 0.5f*(rect->ymax-rect->ymin);
|
|
|
|
for(a=0; a<6; a++) {
|
|
tria->vec[a][0]= size*check_tria_vert[a][0] + centx;
|
|
tria->vec[a][1]= size*check_tria_vert[a][1] + centy;
|
|
}
|
|
|
|
tria->tot= 4;
|
|
tria->index= check_tria_face;
|
|
}
|
|
|
|
|
|
/* prepares shade colors */
|
|
static void shadecolors4(char *coltop, char *coldown, char *color, short shadetop, short shadedown)
|
|
{
|
|
|
|
coltop[0]= CLAMPIS(color[0]+shadetop, 0, 255);
|
|
coltop[1]= CLAMPIS(color[1]+shadetop, 0, 255);
|
|
coltop[2]= CLAMPIS(color[2]+shadetop, 0, 255);
|
|
coltop[3]= color[3];
|
|
|
|
coldown[0]= CLAMPIS(color[0]+shadedown, 0, 255);
|
|
coldown[1]= CLAMPIS(color[1]+shadedown, 0, 255);
|
|
coldown[2]= CLAMPIS(color[2]+shadedown, 0, 255);
|
|
coldown[3]= color[3];
|
|
}
|
|
|
|
static void round_box_shade_col4(char *col1, char *col2, float fac)
|
|
{
|
|
int faci, facm;
|
|
char col[4];
|
|
|
|
faci= floor(255.1f*fac);
|
|
facm= 255-faci;
|
|
|
|
col[0]= (faci*col1[0] + facm*col2[0])>>8;
|
|
col[1]= (faci*col1[1] + facm*col2[1])>>8;
|
|
col[2]= (faci*col1[2] + facm*col2[2])>>8;
|
|
col[3]= (faci*col1[3] + facm*col2[3])>>8;
|
|
|
|
glColor4ubv(col);
|
|
}
|
|
|
|
static void widgetbase_outline(uiWidgetBase *wtb)
|
|
{
|
|
int a;
|
|
|
|
/* outline */
|
|
glBegin(GL_QUAD_STRIP);
|
|
for(a=0; a<wtb->totvert; a++) {
|
|
glVertex2fv(wtb->outer_v[a]);
|
|
glVertex2fv(wtb->inner_v[a]);
|
|
}
|
|
glVertex2fv(wtb->outer_v[0]);
|
|
glVertex2fv(wtb->inner_v[0]);
|
|
glEnd();
|
|
}
|
|
|
|
static void widgetbase_draw(uiWidgetBase *wtb, uiWidgetColors *wcol)
|
|
{
|
|
int j, a;
|
|
|
|
glEnable(GL_BLEND);
|
|
|
|
/* backdrop non AA */
|
|
if(wtb->inner) {
|
|
if(wcol->shaded==0) {
|
|
|
|
/* filled center, solid */
|
|
glColor4ubv(wcol->inner);
|
|
glBegin(GL_POLYGON);
|
|
for(a=0; a<wtb->totvert; a++)
|
|
glVertex2fv(wtb->inner_v[a]);
|
|
glEnd();
|
|
|
|
}
|
|
else {
|
|
char col1[4], col2[4];
|
|
|
|
shadecolors4(col1, col2, wcol->inner, wcol->shadetop, wcol->shadedown);
|
|
|
|
glShadeModel(GL_SMOOTH);
|
|
glBegin(GL_POLYGON);
|
|
for(a=0; a<wtb->totvert; a++) {
|
|
round_box_shade_col4(col1, col2, wtb->inner_uv[a][1]);
|
|
glVertex2fv(wtb->inner_v[a]);
|
|
}
|
|
glEnd();
|
|
glShadeModel(GL_FLAT);
|
|
}
|
|
}
|
|
|
|
/* for each AA step */
|
|
if(wtb->outline) {
|
|
for(j=0; j<8; j++) {
|
|
glTranslatef(1.0*jit[j][0], 1.0*jit[j][1], 0.0f);
|
|
|
|
/* outline */
|
|
glColor4ub(wcol->outline[0], wcol->outline[1], wcol->outline[2], 32);
|
|
glBegin(GL_QUAD_STRIP);
|
|
for(a=0; a<wtb->totvert; a++) {
|
|
glVertex2fv(wtb->outer_v[a]);
|
|
glVertex2fv(wtb->inner_v[a]);
|
|
}
|
|
glVertex2fv(wtb->outer_v[0]);
|
|
glVertex2fv(wtb->inner_v[0]);
|
|
glEnd();
|
|
|
|
/* emboss bottom shadow */
|
|
if(wtb->emboss) {
|
|
glColor4f(1.0f, 1.0f, 1.0f, 0.02f);
|
|
glBegin(GL_QUAD_STRIP);
|
|
for(a=0; a<wtb->halfwayvert; a++) {
|
|
glVertex2fv(wtb->outer_v[a]);
|
|
glVertex2f(wtb->outer_v[a][0], wtb->outer_v[a][1]-1.0f);
|
|
}
|
|
glEnd();
|
|
}
|
|
|
|
glTranslatef(-1.0*jit[j][0], -1.0*jit[j][1], 0.0f);
|
|
}
|
|
}
|
|
|
|
/* decoration */
|
|
if(wtb->tria1.tot || wtb->tria2.tot) {
|
|
/* for each AA step */
|
|
for(j=0; j<8; j++) {
|
|
glTranslatef(1.0*jit[j][0], 1.0*jit[j][1], 0.0f);
|
|
|
|
if(wtb->tria1.tot) {
|
|
glColor4ub(wcol->item[0], wcol->item[1], wcol->item[2], 32);
|
|
widget_trias_draw(&wtb->tria1);
|
|
}
|
|
if(wtb->tria2.tot) {
|
|
glColor4ub(wcol->item[0], wcol->item[1], wcol->item[2], 32);
|
|
widget_trias_draw(&wtb->tria2);
|
|
}
|
|
|
|
glTranslatef(-1.0*jit[j][0], -1.0*jit[j][1], 0.0f);
|
|
}
|
|
}
|
|
|
|
glDisable(GL_BLEND);
|
|
|
|
}
|
|
|
|
/* *********************** text/icon ************************************** */
|
|
|
|
|
|
/* icons have been standardized... and this call draws in untransformed coordinates */
|
|
#define ICON_HEIGHT 16.0f
|
|
|
|
static void widget_draw_icon(uiBut *but, BIFIconID icon, int blend, rcti *rect)
|
|
{
|
|
int xs=0, ys=0;
|
|
float aspect, height;
|
|
|
|
/* this icon doesn't need draw... */
|
|
if(icon==ICON_BLANK1 && (but->flag & UI_ICON_SUBMENU)==0) 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;
|
|
|
|
/* calculate blend color */
|
|
if ELEM3(but->type, TOG, ROW, TOGN) {
|
|
if(but->flag & UI_SELECT);
|
|
else if(but->flag & UI_ACTIVE);
|
|
else blend= -60;
|
|
}
|
|
|
|
glEnable(GL_BLEND);
|
|
|
|
if(icon && icon!=ICON_BLANK1) {
|
|
if(but->flag & UI_ICON_LEFT) {
|
|
if (but->type==BUT_TOGDUAL) {
|
|
if (but->drawstr[0]) {
|
|
xs= rect->xmin-1;
|
|
} else {
|
|
xs= (rect->xmin+rect->xmax- height)/2;
|
|
}
|
|
}
|
|
else if (but->block->flag & UI_BLOCK_LOOP) {
|
|
if(but->type==SEARCH_MENU)
|
|
xs= rect->xmin+4;
|
|
else
|
|
xs= rect->xmin+1;
|
|
}
|
|
else if ((but->type==ICONROW) || (but->type==ICONTEXTROW)) {
|
|
xs= rect->xmin+3;
|
|
}
|
|
else {
|
|
xs= rect->xmin+4;
|
|
}
|
|
ys= (rect->ymin+rect->ymax- height)/2;
|
|
}
|
|
else {
|
|
xs= (rect->xmin+rect->xmax- height)/2;
|
|
ys= (rect->ymin+rect->ymax- height)/2;
|
|
}
|
|
|
|
UI_icon_draw_aspect_blended(xs, ys, icon, aspect, blend);
|
|
}
|
|
|
|
if(but->flag & UI_ICON_SUBMENU) {
|
|
xs= rect->xmax-17;
|
|
ys= (rect->ymin+rect->ymax- height)/2;
|
|
|
|
UI_icon_draw_aspect_blended(xs, ys, ICON_RIGHTARROW_THIN, aspect, blend);
|
|
}
|
|
|
|
glDisable(GL_BLEND);
|
|
}
|
|
|
|
/* sets but->ofs to make sure text is correctly visible */
|
|
static void ui_text_leftclip(uiFontStyle *fstyle, uiBut *but, rcti *rect)
|
|
{
|
|
int okwidth= rect->xmax-rect->xmin;
|
|
|
|
/* need to set this first */
|
|
uiStyleFontSet(fstyle);
|
|
|
|
but->strwidth= BLF_width(but->drawstr);
|
|
but->ofs= 0;
|
|
|
|
while(but->strwidth > okwidth ) {
|
|
|
|
but->ofs++;
|
|
but->strwidth= BLF_width(but->drawstr+but->ofs);
|
|
|
|
/* textbut exception */
|
|
if(but->editstr && but->pos != -1) {
|
|
int pos= but->pos+strlen(but->str);
|
|
|
|
if(pos-1 < but->ofs) {
|
|
pos= but->ofs-pos+1;
|
|
but->ofs -= pos;
|
|
if(but->ofs<0) {
|
|
but->ofs= 0;
|
|
pos--;
|
|
}
|
|
but->drawstr[ strlen(but->drawstr)-pos ]= 0;
|
|
}
|
|
}
|
|
|
|
if(but->strwidth < 10) break;
|
|
}
|
|
}
|
|
|
|
static void widget_draw_text(uiFontStyle *fstyle, uiWidgetColors *wcol, uiBut *but, rcti *rect)
|
|
{
|
|
// int transopts;
|
|
char *cpoin = NULL;
|
|
|
|
uiStyleFontSet(fstyle);
|
|
|
|
if(but->editstr || (but->flag & UI_TEXT_LEFT))
|
|
fstyle->align= UI_STYLE_TEXT_LEFT;
|
|
else
|
|
fstyle->align= UI_STYLE_TEXT_CENTER;
|
|
|
|
/* text button selection and cursor */
|
|
if(but->editstr && but->pos != -1) {
|
|
short t, pos, ch;
|
|
short selsta_tmp, selend_tmp, selsta_draw, selwidth_draw;
|
|
|
|
if ((but->selend - but->selsta) > 0) {
|
|
/* XXX weak, why is this? (ton) */
|
|
t= but->str[0]?1:-2;
|
|
|
|
/* 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 = BLF_width(but->drawstr+but->ofs) + t;
|
|
|
|
but->drawstr[selsta_tmp]= ch;
|
|
|
|
ch= but->drawstr[selend_tmp];
|
|
but->drawstr[selend_tmp]= 0;
|
|
|
|
selwidth_draw = BLF_width(but->drawstr+but->ofs) + t;
|
|
|
|
but->drawstr[selend_tmp]= ch;
|
|
|
|
glColor3ubv(wcol->item);
|
|
glRects(rect->xmin+selsta_draw+1, rect->ymin+2, rect->xmin+selwidth_draw+1, rect->ymax-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;
|
|
|
|
t= BLF_width(but->drawstr+but->ofs) + 1;
|
|
|
|
but->drawstr[pos]= ch;
|
|
}
|
|
else t= 1;
|
|
|
|
glColor3ub(255,0,0);
|
|
glRects(rect->xmin+t, rect->ymin+2, rect->xmin+t+2, rect->ymax-2);
|
|
}
|
|
}
|
|
}
|
|
// ui_rasterpos_safe(x, y, but->aspect);
|
|
// if(but->type==IDPOIN) transopts= 0; // no translation, of course!
|
|
// else transopts= ui_translate_buttons();
|
|
|
|
/* cut string in 2 parts - only for menu entries */
|
|
if(ELEM5(but->type, SLI, NUM, TEX, NUMSLI, NUMABS)==0) {
|
|
cpoin= strchr(but->drawstr, '|');
|
|
if(cpoin) *cpoin= 0;
|
|
}
|
|
|
|
glColor3ubv(wcol->text);
|
|
uiStyleFontDraw(fstyle, rect, but->drawstr+but->ofs);
|
|
|
|
/* part text right aligned */
|
|
if(cpoin) {
|
|
fstyle->align= UI_STYLE_TEXT_RIGHT;
|
|
rect->xmax-=5;
|
|
uiStyleFontDraw(fstyle, rect, cpoin+1);
|
|
*cpoin= '|';
|
|
}
|
|
}
|
|
|
|
/* draws text and icons for buttons */
|
|
static void widget_draw_text_icon(uiFontStyle *fstyle, uiWidgetColors *wcol, uiBut *but, rcti *rect)
|
|
{
|
|
|
|
if(but==NULL) return;
|
|
|
|
/* cutting off from left part */
|
|
if ELEM3(but->type, NUM, NUMABS, TEX) {
|
|
ui_text_leftclip(fstyle, but, rect);
|
|
}
|
|
else but->ofs= 0;
|
|
|
|
/* check for button text label */
|
|
if (but->type == ICONTEXTROW) {
|
|
widget_draw_icon(but, (BIFIconID) (but->icon+but->iconadd), 0, rect);
|
|
}
|
|
else {
|
|
|
|
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);
|
|
|
|
widget_draw_icon(but, ICON_DOT, dualset?0:-100, rect);
|
|
}
|
|
|
|
/* 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) {
|
|
widget_draw_icon(but, but->icon, 0, rect);
|
|
|
|
rect->xmin += UI_icon_get_width(but->icon);
|
|
|
|
if(but->editstr || (but->flag & UI_TEXT_LEFT))
|
|
rect->xmin += 5;
|
|
}
|
|
else if(but->flag & UI_TEXT_LEFT)
|
|
rect->xmin += 5;
|
|
|
|
/* always draw text for textbutton cursor */
|
|
widget_draw_text(fstyle, wcol, but, rect);
|
|
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/* *********************** widget types ************************************* */
|
|
|
|
|
|
/* uiWidgetStateColors
|
|
char inner_anim[4];
|
|
char inner_anim_sel[4];
|
|
char inner_key[4];
|
|
char inner_key_sel[4];
|
|
char inner_driven[4];
|
|
char inner_driven_sel[4];
|
|
|
|
*/
|
|
|
|
static struct uiWidgetStateColors wcol_state= {
|
|
{115, 190, 76, 255},
|
|
{90, 166, 51, 255},
|
|
{240, 235, 100, 255},
|
|
{148, 204, 76, 255},
|
|
{180, 0, 255, 255},
|
|
{153, 0, 230, 255}
|
|
};
|
|
|
|
/* uiWidgetColors
|
|
float outline[3];
|
|
float inner[4];
|
|
float inner_sel[4];
|
|
float item[3];
|
|
float text[3];
|
|
float text_sel[3];
|
|
|
|
short shaded;
|
|
float shadetop, shadedown;
|
|
*/
|
|
|
|
static struct uiWidgetColors wcol_num= {
|
|
{25, 25, 25, 255},
|
|
{180, 180, 180, 255},
|
|
{153, 153, 153, 255},
|
|
{90, 90, 90, 255},
|
|
|
|
{0, 0, 0, 255},
|
|
{255, 255, 255, 255},
|
|
|
|
1,
|
|
-20, 0
|
|
};
|
|
|
|
static struct uiWidgetColors wcol_numslider= {
|
|
{25, 25, 25, 255},
|
|
{180, 180, 180, 255},
|
|
{153, 153, 153, 255},
|
|
{128, 128, 128, 255},
|
|
|
|
{0, 0, 0, 255},
|
|
{255, 255, 255, 255},
|
|
|
|
1,
|
|
-20, 0
|
|
};
|
|
|
|
static struct uiWidgetColors wcol_text= {
|
|
{25, 25, 25, 255},
|
|
{153, 153, 153, 255},
|
|
{153, 153, 153, 255},
|
|
{90, 90, 90, 255},
|
|
|
|
{0, 0, 0, 255},
|
|
{255, 255, 255, 255},
|
|
|
|
1,
|
|
0, 25
|
|
};
|
|
|
|
static struct uiWidgetColors wcol_option= {
|
|
{0, 0, 0, 255},
|
|
{70, 70, 70, 255},
|
|
{70, 70, 70, 255},
|
|
{255, 255, 255, 255},
|
|
|
|
{0, 0, 0, 255},
|
|
{255, 255, 255, 255},
|
|
|
|
1,
|
|
15, -15
|
|
};
|
|
|
|
/* button that shows popup */
|
|
static struct uiWidgetColors wcol_menu= {
|
|
{0, 0, 0, 255},
|
|
{70, 70, 70, 255},
|
|
{70, 70, 70, 255},
|
|
{255, 255, 255, 255},
|
|
|
|
{255, 255, 255, 255},
|
|
{204, 204, 204, 255},
|
|
|
|
1,
|
|
15, -15
|
|
};
|
|
|
|
/* button that starts pulldown */
|
|
static struct uiWidgetColors wcol_pulldown= {
|
|
{0, 0, 0, 255},
|
|
{63, 63, 63, 255},
|
|
{86, 128, 194, 255},
|
|
{255, 255, 255, 255},
|
|
|
|
{0, 0, 0, 255},
|
|
{0, 0, 0, 255},
|
|
|
|
0,
|
|
25, -20
|
|
};
|
|
|
|
/* button inside menu */
|
|
static struct uiWidgetColors wcol_menu_item= {
|
|
{0, 0, 0, 255},
|
|
{0, 0, 0, 0},
|
|
{86, 128, 194, 255},
|
|
{255, 255, 255, 255},
|
|
|
|
{255, 255, 255, 255},
|
|
{0, 0, 0, 255},
|
|
|
|
0,
|
|
38, 0
|
|
};
|
|
|
|
/* backdrop menu + title text color */
|
|
static struct uiWidgetColors wcol_menu_back= {
|
|
{0, 0, 0, 255},
|
|
{25, 25, 25, 230},
|
|
{45, 45, 45, 230},
|
|
{255, 255, 255, 255},
|
|
|
|
{255, 255, 255, 255},
|
|
{255, 255, 255, 255},
|
|
|
|
0,
|
|
25, -20
|
|
};
|
|
|
|
|
|
static struct uiWidgetColors wcol_radio= {
|
|
{0, 0, 0, 255},
|
|
{70, 70, 70, 255},
|
|
{86, 128, 194, 255},
|
|
{255, 255, 255, 255},
|
|
|
|
{255, 255, 255, 255},
|
|
{0, 0, 0, 255},
|
|
|
|
1,
|
|
15, -15
|
|
};
|
|
|
|
static struct uiWidgetColors wcol_regular= {
|
|
{25, 25, 25, 255},
|
|
{153, 153, 153, 255},
|
|
{100, 100, 100, 255},
|
|
{25, 25, 25, 255},
|
|
|
|
{0, 0, 0, 255},
|
|
{255, 255, 255, 255},
|
|
|
|
0,
|
|
0, 0
|
|
};
|
|
|
|
static struct uiWidgetColors wcol_tool= {
|
|
{25, 25, 25, 255},
|
|
{153, 153, 153, 255},
|
|
{100, 100, 100, 255},
|
|
{25, 25, 25, 255},
|
|
|
|
{0, 0, 0, 255},
|
|
{255, 255, 255, 255},
|
|
|
|
1,
|
|
25, -25
|
|
};
|
|
|
|
static struct uiWidgetColors wcol_box= {
|
|
{25, 25, 25, 255},
|
|
{128, 128, 128, 255},
|
|
{100, 100, 100, 255},
|
|
{25, 25, 25, 255},
|
|
|
|
{0, 0, 0, 255},
|
|
{255, 255, 255, 255},
|
|
|
|
0,
|
|
0, 0
|
|
};
|
|
|
|
/* free wcol struct to play with */
|
|
static struct uiWidgetColors wcol_tmp= {
|
|
{0, 0, 0, 255},
|
|
{128, 128, 128, 255},
|
|
{100, 100, 100, 255},
|
|
{25, 25, 25, 255},
|
|
|
|
{0, 0, 0, 255},
|
|
{255, 255, 255, 255},
|
|
|
|
0,
|
|
0, 0
|
|
};
|
|
|
|
|
|
/* called for theme init (new theme) and versions */
|
|
void ui_widget_color_init(ThemeUI *tui)
|
|
{
|
|
|
|
tui->wcol_regular= wcol_regular;
|
|
tui->wcol_tool= wcol_tool;
|
|
tui->wcol_radio= wcol_radio;
|
|
tui->wcol_text= wcol_text;
|
|
tui->wcol_option= wcol_option;
|
|
tui->wcol_num= wcol_num;
|
|
tui->wcol_numslider= wcol_numslider;
|
|
tui->wcol_menu= wcol_menu;
|
|
tui->wcol_pulldown= wcol_pulldown;
|
|
tui->wcol_menu_back= wcol_menu_back;
|
|
tui->wcol_menu_item= wcol_menu_item;
|
|
tui->wcol_box= wcol_box;
|
|
}
|
|
|
|
/* ************ button callbacks, state ***************** */
|
|
|
|
/* copy colors from theme, and set changes in it based on state */
|
|
static void widget_state(uiWidgetType *wt, int state)
|
|
{
|
|
wt->wcol= *(wt->wcol_theme);
|
|
|
|
if(state & UI_SELECT) {
|
|
if(state & UI_BUT_ANIMATED_KEY)
|
|
QUATCOPY(wt->wcol.inner, wcol_state.inner_key_sel)
|
|
else if(state & UI_BUT_ANIMATED)
|
|
QUATCOPY(wt->wcol.inner, wcol_state.inner_anim_sel)
|
|
else if(state & UI_BUT_DRIVEN)
|
|
QUATCOPY(wt->wcol.inner, wcol_state.inner_driven_sel)
|
|
else
|
|
QUATCOPY(wt->wcol.inner, wt->wcol.inner_sel)
|
|
|
|
VECCOPY(wt->wcol.text, wt->wcol.text_sel);
|
|
|
|
/* only flip shade if it's not "pushed in" already */
|
|
if(wt->wcol.shaded && wt->wcol.shadetop>wt->wcol.shadedown) {
|
|
SWAP(short, wt->wcol.shadetop, wt->wcol.shadedown);
|
|
}
|
|
}
|
|
else {
|
|
if(state & UI_BUT_ANIMATED_KEY)
|
|
QUATCOPY(wt->wcol.inner, wcol_state.inner_key)
|
|
else if(state & UI_BUT_ANIMATED)
|
|
QUATCOPY(wt->wcol.inner, wcol_state.inner_anim)
|
|
else if(state & UI_BUT_DRIVEN)
|
|
QUATCOPY(wt->wcol.inner, wcol_state.inner_driven)
|
|
|
|
if(state & UI_ACTIVE) { /* mouse over? */
|
|
wt->wcol.inner[0]= wt->wcol.inner[0]>=240? 255 : wt->wcol.inner[0]+15;
|
|
wt->wcol.inner[1]= wt->wcol.inner[1]>=240? 255 : wt->wcol.inner[1]+15;
|
|
wt->wcol.inner[2]= wt->wcol.inner[2]>=240? 255 : wt->wcol.inner[2]+15;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* labels use theme colors for text */
|
|
static void widget_state_label(uiWidgetType *wt, int state)
|
|
{
|
|
/* call this for option button */
|
|
widget_state(wt, state);
|
|
|
|
if(state & UI_SELECT)
|
|
UI_GetThemeColor4ubv(TH_TEXT_HI, wt->wcol.text);
|
|
else
|
|
UI_GetThemeColor4ubv(TH_TEXT, wt->wcol.text);
|
|
|
|
}
|
|
|
|
|
|
/* special case, button that calls pulldown */
|
|
static void widget_state_pulldown(uiWidgetType *wt, int state)
|
|
{
|
|
wt->wcol= *(wt->wcol_theme);
|
|
|
|
QUATCOPY(wt->wcol.inner, wt->wcol.inner_sel);
|
|
VECCOPY(wt->wcol.outline, wt->wcol.inner);
|
|
|
|
if(state & UI_ACTIVE)
|
|
VECCOPY(wt->wcol.text, wt->wcol.text_sel);
|
|
}
|
|
|
|
/* special case, menu items */
|
|
static void widget_state_menu_item(uiWidgetType *wt, int state)
|
|
{
|
|
wt->wcol= *(wt->wcol_theme);
|
|
|
|
if(state & (UI_BUT_DISABLED|UI_BUT_INACTIVE)) {
|
|
wt->wcol.text[0]= 0.5f*(wt->wcol.text[0]+wt->wcol.text_sel[0]);
|
|
wt->wcol.text[1]= 0.5f*(wt->wcol.text[1]+wt->wcol.text_sel[1]);
|
|
wt->wcol.text[2]= 0.5f*(wt->wcol.text[2]+wt->wcol.text_sel[2]);
|
|
}
|
|
else if(state & UI_ACTIVE) {
|
|
QUATCOPY(wt->wcol.inner, wt->wcol.inner_sel);
|
|
VECCOPY(wt->wcol.text, wt->wcol.text_sel);
|
|
|
|
wt->wcol.shaded= 1;
|
|
}
|
|
}
|
|
|
|
|
|
/* ************ menu backdrop ************************* */
|
|
|
|
/* outside of rect, rad to left/bottom/right */
|
|
static void widget_softshadow(rcti *rect, int roundboxalign, float radin, float radout)
|
|
{
|
|
uiWidgetBase wtb;
|
|
rcti rect1= *rect;
|
|
float alpha, alphastep;
|
|
int step, tot, a;
|
|
|
|
/* prevent tooltips to not show round shadow */
|
|
if( 2.0f*radout > 0.2f*(rect1.ymax-rect1.ymin) )
|
|
rect1.ymax -= 0.2f*(rect1.ymax-rect1.ymin);
|
|
else
|
|
rect1.ymax -= 2.0f*radout;
|
|
|
|
/* inner part */
|
|
tot= round_box_shadow_edges(wtb.inner_v, &rect1, radin, roundboxalign & 12, 0.0f);
|
|
|
|
/* inverse linear shadow alpha */
|
|
alpha= 0.15;
|
|
alphastep= 0.67;
|
|
|
|
for(step= 1; step<=radout; step++, alpha*=alphastep) {
|
|
round_box_shadow_edges(wtb.outer_v, &rect1, radin, 15, (float)step);
|
|
|
|
glColor4f(0.0f, 0.0f, 0.0f, alpha);
|
|
|
|
glBegin(GL_QUAD_STRIP);
|
|
for(a=0; a<tot; a++) {
|
|
glVertex2fv(wtb.outer_v[a]);
|
|
glVertex2fv(wtb.inner_v[a]);
|
|
}
|
|
glEnd();
|
|
}
|
|
|
|
}
|
|
|
|
static void widget_menu_back(uiWidgetColors *wcol, rcti *rect, int flag, int direction)
|
|
{
|
|
uiWidgetBase wtb;
|
|
int roundboxalign= 15;
|
|
|
|
widget_init(&wtb);
|
|
|
|
/* menu is 2nd level or deeper */
|
|
if (flag & UI_BLOCK_POPUP) {
|
|
//rect->ymin -= 4.0;
|
|
//rect->ymax += 4.0;
|
|
}
|
|
else if (direction == UI_DOWN) {
|
|
roundboxalign= 12;
|
|
rect->ymin -= 4.0;
|
|
}
|
|
else if (direction == UI_TOP) {
|
|
roundboxalign= 3;
|
|
rect->ymax += 4.0;
|
|
}
|
|
|
|
glEnable(GL_BLEND);
|
|
widget_softshadow(rect, roundboxalign, 5.0f, 8.0f);
|
|
|
|
round_box_edges(&wtb, roundboxalign, rect, 5.0f);
|
|
wtb.emboss= 0;
|
|
widgetbase_draw(&wtb, wcol);
|
|
|
|
glDisable(GL_BLEND);
|
|
}
|
|
|
|
|
|
static void ui_hsv_cursor(float x, float y)
|
|
{
|
|
|
|
glPushMatrix();
|
|
glTranslatef(x, y, 0.0f);
|
|
|
|
glColor3f(1.0f, 1.0f, 1.0f);
|
|
glutil_draw_filled_arc(0.0f, M_PI*2.0, 3.0f, 8);
|
|
|
|
glEnable(GL_BLEND);
|
|
glEnable(GL_LINE_SMOOTH );
|
|
glColor3f(0.0f, 0.0f, 0.0f);
|
|
glutil_draw_lined_arc(0.0f, M_PI*2.0, 3.0f, 12);
|
|
glDisable(GL_BLEND);
|
|
glDisable(GL_LINE_SMOOTH );
|
|
|
|
glPopMatrix();
|
|
|
|
}
|
|
|
|
void ui_hsvcircle_vals_from_pos(float *valrad, float *valdist, rcti *rect, float mx, float my)
|
|
{
|
|
/* duplication of code... well, simple is better now */
|
|
float centx= (float)(rect->xmin + rect->xmax)/2;
|
|
float centy= (float)(rect->ymin + rect->ymax)/2;
|
|
float radius, dist;
|
|
|
|
if( rect->xmax-rect->xmin > rect->ymax-rect->ymin )
|
|
radius= (float)(rect->ymax - rect->ymin)/2;
|
|
else
|
|
radius= (float)(rect->xmax - rect->xmin)/2;
|
|
|
|
mx-= centx;
|
|
my-= centy;
|
|
dist= sqrt( mx*mx + my*my);
|
|
if(dist < radius)
|
|
*valdist= dist/radius;
|
|
else
|
|
*valdist= 1.0f;
|
|
|
|
*valrad= atan2(mx, my)/(2.0f*M_PI) + 0.5f;
|
|
}
|
|
|
|
void ui_draw_but_HSVCIRCLE(uiBut *but, rcti *rect)
|
|
{
|
|
/* gouraud triangle fan */
|
|
float radstep, ang= 0.0f;
|
|
float centx, centy, radius;
|
|
float hsv[3], col[3], colcent[3];
|
|
int a, tot= 32;
|
|
|
|
radstep= 2.0f*M_PI/(float)tot;
|
|
centx= (float)(rect->xmin + rect->xmax)/2;
|
|
centy= (float)(rect->ymin + rect->ymax)/2;
|
|
|
|
if( rect->xmax-rect->xmin > rect->ymax-rect->ymin )
|
|
radius= (float)(rect->ymax - rect->ymin)/2;
|
|
else
|
|
radius= (float)(rect->xmax - rect->xmin)/2;
|
|
|
|
/* color */
|
|
VECCOPY(hsv, but->hsv);
|
|
hsv[0]= hsv[1]= 0.0f;
|
|
hsv_to_rgb(hsv[0], hsv[1], hsv[2], colcent, colcent+1, colcent+2);
|
|
|
|
glShadeModel(GL_SMOOTH);
|
|
|
|
glBegin(GL_TRIANGLE_FAN);
|
|
glColor3fv(colcent);
|
|
glVertex2f( centx, centy);
|
|
|
|
for(a=0; a<=tot; a++, ang+=radstep) {
|
|
float si= sin(ang);
|
|
float co= cos(ang);
|
|
|
|
ui_hsvcircle_vals_from_pos(hsv, hsv+1, rect, centx + co*radius, centy + si*radius);
|
|
hsv_to_rgb(hsv[0], hsv[1], hsv[2], col, col+1, col+2);
|
|
glColor3fv(col);
|
|
glVertex2f( centx + co*radius, centy + si*radius);
|
|
}
|
|
glEnd();
|
|
|
|
glShadeModel(GL_FLAT);
|
|
|
|
/* fully rounded outline */
|
|
glPushMatrix();
|
|
glTranslatef(centx, centy, 0.0f);
|
|
glEnable(GL_BLEND);
|
|
glEnable(GL_LINE_SMOOTH );
|
|
glColor3f(0.0f, 0.0f, 0.0f);
|
|
glutil_draw_lined_arc(0.0f, M_PI*2.0, radius, tot);
|
|
glDisable(GL_BLEND);
|
|
glDisable(GL_LINE_SMOOTH );
|
|
glPopMatrix();
|
|
|
|
/* cursor */
|
|
ang= 2.0f*M_PI*but->hsv[0] + 0.5f*M_PI;
|
|
radius= but->hsv[1]*radius;
|
|
ui_hsv_cursor(centx + cos(-ang)*radius, centy + sin(-ang)*radius);
|
|
|
|
}
|
|
|
|
/* ************ custom buttons, old stuff ************** */
|
|
|
|
/* draws in resolution of 20x4 colors */
|
|
static void ui_draw_but_HSVCUBE(uiBut *but, rcti *rect)
|
|
{
|
|
int a;
|
|
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
|
|
|
|
h= but->hsv[0];
|
|
s= but->hsv[1];
|
|
v= but->hsv[2];
|
|
|
|
/* draw series of gouraud rects */
|
|
glShadeModel(GL_SMOOTH);
|
|
|
|
if(but->a1==0) { // H and V vary
|
|
hsv_to_rgb(0.0, s, 0.0, &col1[0][0], &col1[0][1], &col1[0][2]);
|
|
hsv_to_rgb(0.0, s, 0.333, &col1[1][0], &col1[1][1], &col1[1][2]);
|
|
hsv_to_rgb(0.0, s, 0.666, &col1[2][0], &col1[2][1], &col1[2][2]);
|
|
hsv_to_rgb(0.0, s, 1.0, &col1[3][0], &col1[3][1], &col1[3][2]);
|
|
x= h; y= v;
|
|
}
|
|
else if(but->a1==1) { // H and S vary
|
|
hsv_to_rgb(0.0, 0.0, v, &col1[0][0], &col1[0][1], &col1[0][2]);
|
|
hsv_to_rgb(0.0, 0.333, v, &col1[1][0], &col1[1][1], &col1[1][2]);
|
|
hsv_to_rgb(0.0, 0.666, v, &col1[2][0], &col1[2][1], &col1[2][2]);
|
|
hsv_to_rgb(0.0, 1.0, v, &col1[3][0], &col1[3][1], &col1[3][2]);
|
|
x= h; y= s;
|
|
}
|
|
else if(but->a1==2) { // S and V vary
|
|
hsv_to_rgb(h, 0.0, 0.0, &col1[0][0], &col1[0][1], &col1[0][2]);
|
|
hsv_to_rgb(h, 0.333, 0.0, &col1[1][0], &col1[1][1], &col1[1][2]);
|
|
hsv_to_rgb(h, 0.666, 0.0, &col1[2][0], &col1[2][1], &col1[2][2]);
|
|
hsv_to_rgb(h, 1.0, 0.0, &col1[3][0], &col1[3][1], &col1[3][2]);
|
|
x= v; y= s;
|
|
}
|
|
else if(but->a1==3) { // only hue slider
|
|
hsv_to_rgb(0.0, 1.0, 1.0, &col1[0][0], &col1[0][1], &col1[0][2]);
|
|
VECCOPY(col1[1], col1[0]);
|
|
VECCOPY(col1[2], col1[0]);
|
|
VECCOPY(col1[3], col1[0]);
|
|
x= h; y= 0.5;
|
|
}
|
|
|
|
for(dx=0.0; dx<1.0; dx+= 0.05) {
|
|
// previous color
|
|
VECCOPY(col0[0], col1[0]);
|
|
VECCOPY(col0[1], col1[1]);
|
|
VECCOPY(col0[2], col1[2]);
|
|
VECCOPY(col0[3], col1[3]);
|
|
|
|
// new color
|
|
if(but->a1==0) { // H and V vary
|
|
hsv_to_rgb(dx, s, 0.0, &col1[0][0], &col1[0][1], &col1[0][2]);
|
|
hsv_to_rgb(dx, s, 0.333, &col1[1][0], &col1[1][1], &col1[1][2]);
|
|
hsv_to_rgb(dx, s, 0.666, &col1[2][0], &col1[2][1], &col1[2][2]);
|
|
hsv_to_rgb(dx, s, 1.0, &col1[3][0], &col1[3][1], &col1[3][2]);
|
|
}
|
|
else if(but->a1==1) { // H and S vary
|
|
hsv_to_rgb(dx, 0.0, v, &col1[0][0], &col1[0][1], &col1[0][2]);
|
|
hsv_to_rgb(dx, 0.333, v, &col1[1][0], &col1[1][1], &col1[1][2]);
|
|
hsv_to_rgb(dx, 0.666, v, &col1[2][0], &col1[2][1], &col1[2][2]);
|
|
hsv_to_rgb(dx, 1.0, v, &col1[3][0], &col1[3][1], &col1[3][2]);
|
|
}
|
|
else if(but->a1==2) { // S and V vary
|
|
hsv_to_rgb(h, 0.0, dx, &col1[0][0], &col1[0][1], &col1[0][2]);
|
|
hsv_to_rgb(h, 0.333, dx, &col1[1][0], &col1[1][1], &col1[1][2]);
|
|
hsv_to_rgb(h, 0.666, dx, &col1[2][0], &col1[2][1], &col1[2][2]);
|
|
hsv_to_rgb(h, 1.0, dx, &col1[3][0], &col1[3][1], &col1[3][2]);
|
|
}
|
|
else if(but->a1==3) { // only H
|
|
hsv_to_rgb(dx, 1.0, 1.0, &col1[0][0], &col1[0][1], &col1[0][2]);
|
|
VECCOPY(col1[1], col1[0]);
|
|
VECCOPY(col1[2], col1[0]);
|
|
VECCOPY(col1[3], col1[0]);
|
|
}
|
|
|
|
// rect
|
|
sx1= rect->xmin + dx*(rect->xmax-rect->xmin);
|
|
sx2= rect->xmin + (dx+0.05)*(rect->xmax-rect->xmin);
|
|
sy= rect->ymin;
|
|
dy= (rect->ymax-rect->ymin)/3.0;
|
|
|
|
glBegin(GL_QUADS);
|
|
for(a=0; a<3; a++, sy+=dy) {
|
|
glColor3fv(col0[a]);
|
|
glVertex2f(sx1, sy);
|
|
|
|
glColor3fv(col1[a]);
|
|
glVertex2f(sx2, sy);
|
|
|
|
glColor3fv(col1[a+1]);
|
|
glVertex2f(sx2, sy+dy);
|
|
|
|
glColor3fv(col0[a+1]);
|
|
glVertex2f(sx1, sy+dy);
|
|
}
|
|
glEnd();
|
|
}
|
|
|
|
glShadeModel(GL_FLAT);
|
|
|
|
/* cursor */
|
|
x= rect->xmin + x*(rect->xmax-rect->xmin);
|
|
y= rect->ymin + y*(rect->ymax-rect->ymin);
|
|
CLAMP(x, rect->xmin+3.0, rect->xmax-3.0);
|
|
CLAMP(y, rect->ymin+3.0, rect->ymax-3.0);
|
|
|
|
ui_hsv_cursor(x, y);
|
|
|
|
/* outline */
|
|
glColor3ub(0, 0, 0);
|
|
fdrawbox((rect->xmin), (rect->ymin), (rect->xmax), (rect->ymax));
|
|
}
|
|
|
|
/* vertical 'value' slider, using new widget code */
|
|
static void ui_draw_but_HSV_v(uiBut *but, rcti *rect)
|
|
{
|
|
uiWidgetBase wtb;
|
|
float rad= 0.5f*(rect->xmax - rect->xmin);
|
|
float x, y;
|
|
|
|
widget_init(&wtb);
|
|
|
|
/* fully rounded */
|
|
round_box_edges(&wtb, 15, rect, rad);
|
|
|
|
/* setup temp colors */
|
|
wcol_tmp.outline[0]= wcol_tmp.outline[1]= wcol_tmp.outline[2]= 0;
|
|
wcol_tmp.inner[0]= wcol_tmp.inner[1]= wcol_tmp.inner[2]= 128;
|
|
wcol_tmp.shadetop= 127;
|
|
wcol_tmp.shadedown= -128;
|
|
wcol_tmp.shaded= 1;
|
|
|
|
widgetbase_draw(&wtb, &wcol_tmp);
|
|
|
|
/* cursor */
|
|
x= rect->xmin + 0.5f*(rect->xmax-rect->xmin);
|
|
y= rect->ymin + but->hsv[2]*(rect->ymax-rect->ymin);
|
|
CLAMP(y, rect->ymin+3.0, rect->ymax-3.0);
|
|
|
|
ui_hsv_cursor(x, y);
|
|
|
|
}
|
|
|
|
/* ************ button callbacks, draw ***************** */
|
|
|
|
static void widget_numbut(uiWidgetColors *wcol, rcti *rect, int state, int roundboxalign)
|
|
{
|
|
uiWidgetBase wtb;
|
|
float rad= 0.5f*(rect->ymax - rect->ymin);
|
|
|
|
widget_init(&wtb);
|
|
|
|
/* fully rounded */
|
|
round_box_edges(&wtb, roundboxalign, rect, rad);
|
|
|
|
/* decoration */
|
|
if(!(state & UI_TEXTINPUT)) {
|
|
widget_num_tria(&wtb.tria1, rect, 0.6f, 0);
|
|
widget_num_tria(&wtb.tria2, rect, 0.6f, 'r');
|
|
}
|
|
widgetbase_draw(&wtb, wcol);
|
|
|
|
/* text space */
|
|
rect->xmin += (rect->ymax-rect->ymin);
|
|
rect->xmax -= (rect->ymax-rect->ymin);
|
|
|
|
}
|
|
|
|
static void widget_numslider(uiBut *but, uiWidgetColors *wcol, rcti *rect, int state, int roundboxalign)
|
|
{
|
|
uiWidgetBase wtb, wtb1;
|
|
rcti rect1;
|
|
double value;
|
|
float offs, fac;
|
|
char outline[3];
|
|
|
|
widget_init(&wtb);
|
|
widget_init(&wtb1);
|
|
|
|
/* backdrop first */
|
|
|
|
/* fully rounded */
|
|
offs= 0.5f*(rect->ymax - rect->ymin);
|
|
round_box_edges(&wtb, roundboxalign, rect, offs);
|
|
|
|
wtb.outline= 0;
|
|
widgetbase_draw(&wtb, wcol);
|
|
|
|
/* slider part */
|
|
VECCOPY(outline, wcol->outline);
|
|
VECCOPY(wcol->outline, wcol->item);
|
|
VECCOPY(wcol->inner, wcol->item);
|
|
SWAP(short, wcol->shadetop, wcol->shadedown);
|
|
|
|
rect1= *rect;
|
|
|
|
value= ui_get_but_val(but);
|
|
fac= (value-but->softmin)*(rect1.xmax - rect1.xmin - offs)/(but->softmax - but->softmin);
|
|
|
|
/* left part of slider, always rounded */
|
|
rect1.xmax= rect1.xmin + ceil(offs+1.0f);
|
|
round_box_edges(&wtb1, roundboxalign & ~6, &rect1, offs);
|
|
wtb1.outline= 0;
|
|
widgetbase_draw(&wtb1, wcol);
|
|
|
|
/* right part of slider, interpolate roundness */
|
|
rect1.xmax= rect1.xmin + fac + offs;
|
|
rect1.xmin+= floor(offs-1.0f);
|
|
if(rect1.xmax + offs > rect->xmax)
|
|
offs*= (rect1.xmax + offs - rect->xmax)/offs;
|
|
else
|
|
offs= 0.0f;
|
|
round_box_edges(&wtb1, roundboxalign & ~9, &rect1, offs);
|
|
|
|
widgetbase_draw(&wtb1, wcol);
|
|
VECCOPY(wcol->outline, outline);
|
|
SWAP(short, wcol->shadetop, wcol->shadedown);
|
|
|
|
/* outline */
|
|
wtb.outline= 1;
|
|
wtb.inner= 0;
|
|
widgetbase_draw(&wtb, wcol);
|
|
|
|
/* text space */
|
|
rect->xmin += (rect->ymax-rect->ymin);
|
|
rect->xmax -= (rect->ymax-rect->ymin);
|
|
|
|
}
|
|
|
|
static void widget_swatch(uiBut *but, uiWidgetColors *wcol, rcti *rect, int state, int roundboxalign)
|
|
{
|
|
uiWidgetBase wtb;
|
|
float col[4];
|
|
|
|
widget_init(&wtb);
|
|
|
|
/* half rounded */
|
|
round_box_edges(&wtb, roundboxalign, rect, 4.0f);
|
|
|
|
ui_get_but_vectorf(but, col);
|
|
wcol->inner[0]= FTOCHAR(col[0]);
|
|
wcol->inner[1]= FTOCHAR(col[1]);
|
|
wcol->inner[2]= FTOCHAR(col[2]);
|
|
|
|
widgetbase_draw(&wtb, wcol);
|
|
|
|
}
|
|
|
|
|
|
static void widget_textbut(uiWidgetColors *wcol, rcti *rect, int state, int roundboxalign)
|
|
{
|
|
uiWidgetBase wtb;
|
|
|
|
widget_init(&wtb);
|
|
|
|
/* half rounded */
|
|
round_box_edges(&wtb, roundboxalign, rect, 5.0f);
|
|
|
|
widgetbase_draw(&wtb, wcol);
|
|
|
|
}
|
|
|
|
|
|
static void widget_menubut(uiWidgetColors *wcol, rcti *rect, int state, int roundboxalign)
|
|
{
|
|
uiWidgetBase wtb;
|
|
|
|
widget_init(&wtb);
|
|
|
|
/* half rounded */
|
|
round_box_edges(&wtb, roundboxalign, rect, 4.0f);
|
|
|
|
/* decoration */
|
|
widget_menu_trias(&wtb.tria1, rect);
|
|
|
|
widgetbase_draw(&wtb, wcol);
|
|
|
|
/* text space */
|
|
rect->xmax -= (rect->ymax-rect->ymin);
|
|
|
|
}
|
|
|
|
static void widget_pulldownbut(uiWidgetColors *wcol, rcti *rect, int state, int roundboxalign)
|
|
{
|
|
if(state & UI_ACTIVE) {
|
|
uiWidgetBase wtb;
|
|
float rad= 0.5f*(rect->ymax - rect->ymin);
|
|
|
|
widget_init(&wtb);
|
|
|
|
/* fully rounded */
|
|
round_box_edges(&wtb, roundboxalign, rect, rad);
|
|
|
|
widgetbase_draw(&wtb, wcol);
|
|
}
|
|
}
|
|
|
|
static void widget_menu_itembut(uiWidgetColors *wcol, rcti *rect, int state, int roundboxalign)
|
|
{
|
|
uiWidgetBase wtb;
|
|
|
|
widget_init(&wtb);
|
|
|
|
/* not rounded, no outline */
|
|
wtb.outline= 0;
|
|
round_box_edges(&wtb, 0, rect, 0.0f);
|
|
|
|
widgetbase_draw(&wtb, wcol);
|
|
}
|
|
|
|
|
|
static void widget_optionbut(uiWidgetColors *wcol, rcti *rect, int state, int roundboxalign)
|
|
{
|
|
uiWidgetBase wtb;
|
|
rcti recttemp= *rect;
|
|
int delta;
|
|
|
|
widget_init(&wtb);
|
|
|
|
/* square */
|
|
recttemp.xmax= recttemp.xmin + (recttemp.ymax-recttemp.ymin);
|
|
|
|
/* smaller */
|
|
delta= 1 + (recttemp.ymax-recttemp.ymin)/8;
|
|
recttemp.xmin+= delta;
|
|
recttemp.ymin+= delta;
|
|
recttemp.xmax-= delta;
|
|
recttemp.ymax-= delta;
|
|
|
|
/* half rounded */
|
|
round_box_edges(&wtb, 15, &recttemp, 4.0f);
|
|
|
|
/* decoration */
|
|
if(state & UI_SELECT) {
|
|
widget_check_trias(&wtb.tria1, &recttemp);
|
|
}
|
|
|
|
widgetbase_draw(&wtb, wcol);
|
|
|
|
/* text space */
|
|
rect->xmin += (rect->ymax-rect->ymin)*0.7 + delta;
|
|
}
|
|
|
|
|
|
static void widget_radiobut(uiWidgetColors *wcol, rcti *rect, int state, int roundboxalign)
|
|
{
|
|
uiWidgetBase wtb;
|
|
|
|
widget_init(&wtb);
|
|
|
|
/* half rounded */
|
|
round_box_edges(&wtb, roundboxalign, rect, 4.0f);
|
|
|
|
widgetbase_draw(&wtb, wcol);
|
|
|
|
}
|
|
|
|
static void widget_but(uiWidgetColors *wcol, rcti *rect, int state, int roundboxalign)
|
|
{
|
|
uiWidgetBase wtb;
|
|
|
|
widget_init(&wtb);
|
|
|
|
/* half rounded */
|
|
round_box_edges(&wtb, roundboxalign, rect, 4.0f);
|
|
|
|
widgetbase_draw(&wtb, wcol);
|
|
|
|
}
|
|
|
|
static void widget_roundbut(uiWidgetColors *wcol, rcti *rect, int state, int roundboxalign)
|
|
{
|
|
uiWidgetBase wtb;
|
|
float rad= 0.5f*(rect->ymax - rect->ymin);
|
|
|
|
widget_init(&wtb);
|
|
|
|
/* fully rounded */
|
|
round_box_edges(&wtb, roundboxalign, rect, rad);
|
|
|
|
widgetbase_draw(&wtb, wcol);
|
|
}
|
|
|
|
static void widget_draw_extra_mask(const bContext *C, uiBut *but, uiWidgetType *wt, rcti *rect)
|
|
{
|
|
uiWidgetBase wtb;
|
|
char col[4];
|
|
|
|
/* state copy! */
|
|
wt->wcol= *(wt->wcol_theme);
|
|
|
|
widget_init(&wtb);
|
|
|
|
if(but->block->drawextra) {
|
|
/* note: drawextra can change rect +1 or -1, to match round errors of existing previews */
|
|
but->block->drawextra(C, but->poin, rect);
|
|
|
|
/* make mask to draw over image */
|
|
UI_GetThemeColor3ubv(TH_BACK, col);
|
|
glColor3ubv(col);
|
|
|
|
round_box__edges(&wtb, 15, rect, 0.0f, 4.0);
|
|
widgetbase_outline(&wtb);
|
|
}
|
|
|
|
/* outline */
|
|
round_box_edges(&wtb, 15, rect, 5.0f);
|
|
wtb.outline= 1;
|
|
wtb.inner= 0;
|
|
widgetbase_draw(&wtb, &wt->wcol);
|
|
|
|
}
|
|
|
|
|
|
static void widget_disabled(rcti *rect)
|
|
{
|
|
float col[4];
|
|
|
|
glEnable(GL_BLEND);
|
|
|
|
/* can't use theme TH_BACK or TH_PANEL... undefined */
|
|
glGetFloatv(GL_COLOR_CLEAR_VALUE, col);
|
|
glColor4f(col[0], col[1], col[2], 0.5f);
|
|
glRectf(rect->xmin, rect->ymin, rect->xmax, rect->ymax);
|
|
|
|
glDisable(GL_BLEND);
|
|
}
|
|
|
|
static uiWidgetType *widget_type(uiWidgetTypeEnum type)
|
|
{
|
|
bTheme *btheme= U.themes.first;
|
|
static uiWidgetType wt;
|
|
|
|
/* defaults */
|
|
wt.wcol_theme= &btheme->tui.wcol_regular;
|
|
wt.state= widget_state;
|
|
wt.draw= widget_but;
|
|
wt.custom= NULL;
|
|
wt.text= widget_draw_text_icon;
|
|
|
|
switch(type) {
|
|
case UI_WTYPE_LABEL:
|
|
wt.draw= NULL;
|
|
wt.state= widget_state_label;
|
|
break;
|
|
|
|
case UI_WTYPE_TOGGLE:
|
|
break;
|
|
|
|
case UI_WTYPE_OPTION:
|
|
wt.wcol_theme= &btheme->tui.wcol_option;
|
|
wt.draw= widget_optionbut;
|
|
wt.state= widget_state_label;
|
|
break;
|
|
|
|
case UI_WTYPE_RADIO:
|
|
wt.wcol_theme= &btheme->tui.wcol_radio;
|
|
wt.draw= widget_radiobut;
|
|
break;
|
|
|
|
case UI_WTYPE_NUMBER:
|
|
wt.wcol_theme= &btheme->tui.wcol_num;
|
|
wt.draw= widget_numbut;
|
|
break;
|
|
|
|
case UI_WTYPE_SLIDER:
|
|
wt.wcol_theme= &btheme->tui.wcol_numslider;
|
|
wt.custom= widget_numslider;
|
|
break;
|
|
|
|
case UI_WTYPE_EXEC:
|
|
wt.wcol_theme= &btheme->tui.wcol_tool;
|
|
wt.draw= widget_roundbut;
|
|
break;
|
|
|
|
|
|
/* strings */
|
|
case UI_WTYPE_NAME:
|
|
wt.wcol_theme= &btheme->tui.wcol_text;
|
|
wt.draw= widget_textbut;
|
|
break;
|
|
|
|
case UI_WTYPE_NAME_LINK:
|
|
break;
|
|
|
|
case UI_WTYPE_POINTER_LINK:
|
|
break;
|
|
|
|
case UI_WTYPE_FILENAME:
|
|
break;
|
|
|
|
|
|
/* start menus */
|
|
case UI_WTYPE_MENU_RADIO:
|
|
wt.wcol_theme= &btheme->tui.wcol_menu;
|
|
wt.draw= widget_menubut;
|
|
break;
|
|
|
|
case UI_WTYPE_MENU_POINTER_LINK:
|
|
wt.wcol_theme= &btheme->tui.wcol_menu;
|
|
wt.draw= widget_menubut;
|
|
break;
|
|
|
|
|
|
case UI_WTYPE_PULLDOWN:
|
|
wt.wcol_theme= &btheme->tui.wcol_pulldown;
|
|
wt.draw= widget_pulldownbut;
|
|
wt.state= widget_state_pulldown;
|
|
break;
|
|
|
|
/* in menus */
|
|
case UI_WTYPE_MENU_ITEM:
|
|
wt.wcol_theme= &btheme->tui.wcol_menu_item;
|
|
wt.draw= widget_menu_itembut;
|
|
wt.state= widget_state_menu_item;
|
|
break;
|
|
|
|
case UI_WTYPE_MENU_BACK:
|
|
wt.wcol_theme= &btheme->tui.wcol_menu_back;
|
|
wt.draw= widget_menu_back;
|
|
break;
|
|
|
|
/* specials */
|
|
case UI_WTYPE_ICON:
|
|
wt.draw= NULL;
|
|
break;
|
|
|
|
case UI_WTYPE_SWATCH:
|
|
wt.custom= widget_swatch;
|
|
break;
|
|
|
|
case UI_WTYPE_BOX:
|
|
wt.wcol_theme= &btheme->tui.wcol_box;
|
|
break;
|
|
|
|
case UI_WTYPE_RGB_PICKER:
|
|
break;
|
|
|
|
case UI_WTYPE_NORMAL:
|
|
break;
|
|
}
|
|
|
|
return &wt;
|
|
}
|
|
|
|
|
|
static int widget_roundbox_set(uiBut *but, rcti *rect)
|
|
{
|
|
/* alignment */
|
|
if(but->flag & UI_BUT_ALIGN) {
|
|
|
|
if(but->flag & UI_BUT_ALIGN_TOP)
|
|
rect->ymax+= 1;
|
|
if(but->flag & UI_BUT_ALIGN_LEFT)
|
|
rect->xmin-= 1;
|
|
|
|
switch(but->flag & UI_BUT_ALIGN) {
|
|
case UI_BUT_ALIGN_TOP:
|
|
return (12);
|
|
break;
|
|
case UI_BUT_ALIGN_DOWN:
|
|
return (3);
|
|
break;
|
|
case UI_BUT_ALIGN_LEFT:
|
|
return (6);
|
|
break;
|
|
case UI_BUT_ALIGN_RIGHT:
|
|
return (9);
|
|
break;
|
|
|
|
case UI_BUT_ALIGN_DOWN|UI_BUT_ALIGN_RIGHT:
|
|
return (1);
|
|
break;
|
|
case UI_BUT_ALIGN_DOWN|UI_BUT_ALIGN_LEFT:
|
|
return (2);
|
|
break;
|
|
case UI_BUT_ALIGN_TOP|UI_BUT_ALIGN_RIGHT:
|
|
return (8);
|
|
break;
|
|
case UI_BUT_ALIGN_TOP|UI_BUT_ALIGN_LEFT:
|
|
return (4);
|
|
break;
|
|
|
|
default:
|
|
return (0);
|
|
break;
|
|
}
|
|
}
|
|
return 15;
|
|
}
|
|
|
|
/* conversion from old to new buttons, so still messy */
|
|
void ui_draw_but(const bContext *C, ARegion *ar, uiStyle *style, uiBut *but, rcti *rect)
|
|
{
|
|
bTheme *btheme= U.themes.first;
|
|
ThemeUI *tui= &btheme->tui;
|
|
uiFontStyle *fstyle= &style->widget;
|
|
uiWidgetType *wt= NULL;
|
|
|
|
/* handle menus seperately */
|
|
if(but->dt==UI_EMBOSSP) {
|
|
switch (but->type) {
|
|
case LABEL:
|
|
widget_draw_text_icon(&style->widgetlabel, &tui->wcol_menu_back, but, rect);
|
|
break;
|
|
case SEPR:
|
|
break;
|
|
|
|
default:
|
|
wt= widget_type(UI_WTYPE_MENU_ITEM);
|
|
}
|
|
}
|
|
else if(but->dt==UI_EMBOSSN) {
|
|
/* "nothing" */
|
|
wt= widget_type(UI_WTYPE_ICON);
|
|
}
|
|
else {
|
|
|
|
switch (but->type) {
|
|
case LABEL:
|
|
if(but->block->flag & UI_BLOCK_LOOP)
|
|
widget_draw_text_icon(&style->widgetlabel, &tui->wcol_menu_back, but, rect);
|
|
else {
|
|
wt= widget_type(UI_WTYPE_LABEL);
|
|
fstyle= &style->widgetlabel;
|
|
}
|
|
break;
|
|
|
|
case SEPR:
|
|
break;
|
|
|
|
case BUT:
|
|
wt= widget_type(UI_WTYPE_EXEC);
|
|
break;
|
|
case NUM:
|
|
wt= widget_type(UI_WTYPE_NUMBER);
|
|
break;
|
|
|
|
case NUMSLI:
|
|
case HSVSLI:
|
|
wt= widget_type(UI_WTYPE_SLIDER);
|
|
break;
|
|
|
|
case ROW:
|
|
wt= widget_type(UI_WTYPE_RADIO);
|
|
break;
|
|
|
|
case TEX:
|
|
wt= widget_type(UI_WTYPE_NAME);
|
|
break;
|
|
|
|
case SEARCH_MENU:
|
|
wt= widget_type(UI_WTYPE_NAME);
|
|
if(but->block->flag & UI_BLOCK_LOOP)
|
|
wt->wcol_theme= &btheme->tui.wcol_menu_back;
|
|
break;
|
|
|
|
case TOGBUT:
|
|
case TOG:
|
|
case TOGN:
|
|
case TOG3:
|
|
wt= widget_type(UI_WTYPE_TOGGLE);
|
|
break;
|
|
|
|
case OPTION:
|
|
case OPTIONN:
|
|
if (!(but->flag & UI_HAS_ICON)) {
|
|
wt= widget_type(UI_WTYPE_OPTION);
|
|
but->flag |= UI_TEXT_LEFT;
|
|
}
|
|
else
|
|
wt= widget_type(UI_WTYPE_TOGGLE);
|
|
break;
|
|
|
|
case MENU:
|
|
case BLOCK:
|
|
case ICONTEXTROW:
|
|
wt= widget_type(UI_WTYPE_MENU_RADIO);
|
|
break;
|
|
|
|
case PULLDOWN:
|
|
wt= widget_type(UI_WTYPE_PULLDOWN);
|
|
break;
|
|
|
|
case BUTM:
|
|
wt= widget_type(UI_WTYPE_MENU_ITEM);
|
|
break;
|
|
|
|
case COL:
|
|
wt= widget_type(UI_WTYPE_SWATCH);
|
|
break;
|
|
|
|
case ROUNDBOX:
|
|
wt= widget_type(UI_WTYPE_BOX);
|
|
break;
|
|
|
|
case BUT_EXTRA:
|
|
widget_draw_extra_mask(C, but, widget_type(UI_WTYPE_BOX), rect);
|
|
break;
|
|
|
|
case HSVCUBE:
|
|
if(but->a1==4) // vertical V slider, uses new widget draw now
|
|
ui_draw_but_HSV_v(but, rect);
|
|
else // other HSV pickers...
|
|
ui_draw_but_HSVCUBE(but, rect);
|
|
break;
|
|
|
|
case HSVCIRCLE:
|
|
ui_draw_but_HSVCIRCLE(but, rect);
|
|
break;
|
|
|
|
case BUT_COLORBAND:
|
|
ui_draw_but_COLORBAND(but, &tui->wcol_regular, rect);
|
|
break;
|
|
|
|
case BUT_NORMAL:
|
|
ui_draw_but_NORMAL(but, &tui->wcol_regular, rect);
|
|
break;
|
|
|
|
case BUT_CURVE:
|
|
ui_draw_but_CURVE(ar, but, &tui->wcol_regular, rect);
|
|
break;
|
|
|
|
default:
|
|
wt= widget_type(UI_WTYPE_TOGGLE);
|
|
}
|
|
}
|
|
|
|
if(wt) {
|
|
rcti disablerect= *rect; /* rect gets clipped smaller for text */
|
|
int roundboxalign, state;
|
|
|
|
roundboxalign= widget_roundbox_set(but, rect);
|
|
state= but->flag;
|
|
if(but->editstr) state |= UI_TEXTINPUT;
|
|
|
|
wt->state(wt, state);
|
|
if(wt->custom)
|
|
wt->custom(but, &wt->wcol, rect, state, roundboxalign);
|
|
else if(wt->draw)
|
|
wt->draw(&wt->wcol, rect, state, roundboxalign);
|
|
wt->text(fstyle, &wt->wcol, but, rect);
|
|
|
|
if(state & (UI_BUT_DISABLED|UI_BUT_INACTIVE))
|
|
if(but->dt!=UI_EMBOSSP)
|
|
widget_disabled(&disablerect);
|
|
}
|
|
}
|
|
|
|
void ui_draw_menu_back(uiStyle *style, uiBlock *block, rcti *rect)
|
|
{
|
|
uiWidgetType *wt= widget_type(UI_WTYPE_MENU_BACK);
|
|
|
|
wt->state(wt, 0);
|
|
if(block)
|
|
wt->draw(&wt->wcol, rect, block->flag, block->direction);
|
|
else
|
|
wt->draw(&wt->wcol, rect, 0, 0);
|
|
|
|
}
|
|
|
|
void ui_draw_search_back(uiStyle *style, uiBlock *block, rcti *rect)
|
|
{
|
|
uiWidgetType *wt= widget_type(UI_WTYPE_BOX);
|
|
|
|
glEnable(GL_BLEND);
|
|
widget_softshadow(rect, 15, 5.0f, 8.0f);
|
|
glDisable(GL_BLEND);
|
|
|
|
wt->state(wt, 0);
|
|
if(block)
|
|
wt->draw(&wt->wcol, rect, block->flag, 15);
|
|
else
|
|
wt->draw(&wt->wcol, rect, 0, 15);
|
|
|
|
}
|
|
|
|
|
|
/* helper call to draw a menu item without button */
|
|
/* state: UI_ACTIVE or 0 */
|
|
void ui_draw_menu_item(uiFontStyle *fstyle, rcti *rect, char *name, int state)
|
|
{
|
|
uiWidgetType *wt= widget_type(UI_WTYPE_MENU_ITEM);
|
|
rcti _rect= *rect;
|
|
char *cpoin;
|
|
|
|
wt->state(wt, state);
|
|
wt->draw(&wt->wcol, rect, 0, 0);
|
|
|
|
uiStyleFontSet(fstyle);
|
|
fstyle->align= UI_STYLE_TEXT_LEFT;
|
|
|
|
/* text location offset */
|
|
rect->xmin+=5;
|
|
|
|
/* cut string in 2 parts? */
|
|
cpoin= strchr(name, '|');
|
|
if(cpoin) {
|
|
*cpoin= 0;
|
|
rect->xmax -= BLF_width(cpoin+1) + 10;
|
|
}
|
|
|
|
glColor3ubv(wt->wcol.text);
|
|
uiStyleFontDraw(fstyle, rect, name);
|
|
|
|
/* part text right aligned */
|
|
if(cpoin) {
|
|
fstyle->align= UI_STYLE_TEXT_RIGHT;
|
|
rect->xmax= _rect.xmax - 5;
|
|
uiStyleFontDraw(fstyle, rect, cpoin+1);
|
|
*cpoin= '|';
|
|
}
|
|
|
|
/* restore rect, was messed with */
|
|
*rect= _rect;
|
|
|
|
}
|
|
|