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