1 /* Copyright (C) 2021-2024 Harry Godden (hgn) - All Rights Reserved */
6 * 1. layout is defined by subdividing
7 * 2. a parent node should never be resized by the content after creation
8 * 3. when the ui is in an interactive state, no controls should ever move
9 * 4. controls directly reference a memory location and use that as their
11 * 5. a maximum of ONE control per memory location can be drawn at any given
18 #include "vg_engine.h"
20 #include "vg_shader.h"
23 ui_px k_ui_widget_height
= 28,
27 ui_font vg_ui_font_small
= {
48 struct vg_imgui vg_ui
= {
50 [ k_ui_bg
+0 ] = UI_RGB( 0x1d2021 ),
51 [ k_ui_bg
+1 ] = UI_RGB( 0x282828 ),
52 [ k_ui_bg
+2 ] = UI_RGB( 0x3c3836 ),
53 [ k_ui_bg
+3 ] = UI_RGB( 0x504945 ),
54 [ k_ui_bg
+4 ] = UI_RGB( 0x665c54 ),
55 [ k_ui_bg
+5 ] = UI_RGB( 0x7c6f64 ),
56 [ k_ui_bg
+6 ] = UI_RGB( 0x928374 ),
57 [ k_ui_bg
+7 ] = UI_RGB( 0xa89984 ),
59 [ k_ui_fg
+0 ] = UI_RGB( 0xebdbb2 ),
60 [ k_ui_fg
+1 ] = UI_RGB( 0xfbf1c7 ),
61 [ k_ui_fg
+2 ] = UI_RGB( 0xd5c4a1 ),
62 [ k_ui_fg
+3 ] = UI_RGB( 0xbdae93 ),
63 [ k_ui_fg
+4 ] = UI_RGB( 0xa89984 ),
64 [ k_ui_fg
+5 ] = UI_RGB( 0x000000 ),
65 [ k_ui_fg
+6 ] = UI_RGB( 0x000000 ),
66 [ k_ui_fg
+7 ] = UI_RGB( 0x000000 ),
68 [ k_ui_red
] = UI_RGB( 0xcc241d ),
69 [ k_ui_orange
] = UI_RGB( 0xd65d0e ),
70 [ k_ui_yellow
] = UI_RGB( 0xd79921 ),
71 [ k_ui_green
] = UI_RGB( 0x98971a ),
72 [ k_ui_aqua
] = UI_RGB( 0x689d6a ),
73 [ k_ui_blue
] = UI_RGB( 0x458588 ),
74 [ k_ui_purple
] = UI_RGB( 0xb16286 ),
75 [ k_ui_gray
] = UI_RGB( 0x928374 ),
76 [ k_ui_red
+ k_ui_brighter
] = UI_RGB( 0xfb4934 ),
77 [ k_ui_orange
+ k_ui_brighter
] = UI_RGB( 0xfe8019 ),
78 [ k_ui_yellow
+ k_ui_brighter
] = UI_RGB( 0xfabd2f ),
79 [ k_ui_green
+ k_ui_brighter
] = UI_RGB( 0xb8bb26 ),
80 [ k_ui_aqua
+ k_ui_brighter
] = UI_RGB( 0x8ec07c ),
81 [ k_ui_blue
+ k_ui_brighter
] = UI_RGB( 0x83a598 ),
82 [ k_ui_purple
+ k_ui_brighter
] = UI_RGB( 0xd3869b ),
83 [ k_ui_gray
+ k_ui_brighter
] = UI_RGB( 0xa89984 ),
85 .font
= &vg_ui_font_small
,
86 .colour
= {1.0f
,1.0f
,1.0f
,1.0f
},
87 .bg_inverse_ratio
= {1,1}
90 static struct vg_shader _shader_ui
={
91 .name
= "[vg] ui - transparent",
95 "layout (location=0) in vec2 a_co;"
96 "layout (location=1) in vec2 a_uv;"
97 "layout (location=2) in vec4 a_colour;"
99 "uniform vec2 uBGInverseRatio;"
101 "out vec4 aTexCoords;"
105 "vec4 proj_pos = vec4( uPv * vec3( a_co, 1.0 ), 1.0 );"
106 "gl_Position = proj_pos;"
107 "aTexCoords = vec4( a_uv * 0.00390625, "
108 " (proj_pos.xy*0.5+0.5) * uBGInverseRatio );"
109 "aColour = a_colour;"
115 "uniform sampler2D uTexGlyphs;"
116 "uniform sampler2D uTexBG;"
117 "uniform vec4 uColour;"
118 "uniform float uSpread;"
119 "out vec4 FragColor;"
121 "in vec4 aTexCoords;"
124 "vec2 rand_hash22( vec2 p ){"
125 "vec3 p3 = fract(vec3(p.xyx) * 213.8976123);"
126 "p3 += dot(p3, p3.yzx+19.19);"
127 "return fract(vec2((p3.x + p3.y)*p3.z, (p3.x+p3.z)*p3.y));"
131 "vec4 diffuse = aColour;"
133 "vec4 avg = vec4(0.0);"
135 "if( aColour.a == 0.0 ){"
137 "avg.a = texture( uTexGlyphs, aTexCoords.xy ).r;"
140 "if( uSpread > 0.0001 ){"
141 "for( int i=0; i<4; i ++ ){"
142 "vec2 spread = rand_hash22(aTexCoords.zw+vec2(float(i)));"
143 "avg += texture( uTexBG, aTexCoords.zw + (spread-0.5)*uSpread );"
147 "avg.rgb = mix( avg.rgb, aColour.rgb, aColour.a );"
154 "FragColor = avg * uColour;"
159 static struct vg_shader _shader_ui_image
= {
160 .name
= "[vg] ui_image",
165 "layout (location=0) in vec2 a_co;"
166 "layout (location=1) in vec2 a_uv;"
167 "layout (location=2) in vec4 a_colour;"
170 "out vec2 aTexCoords;"
176 "gl_Position = vec4( uPv * vec3( a_co, 1.0 ), 1.0 );"
177 "aTexCoords = a_uv * 0.00390625;"
178 "aColour = a_colour;"
187 "uniform sampler2D uTexImage;"
188 "uniform vec4 uColour;"
189 "out vec4 FragColor;"
191 "in vec2 aTexCoords;"
197 "vec4 colour = texture( uTexImage, aTexCoords );"
198 "FragColor = colour * uColour;"
203 static struct vg_shader _shader_ui_hsv
= {
204 .name
= "[vg] ui_hsv",
208 "layout (location=0) in vec2 a_co;"
209 "layout (location=1) in vec2 a_uv;"
210 "layout (location=2) in vec4 a_colour;"
213 "out vec2 aTexCoords;"
219 "gl_Position = vec4( uPv * vec3( a_co, 1.0 ), 1.0 );"
220 "aTexCoords = a_uv * 0.00390625;"
221 "aColour = a_colour;"
230 "uniform float uHue;"
231 "out vec4 FragColor;"
233 "in vec2 aTexCoords;"
239 "vec3 c = vec3( uHue, aTexCoords );"
240 "vec4 K = vec4(1.0,2.0/3.0,1.0/3.0,3.0);"
241 "vec3 p = abs(fract(c.xxx+K.xyz)*6.0 - K.www);"
242 "vec3 colour = c.z*mix(K.xxx,clamp(p-K.xxx,0.0,1.0),c.y);"
243 "FragColor = vec4( colour, 1.0 );"
248 void vg_ui_init(void)
250 if( !vg_shader_compile( &_shader_ui
) ||
251 !vg_shader_compile( &_shader_ui_image
) ||
252 !vg_shader_compile( &_shader_ui_hsv
) ){
253 vg_fatal_error( "Failed to compile ui shader" );
258 * ----------------------------------------
261 vg_ui
.max_indices
= 20000;
262 vg_ui
.max_verts
= 30000;
264 /* Generate the buffer we are gonna be drawing to */
265 glGenVertexArrays( 1, &vg_ui
.vao
);
266 glGenBuffers( 1, &vg_ui
.vbo
);
267 glGenBuffers( 1, &vg_ui
.ebo
);
269 glBindVertexArray( vg_ui
.vao
);
270 glBindBuffer( GL_ARRAY_BUFFER
, vg_ui
.vbo
);
272 glBufferData( GL_ARRAY_BUFFER
,
273 vg_ui
.max_verts
* sizeof( struct ui_vert
),
274 NULL
, GL_DYNAMIC_DRAW
);
275 glBindVertexArray( vg_ui
.vao
);
277 glBindBuffer( GL_ELEMENT_ARRAY_BUFFER
, vg_ui
.ebo
);
278 glBufferData( GL_ELEMENT_ARRAY_BUFFER
,
279 vg_ui
.max_indices
* sizeof( u16
), NULL
, GL_DYNAMIC_DRAW
);
284 u32
const stride
= sizeof( struct ui_vert
);
287 glVertexAttribPointer( 0, 2, GL_SHORT
, GL_FALSE
, stride
,
288 (void *)offsetof( struct ui_vert
, co
) );
289 glEnableVertexAttribArray( 0 );
292 glVertexAttribPointer( 1, 2, GL_UNSIGNED_SHORT
, GL_FALSE
, stride
,
293 (void *)offsetof( struct ui_vert
, uv
) );
294 glEnableVertexAttribArray( 1 );
297 glVertexAttribPointer( 2, 4, GL_UNSIGNED_BYTE
, GL_TRUE
, stride
,
298 (void *)offsetof( struct ui_vert
, colour
) );
299 glEnableVertexAttribArray( 2 );
303 /* Alloc RAM default context */
304 u32 vert_size
= vg_ui
.max_verts
*sizeof(struct ui_vert
),
305 inds_size
= vg_align8( vg_ui
.max_indices
*sizeof(u16
) );
307 vg_ui
.vertex_buffer
= vg_linear_alloc( vg_mem
.rtmemory
, vert_size
);
308 vg_ui
.indice_buffer
= vg_linear_alloc( vg_mem
.rtmemory
, inds_size
);
311 * -----------------------------------------------------
314 /* Load default font */
316 #include "vg/vg_pxfont_thin.h"
319 u32 pixels
= 0, total
= 256*256, data
= 0;
322 while( pixels
< total
){
323 for( int b
= 31; b
>= 0; b
-- ){
324 image
[ pixels
++ ] = (compressed
[data
] & (0x1u
<< b
))? 0xffu
: 0x00u
;
326 if( pixels
>= total
){
334 glGenTextures( 1, &vg_ui
.tex_glyphs
);
335 glBindTexture( GL_TEXTURE_2D
, vg_ui
.tex_glyphs
);
336 glTexImage2D( GL_TEXTURE_2D
, 0, GL_R8
, 256, 256, 0,
337 GL_RED
, GL_UNSIGNED_BYTE
, image
);
340 glTexParameteri( GL_TEXTURE_2D
, GL_TEXTURE_WRAP_S
, GL_CLAMP_TO_EDGE
);
341 glTexParameteri( GL_TEXTURE_2D
, GL_TEXTURE_WRAP_T
, GL_CLAMP_TO_EDGE
);
342 glTexParameteri( GL_TEXTURE_2D
, GL_TEXTURE_MIN_FILTER
, GL_NEAREST
);
343 glTexParameteri( GL_TEXTURE_2D
, GL_TEXTURE_MAG_FILTER
, GL_NEAREST
);
347 * ---------------------------------------------------------------
350 vg_ui
.cursor_map
[ k_ui_cursor_default
] =
351 SDL_CreateSystemCursor( SDL_SYSTEM_CURSOR_ARROW
);
352 vg_ui
.cursor_map
[ k_ui_cursor_hand
] =
353 SDL_CreateSystemCursor( SDL_SYSTEM_CURSOR_HAND
);
354 vg_ui
.cursor_map
[ k_ui_cursor_ibeam
] =
355 SDL_CreateSystemCursor( SDL_SYSTEM_CURSOR_IBEAM
);
358 void rect_copy( ui_rect a
, ui_rect b
){
359 for( int i
=0; i
<4; i
++ )
363 void ui_flush( enum ui_shader shader
, f32 w
, f32 h
){
364 u32 vertex_offset
= vg_ui
.vert_start
*sizeof(ui_vert
),
365 vertex_count
= vg_ui
.cur_vert
-vg_ui
.vert_start
,
366 vertex_size
= vertex_count
*sizeof(ui_vert
),
368 indice_offset
= vg_ui
.indice_start
*sizeof(u16
),
369 indice_count
= vg_ui
.cur_indice
-vg_ui
.indice_start
,
370 indice_size
= indice_count
* sizeof(u16
);
372 if( !vertex_size
|| !indice_size
)
375 glBindVertexArray( vg_ui
.vao
);
376 glBindBuffer( GL_ARRAY_BUFFER
, vg_ui
.vbo
);
377 glBufferSubData( GL_ARRAY_BUFFER
, vertex_offset
, vertex_size
,
378 vg_ui
.vertex_buffer
+vg_ui
.vert_start
);
380 glBindBuffer( GL_ELEMENT_ARRAY_BUFFER
, vg_ui
.ebo
);
381 glBufferSubData( GL_ELEMENT_ARRAY_BUFFER
, indice_offset
, indice_size
,
382 vg_ui
.indice_buffer
+vg_ui
.indice_start
);
384 glDisable( GL_DEPTH_TEST
);
385 glEnable( GL_BLEND
);
386 glBlendFunc( GL_SRC_ALPHA
, GL_ONE_MINUS_SRC_ALPHA
);
387 glBlendEquation( GL_FUNC_ADD
);
388 glDisable( GL_CULL_FACE
);
390 m3x3f view
= M3X3_IDENTITY
;
391 m3x3_translate( view
, (v3f
){ -1.0f
, 1.0f
, 0.0f
} );
392 m3x3_scale( view
, (v3f
){ 1.0f
/(w
*0.5f
),
393 -1.0f
/(h
*0.5f
), 1.0f
} );
395 if( shader
== k_ui_shader_colour
){
396 glUseProgram( _shader_ui
.id
);
398 glUniformMatrix3fv( glGetUniformLocation( _shader_ui
.id
, "uPv" ), 1,
399 GL_FALSE
, (float *)view
);
400 glUniform4fv( glGetUniformLocation( _shader_ui
.id
, "uColour" ), 1,
403 glActiveTexture( GL_TEXTURE0
);
404 glBindTexture( GL_TEXTURE_2D
, vg_ui
.tex_glyphs
);
405 glUniform1i( glGetUniformLocation( _shader_ui
.id
, "uTexGlyphs" ), 0 );
407 glActiveTexture( GL_TEXTURE1
);
408 glBindTexture( GL_TEXTURE_2D
, vg_ui
.tex_bg
);
409 glUniform1i( glGetUniformLocation( _shader_ui
.id
, "uTexBG" ), 1 );
410 glUniform1f( glGetUniformLocation( _shader_ui
.id
, "uSpread" ),
412 glUniform2fv( glGetUniformLocation( _shader_ui
.id
, "uBGInverseRatio" ),
413 1, vg_ui
.bg_inverse_ratio
);
415 else if( shader
== k_ui_shader_image
){
416 glUseProgram( _shader_ui_image
.id
);
417 glUniformMatrix3fv( glGetUniformLocation( _shader_ui_image
.id
, "uPv" ), 1,
418 GL_FALSE
, (float *)view
);
419 glUniform1i( glGetUniformLocation(_shader_ui_image
.id
,"uTexImage"), 0 );
420 glUniform4fv( glGetUniformLocation( _shader_ui_image
.id
, "uColour" ), 1,
423 else if( shader
== k_ui_shader_hsv
){
424 glUseProgram( _shader_ui_hsv
.id
);
425 glUniformMatrix3fv( glGetUniformLocation( _shader_ui_hsv
.id
, "uPv" ), 1,
426 GL_FALSE
, (float *)view
);
427 glUniform1f( glGetUniformLocation(_shader_ui_hsv
.id
,"uHue"), vg_ui
.hue
);
430 vg_fatal_error( "Invalid UI shader (%d)\n", shader
);
432 glDrawElements( GL_TRIANGLES
, indice_count
, GL_UNSIGNED_SHORT
,
433 (void *)(vg_ui
.indice_start
*sizeof(u16
)) );
435 glDisable( GL_BLEND
);
437 vg_ui
.indice_start
= vg_ui
.cur_indice
;
438 vg_ui
.vert_start
= vg_ui
.cur_vert
;
441 void ui_fill_rect( ui_rect rect
, u32 colour
, ui_px uv
[4] )
443 /* this if far from ideal but stops us from crashing */
444 if( (vg_ui
.cur_vert
+ 4 > vg_ui
.max_verts
) ||
445 (vg_ui
.cur_indice
+ 6 > vg_ui
.max_indices
))
448 struct ui_vert
*vertices
= &vg_ui
.vertex_buffer
[ vg_ui
.cur_vert
];
449 u16
*indices
= &vg_ui
.indice_buffer
[ vg_ui
.cur_indice
];
451 for( int i
=0; i
<4; i
++ ){
452 vertices
[i
].colour
= colour
;
455 vertices
[0].co
[0] = rect
[0];
456 vertices
[0].co
[1] = rect
[1];
457 vertices
[0].uv
[0] = uv
[0];
458 vertices
[0].uv
[1] = uv
[1];
459 vertices
[1].co
[0] = rect
[0]+rect
[2];
460 vertices
[1].co
[1] = rect
[1];
461 vertices
[1].uv
[0] = uv
[2];
462 vertices
[1].uv
[1] = uv
[1];
463 vertices
[2].co
[0] = rect
[0]+rect
[2];
464 vertices
[2].co
[1] = rect
[1]+rect
[3];
465 vertices
[2].uv
[0] = uv
[2];
466 vertices
[2].uv
[1] = uv
[3];
467 vertices
[3].co
[0] = rect
[0];
468 vertices
[3].co
[1] = rect
[1]+rect
[3];
469 vertices
[3].uv
[0] = uv
[0];
470 vertices
[3].uv
[1] = uv
[3];
471 u16 ind_start
= vg_ui
.cur_vert
;
473 u16 start
= vg_ui
.cur_vert
;
474 u32 mesh
[] = { 0,2,1, 0,3,2 };
476 for( u32 i
=0; i
<vg_list_size(mesh
); i
++ ){
477 indices
[i
] = start
+mesh
[i
];
480 vg_ui
.cur_indice
+= 6;
484 void ui_fill( ui_rect rect
, u32 colour
)
486 ui_fill_rect( rect
, colour
, (ui_px
[4]){ 4,4,4,4 } );
489 void ui_outline( ui_rect rect
, ui_px thickness
, u32 colour
, u32 mask
)
491 /* this if far from ideal but stops us from crashing */
492 if( (vg_ui
.cur_vert
+ 8 > vg_ui
.max_verts
) ||
493 (vg_ui
.cur_indice
+ 24 > vg_ui
.max_indices
))
496 struct ui_vert
*vertices
= &vg_ui
.vertex_buffer
[ vg_ui
.cur_vert
];
497 u16
*indices
= &vg_ui
.indice_buffer
[ vg_ui
.cur_indice
];
499 for( int i
=0; i
<8; i
++ ){
500 vertices
[i
].uv
[0] = 4;
501 vertices
[i
].uv
[1] = 4;
502 vertices
[i
].colour
= colour
;
505 vertices
[0].co
[0] = rect
[0];
506 vertices
[0].co
[1] = rect
[1];
507 vertices
[1].co
[0] = rect
[0]+rect
[2];
508 vertices
[1].co
[1] = rect
[1];
509 vertices
[2].co
[0] = rect
[0]+rect
[2];
510 vertices
[2].co
[1] = rect
[1]+rect
[3];
511 vertices
[3].co
[0] = rect
[0];
512 vertices
[3].co
[1] = rect
[1]+rect
[3];
513 vertices
[4].co
[0] = vertices
[0].co
[0]-thickness
;
514 vertices
[4].co
[1] = vertices
[0].co
[1]-thickness
;
515 vertices
[5].co
[0] = vertices
[1].co
[0]+thickness
;
516 vertices
[5].co
[1] = vertices
[1].co
[1]-thickness
;
517 vertices
[6].co
[0] = vertices
[2].co
[0]+thickness
;
518 vertices
[6].co
[1] = vertices
[2].co
[1]+thickness
;
519 vertices
[7].co
[0] = vertices
[3].co
[0]-thickness
;
520 vertices
[7].co
[1] = vertices
[3].co
[1]+thickness
;
522 u16 start
= vg_ui
.cur_vert
;
523 u32 mesh
[] = { 0,5,4, 0,1,5, 1,6,5, 1,2,6, 2,7,6, 2,3,7, 3,4,7, 3,0,4 };
526 mask
= UI_TOP
|UI_LEFT
|UI_BOTTOM
|UI_RIGHT
;
529 for( u32 i
=0; i
<vg_list_size(mesh
)/6; i
++ ){
530 if( (0x1<<i
) & mask
){
531 for( u32 j
=0; j
<6; j
++ )
532 indices
[c
++] = start
+mesh
[i
*6+j
];
536 vg_ui
.cur_indice
+= c
;
540 void ui_split( ui_rect rect
, enum ui_axis other
, ui_px width
, ui_px gap
,
541 ui_rect l
, ui_rect r
){
542 enum ui_axis dir
= other
^ 0x1;
544 if( width
< 0 ) width
= rect
[ 2+dir
] + width
;
547 rect_copy( rect
, temp
);
549 l
[ dir
] = temp
[ dir
];
550 r
[ dir
] = temp
[ dir
] + width
+ (gap
/2);
551 l
[ other
] = temp
[ other
];
552 r
[ other
] = temp
[ other
];
553 l
[ 2+dir
] = width
- (gap
/2);
554 r
[ 2+dir
] = temp
[ 2+dir
] - width
- (gap
/2);
555 l
[ 2+other
] = temp
[ 2+other
];
556 r
[ 2+other
] = temp
[ 2+other
];
559 void ui_rect_center( ui_rect parent
, ui_rect rect
)
561 rect
[0] = parent
[0] + (parent
[2]-rect
[2])/2;
562 rect
[1] = parent
[1] + (parent
[3]-rect
[3])/2;
565 void ui_fit_item( ui_rect rect
, ui_px size
[2], ui_rect d
)
567 i32 rp
= (i32
)rect
[2] * (i32
)size
[1],
568 rc
= (i32
)size
[0] * (i32
)rect
[3];
570 enum ui_axis dir
, other
;
571 if( rc
> rp
) dir
= k_ui_axis_h
;
572 else dir
= k_ui_axis_v
;
575 d
[2+dir
] = rect
[2+dir
];
576 d
[2+other
] = (rect
[2+dir
] * size
[other
]) / size
[dir
];
578 ui_rect_center( rect
, d
);
581 void ui_split_ratio( ui_rect rect
, enum ui_axis dir
, float ratio
,
582 ui_px gap
, ui_rect l
, ui_rect r
)
584 ui_px width
= (float)rect
[ 2+(dir
^0x1) ] * ratio
;
585 ui_split( rect
, dir
, width
, gap
, l
, r
);
588 void ui_rect_pad( ui_rect rect
, ui_px pad
[2] )
596 ui_px
ui_text_line_width( const char *str
)
599 const char *_c
= str
;
602 while( (c
= *(_c
++)) ){
603 if( c
>= 32 ) length
++;
604 else if( c
== '\n' ) break;
607 return length
* vg_ui
.font
->spacing
;
610 ui_px
ui_text_string_height( const char *str
)
613 const char *_c
= str
;
616 while( (c
= *(_c
++)) ){
617 if( c
== '\n' ) height
++;
623 ui_px
ui_text_aligned_x( const char *str
, ui_rect rect
, ui_px scale
,
624 enum ui_align align
)
626 enum ui_align lwr
= k_ui_align_lwr
& align
;
627 if( lwr
== k_ui_align_left
){
631 ui_px width
= ui_text_line_width( str
) * scale
;
633 if( lwr
== k_ui_align_right
)
634 return rect
[0] + rect
[2]-width
;
636 return rect
[0] + (rect
[2]-width
)/2;
640 static ui_px
ui_min( ui_px a
, ui_px b
){ return a
<b
?a
:b
; }
641 static ui_px
ui_max( ui_px a
, ui_px b
){ return a
>b
?a
:b
; }
642 static ui_px
ui_clamp( ui_px a
, ui_px min
, ui_px max
){
643 return ui_min( max
, ui_max( a
, min
) );
646 int ui_clip( ui_rect parent
, ui_rect child
, ui_rect clipped
)
648 ui_px parent_max
[2], child_max
[2];
649 parent_max
[0] = parent
[0]+parent
[2];
650 parent_max
[1] = parent
[1]+parent
[3];
651 child_max
[0] = child
[0]+child
[2];
652 child_max
[1] = child
[1]+child
[3];
654 clipped
[0] = ui_clamp( child
[0], parent
[0], parent_max
[0] );
655 clipped
[1] = ui_clamp( child
[1], parent
[1], parent_max
[1] );
656 clipped
[2] = ui_clamp( child_max
[0], parent
[0], parent_max
[0] );
657 clipped
[3] = ui_clamp( child_max
[1], parent
[1], parent_max
[1] );
659 if( clipped
[0] == clipped
[2] ||
660 clipped
[1] == clipped
[3] )
663 clipped
[2] -= clipped
[0];
664 clipped
[3] -= clipped
[1];
669 int ui_inside_rect( ui_rect rect
, ui_px co
[2] )
671 if( co
[0] >= rect
[0] &&
673 co
[0] < rect
[0]+rect
[2] &&
674 co
[1] < rect
[1]+rect
[3] ){
681 int ui_click_down( u32 mask
)
683 if( vg_ui
.ignore_input_frames
) return 0;
684 if( (vg_ui
.mouse_state
[0] & mask
) &&
685 !(vg_ui
.mouse_state
[1] & mask
) )
691 int ui_clicking( u32 mask
)
693 if( vg_ui
.ignore_input_frames
) return 0;
694 return vg_ui
.mouse_state
[0] & mask
;
697 int ui_click_up( u32 mask
)
699 if( vg_ui
.ignore_input_frames
) return 0;
700 if( (vg_ui
.mouse_state
[1] & mask
) &&
701 !(vg_ui
.mouse_state
[0] & mask
) )
707 void ui_set_mouse_pos( ui_px x
, ui_px y
)
709 SDL_WarpMouseInWindow( vg
.window
, x
, y
);
712 vg_ui
.mouse_pos_overriden
= 1;
715 void ui_prerender(void)
718 vg_ui
.mouse_state
[1] = vg_ui
.mouse_state
[0];
719 vg_ui
.mouse_state
[0] = SDL_GetMouseState( &x
, &y
);
720 vg_ui
.mouse_delta
[0] = x
-vg_ui
.mouse
[0];
721 vg_ui
.mouse_delta
[1] = y
-vg_ui
.mouse
[1];
723 if( !vg_ui
.mouse_pos_overriden
)
730 vg_ui
.cur_indice
= 0;
731 vg_ui
.vert_start
= 0;
732 vg_ui
.indice_start
= 0;
733 vg_ui
.focused_control_hit
= 0;
734 vg_ui
.cursor
= k_ui_cursor_default
;
735 vg_ui
.wants_mouse
= 0;
736 vg_ui
.mouse_pos_overriden
= 0;
738 if( vg_ui
.ignore_input_frames
)
740 vg_ui
.ignore_input_frames
--;
744 if( ui_click_down(UI_MOUSE_LEFT
)||ui_click_down(UI_MOUSE_MIDDLE
) )
746 vg_ui
.mouse_click
[0] = vg_ui
.mouse
[0];
747 vg_ui
.mouse_click
[1] = vg_ui
.mouse
[1];
751 u32
ui_colour( enum ui_scheme_colour id
)
753 return vg_ui
.scheme
[ id
];
756 /* get an appropriately contrasting colour given the base */
757 u32
ui_colourcont( enum ui_scheme_colour id
)
759 if ( id
< k_ui_bg
+6 ) return ui_colour( k_ui_fg
);
760 else if( id
< k_ui_fg
) return ui_colour( k_ui_bg
+1 );
761 else if( id
< k_ui_hue
) return ui_colour( k_ui_bg
+3 );
762 else if( id
< k_ui_red
+k_ui_brighter
) return ui_colour( k_ui_fg
);
763 else return ui_colour( k_ui_fg
+1 );
766 void ui_hex_to_norm( u32 hex
, v4f norm
)
768 norm
[0] = ((hex
) & 0xff);
769 norm
[1] = ((hex
>>8 ) & 0xff);
770 norm
[2] = ((hex
>>16) & 0xff);
771 norm
[3] = ((hex
>>24) & 0xff);
772 v4_muls( norm
, 1.0f
/255.0f
, norm
);
775 u32
v4f_u32_colour( v4f colour
)
777 u32 r
= colour
[0] * 255.0f
,
778 g
= colour
[1] * 255.0f
,
779 b
= colour
[2] * 255.0f
,
780 a
= colour
[3] * 255.0f
;
782 return r
| (g
<<8) | (b
<<16) | (a
<<24);
785 static void ui_text_glyph( const struct ui_font
*font
, ui_px scale
,
786 u8 glyph
, ui_rect out_texcoords
){
787 glyph
-= font
->ascii_start
;
789 ui_px per_row
= font
->sheet_size
/ font
->glyph_width
,
790 column
= (ui_px
)glyph
% per_row
,
791 row
= (glyph
- column
) / per_row
;
793 out_texcoords
[0] = column
* font
->glyph_width
;
794 out_texcoords
[1] = row
* font
->glyph_height
+ font
->offset_y
;
795 out_texcoords
[2] = out_texcoords
[0] + font
->glyph_width
;
796 out_texcoords
[3] = out_texcoords
[1] + font
->glyph_height
;
799 u32
ui_opacity( u32 colour
, f32 opacity
)
801 u32 alpha
= opacity
* 255.0f
;
802 return (colour
& 0x00ffffff) | (alpha
<< 24);
805 u32
ui_ntext( ui_rect rect
, const char *str
, u32 len
, ui_px scale
,
806 enum ui_align align
, u32 colour
)
809 if( colour
== 0 ) colour
= ui_colour( k_ui_fg
);
811 colour
&= 0x00ffffff;
813 const char *_c
= str
;
816 text_cursor
[0] = ui_text_aligned_x( str
, rect
, scale
, align
);
817 text_cursor
[1] = rect
[1];
818 text_cursor
[2] = vg_ui
.font
->glyph_width
*scale
;
819 text_cursor
[3] = vg_ui
.font
->glyph_height
*scale
;
821 u32 printed_chars
= 0;
823 if( align
& (k_ui_align_middle
|k_ui_align_bottom
) ){
824 ui_px height
= ui_text_string_height( str
) * scale
;
826 if( align
& k_ui_align_bottom
)
827 text_cursor
[1] += rect
[3]-height
;
829 text_cursor
[1] += (rect
[3]-height
)/2;
832 while( (c
= *(_c
++)) ){
833 if( printed_chars
>= len
){
835 text_cursor
[1] += vg_ui
.font
->line_height
*scale
;
836 text_cursor
[0] = ui_text_aligned_x( _c
, rect
, scale
, align
);
837 text_cursor
[0] -= vg_ui
.font
->spacing
*scale
;
840 ui_text_glyph( vg_ui
.font
, scale
, '\xb6' /*FIXME*/, glyph
);
841 ui_fill_rect( text_cursor
, 0x00ffffff, glyph
);
842 text_cursor
[0] += vg_ui
.font
->spacing
*scale
;
846 text_cursor
[1] += vg_ui
.font
->line_height
*scale
;
847 text_cursor
[0] = ui_text_aligned_x( _c
, rect
, scale
, align
);
853 ui_text_glyph( vg_ui
.font
, scale
, c
, glyph
);
855 ui_rect cursor_clipped
;
856 if( ui_clip( rect
, text_cursor
, cursor_clipped
) ){
857 ui_fill_rect( cursor_clipped
, colour
, glyph
);
860 else if( c
== '\x1B' ){
864 for( int i
=0; i
<3; i
++ ){
870 case '0': colour
= ui_colour( k_ui_fg
); break;
871 case '3'|'0'<<8: colour
= ui_colour( k_ui_bg
); break;
872 case '3'|'1'<<8: colour
= ui_colour( k_ui_red
); break;
873 case '3'|'2'<<8: colour
= ui_colour( k_ui_green
); break;
874 case '3'|'3'<<8: colour
= ui_colour( k_ui_yellow
); break;
875 case '3'|'4'<<8: colour
= ui_colour( k_ui_blue
); break;
876 case '3'|'5'<<8: colour
= ui_colour( k_ui_purple
); break;
877 case '3'|'6'<<8: colour
= ui_colour( k_ui_aqua
); break;
878 case '3'|'7'<<8: colour
= 0xffffffff; break;
881 colour
&= 0x00ffffff;
885 colour_id
|= _c
[i
] << (i
*8);
895 else if( c
== '\t' ){
896 text_cursor
[0] += vg_ui
.font
->spacing
*scale
*4;
901 text_cursor
[0] += vg_ui
.font
->spacing
*scale
;
905 return printed_chars
;
908 void ui_text( ui_rect rect
, const char *str
, ui_px scale
,
909 enum ui_align align
, u32 colour
)
911 ui_ntext( rect
, str
, 1024, scale
, align
, colour
);
915 * Standard layout stuff
916 * -----------------------------------------------------------------------------
919 void ui_panel( ui_rect in_rect
, ui_rect out_panel
)
921 ui_fill( in_rect
, ui_colour( k_ui_bg
+1 ) );
922 ui_outline( in_rect
, 1, ui_colour( k_ui_bg
+7 ), 0 );
923 rect_copy( in_rect
, out_panel
);
924 ui_rect_pad( out_panel
, (ui_px
[2]){ k_ui_padding
, k_ui_padding
} );
927 void ui_label( ui_rect rect
, const char *text
, ui_px size
,
928 ui_px gap
, ui_rect r
)
931 ui_px width
= (ui_text_line_width(text
)+vg_ui
.font
->spacing
) * size
;
932 ui_split( rect
, k_ui_axis_v
, width
, gap
, l
, r
);
933 ui_text( l
, text
, 1, k_ui_align_middle_left
, 0 );
936 void ui_standard_widget( ui_rect inout_panel
, ui_rect out_rect
, ui_px count
)
938 ui_px height
= (count
* vg_ui
.font
->glyph_height
+ 18) * k_ui_scale
;
939 ui_split( inout_panel
, k_ui_axis_h
, height
, k_ui_padding
,
940 out_rect
, inout_panel
);
943 void ui_info( ui_rect inout_panel
, const char *text
)
946 ui_standard_widget( inout_panel
, box
, 1 );
947 ui_text( box
, text
, 1, k_ui_align_middle_left
, 0 );
950 void ui_image( ui_rect rect
, GLuint image
)
952 ui_flush( k_ui_shader_colour
, vg
.window_x
, vg
.window_y
);
953 glActiveTexture( GL_TEXTURE0
);
954 glBindTexture( GL_TEXTURE_2D
, image
);
955 ui_fill_rect( rect
, 0xffffffff, (ui_px
[4]){ 0,256,256,0 } );
956 ui_flush( k_ui_shader_image
, vg
.window_x
, vg
.window_y
);
959 void ui_defocus_all(void)
961 if( vg_ui
.focused_control_type
== k_ui_control_textbox
){
963 if( vg_ui
.textbox
.callbacks
.escape
)
964 vg_ui
.textbox
.callbacks
.escape();
967 vg_ui
.focused_control_id
= NULL
;
968 vg_ui
.focused_control_hit
= 0;
969 vg_ui
.focused_control_type
= k_ui_control_none
;
972 /* TODO: split this out into a formatless button and one that auto fills */
973 enum ui_button_state
ui_colourbutton( ui_rect rect
,
974 enum ui_scheme_colour colour
,
975 enum ui_scheme_colour hover_colour
,
976 enum ui_scheme_colour hi_colour
,
979 int clickup
= ui_click_up(UI_MOUSE_LEFT
),
980 click
= ui_clicking(UI_MOUSE_LEFT
) | clickup
,
981 target
= ui_inside_rect( rect
, vg_ui
.mouse_click
) && click
,
982 hover
= ui_inside_rect( rect
, vg_ui
.mouse
);
984 u32 col_base
= vg_ui
.scheme
[ colour
],
985 col_highlight
= vg_ui
.scheme
[ hi_colour
? hi_colour
: k_ui_fg
],
986 col_hover
= vg_ui
.scheme
[ hover_colour
? hover_colour
:
987 colour
+ k_ui_brighter
];
989 if( vg_ui
.focused_control_type
!= k_ui_control_none
){
997 vg_ui
.cursor
= k_ui_cursor_hand
;
1004 vg_ui
.ignore_input_frames
= 2;
1008 ui_fill( rect
, col_highlight
);
1009 rect_copy( rect
, vg_ui
.click_fader
);
1010 rect_copy( rect
, vg_ui
.click_fader_end
);
1011 vg_ui
.click_fader_end
[3] = 0;
1012 ui_rect_center( rect
, vg_ui
.click_fader_end
);
1013 vg_ui
.click_fade_opacity
= 1.0f
;
1016 return k_ui_button_click
;
1019 if( fill
) ui_fill( rect
, col_highlight
);
1020 return k_ui_button_holding_inside
;
1024 if( fill
) ui_fill( rect
, col_base
);
1025 ui_outline( rect
, 1, col_highlight
, 0 );
1026 return k_ui_button_holding_outside
;
1030 if( fill
) ui_fill( rect
, col_base
);
1031 return k_ui_button_none
;
1036 if( fill
) ui_fill( rect
, col_hover
);
1037 return k_ui_button_hover
;
1040 if( fill
) ui_fill( rect
, col_base
);
1041 return k_ui_button_none
;
1046 enum ui_button_state
ui_colourbutton_text(
1047 ui_rect rect
, const char *string
, ui_px scale
,
1048 enum ui_scheme_colour colour
){
1049 enum ui_button_state state
= ui_colourbutton( rect
, colour
, 0, 0, 1 );
1050 ui_rect t
= { 0,0, ui_text_line_width( string
)*scale
, 14*scale
};
1051 ui_rect_center( rect
, t
);
1053 u32 text_colour
= ui_colourcont(colour
);
1054 if( state
== k_ui_button_holding_inside
)
1055 text_colour
= colour
;
1057 ui_text( t
, string
, scale
, k_ui_align_left
, text_colour
);
1061 enum ui_button_state
ui_button_text( ui_rect rect
,
1062 const char *string
, ui_px scale
)
1064 return ui_colourbutton_text( rect
, string
, scale
, k_ui_bg
+4 );
1067 enum ui_button_state
ui_button( ui_rect inout_panel
, const char *string
)
1070 ui_standard_widget( inout_panel
, rect
, 1 );
1071 return ui_colourbutton_text( rect
, string
, 1, k_ui_bg
+4 );
1074 static void ui_enum_post(void);
1075 void ui_postrender(void)
1077 if( vg_ui
.click_fade_opacity
> 0.0f
){
1078 float scale
= vg_ui
.click_fade_opacity
;
1079 scale
= vg_maxf( 1.0f
/255.0f
, scale
*scale
);
1081 vg_ui
.click_fade_opacity
-= vg
.time_frame_delta
* 3.8f
;
1082 u32 colour
= (0x00ffffff & ui_colour(k_ui_fg
))|0x7f000000;
1084 v4f begin
, end
, dest
;
1085 for( int i
=0; i
<4; i
++ ){
1086 begin
[i
] = vg_ui
.click_fader
[i
];
1087 end
[i
] = vg_ui
.click_fader_end
[i
]+1;
1090 v4_lerp( end
, begin
, scale
, dest
);
1093 for( int i
=0; i
<4; i
++ ){
1097 ui_fill( rect
, colour
);
1100 if( vg_ui
.focused_control_type
== k_ui_control_enum
){
1103 else if( vg_ui
.focused_control_type
== k_ui_control_modal
){
1104 ui_rect screen
= {0,0,vg
.window_x
,vg
.window_y
};
1105 ui_fill( screen
, 0xa0000000 );
1106 ui_rect box
= {0,0,400,200};
1108 u32 colour
= ui_colour(k_ui_fg
),
1109 type
= vg_ui
.modal
.options
& UI_MODAL_TYPE_BITS
;
1110 if ( type
== 1 ) colour
= ui_colour(k_ui_green
);
1111 else if( type
== 2 ) colour
= ui_colour(k_ui_red
);
1112 else if( type
== 3 ) colour
= ui_colour(k_ui_yellow
);
1114 ui_rect_center( screen
, box
);
1115 ui_fill( box
, ui_colour(k_ui_bg
) );
1116 ui_outline( box
, -1, colour
, 0 );
1119 rect_copy( box
, message
);
1121 ui_rect_center( box
, message
);
1123 ui_rect row0
, row1
, btn
;
1124 ui_split_ratio( message
, k_ui_axis_h
, 0.5f
, 0, row0
, row1
);
1125 row0
[0] += vg_ui
.font
->spacing
;
1126 ui_ntext( row0
, vg_ui
.modal
.message
, (box
[2]/vg_ui
.font
->spacing
)-2, 1,
1127 k_ui_align_left
, colour
);
1129 rect_copy( row1
, btn
);
1132 ui_rect_center( row1
, btn
);
1134 vg_ui
.focused_control_type
= k_ui_control_none
; /* HACK */
1135 if( ui_button_text( btn
, "OK", 1 ) != 1 )
1136 vg_ui
.focused_control_hit
= 1;
1137 vg_ui
.focused_control_type
= k_ui_control_modal
; /* HACK */
1138 vg_ui
.wants_mouse
= 1;
1141 ui_flush( k_ui_shader_colour
, vg
.window_x
, vg
.window_y
);
1143 if( !vg_ui
.focused_control_hit
){
1147 if( vg_ui
.wants_mouse
){
1148 SDL_SetWindowGrab( vg
.window
, SDL_FALSE
);
1149 SDL_SetRelativeMouseMode( SDL_FALSE
);
1152 SDL_SetWindowGrab( vg
.window
, SDL_TRUE
);
1153 SDL_SetRelativeMouseMode( SDL_TRUE
);
1156 SDL_SetCursor( vg_ui
.cursor_map
[ vg_ui
.cursor
] );
1162 * -----------------------------------------------------------------------------
1165 int ui_checkbox( ui_rect inout_panel
, const char *str_label
, i32
*data
)
1167 ui_rect rect
, label
, box
;
1168 ui_standard_widget( inout_panel
, rect
, 1 );
1170 ui_split( rect
, k_ui_axis_v
, -rect
[3], 0, label
, box
);
1171 ui_text( label
, str_label
, k_ui_scale
, k_ui_align_middle_left
, 0 );
1173 int changed
= ui_colourbutton( box
, k_ui_bg
, 0, 0, 1 )==1;
1175 *data
= (*data
) ^ 0x1;
1178 ui_rect_pad( box
, (ui_px
[2]){4,4} );
1179 ui_fill( box
, ui_colour( k_ui_orange
) );
1187 * -----------------------------------------------------------------------------
1191 * unfortunately no return value since we only find out that event in the
1194 void ui_enum( ui_rect inout_panel
, const char *str_label
,
1195 struct ui_enum_opt
*options
, u32 len
, i32
*value
)
1197 ui_rect rect
, label
, box
;
1198 ui_standard_widget( inout_panel
, rect
, 1 );
1199 ui_label( rect
, str_label
, k_ui_scale
, 0, box
);
1201 const char *display
= "OUT OF RANGE";
1203 for( u32 i
=0; i
<len
; i
++ ){
1204 if( *value
== options
[i
].value
){
1205 display
= options
[i
].alias
;
1211 if( ui_button_text( box
, display
, k_ui_scale
) == 1 ){
1212 vg_ui
.focused_control_type
= k_ui_control_enum
;
1213 vg_ui
.ptr_enum
= value
;
1214 vg_ui
._enum
.option_count
= len
;
1215 vg_ui
._enum
.options
= options
;
1216 rect_copy( box
, vg_ui
._enum
.rect
);
1220 ui_outline( box
, 1, ui_colour(k_ui_red
), 0 );
1223 static void ui_enum_post(void){
1225 rect_copy( vg_ui
._enum
.rect
, drawer
);
1226 drawer
[3] *= vg_ui
._enum
.option_count
;
1229 int clickany
= ui_click_up(UI_MOUSE_LEFT
|UI_MOUSE_RIGHT
|UI_MOUSE_MIDDLE
),
1230 hover
= ui_inside_rect( drawer
, vg_ui
.mouse
);
1232 if( clickany
&& !hover
){
1237 vg_ui
.focused_control_type
= k_ui_control_none
;
1238 i32
*value
= vg_ui
.ptr_enum
;
1240 for( u32 i
=0; i
<vg_ui
._enum
.option_count
; i
++ ){
1242 ui_split( drawer
, k_ui_axis_h
, vg_ui
._enum
.rect
[3], 0, button
,drawer
);
1244 enum ui_scheme_colour colour
= k_ui_bg
+3;
1245 if( vg_ui
._enum
.options
[i
].value
== *value
)
1246 colour
= k_ui_orange
;
1248 if( ui_colourbutton_text( button
, vg_ui
._enum
.options
[i
].alias
,
1249 k_ui_scale
, colour
) == 1 ){
1250 *value
= vg_ui
._enum
.options
[i
].value
;
1256 vg_ui
.focused_control_type
= k_ui_control_enum
;
1259 vg_ui
.focused_control_hit
= 1;
1264 * -----------------------------------------------------------------------------
1267 static enum ui_button_state
_ui_slider(
1268 ui_rect box
, f32 min
, f32 max
, f32
*value
, const char *format
)
1272 enum ui_button_state
1274 k_ui_button_holding_inside
|
1275 k_ui_button_holding_outside
|
1278 mask_using
| k_ui_button_hover
,
1279 state
= ui_colourbutton( box
, k_ui_bg
, k_ui_bg
+2, k_ui_bg
+3, 1 );
1281 if( state
& mask_using
){
1282 t
= vg_clampf( (f32
)(vg_ui
.mouse
[0] - box
[0]) / (f32
)( box
[2] ),
1284 *value
= vg_lerpf( min
, max
, t
);
1287 t
= vg_clampf( (*value
- min
) / (max
-min
), 0.0f
, 1.0f
);
1289 ui_rect line
= { box
[0], box
[1], t
* (f32
)box
[2], box
[3] };
1290 ui_fill( line
, ui_colour(state
&mask_brighter
? k_ui_bg
+4: k_ui_bg
+2) );
1292 ui_outline( box
, 1, ui_colour(state
? k_ui_fg
+3: k_ui_bg
+3), 0 );
1294 /* TODO: replace this one day with our own function */
1296 snprintf( buf
, sizeof(buf
), format
? format
: "%.2f", *value
);
1297 ui_text( box
, buf
, 1, k_ui_align_middle_center
, 0 );
1302 bool ui_slider( ui_rect inout_panel
, const char *str_label
,
1303 f32 min
, f32 max
, f32
*value
, const char *format
)
1305 ui_rect rect
, label
, box
;
1306 ui_standard_widget( inout_panel
, rect
, 1 );
1307 ui_label( rect
, str_label
, k_ui_scale
, 0, box
);
1309 enum ui_button_state mask_using
=
1310 k_ui_button_holding_inside
|
1311 k_ui_button_holding_outside
|
1314 if( _ui_slider( box
, min
, max
, value
, format
) & mask_using
)
1322 * -----------------------------------------------------------------------------
1325 void ui_colourpicker( ui_rect inout_panel
, const char *str_label
, v4f value
)
1327 ui_rect widget
, left
, right
;
1328 ui_standard_widget( inout_panel
, widget
, 8 );
1329 ui_split_ratio( widget
, k_ui_axis_v
, 0.5f
, 8, left
, right
);
1332 ui_split_ratio( right
, k_ui_axis_h
, 0.5f
, 2, sliders
[0], sliders
[2] );
1333 ui_split_ratio( sliders
[0], k_ui_axis_h
, 0.5f
, 2, sliders
[0], sliders
[1] );
1334 ui_split_ratio( sliders
[2], k_ui_axis_h
, 0.5f
, 2, sliders
[2], sliders
[3] );
1337 vg_rgb_hsv( value
, hsv
);
1340 enum ui_button_state modified
= 0x00;
1342 for( u32 i
=0; i
<4; i
++ ){
1343 modified
|= _ui_slider( sliders
[i
], 0.0f
, 1.0f
, hsv
+i
,
1344 (const char *[]){ "hue %.2f",
1347 "alpha %.2f" }[i
] );
1350 ui_rect preview
, square
;
1351 ui_split_ratio( left
, k_ui_axis_v
, 0.8f
, 8, square
, preview
);
1353 u32 state
= ui_colourbutton( square
, 0, 0, 0, 0 );
1356 enum ui_button_state
1358 k_ui_button_holding_inside
|
1359 k_ui_button_holding_outside
|
1362 if( state
& mask_using
){
1363 for( u32 i
=0; i
<2; i
++ ){
1364 hsv
[1+i
] = vg_clampf(
1365 (f32
)(vg_ui
.mouse
[i
] - square
[i
]) / (f32
)(square
[2+i
]),
1369 hsv
[2] = 1.0f
-hsv
[2];
1372 if( modified
& (k_ui_button_click
|k_ui_button_holding_inside
|
1373 k_ui_button_holding_outside
) ){
1374 vg_hsv_rgb( hsv
, value
);
1378 ui_outline( square
, 1, ui_colour( state
? k_ui_fg
+3: k_ui_bg
+3 ), 0 );
1380 /* preview colour */
1382 vg_hsv_rgb( hsv
, colour
);
1384 ui_fill( preview
, v4f_u32_colour( colour
) );
1386 /* Draw hsv shader thingy */
1387 ui_flush( k_ui_shader_colour
, vg
.window_x
, vg
.window_y
);
1388 ui_fill_rect( square
, 0xffffffff, (ui_px
[4]){ 0,256,256,0 } );
1390 ui_flush( k_ui_shader_hsv
, vg
.window_x
, vg
.window_y
);
1392 ui_rect marker
= { square
[0] + hsv
[1] * (f32
)square
[2] - 4,
1393 square
[1] + (1.0f
-hsv
[2]) * (f32
)square
[3] - 4,
1396 square
[1] + (1.0f
-hsv
[2]) * (f32
)square
[3],
1398 ly
= { square
[0] + hsv
[1] * (f32
)square
[2],
1402 ui_fill( marker
, ui_colour( k_ui_fg
) );
1403 ui_fill( lx
, ui_colour( k_ui_fg
) );
1404 ui_fill( ly
, ui_colour( k_ui_fg
) );
1409 * -----------------------------------------------------------------------------
1412 static void _ui_textbox_make_selection( int *start
, int *end
){
1413 *start
= VG_MIN( vg_ui
.textbox
.cursor_pos
, vg_ui
.textbox
.cursor_user
);
1414 *end
= VG_MAX( vg_ui
.textbox
.cursor_pos
, vg_ui
.textbox
.cursor_user
);
1417 void _ui_textbox_move_cursor( int *cursor0
, int *cursor1
,
1418 int dir
, int snap_together
)
1420 *cursor0
= VG_MAX( 0, vg_ui
.textbox
.cursor_user
+ dir
);
1423 VG_MIN( vg_ui
.textbox
.len
-1, strlen( vg_ui
.textbuf
)),
1427 *cursor1
= *cursor0
;
1430 static int _ui_textbox_makeroom( int datastart
, int length
){
1431 int move_to
= VG_MIN( datastart
+length
, vg_ui
.textbox
.len
-1 );
1432 int move_amount
= strlen( vg_ui
.textbuf
)-datastart
;
1433 int move_end
= VG_MIN( move_to
+move_amount
, vg_ui
.textbox
.len
-1 );
1434 move_amount
= move_end
-move_to
;
1437 memmove( &vg_ui
.textbuf
[ move_to
],
1438 &vg_ui
.textbuf
[ datastart
],
1441 vg_ui
.textbuf
[ move_end
] = '\0';
1443 return VG_MIN( length
, vg_ui
.textbox
.len
-datastart
-1 );
1446 int _ui_textbox_delete_char( int direction
)
1449 _ui_textbox_make_selection( &start
, &end
);
1451 /* There is no selection */
1453 if( direction
== 1 ) end
= VG_MIN( end
+1, strlen( vg_ui
.textbuf
) );
1454 else if( direction
== -1 ) start
= VG_MAX( start
-1, 0 );
1457 /* Still no selction, no need to do anything */
1461 /* Copy the end->terminator to start */
1462 int remaining_length
= strlen( vg_ui
.textbuf
)+1-end
;
1463 memmove( &vg_ui
.textbuf
[ start
],
1464 &vg_ui
.textbuf
[ end
],
1469 static void _ui_textbox_to_clipboard(void){
1471 _ui_textbox_make_selection( &start
, &end
);
1475 memcpy( buffer
, &vg_ui
.textbuf
[ start
], end
-start
);
1476 buffer
[ end
-start
] = 0x00;
1477 SDL_SetClipboardText( buffer
);
1481 static void _ui_textbox_change_callback(void){
1482 if( vg_ui
.textbox
.callbacks
.change
){
1483 vg_ui
.textbox
.callbacks
.change( vg_ui
.textbuf
, vg_ui
.textbox
.len
);
1485 /* we gave permission to modify the buffer in this callback so.. */
1486 int len
= strlen( vg_ui
.textbuf
);
1487 vg_ui
.textbox
.cursor_user
= VG_MIN( vg_ui
.textbox
.cursor_user
, len
);
1488 vg_ui
.textbox
.cursor_pos
= VG_MIN( vg_ui
.textbox
.cursor_pos
, len
);
1492 void ui_start_modal( const char *message
, u32 options
);
1493 static void _ui_textbox_clipboard_paste(void){
1494 if( !SDL_HasClipboardText() )
1497 char *text
= SDL_GetClipboardText();
1502 int datastart
= _ui_textbox_delete_char( 0 );
1503 int length
= strlen( text
);
1505 if( (vg_ui
.textbox
.len
- strlen(vg_ui
.textbuf
)) < length
){
1506 ui_start_modal( "Clipboard content exceeds buffer size.", UI_MODAL_BAD
);
1510 int cpylength
= _ui_textbox_makeroom( datastart
, length
);
1512 memcpy( vg_ui
.textbuf
+ datastart
, text
, cpylength
);
1513 _ui_textbox_move_cursor( &vg_ui
.textbox
.cursor_user
,
1514 &vg_ui
.textbox
.cursor_pos
, cpylength
, 1 );
1516 _ui_textbox_change_callback();
1519 void _ui_textbox_put_char( char c
)
1521 vg_ui
.textbox
.cursor_user
= _ui_textbox_delete_char(0);
1522 if( (vg_ui
.textbox
.len
- strlen(vg_ui
.textbuf
)) <= 1 ) return;
1524 if( _ui_textbox_makeroom( vg_ui
.textbox
.cursor_user
, 1 ) )
1525 vg_ui
.textbuf
[ vg_ui
.textbox
.cursor_user
] = c
;
1527 _ui_textbox_move_cursor( &vg_ui
.textbox
.cursor_user
,
1528 &vg_ui
.textbox
.cursor_pos
, 1, 1 );
1531 /* Receed secondary cursor */
1532 void _ui_textbox_left_select(void)
1534 _ui_textbox_move_cursor( &vg_ui
.textbox
.cursor_user
, NULL
, -1, 0 );
1537 /* Match and receed both cursors */
1538 void _ui_textbox_left(void)
1540 int cursor_diff
= vg_ui
.textbox
.cursor_pos
- vg_ui
.textbox
.cursor_user
? 0: 1;
1542 _ui_textbox_move_cursor( &vg_ui
.textbox
.cursor_user
,
1543 &vg_ui
.textbox
.cursor_pos
, -cursor_diff
, 1 );
1546 void _ui_textbox_up(void)
1548 if( vg_ui
.textbox
.flags
& UI_TEXTBOX_MULTILINE
){
1549 int line_begin
= vg_ui
.textbox
.cursor_user
;
1551 while( line_begin
){
1552 if( vg_ui
.textbuf
[ line_begin
-1 ] == '\n' ){
1560 int line_above_begin
= line_begin
-1;
1562 while( line_above_begin
){
1563 if( vg_ui
.textbuf
[ line_above_begin
-1 ] == '\n' ){
1567 line_above_begin
--;
1570 int offset
= vg_ui
.textbox
.cursor_user
- line_begin
,
1571 line_length_above
= line_begin
- line_above_begin
-1;
1573 offset
= VG_MIN( line_length_above
, offset
);
1575 vg_ui
.textbox
.cursor_user
= line_above_begin
+offset
;
1576 vg_ui
.textbox
.cursor_pos
= line_above_begin
+offset
;
1579 vg_ui
.textbox
.cursor_user
= line_begin
;
1580 vg_ui
.textbox
.cursor_pos
= line_begin
;
1584 if( vg_ui
.textbox
.callbacks
.up
){
1585 vg_ui
.textbox
.callbacks
.up( vg_ui
.textbuf
, vg_ui
.textbox
.len
);
1590 void _ui_textbox_down(void)
1592 if( vg_ui
.textbox
.flags
& UI_TEXTBOX_MULTILINE
){
1593 int line_begin
= vg_ui
.textbox
.cursor_user
;
1595 while( line_begin
){
1596 if( vg_ui
.textbuf
[ line_begin
-1 ] == '\n' ){
1603 int line_below_begin
= vg_ui
.textbox
.cursor_user
;
1606 if( vg_ui
.textbuf
[ line_below_begin
] == '\0' ){
1607 vg_ui
.textbox
.cursor_user
= line_below_begin
;
1608 vg_ui
.textbox
.cursor_pos
= line_below_begin
;
1612 if( vg_ui
.textbuf
[ line_below_begin
] == '\n' ){
1613 line_below_begin
++;
1617 line_below_begin
++;
1620 int line_below_end
= line_below_begin
;
1622 if( vg_ui
.textbuf
[ line_below_end
] == '\0' ||
1623 vg_ui
.textbuf
[ line_below_end
] == '\n' ){
1630 int offset
= vg_ui
.textbox
.cursor_user
- line_begin
,
1631 line_length_below
= line_below_end
- line_below_begin
-1;
1633 offset
= VG_MIN( line_length_below
, offset
);
1635 vg_ui
.textbox
.cursor_user
= line_below_begin
+offset
;
1636 vg_ui
.textbox
.cursor_pos
= line_below_begin
+offset
;
1639 if( vg_ui
.textbox
.callbacks
.down
){
1640 vg_ui
.textbox
.callbacks
.down( vg_ui
.textbuf
, vg_ui
.textbox
.len
);
1645 void _ui_textbox_right_select(void)
1647 _ui_textbox_move_cursor( &vg_ui
.textbox
.cursor_user
, NULL
, 1, 0 );
1650 void _ui_textbox_right(void)
1652 int cursor_diff
= vg_ui
.textbox
.cursor_pos
- vg_ui
.textbox
.cursor_user
? 0: 1;
1654 _ui_textbox_move_cursor( &vg_ui
.textbox
.cursor_user
,
1655 &vg_ui
.textbox
.cursor_pos
, +cursor_diff
, 1 );
1658 void _ui_textbox_backspace(void)
1660 if( vg_ui
.focused_control_type
== k_ui_control_textbox
){
1661 vg_ui
.textbox
.cursor_user
= _ui_textbox_delete_char( -1 );
1662 vg_ui
.textbox
.cursor_pos
= vg_ui
.textbox
.cursor_user
;
1663 _ui_textbox_change_callback();
1667 void _ui_textbox_delete(void)
1669 if( vg_ui
.focused_control_type
== k_ui_control_textbox
){
1670 vg_ui
.textbox
.cursor_user
= _ui_textbox_delete_char( 1 );
1671 vg_ui
.textbox
.cursor_pos
= vg_ui
.textbox
.cursor_user
;
1672 _ui_textbox_change_callback();
1676 void _ui_textbox_home_select(void)
1678 i32 start
= vg_ui
.textbox
.cursor_user
;
1680 if( vg_ui
.textbox
.flags
& UI_TEXTBOX_MULTILINE
){
1682 if( vg_ui
.textbuf
[start
-1] == '\n' )
1691 vg_ui
.textbox
.cursor_user
= start
;
1694 void _ui_textbox_home(void)
1696 _ui_textbox_home_select();
1697 vg_ui
.textbox
.cursor_pos
= vg_ui
.textbox
.cursor_user
;
1700 void _ui_textbox_end_select(void)
1702 i32 end
= vg_ui
.textbox
.cursor_user
;
1704 if( vg_ui
.textbox
.flags
& UI_TEXTBOX_MULTILINE
){
1705 while( vg_ui
.textbuf
[end
] ){
1706 if( vg_ui
.textbuf
[end
] == '\n' )
1713 end
= VG_MIN( vg_ui
.textbox
.len
-1, strlen(vg_ui
.textbuf
) );
1715 vg_ui
.textbox
.cursor_user
= end
;
1718 void _ui_textbox_end(void)
1720 _ui_textbox_end_select();
1721 vg_ui
.textbox
.cursor_pos
= vg_ui
.textbox
.cursor_user
;
1724 void _ui_textbox_select_all(void)
1726 _ui_textbox_move_cursor( &vg_ui
.textbox
.cursor_user
, NULL
, 10000, 0);
1727 _ui_textbox_move_cursor( &vg_ui
.textbox
.cursor_pos
, NULL
, -10000, 0);
1730 void _ui_textbox_cut(void)
1732 _ui_textbox_to_clipboard();
1733 vg_ui
.textbox
.cursor_user
= _ui_textbox_delete_char(0);
1734 vg_ui
.textbox
.cursor_pos
= vg_ui
.textbox
.cursor_user
;
1735 _ui_textbox_change_callback();
1738 void _ui_textbox_enter(void)
1740 if( vg_ui
.focused_control_type
== k_ui_control_textbox
){
1741 vg_ui
.ignore_input_frames
= 2;
1743 if( vg_ui
.textbox
.callbacks
.enter
)
1744 vg_ui
.textbox
.callbacks
.enter( vg_ui
.textbuf
, vg_ui
.textbox
.len
);
1746 if( vg_ui
.focused_control_type
!= k_ui_control_textbox
) return;
1748 if( vg_ui
.textbox
.flags
& UI_TEXTBOX_MULTILINE
){
1749 _ui_textbox_put_char( '\n' );
1750 _ui_textbox_change_callback();
1753 if( !(vg_ui
.textbox
.flags
& UI_TEXTBOX_AUTOFOCUS
) )
1760 * based on a visual character coordinate relative to the anchor of the textbox,
1761 * this works out the linear place in the buffer that coordinate maps to
1763 * input coordinates go in co[0], co[1], and the result index is in co[2]
1765 static void _ui_textbox_calc_index_from_grid( int co
[3], int wrap_length
){
1769 while( (c
= vg_ui
.textbuf
[i
[2]]) ){
1770 if( i
[1]==co
[1] && i
[0]>=co
[0] ) break;
1772 if( i
[0] >= wrap_length
){
1777 if( c
>= 32 && c
<= 126 ){
1781 else if( c
== '\n' ){
1784 if( i
[1] > co
[1] ) break;
1798 * based on the index specied in co[2], work out the visual character
1799 * coordinates and store them in co[0], co[1]
1801 static void _ui_textbox_index_calc_coords( int co
[3], int wrap_length
){
1808 while( (c
= vg_ui
.textbuf
[i
++]) ){
1809 if( i
> co
[2] ) break;
1810 if( co
[0] >= wrap_length
){
1814 if( c
>= 32 && c
<= 126 ) co
[0] ++;
1815 else if( c
== '\n' ){
1823 * calculate the number of characters remaining until either:
1824 * - the wrap_length limit is hit
1825 * - end of the line/string
1827 * index must be fully populated with visual X/Y, and linear index
1829 static int _ui_textbox_run_remaining( int index
[3], int wrap_length
){
1830 int i
=0, printed_chars
=0;
1832 while( (c
= vg_ui
.textbuf
[index
[2] + (i
++)]) ){
1833 if( index
[0]+i
>= wrap_length
) break;
1834 if( c
>= 32 && c
<= 126 ) printed_chars
++;
1835 else if( c
== '\n' ) break;
1838 return printed_chars
+1;
1841 int ui_textbox( ui_rect inout_panel
, const char *label
,
1842 char *buf
, u32 len
, u32 lines
, u32 flags
,
1843 struct ui_textbox_callbacks
*callbacks
)
1845 if( lines
> 1 ) flags
|= UI_TEXTBOX_MULTILINE
;
1848 ui_standard_widget( inout_panel
, rect
, lines
);
1851 ui_label( rect
, label
, 1, 0, rect
);
1853 int clickup
= ui_click_up(UI_MOUSE_LEFT
),
1854 clickdown
= ui_click_down(UI_MOUSE_LEFT
),
1855 click
= ui_clicking(UI_MOUSE_LEFT
) | clickup
,
1856 target
= ui_inside_rect( rect
, vg_ui
.mouse_click
) && click
,
1857 hover
= ui_inside_rect( rect
, vg_ui
.mouse
);
1859 /* allow instant transitions from textbox->textbox */
1860 if( (vg_ui
.focused_control_type
!= k_ui_control_none
) &&
1861 (vg_ui
.focused_control_type
!= k_ui_control_textbox
) ){
1867 flags
&= ~UI_TEXTBOX_AUTOFOCUS
;
1870 u32 col_base
= ui_colour( k_ui_bg
),
1871 col_highlight
= ui_colour( k_ui_fg
),
1872 col_cursor
= (0x00ffffff & ui_colour(k_ui_fg
))|0x7f000000;
1877 rect_copy( rect
, text_rect
);
1879 if( flags
& UI_TEXTBOX_MULTILINE
) text_rect
[3] = rect
[3]-16;
1880 else text_rect
[3] = vg_ui
.font
->line_height
;
1883 ui_rect_center( rect
, text_rect
);
1885 ui_px wrap_length
= 1024;
1887 if( flags
& UI_TEXTBOX_WRAP
)
1888 wrap_length
= text_rect
[2] / vg_ui
.font
->spacing
;
1891 vg_ui
.cursor
= k_ui_cursor_ibeam
;
1894 if( vg_ui
.focused_control_id
== buf
){
1895 ui_fill( rect
, col_base
);
1896 ui_ntext( text_rect
, buf
, wrap_length
, 1, k_ui_align_left
, 0 );
1898 if( !(flags
& UI_TEXTBOX_AUTOFOCUS
) && ((clickup
||clickdown
) && !target
)){
1902 vg_ui
.focused_control_hit
= 1;
1903 if( click
&& target
){
1905 (vg_ui
.mouse_click
[0] - text_rect
[0]) / vg_ui
.font
->spacing
,
1906 (vg_ui
.mouse_click
[1] - text_rect
[1]) / vg_ui
.font
->line_height
,
1910 (vg_ui
.mouse
[0] - text_rect
[0]) / vg_ui
.font
->spacing
,
1911 (vg_ui
.mouse
[1] - text_rect
[1]) / vg_ui
.font
->line_height
,
1915 if( flags
& UI_TEXTBOX_MULTILINE
){
1916 _ui_textbox_calc_index_from_grid( p0
, wrap_length
);
1917 _ui_textbox_calc_index_from_grid( p1
, wrap_length
);
1919 vg_ui
.textbox
.cursor_pos
= p0
[2];
1920 vg_ui
.textbox
.cursor_user
= p1
[2];
1923 int max
= strlen( buf
);
1924 vg_ui
.textbox
.cursor_pos
= VG_MAX( 0, VG_MIN( max
, p0
[0] )),
1925 vg_ui
.textbox
.cursor_user
= VG_MAX( 0, VG_MIN( max
, p1
[0] ));
1929 ui_outline( rect
, -2, vg_ui
.scheme
[ k_ui_orange
], 0 );
1933 int c0
= vg_ui
.textbox
.cursor_pos
,
1934 c1
= vg_ui
.textbox
.cursor_user
,
1935 start
= VG_MIN( c0
, c1
),
1936 end
= VG_MAX( c0
, c1
),
1939 if( flags
& (UI_TEXTBOX_WRAP
|UI_TEXTBOX_MULTILINE
) ){
1940 int pos
[3], remaining
= chars
;
1943 _ui_textbox_index_calc_coords( pos
, wrap_length
);
1946 cursor
[0] = text_rect
[0] + pos
[0]*vg_ui
.font
->spacing
-1;
1947 cursor
[1] = text_rect
[1] + pos
[1]*14;
1950 ui_fill( cursor
, col_cursor
);
1951 rect_copy( cursor
, vg_ui
.click_fader_end
);
1955 int run
= _ui_textbox_run_remaining( pos
, wrap_length
);
1956 run
= VG_MIN( run
, remaining
);
1958 cursor
[0] = text_rect
[0] + pos
[0]*vg_ui
.font
->spacing
-1;
1959 cursor
[1] = text_rect
[1] + pos
[1]*14;
1960 cursor
[2] = (float)(run
)*(float)vg_ui
.font
->spacing
;
1963 ui_fill( cursor
, col_cursor
);
1970 rect_copy( cursor
, vg_ui
.click_fader_end
);
1974 cursor
[0] = text_rect
[0] + start
*vg_ui
.font
->spacing
-1;
1975 cursor
[1] = text_rect
[1];
1982 cursor
[2] = (float)(chars
)*(float)vg_ui
.font
->spacing
;
1985 if( (vg_ui
.click_fade_opacity
<=0.0f
) &&
1986 ui_clip( rect
, cursor
, cursor
) ){
1987 ui_fill( cursor
, col_cursor
);
1990 rect_copy( cursor
, vg_ui
.click_fader_end
);
1997 if( click
|| (flags
& UI_TEXTBOX_AUTOFOCUS
) ){
1998 if( (target
&& hover
) || (flags
& UI_TEXTBOX_AUTOFOCUS
) ){
2001 ui_fill( rect
, col_highlight
);
2002 vg_ui
.ignore_input_frames
= 2;
2003 rect_copy( rect
, vg_ui
.click_fader
);
2004 rect_copy( rect
, vg_ui
.click_fader_end
);
2006 vg_ui
.click_fade_opacity
= 1.0f
;
2007 vg_ui
.textbuf
= buf
;
2008 vg_ui
.focused_control_hit
= 1;
2009 vg_ui
.focused_control_type
= k_ui_control_textbox
;
2010 vg_ui
.textbox
.len
= len
;
2011 vg_ui
.textbox
.flags
= flags
;
2012 vg_ui
.textbox
.cursor_pos
= 0;
2013 vg_ui
.textbox
.cursor_user
= 0;
2016 vg_ui
.textbox
.callbacks
= *callbacks
;
2019 vg_ui
.textbox
.callbacks
.change
= NULL
;
2020 vg_ui
.textbox
.callbacks
.down
= NULL
;
2021 vg_ui
.textbox
.callbacks
.up
= NULL
;
2022 vg_ui
.textbox
.callbacks
.enter
= NULL
;
2025 SDL_StartTextInput();
2029 ui_fill( rect
, col_base
);
2032 ui_outline( rect
, -1, col_highlight
, 0 );
2035 ui_ntext( text_rect
, buf
, wrap_length
, 1, k_ui_align_left
, 0 );
2041 * -----------------------------------------------------------------------------
2044 void ui_tabs( ui_rect inout_panel
, ui_rect out_content_panel
,
2045 const char **titles
, u32 count
, i32
*page
)
2048 ui_standard_widget( inout_panel
, bar
, 1 );
2050 i32 cur_page
= *page
;
2052 f32 width
= (f32
)inout_panel
[2] / (f32
)count
;
2054 ui_px h
= (inout_panel
[1] + inout_panel
[3]) - (bar
[1]+bar
[3]);
2055 inout_panel
[1] = bar
[1]+bar
[3];
2058 ui_fill( inout_panel
, ui_colour( k_ui_bg
+2 ) );
2059 ui_outline( inout_panel
, 1, ui_colour( k_ui_bg
+5 ), 0 );
2061 rect_copy( inout_panel
, out_content_panel
);
2062 ui_rect_pad( out_content_panel
, (ui_px
[2]){ k_ui_padding
, k_ui_padding
} );
2065 for( i32 i
=0; i
<count
; i
++ ){
2067 bar
[0] + ((f32
)i
*width
),
2073 enum ui_scheme_colour colour
= k_ui_bg
+4;
2074 if( i
== cur_page
){
2076 ui_outline( button
, 1, ui_colour( k_ui_bg
+5 ),
2077 UI_TOP
|UI_LEFT
|UI_RIGHT
);
2081 if( ui_colourbutton_text( button
, titles
[i
], 1, colour
) == 1 )
2088 * -----------------------------------------------------------------------------
2090 void ui_start_modal( const char *message
, u32 options
)
2092 vg_ui
.focused_control_type
= k_ui_control_modal
;
2093 vg_ui
.modal
.message
= message
;
2094 vg_ui
.modal
.callbacks
.close
= NULL
;
2095 vg_ui
.modal
.options
= options
;
2097 u32 type
= options
& UI_MODAL_TYPE_BITS
;
2098 if( type
== UI_MODAL_OK
) vg_info( message
);
2099 else if( type
== UI_MODAL_WARN
) vg_warn( message
);
2100 else if( type
== UI_MODAL_GOOD
) vg_success( message
);
2101 else if( type
== UI_MODAL_BAD
) vg_error( message
);
2106 * -----------------------------------------------------------------------------
2112 void ui_proc_key( SDL_Keysym ev
)
2114 if( vg_ui
.focused_control_type
!= k_ui_control_textbox
){
2118 struct textbox_mapping
{
2122 void (*handler
)(void);
2126 { 0, SDLK_LEFT
, _ui_textbox_left
},
2127 { KMOD_SHIFT
, SDLK_LEFT
, _ui_textbox_left_select
},
2128 { 0, SDLK_RIGHT
, _ui_textbox_right
},
2129 { KMOD_SHIFT
, SDLK_RIGHT
, _ui_textbox_right_select
},
2130 { 0, SDLK_DOWN
, _ui_textbox_down
},
2131 { 0, SDLK_UP
, _ui_textbox_up
},
2132 { 0, SDLK_BACKSPACE
, _ui_textbox_backspace
},
2133 { KMOD_SHIFT
, SDLK_BACKSPACE
, _ui_textbox_backspace
},
2134 { KMOD_CTRL
, SDLK_BACKSPACE
, _ui_textbox_backspace
},
2135 { 0, SDLK_DELETE
, _ui_textbox_delete
},
2136 { 0, SDLK_HOME
, _ui_textbox_home
},
2137 { KMOD_SHIFT
, SDLK_HOME
, _ui_textbox_home_select
},
2138 { 0, SDLK_END
, _ui_textbox_end
},
2139 { KMOD_SHIFT
, SDLK_END
, _ui_textbox_end_select
},
2140 { KMOD_CTRL
, SDLK_a
, _ui_textbox_select_all
},
2141 { KMOD_CTRL
, SDLK_c
, _ui_textbox_to_clipboard
},
2142 { KMOD_CTRL
, SDLK_x
, _ui_textbox_cut
},
2143 { KMOD_CTRL
, SDLK_v
, _ui_textbox_clipboard_paste
},
2144 { 0, SDLK_RETURN
, _ui_textbox_enter
},
2145 { 0, SDLK_ESCAPE
, ui_defocus_all
},
2150 if( ev
.mod
& KMOD_SHIFT
)
2153 if( ev
.mod
& KMOD_CTRL
)
2156 if( ev
.mod
& KMOD_ALT
)
2159 for( int i
=0; i
<vg_list_size( mappings
); i
++ ){
2160 struct textbox_mapping
*mapping
= &mappings
[i
];
2162 if( mapping
->key
== ev
.sym
){
2163 if( mapping
->mod
== 0 ){
2169 else if( (mod
& mapping
->mod
) == mapping
->mod
){
2178 * Callback for text entry mode
2180 void ui_proc_utf8( const char *text
)
2182 if( vg_ui
.focused_control_type
== k_ui_control_textbox
){
2183 const char *ptr
= text
;
2186 if( *ptr
!= '`' ) _ui_textbox_put_char( *ptr
);
2190 _ui_textbox_change_callback();
2196 * -----------------------------------------------------------------------------
2199 void ui_dev_colourview(void)
2201 ui_rect window
= {vg
.window_x
-256,0,256,vg
.window_y
}, swatch
;
2203 const char *names
[vg_list_size(vg_ui
.scheme
)] = {
2204 [k_ui_bg
] = "k_ui_bg", "k_ui_bg+1", "k_ui_bg+2", "k_ui_bg+3",
2205 "k_ui_bg+4", "k_ui_bg+5", "k_ui_bg+6", "k_ui_bg+7",
2207 [k_ui_fg
] = "k_ui_fg", "k_ui_fg+1", "k_ui_fg+2", "k_ui_fg+3",
2208 "k_ui_fg+4", "k_ui_fg+5", "k_ui_fg+6", "k_ui_fg+7",
2210 [k_ui_red
] = "k_ui_red", "k_ui_orange", "k_ui_yellow", "k_ui_green",
2211 "k_ui_aqua", "k_ui_blue", "k_ui_purple", "k_ui_gray",
2212 "k_ui_red+8","k_ui_orange+8","k_ui_yellow+8","k_ui_green+8",
2213 "k_ui_aqua+8","k_ui_blue+8","k_ui_purple+8","k_ui_gray+8" };
2216 ui_split_ratio( window
, k_ui_axis_v
, 0.5f
, 0, col
[0], col
[1] );
2218 for( int i
=0; i
<vg_list_size(vg_ui
.scheme
); i
++ ){
2219 int which
= (i
/8)%2;
2221 ui_split( col
[which
], k_ui_axis_h
, 24, 0, swatch
, col
[which
] );
2222 ui_fill( swatch
, ui_colour(i
) );
2225 ui_text(swatch
, names
[i
], 1, k_ui_align_middle_left
, ui_colourcont(i
));