Merge branch 'blender2.7'
[blender.git] / source / blender / editors / interface / interface_widgets.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2009 Blender Foundation.
19  * All rights reserved.
20  *
21  * Contributor(s): Blender Foundation
22  *
23  * ***** END GPL LICENSE BLOCK *****
24  */
25
26 /** \file blender/editors/interface/interface_widgets.c
27  *  \ingroup edinterface
28  */
29
30 #include <limits.h>
31 #include <stdlib.h>
32 #include <string.h>
33 #include <assert.h>
34
35 #include "DNA_brush_types.h"
36 #include "DNA_screen_types.h"
37 #include "DNA_userdef_types.h"
38
39 #include "BLI_math.h"
40 #include "BLI_rect.h"
41 #include "BLI_string.h"
42 #include "BLI_string_utf8.h"
43 #include "BLI_utildefines.h"
44
45 #include "BKE_context.h"
46
47 #include "RNA_access.h"
48
49 #include "BLF_api.h"
50
51 #include "UI_interface.h"
52 #include "UI_interface_icons.h"
53
54 #include "interface_intern.h"
55
56 #include "GPU_batch.h"
57 #include "GPU_batch_presets.h"
58 #include "GPU_immediate.h"
59 #include "GPU_immediate_util.h"
60 #include "GPU_matrix.h"
61 #include "GPU_state.h"
62
63 #ifdef WITH_INPUT_IME
64 #  include "WM_types.h"
65 #endif
66
67 /* icons are 80% of height of button (16 pixels inside 20 height) */
68 #define ICON_SIZE_FROM_BUTRECT(rect) (0.8f * BLI_rcti_size_y(rect))
69
70 /* Button state argument shares bits with 'uiBut.flag'.
71  * reuse flags that aren't needed for drawing to avoid collision. */
72 enum {
73         /* Show that holding the button opens a menu. */
74         UI_STATE_HOLD_ACTION = UI_BUT_UPDATE_DELAY,
75         UI_STATE_TEXT_INPUT  = UI_BUT_UNDO,
76         UI_STATE_ACTIVE_LEFT  = UI_BUT_VALUE_CLEAR,
77         UI_STATE_ACTIVE_RIGHT = UI_BUT_TEXTEDIT_UPDATE,
78
79         UI_STATE_FLAGS_ALL = (UI_STATE_HOLD_ACTION |
80                               UI_STATE_TEXT_INPUT |
81                               UI_STATE_ACTIVE_LEFT |
82                               UI_STATE_ACTIVE_RIGHT),
83 };
84 /* Prevent accidental use. */
85 #define UI_BUT_UPDATE_DELAY ((void)0)
86 #define UI_BUT_UNDO ((void)0)
87
88
89 /* ************** widget base functions ************** */
90 /**
91  * - in: roundbox codes for corner types and radius
92  * - return: array of `[size][2][x, y]` points, the edges of the roundbox, + UV coords
93  *
94  * - draw black box with alpha 0 on exact button boundbox
95  * - for every AA step:
96  *    - draw the inner part for a round filled box, with color blend codes or texture coords
97  *    - draw outline in outline color
98  *    - draw outer part, bottom half, extruded 1 pixel to bottom, for emboss shadow
99  *    - draw extra decorations
100  * - draw background color box with alpha 1 on exact button boundbox
101  */
102
103 /* fill this struct with polygon info to draw AA'ed */
104 /* it has outline, back, and two optional tria meshes */
105
106 typedef struct uiWidgetTrias {
107         uint tot;
108         int type;
109         float size, center[2];
110
111         float vec[16][2];
112         const uint (*index)[3];
113
114 } uiWidgetTrias;
115
116 /* max as used by round_box__edges */
117 /* Make sure to change widget_base_vert.glsl accordingly. */
118 #define WIDGET_CURVE_RESOLU 9
119 #define WIDGET_SIZE_MAX (WIDGET_CURVE_RESOLU * 4)
120
121 typedef struct uiWidgetBase {
122         /* TODO remove these completely */
123         int totvert, halfwayvert;
124         float outer_v[WIDGET_SIZE_MAX][2];
125         float inner_v[WIDGET_SIZE_MAX][2];
126         float inner_uv[WIDGET_SIZE_MAX][2];
127
128         bool draw_inner, draw_outline, draw_emboss;
129
130         uiWidgetTrias tria1;
131         uiWidgetTrias tria2;
132
133         /* Widget shader parameters, must match the shader layout. */
134         uiWidgetBaseParameters uniform_params;
135 } uiWidgetBase;
136
137 /** uiWidgetType: for time being only for visual appearance,
138  * later, a handling callback can be added too
139  */
140 typedef struct uiWidgetType {
141
142         /* pointer to theme color definition */
143         const uiWidgetColors *wcol_theme;
144         uiWidgetStateColors *wcol_state;
145
146         /* converted colors for state */
147         uiWidgetColors wcol;
148
149         void (*state)(struct uiWidgetType *, int state, int drawflag);
150         void (*draw)(uiWidgetColors *, rcti *, int state, int roundboxalign);
151         void (*custom)(uiBut *, uiWidgetColors *, rcti *, int state, int roundboxalign);
152         void (*text)(const uiFontStyle *, const uiWidgetColors *, uiBut *, rcti *);
153
154 } uiWidgetType;
155
156
157 /* *********************** draw data ************************** */
158
159 static const float cornervec[WIDGET_CURVE_RESOLU][2] = {
160         {0.0, 0.0}, {0.195, 0.02}, {0.383, 0.067},
161         {0.55, 0.169}, {0.707, 0.293}, {0.831, 0.45},
162         {0.924, 0.617}, {0.98, 0.805}, {1.0, 1.0}
163 };
164
165
166 const float ui_pixel_jitter[UI_PIXEL_AA_JITTER][2] = {
167         { 0.468813, -0.481430}, {-0.155755, -0.352820},
168         { 0.219306, -0.238501}, {-0.393286, -0.110949},
169         {-0.024699,  0.013908}, { 0.343805,  0.147431},
170         {-0.272855,  0.269918}, { 0.095909,  0.388710}
171 };
172 #define WIDGET_AA_JITTER UI_PIXEL_AA_JITTER
173 #define jit ui_pixel_jitter
174
175 /* -------------------------------------------------------------------- */
176 /** \name Shape Preset Data
177  * \{ */
178
179 static const float g_shape_preset_number_arrow_vert[3][2] = {
180         {-0.352077, 0.532607}, {-0.352077, -0.549313}, {0.330000, -0.008353}
181 };
182 static const uint g_shape_preset_number_arrow_face[1][3] = {
183         {0, 1, 2}
184 };
185
186 static const float g_shape_preset_scroll_circle_vert[16][2] = {
187         {0.382684, 0.923879}, {0.000001, 1.000000}, {-0.382683, 0.923880}, {-0.707107, 0.707107},
188         {-0.923879, 0.382684}, {-1.000000, 0.000000}, {-0.923880, -0.382684}, {-0.707107, -0.707107},
189         {-0.382683, -0.923880}, {0.000000, -1.000000}, {0.382684, -0.923880}, {0.707107, -0.707107},
190         {0.923880, -0.382684}, {1.000000, -0.000000}, {0.923880, 0.382683}, {0.707107, 0.707107}
191 };
192 static const uint g_shape_preset_scroll_circle_face[14][3] = {
193         {0, 1, 2}, {2, 0, 3}, {3, 0, 15}, {3, 15, 4}, {4, 15, 14}, {4, 14, 5}, {5, 14, 13}, {5, 13, 6},
194         {6, 13, 12}, {6, 12, 7}, {7, 12, 11}, {7, 11, 8}, {8, 11, 10}, {8, 10, 9}
195 };
196
197 static const float g_shape_preset_menu_arrow_vert[6][2] = {
198         {-0.33, 0.16}, {0.33, 0.16}, {0, 0.82},
199         {0, -0.82}, {-0.33, -0.16}, {0.33, -0.16}
200 };
201 static const uint g_shape_preset_menu_arrow_face[2][3] = {{2, 0, 1}, {3, 5, 4}};
202
203 static const float g_shape_preset_checkmark_vert[6][2] = {
204         {-0.578579, 0.253369},  {-0.392773, 0.412794},  {-0.004241, -0.328551},
205         {-0.003001, 0.034320},  {1.055313, 0.864744},   {0.866408, 1.026895}
206 };
207
208 static const uint g_shape_preset_checkmark_face[4][3] = {
209         {3, 2, 4}, {3, 4, 5}, {1, 0, 3}, {0, 2, 3}
210 };
211
212 #define OY (-0.2 / 2)
213 #define SC (0.35 * 2)
214 static const float g_shape_preset_hold_action_vert[6][2] = {
215         {-0.5 + SC, 1.0 + OY},  {0.5, 1.0 + OY},  {0.5, 0.0 + OY + SC},
216 };
217 static const uint g_shape_preset_hold_action_face[2][3] = {{2, 0, 1}, {3, 5, 4}};
218 #undef OY
219 #undef SC
220
221 /** \} */
222
223 /* **************** Batch creations ****************** */
224 /**
225  * In order to speed up UI drawing we create some batches that are then
226  * modified by specialized shaders to draw certain elements really fast.
227  * TODO: find a better place. Maybe it's own file?
228  **/
229
230 /* offset in triavec[] in shader per type */
231 static const int tria_ofs[ROUNDBOX_TRIA_MAX] = {
232         [ROUNDBOX_TRIA_NONE]              = 0,
233         [ROUNDBOX_TRIA_ARROWS]            = 0,
234         [ROUNDBOX_TRIA_SCROLL]            = 12,
235         [ROUNDBOX_TRIA_MENU]              = 28,
236         [ROUNDBOX_TRIA_CHECK]             = 34,
237         [ROUNDBOX_TRIA_HOLD_ACTION_ARROW] = 40,
238 };
239 static const int tria_vcount[ROUNDBOX_TRIA_MAX] = {
240         [ROUNDBOX_TRIA_NONE]              = 0,
241         [ROUNDBOX_TRIA_ARROWS]            = 6,
242         [ROUNDBOX_TRIA_SCROLL]            = 16,
243         [ROUNDBOX_TRIA_MENU]              = 6,
244         [ROUNDBOX_TRIA_CHECK]             = 6,
245         [ROUNDBOX_TRIA_HOLD_ACTION_ARROW] = 3,
246 };
247
248 static struct {
249         GPUBatch *roundbox_widget[ROUNDBOX_TRIA_MAX];
250
251         GPUBatch *roundbox_simple;
252         GPUBatch *roundbox_simple_aa;
253         GPUBatch *roundbox_simple_outline;
254         GPUBatch *roundbox_shadow;
255
256         GPUVertFormat format;
257         uint vflag_id;
258 } g_ui_batch_cache = {{0}};
259
260 static GPUVertFormat *vflag_format(void)
261 {
262         if (g_ui_batch_cache.format.attr_len == 0) {
263                 GPUVertFormat *format = &g_ui_batch_cache.format;
264                 g_ui_batch_cache.vflag_id = GPU_vertformat_attr_add(format, "vflag", GPU_COMP_U32, 1, GPU_FETCH_INT);
265         }
266         return &g_ui_batch_cache.format;
267 }
268
269 #define INNER 0
270 #define OUTLINE 1
271 #define EMBOSS 2
272 #define NO_AA WIDGET_AA_JITTER
273
274 static void set_roundbox_vertex_data(
275         GPUVertBufRaw *vflag_step, uint32_t d)
276 {
277         uint32_t *data = GPU_vertbuf_raw_step(vflag_step);
278         *data = d;
279 }
280
281 static uint32_t set_roundbox_vertex(
282         GPUVertBufRaw *vflag_step,
283         int corner_id, int corner_v, int jit_v, bool inner, bool emboss, int color)
284 {
285         uint32_t *data = GPU_vertbuf_raw_step(vflag_step);
286         *data  = corner_id;
287         *data |= corner_v << 2;
288         *data |= jit_v << 6;
289         *data |= color << 12;
290         *data |= (inner) ? (1 << 10) : 0; /* is inner vert */
291         *data |= (emboss) ? (1 << 11) : 0; /* is emboss vert */
292         return *data;
293 }
294
295 static uint32_t set_tria_vertex(
296         GPUVertBufRaw *vflag_step,
297         int tria_type, int tria_v, int tria_id, int jit_v)
298 {
299         uint32_t *data = GPU_vertbuf_raw_step(vflag_step);
300         if (ELEM(tria_type, ROUNDBOX_TRIA_ARROWS)) {
301                 tria_v += tria_id * tria_vcount[ROUNDBOX_TRIA_ARROWS];
302         }
303         *data  = tria_ofs[tria_type] + tria_v;
304         *data |= jit_v << 6;
305         *data |= (tria_id == 0) ? (1 << 10) : 0; /* is first tria */
306         *data |= 1 << 14; /* is tria vert */
307         return *data;
308 }
309
310 static void roundbox_batch_add_tria(GPUVertBufRaw *vflag_step, int tria, uint32_t last_data)
311 {
312         const int tria_num = ELEM(tria, ROUNDBOX_TRIA_CHECK, ROUNDBOX_TRIA_HOLD_ACTION_ARROW, ROUNDBOX_TRIA_MENU) ? 1 : 2;
313         /* for each tria */
314         for (int t = 0; t < tria_num; ++t) {
315                 for (int j = 0; j < WIDGET_AA_JITTER; j++) {
316                         /* restart */
317                         set_roundbox_vertex_data(vflag_step, last_data);
318                         set_tria_vertex(vflag_step, tria, 0, t, j);
319                         for (int v = 0; v < tria_vcount[tria]; v++) {
320                                 last_data = set_tria_vertex(vflag_step, tria, v, t, j);
321                         }
322                 }
323         }
324 }
325
326 GPUBatch *ui_batch_roundbox_widget_get(int tria)
327 {
328         if (g_ui_batch_cache.roundbox_widget[tria] == NULL) {
329                 uint32_t last_data;
330                 GPUVertBufRaw vflag_step;
331                 GPUVertBuf *vbo = GPU_vertbuf_create_with_format(vflag_format());
332                 int vcount = WIDGET_SIZE_MAX; /* inner */
333                 vcount += 2; /* restart */
334                 vcount += ((WIDGET_SIZE_MAX + 1) * 2) * WIDGET_AA_JITTER; /* outline (edges) */
335                 vcount += 2; /* restart */
336                 vcount += ((WIDGET_CURVE_RESOLU * 2) * 2) * WIDGET_AA_JITTER; /* emboss */
337                 if (tria) {
338                         vcount += (tria_vcount[tria] + 2) * WIDGET_AA_JITTER; /* tria1 */
339                         if (!ELEM(tria, ROUNDBOX_TRIA_CHECK, ROUNDBOX_TRIA_HOLD_ACTION_ARROW, ROUNDBOX_TRIA_MENU)) {
340                                 vcount += (tria_vcount[tria] + 2) * WIDGET_AA_JITTER; /* tria2 */
341                         }
342                 }
343                 GPU_vertbuf_data_alloc(vbo, vcount);
344                 GPU_vertbuf_attr_get_raw_data(vbo, g_ui_batch_cache.vflag_id, &vflag_step);
345                 /* Inner */
346                 for (int c1 = 0, c2 = 3; c1 < 2; c1++, c2--) {
347                         for (int a1 = 0, a2 = WIDGET_CURVE_RESOLU -1; a2 >= 0; a1++, a2--) {
348                                 last_data = set_roundbox_vertex(&vflag_step, c1, a1, NO_AA, true, false, INNER);
349                                 last_data = set_roundbox_vertex(&vflag_step, c2, a2, NO_AA, true, false, INNER);
350                         }
351                 }
352                 /* restart */
353                 set_roundbox_vertex_data(&vflag_step, last_data);
354                 set_roundbox_vertex(&vflag_step, 0, 0, 0, true, false, OUTLINE);
355                 /* Outlines */
356                 for (int j = 0; j < WIDGET_AA_JITTER; j++) {
357                         for (int c = 0; c < 4; c++) {
358                                 for (int a = 0; a < WIDGET_CURVE_RESOLU; a++) {
359                                         set_roundbox_vertex(&vflag_step, c, a, j, true, false, OUTLINE);
360                                         set_roundbox_vertex(&vflag_step, c, a, j, false, false, OUTLINE);
361                                 }
362                         }
363                         /* Close the loop. */
364                         set_roundbox_vertex(&vflag_step, 0, 0, j, true, false, OUTLINE);
365                         last_data = set_roundbox_vertex(&vflag_step, 0, 0, j, false, false, OUTLINE);
366                 }
367                 /* restart */
368                 set_roundbox_vertex_data(&vflag_step, last_data);
369                 set_roundbox_vertex(&vflag_step, 0, 0, 0, false, false, EMBOSS);
370                 /* Emboss */
371                 /* go back and forth : avoid degenerate triangle (but beware of backface cull) */
372                 bool rev = false;
373                 for (int j = 0; j < WIDGET_AA_JITTER; j++, rev = !rev) {
374                         for (int c = (rev) ? 1 : 0; (rev) ? c >= 0 : c < 2; (rev) ? c-- : c++) {
375                                 int sta = (rev) ? WIDGET_CURVE_RESOLU - 1 : 0;
376                                 int end = WIDGET_CURVE_RESOLU;
377                                 for (int a = sta; (rev) ? a >= 0 : a < end; (rev) ? a-- : a++) {
378                                         set_roundbox_vertex(&vflag_step, c, a, j, false, false, EMBOSS);
379                                         last_data = set_roundbox_vertex(&vflag_step, c, a, j, false, true, EMBOSS);
380                                 }
381                         }
382                 }
383                 if (tria) {
384                         roundbox_batch_add_tria(&vflag_step, tria, last_data);
385                 }
386                 g_ui_batch_cache.roundbox_widget[tria] = GPU_batch_create_ex(GPU_PRIM_TRI_STRIP, vbo, NULL, GPU_BATCH_OWNS_VBO);
387                 gpu_batch_presets_register(g_ui_batch_cache.roundbox_widget[tria]);
388         }
389         return g_ui_batch_cache.roundbox_widget[tria];
390 }
391
392 GPUBatch *ui_batch_roundbox_get(bool filled, bool antialiased)
393 {
394         GPUBatch **batch = NULL;
395
396         if (filled) {
397                 if (antialiased)
398                         batch = &g_ui_batch_cache.roundbox_simple_aa;
399                 else
400                         batch = &g_ui_batch_cache.roundbox_simple;
401         }
402         else {
403                 if (antialiased)
404                         BLI_assert(0); /* Use GL_LINE_SMOOTH instead!!: */
405                 else
406                         batch = &g_ui_batch_cache.roundbox_simple_outline;
407         }
408
409         if (*batch == NULL) {
410                 uint32_t last_data;
411                 GPUVertBufRaw vflag_step;
412                 GPUVertBuf *vbo = GPU_vertbuf_create_with_format(vflag_format());
413                 int vcount = WIDGET_SIZE_MAX;
414                 vcount += (filled) ? 2 : 0;
415                 vcount *= (antialiased) ? WIDGET_AA_JITTER : 1;
416                 GPU_vertbuf_data_alloc(vbo, vcount);
417                 GPU_vertbuf_attr_get_raw_data(vbo, g_ui_batch_cache.vflag_id, &vflag_step);
418
419                 if (filled) {
420                         for (int j = 0; j < WIDGET_AA_JITTER; j++) {
421                                 if (!antialiased) {
422                                         j = NO_AA;
423                                 }
424                                 /* restart */
425                                 set_roundbox_vertex(&vflag_step, 0, 0, j, true, false, INNER);
426                                 for (int c1 = 0, c2 = 3; c1 < 2; c1++, c2--) {
427                                         for (int a1 = 0, a2 = WIDGET_CURVE_RESOLU -1; a2 >= 0; a1++, a2--) {
428                                                 last_data = set_roundbox_vertex(&vflag_step, c1, a1, j, true, false, INNER);
429                                                 last_data = set_roundbox_vertex(&vflag_step, c2, a2, j, true, false, INNER);
430                                         }
431                                 }
432                                 /* restart */
433                                 set_roundbox_vertex_data(&vflag_step, last_data);
434                                 if (!antialiased) {
435                                         break;
436                                 }
437                         }
438                         *batch = GPU_batch_create_ex(GPU_PRIM_TRI_STRIP, vbo, NULL, GPU_BATCH_OWNS_VBO);
439                 }
440                 else {
441                         for (int j = 0; j < WIDGET_AA_JITTER; j++) {
442                                 if (!antialiased) {
443                                         j = NO_AA;
444                                 }
445                                 for (int c = 0; c < 4; c++) {
446                                         for (int a = 0; a < WIDGET_CURVE_RESOLU; a++) {
447                                                 set_roundbox_vertex(&vflag_step, c, a, j, true, false, INNER);
448                                         }
449                                 }
450                                 if (!antialiased) {
451                                         break;
452                                 }
453                         }
454                         *batch = GPU_batch_create_ex(GPU_PRIM_LINE_LOOP, vbo, NULL, GPU_BATCH_OWNS_VBO);
455                 }
456
457                 gpu_batch_presets_register(*batch);
458         }
459         return *batch;
460 }
461
462 GPUBatch *ui_batch_roundbox_shadow_get(void)
463 {
464         if (g_ui_batch_cache.roundbox_shadow == NULL) {
465                 uint32_t last_data;
466                 GPUVertBufRaw vflag_step;
467                 GPUVertBuf *vbo = GPU_vertbuf_create_with_format(vflag_format());
468                 int vcount = (WIDGET_SIZE_MAX + 1) * 2 + 2 + WIDGET_SIZE_MAX;
469                 GPU_vertbuf_data_alloc(vbo, vcount);
470                 GPU_vertbuf_attr_get_raw_data(vbo, g_ui_batch_cache.vflag_id, &vflag_step);
471
472                 for (int c = 0; c < 4; c++) {
473                         for (int a = 0; a < WIDGET_CURVE_RESOLU; a++) {
474                                 set_roundbox_vertex(&vflag_step, c, a, NO_AA, true, false, INNER);
475                                 set_roundbox_vertex(&vflag_step, c, a, NO_AA, false, false, INNER);
476                         }
477                 }
478                 /* close loop */
479                 last_data = set_roundbox_vertex(&vflag_step, 0, 0, NO_AA, true, false, INNER);
480                 last_data = set_roundbox_vertex(&vflag_step, 0, 0, NO_AA, false, false, INNER);
481                 /* restart */
482                 set_roundbox_vertex_data(&vflag_step, last_data);
483                 set_roundbox_vertex(&vflag_step, 0, 0, NO_AA, true, false, INNER);
484                 /* filled */
485                 for (int c1 = 0, c2 = 3; c1 < 2; c1++, c2--) {
486                         for (int a1 = 0, a2 = WIDGET_CURVE_RESOLU -1; a2 >= 0; a1++, a2--) {
487                                 set_roundbox_vertex(&vflag_step, c1, a1, NO_AA, true, false, INNER);
488                                 set_roundbox_vertex(&vflag_step, c2, a2, NO_AA, true, false, INNER);
489                         }
490                 }
491                 g_ui_batch_cache.roundbox_shadow = GPU_batch_create_ex(GPU_PRIM_TRI_STRIP, vbo, NULL, GPU_BATCH_OWNS_VBO);
492                 gpu_batch_presets_register(g_ui_batch_cache.roundbox_shadow);
493         }
494         return g_ui_batch_cache.roundbox_shadow;
495 }
496
497 #undef INNER
498 #undef OUTLINE
499 #undef EMBOSS
500 #undef NO_AA
501
502 /* ************************************************* */
503
504 void UI_draw_anti_tria(float x1, float y1, float x2, float y2, float x3, float y3,
505                        const float color[4])
506 {
507         float tri_arr[3][2] = {{x1, y1}, {x2, y2}, {x3, y3}};
508         float draw_color[4];
509
510         copy_v4_v4(draw_color, color);
511         /* Note: This won't give back the original color. */
512         draw_color[3] *= 1.0f / WIDGET_AA_JITTER;
513
514         GPU_blend(true);
515
516         uint pos = GPU_vertformat_attr_add(immVertexFormat(), "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
517         immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
518
519         immUniformColor4fv(draw_color);
520         immBegin(GPU_PRIM_TRIS, 3 * WIDGET_AA_JITTER);
521
522         /* for each AA step */
523         for (int j = 0; j < WIDGET_AA_JITTER; j++) {
524                 immVertex2f(pos, tri_arr[0][0] + jit[j][0], tri_arr[0][1] + jit[j][1]);
525                 immVertex2f(pos, tri_arr[1][0] + jit[j][0], tri_arr[1][1] + jit[j][1]);
526                 immVertex2f(pos, tri_arr[2][0] + jit[j][0], tri_arr[2][1] + jit[j][1]);
527         }
528
529         immEnd();
530
531         immUnbindProgram();
532
533         GPU_blend(false);
534 }
535
536 /* triangle 'icon' inside rect */
537 void ui_draw_anti_tria_rect(const rctf *rect, char dir, const float color[4])
538 {
539         if (dir == 'h') {
540                 float half = 0.5f * BLI_rctf_size_y(rect);
541                 UI_draw_anti_tria(rect->xmin, rect->ymin, rect->xmin, rect->ymax, rect->xmax, rect->ymin + half, color);
542         }
543         else {
544                 float half = 0.5f * BLI_rctf_size_x(rect);
545                 UI_draw_anti_tria(rect->xmin, rect->ymax, rect->xmax, rect->ymax, rect->xmin + half, rect->ymin, color);
546         }
547 }
548
549
550 void UI_draw_anti_fan(float tri_array[][2], uint length, const float color[4])
551 {
552         float draw_color[4];
553
554         copy_v4_v4(draw_color, color);
555         draw_color[3] *= 2.0f / WIDGET_AA_JITTER;
556
557         GPU_blend(true);
558
559         uint pos = GPU_vertformat_attr_add(immVertexFormat(), "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
560         immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
561
562         immUniformColor4fv(draw_color);
563
564         /* for each AA step */
565         for (int j = 0; j < WIDGET_AA_JITTER; j++) {
566                 immBegin(GPU_PRIM_TRI_FAN, length);
567                 immVertex2f(pos, tri_array[0][0], tri_array[0][1]);
568                 immVertex2f(pos, tri_array[1][0], tri_array[1][1]);
569
570                 /* We jitter only the middle of the fan, the extremes are pinned. */
571                 for (int i = 2; i < length - 1; i++) {
572                         immVertex2f(pos, tri_array[i][0] + jit[j][0], tri_array[i][1] + jit[j][1]);
573                 }
574
575                 immVertex2f(pos, tri_array[length - 1][0], tri_array[length - 1][1]);
576                 immEnd();
577         }
578
579         immUnbindProgram();
580
581         GPU_blend(false);
582 }
583
584 static void widget_init(uiWidgetBase *wtb)
585 {
586         wtb->totvert = wtb->halfwayvert = 0;
587         wtb->tria1.tot = 0;
588         wtb->tria2.tot = 0;
589         wtb->tria1.type = ROUNDBOX_TRIA_NONE;
590         wtb->tria1.size = 0;
591         wtb->tria2.size = 0;
592
593         wtb->draw_inner = true;
594         wtb->draw_outline = true;
595         wtb->draw_emboss = true;
596
597         wtb->uniform_params.shade_dir = 1.0f;
598         wtb->uniform_params.alpha_discard = 1.0f;
599 }
600
601 /* helper call, makes shadow rect, with 'sun' above menu, so only shadow to left/right/bottom */
602 /* return tot */
603 static int round_box_shadow_edges(float (*vert)[2], const rcti *rect, float rad, int roundboxalign, float step)
604 {
605         float vec[WIDGET_CURVE_RESOLU][2];
606         float minx, miny, maxx, maxy;
607         int a, tot = 0;
608
609         rad += step;
610
611         if (2.0f * rad > BLI_rcti_size_y(rect))
612                 rad = 0.5f * BLI_rcti_size_y(rect);
613
614         minx = rect->xmin - step;
615         miny = rect->ymin - step;
616         maxx = rect->xmax + step;
617         maxy = rect->ymax + step;
618
619         /* mult */
620         for (a = 0; a < WIDGET_CURVE_RESOLU; a++) {
621                 vec[a][0] = rad * cornervec[a][0];
622                 vec[a][1] = rad * cornervec[a][1];
623         }
624
625         /* start with left-top, anti clockwise */
626         if (roundboxalign & UI_CNR_TOP_LEFT) {
627                 for (a = 0; a < WIDGET_CURVE_RESOLU; a++, tot++) {
628                         vert[tot][0] = minx + rad - vec[a][0];
629                         vert[tot][1] = maxy - vec[a][1];
630                 }
631         }
632         else {
633                 for (a = 0; a < WIDGET_CURVE_RESOLU; a++, tot++) {
634                         vert[tot][0] = minx;
635                         vert[tot][1] = maxy;
636                 }
637         }
638
639         if (roundboxalign & UI_CNR_BOTTOM_LEFT) {
640                 for (a = 0; a < WIDGET_CURVE_RESOLU; a++, tot++) {
641                         vert[tot][0] = minx + vec[a][1];
642                         vert[tot][1] = miny + rad - vec[a][0];
643                 }
644         }
645         else {
646                 for (a = 0; a < WIDGET_CURVE_RESOLU; a++, tot++) {
647                         vert[tot][0] = minx;
648                         vert[tot][1] = miny;
649                 }
650         }
651
652         if (roundboxalign & UI_CNR_BOTTOM_RIGHT) {
653                 for (a = 0; a < WIDGET_CURVE_RESOLU; a++, tot++) {
654                         vert[tot][0] = maxx - rad + vec[a][0];
655                         vert[tot][1] = miny + vec[a][1];
656                 }
657         }
658         else {
659                 for (a = 0; a < WIDGET_CURVE_RESOLU; a++, tot++) {
660                         vert[tot][0] = maxx;
661                         vert[tot][1] = miny;
662                 }
663         }
664
665         if (roundboxalign & UI_CNR_TOP_RIGHT) {
666                 for (a = 0; a < WIDGET_CURVE_RESOLU; a++, tot++) {
667                         vert[tot][0] = maxx - vec[a][1];
668                         vert[tot][1] = maxy - rad + vec[a][0];
669                 }
670         }
671         else {
672                 for (a = 0; a < WIDGET_CURVE_RESOLU; a++, tot++) {
673                         vert[tot][0] = maxx;
674                         vert[tot][1] = maxy;
675                 }
676         }
677         return tot;
678 }
679
680 /* this call has 1 extra arg to allow mask outline */
681 static void round_box__edges(uiWidgetBase *wt, int roundboxalign, const rcti *rect, float rad, float radi)
682 {
683         float vec[WIDGET_CURVE_RESOLU][2], veci[WIDGET_CURVE_RESOLU][2];
684         float minx = rect->xmin, miny = rect->ymin, maxx = rect->xmax, maxy = rect->ymax;
685         float minxi = minx + U.pixelsize; /* boundbox inner */
686         float maxxi = maxx - U.pixelsize;
687         float minyi = miny + U.pixelsize;
688         float maxyi = maxy - U.pixelsize;
689         /* for uv, can divide by zero */
690         float facxi = (maxxi != minxi) ? 1.0f / (maxxi - minxi) : 0.0f;
691         float facyi = (maxyi != minyi) ? 1.0f / (maxyi - minyi) : 0.0f;
692         int a, tot = 0, minsize;
693         const int hnum = (
694                 (roundboxalign & (UI_CNR_TOP_LEFT | UI_CNR_TOP_RIGHT)) == (UI_CNR_TOP_LEFT | UI_CNR_TOP_RIGHT) ||
695                 (roundboxalign & (UI_CNR_BOTTOM_RIGHT | UI_CNR_BOTTOM_LEFT)) == (UI_CNR_BOTTOM_RIGHT | UI_CNR_BOTTOM_LEFT)) ? 1 : 2;
696         const int vnum = (
697                 (roundboxalign & (UI_CNR_TOP_LEFT | UI_CNR_BOTTOM_LEFT)) == (UI_CNR_TOP_LEFT | UI_CNR_BOTTOM_LEFT) ||
698                 (roundboxalign & (UI_CNR_TOP_RIGHT | UI_CNR_BOTTOM_RIGHT)) == (UI_CNR_TOP_RIGHT | UI_CNR_BOTTOM_RIGHT)) ? 1 : 2;
699
700         minsize = min_ii(
701                 BLI_rcti_size_x(rect) * hnum,
702                 BLI_rcti_size_y(rect) * vnum);
703
704         if (2.0f * rad > minsize)
705                 rad = 0.5f * minsize;
706
707         if (2.0f * (radi + 1.0f) > minsize)
708                 radi = 0.5f * minsize - U.pixelsize;
709
710         wt->uniform_params.rad = rad;
711         wt->uniform_params.radi = radi;
712         wt->uniform_params.facxi = facxi;
713         wt->uniform_params.facyi = facyi;
714         wt->uniform_params.round_corners[0] = (roundboxalign & UI_CNR_BOTTOM_LEFT) ? 1.0f : 0.0f;
715         wt->uniform_params.round_corners[1] = (roundboxalign & UI_CNR_BOTTOM_RIGHT) ? 1.0f : 0.0f;
716         wt->uniform_params.round_corners[2] = (roundboxalign & UI_CNR_TOP_RIGHT) ? 1.0f : 0.0f;
717         wt->uniform_params.round_corners[3] = (roundboxalign & UI_CNR_TOP_LEFT) ? 1.0f : 0.0f;
718         BLI_rctf_rcti_copy(&wt->uniform_params.rect, rect);
719         BLI_rctf_init(&wt->uniform_params.recti, minxi, maxxi, minyi, maxyi);
720
721         /* mult */
722         for (a = 0; a < WIDGET_CURVE_RESOLU; a++) {
723                 veci[a][0] = radi * cornervec[a][0];
724                 veci[a][1] = radi * cornervec[a][1];
725                 vec[a][0] = rad * cornervec[a][0];
726                 vec[a][1] = rad * cornervec[a][1];
727         }
728
729         /* corner left-bottom */
730         if (roundboxalign & UI_CNR_BOTTOM_LEFT) {
731
732                 for (a = 0; a < WIDGET_CURVE_RESOLU; a++, tot++) {
733                         wt->inner_v[tot][0] = minxi + veci[a][1];
734                         wt->inner_v[tot][1] = minyi + radi - veci[a][0];
735
736                         wt->outer_v[tot][0] = minx + vec[a][1];
737                         wt->outer_v[tot][1] = miny + rad - vec[a][0];
738
739                         wt->inner_uv[tot][0] = facxi * (wt->inner_v[tot][0] - minxi);
740                         wt->inner_uv[tot][1] = facyi * (wt->inner_v[tot][1] - minyi);
741                 }
742         }
743         else {
744                 wt->inner_v[tot][0] = minxi;
745                 wt->inner_v[tot][1] = minyi;
746
747                 wt->outer_v[tot][0] = minx;
748                 wt->outer_v[tot][1] = miny;
749
750                 wt->inner_uv[tot][0] = 0.0f;
751                 wt->inner_uv[tot][1] = 0.0f;
752
753                 tot++;
754         }
755
756         /* corner right-bottom */
757         if (roundboxalign & UI_CNR_BOTTOM_RIGHT) {
758
759                 for (a = 0; a < WIDGET_CURVE_RESOLU; a++, tot++) {
760                         wt->inner_v[tot][0] = maxxi - radi + veci[a][0];
761                         wt->inner_v[tot][1] = minyi + veci[a][1];
762
763                         wt->outer_v[tot][0] = maxx - rad + vec[a][0];
764                         wt->outer_v[tot][1] = miny + vec[a][1];
765
766                         wt->inner_uv[tot][0] = facxi * (wt->inner_v[tot][0] - minxi);
767                         wt->inner_uv[tot][1] = facyi * (wt->inner_v[tot][1] - minyi);
768                 }
769         }
770         else {
771                 wt->inner_v[tot][0] = maxxi;
772                 wt->inner_v[tot][1] = minyi;
773
774                 wt->outer_v[tot][0] = maxx;
775                 wt->outer_v[tot][1] = miny;
776
777                 wt->inner_uv[tot][0] = 1.0f;
778                 wt->inner_uv[tot][1] = 0.0f;
779
780                 tot++;
781         }
782
783         wt->halfwayvert = tot;
784
785         /* corner right-top */
786         if (roundboxalign & UI_CNR_TOP_RIGHT) {
787
788                 for (a = 0; a < WIDGET_CURVE_RESOLU; a++, tot++) {
789                         wt->inner_v[tot][0] = maxxi - veci[a][1];
790                         wt->inner_v[tot][1] = maxyi - radi + veci[a][0];
791
792                         wt->outer_v[tot][0] = maxx - vec[a][1];
793                         wt->outer_v[tot][1] = maxy - rad + vec[a][0];
794
795                         wt->inner_uv[tot][0] = facxi * (wt->inner_v[tot][0] - minxi);
796                         wt->inner_uv[tot][1] = facyi * (wt->inner_v[tot][1] - minyi);
797                 }
798         }
799         else {
800                 wt->inner_v[tot][0] = maxxi;
801                 wt->inner_v[tot][1] = maxyi;
802
803                 wt->outer_v[tot][0] = maxx;
804                 wt->outer_v[tot][1] = maxy;
805
806                 wt->inner_uv[tot][0] = 1.0f;
807                 wt->inner_uv[tot][1] = 1.0f;
808
809                 tot++;
810         }
811
812         /* corner left-top */
813         if (roundboxalign & UI_CNR_TOP_LEFT) {
814
815                 for (a = 0; a < WIDGET_CURVE_RESOLU; a++, tot++) {
816                         wt->inner_v[tot][0] = minxi + radi - veci[a][0];
817                         wt->inner_v[tot][1] = maxyi - veci[a][1];
818
819                         wt->outer_v[tot][0] = minx + rad - vec[a][0];
820                         wt->outer_v[tot][1] = maxy - vec[a][1];
821
822                         wt->inner_uv[tot][0] = facxi * (wt->inner_v[tot][0] - minxi);
823                         wt->inner_uv[tot][1] = facyi * (wt->inner_v[tot][1] - minyi);
824                 }
825
826         }
827         else {
828
829                 wt->inner_v[tot][0] = minxi;
830                 wt->inner_v[tot][1] = maxyi;
831
832                 wt->outer_v[tot][0] = minx;
833                 wt->outer_v[tot][1] = maxy;
834
835                 wt->inner_uv[tot][0] = 0.0f;
836                 wt->inner_uv[tot][1] = 1.0f;
837
838                 tot++;
839         }
840
841         BLI_assert(tot <= WIDGET_SIZE_MAX);
842
843         wt->totvert = tot;
844 }
845
846 static void round_box_edges(uiWidgetBase *wt, int roundboxalign, const rcti *rect, float rad)
847 {
848         round_box__edges(wt, roundboxalign, rect, rad, rad - U.pixelsize);
849 }
850
851 /* -------------------------------------------------------------------- */
852 /** \name Shape Preset Mini API
853  * \{ */
854
855 /* based on button rect, return scaled array of triangles */
856 static void shape_preset_init_trias_ex(
857         uiWidgetTrias *tria, const rcti *rect, float triasize, char where,
858         /* input data */
859         const float verts[][2], const int verts_tot,
860         const uint tris[][3], const int tris_tot)
861 {
862         float centx, centy, sizex, sizey, minsize;
863         int a, i1 = 0, i2 = 1;
864
865         if (where == 'r' || where == 'l') {
866                 minsize = BLI_rcti_size_y(rect);
867         }
868         else {
869                 minsize = BLI_rcti_size_x(rect);
870         }
871
872         /* center position and size */
873         centx = (float)rect->xmin + 0.4f * minsize;
874         centy = (float)rect->ymin + 0.5f * minsize;
875         tria->size = sizex = sizey = -0.5f * triasize * minsize;
876
877         if (where == 'r') {
878                 centx = (float)rect->xmax - 0.4f * minsize;
879                 sizex = -sizex;
880         }
881         else if (where == 't') {
882                 centx = (float)rect->xmin + 0.5f * minsize;
883                 centy = (float)rect->ymax - 0.5f * minsize;
884                 sizey = -sizey;
885                 i2 = 0; i1 = 1;
886         }
887         else if (where == 'b') {
888                 centx = (float)rect->xmin + 0.5f * minsize;
889                 sizex = -sizex;
890                 i2 = 0; i1 = 1;
891         }
892
893         for (a = 0; a < verts_tot; a++) {
894                 tria->vec[a][0] = sizex * verts[a][i1] + centx;
895                 tria->vec[a][1] = sizey * verts[a][i2] + centy;
896         }
897
898         tria->center[0] = centx;
899         tria->center[1] = centy;
900
901         tria->tot = tris_tot;
902         tria->index = tris;
903 }
904
905 static void shape_preset_init_number_arrows(uiWidgetTrias *tria, const rcti *rect, float triasize, char where)
906 {
907         tria->type = ROUNDBOX_TRIA_ARROWS;
908         shape_preset_init_trias_ex(
909                 tria, rect, triasize, where,
910                 g_shape_preset_number_arrow_vert, ARRAY_SIZE(g_shape_preset_number_arrow_vert),
911                 g_shape_preset_number_arrow_face, ARRAY_SIZE(g_shape_preset_number_arrow_face));
912 }
913
914 static void shape_preset_init_hold_action(uiWidgetTrias *tria, const rcti *rect, float triasize, char where)
915 {
916         tria->type = ROUNDBOX_TRIA_HOLD_ACTION_ARROW;
917         /* With the current changes to use batches for widget drawing, the code
918          * below is doing almost nothing effectively. 'where' doesn't work either,
919          * shader is currently hardcoded to work for the button triangle pointing
920          * at the lower right. The same limitation applies to other trias as well.
921          * XXX Should be addressed. */
922         shape_preset_init_trias_ex(
923                 tria, rect, triasize, where,
924                 g_shape_preset_hold_action_vert, ARRAY_SIZE(g_shape_preset_hold_action_vert),
925                 g_shape_preset_hold_action_face, ARRAY_SIZE(g_shape_preset_hold_action_face));
926 }
927
928 static void shape_preset_init_scroll_circle(uiWidgetTrias *tria, const rcti *rect, float triasize, char where)
929 {
930         tria->type = ROUNDBOX_TRIA_SCROLL;
931         shape_preset_init_trias_ex(
932                 tria, rect, triasize, where,
933                 g_shape_preset_scroll_circle_vert, ARRAY_SIZE(g_shape_preset_scroll_circle_vert),
934                 g_shape_preset_scroll_circle_face, ARRAY_SIZE(g_shape_preset_scroll_circle_face));
935 }
936
937 static void widget_draw_vertex_buffer(uint pos, uint col, int mode,
938                                       const float quads_pos[WIDGET_SIZE_MAX][2],
939                                       const uchar quads_col[WIDGET_SIZE_MAX][4],
940                                       uint totvert)
941 {
942         immBegin(mode, totvert);
943         for (int i = 0; i < totvert; ++i) {
944                 if (quads_col)
945                         immAttr4ubv(col, quads_col[i]);
946                 immVertex2fv(pos, quads_pos[i]);
947         }
948         immEnd();
949 }
950
951 static void shape_preset_trias_from_rect_menu(uiWidgetTrias *tria, const rcti *rect)
952 {
953         float width = BLI_rcti_size_x(rect);
954         float height = BLI_rcti_size_y(rect);
955         float centx, centy, size;
956
957         tria->type = ROUNDBOX_TRIA_MENU;
958
959         /* Center position and size. */
960         tria->center[0] = centx = rect->xmin + 0.52f * BLI_rcti_size_y(rect);
961         tria->center[1] = centy = rect->ymin + 0.52f * BLI_rcti_size_y(rect);
962         tria->size = size = 0.4f * height;
963
964         if (width > height * 1.1f) {
965                 /* For wider buttons align tighter to the right. */
966                 tria->center[0] = centx = rect->xmax - 0.32f * height;
967         }
968
969         for (int a = 0; a < 6; a++) {
970                 tria->vec[a][0] = size * g_shape_preset_menu_arrow_vert[a][0] + centx;
971                 tria->vec[a][1] = size * g_shape_preset_menu_arrow_vert[a][1] + centy;
972         }
973
974         tria->tot = 2;
975         tria->index = g_shape_preset_menu_arrow_face;
976 }
977
978 static void shape_preset_trias_from_rect_checkmark(uiWidgetTrias *tria, const rcti *rect)
979 {
980         float centx, centy, size;
981
982         tria->type = ROUNDBOX_TRIA_CHECK;
983
984         /* Center position and size. */
985         tria->center[0] = centx = rect->xmin + 0.5f * BLI_rcti_size_y(rect);
986         tria->center[1] = centy = rect->ymin + 0.5f * BLI_rcti_size_y(rect);
987         tria->size = size = 0.5f * BLI_rcti_size_y(rect);
988
989         for (int a = 0; a < 6; a++) {
990                 tria->vec[a][0] = size * g_shape_preset_checkmark_vert[a][0] + centx;
991                 tria->vec[a][1] = size * g_shape_preset_checkmark_vert[a][1] + centy;
992         }
993
994         tria->tot = 4;
995         tria->index = g_shape_preset_checkmark_face;
996 }
997
998 /** \} */
999
1000
1001 /* prepares shade colors */
1002 static void shadecolors4(char coltop[4], char coldown[4], const char *color, short shadetop, short shadedown)
1003 {
1004         coltop[0] = CLAMPIS(color[0] + shadetop, 0, 255);
1005         coltop[1] = CLAMPIS(color[1] + shadetop, 0, 255);
1006         coltop[2] = CLAMPIS(color[2] + shadetop, 0, 255);
1007         coltop[3] = color[3];
1008
1009         coldown[0] = CLAMPIS(color[0] + shadedown, 0, 255);
1010         coldown[1] = CLAMPIS(color[1] + shadedown, 0, 255);
1011         coldown[2] = CLAMPIS(color[2] + shadedown, 0, 255);
1012         coldown[3] = color[3];
1013 }
1014
1015 static void round_box_shade_col4_r(uchar r_col[4], const char col1[4], const char col2[4], const float fac)
1016 {
1017         const int faci = unit_float_to_uchar_clamp(fac);
1018         const int facm = 255 - faci;
1019
1020         r_col[0] = (faci * col1[0] + facm * col2[0]) / 256;
1021         r_col[1] = (faci * col1[1] + facm * col2[1]) / 256;
1022         r_col[2] = (faci * col1[2] + facm * col2[2]) / 256;
1023         r_col[3] = (faci * col1[3] + facm * col2[3]) / 256;
1024 }
1025
1026 static void widget_verts_to_triangle_strip(uiWidgetBase *wtb, const int totvert, float triangle_strip[WIDGET_SIZE_MAX * 2 + 2][2])
1027 {
1028         int a;
1029         for (a = 0; a < totvert; a++) {
1030                 copy_v2_v2(triangle_strip[a * 2], wtb->outer_v[a]);
1031                 copy_v2_v2(triangle_strip[a * 2 + 1], wtb->inner_v[a]);
1032         }
1033         copy_v2_v2(triangle_strip[a * 2], wtb->outer_v[0]);
1034         copy_v2_v2(triangle_strip[a * 2 + 1], wtb->inner_v[0]);
1035 }
1036
1037 static void widgetbase_outline(uiWidgetBase *wtb, uint pos)
1038 {
1039         float triangle_strip[WIDGET_SIZE_MAX * 2 + 2][2]; /* + 2 because the last pair is wrapped */
1040         widget_verts_to_triangle_strip(wtb, wtb->totvert, triangle_strip);
1041
1042         widget_draw_vertex_buffer(pos, 0, GL_TRIANGLE_STRIP, triangle_strip, NULL, wtb->totvert * 2 + 2);
1043 }
1044
1045 static void widgetbase_set_uniform_alpha_discard(
1046         uiWidgetBase *wtb,
1047         const bool alpha_check,
1048         const float discard_factor)
1049 {
1050         if (alpha_check) {
1051                 wtb->uniform_params.alpha_discard = -discard_factor;
1052         }
1053         else {
1054                 wtb->uniform_params.alpha_discard = discard_factor;
1055         }
1056 }
1057
1058 static void widgetbase_set_uniform_alpha_check(
1059         uiWidgetBase *wtb,
1060         const bool alpha_check)
1061 {
1062         const float discard_factor = fabs(wtb->uniform_params.alpha_discard);
1063         widgetbase_set_uniform_alpha_discard(wtb, alpha_check, discard_factor);
1064 }
1065
1066 static void widgetbase_set_uniform_discard_factor(
1067         uiWidgetBase *wtb,
1068         const float discard_factor)
1069 {
1070         bool alpha_check = wtb->uniform_params.alpha_discard < 0.0f;
1071         widgetbase_set_uniform_alpha_discard(wtb, alpha_check, discard_factor);
1072 }
1073
1074 static void widgetbase_set_uniform_colors_ubv(
1075         uiWidgetBase *wtb,
1076         const uchar *col1, const uchar *col2,
1077         const uchar *outline,
1078         const uchar *emboss,
1079         const uchar *tria,
1080         const bool alpha_check)
1081 {
1082         widgetbase_set_uniform_alpha_check(wtb, alpha_check);
1083         rgba_float_args_set_ch(wtb->uniform_params.color_inner1, col1[0], col1[1], col1[2], col1[3]);
1084         rgba_float_args_set_ch(wtb->uniform_params.color_inner2, col2[0], col2[1], col2[2], col2[3]);
1085         rgba_float_args_set_ch(wtb->uniform_params.color_outline, outline[0], outline[1], outline[2], outline[3]);
1086         rgba_float_args_set_ch(wtb->uniform_params.color_emboss, emboss[0], emboss[1], emboss[2], emboss[3]);
1087         rgba_float_args_set_ch(wtb->uniform_params.color_tria, tria[0], tria[1], tria[2], tria[3]);
1088 }
1089
1090 /* keep in sync with shader */
1091 #define MAX_WIDGET_BASE_BATCH 6
1092 #define MAX_WIDGET_PARAMETERS 11
1093
1094 static struct {
1095         GPUBatch *batch; /* Batch type */
1096         uiWidgetBaseParameters params[MAX_WIDGET_BASE_BATCH];
1097         int count;
1098         bool enabled;
1099 } g_widget_base_batch = {0};
1100
1101 void UI_widgetbase_draw_cache_flush(void)
1102 {
1103         float checker_params[3] = {UI_ALPHA_CHECKER_DARK / 255.0f, UI_ALPHA_CHECKER_LIGHT / 255.0f, 8.0f};
1104
1105         if (g_widget_base_batch.count == 0)
1106                 return;
1107
1108         GPUBatch *batch = g_widget_base_batch.batch;
1109         if (g_widget_base_batch.count == 1) {
1110                 /* draw single */
1111                 GPU_batch_program_set_builtin(batch, GPU_SHADER_2D_WIDGET_BASE);
1112                 GPU_batch_uniform_4fv_array(batch, "parameters", MAX_WIDGET_PARAMETERS, (float *)g_widget_base_batch.params);
1113                 GPU_batch_uniform_3fv(batch, "checkerColorAndSize", checker_params);
1114                 GPU_batch_draw(batch);
1115         }
1116         else {
1117                 GPU_batch_program_set_builtin(batch, GPU_SHADER_2D_WIDGET_BASE_INST);
1118                 GPU_batch_uniform_4fv_array(batch, "parameters", MAX_WIDGET_PARAMETERS * MAX_WIDGET_BASE_BATCH,
1119                                             (float *)g_widget_base_batch.params);
1120                 GPU_batch_uniform_3fv(batch, "checkerColorAndSize", checker_params);
1121                 GPU_matrix_bind(batch->interface);
1122                 GPU_batch_draw_range_ex(batch, 0, g_widget_base_batch.count, true);
1123                 GPU_batch_program_use_end(batch);
1124         }
1125         g_widget_base_batch.count = 0;
1126 }
1127
1128 void UI_widgetbase_draw_cache_begin(void)
1129 {
1130         BLI_assert(g_widget_base_batch.enabled == false);
1131         g_widget_base_batch.enabled = true;
1132 }
1133
1134 void UI_widgetbase_draw_cache_end(void)
1135 {
1136         BLI_assert(g_widget_base_batch.enabled == true);
1137         g_widget_base_batch.enabled = false;
1138
1139         GPU_blend(true);
1140
1141         UI_widgetbase_draw_cache_flush();
1142
1143         GPU_blend(false);
1144 }
1145
1146 static void draw_widgetbase_batch(GPUBatch *batch, uiWidgetBase *wtb)
1147 {
1148         wtb->uniform_params.tria1_size = wtb->tria1.size;
1149         wtb->uniform_params.tria2_size = wtb->tria2.size;
1150         copy_v2_v2(wtb->uniform_params.tria1_center, wtb->tria1.center);
1151         copy_v2_v2(wtb->uniform_params.tria2_center, wtb->tria2.center);
1152
1153         if (g_widget_base_batch.enabled) {
1154                 if (g_widget_base_batch.batch == NULL) {
1155                         g_widget_base_batch.batch = ui_batch_roundbox_widget_get(ROUNDBOX_TRIA_ARROWS);
1156                 }
1157
1158                 /* draw multi */
1159                 if (batch != g_ui_batch_cache.roundbox_widget[ROUNDBOX_TRIA_NONE] &&
1160                     batch != g_widget_base_batch.batch)
1161                 {
1162                         /* issue previous calls before changing batch type. */
1163                         UI_widgetbase_draw_cache_flush();
1164                         g_widget_base_batch.batch = batch;
1165                 }
1166
1167                 /* No need to change batch if tria is not visible. Just scale it to 0. */
1168                 if (batch == g_ui_batch_cache.roundbox_widget[ROUNDBOX_TRIA_NONE]) {
1169                         wtb->uniform_params.tria1_size = wtb->uniform_params.tria2_size = 0;
1170                 }
1171
1172                 g_widget_base_batch.params[g_widget_base_batch.count] = wtb->uniform_params;
1173                 g_widget_base_batch.count++;
1174
1175                 if (g_widget_base_batch.count == MAX_WIDGET_BASE_BATCH) {
1176                         UI_widgetbase_draw_cache_flush();
1177                 }
1178         }
1179         else {
1180                 float checker_params[3] = {UI_ALPHA_CHECKER_DARK / 255.0f, UI_ALPHA_CHECKER_LIGHT / 255.0f, 8.0f};
1181                 /* draw single */
1182                 GPU_batch_program_set_builtin(batch, GPU_SHADER_2D_WIDGET_BASE);
1183                 GPU_batch_uniform_4fv_array(batch, "parameters", MAX_WIDGET_PARAMETERS, (float *)&wtb->uniform_params);
1184                 GPU_batch_uniform_3fv(batch, "checkerColorAndSize", checker_params);
1185                 GPU_batch_draw(batch);
1186         }
1187 }
1188
1189 static void widgetbase_draw_ex(
1190         uiWidgetBase *wtb, const uiWidgetColors *wcol,
1191         bool show_alpha_checkers)
1192 {
1193         uchar inner_col1[4] = {0};
1194         uchar inner_col2[4] = {0};
1195         uchar emboss_col[4] = {0};
1196         uchar outline_col[4] = {0};
1197         uchar tria_col[4] = {0};
1198         /* For color widget. */
1199         if (wcol->shaded != 0) {
1200                 show_alpha_checkers = false;
1201         }
1202
1203         GPU_blend(true);
1204
1205         /* backdrop non AA */
1206         if (wtb->draw_inner) {
1207                 if (wcol->shaded == 0) {
1208                         /* simple fill */
1209                         inner_col1[0] = inner_col2[0] = (uchar)wcol->inner[0];
1210                         inner_col1[1] = inner_col2[1] = (uchar)wcol->inner[1];
1211                         inner_col1[2] = inner_col2[2] = (uchar)wcol->inner[2];
1212                         inner_col1[3] = inner_col2[3] = (uchar)wcol->inner[3];
1213                 }
1214                 else {
1215                         /* gradient fill */
1216                         shadecolors4((char *)inner_col1, (char *)inner_col2, wcol->inner, wcol->shadetop, wcol->shadedown);
1217                 }
1218         }
1219
1220         if (wtb->draw_outline) {
1221                 outline_col[0] = wcol->outline[0];
1222                 outline_col[1] = wcol->outline[1];
1223                 outline_col[2] = wcol->outline[2];
1224                 outline_col[3] = wcol->outline[3] / WIDGET_AA_JITTER;
1225
1226                 /* emboss bottom shadow */
1227                 if (wtb->draw_emboss) {
1228                         UI_GetThemeColor4ubv(TH_WIDGET_EMBOSS, emboss_col);
1229                 }
1230         }
1231
1232         if (wtb->tria1.type != ROUNDBOX_TRIA_NONE) {
1233                 tria_col[0] = wcol->item[0];
1234                 tria_col[1] = wcol->item[1];
1235                 tria_col[2] = wcol->item[2];
1236                 tria_col[3] = (uchar)((float)wcol->item[3] / WIDGET_AA_JITTER);
1237         }
1238
1239         /* Draw everything in one drawcall */
1240         if (inner_col1[3] || inner_col2[3] || outline_col[3] || emboss_col[3] || tria_col[3] || show_alpha_checkers) {
1241                 widgetbase_set_uniform_colors_ubv(wtb, inner_col1, inner_col2, outline_col, emboss_col, tria_col, show_alpha_checkers);
1242
1243                 GPUBatch *roundbox_batch = ui_batch_roundbox_widget_get(wtb->tria1.type);
1244                 draw_widgetbase_batch(roundbox_batch, wtb);
1245         }
1246
1247         GPU_blend(false);
1248 }
1249
1250 static void widgetbase_draw(uiWidgetBase *wtb, const uiWidgetColors *wcol)
1251 {
1252         widgetbase_draw_ex(wtb, wcol, false);
1253 }
1254
1255 /* *********************** text/icon ************************************** */
1256
1257 #define UI_TEXT_CLIP_MARGIN (0.25f * U.widget_unit / but->block->aspect)
1258
1259 #define PREVIEW_PAD 4
1260
1261 static void widget_draw_preview(BIFIconID icon, float alpha, const rcti *rect)
1262 {
1263         int w, h, size;
1264
1265         if (icon == ICON_NONE)
1266                 return;
1267
1268         w = BLI_rcti_size_x(rect);
1269         h = BLI_rcti_size_y(rect);
1270         size = MIN2(w, h);
1271         size -= PREVIEW_PAD * 2;  /* padding */
1272
1273         if (size > 0) {
1274                 int x = rect->xmin + w / 2 - size / 2;
1275                 int y = rect->ymin + h / 2 - size / 2;
1276
1277                 UI_icon_draw_preview_aspect_size(x, y, icon, 1.0f, alpha, size);
1278         }
1279 }
1280
1281
1282 static int ui_but_draw_menu_icon(const uiBut *but)
1283 {
1284         return (but->flag & UI_BUT_ICON_SUBMENU) && (but->dt == UI_EMBOSS_PULLDOWN);
1285 }
1286
1287 /* icons have been standardized... and this call draws in untransformed coordinates */
1288
1289 static void widget_draw_icon(
1290         const uiBut *but, BIFIconID icon, float alpha,
1291         const rcti *rect, const char mono_color[4])
1292 {
1293         float xs = 0.0f, ys = 0.0f;
1294         float aspect, height;
1295
1296         if (but->flag & UI_BUT_ICON_PREVIEW) {
1297                 GPU_blend(true);
1298                 widget_draw_preview(icon, alpha, rect);
1299                 GPU_blend(false);
1300                 return;
1301         }
1302
1303         /* this icon doesn't need draw... */
1304         if (icon == ICON_BLANK1 && (but->flag & UI_BUT_ICON_SUBMENU) == 0) return;
1305
1306         aspect = but->block->aspect / UI_DPI_FAC;
1307         height = ICON_DEFAULT_HEIGHT / aspect;
1308
1309         /* calculate blend color */
1310         if (ELEM(but->type, UI_BTYPE_TOGGLE, UI_BTYPE_ROW, UI_BTYPE_TOGGLE_N, UI_BTYPE_LISTROW)) {
1311                 if (but->flag & UI_SELECT) {}
1312                 else if (but->flag & UI_ACTIVE) {}
1313                 else alpha = 0.75f;
1314         }
1315         else if ((but->type == UI_BTYPE_LABEL)) {
1316                 /* extra feature allows more alpha blending */
1317                 if (but->a1 == 1.0f) {
1318                         alpha *= but->a2;
1319                 }
1320         }
1321         else if (ELEM(but->type, UI_BTYPE_BUT)) {
1322                 if (but->flag & UI_BUT_DISABLED) {
1323                         alpha *= 0.5f;
1324                 }
1325         }
1326
1327         GPU_blend(true);
1328
1329         if (icon && icon != ICON_BLANK1) {
1330                 float ofs = 1.0f / aspect;
1331
1332                 if (but->drawflag & UI_BUT_ICON_LEFT) {
1333                         /* special case - icon_only pie buttons */
1334                         if (ui_block_is_pie_menu(but->block) && !ELEM(but->type, UI_BTYPE_MENU, UI_BTYPE_POPOVER) && but->str && but->str[0] == '\0')
1335                                 xs = rect->xmin + 2.0f * ofs;
1336                         else if (but->dt == UI_EMBOSS_NONE || but->type == UI_BTYPE_LABEL)
1337                                 xs = rect->xmin + 2.0f * ofs;
1338                         else
1339                                 xs = rect->xmin + 4.0f * ofs;
1340                 }
1341                 else {
1342                         xs = (rect->xmin + rect->xmax - height) / 2.0f;
1343                 }
1344                 ys = (rect->ymin + rect->ymax - height) / 2.0f;
1345
1346                 /* force positions to integers, for zoom levels near 1. draws icons crisp. */
1347                 if (aspect > 0.95f && aspect < 1.05f) {
1348                         xs = (int)(xs + 0.1f);
1349                         ys = (int)(ys + 0.1f);
1350                 }
1351
1352                 /* to indicate draggable */
1353                 if (but->dragpoin && (but->flag & UI_ACTIVE)) {
1354                         float rgb[3] = {1.25f, 1.25f, 1.25f};
1355                         UI_icon_draw_aspect_color(xs, ys, icon, aspect, rgb, mono_color);
1356                 }
1357                 else if ((but->flag & (UI_ACTIVE | UI_SELECT | UI_SELECT_DRAW)) || !UI_but_is_tool(but)) {
1358                         UI_icon_draw_aspect(xs, ys, icon, aspect, alpha, mono_color);
1359                 }
1360                 else {
1361                         const bTheme *btheme = UI_GetTheme();
1362                         UI_icon_draw_desaturate(xs, ys, icon, aspect, alpha, 1.0 - btheme->tui.icon_saturation, mono_color);
1363                 }
1364         }
1365
1366         GPU_blend(false);
1367 }
1368
1369 static void widget_draw_submenu_tria(const uiBut *but, const rcti *rect, const uiWidgetColors *wcol)
1370 {
1371         const float aspect = but->block->aspect / UI_DPI_FAC;
1372         const int tria_height = (int)(ICON_DEFAULT_HEIGHT / aspect);
1373         const int tria_width = (int)(ICON_DEFAULT_WIDTH / aspect) - 2 * U.pixelsize;
1374         const int xs = rect->xmax - tria_width;
1375         const int ys = (rect->ymin + rect->ymax - tria_height) / 2.0f;
1376         float col[4];
1377         rctf tria_rect;
1378
1379         rgba_uchar_to_float(col, (const uchar *)wcol->text);
1380         col[3] *= 0.8f;
1381
1382         BLI_rctf_init(&tria_rect, xs, xs + tria_width, ys, ys + tria_height);
1383         BLI_rctf_scale(&tria_rect, 0.4f);
1384
1385         GPU_blend(true);
1386         UI_widgetbase_draw_cache_flush();
1387         GPU_blend(false);
1388         ui_draw_anti_tria_rect(&tria_rect, 'h', col);
1389 }
1390
1391 static void ui_text_clip_give_prev_off(uiBut *but, const char *str)
1392 {
1393         const char *prev_utf8 = BLI_str_find_prev_char_utf8(str, str + but->ofs);
1394         int bytes = str + but->ofs - prev_utf8;
1395
1396         but->ofs -= bytes;
1397 }
1398
1399 static void ui_text_clip_give_next_off(uiBut *but, const char *str)
1400 {
1401         const char *next_utf8 = BLI_str_find_next_char_utf8(str + but->ofs, NULL);
1402         int bytes = next_utf8 - (str + but->ofs);
1403
1404         but->ofs += bytes;
1405 }
1406
1407 /**
1408  * Helper.
1409  * This func assumes things like kerning handling have already been handled!
1410  * Return the length of modified (right-clipped + ellipsis) string.
1411  */
1412 static void ui_text_clip_right_ex(
1413         const uiFontStyle *fstyle, char *str, const size_t max_len, const float okwidth,
1414         const char *sep, const int sep_len, const float sep_strwidth, size_t *r_final_len)
1415 {
1416         float tmp;
1417         int l_end;
1418
1419         BLI_assert(str[0]);
1420
1421         /* If the trailing ellipsis takes more than 20% of all available width, just cut the string
1422          * (as using the ellipsis would remove even more useful chars, and we cannot show much already!).
1423          */
1424         if (sep_strwidth / okwidth > 0.2f) {
1425                 l_end = BLF_width_to_strlen(fstyle->uifont_id, str, max_len, okwidth, &tmp);
1426                 str[l_end] = '\0';
1427                 if (r_final_len) {
1428                         *r_final_len = (size_t)l_end;
1429                 }
1430         }
1431         else {
1432                 l_end = BLF_width_to_strlen(fstyle->uifont_id, str, max_len, okwidth - sep_strwidth, &tmp);
1433                 memcpy(str + l_end, sep, sep_len + 1);  /* +1 for trailing '\0'. */
1434                 if (r_final_len) {
1435                         *r_final_len = (size_t)(l_end + sep_len);
1436                 }
1437         }
1438 }
1439
1440 /**
1441  * Cut off the middle of the text to fit into the given width.
1442  * Note in case this middle clipping would just remove a few chars, it rather clips right, which is more readable.
1443  * If rpart_sep is not Null, the part of str starting to first occurrence of rpart_sep is preserved at all cost (useful
1444  * for strings with shortcuts, like 'AVeryLongFooBarLabelForMenuEntry|Ctrl O' -> 'AVeryLong...MenuEntry|Ctrl O').
1445  */
1446 float UI_text_clip_middle_ex(
1447         const uiFontStyle *fstyle, char *str, float okwidth, const float minwidth,
1448         const size_t max_len, const char rpart_sep)
1449 {
1450         float strwidth;
1451
1452         /* Add some epsilon to OK width, avoids 'ellipsing' text that nearly fits!
1453          * Better to have a small piece of the last char cut out,
1454          * than two remaining chars replaced by an ellipsis... */
1455         okwidth += 1.0f + UI_DPI_FAC;
1456
1457         BLI_assert(str[0]);
1458
1459         /* need to set this first */
1460         UI_fontstyle_set(fstyle);
1461
1462         if (fstyle->kerning == 1) {  /* for BLF_width */
1463                 BLF_enable(fstyle->uifont_id, BLF_KERNING_DEFAULT);
1464         }
1465
1466         strwidth = BLF_width(fstyle->uifont_id, str, max_len);
1467
1468         if ((okwidth > 0.0f) && (strwidth > okwidth)) {
1469                 /* utf8 two-dots leader '..' (shorter than ellipsis '...'),
1470                  * some compilers complain with real litteral string. */
1471                 const char sep[] = {0xe2, 0x80, 0xA5, 0x0};
1472                 const int sep_len = sizeof(sep) - 1;
1473                 const float sep_strwidth = BLF_width(fstyle->uifont_id, sep, sep_len + 1);
1474                 float parts_strwidth;
1475                 size_t l_end;
1476
1477                 char *rpart = NULL, rpart_buf[UI_MAX_DRAW_STR];
1478                 float rpart_width = 0.0f;
1479                 size_t rpart_len = 0;
1480                 size_t final_lpart_len;
1481
1482                 if (rpart_sep) {
1483                         rpart = strrchr(str, rpart_sep);
1484
1485                         if (rpart) {
1486                                 rpart_len = strlen(rpart);
1487                                 rpart_width = BLF_width(fstyle->uifont_id, rpart, rpart_len);
1488                                 okwidth -= rpart_width;
1489                                 strwidth -= rpart_width;
1490
1491                                 if (okwidth < 0.0f) {
1492                                         /* Not enough place for actual label, just display protected right part.
1493                                          * Here just for safety, should never happen in real life! */
1494                                         memmove(str, rpart, rpart_len + 1);
1495                                         rpart = NULL;
1496                                         okwidth += rpart_width;
1497                                         strwidth = rpart_width;
1498                                 }
1499                         }
1500                 }
1501
1502                 parts_strwidth = (okwidth - sep_strwidth) / 2.0f;
1503
1504                 if (rpart) {
1505                         strcpy(rpart_buf, rpart);
1506                         *rpart = '\0';
1507                         rpart = rpart_buf;
1508                 }
1509
1510                 l_end = BLF_width_to_strlen(fstyle->uifont_id, str, max_len, parts_strwidth, NULL);
1511                 if (l_end < 10 || min_ff(parts_strwidth, strwidth - okwidth) < minwidth) {
1512                         /* If we really have no place, or we would clip a very small piece of string in the middle,
1513                          * only show start of string.
1514                          */
1515                         ui_text_clip_right_ex(fstyle, str, max_len, okwidth, sep, sep_len, sep_strwidth, &final_lpart_len);
1516                 }
1517                 else {
1518                         size_t r_offset, r_len;
1519
1520                         r_offset = BLF_width_to_rstrlen(fstyle->uifont_id, str, max_len, parts_strwidth, NULL);
1521                         r_len = strlen(str + r_offset) + 1;  /* +1 for the trailing '\0'. */
1522
1523                         if (l_end + sep_len + r_len + rpart_len > max_len) {
1524                                 /* Corner case, the str already takes all available mem, and the ellipsis chars would actually
1525                                  * add more chars...
1526                                  * Better to just trim one or two letters to the right in this case...
1527                                  * Note: with a single-char ellipsis, this should never happen! But better be safe here...
1528                                  */
1529                                 ui_text_clip_right_ex(fstyle, str, max_len, okwidth, sep, sep_len, sep_strwidth, &final_lpart_len);
1530                         }
1531                         else {
1532                                 memmove(str + l_end + sep_len, str + r_offset, r_len);
1533                                 memcpy(str + l_end, sep, sep_len);
1534                                 /* -1 to remove trailing '\0'! */
1535                                 final_lpart_len = (size_t)(l_end + sep_len + r_len - 1);
1536
1537                                 while (BLF_width(fstyle->uifont_id, str, max_len) > okwidth) {
1538                                         /* This will happen because a lot of string width processing is done in integer pixels,
1539                                          * which can introduce a rather high error in the end (about 2 pixels or so).
1540                                          * Only one char removal shall ever be needed in real-life situation... */
1541                                         r_len--;
1542                                         final_lpart_len--;
1543                                         char *c = str + l_end + sep_len;
1544                                         memmove(c, c + 1, r_len);
1545                                 }
1546                         }
1547                 }
1548
1549                 if (rpart) {
1550                         /* Add back preserved right part to our shorten str. */
1551                         memcpy(str + final_lpart_len, rpart, rpart_len + 1);  /* +1 for trailing '\0'. */
1552                         okwidth += rpart_width;
1553                 }
1554
1555                 strwidth = BLF_width(fstyle->uifont_id, str, max_len);
1556         }
1557
1558         if (fstyle->kerning == 1) {
1559                 BLF_disable(fstyle->uifont_id, BLF_KERNING_DEFAULT);
1560         }
1561
1562         BLI_assert(strwidth <= okwidth);
1563
1564         return strwidth;
1565 }
1566
1567 /**
1568  * Wrapper around UI_text_clip_middle_ex.
1569  */
1570 static void ui_text_clip_middle(const uiFontStyle *fstyle, uiBut *but, const rcti *rect)
1571 {
1572         /* No margin for labels! */
1573         const int border = ELEM(but->type, UI_BTYPE_LABEL, UI_BTYPE_MENU, UI_BTYPE_POPOVER) ? 0 : (int)(UI_TEXT_CLIP_MARGIN + 0.5f);
1574         const float okwidth = (float)max_ii(BLI_rcti_size_x(rect) - border, 0);
1575         const size_t max_len = sizeof(but->drawstr);
1576         const float minwidth = (float)(UI_DPI_ICON_SIZE) / but->block->aspect * 2.0f;
1577
1578         but->ofs = 0;
1579         but->strwidth = UI_text_clip_middle_ex(fstyle, but->drawstr, okwidth, minwidth, max_len, '\0');
1580 }
1581
1582 /**
1583  * Like ui_text_clip_middle(), but protect/preserve at all cost the right part of the string after sep.
1584  * Useful for strings with shortcuts (like 'AVeryLongFooBarLabelForMenuEntry|Ctrl O' -> 'AVeryLong...MenuEntry|Ctrl O').
1585  */
1586 static void ui_text_clip_middle_protect_right(const uiFontStyle *fstyle, uiBut *but, const rcti *rect, const char rsep)
1587 {
1588         /* No margin for labels! */
1589         const int border = ELEM(but->type, UI_BTYPE_LABEL, UI_BTYPE_MENU, UI_BTYPE_POPOVER) ? 0 : (int)(UI_TEXT_CLIP_MARGIN + 0.5f);
1590         const float okwidth = (float)max_ii(BLI_rcti_size_x(rect) - border, 0);
1591         const size_t max_len = sizeof(but->drawstr);
1592         const float minwidth = (float)(UI_DPI_ICON_SIZE) / but->block->aspect * 2.0f;
1593
1594         but->ofs = 0;
1595         but->strwidth = UI_text_clip_middle_ex(fstyle, but->drawstr, okwidth, minwidth, max_len, rsep);
1596 }
1597
1598 /**
1599  * Cut off the text, taking into account the cursor location (text display while editing).
1600  */
1601 static void ui_text_clip_cursor(const uiFontStyle *fstyle, uiBut *but, const rcti *rect)
1602 {
1603         const int border = (int)(UI_TEXT_CLIP_MARGIN + 0.5f);
1604         const int okwidth = max_ii(BLI_rcti_size_x(rect) - border, 0);
1605
1606         BLI_assert(but->editstr && but->pos >= 0);
1607
1608         /* need to set this first */
1609         UI_fontstyle_set(fstyle);
1610
1611         if (fstyle->kerning == 1) /* for BLF_width */
1612                 BLF_enable(fstyle->uifont_id, BLF_KERNING_DEFAULT);
1613
1614         /* define ofs dynamically */
1615         if (but->ofs > but->pos)
1616                 but->ofs = but->pos;
1617
1618         if (BLF_width(fstyle->uifont_id, but->editstr, INT_MAX) <= okwidth)
1619                 but->ofs = 0;
1620
1621         but->strwidth = BLF_width(fstyle->uifont_id, but->editstr + but->ofs, INT_MAX);
1622
1623         if (but->strwidth > okwidth) {
1624                 int len = strlen(but->editstr);
1625
1626                 while (but->strwidth > okwidth) {
1627                         float width;
1628
1629                         /* string position of cursor */
1630                         width = BLF_width(fstyle->uifont_id, but->editstr + but->ofs, (but->pos - but->ofs));
1631
1632                         /* if cursor is at 20 pixels of right side button we clip left */
1633                         if (width > okwidth - 20) {
1634                                 ui_text_clip_give_next_off(but, but->editstr);
1635                         }
1636                         else {
1637                                 int bytes;
1638                                 /* shift string to the left */
1639                                 if (width < 20 && but->ofs > 0)
1640                                         ui_text_clip_give_prev_off(but, but->editstr);
1641                                 bytes = BLI_str_utf8_size(BLI_str_find_prev_char_utf8(but->editstr, but->editstr + len));
1642                                 if (bytes == -1)
1643                                         bytes = 1;
1644                                 len -= bytes;
1645                         }
1646
1647                         but->strwidth = BLF_width(fstyle->uifont_id, but->editstr + but->ofs, len - but->ofs);
1648
1649                         if (but->strwidth < 10) break;
1650                 }
1651         }
1652
1653         if (fstyle->kerning == 1) {
1654                 BLF_disable(fstyle->uifont_id, BLF_KERNING_DEFAULT);
1655         }
1656 }
1657
1658 /**
1659  * Cut off the end of text to fit into the width of \a rect.
1660  *
1661  * \note deals with ': ' especially for number buttons
1662  */
1663 static void ui_text_clip_right_label(const uiFontStyle *fstyle, uiBut *but, const rcti *rect)
1664 {
1665         const int border = UI_TEXT_CLIP_MARGIN + 1;
1666         const int okwidth = max_ii(BLI_rcti_size_x(rect) - border, 0);
1667         char *cpoin = NULL;
1668         int drawstr_len = strlen(but->drawstr);
1669         const char *cpend = but->drawstr + drawstr_len;
1670
1671         /* need to set this first */
1672         UI_fontstyle_set(fstyle);
1673
1674         if (fstyle->kerning == 1) /* for BLF_width */
1675                 BLF_enable(fstyle->uifont_id, BLF_KERNING_DEFAULT);
1676
1677         but->strwidth = BLF_width(fstyle->uifont_id, but->drawstr, sizeof(but->drawstr));
1678         but->ofs = 0;
1679
1680
1681         /* First shorten num-buttons eg,
1682          *   Translucency: 0.000
1683          * becomes
1684          *   Trans: 0.000
1685          */
1686
1687         /* find the space after ':' separator */
1688         cpoin = strrchr(but->drawstr, ':');
1689
1690         if (cpoin && (cpoin < cpend - 2)) {
1691                 char *cp2 = cpoin;
1692
1693                 /* chop off the leading text, starting from the right */
1694                 while (but->strwidth > okwidth && cp2 > but->drawstr) {
1695                         const char *prev_utf8 = BLI_str_find_prev_char_utf8(but->drawstr, cp2);
1696                         int bytes = cp2 - prev_utf8;
1697
1698                         /* shift the text after and including cp2 back by 1 char,
1699                          * +1 to include null terminator */
1700                         memmove(cp2 - bytes, cp2, drawstr_len + 1);
1701                         cp2 -= bytes;
1702
1703                         drawstr_len -= bytes;
1704                         // BLI_assert(strlen(but->drawstr) == drawstr_len);
1705
1706                         but->strwidth = BLF_width(fstyle->uifont_id, but->drawstr + but->ofs, sizeof(but->drawstr) - but->ofs);
1707                         if (but->strwidth < 10) break;
1708                 }
1709
1710
1711                 /* after the leading text is gone, chop off the : and following space, with ofs */
1712                 while ((but->strwidth > okwidth) && (but->ofs < 2)) {
1713                         ui_text_clip_give_next_off(but, but->drawstr);
1714                         but->strwidth = BLF_width(fstyle->uifont_id, but->drawstr + but->ofs, sizeof(but->drawstr) - but->ofs);
1715                         if (but->strwidth < 10) break;
1716                 }
1717         }
1718
1719
1720         /* Now just remove trailing chars */
1721         /* once the label's gone, chop off the least significant digits */
1722         if (but->strwidth > okwidth) {
1723                 float strwidth;
1724                 drawstr_len = BLF_width_to_strlen(
1725                         fstyle->uifont_id, but->drawstr + but->ofs,
1726                         drawstr_len - but->ofs, okwidth, &strwidth) + but->ofs;
1727                 but->strwidth = strwidth;
1728                 but->drawstr[drawstr_len] = 0;
1729         }
1730
1731         if (fstyle->kerning == 1)
1732                 BLF_disable(fstyle->uifont_id, BLF_KERNING_DEFAULT);
1733 }
1734
1735 #ifdef WITH_INPUT_IME
1736 static void widget_draw_text_ime_underline(
1737         uiFontStyle *fstyle, uiWidgetColors *wcol, uiBut *but, const rcti *rect,
1738         const wmIMEData *ime_data, const char *drawstr)
1739 {
1740         int ofs_x, width;
1741         int rect_x = BLI_rcti_size_x(rect);
1742         int sel_start = ime_data->sel_start, sel_end = ime_data->sel_end;
1743         float fcol[4];
1744
1745         if (drawstr[0] != 0) {
1746                 if (but->pos >= but->ofs) {
1747                         ofs_x = BLF_width(fstyle->uifont_id, drawstr + but->ofs, but->pos - but->ofs);
1748                 }
1749                 else {
1750                         ofs_x = 0;
1751                 }
1752
1753                 width = BLF_width(
1754                         fstyle->uifont_id, drawstr + but->ofs,
1755                         ime_data->composite_len + but->pos - but->ofs);
1756
1757                 rgba_uchar_to_float(fcol, wcol->text);
1758                 UI_draw_text_underline(rect->xmin + ofs_x, rect->ymin + 6 * U.pixelsize, min_ii(width, rect_x - 2) - ofs_x, 1, fcol);
1759
1760                 /* draw the thick line */
1761                 if (sel_start != -1 && sel_end != -1) {
1762                         sel_end -= sel_start;
1763                         sel_start += but->pos;
1764
1765                         if (sel_start >= but->ofs) {
1766                                 ofs_x = BLF_width(fstyle->uifont_id, drawstr + but->ofs, sel_start - but->ofs);
1767                         }
1768                         else {
1769                                 ofs_x = 0;
1770                         }
1771
1772                         width = BLF_width(
1773                                 fstyle->uifont_id, drawstr + but->ofs,
1774                                 sel_end + sel_start - but->ofs);
1775
1776                         UI_draw_text_underline(rect->xmin + ofs_x, rect->ymin + 6 * U.pixelsize, min_ii(width, rect_x - 2) - ofs_x, 2, fcol);
1777                 }
1778         }
1779 }
1780 #endif  /* WITH_INPUT_IME */
1781
1782 static void widget_draw_text(const uiFontStyle *fstyle, const uiWidgetColors *wcol, uiBut *but, rcti *rect)
1783 {
1784         int drawstr_left_len = UI_MAX_DRAW_STR;
1785         const char *drawstr = but->drawstr;
1786         const char *drawstr_right = NULL;
1787         bool use_right_only = false;
1788
1789 #ifdef WITH_INPUT_IME
1790         const wmIMEData *ime_data;
1791 #endif
1792
1793         UI_fontstyle_set(fstyle);
1794
1795         eFontStyle_Align align;
1796         if (but->editstr || (but->drawflag & UI_BUT_TEXT_LEFT)) {
1797                 align = UI_STYLE_TEXT_LEFT;
1798         }
1799         else if (but->drawflag & UI_BUT_TEXT_RIGHT) {
1800                 align = UI_STYLE_TEXT_RIGHT;
1801         }
1802         else {
1803                 align = UI_STYLE_TEXT_CENTER;
1804         }
1805
1806         if (fstyle->kerning == 1) /* for BLF_width */
1807                 BLF_enable(fstyle->uifont_id, BLF_KERNING_DEFAULT);
1808
1809
1810         /* Special case: when we're entering text for multiple buttons,
1811          * don't draw the text for any of the multi-editing buttons */
1812         if (UNLIKELY(but->flag & UI_BUT_DRAG_MULTI)) {
1813                 uiBut *but_edit = ui_but_drag_multi_edit_get(but);
1814                 if (but_edit) {
1815                         drawstr = but_edit->editstr;
1816                         align = UI_STYLE_TEXT_LEFT;
1817                 }
1818         }
1819         else {
1820                 if (but->editstr) {
1821                         /* max length isn't used in this case,
1822                          * we rely on string being NULL terminated. */
1823                         drawstr_left_len = INT_MAX;
1824
1825 #ifdef WITH_INPUT_IME
1826                         /* FIXME, IME is modifying 'const char *drawstr! */
1827                         ime_data = ui_but_ime_data_get(but);
1828
1829                         if (ime_data && ime_data->composite_len) {
1830                                 /* insert composite string into cursor pos */
1831                                 BLI_snprintf(
1832                                         (char *)drawstr, UI_MAX_DRAW_STR, "%s%s%s",
1833                                         but->editstr, ime_data->str_composite,
1834                                         but->editstr + but->pos);
1835                         }
1836                         else
1837 #endif
1838                         {
1839                                 drawstr = but->editstr;
1840                         }
1841                 }
1842         }
1843
1844
1845         /* text button selection, cursor, composite underline */
1846         if (but->editstr && but->pos != -1) {
1847                 int but_pos_ofs;
1848                 int tx, ty;
1849
1850                 /* text button selection */
1851                 if ((but->selend - but->selsta) > 0) {
1852                         int selsta_draw, selwidth_draw;
1853
1854                         if (drawstr[0] != 0) {
1855                                 /* We are drawing on top of widget bases. Flush cache. */
1856                                 GPU_blend(true);
1857                                 UI_widgetbase_draw_cache_flush();
1858                                 GPU_blend(false);
1859
1860                                 if (but->selsta >= but->ofs) {
1861                                         selsta_draw = BLF_width(fstyle->uifont_id, drawstr + but->ofs, but->selsta - but->ofs);
1862                                 }
1863                                 else {
1864                                         selsta_draw = 0;
1865                                 }
1866
1867                                 selwidth_draw = BLF_width(fstyle->uifont_id, drawstr + but->ofs, but->selend - but->ofs);
1868
1869                                 uint pos = GPU_vertformat_attr_add(immVertexFormat(), "pos", GPU_COMP_I32, 2, GPU_FETCH_INT_TO_FLOAT);
1870                                 immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
1871
1872                                 immUniformColor4ubv((uchar *)wcol->item);
1873                                 immRecti(pos, rect->xmin + selsta_draw,
1874                                          rect->ymin + 2,
1875                                          min_ii(rect->xmin + selwidth_draw, rect->xmax - 2),
1876                                          rect->ymax - 2);
1877
1878                                 immUnbindProgram();
1879                         }
1880                 }
1881
1882                 /* text cursor */
1883                 but_pos_ofs = but->pos;
1884
1885 #ifdef WITH_INPUT_IME
1886                 /* if is ime compositing, move the cursor */
1887                 if (ime_data && ime_data->composite_len && ime_data->cursor_pos != -1) {
1888                         but_pos_ofs += ime_data->cursor_pos;
1889                 }
1890 #endif
1891
1892                 if (but->pos >= but->ofs) {
1893                         int t;
1894                         if (drawstr[0] != 0) {
1895                                 t = BLF_width(fstyle->uifont_id, drawstr + but->ofs, but_pos_ofs - but->ofs);
1896                         }
1897                         else {
1898                                 t = 0;
1899                         }
1900                         /* We are drawing on top of widget bases. Flush cache. */
1901                         GPU_blend(true);
1902                         UI_widgetbase_draw_cache_flush();
1903                         GPU_blend(false);
1904
1905                         uint pos = GPU_vertformat_attr_add(immVertexFormat(), "pos", GPU_COMP_I32, 2, GPU_FETCH_INT_TO_FLOAT);
1906                         immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
1907
1908                         immUniformColor3f(0.2f, 0.6f, 0.9f);
1909
1910                         tx = rect->xmin + t + 2;
1911                         ty = rect->ymin + 2;
1912
1913                         /* draw cursor */
1914                         immRecti(pos, rect->xmin + t, ty, tx, rect->ymax - 2);
1915
1916                         immUnbindProgram();
1917                 }
1918
1919 #ifdef WITH_INPUT_IME
1920                 if (ime_data && ime_data->composite_len) {
1921                         /* ime cursor following */
1922                         if (but->pos >= but->ofs) {
1923                                 ui_but_ime_reposition(but, tx + 5, ty + 3, false);
1924                         }
1925
1926                         /* composite underline */
1927                         widget_draw_text_ime_underline(fstyle, wcol, but, rect, ime_data, drawstr);
1928                 }
1929 #endif
1930         }
1931
1932         if (fstyle->kerning == 1)
1933                 BLF_disable(fstyle->uifont_id, BLF_KERNING_DEFAULT);
1934
1935 #if 0
1936         ui_rasterpos_safe(x, y, but->aspect);
1937         transopts = ui_translate_buttons();
1938 #endif
1939
1940         /* cut string in 2 parts - only for menu entries */
1941         if ((but->drawflag & UI_BUT_HAS_SHORTCUT) &&
1942             (but->editstr == NULL))
1943         {
1944                 if (but->flag & UI_BUT_HAS_SEP_CHAR) {
1945                         drawstr_right = strrchr(drawstr, UI_SEP_CHAR);
1946                         if (drawstr_right) {
1947                                 drawstr_left_len = (drawstr_right - drawstr);
1948                                 drawstr_right++;
1949                         }
1950                 }
1951         }
1952
1953 #ifdef USE_NUMBUTS_LR_ALIGN
1954         if (!drawstr_right &&
1955             (but->drawflag & UI_BUT_TEXT_LEFT) &&
1956             ELEM(but->type, UI_BTYPE_NUM, UI_BTYPE_NUM_SLIDER) &&
1957             /* if we're editing or multi-drag (fake editing), then use left alignment */
1958             (but->editstr == NULL) && (drawstr == but->drawstr))
1959         {
1960                 drawstr_right = strchr(drawstr + but->ofs, ':');
1961                 if (drawstr_right) {
1962                         drawstr_right++;
1963                         drawstr_left_len = (drawstr_right - drawstr);
1964
1965                         while (*drawstr_right == ' ') {
1966                                 drawstr_right++;
1967                         }
1968                 }
1969                 else {
1970                         /* no prefix, even so use only cpoin */
1971                         drawstr_right = drawstr + but->ofs;
1972                         use_right_only = true;
1973                 }
1974         }
1975 #endif
1976
1977         if (!use_right_only) {
1978                 /* for underline drawing */
1979                 float font_xofs, font_yofs;
1980
1981                 int drawlen = (drawstr_left_len == INT_MAX) ? strlen(drawstr + but->ofs) : (drawstr_left_len - but->ofs);
1982
1983                 if (drawlen > 0) {
1984                         UI_fontstyle_draw_ex(
1985                                 fstyle, rect, drawstr + but->ofs, (uchar *)wcol->text,
1986                                 &(struct uiFontStyleDraw_Params) { .align = align, },
1987                                 drawlen, &font_xofs, &font_yofs);
1988
1989                         if (but->menu_key != '\0') {
1990                                 char fixedbuf[128];
1991                                 const char *str;
1992
1993                                 BLI_strncpy(fixedbuf, drawstr + but->ofs, min_ii(sizeof(fixedbuf), drawlen));
1994
1995                                 str = strchr(fixedbuf, but->menu_key - 32); /* upper case */
1996                                 if (str == NULL)
1997                                         str = strchr(fixedbuf, but->menu_key);
1998
1999                                 if (str) {
2000                                         int ul_index = -1;
2001                                         float ul_advance;
2002
2003                                         ul_index = (int)(str - fixedbuf);
2004
2005                                         if (fstyle->kerning == 1) {
2006                                                 BLF_enable(fstyle->uifont_id, BLF_KERNING_DEFAULT);
2007                                         }
2008
2009                                         fixedbuf[ul_index] = '\0';
2010                                         ul_advance = BLF_width(fstyle->uifont_id, fixedbuf, ul_index) + (1.0f * UI_DPI_FAC);
2011
2012                                         BLF_position(fstyle->uifont_id, rect->xmin + font_xofs + ul_advance, rect->ymin + font_yofs, 0.0f);
2013                                         BLF_color4ubv(fstyle->uifont_id, (uchar *)wcol->text);
2014                                         BLF_draw(fstyle->uifont_id, "_", 2);
2015
2016                                         if (fstyle->kerning == 1) {
2017                                                 BLF_disable(fstyle->uifont_id, BLF_KERNING_DEFAULT);
2018                                         }
2019                                 }
2020                         }
2021                 }
2022         }
2023
2024         /* part text right aligned */
2025         if (drawstr_right) {
2026                 char col[4];
2027                 copy_v4_v4_char(col, wcol->text);
2028                 if (but->drawflag & UI_BUT_HAS_SHORTCUT) {
2029                         col[3] *= 0.5f;
2030                 }
2031
2032                 rect->xmax -= UI_TEXT_CLIP_MARGIN;
2033                 UI_fontstyle_draw(
2034                         fstyle, rect, drawstr_right, (const uchar *)col,
2035                         &(struct uiFontStyleDraw_Params) { .align = UI_STYLE_TEXT_RIGHT, });
2036         }
2037 }
2038
2039 static BIFIconID widget_icon_id(uiBut *but)
2040 {
2041         if (!(but->flag & UI_HAS_ICON)) {
2042                 return ICON_NONE;
2043         }
2044
2045         /* Consecutive icons can be toggle between. */
2046         if (but->drawflag & UI_BUT_ICON_REVERSE) {
2047                 return but->icon - but->iconadd;
2048         }
2049         else {
2050                 return but->icon + but->iconadd;
2051         }
2052 }
2053
2054 /* draws text and icons for buttons */
2055 static void widget_draw_text_icon(const uiFontStyle *fstyle, const uiWidgetColors *wcol, uiBut *but, rcti *rect)
2056 {
2057         const uiButExtraIconType extra_icon_type = ui_but_icon_extra_get(but);
2058         const bool show_menu_icon = ui_but_draw_menu_icon(but);
2059         float alpha = (float)wcol->text[3] / 255.0f;
2060         char password_str[UI_MAX_DRAW_STR];
2061
2062         ui_but_text_password_hide(password_str, but, false);
2063
2064         /* check for button text label */
2065         if (ELEM(but->type, UI_BTYPE_MENU, UI_BTYPE_POPOVER) && (but->flag & UI_BUT_NODE_LINK)) {
2066                 rcti temp = *rect;
2067                 temp.xmin = rect->xmax - BLI_rcti_size_y(rect) - 1;
2068                 widget_draw_icon(but, ICON_LAYER_USED, alpha, &temp, wcol->text);
2069                 rect->xmax = temp.xmin;
2070         }
2071
2072         /* If there's an icon too (made with uiDefIconTextBut) then draw the icon
2073          * and offset the text label to accommodate it */
2074
2075         /* Big previews with optional text label below */
2076         if (but->flag & UI_BUT_ICON_PREVIEW && ui_block_is_menu(but->block)) {
2077                 const BIFIconID icon = widget_icon_id(but);
2078                 int icon_size = BLI_rcti_size_y(rect);
2079                 int text_size = 0;
2080
2081                 /* This is a bit britle, but avoids adding an 'UI_BUT_HAS_LABEL' flag to but... */
2082                 if (icon_size > BLI_rcti_size_x(rect)) {
2083                         /* button is not square, it has extra height for label */
2084                         text_size = UI_UNIT_Y;
2085                         icon_size -= text_size;
2086                 }
2087
2088                 /* draw icon in rect above the space reserved for the label */
2089                 rect->ymin += text_size;
2090                 GPU_blend(true);
2091                 widget_draw_preview(icon, alpha, rect);
2092                 GPU_blend(false);
2093
2094                 /* offset rect to draw label in */
2095                 rect->ymin -= text_size;
2096                 rect->ymax -= icon_size;
2097
2098                 /* vertically centering text */
2099                 rect->ymin += UI_UNIT_Y / 2;
2100         }
2101         /* Icons on the left with optional text label on the right */
2102         else if (but->flag & UI_HAS_ICON || show_menu_icon) {
2103                 const bool is_tool = UI_but_is_tool(but);
2104
2105                 /* XXX add way to draw icons at a different size!
2106                  * Use small icons for popup. */
2107 #ifdef USE_UI_TOOLBAR_HACK
2108                 const float aspect_orig = but->block->aspect;
2109                 if (is_tool && (but->block->flag & UI_BLOCK_POPOVER)) {
2110                         but->block->aspect *= 2.0f;
2111                 }
2112 #endif
2113
2114                 const BIFIconID icon = widget_icon_id(but);
2115                 int icon_size_init = is_tool ? ICON_DEFAULT_HEIGHT_TOOLBAR : ICON_DEFAULT_HEIGHT;
2116                 const float icon_size = icon_size_init / (but->block->aspect / UI_DPI_FAC);
2117                 const float icon_padding = 2 * UI_DPI_FAC;
2118
2119 #ifdef USE_UI_TOOLBAR_HACK
2120                 if (is_tool) {
2121                         /* pass (even if its a menu toolbar) */
2122                         but->drawflag |= UI_BUT_TEXT_LEFT;
2123                         but->drawflag |= UI_BUT_ICON_LEFT;
2124                 }
2125 #endif
2126
2127                 /* menu item - add some more padding so menus don't feel cramped. it must
2128                  * be part of the button so that this area is still clickable */
2129                 if (is_tool) {
2130                         /* pass (even if its a menu toolbar) */
2131                 }
2132                 else if (ui_block_is_pie_menu(but->block)) {
2133                         if (but->dt == UI_EMBOSS_RADIAL)
2134                                 rect->xmin += 0.3f * U.widget_unit;
2135                 }
2136                 else if (ui_block_is_menu(but->block))
2137                         rect->xmin += 0.2f * U.widget_unit;
2138
2139                 widget_draw_icon(but, icon, alpha, rect, wcol->text);
2140                 if (show_menu_icon) {
2141                         BLI_assert(but->block->content_hints & UI_BLOCK_CONTAINS_SUBMENU_BUT);
2142                         widget_draw_submenu_tria(but, rect, wcol);
2143                 }
2144
2145 #ifdef USE_UI_TOOLBAR_HACK
2146                 but->block->aspect = aspect_orig;
2147 #endif
2148
2149                 rect->xmin += icon_size + icon_padding;
2150         }
2151
2152         if (but->editstr || (but->drawflag & UI_BUT_TEXT_LEFT)) {
2153                 rect->xmin += (UI_TEXT_MARGIN_X * U.widget_unit) / but->block->aspect;
2154         }
2155         else if ((but->drawflag & UI_BUT_TEXT_RIGHT)) {
2156                 rect->xmax -= (UI_TEXT_MARGIN_X * U.widget_unit) / but->block->aspect;
2157         }
2158
2159         /* Menu contains sub-menu items with triangle icon on their right. Shortcut
2160          * strings should be drawn with some padding to the right then. */
2161         if (ui_block_is_menu(but->block) && (but->block->content_hints & UI_BLOCK_CONTAINS_SUBMENU_BUT)) {
2162                 rect->xmax -= UI_MENU_SUBMENU_PADDING;
2163         }
2164
2165         /* extra icons, e.g. 'x' icon to clear text or icon for eyedropper */
2166         if (extra_icon_type != UI_BUT_ICONEXTRA_NONE) {
2167                 rcti temp = *rect;
2168
2169                 temp.xmin = temp.xmax - (BLI_rcti_size_y(rect) * 1.08f);
2170
2171                 if (extra_icon_type == UI_BUT_ICONEXTRA_CLEAR) {
2172                         widget_draw_icon(but, ICON_PANEL_CLOSE, alpha, &temp, wcol->text);
2173                 }
2174                 else if (extra_icon_type == UI_BUT_ICONEXTRA_EYEDROPPER) {
2175                         widget_draw_icon(but, ICON_EYEDROPPER, alpha, &temp, wcol->text);
2176                 }
2177                 else {
2178                         BLI_assert(0);
2179                 }
2180
2181                 rect->xmax -= ICON_SIZE_FROM_BUTRECT(rect);
2182         }
2183
2184         /* clip but->drawstr to fit in available space */
2185         if (but->editstr && but->pos >= 0) {
2186                 ui_text_clip_cursor(fstyle, but, rect);
2187         }
2188         else if (but->drawstr[0] == '\0') {
2189                 /* bypass text clipping on icon buttons */
2190                 but->ofs = 0;
2191                 but->strwidth = 0;
2192         }
2193         else if (ELEM(but->type, UI_BTYPE_NUM, UI_BTYPE_NUM_SLIDER)) {
2194                 ui_text_clip_right_label(fstyle, but, rect);
2195         }
2196         else if (but->flag & UI_BUT_HAS_SEP_CHAR) {
2197                 /* Clip middle, but protect in all case right part containing the shortcut, if any. */
2198                 ui_text_clip_middle_protect_right(fstyle, but, rect, UI_SEP_CHAR);
2199         }
2200         else {
2201                 ui_text_clip_middle(fstyle, but, rect);
2202         }
2203
2204         /* always draw text for textbutton cursor */
2205         widget_draw_text(fstyle, wcol, but, rect);
2206
2207         ui_but_text_password_hide(password_str, but, true);
2208
2209         /* if a widget uses font shadow it has to be deactivated now */
2210         BLF_disable(fstyle->uifont_id, BLF_SHADOW);
2211 }
2212
2213 #undef UI_TEXT_CLIP_MARGIN
2214
2215
2216 /* *********************** widget types ************************************* */
2217
2218 /* ************ button callbacks, state ***************** */
2219
2220 static void widget_state_blend(char cp[3], const char cpstate[3], const float fac)
2221 {
2222         if (fac != 0.0f) {
2223                 cp[0] = (int)((1.0f - fac) * cp[0] + fac * cpstate[0]);
2224                 cp[1] = (int)((1.0f - fac) * cp[1] + fac * cpstate[1]);
2225                 cp[2] = (int)((1.0f - fac) * cp[2] + fac * cpstate[2]);
2226         }
2227 }
2228
2229 /* put all widget colors on half alpha, use local storage */
2230 static void ui_widget_color_disabled(uiWidgetType *wt)
2231 {
2232         static uiWidgetColors wcol_theme_s;
2233
2234         wcol_theme_s = *wt->wcol_theme;
2235
2236         wcol_theme_s.outline[3] *= 0.5;
2237         wcol_theme_s.inner[3] *= 0.5;
2238         wcol_theme_s.inner_sel[3] *= 0.5;
2239         wcol_theme_s.item[3] *= 0.5;
2240         wcol_theme_s.text[3] *= 0.5;
2241         wcol_theme_s.text_sel[3] *= 0.5;
2242
2243         wt->wcol_theme = &wcol_theme_s;
2244 }
2245
2246 static void widget_active_color(char cp[3])
2247 {
2248         cp[0] = cp[0] >= 240 ? 255 : cp[0] + 15;
2249         cp[1] = cp[1] >= 240 ? 255 : cp[1] + 15;
2250         cp[2] = cp[2] >= 240 ? 255 : cp[2] + 15;
2251 }
2252
2253 /* copy colors from theme, and set changes in it based on state */
2254 static void widget_state(uiWidgetType *wt, int state, int drawflag)
2255 {
2256         uiWidgetStateColors *wcol_state = wt->wcol_state;
2257
2258         if ((state & UI_BUT_LIST_ITEM) && !(state & UI_STATE_TEXT_INPUT)) {
2259                 /* Override default widget's colors. */
2260                 bTheme *btheme = UI_GetTheme();
2261                 wt->wcol_theme = &btheme->tui.wcol_list_item;
2262
2263                 if (state & (UI_BUT_DISABLED | UI_BUT_INACTIVE)) {
2264                         ui_widget_color_disabled(wt);
2265                 }
2266         }
2267
2268         wt->wcol = *(wt->wcol_theme);
2269
2270         if (state & UI_SELECT) {
2271                 copy_v4_v4_char(wt->wcol.inner, wt->wcol.inner_sel);
2272                 if (drawflag & UI_BUT_ANIMATED_CHANGED)
2273                         widget_state_blend(wt->wcol.inner, wcol_state->inner_changed_sel, wcol_state->blend);
2274                 else if (state & UI_BUT_ANIMATED_KEY)
2275                         widget_state_blend(wt->wcol.inner, wcol_state->inner_key_sel, wcol_state->blend);
2276                 else if (state & UI_BUT_ANIMATED)
2277                         widget_state_blend(wt->wcol.inner, wcol_state->inner_anim_sel, wcol_state->blend);
2278                 else if (state & UI_BUT_DRIVEN)
2279                         widget_state_blend(wt->wcol.inner, wcol_state->inner_driven_sel, wcol_state->blend);
2280                 else if (state & UI_BUT_OVERRIDEN)
2281                         widget_state_blend(wt->wcol.inner, wcol_state->inner_overridden_sel, wcol_state->blend);
2282
2283                 copy_v3_v3_char(wt->wcol.text, wt->wcol.text_sel);
2284
2285                 if (state & UI_SELECT)
2286                         SWAP(short, wt->wcol.shadetop, wt->wcol.shadedown);
2287         }
2288         else {
2289                 if (drawflag & UI_BUT_ANIMATED_CHANGED)
2290                         widget_state_blend(wt->wcol.inner, wcol_state->inner_changed, wcol_state->blend);
2291                 else if (state & UI_BUT_ANIMATED_KEY)
2292                         widget_state_blend(wt->wcol.inner, wcol_state->inner_key, wcol_state->blend);
2293                 else if (state & UI_BUT_ANIMATED)
2294                         widget_state_blend(wt->wcol.inner, wcol_state->inner_anim, wcol_state->blend);
2295                 else if (state & UI_BUT_DRIVEN)
2296                         widget_state_blend(wt->wcol.inner, wcol_state->inner_driven, wcol_state->blend);
2297                 else if (state & UI_BUT_OVERRIDEN)
2298                         widget_state_blend(wt->wcol.inner, wcol_state->inner_overridden, wcol_state->blend);
2299
2300                 if (state & UI_ACTIVE) { /* mouse over? */
2301                         widget_active_color(wt->wcol.inner);
2302                 }
2303         }
2304
2305         if (state & UI_BUT_REDALERT) {
2306                 char red[4] = {255, 0, 0};
2307                 if (wt->draw) {
2308                         widget_state_blend(wt->wcol.inner, red, 0.4f);
2309                 }
2310                 else {
2311                         widget_state_blend(wt->wcol.text, red, 0.4f);
2312                 }
2313         }
2314
2315         if (state & UI_BUT_DRAG_MULTI) {
2316                 /* the button isn't SELECT but we're editing this so draw with sel color */
2317                 copy_v4_v4_char(wt->wcol.inner, wt->wcol.inner_sel);
2318                 SWAP(short, wt->wcol.shadetop, wt->wcol.shadedown);
2319                 widget_state_blend(wt->wcol.text, wt->wcol.text_sel, 0.85f);
2320         }
2321
2322         if (state & UI_BUT_NODE_ACTIVE) {
2323                 char blue[4] = {86, 128, 194};
2324                 widget_state_blend(wt->wcol.inner, blue, 0.3f);
2325         }
2326 }
2327
2328 /* sliders use special hack which sets 'item' as inner when drawing filling */
2329 static void widget_state_numslider(uiWidgetType *wt, int state, int drawflag)
2330 {
2331         uiWidgetStateColors *wcol_state = wt->wcol_state;
2332         /* XXX special tweak to make sure that bar will still be visible */
2333         float blend = wcol_state->blend - 0.2f;
2334
2335         /* call this for option button */
2336         widget_state(wt, state, drawflag);
2337
2338         /* now, set the inner-part so that it reflects state settings too */
2339         /* TODO: maybe we should have separate settings for the blending colors used for this case? */
2340         if (state & UI_SELECT) {
2341
2342                 if (drawflag & UI_BUT_ANIMATED_CHANGED)
2343                         widget_state_blend(wt->wcol.item, wcol_state->inner_changed_sel, blend);
2344                 else if (state & UI_BUT_ANIMATED_KEY)
2345                         widget_state_blend(wt->wcol.item, wcol_state->inner_key_sel, blend);
2346                 else if (state & UI_BUT_ANIMATED)
2347                         widget_state_blend(wt->wcol.item, wcol_state->inner_anim_sel, blend);
2348                 else if (state & UI_BUT_DRIVEN)
2349                         widget_state_blend(wt->wcol.item, wcol_state->inner_driven_sel, blend);
2350                 else if (state & UI_BUT_OVERRIDEN)
2351                         widget_state_blend(wt->wcol.item, wcol_state->inner_overridden_sel, blend);
2352
2353                 if (state & UI_SELECT)
2354                         SWAP(short, wt->wcol.shadetop, wt->wcol.shadedown);
2355         }
2356         else {
2357                 if (drawflag & UI_BUT_ANIMATED_CHANGED)
2358                         widget_state_blend(wt->wcol.item, wcol_state->inner_changed, blend);
2359                 else if (state & UI_BUT_ANIMATED_KEY)
2360                         widget_state_blend(wt->wcol.item, wcol_state->inner_key, blend);
2361                 else if (state & UI_BUT_ANIMATED)
2362                         widget_state_blend(wt->wcol.item, wcol_state->inner_anim, blend);
2363                 else if (state & UI_BUT_DRIVEN)
2364                         widget_state_blend(wt->wcol.item, wcol_state->inner_driven, blend);
2365                 else if (state & UI_BUT_OVERRIDEN)
2366                         widget_state_blend(wt->wcol.item, wcol_state->inner_overridden, blend);
2367         }
2368 }
2369
2370 /* labels use theme colors for text */
2371 static void widget_state_option_menu(uiWidgetType *wt, int state, int drawflag)
2372 {
2373         bTheme *btheme = UI_GetTheme(); /* XXX */
2374
2375         /* call this for option button */
2376         widget_state(wt, state, drawflag);
2377
2378         /* if not selected we get theme from menu back */
2379         if (state & UI_SELECT)
2380                 copy_v3_v3_char(wt->wcol.text, btheme->tui.wcol_menu_back.text_sel);
2381         else
2382                 copy_v3_v3_char(wt->wcol.text, btheme->tui.wcol_menu_back.text);
2383 }
2384
2385
2386 static void widget_state_nothing(uiWidgetType *wt, int UNUSED(state), int UNUSED(drawflag))
2387 {
2388         wt->wcol = *(wt->wcol_theme);
2389 }
2390
2391 /* special case, button that calls pulldown */
2392 static void widget_state_pulldown(uiWidgetType *wt, int UNUSED(state), int UNUSED(drawflag))
2393 {
2394         wt->wcol = *(wt->wcol_theme);
2395 }
2396
2397 /* special case, pie menu items */
2398 static void widget_state_pie_menu_item(uiWidgetType *wt, int state, int UNUSED(drawflag))
2399 {
2400         wt->wcol = *(wt->wcol_theme);
2401
2402         /* active and disabled (not so common) */
2403         if ((state & UI_BUT_DISABLED) && (state & UI_ACTIVE)) {
2404                 widget_state_blend(wt->wcol.text, wt->wcol.text_sel, 0.5f);
2405                 /* draw the backdrop at low alpha, helps navigating with keys
2406                  * when disabled items are active */
2407                 copy_v4_v4_char(wt->wcol.inner, wt->wcol.item);
2408                 wt->wcol.inner[3] = 64;
2409         }
2410         else {
2411                 /* regular active */
2412                 if (state & (UI_SELECT | UI_ACTIVE)) {
2413                         copy_v3_v3_char(wt->wcol.text, wt->wcol.text_sel);
2414                 }
2415                 else if (state & (UI_BUT_DISABLED | UI_BUT_INACTIVE)) {
2416                         /* regular disabled */
2417                         widget_state_blend(wt->wcol.text, wt->wcol.inner, 0.5f);
2418                 }
2419
2420                 if (state & UI_SELECT) {
2421                         copy_v4_v4_char(wt->wcol.inner, wt->wcol.inner_sel);
2422                 }
2423                 else if (state & UI_ACTIVE) {
2424                         copy_v4_v4_char(wt->wcol.inner, wt->wcol.item);
2425                 }
2426         }
2427 }
2428
2429 /* special case, menu items */
2430 static void widget_state_menu_item(uiWidgetType *wt, int state, int UNUSED(drawflag))
2431 {
2432         wt->wcol = *(wt->wcol_theme);
2433
2434         /* active and disabled (not so common) */
2435         if ((state & UI_BUT_DISABLED) && (state & UI_ACTIVE)) {
2436                 widget_state_blend(wt->wcol.text, wt->wcol.text_sel, 0.5f);
2437                 /* draw the backdrop at low alpha, helps navigating with keys
2438                  * when disabled items are active */
2439                 copy_v4_v4_char(wt->wcol.inner, wt->wcol.inner_sel);
2440                 wt->wcol.inner[3] = 64;
2441         }
2442         else {
2443                 /* regular active */
2444                 if (state & UI_ACTIVE) {
2445                         copy_v3_v3_char(wt->wcol.text, wt->wcol.text_sel);
2446                 }
2447                 else if (state & (UI_BUT_DISABLED | UI_BUT_INACTIVE)) {
2448                         /* regular disabled */
2449                         widget_state_blend(wt->wcol.text, wt->wcol.inner, 0.5f);
2450                 }
2451
2452                 if (state & UI_ACTIVE) {
2453                         copy_v4_v4_char(wt->wcol.inner, wt->wcol.inner_sel);
2454                 }
2455         }
2456 }
2457
2458
2459 /* ************ menu backdrop ************************* */
2460
2461 /* outside of rect, rad to left/bottom/right */
2462 static void widget_softshadow(const rcti *rect, int roundboxalign, const float radin)
2463 {
2464         bTheme *btheme = UI_GetTheme();
2465         uiWidgetBase wtb;
2466         rcti rect1 = *rect;
2467         float alphastep;
2468         int step, totvert;
2469         float triangle_strip[WIDGET_SIZE_MAX * 2 + 2][2];
2470         const float radout = UI_ThemeMenuShadowWidth();
2471
2472         /* disabled shadow */
2473         if (radout == 0.0f)
2474                 return;
2475
2476         /* prevent tooltips to not show round shadow */
2477         if (radout > 0.2f * BLI_rcti_size_y(&rect1))
2478                 rect1.ymax -= 0.2f * BLI_rcti_size_y(&rect1);
2479         else
2480                 rect1.ymax -= radout;
2481
2482         /* inner part */
2483         totvert = round_box_shadow_edges(wtb.inner_v, &rect1, radin, roundboxalign & (UI_CNR_BOTTOM_RIGHT | UI_CNR_BOTTOM_LEFT), 0.0f);
2484
2485         /* we draw a number of increasing size alpha quad strips */
2486         alphastep = 3.0f * btheme->tui.menu_shadow_fac / radout;
2487
2488         uint pos = GPU_vertformat_attr_add(immVertexFormat(), "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
2489
2490         immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
2491
2492         for (step = 1; step <= (int)radout; step++) {
2493                 float expfac = sqrtf(step / radout);
2494
2495                 round_box_shadow_edges(wtb.outer_v, &rect1, radin, UI_CNR_ALL, (float)step);
2496
2497                 immUniformColor4f(0.0f, 0.0f, 0.0f, alphastep * (1.0f - expfac));
2498
2499                 widget_verts_to_triangle_strip(&wtb, totvert, triangle_strip);
2500
2501                 widget_draw_vertex_buffer(pos, 0, GL_TRIANGLE_STRIP, triangle_strip, NULL, totvert * 2);
2502         }
2503
2504         immUnbindProgram();
2505 }
2506
2507 static void widget_menu_back(uiWidgetColors *wcol, rcti *rect, int flag, int direction)
2508 {
2509         uiWidgetBase wtb;
2510         int roundboxalign = UI_CNR_ALL;
2511
2512         widget_init(&wtb);
2513
2514         /* menu is 2nd level or deeper */
2515         if (flag & UI_BLOCK_POPUP) {
2516                 //rect->ymin -= 4.0;
2517                 //rect->ymax += 4.0;
2518         }
2519         else if (direction == UI_DIR_DOWN) {
2520                 roundboxalign = (UI_CNR_BOTTOM_RIGHT | UI_CNR_BOTTOM_LEFT);
2521                 rect->ymin -= 0.1f * U.widget_unit;
2522         }
2523         else if (direction == UI_DIR_UP) {
2524                 roundboxalign = UI_CNR_TOP_LEFT | UI_CNR_TOP_RIGHT;
2525                 rect->ymax += 0.1f * U.widget_unit;
2526         }
2527
2528         GPU_blend_set_func_separate(GPU_SRC_ALPHA, GPU_ONE_MINUS_SRC_ALPHA, GPU_ONE, GPU_ONE_MINUS_SRC_ALPHA);
2529         GPU_blend(true);
2530         widget_softshadow(rect, roundboxalign, wcol->roundness * U.widget_unit);
2531
2532         round_box_edges(&wtb, roundboxalign, rect, wcol->roundness * U.widget_unit);
2533         wtb.draw_emboss = false;
2534         widgetbase_draw(&wtb, wcol);
2535
2536         GPU_blend(false);
2537 }
2538
2539 static void ui_hsv_cursor(float x, float y)
2540 {
2541         uint pos = GPU_vertformat_attr_add(immVertexFormat(), "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
2542
2543         immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
2544
2545         immUniformColor3f(1.0f, 1.0f, 1.0f);
2546         imm_draw_circle_fill_2d(pos, x, y, 3.0f * U.pixelsize, 8);
2547
2548         GPU_blend(true);
2549         GPU_line_smooth(true);
2550         immUniformColor3f(0.0f, 0.0f, 0.0f);
2551         imm_draw_circle_wire_2d(pos, x, y, 3.0f * U.pixelsize, 12);
2552         GPU_blend(false);
2553         GPU_line_smooth(false);
2554
2555         immUnbindProgram();
2556 }
2557
2558 void ui_hsvcircle_vals_from_pos(
2559         float *val_rad, float *val_dist, const rcti *rect,
2560         const float mx, const float my)
2561 {
2562         /* duplication of code... well, simple is better now */
2563         const float centx = BLI_rcti_cent_x_fl(rect);
2564         const float centy = BLI_rcti_cent_y_fl(rect);
2565         const float radius = (float)min_ii(BLI_rcti_size_x(rect), BLI_rcti_size_y(rect)) / 2.0f;
2566         const float m_delta[2] = {mx - centx, my - centy};
2567         const float dist_sq = len_squared_v2(m_delta);
2568
2569         *val_dist = (dist_sq < (radius * radius)) ? sqrtf(dist_sq) / radius : 1.0f;
2570         *val_rad = atan2f(m_delta[0], m_delta[1]) / (2.0f * (float)M_PI) + 0.5f;
2571 }
2572
2573 /* cursor in hsv circle, in float units -1 to 1, to map on radius */
2574 void ui_hsvcircle_pos_from_vals(uiBut *but, const rcti *rect, float *hsv, float *xpos, float *ypos)
2575 {
2576         /* duplication of code... well, simple is better now */
2577         const float centx = BLI_rcti_cent_x_fl(rect);
2578         const float centy = BLI_rcti_cent_y_fl(rect);
2579         float radius = (float)min_ii(BLI_rcti_size_x(rect), BLI_rcti_size_y(rect)) / 2.0f;
2580         float ang, radius_t;
2581
2582         ang = 2.0f * (float)M_PI * hsv[0] + (float)M_PI_2;
2583
2584         if ((but->flag & UI_BUT_COLOR_CUBIC) && (U.color_picker_type == USER_CP_CIRCLE_HSV))
2585                 radius_t = (1.0f - pow3f(1.0f - hsv[1]));
2586         else
2587                 radius_t = hsv[1];
2588
2589         radius = clamp_f(radius_t, 0.0f, 1.0f) * radius;
2590         *xpos = centx + cosf(-ang) * radius;
2591         *ypos = centy + sinf(-ang) * radius;
2592 }
2593
2594 static void ui_draw_but_HSVCIRCLE(uiBut *but, const uiWidgetColors *wcol, const rcti *rect)
2595 {
2596         /* TODO(merwin): reimplement as shader for pixel-perfect colors */
2597
2598         const int tot = 64;
2599         const float radstep = 2.0f * (float)M_PI / (float)tot;
2600         const float centx = BLI_rcti_cent_x_fl(rect);
2601         const float centy = BLI_rcti_cent_y_fl(rect);
2602         float radius = (float)min_ii(BLI_rcti_size_x(rect), BLI_rcti_size_y(rect)) / 2.0f;
2603
2604         ColorPicker *cpicker = but->custom_data;
2605         float rgb[3], hsv[3], rgb_center[3];
2606         bool is_color_gamma = ui_but_is_color_gamma(but);
2607
2608         /* Initialize for compatibility. */
2609         copy_v3_v3(hsv, cpicker->color_data);
2610
2611         /* Compute current hue. */
2612         ui_but_v3_get(but, rgb);
2613         ui_scene_linear_to_color_picker_space(but, rgb);
2614         ui_rgb_to_color_picker_compat_v(rgb, hsv);
2615
2616         CLAMP(hsv[2], 0.0f, 1.0f); /* for display only */
2617
2618         /* exception: if 'lock' is set
2619          * lock the value of the color wheel to 1.
2620          * Useful for color correction tools where you're only interested in hue. */
2621         if (but->flag & UI_BUT_COLOR_LOCK) {
2622                 if (U.color_picker_type == USER_CP_CIRCLE_HSV)
2623                         hsv[2] = 1.0f;
2624                 else
2625                         hsv[2] = 0.5f;
2626         }
2627
2628         const float hsv_center[3] = {0.0f, 0.0f, hsv[2]};
2629         ui_color_picker_to_rgb_v(hsv_center, rgb_center);
2630         ui_color_picker_to_scene_linear_space(but, rgb_center);
2631
2632         if (!is_color_gamma) {
2633                 ui_block_cm_to_display_space_v3(but->block, rgb_center);
2634         }
2635
2636         GPUVertFormat *format = immVertexFormat();
2637         uint pos = GPU_vertformat_attr_add(format, "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
2638         uint color = GPU_vertformat_attr_add(format, "color", GPU_COMP_F32, 3, GPU_FETCH_FLOAT);
2639
2640         immBindBuiltinProgram(GPU_SHADER_2D_SMOOTH_COLOR);
2641
2642         immBegin(GPU_PRIM_TRI_FAN, tot + 2);
2643         immAttr3fv(color, rgb_center);
2644         immVertex2f(pos, centx, centy);
2645
2646         float ang = 0.0f;
2647         for (int a = 0; a <= tot; a++, ang += radstep) {
2648                 float si = sinf(ang);
2649                 float co = cosf(ang);
2650                 float hsv_ang[3];
2651                 float rgb_ang[3];
2652
2653                 ui_hsvcircle_vals_from_pos(hsv_ang, hsv_ang + 1, rect, centx + co * radius, centy + si * radius);
2654                 hsv_ang[2] = hsv[2];
2655
2656                 ui_color_picker_to_rgb_v(hsv_ang, rgb_ang);
2657                 ui_color_picker_to_scene_linear_space(but, rgb_ang);
2658
2659                 if (!is_color_gamma) {
2660                         ui_block_cm_to_display_space_v3(but->block, rgb_ang);
2661                 }
2662
2663                 immAttr3fv(color, rgb_ang);
2664                 immVertex2f(pos, centx + co * radius, centy + si * radius);
2665         }
2666         immEnd();
2667         immUnbindProgram();
2668
2669         /* fully rounded outline */
2670         format = immVertexFormat();
2671         pos = GPU_vertformat_attr_add(format, "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
2672
2673         immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
2674
2675         GPU_blend(true);
2676         GPU_line_smooth(true);
2677
2678         immUniformColor3ubv((uchar *)wcol->outline);
2679         imm_draw_circle_wire_2d(pos, centx, centy, radius, tot);
2680
2681         immUnbindProgram();
2682
2683         GPU_blend(false);
2684         GPU_line_smooth(false);
2685
2686         /* cursor */
2687         copy_v3_v3(hsv, cpicker->color_data);
2688         ui_but_v3_get(but, rgb);
2689         ui_scene_linear_to_color_picker_space(but, rgb);
2690         ui_rgb_to_color_picker_compat_v(rgb, hsv);
2691
2692         float xpos, ypos;
2693         ui_hsvcircle_pos_from_vals(but, rect, hsv, &xpos, &ypos);
2694         ui_hsv_cursor(xpos, ypos);
2695 }
2696
2697 /* ************ custom buttons, old stuff ************** */
2698
2699 /* draws in resolution of 48x4 colors */
2700 void ui_draw_gradient(const rcti *rect, const float hsv[3], const int type, const float alpha)
2701 {
2702         /* allows for 4 steps (red->yellow) */
2703         const int steps = 48;
2704         const float color_step = 1.0f / steps;
2705         int a;
2706         float h = hsv[0], s = hsv[1], v = hsv[2];
2707         float dx, dy, sx1, sx2, sy;
2708         float col0[4][3];   /* left half, rect bottom to top */
2709         float col1[4][3];   /* right half, rect bottom to top */
2710
2711         /* draw series of gouraud rects */
2712
2713         switch (type) {
2714                 case UI_GRAD_SV:
2715                         hsv_to_rgb(h, 0.0, 0.0,   &col1[0][0], &col1[0][1], &col1[0][2]);
2716                         hsv_to_rgb(h, 0.0, 0.333, &col1[1][0], &col1[1][1], &col1[1][2]);
2717                         hsv_to_rgb(h, 0.0, 0.666, &col1[2][0], &col1[2][1], &col1[2][2]);
2718                         hsv_to_rgb(h, 0.0, 1.0,   &col1[3][0], &col1[3][1], &col1[3][2]);
2719                         break;
2720                 case UI_GRAD_HV:
2721                         hsv_to_rgb(0.0, s, 0.0,   &col1[0][0], &col1[0][1], &col1[0][2]);
2722                         hsv_to_rgb(0.0, s, 0.333, &col1[1][0], &col1[1][1], &col1[1][2]);
2723                         hsv_to_rgb(0.0, s, 0.666, &col1[2][0], &col1[2][1], &col1[2][2]);
2724                         hsv_to_rgb(0.0, s, 1.0,   &col1[3][0], &col1[3][1], &col1[3][2]);
2725                         break;
2726                 case UI_GRAD_HS:
2727                         hsv_to_rgb(0.0, 0.0, v,   &col1[0][0], &col1[0][1], &col1[0][2]);
2728                         hsv_to_rgb(0.0, 0.333, v, &col1[1][0], &col1[1][1], &col1[1][2]);
2729                         hsv_to_rgb(0.0, 0.666, v, &col1[2][0], &col1[2][1], &col1[2][2]);
2730                         hsv_to_rgb(0.0, 1.0, v,   &col1[3][0], &col1[3][1], &col1[3][2]);
2731                         break;
2732                 case UI_GRAD_H:
2733                         hsv_to_rgb(0.0, 1.0, 1.0, &col1[0][0], &col1[0][1], &col1[0][2]);
2734                         copy_v3_v3(col1[1], col1[0]);
2735                         copy_v3_v3(col1[2], col1[0]);
2736                         copy_v3_v3(col1[3], col1[0]);
2737                         break;
2738                 case UI_GRAD_S:
2739                         hsv_to_rgb(1.0, 0.0, 1.0, &col1[1][0], &col1[1][1], &col1[1][2]);
2740                         copy_v3_v3(col1[0], col1[1]);
2741                         copy_v3_v3(col1[2], col1[1]);
2742                         copy_v3_v3(col1[3], col1[1]);
2743                         break;
2744                 case UI_GRAD_V:
2745                         hsv_to_rgb(1.0, 1.0, 0.0, &col1[2][0], &col1[2][1], &col1[2][2]);
2746                         copy_v3_v3(col1[0], col1[2]);
2747                         copy_v3_v3(col1[1], col1[2]);
2748                         copy_v3_v3(col1[3], col1[2]);
2749                         break;
2750                 default:
2751                         assert(!"invalid 'type' argument");
2752                         hsv_to_rgb(1.0, 1.0, 1.0, &col1[2][0], &col1[2][1], &col1[2][2]);
2753                         copy_v3_v3(col1[0], col1[2]);
2754                         copy_v3_v3(col1[1], col1[2]);
2755                         copy_v3_v3(col1[3], col1[2]);
2756                         break;
2757         }
2758
2759         /* old below */
2760         GPUVertFormat *format = immVertexFormat();
2761         uint pos = GPU_vertformat_attr_add(format, "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
2762         uint col = GPU_vertformat_attr_add(format, "color", GPU_COMP_F32, 4, GPU_FETCH_FLOAT);
2763         immBindBuiltinProgram(GPU_SHADER_2D_SMOOTH_COLOR);
2764
2765         immBegin(GPU_PRIM_TRIS, steps * 3 * 6);
2766
2767         /* 0.999 = prevent float inaccuracy for steps */
2768         for (dx = 0.0f; dx < 0.999f; dx += color_step) {
2769                 const float dx_next = dx + color_step;
2770
2771                 /* previous color */
2772                 copy_v3_v3(col0[0], col1[0]);
2773                 copy_v3_v3(col0[1], col1[1]);
2774                 copy_v3_v3(col0[2], col1[2]);
2775                 copy_v3_v3(col0[3], col1[3]);
2776
2777                 /* new color */
2778                 switch (type) {
2779                         case UI_GRAD_SV:
2780                                 hsv_to_rgb(h, dx, 0.0,   &col1[0][0], &col1[0][1], &col1[0][2]);
2781                                 hsv_to_rgb(h, dx, 0.333, &col1[1][0], &col1[1][1], &col1[1][2]);
2782                                 hsv_to_rgb(h, dx, 0.666, &col1[2][0], &col1[2][1], &col1[2][2]);
2783                                 hsv_to_rgb(h, dx, 1.0,   &col1[3][0], &col1[3][1], &col1[3][2]);
2784                                 break;
2785                         case UI_GRAD_HV:
2786                                 hsv_to_rgb(dx_next, s, 0.0,   &col1[0][0], &col1[0][1], &col1[0][2]);
2787                                 hsv_to_rgb(dx_next, s, 0.333, &col1[1][0], &col1[1][1], &col1[1][2]);
2788                                 hsv_to_rgb(dx_next, s, 0.666, &col1[2][0], &col1[2][1], &col1[2][2]);
2789                                 hsv_to_rgb(dx_next, s, 1.0,   &col1[3][0], &col1[3][1], &col1[3][2]);
2790                                 break;
2791                         case UI_GRAD_HS:
2792                                 hsv_to_rgb(dx_next, 0.0, v,   &col1[0][0], &col1[0][1], &col1[0][2]);
2793                                 hsv_to_rgb(dx_next, 0.333, v, &col1[1][0], &col1[1][1], &col1[1][2]);
2794                                 hsv_to_rgb(dx_next, 0.666, v, &col1[2][0], &col1[2][1], &col1[2][2]);
2795                                 hsv_to_rgb(dx_next, 1.0, v,   &col1[3][0], &col1[3][1], &col1[3][2]);
2796                                 break;
2797                         case UI_GRAD_H:
2798                                 /* annoying but without this the color shifts - could be solved some other way
2799                                  * - campbell */
2800                                 hsv_to_rgb(dx_next, 1.0, 1.0, &col1[0][0], &col1[0][1], &col1[0][2]);
2801                                 copy_v3_v3(col1[1], col1[0]);
2802                                 copy_v3_v3(col1[2], col1[0]);
2803                                 copy_v3_v3(col1[3], col1[0]);
2804                                 break;
2805                         case UI_GRAD_S:
2806                                 hsv_to_rgb(h, dx, 1.0, &col1[1][0], &col1[1][1], &col1[1][2]);
2807                                 copy_v3_v3(col1[0], col1[1]);
2808                                 copy_v3_v3(col1[2], col1[1]);
2809                                 copy_v3_v3(col1[3], col1[1]);
2810                                 break;
2811                         case UI_GRAD_V:
2812                                 hsv_to_rgb(h, 1.0, dx, &col1[2][0], &col1[2][1], &col1[2][2]);
2813                                 copy_v3_v3(col1[0], col1[2]);
2814                                 copy_v3_v3(col1[1], col1[2]);
2815                                 copy_v3_v3(col1[3], col1[2]);
2816                                 break;
2817                 }
2818
2819                 /* rect */
2820                 sx1 = rect->xmin + dx      * BLI_rcti_size_x(rect);
2821                 sx2 = rect->xmin + dx_next * BLI_rcti_size_x(rect);
2822                 sy = rect->ymin;
2823                 dy = (float)BLI_rcti_size_y(rect) / 3.0f;
2824
2825                 for (a = 0; a < 3; a++, sy += dy) {
2826                         immAttr4f(col, col0[a][0], col0[a][1], col0[a][2], alpha);
2827                         immVertex2f(pos, sx1, sy);
2828
2829                         immAttr4f(col, col1[a][0], col1[a][1], col1[a][2], alpha);
2830                         immVertex2f(pos, sx2, sy);
2831
2832                         immAttr4f(col, col1[a + 1][0], col1[a + 1][1], col1[a + 1][2], alpha);
2833                         immVertex2f(pos, sx2, sy + dy);
2834
2835                         immAttr4f(col, col0[a][0], col0[a][1], col0[a][2], alpha);
2836                         immVertex2f(pos, sx1, sy);
2837
2838                         immAttr4f(col, col1[a + 1][0], col1[a + 1][1], col1[a + 1][2], alpha);
2839                         immVertex2f(pos, sx2, sy + dy);
2840
2841                         immAttr4f(col, col0[a + 1][0], col0[a + 1][1], col0[a + 1][2], alpha);
2842                         immVertex2f(pos, sx1, sy + dy);
2843                 }
2844         }
2845         immEnd();
2846
2847         immUnbindProgram();
2848 }
2849
2850 void ui_hsvcube_pos_from_vals(uiBut *but, const rcti *rect, float *hsv, float *xp, float *yp)
2851 {
2852         float x = 0.0f, y = 0.0f;
2853
2854         switch ((int)but->a1) {
2855                 case UI_GRAD_SV:
2856                         x = hsv[1]; y = hsv[2]; break;
2857                 case UI_GRAD_HV:
2858                         x = hsv[0]; y = hsv[2]; break;
2859                 case UI_GRAD_HS:
2860                         x = hsv[0]; y = hsv[1]; break;
2861                 case UI_GRAD_H:
2862                         x = hsv[0]; y = 0.5; break;
2863                 case UI_GRAD_S:
2864                         x = hsv[1]; y = 0.5; break;
2865                 case UI_GRAD_V:
2866                         x = hsv[2]; y = 0.5; break;
2867                 case UI_GRAD_L_ALT:
2868                         x = 0.5f;
2869                         /* exception only for value strip - use the range set in but->min/max */
2870                         y = hsv[2];
2871                         break;
2872                 case UI_GRAD_V_ALT:
2873                         x = 0.5f;
2874                         /* exception only for value strip - use the range set in but->min/max */
2875                         y = (hsv[2] - but->softmin) / (but->softmax - but->softmin);
2876                         break;
2877         }
2878
2879         /* cursor */
2880         *xp = rect->xmin + x * BLI_rcti_size_x(rect);
2881         *yp = rect->ymin + y * BLI_rcti_size_y(rect);
2882 }
2883
2884 static void ui_draw_but_HSVCUBE(uiBut *but, const rcti *rect)
2885 {
2886         float rgb[3];
2887         float x = 0.0f, y = 0.0f;
2888         ColorPicker *cpicker = but->custom_data;
2889         float *hsv = cpicker->color_data;
2890         float hsv_n[3];
2891
2892         /* Initialize for compatibility. */
2893         copy_v3_v3(hsv_n, hsv);
2894
2895         ui_but_v3_get(but, rgb);
2896         ui_scene_linear_to_color_picker_space(but, rgb);
2897         rgb_to_hsv_compat_v(rgb, hsv_n);
2898
2899         ui_draw_gradient(rect, hsv_n, but->a1, 1.0f);
2900
2901         ui_hsvcube_pos_from_vals(but, rect, hsv_n, &x, &y);
2902         CLAMP(x, rect->xmin + 3.0f, rect->xmax - 3.0f);
2903         CLAMP(y, rect->ymin + 3.0f, rect->ymax - 3.0f);
2904
2905         ui_hsv_cursor(x, y);
2906
2907         /* outline */
2908         uint pos = GPU_vertformat_attr_add(immVertexFormat(), "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
2909         immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
2910         immUniformColor3ub(0, 0, 0);
2911         imm_draw_box_wire_2d(pos, (rect->xmin), (rect->ymin), (rect->xmax), (rect->ymax));
2912         immUnbindProgram();
2913 }
2914
2915 /* vertical 'value' slider, using new widget code */
2916 static void ui_draw_but_HSV_v(uiBut *but, const rcti *rect)
2917 {
2918         bTheme *btheme = UI_GetTheme();
2919         uiWidgetColors *wcol = &btheme->tui.wcol_numslider;
2920         uiWidgetBase wtb;
2921         const float rad = wcol->roundness * BLI_rcti_size_x(rect);
2922         float x, y;
2923         float rgb[3], hsv[3], v;
2924
2925         ui_but_v3_get(but, rgb);
2926         ui_scene_linear_to_color_picker_space(but, rgb);
2927
2928         if (but->a1 == UI_GRAD_L_ALT)
2929                 rgb_to_hsl_v(rgb, hsv);
2930         else
2931                 rgb_to_hsv_v(rgb, hsv);
2932         v = hsv[2];
2933
2934         /* map v from property range to [0,1] */
2935         if (but->a1 == UI_GRAD_V_ALT) {
2936                 float min = but->softmin, max = but->softmax;
2937                 v = (v - min) / (max - min);
2938         }
2939
2940         widget_init(&wtb);
2941
2942         /* fully rounded */
2943         round_box_edges(&wtb, UI_CNR_ALL, rect, rad);
2944
2945         /* setup temp colors */
2946         widgetbase_draw(
2947                 &wtb,
2948                 &((uiWidgetColors){
2949                     .outline = {0, 0, 0, 255},
2950                     .inner = {128, 128, 128, 255},
2951                     .shadetop = 127,
2952                     .shadedown = -128,
2953                     .shaded = 1,
2954                 })
2955         );
2956
2957         /* We are drawing on top of widget bases. Flush cache. */
2958         GPU_blend(true);
2959         UI_widgetbase_draw_cache_flush();
2960         GPU_blend(false);
2961
2962         /* cursor */
2963         x = rect->xmin + 0.5f * BLI_rcti_size_x(rect);
2964         y = rect->ymin + v    * BLI_rcti_size_y(rect);
2965         CLAMP(y, rect->ymin + 3.0f, rect->ymax - 3.0f);
2966
2967         ui_hsv_cursor(x, y);
2968 }
2969
2970 /* Generic round-box drawing. */
2971 static void ui_draw_roundbox(const rcti *rect, const float rad, const uiWidgetColors *wcol)
2972 {
2973         uiWidgetBase wtb;
2974         widget_init(&wtb);
2975         round_box_edges(&wtb, UI_CNR_ALL, rect, rad);
2976         widgetbase_draw(&wtb, wcol);
2977
2978         /* We are drawing on top of widget bases. Flush cache. */
2979         GPU_blend(true);
2980         UI_widgetbase_draw_cache_flush();
2981         GPU_blend(false);
2982 }
2983
2984
2985 /* ************ separator, for menus etc ***************** */
2986 static void ui_draw_separator(const rcti *rect, const uiWidgetColors *wcol)
2987 {
2988         int y = rect->ymin + BLI_rcti_size_y(rect) / 2 - 1;
2989         uchar col[4] = {
2990                 wcol->text[0],
2991                 wcol->text[1],
2992                 wcol->text[2],
2993                 30
2994         };
2995
2996         uint pos = GPU_vertformat_attr_add(immVertexFormat(), "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
2997         immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
2998
2999         GPU_blend(true);
3000         immUniformColor4ubv(col);
3001         GPU_line_width(1.0f);
3002
3003         immBegin(GPU_PRIM_LINES, 2);
3004         immVertex2f(pos, rect->xmin, y);
3005         immVertex2f(pos, rect->xmax, y);
3006         immEnd();
3007
3008         GPU_blend(false);
3009
3010         immUnbindProgram();
3011 }
3012
3013 /* ************ button callbacks, draw ***************** */
3014 static void widget_numbut_draw(uiWidgetColors *wcol, rcti *rect, int state, int roundboxalign, bool emboss)
3015 {
3016         uiWidgetBase wtb;
3017         const float rad = wcol->roundness * BLI_rcti_size_y(rect);
3018         const int handle_width = min_ii(BLI_rcti_size_x(rect) / 3, BLI_rcti_size_y(rect) * 0.7f);
3019
3020         if (state & UI_SELECT)
3021                 SWAP(short, wcol->shadetop, wcol->shadedown);
3022
3023         widget_init(&wtb);
3024
3025         if (!emboss) {
3026                 round_box_edges(&wtb, roundboxalign, rect, rad);
3027         }
3028         else {
3029                 wtb.draw_inner = false;
3030                 wtb.draw_outline = false;
3031         }
3032
3033         /* decoration */
3034         if ((state & UI_ACTIVE) && !(state & UI_STATE_TEXT_INPUT)) {
3035                 uiWidgetColors wcol_zone;
3036                 uiWidgetBase wtb_zone;
3037                 rcti rect_zone;
3038                 int roundboxalign_zone;
3039
3040                 /* left arrow zone */
3041                 widget_init(&wtb_zone);
3042                 wtb_zone.draw_outline = false;
3043                 wtb_zone.draw_emboss = false;
3044
3045                 wcol_zone = *wcol;
3046                 copy_v3_v3_char(wcol_zone.item, wcol->text);
3047                 if (state & UI_STATE_ACTIVE_LEFT) {
3048                         widget_active_color(wcol_zone.inner);
3049                 }
3050
3051                 rect_zone = *rect;
3052                 rect_zone.xmax = rect->xmin + handle_width + U.pixelsize;
3053                 roundboxalign_zone = roundboxalign & ~(UI_CNR_TOP_RIGHT | UI_CNR_BOTTOM_RIGHT);
3054                 round_box_edges(&wtb_zone, roundboxalign_zone, &rect_zone, rad);
3055
3056                 shape_preset_init_number_arrows(&wtb_zone.tria1, &rect_zone, 0.6f, 'l');
3057                 widgetbase_draw(&wtb_zone, &wcol_zone);
3058
3059                 /* right arrow zone */
3060                 widget_init(&wtb_zone);
3061                 wtb_zone.draw_outline = false;
3062                 wtb_zone.draw_emboss = false;
3063                 wtb_zone.tria1.type = ROUNDBOX_TRIA_ARROWS;
3064
3065                 wcol_zone = *wcol;
3066                 copy_v3_v3_char(wcol_zone.item, wcol->text);
3067                 if (state & UI_STATE_ACTIVE_RIGHT) {
3068                         widget_active_color(wcol_zone.inner);
3069                 }
3070
3071                 rect_zone = *rect;
3072                 rect_zone.xmin = rect->xmax - handle_width - U.pixelsize;
3073                 roundboxalign_zone = roundboxalign & ~(UI_CNR_TOP_LEFT | UI_CNR_BOTTOM_LEFT);
3074                 round_box_edges(&wtb_zone, roundboxalign_zone, &rect_zone, rad);
3075
3076                 shape_preset_init_number_arrows(&wtb_zone.tria2, &rect_zone, 0.6f, 'r');
3077                 widgetbase_draw(&wtb_zone, &wcol_zone);
3078
3079                 /* middle highlight zone */
3080                 widget_init(&wtb_zone);
3081                 wtb_zone.draw_outline = false;
3082                 wtb_zone.draw_emboss = false;
3083
3084                 wcol_zone = *wcol;
3085                 copy_v3_v3_char(wcol_zone.item, wcol->text);
3086                 if (!(state & (UI_STATE_ACTIVE_LEFT | UI_STATE_ACTIVE_RIGHT))) {
3087                         widget_active_color(wcol_zone.inner);
3088                 }
3089
3090                 rect_zone = *rect;
3091                 rect_zone.xmin = rect->xmin + handle_width - U.pixelsize;
3092                 rect_zone.xmax = rect->xmax - handle_width + U.pixelsize;
3093                 round_box_edges(&wtb_zone, 0, &rect_zone, 0);
3094                 widgetbase_draw(&wtb_zone, &wcol_zone);
3095
3096                 /* outline */
3097                 wtb.draw_inner = false;
3098                 widgetbase_draw(&wtb, wcol);
3099         }
3100         else {
3101                 /* inner and outline */
3102                 widgetbase_draw(&wtb, wcol);
3103         }
3104
3105         if (!(state & UI_STATE_TEXT_INPUT)) {
3106      &nb