vg_console.h

   1 /* Copyright (C) 2021-2023 Harry Godden (hgn) - All Rights Reserved */
   2
   3 #ifndef VG_CONSOLE_H
   4 #define VG_CONSOLE_H
   5
   6 #ifndef VG_GAME
   7   #define VG_GAME
   8 #endif
   9
  10 #include "vg/vg_imgui.h"
  11 #include "vg/vg_log.h"
  12
  13 #define VG_VAR_F32( NAME, ... ) \
  14    { u32 flags=0x00; __VA_ARGS__ ;\
  15    vg_console_reg_var( #NAME, &NAME, k_var_dtype_f32, flags ); }
  16
  17 #define VG_VAR_I32( NAME, ... ) \
  18    { u32 flags=0x00; __VA_ARGS__ ;\
  19    vg_console_reg_var( #NAME, &NAME, k_var_dtype_i32, flags ); }
  20
  21 #define VG_VAR_PERSISTENT  0x1
  22 #define VG_VAR_CHEAT       0x2
  23 #define VG_VAR_CHEATTOGGLE 0x4
  24
  25 typedef struct vg_var vg_var;
  26 typedef struct vg_cmd vg_cmd;
  27
  28 struct vg_console{
  29         struct vg_var{
  30                 void *data;
  31                 const char *name;
  32
  33                 enum vg_var_dtype{
  34                         k_var_dtype_i32,
  35                         k_var_dtype_u32,
  36                         k_var_dtype_f32
  37                 }
  38                 data_type;
  39       u32 flags;
  40
  41       union{ u32 _u32; f32 _f32; i32 _i32; } defaults;
  42         }
  43         vars[ 128 ];
  44
  45         struct vg_cmd{
  46                 int  (*function)( int argc, char const *argv[] );
  47       void (*poll_suggest)( int argc, char const *argv[] );
  48                 const char *name;
  49         }
  50         functions[ 32 ];
  51
  52    struct {
  53       const char *str;
  54       int len;
  55
  56       u32 lev_score;
  57    }
  58    suggestions[12];
  59    u32 suggestion_count;
  60    int suggestion_select,
  61        suggestion_pastepos,
  62        suggestion_maxlen;
  63
  64    u32 var_count, function_count;
  65
  66         char input[96],
  67         input_copy[96];
  68
  69         char history[32][96];
  70         int history_last, history_pos, history_count;
  71
  72         i32 enabled, cheats;
  73 }
  74 static vg_console;
  75
  76 static void _vg_console_draw( void );
  77 void           _vg_console_println( const char *str );
  78 static int  _vg_console_list( int argc, char const *argv[] );
  79 static void _vg_console_init(void);
  80 static void _vg_console_write_persistent(void);
  81 static void _vg_console_free(void);
  82 static void  vg_execute_console_input( const char *cmd, bool silent );
  83
  84 /*
  85  * Console interface
  86  */
  87 static void console_history_get( char* buf, int entry_num );
  88 static int _vg_console_enabled(void);
  89 static void console_proc_key( SDL_Keysym ev );
  90
  91 /*
  92  * Implementation
  93  */
  94 static int _vg_console_enabled(void){
  95         return vg_console.enabled;
  96 }
  97
  98 static
  99 void vg_console_reg_var( const char *alias, void *ptr, enum vg_var_dtype type,
 100                          u32 flags )
 101 {
 102    if( vg_console.var_count > vg_list_size(vg_console.vars) )
 103       vg_fatal_error( "Too many vars registered" );
 104
 105    vg_var *var = &vg_console.vars[ vg_console.var_count ++ ];
 106    var->name = alias;
 107    var->data = ptr;
 108    var->data_type = type;
 109    var->flags = flags;
 110
 111    if     ( type == k_var_dtype_f32 ) var->defaults._f32 = *((f32 *)ptr);
 112    else if( type == k_var_dtype_i32 ) var->defaults._i32 = *((i32 *)ptr);
 113    else if( type == k_var_dtype_u32 ) var->defaults._u32 = *((u32 *)ptr);
 114
 115    vg_info( "Console variable '%s' registered\n", alias );
 116 }
 117
 118 static
 119 void vg_console_reg_cmd( const char *alias,
 120                          int (*function)(int argc, const char *argv[]),
 121                          void (*poll_suggest)(int argc, const char *argv[]) )
 122 {
 123    if( vg_console.function_count > vg_list_size(vg_console.functions) )
 124       vg_fatal_error( "Too many functions registered" );
 125
 126    vg_cmd *cmd = &vg_console.functions[ vg_console.function_count ++ ];
 127
 128    cmd->function = function;
 129    cmd->poll_suggest = poll_suggest;
 130    cmd->name = alias;
 131
 132    vg_info( "Console function '%s' registered\n", alias );
 133 }
 134
 135 static int _vg_console_list( int argc, char const *argv[] ){
 136         for( int i=0; i<vg_console.function_count; i ++ ){
 137                 struct vg_cmd *cmd = &vg_console.functions[ i ];
 138                 vg_info( "* %s\n", cmd->name );
 139         }
 140
 141         for( int i=0; i<vg_console.var_count; i ++ ){
 142                 struct vg_var *cv = &vg_console.vars[ i ];
 143                 vg_info( "%s\n", cv->name );
 144         }
 145
 146         return 0;
 147 }
 148
 149 int _test_break( int argc, const char *argv[] ){
 150    vg_fatal_error( "Test crash from main, after loading (console)" );
 151    return 0;
 152 }
 153
 154 int _vg_console_exec( int argc, const char *argv[] ){
 155    if( argc < 1 ) return 0;
 156
 157    int silent=0;
 158    if( argc == 2 ) silent=1;
 159
 160    char path[256];
 161    strcpy( path, "cfg/" );
 162    strncat( path, argv[0], 250 );
 163
 164         FILE *fp = fopen( path, "r" );
 165         if( fp ){
 166                 char line[256];
 167
 168                 while( fgets( line, sizeof( line ), fp ) ){
 169                         line[ strcspn( line, "\r\n#" ) ] = 0x00;
 170
 171                         if( line[0] != 0x00 ){
 172                                 vg_execute_console_input( line, silent );
 173                         }
 174                 }
 175
 176                 fclose( fp );
 177         }
 178    else{
 179       vg_error( "Could not open '%s'\n", path );
 180    }
 181
 182    return 0;
 183 }
 184
 185 int _ccmd_vg_console_defaults( int argc, const char *argv[] ){
 186         for( int i=0; i<vg_console.var_count; i ++ ){
 187                 struct vg_var *cv = &vg_console.vars[i];
 188
 189       enum vg_var_dtype type = cv->data_type;
 190       void *ptr = cv->data;
 191
 192       if     ( type == k_var_dtype_f32 ) *((f32 *)ptr) = cv->defaults._f32;
 193       else if( type == k_var_dtype_i32 ) *((i32 *)ptr) = cv->defaults._i32;
 194       else if( type == k_var_dtype_u32 ) *((u32 *)ptr) = cv->defaults._u32;
 195         }
 196
 197    return 0;
 198 }
 199
 200 static void _vg_console_init(void){
 201    vg_console_reg_cmd( "list", _vg_console_list, NULL );
 202    vg_console_reg_cmd( "crash", _test_break, NULL );
 203    vg_console_reg_cmd( "exec", _vg_console_exec, NULL );
 204    vg_console_reg_cmd( "defaults", _ccmd_vg_console_defaults, NULL );
 205    vg_console_reg_var( "cheats", &vg_console.cheats, k_var_dtype_i32,
 206 #ifdef VG_DEVWINDOW
 207                        VG_VAR_PERSISTENT
 208 #else
 209                        0
 210 #endif
 211                        );
 212 }
 213
 214 static void vg_console_load_autos(void){
 215    _vg_console_exec( 2, (const char *[]){ "auto.conf", "silent" } );
 216 }
 217
 218 static void _vg_console_write_persistent(void){
 219         FILE *fp = fopen( "cfg/auto.conf", "w" );
 220
 221    if( !fp ){
 222       vg_error( "Cannot open cfg/auto.conf\n" );
 223       return;
 224    }
 225
 226         for( int i=0; i<vg_console.var_count; i ++ ){
 227                 struct vg_var *cv = &vg_console.vars[i];
 228
 229                 if( cv->flags & VG_VAR_PERSISTENT ){
 230                         switch( cv->data_type ){
 231                                 case k_var_dtype_i32:
 232                                         fprintf( fp, "%s %d\n", cv->name, *(i32 *)(cv->data) );
 233                                 break;
 234                                 case k_var_dtype_u32:
 235                                         fprintf( fp, "%s %u\n", cv->name, *(u32 *)(cv->data) );
 236                                 break;
 237                                 case k_var_dtype_f32:
 238                                         fprintf( fp, "%s %.5f\n", cv->name, *(float *)(cv->data ) );
 239                                 break;
 240                         }
 241                 }
 242         }
 243
 244         fclose( fp );
 245 }
 246
 247 static void _vg_console_free(void)
 248 {
 249         _vg_console_write_persistent();
 250 }
 251
 252 /*
 253  * splits src into tokens and fills out args as pointers to those tokens
 254  * returns number of tokens
 255  * dst must be as long as src
 256  */
 257 static int vg_console_tokenize( const char *src, char *dst,
 258                                    const char *args[8] )
 259 {
 260         int arg_count = 0,
 261        in_token = 0;
 262
 263         for( int i=0;; i ++ ){
 264                 if( src[i] ){
 265                         if( src[i] == ' ' || src[i] == '\t' ){
 266             if( in_token )
 267                dst[i] = '\0';
 268
 269                                 in_token = 0;
 270
 271                                 if( arg_count == 8 )
 272                                         break;
 273                         }
 274                         else{
 275                                 dst[i] = src[i];
 276
 277                                 if( !in_token ){
 278                                         args[ arg_count ++ ] = &dst[i];
 279                                         in_token = 1;
 280                                 }
 281                         }
 282                 }
 283                 else{
 284                         dst[i] = '\0';
 285                         break;
 286                 }
 287         }
 288
 289    return arg_count;
 290 }
 291
 292 static vg_var *vg_console_match_var( const char *kw )
 293 {
 294         for( int i=0; i<vg_console.var_count; i ++ ){
 295                 struct vg_var *cv = &vg_console.vars[ i ];
 296                 if( !strcmp( cv->name, kw ) ){
 297          return cv;
 298       }
 299    }
 300
 301    return NULL;
 302 }
 303
 304 static vg_cmd *vg_console_match_cmd( const char *kw )
 305 {
 306         for( int i=0; i<vg_console.function_count; i ++ ){
 307                 struct vg_cmd *cmd = &vg_console.functions[ i ];
 308                 if( !strcmp( cmd->name, kw ) ){
 309          return cmd;
 310       }
 311    }
 312
 313    return NULL;
 314 }
 315
 316 static void vg_execute_console_input( const char *cmd, bool silent )
 317 {
 318         char temp[512];
 319         char const *args[8];
 320         int arg_count = vg_console_tokenize( cmd, temp, args );
 321
 322         if( arg_count == 0 )
 323                 return;
 324
 325    vg_var *cv = vg_console_match_var( args[0] );
 326    vg_cmd *fn = vg_console_match_cmd( args[0] );
 327
 328    assert( !(cv && fn) );
 329
 330    if( cv ){
 331       /* Cvar Matched, try get value */
 332       if( arg_count >= 2 ){
 333          if( cv->flags & VG_VAR_CHEAT ){
 334             if( !vg_console.cheats && !silent ){
 335                vg_error( "variable is cheat protected\n" );
 336                return;
 337             }
 338          }
 339
 340          if( (cv->data_type == k_var_dtype_u32) ||
 341              (cv->data_type == k_var_dtype_i32) )
 342          {
 343             int *ptr = cv->data;
 344             *ptr = atoi( args[1] );
 345
 346             if( cv->flags & VG_VAR_CHEATTOGGLE ){
 347                if( *ptr ){
 348                   _ccmd_vg_console_defaults( 0, NULL );
 349                }
 350             }
 351          }
 352          else if( cv->data_type == k_var_dtype_f32 ){
 353             float *ptr = cv->data;
 354             *ptr = atof( args[1] );
 355          }
 356       }
 357       else{
 358          if( cv->data_type == k_var_dtype_i32 )
 359             vg_info( "= %d\n", *((int *)cv->data) );
 360          else if( cv->data_type == k_var_dtype_u32 )
 361             vg_info( "= %u\n", *((u32 *)cv->data) );
 362          else if( cv->data_type == k_var_dtype_f32 )
 363             vg_info( "= %.4f\n", *((float *)cv->data) );
 364       }
 365
 366       return;
 367         }
 368    else if( fn ){
 369       fn->function( arg_count-1, args+1 );
 370       return;
 371    }
 372
 373    if( !silent )
 374       vg_error( "No command/var named '%s'. Use 'list' to view all\n",args[0]);
 375 }
 376
 377 u32 str_lev_distance( const char *s1, const char *s2 ){
 378    u32 m = strlen( s1 ),
 379        n = strlen( s2 );
 380
 381    if( m==0 ) return n;
 382    if( n==0 ) return m;
 383
 384    assert( n+1 <= 256 );
 385
 386    u32 costs[ 256 ];
 387
 388    for( u32 k=0; k<=n; k++ )
 389       costs[k] = k;
 390
 391    u32 i = 0;
 392    for( u32 i=0; i<m; i++ ){
 393       costs[0] = i+1;
 394
 395       u32 corner = i;
 396
 397       for( u32 j=0; j<n; j++ ){
 398          u32 upper = costs[j+1];
 399
 400          if( s1[i] == s2[j] )
 401             costs[ j+1 ] = corner;
 402          else{
 403             u32 t = (upper < corner)? upper: corner;
 404             costs[j+1] = ((costs[j] < t)? costs[j]: t) + 1;
 405          }
 406
 407          corner = upper;
 408       }
 409    }
 410
 411    return costs[n];
 412 }
 413
 414 u32 str_lcs( const char *s1, const char *s2 ){
 415    u32 m = VG_MIN( 31, strlen( s1 ) ),
 416        n = VG_MIN( 31, strlen( s2 ) );
 417
 418    int suff[32][32],
 419        result = 0;
 420
 421    for( int i=0; i<=m; i++ ){
 422       for( int j=0; j<=n; j++ ){
 423          if( i == 0 || j == 0 )
 424             suff[i][j] = 0;
 425          else if( s1[i-1] == s2[j-1] ){
 426             suff[i][j] = suff[i-1][j-1] + 1;
 427             result = VG_MAX( result, suff[i][j] );
 428          }
 429          else
 430             suff[i][j] = 0;
 431       }
 432    }
 433
 434    return result;
 435 }
 436
 437 /* str must not fuckoff ever! */
 438 static void console_suggest_score_text( const char *str, const char *input,
 439                                            int minscore )
 440 {
 441    /* filter duplicates */
 442    for( int i=0; i<vg_console.suggestion_count; i++ )
 443       if( !strcmp( vg_console.suggestions[i].str, str ) )
 444          return;
 445
 446    /* calc score */
 447    u32 score = str_lcs( str, input );
 448
 449    if( score < minscore )
 450       return;
 451
 452    int best_pos = vg_console.suggestion_count;
 453    for( int j=best_pos-1; j>=0; j -- )
 454       if( score > vg_console.suggestions[j].lev_score )
 455          best_pos = j;
 456
 457    /* insert if good score */
 458    if( best_pos < vg_list_size( vg_console.suggestions ) ){
 459       int start = VG_MIN( vg_console.suggestion_count,
 460                           vg_list_size( vg_console.suggestions )-1 );
 461       for( int j=start; j>best_pos; j -- )
 462          vg_console.suggestions[j] = vg_console.suggestions[j-1];
 463
 464       vg_console.suggestions[ best_pos ].str = str;
 465       vg_console.suggestions[ best_pos ].len = strlen( str );
 466       vg_console.suggestions[ best_pos ].lev_score = score;
 467
 468       if( vg_console.suggestion_count <
 469             vg_list_size( vg_console.suggestions ) )
 470          vg_console.suggestion_count ++;
 471    }
 472 }
 473
 474 static void console_update_suggestions(void)
 475 {
 476    if( vg_ui.focused_control_type != k_ui_control_textbox ||
 477        vg_ui.textbuf != vg_console.input )
 478       return;
 479
 480    vg_console.suggestion_count = 0;
 481    vg_console.suggestion_select = -1;
 482    vg_console.suggestion_maxlen = 0;
 483
 484    /*
 485     * - must be typing something
 486     * - must be at the end
 487     * - prev char must not be a whitespace
 488     * - cursors should match
 489     */
 490
 491    if( vg_ui.textbox.cursor_pos == 0 ) return;
 492    if( vg_ui.textbox.cursor_pos != vg_ui.textbox.cursor_user ) return;
 493    if( vg_console.input[ vg_ui.textbox.cursor_pos ] != '\0' ) return;
 494
 495    if(  (vg_console.input[ vg_ui.textbox.cursor_pos -1 ] == ' ') ||
 496         (vg_console.input[ vg_ui.textbox.cursor_pos -1 ] == '\t') )
 497       return;
 498
 499    char temp[128];
 500    const char *args[8];
 501
 502    int token_count = vg_console_tokenize( vg_console.input, temp, args );
 503    if( !token_count ) return;
 504    vg_console.suggestion_pastepos = args[token_count-1]-temp;
 505
 506    /* Score all our commands and cvars */
 507    if( token_count == 1 ){
 508       for( int i=0; i<vg_console.var_count; i++ ){
 509          vg_var *cvar = &vg_console.vars[i];
 510          console_suggest_score_text( cvar->name, args[0], 1 );
 511       }
 512
 513       for( int i=0; i<vg_console.function_count; i++ ){
 514          vg_cmd *cmd = &vg_console.functions[i];
 515          console_suggest_score_text( cmd->name, args[0], 1 );
 516       }
 517    }
 518    else{
 519       vg_cmd *cmd = vg_console_match_cmd( args[0] );
 520       vg_var *var = vg_console_match_var( args[0] );
 521
 522       assert( !( cmd && var ) );
 523
 524       if( cmd )
 525          if( cmd->poll_suggest )
 526             cmd->poll_suggest( token_count-1, &args[1] );
 527    }
 528
 529    /* some post processing */
 530    for( int i=0; i<vg_console.suggestion_count; i++ ){
 531       vg_console.suggestion_maxlen = VG_MAX( vg_console.suggestion_maxlen,
 532                                              vg_console.suggestions[i].len );
 533
 534       if( vg_console.suggestions[i].lev_score <
 535           vg_console.suggestions[0].lev_score/2 )
 536       {
 537          vg_console.suggestion_count = i;
 538          return;
 539       }
 540    }
 541 }
 542
 543 /*
 544  * Suggestion controls
 545  */
 546 static void _console_fetch_suggestion(void)
 547 {
 548    char *target = &vg_console.input[ vg_console.suggestion_pastepos ];
 549
 550    if( vg_console.suggestion_select == -1 ){
 551       strcpy( target, vg_console.input_copy );
 552       _ui_textbox_move_cursor( &vg_ui.textbox.cursor_user,
 553                                &vg_ui.textbox.cursor_pos, 10000, 1 );
 554    }
 555    else{
 556       strncpy( target,
 557             vg_console.suggestions[ vg_console.suggestion_select ].str,
 558             vg_list_size( vg_console.input )-1 );
 559
 560       _ui_textbox_move_cursor( &vg_ui.textbox.cursor_user,
 561                                &vg_ui.textbox.cursor_pos, 10000, 1 );
 562       _ui_textbox_put_char( ' ' );
 563    }
 564 }
 565
 566 static void _console_suggest_store_normal(void)
 567 {
 568    if( vg_console.suggestion_select == -1 ){
 569       char *target = &vg_console.input[ vg_console.suggestion_pastepos ];
 570       strcpy( vg_console.input_copy, target );
 571    }
 572 }
 573
 574 static void _console_suggest_next(void)
 575 {
 576    if( vg_console.suggestion_count ){
 577       _console_suggest_store_normal();
 578
 579       vg_console.suggestion_select ++;
 580
 581       if( vg_console.suggestion_select >= vg_console.suggestion_count )
 582          vg_console.suggestion_select = -1;
 583
 584       _console_fetch_suggestion();
 585    }
 586 }
 587
 588 static void _console_suggest_prev(void)
 589 {
 590    if( vg_console.suggestion_count ){
 591       _console_suggest_store_normal();
 592
 593       vg_console.suggestion_select --;
 594
 595       if( vg_console.suggestion_select < -1 )
 596          vg_console.suggestion_select = vg_console.suggestion_count-1;
 597
 598       _console_fetch_suggestion();
 599    }
 600 }
 601
 602 static void _vg_console_on_update( char *buf, u32 len )
 603 {
 604    if( buf == vg_console.input ){
 605       console_update_suggestions();
 606    }
 607 }
 608
 609 static void console_history_get( char* buf, int entry_num )
 610 {
 611         if( !vg_console.history_count )
 612                 return;
 613
 614    int offset = VG_MIN( entry_num, vg_console.history_count -1 ),
 615        pick = (vg_console.history_last - offset) %
 616                vg_list_size( vg_console.history );
 617         strcpy( buf, vg_console.history[ pick ] );
 618 }
 619
 620 static void _vg_console_on_up( char *buf, u32 len )
 621 {
 622    if( buf == vg_console.input ){
 623       vg_console.history_pos =
 624       VG_MAX
 625       (
 626         0,
 627         VG_MIN
 628         (
 629           vg_console.history_pos+1,
 630           VG_MIN
 631           (
 632             vg_list_size( vg_console.history ),
 633             vg_console.history_count - 1
 634           )
 635         )
 636       );
 637
 638       console_history_get( vg_console.input, vg_console.history_pos );
 639       _ui_textbox_move_cursor( &vg_ui.textbox.cursor_user,
 640                                &vg_ui.textbox.cursor_pos,
 641                                vg_list_size(vg_console.input)-1, 1);
 642    }
 643 }
 644
 645 static void _vg_console_on_down( char *buf, u32 len )
 646 {
 647    if( buf == vg_console.input ){
 648       vg_console.history_pos = VG_MAX( 0, vg_console.history_pos-1 );
 649       console_history_get( vg_console.input, vg_console.history_pos );
 650
 651       _ui_textbox_move_cursor( &vg_ui.textbox.cursor_user,
 652                                &vg_ui.textbox.cursor_pos,
 653                                vg_list_size(vg_console.input)-1, 1 );
 654    }
 655 }
 656
 657 static void _vg_console_on_enter( char *buf, u32 len )
 658 {
 659    if( buf == vg_console.input ){
 660       if( !strlen( vg_console.input ) )
 661          return;
 662
 663       vg_info( "%s\n", vg_console.input );
 664
 665       if( strcmp( vg_console.input,
 666                   vg_console.history[ vg_console.history_last ]) )
 667       {
 668          vg_console.history_last = ( vg_console.history_last + 1) %
 669                                     vg_list_size(vg_console.history );
 670          vg_console.history_count =
 671             VG_MIN( vg_list_size( vg_console.history ),
 672                   vg_console.history_count + 1 );
 673          strcpy( vg_console.history[ vg_console.history_last ],
 674                  vg_console.input );
 675       }
 676
 677       vg_console.history_pos = -1;
 678       vg_execute_console_input( vg_console.input, 0 );
 679       _ui_textbox_move_cursor( &vg_ui.textbox.cursor_user,
 680                                &vg_ui.textbox.cursor_pos, -10000, 1 );
 681
 682       vg_console.input[0] = '\0';
 683       console_update_suggestions();
 684    }
 685 }
 686
 687 static void _vg_console_draw(void)
 688 {
 689         if( !vg_console.enabled ) return;
 690
 691    SDL_AtomicLock( &log_print_sl );
 692
 693         int ptr = vg_log.log_line_current;
 694    int const fh = vg_ui.font->line_height, log_lines = 32;
 695    int console_lines = VG_MIN( log_lines, vg_log.log_line_count );
 696
 697    ui_rect rect_log   = { 0, 0,                vg.window_x, log_lines*fh },
 698            rect_input = { 0, log_lines*fh + 1, vg.window_x, fh*2 },
 699            rect_line  = { 0, 0,                vg.window_x, fh };
 700
 701    /*
 702     * log
 703     */
 704    u32 bg_colour = (ui_colour( k_ui_bg )&0x00ffffff)|0x9f000000;
 705
 706    ui_fill( rect_log, bg_colour );
 707    rect_line[1] = rect_log[1]+rect_log[3]-fh;
 708
 709    for( int i=0; i<console_lines; i ++ ){
 710       ptr --;
 711
 712       if( ptr < 0 ) ptr = vg_list_size( vg_log.log )-1;
 713
 714       ui_text( rect_line, vg_log.log[ptr], 1, k_ui_align_left, 0 );
 715       rect_line[1] -= fh;
 716    }
 717
 718    /*
 719     * Input area
 720     */
 721
 722    struct ui_textbox_callbacks callbacks = {
 723       .up = _vg_console_on_up,
 724       .down = _vg_console_on_down,
 725       .change = _vg_console_on_update,
 726       .enter = _vg_console_on_enter,
 727    };
 728    ui_textbox( rect_input, NULL,
 729                vg_console.input, vg_list_size(vg_console.input), 1,
 730                UI_TEXTBOX_AUTOFOCUS, &callbacks );
 731
 732    /*
 733     * suggestions
 734     */
 735    if( vg_console.suggestion_count ){
 736       ui_rect rect_suggest;
 737       rect_copy( rect_input, rect_suggest );
 738
 739       rect_suggest[0] += 6 + vg_ui.font->spacing*vg_console.suggestion_pastepos;
 740       rect_suggest[1] += rect_input[3];
 741       rect_suggest[2]  = vg_ui.font->spacing * vg_console.suggestion_maxlen;
 742       rect_suggest[3]  = vg_console.suggestion_count * fh;
 743
 744       ui_fill( rect_suggest, bg_colour );
 745
 746       rect_suggest[3] = fh;
 747
 748       for( int i=0; i<vg_console.suggestion_count; i ++ ){
 749          u32 text_colour;
 750          if( i == vg_console.suggestion_select ){
 751             ui_fill( rect_suggest, ui_colour( k_ui_orange ) );
 752             text_colour = ui_colourcont( k_ui_orange );
 753          }
 754          else text_colour = ui_colourcont( k_ui_bg );
 755
 756          ui_text( rect_suggest, vg_console.suggestions[i].str, 1,
 757                   k_ui_align_left, text_colour );
 758
 759          rect_suggest[1] += fh;
 760       }
 761    }
 762
 763    SDL_AtomicUnlock( &log_print_sl );
 764 }
 765
 766
 767 #endif /* VG_CONSOLE_H */