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