retrogui.h

Go to the documentation of this file.

 
#ifndef RETROGUI_H
#define RETROGUI_H

 
#ifndef RETROFONT_PRESENT
#  error "retrofont not present!"
#endif /* !RETROFONT_PRESENT */
 
/* TODO: Maug log unified API to reference. */
 
#ifndef RETROGUI_TRACE_LVL
#  define RETROGUI_TRACE_LVL 0
#endif /* !RETROGUI_TRACE_LVL */
 
#ifndef RETROGUI_COLOR_BORDER
#  define RETROGUI_COLOR_BORDER RETROFLAT_COLOR_DARKBLUE
#endif /* !RETROGUI_COLOR_BORDER */
 
#ifndef RETROGUI_CTL_TEXT_SZ_MAX
 
#ifndef RETROGUI_KEY_ACTIVATE
#  define RETROGUI_KEY_ACTIVATE RETROFLAT_KEY_SPACE
#endif /* !RETROGUI_KEY_ACTIVATE */
 
#ifndef RETROGUI_KEY_NEXT
#  define RETROGUI_KEY_NEXT RETROFLAT_KEY_DOWN
#endif /* !RETROGUI_KEY_NEXT */
 
#ifndef RETROGUI_KEY_PREV
#  define RETROGUI_KEY_PREV RETROFLAT_KEY_UP
#endif /* !RETROGUI_KEY_PREV */
 
#ifndef RETROGUI_KEY_SEL_NEXT
#  define RETROGUI_KEY_SEL_NEXT RETROFLAT_KEY_RIGHT
#endif /* !RETROGUI_KEY_SEL_NEXT */
 
#ifndef RETROGUI_KEY_SEL_PREV
#  define RETROGUI_KEY_SEL_PREV RETROFLAT_KEY_LEFT
#endif /* !RETROGUI_KEY_SEL_PREV */
 
#ifndef RETROGUI_PAD_ACTIVATE
#  define RETROGUI_PAD_ACTIVATE RETROFLAT_PAD_A
#endif /* !RETROGUI_PAD_ACTIVATE */
 
#ifndef RETROGUI_PAD_NEXT
#  define RETROGUI_PAD_NEXT RETROFLAT_PAD_DOWN
#endif /* !RETROGUI_PAD_NEXT */
 
#ifndef RETROGUI_PAD_PREV
#  define RETROGUI_PAD_PREV RETROFLAT_PAD_UP
#endif /* !RETROGUI_PAD_PREV */
 
#ifndef RETROGUI_PAD_SEL_NEXT
#  define RETROGUI_PAD_SEL_NEXT RETROFLAT_PAD_RIGHT
#endif /* !RETROGUI_PAD_SEL_NEXT */
 
#ifndef RETROGUI_PAD_SEL_PREV
#  define RETROGUI_PAD_SEL_PREV RETROFLAT_PAD_LEFT
#endif /* !RETROGUI_PAD_SEL_PREV */
 
#  define RETROGUI_CTL_TEXT_SZ_MAX 128
#endif /* !RETROGUI_CTL_TEXT_SZ_MAX */
 
#ifndef RETROGUI_CTL_SZ_MAX_INIT
#  define RETROGUI_CTL_SZ_MAX_INIT 20
#endif /* !RETROGUI_CTL_SZ_MAX_INIT */
 
#ifndef RETROGUI_PADDING
#  define RETROGUI_PADDING 5
#endif /* !RETROGUI_PADDING */
 
#ifndef RETROGUI_BTN_LBL_SZ_MAX
#  define RETROGUI_BTN_LBL_SZ_MAX 64
#endif /* !RETROGUI_BTN_LBL_SZ_MAX */
 
#ifndef RETROGUI_BTN_LBL_PADDED_X
#  define RETROGUI_BTN_LBL_PADDED_X 8
#endif /* !RETROGUI_BTN_LBL_PADDED_X */
 
#ifndef RETROGUI_BTN_LBL_PADDED_Y
#  define RETROGUI_BTN_LBL_PADDED_Y 8
#endif /* !RETROGUI_BTN_LBL_PADDED_Y */
 
#ifndef RETROGUI_CTL_TEXT_BLINK_FRAMES
#  define RETROGUI_CTL_TEXT_BLINK_FRAMES 15
#endif /* !RETROGUI_CTL_TEXT_BLINK_FRAMES */
 
#ifndef RETROGUI_CTL_LISTBOX_CURSOR_RADIUS
#  define RETROGUI_CTL_LISTBOX_CURSOR_RADIUS 8
#endif /* !RETROGUI_CTL_LISTBOX_CURSOR_RADIUS */
 
#ifndef RETROGUI_CTL_LISTBOX_STR_SZ_MAX
#  define RETROGUI_CTL_LISTBOX_STR_SZ_MAX 255
#endif /* !RETROGUI_CTL_LISTBOX_STR_SZ_MAX */
 
#ifndef RETROGUI_CTL_TEXT_CUR_WH
#  define RETROGUI_CTL_TEXT_CUR_WH 8
#endif /* !RETROGUI_CTL_LISTBOX_STR_SZ_MAX */
 
#ifndef RETROGUI_DEBOUNCE_MAX_DEFAULT
#  define RETROGUI_DEBOUNCE_MAX_DEFAULT 100
#endif /* !RETROGUI_DEBOUNCE_MAX_DEFAULT */
 
#ifndef RETROGUI_LABEL_SHOW_TICKS_MAX
#  define RETROGUI_LABEL_SHOW_TICKS_MAX 2
#endif /* !RETROGUI_LABEL_SHOW_TICKS_MAX */
 
#ifndef RETROGUI_LABEL_SHOW_INC
#  define RETROGUI_LABEL_SHOW_INC 3
#endif /* !RETROGUI_LABEL_SHOW_INC */
 /* maug_retrogui_cfg */

#define RETROGUI_FLAGS_DIRTY 0x01

#define RETROGUI_FLAGS_FONT_OWNED 0x02

#define RETROGUI_LABEL_FLAG_SHOWINC 0x02

#define RETROGUI_LABEL_FLAG_SHOWINC_SLOW 0x06
 
#define RETROGUI_FILLBAR_FLAG_SHOWNUM 0x02
 
#define _retrogui_copy_str( field, src_str, dest_ctl, str_tmp, str_sz ) \
   /* Sanity checking. */ \
   assert( NULL != src_str ); \
   debug_printf( RETROGUI_TRACE_LVL, \
      "copying string \"%s\" to " #dest_ctl, src_str ); \
   if( 0 == str_sz ) { \
      str_sz = maug_strlen( src_str ); \
      debug_printf( RETROGUI_TRACE_LVL, \
         "determined str sz of \"%s\": " SIZE_T_FMT, src_str, str_sz ); \
   } \
   if( \
      str_sz != dest_ctl. field ## _sz && \
      (MAUG_MHANDLE)NULL != dest_ctl. field ## _h \
   ) { \
      debug_printf( RETROGUI_TRACE_LVL, \
         "string size different; creating new buffer..." ); \
      /* Free the existing string. */ \
      maug_mfree( dest_ctl. field ## _h ); \
      dest_ctl. field ## _h = (MAUG_MHANDLE)NULL; \
   } \
   if( (MAUG_MHANDLE)NULL == dest_ctl. field ## _h ) { \
      /* Allocate new string space if not allocated. */ \
      maug_malloc_test( dest_ctl. field ## _h, str_sz + 1, 1 ); \
   } \
   maug_mlock( dest_ctl. field ## _h, str_tmp ); \
   maug_cleanup_if_null_lock( char*, str_tmp ); \
   \
   /* Copy the string over. */ \
   assert( NULL != str_tmp ); \
   maug_mzero( str_tmp, str_sz + 1 ); \
   debug_printf( RETROGUI_TRACE_LVL, \
      "zeroed str sz for \"%s\": " SIZE_T_FMT, src_str, str_sz + 1 ); \
   maug_strncpy( str_tmp, src_str, str_sz ); \
   dest_ctl. field ## _sz = str_sz; \
   debug_printf( RETROGUI_TRACE_LVL, "copied str as: \"%s\"", str_tmp ); \
   maug_munlock( dest_ctl. field ## _h, str_tmp );

typedef int16_t retrogui_idc_t;
 
#define RETROGUI_IDC_FMT "%d"
 
#define RETROGUI_IDC_NONE 0

#define RETROGUI_COLOR_BG 1

#define RETROGUI_COLOR_FG 2

#define RETROGUI_COLOR_SEL_BG 3

#define RETROGUI_COLOR_SEL_FG 4


/* TODO: USe MDATA_VECTOR for LISTBOX items. */
#define RETROGUI_CTL_TABLE_BASE( f ) \
   f( 0, NONE, void* none; ) \
   f( 1, LISTBOX, struct MDATA_VECTOR list; size_t sel_idx; ) \
   f( 2, BUTTON, MAUG_MHANDLE label_h; char* label; size_t label_sz; int16_t push_frames; uint8_t font_flags; ) \
   f( 3, LABEL, uint8_t flags; MAUG_MHANDLE label_h; char* label; size_t label_sz; uint8_t font_flags; size_t shown_sz; int show_ticks; ) \
   f( 4, IMAGE, retroflat_blit_t image; ssize_t image_cache_id; int16_t instance; retroflat_pxxy_t src_x; retroflat_pxxy_t src_y; ) \
   f( 5, FILLBAR, uint8_t flags; uint16_t cur; uint16_t max; )
 
#ifdef RETROGUI_NO_TEXTBOX
#  define RETROGUI_CTL_TABLE( f ) RETROGUI_CTL_TABLE_BASE( f )
#else
#  define RETROGUI_CTL_TABLE( f ) RETROGUI_CTL_TABLE_BASE( f ) \
   f( 6, TEXTBOX, MAUG_MHANDLE text_h; char* text; size_t text_sz; size_t text_sz_max; size_t text_cur; int16_t blink_frames; )
#endif /* RETROGUI_NO_TEXTBOX */
 
#if 0
   f( 6, SCROLLBAR, size_t min; size_t max; size_t value; )
#endif
 
#ifdef RETROGUI_NO_TEXTBOX
#  define retrogui_can_focus_ctl( ctl ) \
      (RETROGUI_CTL_TYPE_BUTTON == (ctl)->base.type || \
      RETROGUI_CTL_TYPE_LISTBOX == (ctl)->base.type)
#else
#  define retrogui_can_focus_ctl( ctl ) \
      (RETROGUI_CTL_TYPE_BUTTON == (ctl)->base.type || \
      RETROGUI_CTL_TYPE_TEXTBOX == (ctl)->base.type || \
      RETROGUI_CTL_TYPE_LISTBOX == (ctl)->base.type)
#endif /* RETROGUI_NO_TEXTBOX */

struct RETROGUI_CTL_BASE {
   uint8_t type;
   retrogui_idc_t idc;
   retroflat_pxxy_t x;
   retroflat_pxxy_t y;
   retroflat_pxxy_t w;
   retroflat_pxxy_t h;
   RETROFLAT_COLOR bg_color;
   RETROFLAT_COLOR fg_color;
   RETROFLAT_COLOR sel_fg;
   RETROFLAT_COLOR sel_bg;
#if defined( RETROGUI_NATIVE_WIN )
   HWND hwnd;
#endif
};

#define RETROGUI_CTL_TABLE_FIELDS( idx, c_name, c_fields ) \
   struct RETROGUI_CTL_ ## c_name { \
      struct RETROGUI_CTL_BASE base; \
      c_fields \
   };
 
RETROGUI_CTL_TABLE( RETROGUI_CTL_TABLE_FIELDS )
 

#define RETROGUI_CTL_TABLE_TYPES( idx, c_name, c_fields ) \
   struct RETROGUI_CTL_ ## c_name c_name;
 
union RETROGUI_CTL {
   struct RETROGUI_CTL_BASE base;
   RETROGUI_CTL_TABLE( RETROGUI_CTL_TABLE_TYPES )
};
 /* maug_retrogui_ctl */
 
typedef void (*retrogui_xy_cb)(
   retroflat_pxxy_t* x, retroflat_pxxy_t* y, void* data );
 
typedef char retrogui_list_t[RETROGUI_CTL_LISTBOX_STR_SZ_MAX + 1];
 
/*
 * \note It is possible to have multiple GUI controllers in a program. For
 *       example, a web browser might have a controller for its address bar and
 *       a controller for form elements on pages.
 *
 */
struct RETROGUI {
   uint8_t flags;
   retroflat_pxxy_t x;
   retroflat_pxxy_t y;
   retroflat_pxxy_t w;
   retroflat_pxxy_t h;
   RETROFLAT_COLOR bg_color;
   retrogui_idc_t idc_prev;
   struct MDATA_VECTOR ctls;
   retrogui_idc_t focus_idc;
   retroflat_blit_t* draw_bmp;
   retroflat_ms_t debounce_next;
   retroflat_ms_t debounce_max;
   union RETROGXC_CACHABLE font;
};
 
MERROR_RETVAL retrogui_push_listbox_item(
   struct RETROGUI* gui, retrogui_idc_t idc, const char* item, size_t item_sz );

retrogui_idc_t retrogui_poll_ctls(
   struct RETROGUI* gui, RETROFLAT_IN_KEY* p_input,
   struct RETROFLAT_INPUT* input_evt );
 
MERROR_RETVAL retrogui_redraw_ctls( struct RETROGUI* gui );
 
MERROR_RETVAL retrogui_sz_ctl(
   struct RETROGUI* gui, retrogui_idc_t idc,
   retroflat_pxxy_t* p_w, retroflat_pxxy_t* p_h,
   retroflat_pxxy_t max_w, retroflat_pxxy_t max_h );
 
MERROR_RETVAL retrogui_pos_ctl(
   struct RETROGUI* gui, retrogui_idc_t idc,
   retroflat_pxxy_t x, retroflat_pxxy_t y,
   retroflat_pxxy_t w, retroflat_pxxy_t h );
 
MERROR_RETVAL retrogui_push_ctl(
   struct RETROGUI* gui, union RETROGUI_CTL* ctl );

MERROR_RETVAL retrogui_set_font(
   struct RETROGUI* gui, const maug_path font_path );
 
#ifndef RETROGUI_NO_TEXTBOX
 
MERROR_RETVAL retrogui_get_ctl_text(
   struct RETROGUI* gui, retrogui_idc_t idc, char* buffer, size_t buffer_sz );
 
#endif /* !RETROGUI_NO_TEXTBOX */
 
ssize_t retrogui_get_ctl_sel_idx( struct RETROGUI* gui, retrogui_idc_t idc );
 
MERROR_RETVAL retrogui_set_ctl_color(
   struct RETROGUI* gui, retrogui_idc_t idc, uint8_t color_key,
   RETROFLAT_COLOR color_val );
 
MERROR_RETVAL retrogui_set_ctl_text(
   struct RETROGUI* gui, retrogui_idc_t idc, size_t buffer_sz,
   const char* fmt, ... );

MERROR_RETVAL retrogui_set_ctl_image(
   struct RETROGUI* gui, retrogui_idc_t idc, const maug_path path,
   uint8_t flags );

MERROR_RETVAL retrogui_set_ctl_image_blit(
   struct RETROGUI* gui, retrogui_idc_t idc, retroflat_blit_t* blit,
   uint8_t flags );

MERROR_RETVAL retrogui_set_ctl_level(
   struct RETROGUI* gui, retrogui_idc_t idc, uint16_t level, uint16_t max,
   uint8_t flags );
 
MERROR_RETVAL retrogui_init_ctl(
   union RETROGUI_CTL* ctl, uint8_t type, retrogui_idc_t idc );

retrogui_idc_t retrogui_focus_iter(
   struct RETROGUI* gui, size_t start, ssize_t incr );

MERROR_RETVAL retrogui_init( struct RETROGUI* gui );

MERROR_RETVAL retrogui_remove_ctl( struct RETROGUI* gui, retrogui_idc_t idc );

MERROR_RETVAL retrogui_destroy( struct RETROGUI* gui );
 
#define retrogui_focus_next( gui ) \
   retrogui_focus_iter( gui, 0, 1 )
 
#define retrogui_focus_prev( gui ) \
   retrogui_focus_iter( gui, mdata_vector_ct( &((gui)->ctls) ) - 1, -1 )
 
#ifdef RETROGUI_C
 
#define RETROGUI_CTL_TABLE_CONSTS( idx, c_name, c_fields ) \
   MAUG_CONST uint8_t SEG_MCONST RETROGUI_CTL_TYPE_ ## c_name = idx;
 
RETROGUI_CTL_TABLE( RETROGUI_CTL_TABLE_CONSTS )
 
#ifdef RETROGUI_TRACE_TOKENS
 
#define RETROGUI_CTL_TABLE_NAMES( idx, c_name, f_fields ) \
   #c_name,
 
MAUG_CONST char* SEG_MCONST gc_retrogui_ctl_names[] = {
   RETROGUI_CTL_TABLE( RETROGUI_CTL_TABLE_NAMES )
   ""
};
 
#endif /* RETROGUI_TRACE_TOKENS */
 
static union RETROGUI_CTL* _retrogui_get_ctl_by_idc(
   struct RETROGUI* gui, retrogui_idc_t idc );
 
/* === Control: NONE === */
 
static retrogui_idc_t retrogui_click_NONE( 
   struct RETROGUI* gui,
   union RETROGUI_CTL* ctl, RETROFLAT_IN_KEY* p_input,
   struct RETROFLAT_INPUT* input_evt
) {
   retrogui_idc_t idc_out = RETROGUI_IDC_NONE;
 
   return idc_out;
}
 
static retrogui_idc_t retrogui_key_NONE( 
   struct RETROGUI* gui, union RETROGUI_CTL* ctl, RETROFLAT_IN_KEY* p_input,
   struct RETROFLAT_INPUT* input_evt
) {
   retrogui_idc_t idc_out = RETROGUI_IDC_NONE;
 
   return idc_out;
}
 
void retrogui_redraw_NONE( struct RETROGUI* gui, union RETROGUI_CTL* ctl ) {
}
 
static MERROR_RETVAL retrogui_push_NONE( union RETROGUI_CTL* ctl ) {
   MERROR_RETVAL retval = MERROR_GUI;
  
   return retval;
}
 
static MERROR_RETVAL retrogui_sz_NONE(
   struct RETROGUI* gui, union RETROGUI_CTL* ctl,
   retroflat_pxxy_t* p_w, retroflat_pxxy_t* p_h,
   retroflat_pxxy_t max_w, retroflat_pxxy_t max_h
) {
   return MERROR_OK;
}
 
static MERROR_RETVAL retrogui_pos_NONE(
   struct RETROGUI* gui, union RETROGUI_CTL* ctl,
   retroflat_pxxy_t x, retroflat_pxxy_t y,
   retroflat_pxxy_t w, retroflat_pxxy_t h
) {
   return MERROR_OK;
}
 
static void retrogui_destroy_NONE( union RETROGUI_CTL* ctl ) {
}
 
static MERROR_RETVAL retrogui_init_NONE( union RETROGUI_CTL* ctl ) {
   MERROR_RETVAL retval = MERROR_GUI;
 
   return retval;
}
 
/* === Control: LISTBOX === */
 
static retrogui_idc_t retrogui_click_LISTBOX( 
   struct RETROGUI* gui,
   union RETROGUI_CTL* ctl, RETROFLAT_IN_KEY* p_input,
   struct RETROFLAT_INPUT* input_evt
) {
   retrogui_idc_t idc_out = RETROGUI_IDC_NONE;
   MERROR_RETVAL retval = MERROR_OK;
   size_t i = 0;
   retroflat_pxxy_t w = 0,
      h = 0;
   int autolock = 0;
   char* list_i = NULL;
   MAUG_MHANDLE font_h = (MAUG_MHANDLE)NULL;
 
#  if defined( RETROGUI_NATIVE_WIN )
   /* Do nothing. */
#  else
 
   if( !mdata_vector_is_locked( &(ctl->LISTBOX.list) ) ) {
      mdata_vector_lock( &(ctl->LISTBOX.list) );
      autolock = 1;
   }
 
   /* Figure out the item clicked. */
   while( i < mdata_vector_ct( &(ctl->LISTBOX.list) ) ) {
      list_i =
         (char*)mdata_vector_get( &(ctl->LISTBOX.list), i, retrogui_list_t );
 
      /* TODO: Use retrogui_sz_LISTBOX() instead? */
#ifdef RETROGXC_PRESENT
      font_h = retrogxc_get_asset(
         gui->font.cache_idx, RETROGXC_ASSET_TYPE_FONT );
      maug_cleanup_if_null_alloc( MAUG_MHANDLE, font_h );
#else
      font_h = gui->font.handle;
#endif /* RETROGXC_PRESENT */
      retrofont_string_sz(
         gui->draw_bmp, list_i, 0, font_h,
         ctl->base.w, ctl->base.h, &w, &h, 0 );
 
      if(
         (retroflat_pxxy_t)(input_evt->mouse_y) < 
         ctl->base.y + ((i + 1) * (h + RETROGUI_PADDING))
      ) {
         ctl->LISTBOX.sel_idx = i;
         break;
      }
 
      i++;
   }
 
cleanup:
 
   if( autolock ) {
      mdata_vector_unlock( &(ctl->LISTBOX.list) );
   }
 
   if( MERROR_OK != retval ) {
      idc_out = RETROGUI_IDC_NONE;
   }
 
#endif
 
   return idc_out;
}
 
static retrogui_idc_t retrogui_key_LISTBOX( 
   struct RETROGUI* gui, union RETROGUI_CTL* ctl, RETROFLAT_IN_KEY* p_input,
   struct RETROFLAT_INPUT* input_evt
) {
   retrogui_idc_t idc_out = RETROGUI_IDC_NONE;
 
   switch( *p_input ) {
   retroflat_case_key( RETROGUI_KEY_SEL_NEXT, RETROGUI_PAD_SEL_NEXT )
      ctl->LISTBOX.sel_idx++;
      if( ctl->LISTBOX.sel_idx >= mdata_vector_ct( &(ctl->LISTBOX.list) ) ) {
         ctl->LISTBOX.sel_idx = 0;
      }
 
      /* Redraw and preempt further processing of input. */
      gui->flags |= RETROGUI_FLAGS_DIRTY;
      *p_input = 0;
      break;
 
   retroflat_case_key( RETROGUI_KEY_SEL_PREV, RETROGUI_PAD_SEL_PREV )
      ctl->LISTBOX.sel_idx--;
      /* sel_idx is unsigned, so overflow is always positive! */
      if( ctl->LISTBOX.sel_idx >= mdata_vector_ct( &(ctl->LISTBOX.list) ) ) {
         ctl->LISTBOX.sel_idx = mdata_vector_ct( &(ctl->LISTBOX.list) ) - 1;
      }
 
      /* Redraw and preempt further processing of input. */
      gui->flags |= RETROGUI_FLAGS_DIRTY;
      *p_input = 0;
      break;
   }
 
   return idc_out;
}
 
static void retrogui_redraw_LISTBOX(
   struct RETROGUI* gui, union RETROGUI_CTL* ctl
) {
   size_t i = 0;
   retroflat_pxxy_t w = 0,
      h = 0,
      item_y = 0;
   RETROFLAT_COLOR fg_color;
   int autolock = 0;
   char* list_i = NULL;
   MERROR_RETVAL retval = MERROR_OK;
   MAUG_MHANDLE font_h = (MAUG_MHANDLE)NULL;
   
#  if defined( RETROGUI_NATIVE_WIN )
   /* TODO: InvalidateRect()? */
#  else
 
   if( !mdata_vector_is_locked( &(ctl->LISTBOX.list) ) ) {
      mdata_vector_lock( &(ctl->LISTBOX.list) );
      autolock = 1;
   }
 
   if( RETROFLAT_COLOR_BLACK != ctl->base.bg_color ) {
      retroflat_2d_rect( gui->draw_bmp, ctl->base.bg_color,
         gui->x + ctl->base.x, gui->y + ctl->base.y,
         ctl->base.w, ctl->base.h, RETROFLAT_DRAW_FLAG_FILL );
   }
 
   while( i < mdata_vector_ct( &(ctl->LISTBOX.list) ) ) {
      list_i =
         (char*)mdata_vector_get( &(ctl->LISTBOX.list), i, retrogui_list_t );
#ifdef RETROGXC_PRESENT
      font_h = retrogxc_get_asset(
         gui->font.cache_idx, RETROGXC_ASSET_TYPE_FONT );
      maug_cleanup_if_null_alloc( MAUG_MHANDLE, font_h );
#else
      font_h = gui->font.handle;
#endif /* RETROGXC_PRESENT */
      retrofont_string_sz(
         gui->draw_bmp, list_i, 0, font_h,
         ctl->base.w, ctl->base.h, &w, &h, 0 );
#if RETROGUI_TRACE_LVL > 0
      debug_printf( RETROGUI_TRACE_LVL,
         "str height for \"%s\": " SIZE_T_FMT, list_i, h );
#endif /* RETROGUI_TRACE_LVL */
      if( i == ctl->LISTBOX.sel_idx ) {
         /* Draw selection colors. */
         retroflat_2d_rect( gui->draw_bmp, ctl->base.sel_bg,
            gui->x + ctl->base.x,
            gui->y + ctl->base.y + item_y,
            ctl->base.w, h, RETROFLAT_DRAW_FLAG_FILL );
         fg_color = ctl->base.sel_fg;
 
         retroflat_2d_ellipse(
            gui->draw_bmp, ctl->base.sel_fg,
            gui->x + ctl->base.x,
            gui->y + ctl->base.y + item_y,
            RETROGUI_CTL_LISTBOX_CURSOR_RADIUS,
            RETROGUI_CTL_LISTBOX_CURSOR_RADIUS, 0 );
 
      } else {
         fg_color = ctl->base.fg_color;
      }
 
#ifdef RETROGXC_PRESENT
      font_h = retrogxc_get_asset(
         gui->font.cache_idx, RETROGXC_ASSET_TYPE_FONT );
      maug_cleanup_if_null_alloc( MAUG_MHANDLE, font_h );
#else
      font_h = gui->font.handle;
#endif /* RETROGXC_PRESENT */
      retrofont_string(
         gui->draw_bmp, fg_color, list_i, 0, font_h,
         gui->x + ctl->base.x +
            RETROGUI_CTL_LISTBOX_CURSOR_RADIUS + RETROGUI_PADDING,
         gui->y + ctl->base.y + item_y,
         0, 0, 0 );
 
      i++;
      /* Track the item height separately in case the item is multi-line. */
      item_y += h + RETROGUI_PADDING;
   }
 
cleanup:
 
   if( autolock ) {
      mdata_vector_unlock( &(ctl->LISTBOX.list) );
   }
 
   if( MERROR_OK != retval ) {
      error_printf( "error drawing LISTBOX: %d", retval );
   }
 
#  endif
 
}
 
MERROR_RETVAL retrogui_select_listbox_item(
   union RETROGUI_CTL* ctl, size_t item_idx
) {
   MERROR_RETVAL retval = MERROR_OK;
 
#  if defined( RETROGUI_NATIVE_WIN )
 
   /* Select sel_idx. */
   SendMessage( ctl->base.hwnd, LB_SETCURSEL, item_idx, 0 );
 
#  else
 
   ctl->LISTBOX.sel_idx = item_idx;
 
#  endif
 
   return retval;
}
 
MERROR_RETVAL retrogui_push_listbox_item(
   struct RETROGUI* gui, retrogui_idc_t idc, const char* item, size_t item_sz
) {
   MERROR_RETVAL retval = MERROR_OK;
   union RETROGUI_CTL* ctl = NULL;
   int autolock = 0;
   retrogui_list_t item_stage;
   ssize_t i = 0;
 
   if( !mdata_vector_is_locked( &((gui)->ctls) ) ) {
      mdata_vector_lock( &(gui->ctls) );
      autolock = 1;
   }
 
#if RETROGUI_TRACE_LVL > 0
   debug_printf( RETROGUI_TRACE_LVL,
      "pushing item \"%s\" to listbox " RETROGUI_IDC_FMT "...", item, idc );
#endif /* RETROGUI_TRACE_LVL */
 
   ctl = _retrogui_get_ctl_by_idc( gui, idc );
   if( NULL == ctl ) {
      /* Elaborate on error from _retrogui_get_ctl_by_idc(). */
      error_printf( "could not add item: %s", item );
      retval = MERROR_GUI;
      goto cleanup;
   }
   
#  if defined( RETROGUI_NATIVE_WIN )
 
   SendMessage( ctl->LISTBOX.base.hwnd, LB_ADDSTRING, 0, (LPARAM)item );
 
#  else
 
   maug_mzero( item_stage, RETROGUI_CTL_LISTBOX_STR_SZ_MAX + 1 );
   maug_strncpy( item_stage, item, RETROGUI_CTL_LISTBOX_STR_SZ_MAX );
   i = mdata_vector_append(
      &(ctl->LISTBOX.list), item_stage, RETROGUI_CTL_LISTBOX_STR_SZ_MAX + 1 );
   if( 0 > i ) {
      retval = merror_sz_to_retval( i );
   }
 
#endif
 
   gui->flags |= RETROGUI_FLAGS_DIRTY;
 
cleanup:
 
   if( autolock ) {
      mdata_vector_unlock( &(gui->ctls) );
   }
 
   return retval;
}
 
static MERROR_RETVAL retrogui_push_LISTBOX( union RETROGUI_CTL* ctl ) {
   MERROR_RETVAL retval = MERROR_OK;
 
#  if defined( RETROGUI_NATIVE_WIN )
 
   ctl->base.hwnd = CreateWindow(
      "LISTBOX", NULL, WS_CHILD | WS_VISIBLE | LBS_STANDARD,
      gui->x + ctl->base.x, gui->y + ctl->base.y, ctl->base.w, ctl->base.h,
      g_retroflat_state->window, (HMENU)(ctl->base.idc),
      g_retroflat_instance, NULL );
#if RETROGUI_TRACE_LVL > 0
   debug_printf( RETROGUI_TRACE_LVL,
      "listbox hwnd: %p", ctl->LISTBOX.base.hwnd );
#endif /* RETROGUI_TRACE_LVL */
   if( (HWND)NULL == ctl->base.hwnd ) {
      error_printf( "could not create listbox" );
      retval = MERROR_GUI;
      goto cleanup;
   }
 
   gui->flags |= RETROGUI_FLAGS_DIRTY;
 
cleanup:
 
#  else
 
   /* TODO? */
 
#  endif
 
   return retval;
}
 
static MERROR_RETVAL retrogui_sz_LISTBOX(
   struct RETROGUI* gui, union RETROGUI_CTL* ctl,
   retroflat_pxxy_t* p_w, retroflat_pxxy_t* p_h,
   retroflat_pxxy_t max_w, retroflat_pxxy_t max_h
) {
   MERROR_RETVAL retval = MERROR_GUI;
   /* TODO */
   return retval;
}
 
static MERROR_RETVAL retrogui_pos_LISTBOX(
   struct RETROGUI* gui, union RETROGUI_CTL* ctl,
   retroflat_pxxy_t x, retroflat_pxxy_t y,
   retroflat_pxxy_t w, retroflat_pxxy_t h
) {
   MERROR_RETVAL retval = MERROR_GUI;
   /* TODO */
   return retval;
}
 
static void retrogui_destroy_LISTBOX( union RETROGUI_CTL* ctl ) {
   mdata_vector_free( &(ctl->LISTBOX.list) );
}
 
static MERROR_RETVAL retrogui_init_LISTBOX( union RETROGUI_CTL* ctl ) {
   MERROR_RETVAL retval = MERROR_OK;
 
#if RETROGUI_TRACE_LVL > 0
   debug_printf( RETROGUI_TRACE_LVL,
      "initializing listbox " RETROGUI_IDC_FMT "...", ctl->base.idc );
#endif /* RETROGUI_IDC_FMT */
 
   ctl->base.bg_color = RETROFLAT_COLOR_WHITE;
   ctl->base.sel_fg = RETROFLAT_COLOR_WHITE;
   if( 2 < retroflat_screen_colors() ) {
      ctl->base.sel_bg = RETROFLAT_COLOR_BLUE;
      ctl->base.fg_color = RETROGUI_COLOR_BORDER;
   } else {
      ctl->base.sel_bg = RETROFLAT_COLOR_BLACK;
      ctl->base.fg_color = RETROFLAT_COLOR_BLACK;
   }
 
   return retval;
}
 
/* === Control: BUTTON === */
 
static retrogui_idc_t retrogui_click_BUTTON( 
   struct RETROGUI* gui,
   union RETROGUI_CTL* ctl, RETROFLAT_IN_KEY* p_input,
   struct RETROFLAT_INPUT* input_evt
) {
   retrogui_idc_t idc_out = RETROGUI_IDC_NONE;
 
   if( 0 < ctl->BUTTON.push_frames ) {
      goto cleanup;
   }
 
   /* Set the last button clicked. */
   idc_out = ctl->base.idc;
 
   /* Set the frames to show the pushed-in view. */
   /* TODO: Use a constant, here. */
   ctl->BUTTON.push_frames = 3;
 
cleanup:
 
   return idc_out;
}
 
static retrogui_idc_t retrogui_key_BUTTON( 
   struct RETROGUI* gui, union RETROGUI_CTL* ctl, RETROFLAT_IN_KEY* p_input,
   struct RETROFLAT_INPUT* input_evt
) {
   retrogui_idc_t idc_out = RETROGUI_IDC_NONE;
 
   /* Set the last button clicked. Only set out on ENTER/SPACE. */
   if(
      retroflat_or_key( *p_input, RETROGUI_KEY_ACTIVATE, RETROGUI_PAD_ACTIVATE )
   ) {
#if RETROGUI_TRACE_LVL > 0
      debug_printf( RETROGUI_TRACE_LVL, "pushing BUTTON control..." );
#endif /* RETROGUI_TRACE_LVL */
      idc_out = ctl->base.idc;
   }
 
   return idc_out;
}
 
static void retrogui_redraw_BUTTON(
   struct RETROGUI* gui, union RETROGUI_CTL* ctl
) {
   retroflat_pxxy_t w = 0,
      h = 0,
      text_offset = 0;
   RETROFLAT_COLOR fg_color = ctl->base.fg_color;
   RETROFLAT_COLOR bg_color = ctl->base.bg_color;
   RETROFLAT_COLOR push_shadow_color = RETROFLAT_COLOR_DARKGRAY;
   RETROFLAT_COLOR border_color = RETROGUI_COLOR_BORDER;
   MAUG_MHANDLE font_h = (MAUG_MHANDLE)NULL;
 
   if( ctl->base.idc == gui->focus_idc ) {
      /* Assign selected color if focused. */
      fg_color = ctl->base.sel_fg;
   }
 
   if( ctl->base.idc == gui->focus_idc ) {
      /* Assign selected color if focused. */
      bg_color = ctl->base.sel_bg;
   }
 
   /* Figure out push shadow color for current color depth. */
   if( 2 >= retroflat_screen_colors() ) {
      push_shadow_color = RETROFLAT_COLOR_BLACK;
      border_color = RETROFLAT_COLOR_BLACK;
   }
 
   retroflat_2d_rect(
      gui->draw_bmp, bg_color, gui->x + ctl->base.x, gui->y + ctl->base.y,
      ctl->base.w, ctl->base.h, RETROFLAT_DRAW_FLAG_FILL );
 
   retroflat_2d_rect( gui->draw_bmp, border_color,
      gui->x + ctl->base.x, gui->y + ctl->base.y,
      ctl->base.w, ctl->base.h, 0 );
 
   /* Draw the push shadows on top/left or bottom/right, depending on pushed
    * status.
    */
   if( 0 < ctl->BUTTON.push_frames ) {
      retroflat_2d_line(
         gui->draw_bmp, push_shadow_color,
         gui->x + ctl->base.x + 1, gui->y + ctl->base.y + 1,
         gui->x + ctl->base.x + ctl->base.w - 2, gui->y + ctl->base.y + 1, 0 );
      retroflat_2d_line(
         gui->draw_bmp, push_shadow_color,
         gui->x + ctl->base.x + 1, gui->y + ctl->base.y + 2,
         gui->x + ctl->base.x + 1, gui->y + ctl->base.y + ctl->base.h - 3, 0 );
 
      gui->flags |= RETROGUI_FLAGS_DIRTY; /* Mark dirty for push animation. */
      ctl->BUTTON.push_frames--;
      text_offset = 1;
   } else {
      /* Button is not pushed. */
      retroflat_2d_line(
         gui->draw_bmp, RETROFLAT_COLOR_WHITE,
         gui->x + ctl->base.x + 1, gui->y + ctl->base.y + 1,
         gui->x + ctl->base.x + ctl->base.w - 2, gui->y + ctl->base.y + 1, 0 );
      retroflat_2d_line(
         gui->draw_bmp, RETROFLAT_COLOR_WHITE,
         gui->x + ctl->base.x + 1, gui->y + ctl->base.y + 2,
         gui->x + ctl->base.x + 1, gui->y + ctl->base.y + ctl->base.h - 3, 0 );
   }
 
   maug_mlock( ctl->BUTTON.label_h, ctl->BUTTON.label );
   if( NULL == ctl->BUTTON.label ) {
      error_printf( "could not lock BUTTON label!" );
      goto cleanup;
   }
      
   /* Grab the string size and use it to center the text in the control. */
#ifdef RETROGXC_PRESENT
   font_h = retrogxc_get_asset(
      gui->font.cache_idx, RETROGXC_ASSET_TYPE_FONT );
   if( (MAUG_MHANDLE)NULL == font_h ) {
      goto cleanup;
   }
#else
   font_h = gui->font.handle;
#endif /* RETROGXC_PRESENT */
   retrofont_string_sz(
      gui->draw_bmp, ctl->BUTTON.label, 0, font_h,
      ctl->base.w, ctl->base.h, &w, &h, ctl->BUTTON.font_flags );
 
   retrofont_string(
      gui->draw_bmp, fg_color, ctl->BUTTON.label, 0, font_h,
      gui->x + ctl->base.x + ((ctl->base.w >> 1) - (w >> 1)) + text_offset,
      gui->y + ctl->base.y + ((ctl->base.h >> 1) - (h >> 1)) + text_offset,
      /* TODO: Pad max client area. */
      ctl->base.w, ctl->base.h, ctl->BUTTON.font_flags );
 
   maug_munlock( ctl->BUTTON.label_h, ctl->BUTTON.label );
 
cleanup:
 
   return;
}
 
static MERROR_RETVAL retrogui_push_BUTTON( union RETROGUI_CTL* ctl ) {
   MERROR_RETVAL retval = MERROR_OK;
 
#  if defined( RETROGUI_NATIVE_WIN )
 
   ctl->base.hwnd = CreateWindow(
      "BUTTON", ctl->BUTTON.label, WS_CHILD | WS_VISIBLE | BS_DEFPUSHBUTTON,
      gui->x + ctl->base.x, gui->y + ctl->base.y, ctl->base.w, ctl->base.h,
      g_retroflat_state->window, (HMENU)(ctl->base.idc),
      g_retroflat_instance, NULL );
   if( (HWND)NULL == ctl->base.hwnd ) {
      retroflat_message( RETROFLAT_MSG_FLAG_ERROR, "Error",
         "Could not create button " RETROGUI_IDC_FMT ": %s",
         ctl->base.idc, ctl->BUTTON.label );
      retval = MERROR_GUI;
      goto cleanup;
   }
 
#  else
   char* label_tmp = NULL;
 
#if RETROGUI_TRACE_LVL > 0
   debug_printf( RETROGUI_TRACE_LVL, "pushing BUTTON control..." );
#endif /* RETROGUI_TRACE_LVL */
 
   _retrogui_copy_str(
      label, ctl->BUTTON.label, ctl->BUTTON, label_tmp, ctl->BUTTON.label_sz );
   ctl->BUTTON.label = NULL;
#  endif
 
cleanup:
 
   return retval;
}
 
static MERROR_RETVAL retrogui_sz_BUTTON(
   struct RETROGUI* gui, union RETROGUI_CTL* ctl,
   retroflat_pxxy_t* p_w, retroflat_pxxy_t* p_h,
   retroflat_pxxy_t max_w, retroflat_pxxy_t max_h
) {
   MERROR_RETVAL retval = MERROR_OK;
   MAUG_MHANDLE font_h = (MAUG_MHANDLE)NULL;
 
   assert( NULL != ctl );
   assert( NULL == ctl->BUTTON.label );
   assert( (MAUG_MHANDLE)NULL != ctl->BUTTON.label_h );
 
   maug_mlock( ctl->BUTTON.label_h, ctl->BUTTON.label );
   maug_cleanup_if_null_lock( char*, ctl->BUTTON.label );
 
   /* Get the size of the text-based GUI item. */
#ifdef RETROGXC_PRESENT
   font_h = retrogxc_get_asset(
      gui->font.cache_idx, RETROGXC_ASSET_TYPE_FONT );
   maug_cleanup_if_null_alloc( MAUG_MHANDLE, font_h );
#else
   font_h = gui->font.handle;
#endif /* RETROGXC_PRESENT */
   retrofont_string_sz(
      NULL, ctl->BUTTON.label, 0, font_h,
      max_w - 8, max_h - 8, p_w, p_h, ctl->BUTTON.font_flags );
 
   /* Add space for borders and stuff. */
   *p_w += RETROGUI_BTN_LBL_PADDED_X;
   *p_h += RETROGUI_BTN_LBL_PADDED_Y;
 
cleanup:
 
   maug_munlock( ctl->BUTTON.label_h, ctl->BUTTON.label );
 
   return retval;
}
 
static MERROR_RETVAL retrogui_pos_BUTTON(
   struct RETROGUI* gui, union RETROGUI_CTL* ctl,
   retroflat_pxxy_t x, retroflat_pxxy_t y,
   retroflat_pxxy_t w, retroflat_pxxy_t h
) {
   MERROR_RETVAL retval = MERROR_OK;
 
#  if defined( RETROGUI_NATIVE_WIN )
   /* TODO */
#  else
   assert( NULL != ctl );
 
   ctl->base.x = x;
   ctl->base.y = y;
   if( 0 < w ) {
      ctl->base.w = w;
   }
   if( 0 < h ) {
      ctl->base.h = h;
   }
#  endif /* RETROGUI_NATIVE_WIN */
 
   return retval;
}
 
static void retrogui_destroy_BUTTON( union RETROGUI_CTL* ctl ) {
   if( (MAUG_MHANDLE)NULL != ctl->BUTTON.label_h ) {
      maug_mfree( ctl->BUTTON.label_h );
   }
}
 
static MERROR_RETVAL retrogui_init_BUTTON( union RETROGUI_CTL* ctl ) {
   MERROR_RETVAL retval = MERROR_OK;
 
#if RETROGUI_TRACE_LVL > 0
   debug_printf( RETROGUI_TRACE_LVL,
      "initializing button " RETROGUI_IDC_FMT "...", ctl->base.idc );
#endif /* RETROGUI_TRACE_LVL */
 
   if( 2 < retroflat_screen_colors() ) {
      ctl->base.fg_color = RETROGUI_COLOR_BORDER;
      ctl->base.bg_color = RETROFLAT_COLOR_GRAY;
      ctl->base.sel_fg = RETROFLAT_COLOR_BLUE;
      ctl->base.sel_bg = RETROFLAT_COLOR_GRAY;
   } else {
      ctl->base.fg_color = RETROFLAT_COLOR_BLACK;
      ctl->base.bg_color = RETROFLAT_COLOR_WHITE;
      ctl->base.sel_fg = RETROFLAT_COLOR_WHITE;
      ctl->base.sel_bg = RETROFLAT_COLOR_BLACK;
   }
 
   return retval;
}
 
#ifndef RETROGUI_NO_TEXTBOX
 
/* === Control: TEXTBOX === */
 
static retrogui_idc_t retrogui_click_TEXTBOX(
   struct RETROGUI* gui,
   union RETROGUI_CTL* ctl, RETROFLAT_IN_KEY* p_input,
   struct RETROFLAT_INPUT* input_evt
) {
   retrogui_idc_t idc_out = RETROGUI_IDC_NONE;
 
   return idc_out;
}
 
static retrogui_idc_t retrogui_key_TEXTBOX(
   struct RETROGUI* gui, union RETROGUI_CTL* ctl, RETROFLAT_IN_KEY* p_input,
   struct RETROFLAT_INPUT* input_evt
) {
   retrogui_idc_t idc_out = RETROGUI_IDC_NONE;
   char c = '\0';
 
#  if defined( RETROGUI_NATIVE_WIN )
   /* Do nothing. */
#  else
 
   c = retroflat_vk_to_ascii( *p_input, input_evt->key_flags );
 
   /* Ignore non-printable characters. */
   if(
      0 == c &&
      RETROFLAT_KEY_RIGHT != *p_input &&
      RETROFLAT_KEY_LEFT != *p_input
   ) {
      goto cleanup;
   }
 
   /* Lock text field. */
   assert( NULL == ctl->TEXTBOX.text );
   assert( (MAUG_MHANDLE)NULL != ctl->TEXTBOX.text_h );
   maug_mlock( ctl->TEXTBOX.text_h, ctl->TEXTBOX.text );
   if( NULL == ctl->TEXTBOX.text ) {
      error_printf( "could not lock TEXTBOX text handle!" );
      goto cleanup;
   }
 
   switch( *p_input ) {
   case RETROFLAT_KEY_BKSP:
      retroflat_buffer_bksp(
         ctl->TEXTBOX.text, ctl->TEXTBOX.text_cur, ctl->TEXTBOX.text_sz )
      break;
 
   case RETROFLAT_KEY_ENTER:
      idc_out = ctl->base.idc;
      break;
 
   case RETROFLAT_KEY_LEFT:
      if( 0 < ctl->TEXTBOX.text_cur ) {
         ctl->TEXTBOX.text_cur--;
      }
      break;
 
   case RETROFLAT_KEY_RIGHT:
      if( ctl->TEXTBOX.text_sz > ctl->TEXTBOX.text_cur ) {
         ctl->TEXTBOX.text_cur++;
      }
      break;
 
   default:
      assert( ctl->TEXTBOX.text_sz < ctl->TEXTBOX.text_sz_max );
      debug_printf( 1, "cur: %d, sz: %d, sz_max: %d",
         ctl->TEXTBOX.text_cur, ctl->TEXTBOX.text_sz, ctl->TEXTBOX.text_sz_max );
      retroflat_buffer_insert( c, 
         ctl->TEXTBOX.text,
         ctl->TEXTBOX.text_cur,
         ctl->TEXTBOX.text_sz,
         ctl->TEXTBOX.text_sz_max );
      break;
   }
 
   /* TODO: Remove input from queue? */
 
cleanup:
 
   if( NULL != ctl->TEXTBOX.text ) {
      maug_munlock( ctl->TEXTBOX.text_h, ctl->TEXTBOX.text );
   }
 
#  endif
 
   return idc_out;
}
 
static void retrogui_redraw_TEXTBOX(
   struct RETROGUI* gui, union RETROGUI_CTL* ctl
) {
   RETROFLAT_COLOR shadow_color = RETROFLAT_COLOR_DARKGRAY;
   RETROFLAT_COLOR border_color = RETROGUI_COLOR_BORDER;
   retroflat_pxxy_t cursor_x = 0,
      cursor_y = 0;
   MAUG_MHANDLE font_h = (MAUG_MHANDLE)NULL;
 
   /* Adjust shadow colors for monochrome. */
   if( 2 >= retroflat_screen_colors() ) {
      shadow_color = RETROFLAT_COLOR_BLACK;
      border_color = RETROFLAT_COLOR_BLACK;
   }
 
#  if defined( RETROGUI_NATIVE_WIN )
   /* Do nothing. */
#  else
 
   retroflat_2d_rect( gui->draw_bmp, ctl->base.bg_color,
      gui->x + ctl->base.x, gui->y + ctl->base.y,
      ctl->base.w, ctl->base.h, RETROFLAT_DRAW_FLAG_FILL );
 
   /* Draw chiselled inset border. */
 
   retroflat_2d_rect( gui->draw_bmp, border_color,
      gui->x + ctl->base.x,
      gui->y + ctl->base.y, ctl->base.w, 2,
      RETROFLAT_DRAW_FLAG_FILL );
 
   retroflat_2d_rect( gui->draw_bmp, border_color,
      gui->x + ctl->base.x,
      gui->y + ctl->base.y, 2, ctl->base.h,
      RETROFLAT_DRAW_FLAG_FILL );
 
   retroflat_2d_rect( gui->draw_bmp, shadow_color,
      gui->x + ctl->base.x,
      gui->y + ctl->base.y + ctl->base.h - 1,
      ctl->base.w, 2,
      RETROFLAT_DRAW_FLAG_FILL );
 
   retroflat_2d_rect( gui->draw_bmp, shadow_color,
       gui->x + ctl->base.x + ctl->base.w - 1,
       gui->y + ctl->base.y, 2, ctl->base.h,
      RETROFLAT_DRAW_FLAG_FILL );
 
   /* Draw text. */
 
   assert( NULL == ctl->TEXTBOX.text );
   maug_mlock( ctl->TEXTBOX.text_h, ctl->TEXTBOX.text );
   if( NULL == ctl->TEXTBOX.text ) {
      goto cleanup;
   }
 
#ifdef RETROGXC_PRESENT
   font_h = retrogxc_get_asset(
      gui->font.cache_idx, RETROGXC_ASSET_TYPE_FONT );
   if( (MAUG_MHANDLE)NULL == font_h ) {
      goto cleanup;
   }
#else
   font_h = gui->font.handle;
#endif /* RETROGXC_PRESENT */
   retrofont_string(
      gui->draw_bmp, ctl->base.fg_color,
      ctl->TEXTBOX.text, ctl->TEXTBOX.text_cur, font_h,
      gui->x + ctl->base.x + RETROGUI_PADDING,
      gui->y + ctl->base.y + RETROGUI_PADDING, ctl->base.w, ctl->base.h, 0 );
 
   /* Get the line size for cursor placement below. */
   retrofont_string_sz(
      gui->draw_bmp, ctl->TEXTBOX.text, ctl->TEXTBOX.text_cur, font_h,
      ctl->base.w, ctl->base.h, &cursor_x, &cursor_y, RETROFONT_FLAG_SZ_MIN );
 
   if( cursor_x + RETROGUI_CTL_TEXT_CUR_WH >= ctl->base.w ) {
      cursor_x = 0;
      /* TODO: Use font height. */
      cursor_y += RETROGUI_CTL_TEXT_CUR_WH;
   }
 
   /* Use same padding as font for cursor. */
   retroflat_2d_rect( gui->draw_bmp,
      ctl->base.sel_fg,
      gui->x + ctl->base.x + RETROGUI_PADDING + cursor_x,
      gui->y + ctl->base.y + RETROGUI_PADDING + cursor_y,
      RETROGUI_CTL_TEXT_CUR_WH, RETROGUI_CTL_TEXT_CUR_WH,
      /* Draw blinking cursor. */
      /* TODO: Use a global timer to mark this field dirty. */
      gui->focus_idc == ctl->base.idc &&
         0 < ctl->TEXTBOX.blink_frames ? RETROFLAT_DRAW_FLAG_FILL : 0 );
 
   if( (-1 * RETROGUI_CTL_TEXT_BLINK_FRAMES) > --(ctl->TEXTBOX.blink_frames) ) {
      ctl->TEXTBOX.blink_frames = RETROGUI_CTL_TEXT_BLINK_FRAMES;
   }
 
   if( NULL != ctl->TEXTBOX.text ) {
      /* Draw the text that comes after the cursor. */
#ifdef RETROGXC_PRESENT
   font_h = retrogxc_get_asset(
      gui->font.cache_idx, RETROGXC_ASSET_TYPE_FONT );
   if( (MAUG_MHANDLE)NULL == font_h ) {
      goto cleanup;
   }
#else
   font_h = gui->font.handle;
#endif /* RETROGXC_PRESENT */
   retrofont_string_indent(
      gui->draw_bmp, ctl->base.fg_color,
      &(ctl->TEXTBOX.text[ctl->TEXTBOX.text_cur]),
      /* Chop off chars from first half. */
      strlen( ctl->TEXTBOX.text ) - ctl->TEXTBOX.text_cur, font_h,
      gui->x + ctl->base.x + RETROGUI_PADDING,
      /* Post-cursor line beings on cursor line. */
      gui->y + ctl->base.y + RETROGUI_PADDING + cursor_y,
      ctl->base.w, ctl->base.h,
      cursor_x + RETROGUI_CTL_TEXT_CUR_WH, 0 );
  
      maug_munlock( ctl->TEXTBOX.text_h, ctl->TEXTBOX.text );
   }
 
   gui->flags |= RETROGUI_FLAGS_DIRTY; /* Mark dirty for blink animation. */
 
cleanup:
 
#  endif
 
   return;
}
 
static MERROR_RETVAL retrogui_push_TEXTBOX( union RETROGUI_CTL* ctl ) {
   MERROR_RETVAL retval = MERROR_OK;
 
#  if defined( RETROGUI_NATIVE_WIN )
 
   ctl->base.hwnd = CreateWindow(
      "EDIT", 0, WS_CHILD | WS_VISIBLE | WS_BORDER,
      gui->x + ctl->base.x, gui->y + ctl->base.y, ctl->base.w, ctl->base.h,
      g_retroflat_state->window, (HMENU)(ctl->base.idc),
      g_retroflat_instance, NULL );
   if( (HWND)NULL == ctl->base.hwnd ) {
      retroflat_message( RETROFLAT_MSG_FLAG_ERROR, "Error",
         "Could not create textbox: " RETROGUI_IDC_FMT, ctl->base.idc );
      retval = MERROR_GUI;
      goto cleanup;
   }
 
#  else
 
#if RETROGUI_TRACE_LVL > 0
   debug_printf( RETROGUI_TRACE_LVL,
      "clearing textbox " RETROGUI_IDC_FMT " buffer...", ctl->base.idc );
#endif /* RETROGUI_TRACE_LVL */
   assert( (MAUG_MHANDLE)NULL == ctl->TEXTBOX.text_h );
   maug_malloc_test( ctl->TEXTBOX.text_h, RETROGUI_CTL_TEXT_SZ_MAX + 1, 1 );
   ctl->TEXTBOX.text_sz_max = RETROGUI_CTL_TEXT_SZ_MAX;
 
   maug_mlock( ctl->TEXTBOX.text_h, ctl->TEXTBOX.text );
   maug_cleanup_if_null_alloc( char*, ctl->TEXTBOX.text );
#if RETROGUI_TRACE_LVL > 0
   debug_printf( RETROGUI_TRACE_LVL,
      "clearing textbox " RETROGUI_IDC_FMT " buffer...", ctl->base.idc );
#endif /* RETROGUI_TRACE_LVL */
   maug_mzero( ctl->TEXTBOX.text, RETROGUI_CTL_TEXT_SZ_MAX + 1 );
   maug_munlock( ctl->TEXTBOX.text_h, ctl->TEXTBOX.text );
 
#  endif
 
cleanup:
 
   return retval;
}
 
static MERROR_RETVAL retrogui_sz_TEXTBOX(
   struct RETROGUI* gui, union RETROGUI_CTL* ctl,
   retroflat_pxxy_t* p_w, retroflat_pxxy_t* p_h,
   retroflat_pxxy_t max_w, retroflat_pxxy_t max_h
) {
   MERROR_RETVAL retval = MERROR_GUI;
   /* TODO */
   return retval;
}
 
static MERROR_RETVAL retrogui_pos_TEXTBOX(
   struct RETROGUI* gui, union RETROGUI_CTL* ctl,
   retroflat_pxxy_t x, retroflat_pxxy_t y,
   retroflat_pxxy_t w, retroflat_pxxy_t h
) {
   MERROR_RETVAL retval = MERROR_GUI;
   /* TODO */
   return retval;
}
 
static void retrogui_destroy_TEXTBOX( union RETROGUI_CTL* ctl ) {
   if( (MAUG_MHANDLE)NULL != ctl->TEXTBOX.text_h ) {
      maug_mfree( ctl->TEXTBOX.text_h );
   }
}
 
static MERROR_RETVAL retrogui_init_TEXTBOX( union RETROGUI_CTL* ctl ) {
   MERROR_RETVAL retval = MERROR_OK;
 
#if RETROGUI_TRACE_LVL > 0
   debug_printf( RETROGUI_TRACE_LVL,
      "initializing textbox " RETROGUI_IDC_FMT "...", ctl->base.idc );
#endif /* RETROGUI_TRACE_LVL */
 
   ctl->base.bg_color = RETROFLAT_COLOR_WHITE;
   ctl->base.sel_bg = RETROFLAT_COLOR_WHITE;
   if( 2 < retroflat_screen_colors() ) {
      ctl->base.sel_fg = RETROFLAT_COLOR_BLUE;
      ctl->base.fg_color = RETROGUI_COLOR_BORDER;
   } else {
      ctl->base.sel_fg = RETROFLAT_COLOR_BLACK;
      ctl->base.fg_color = RETROFLAT_COLOR_BLACK;
   }
 
   return retval;
}
 
#endif /* RETROGUI_NO_TEXTBOX */
 
/* === Control: LABEL === */
 
static retrogui_idc_t retrogui_click_LABEL(
   struct RETROGUI* gui,
   union RETROGUI_CTL* ctl, RETROFLAT_IN_KEY* p_input,
   struct RETROFLAT_INPUT* input_evt
) {
   return RETROGUI_IDC_NONE;
}
 
static retrogui_idc_t retrogui_key_LABEL(
   struct RETROGUI* gui, union RETROGUI_CTL* ctl, RETROFLAT_IN_KEY* p_input,
   struct RETROFLAT_INPUT* input_evt
) {
   return RETROGUI_IDC_NONE;
}
 
static void retrogui_redraw_LABEL(
   struct RETROGUI* gui, union RETROGUI_CTL* ctl
) {
   size_t show_sz = 0;
   MAUG_MHANDLE font_h = (MAUG_MHANDLE)NULL;
 
#  if defined( RETROGUI_NATIVE_WIN )
   /* Do nothing. */
#  else
 
   /* Draw text. */
 
   assert( NULL == ctl->LABEL.label );
   maug_mlock( ctl->LABEL.label_h, ctl->LABEL.label );
   if( NULL == ctl->LABEL.label ) {
      error_printf( "could not lock LABEL text!" );
      goto cleanup;
   }
 
   if(
      RETROGUI_LABEL_FLAG_SHOWINC ==
      (RETROGUI_LABEL_FLAG_SHOWINC & ctl->LABEL.flags)
   ) {
      if( 0 < ctl->LABEL.show_ticks ) {
         /* Increment timer to hold on this much of the label. */
         ctl->LABEL.show_ticks--;
         show_sz = ctl->LABEL.shown_sz;
         if( ctl->LABEL.shown_sz < ctl->LABEL.label_sz ) {
            gui->flags |= RETROGUI_FLAGS_DIRTY;
         }
 
      } else {
         /* Reset ticks counter. */
         ctl->LABEL.show_ticks =
            RETROGUI_LABEL_FLAG_SHOWINC_SLOW ==
            (RETROGUI_LABEL_FLAG_SHOWINC_SLOW & ctl->LABEL.flags) ?
               RETROGUI_LABEL_SHOW_TICKS_MAX * 2 :
               RETROGUI_LABEL_SHOW_TICKS_MAX;
 
         /* Work out how much of the label to show this time. */
         show_sz = ctl->LABEL.shown_sz + RETROGUI_LABEL_SHOW_INC;
         if( show_sz > ctl->LABEL.label_sz ) {
            /* Trim down show size to label size. */
            show_sz = ctl->LABEL.label_sz;
         } else {
            /* Not done showing yet! */
            gui->flags |= RETROGUI_FLAGS_DIRTY;
         }
 
         /* Finalize whatever decision we came to above. */
         ctl->LABEL.shown_sz = show_sz;
      }
 
   } else {
      show_sz = ctl->LABEL.label_sz;
   }
 
#ifdef RETROGXC_PRESENT
   font_h = retrogxc_get_asset(
      gui->font.cache_idx, RETROGXC_ASSET_TYPE_FONT );
   if( (MAUG_MHANDLE)NULL == font_h ) {
      goto cleanup;
   }
#else
   font_h = gui->font.handle;
#endif /* RETROGXC_PRESENT */
   retrofont_string(
      gui->draw_bmp, ctl->base.fg_color, ctl->LABEL.label, show_sz, font_h,
      gui->x + ctl->base.x + RETROGUI_PADDING,
      gui->y + ctl->base.y + RETROGUI_PADDING, ctl->base.w, ctl->base.h,
      ctl->LABEL.font_flags );
 
cleanup:
 
   if( NULL != ctl->LABEL.label ) {
      maug_munlock( ctl->LABEL.label_h, ctl->LABEL.label );
   }
 
#  endif
 
   return;
}
 
static MERROR_RETVAL retrogui_push_LABEL( union RETROGUI_CTL* ctl ) {
   MERROR_RETVAL retval = MERROR_OK;
 
#  if defined( RETROGUI_NATIVE_WIN )
 
   /* TODO */
 
#  else
   char* label_tmp = NULL;
 
#if RETROGUI_TRACE_LVL > 0
   debug_printf( RETROGUI_TRACE_LVL, "pushing LABEL control..." );
#endif /* RETROGUI_TRACE_LVL */
 
   _retrogui_copy_str(
      label, ctl->LABEL.label, ctl->LABEL, label_tmp, ctl->LABEL.label_sz );
   ctl->LABEL.label = NULL;
   ctl->LABEL.shown_sz = 1;
   ctl->LABEL.show_ticks = 
      RETROGUI_LABEL_FLAG_SHOWINC_SLOW ==
      (RETROGUI_LABEL_FLAG_SHOWINC_SLOW & ctl->LABEL.flags) ?
         RETROGUI_LABEL_SHOW_TICKS_MAX * 2 :
         RETROGUI_LABEL_SHOW_TICKS_MAX;
#  endif
 
cleanup:
 
   return retval;
}
 
static MERROR_RETVAL retrogui_sz_LABEL(
   struct RETROGUI* gui, union RETROGUI_CTL* ctl,
   retroflat_pxxy_t* p_w, retroflat_pxxy_t* p_h,
   retroflat_pxxy_t max_w, retroflat_pxxy_t max_h
) {
   MERROR_RETVAL retval = MERROR_GUI;
   /* TODO */
   return retval;
}
 
static MERROR_RETVAL retrogui_pos_LABEL(
   struct RETROGUI* gui, union RETROGUI_CTL* ctl,
   retroflat_pxxy_t x, retroflat_pxxy_t y,
   retroflat_pxxy_t w, retroflat_pxxy_t h
) {
   MERROR_RETVAL retval = MERROR_GUI;
   /* TODO */
   return retval;
}
 
static void retrogui_destroy_LABEL( union RETROGUI_CTL* ctl ) {
   if( (MAUG_MHANDLE)NULL != ctl->LABEL.label_h ) {
      maug_mfree( ctl->LABEL.label_h );
   }
}
 
static MERROR_RETVAL retrogui_init_LABEL( union RETROGUI_CTL* ctl ) {
   MERROR_RETVAL retval = MERROR_OK;
 
#if RETROGUI_TRACE_LVL > 0
   debug_printf( RETROGUI_TRACE_LVL,
      "initializing label " RETROGUI_IDC_FMT "...", ctl->base.idc );
#endif /* RETROGUI_TRACE_LVL */
 
   if( 2 < retroflat_screen_colors() ) {
      ctl->base.fg_color = RETROGUI_COLOR_BORDER;
   } else {
      ctl->base.fg_color = RETROFLAT_COLOR_BLACK;
   }
   ctl->base.bg_color = RETROFLAT_COLOR_WHITE;
 
   return retval;
}
 
/* === Control: IMAGE === */
 
static retrogui_idc_t retrogui_click_IMAGE(
   struct RETROGUI* gui,
   union RETROGUI_CTL* ctl, RETROFLAT_IN_KEY* p_input,
   struct RETROFLAT_INPUT* input_evt
) {
   return RETROGUI_IDC_NONE;
}
 
static retrogui_idc_t retrogui_key_IMAGE(
   struct RETROGUI* gui, union RETROGUI_CTL* ctl, RETROFLAT_IN_KEY* p_input,
   struct RETROFLAT_INPUT* input_evt
) {
   return RETROGUI_IDC_NONE;
}
 
static void retrogui_redraw_IMAGE(
   struct RETROGUI* gui, union RETROGUI_CTL* ctl
) {
#  if defined( RETROGUI_NATIVE_WIN )
   /* Do nothing. */
#  else
 
#     if defined( RETROGXC_PRESENT )
   if( 0 <= ctl->IMAGE.image_cache_id ) {
      /* Draw the image from the cache if there is one. */
 
#if RETROGUI_TRACE_LVL > 0
      debug_printf( RETROGUI_TRACE_LVL,
         "redrawing image ctl " RETROGUI_IDC_FMT
         ", cache ID " SSIZE_T_FMT "...",
         ctl->base.idc, ctl->IMAGE.image_cache_id );
#endif /* RETROGUI_TRACE_LVL */
      retrogxc_blit_bitmap(
         gui->draw_bmp,
         ctl->IMAGE.image_cache_id,
         ctl->IMAGE.src_x, ctl->IMAGE.src_y,
         gui->x + ctl->base.x, gui->y + ctl->base.y, ctl->base.w, ctl->base.h,
         ctl->IMAGE.instance );
   } else
#     endif /* RETROGXC_PRESENT */
   if( retroflat_2d_bitmap_ok( &(ctl->IMAGE.image) ) ) {
      /* If no cached image (or cache), try to draw the stored image. */
      retroflat_2d_blit_bitmap(
         gui->draw_bmp,
         &(ctl->IMAGE.image),
         ctl->IMAGE.src_x, ctl->IMAGE.src_y,
         gui->x + ctl->base.x, gui->y + ctl->base.y, ctl->base.w, ctl->base.h,
         ctl->IMAGE.instance );
   }
 
#  endif /* RETROGUI_NATIVE_WIN */
 
   return;
}
 
static MERROR_RETVAL retrogui_push_IMAGE( union RETROGUI_CTL* ctl ) {
   MERROR_RETVAL retval = MERROR_OK;
 
#  if defined( RETROGUI_NATIVE_WIN )
 
   /* TODO */
 
#  else
 
#if RETROGUI_TRACE_LVL > 0
   debug_printf( RETROGUI_TRACE_LVL, "pushing IMAGE control..." );
#endif /* RETROGUI_TRACE_LVL */
 
   assert( !retroflat_2d_bitmap_ok( &(ctl->IMAGE.image) ) );
 
   /* TODO: Copy non-cached image. */
 
   /* ctl->IMAGE.cache_idx = NULL; */
#  endif
 
   return retval;
}
 
static MERROR_RETVAL retrogui_sz_IMAGE(
   struct RETROGUI* gui, union RETROGUI_CTL* ctl,
   retroflat_pxxy_t* p_w, retroflat_pxxy_t* p_h,
   retroflat_pxxy_t max_w, retroflat_pxxy_t max_h
) {
   MERROR_RETVAL retval = MERROR_GUI;
 
   *p_w = 0;
   *p_h = 0;
 
#     ifdef RETROGXC_PRESENT
   retval = retrogxc_bitmap_wh( ctl->IMAGE.image_cache_id, p_w, p_h );
   maug_cleanup_if_not_ok();
#     endif /* RETROGXC_PRESENT */
 
   if(
      0 == *p_w && 0 == *p_h &&
      !retroflat_2d_bitmap_ok( &(ctl->IMAGE.image) )
   ) {
      error_printf( "image not assigned!" );
      retval = MERROR_GUI;
      goto cleanup;
   }
 
   *p_w = retroflat_2d_bitmap_w( &(ctl->IMAGE.image) );
   *p_h = retroflat_2d_bitmap_h( &(ctl->IMAGE.image) );
 
cleanup:
 
   return retval;
}
 
static MERROR_RETVAL retrogui_pos_IMAGE(
   struct RETROGUI* gui, union RETROGUI_CTL* ctl,
   retroflat_pxxy_t x, retroflat_pxxy_t y,
   retroflat_pxxy_t w, retroflat_pxxy_t h
) {
   MERROR_RETVAL retval = MERROR_GUI;
   /* TODO */
   return retval;
}
 
static void retrogui_destroy_IMAGE( union RETROGUI_CTL* ctl ) {
   if( retroflat_2d_bitmap_ok( &(ctl->IMAGE.image) ) ) {
      retroflat_2d_destroy_bitmap( &(ctl->IMAGE.image) );
   }
}
 
static MERROR_RETVAL retrogui_init_IMAGE( union RETROGUI_CTL* ctl ) {
   MERROR_RETVAL retval = MERROR_OK;
 
#if RETROGUI_TRACE_LVL > 0
   debug_printf( RETROGUI_TRACE_LVL,
      "initializing IMAGE " RETROGUI_IDC_FMT "...", ctl->base.idc );
#endif /* RETROGUI_TRACE_LVL */
 
   return retval;
}
 
/* === Control: FILLBAR === */
 
static retrogui_idc_t retrogui_click_FILLBAR( 
   struct RETROGUI* gui,
   union RETROGUI_CTL* ctl, RETROFLAT_IN_KEY* p_input,
   struct RETROFLAT_INPUT* input_evt
) {
   retrogui_idc_t idc_out = RETROGUI_IDC_NONE;
 
   return idc_out;
}
 
static retrogui_idc_t retrogui_key_FILLBAR( 
   struct RETROGUI* gui, union RETROGUI_CTL* ctl, RETROFLAT_IN_KEY* p_input,
   struct RETROFLAT_INPUT* input_evt
) {
   retrogui_idc_t idc_out = RETROGUI_IDC_NONE;
 
   return idc_out;
}
 
static void retrogui_redraw_FILLBAR(
   struct RETROGUI* gui, union RETROGUI_CTL* ctl
) {
   retroflat_pxxy_t fill_w = 0;
 
   if( 0 == ctl->FILLBAR.cur ) {
      fill_w = 0;
   } else {
      fill_w = ctl->base.w * ctl->FILLBAR.cur / ctl->FILLBAR.max;
   }
 
   retroflat_2d_rect(
      gui->draw_bmp, ctl->base.bg_color,
      gui->x + ctl->base.x + fill_w,
      gui->y + ctl->base.y,
      ctl->base.w - fill_w, ctl->base.h, RETROFLAT_DRAW_FLAG_FILL );
 
   retroflat_2d_rect(
      gui->draw_bmp, ctl->base.fg_color,
      gui->x + ctl->base.x, 
      gui->y + ctl->base.y,
      fill_w, ctl->base.h, RETROFLAT_DRAW_FLAG_FILL );
 
   return;
}
 
static MERROR_RETVAL retrogui_push_FILLBAR( union RETROGUI_CTL* ctl ) {
   MERROR_RETVAL retval = MERROR_OK;
 
#  if defined( RETROGUI_NATIVE_WIN )
 
   /* TODO: Native fillbar implementation. */
 
#  endif
 
   return retval;
}
 
static MERROR_RETVAL retrogui_sz_FILLBAR(
   struct RETROGUI* gui, union RETROGUI_CTL* ctl,
   retroflat_pxxy_t* p_w, retroflat_pxxy_t* p_h,
   retroflat_pxxy_t max_w, retroflat_pxxy_t max_h
) {
   MERROR_RETVAL retval = MERROR_OK;
 
   assert( NULL != ctl );
 
   /* TODO? */
 
   return retval;
}
 
static MERROR_RETVAL retrogui_pos_FILLBAR(
   struct RETROGUI* gui, union RETROGUI_CTL* ctl,
   retroflat_pxxy_t x, retroflat_pxxy_t y,
   retroflat_pxxy_t w, retroflat_pxxy_t h
) {
   MERROR_RETVAL retval = MERROR_OK;
 
#  if defined( RETROGUI_NATIVE_WIN )
   /* TODO */
#  else
   assert( NULL != ctl );
 
   ctl->base.x = x;
   ctl->base.y = y;
   if( 0 < w ) {
      ctl->base.w = w;
   }
   if( 0 < h ) {
      ctl->base.h = h;
   }
#  endif /* RETROGUI_NATIVE_WIN */
 
   return retval;
}
 
static void retrogui_destroy_FILLBAR( union RETROGUI_CTL* ctl ) {
}
 
static MERROR_RETVAL retrogui_init_FILLBAR( union RETROGUI_CTL* ctl ) {
   MERROR_RETVAL retval = MERROR_OK;
 
#if RETROGUI_TRACE_LVL > 0
   debug_printf( RETROGUI_TRACE_LVL,
      "initializing fillbar " RETROGUI_IDC_FMT "...", ctl->base.idc );
#endif /* RETROGUI_TRACE_LVL */
 
   if( 2 < retroflat_screen_colors() ) {
      ctl->base.fg_color = RETROGUI_COLOR_BORDER;
      ctl->base.bg_color = RETROFLAT_COLOR_GRAY;
   } else {
      ctl->base.fg_color = RETROFLAT_COLOR_BLACK;
      ctl->base.bg_color = RETROFLAT_COLOR_WHITE;
   }
 
   return retval;
}
 
/* === Static Internal Functions === */
 
static union RETROGUI_CTL* _retrogui_get_ctl_by_idc(
   struct RETROGUI* gui, retrogui_idc_t idc
) {
   size_t i = 0;
   union RETROGUI_CTL* ctl = NULL;
 
   assert( mdata_vector_is_locked( &((gui)->ctls) ) );
 
   for( i = 0 ; mdata_vector_ct( &(gui->ctls) ) > i ; i++ ) {
      ctl = mdata_vector_get( &(gui->ctls), i, union RETROGUI_CTL );
      if( idc == ctl->base.idc ) {
         break;
      }
      ctl = NULL;
   }
 
   if( NULL == ctl ) {
      error_printf( "could not find GUI item IDC " RETROGUI_IDC_FMT, idc );
   }
 
   return ctl;
}
 
/* === */
 
static MERROR_RETVAL _retrogui_sz_ctl(
   struct RETROGUI* gui, retrogui_idc_t idc,
   retroflat_pxxy_t* p_w, retroflat_pxxy_t* p_h,
   retroflat_pxxy_t max_w, retroflat_pxxy_t max_h
) {
   MERROR_RETVAL retval = MERROR_OK;
   union RETROGUI_CTL* ctl = NULL;
 
   assert( mdata_vector_is_locked( &((gui)->ctls) ) );
 
#if RETROGUI_TRACE_LVL > 0
   debug_printf( RETROGUI_TRACE_LVL,
      "sizing control " RETROGUI_IDC_FMT " to: " SIZE_T_FMT "x" SIZE_T_FMT,
      idc, max_w, max_h );
#endif /* RETROGUI_TRACE_LVL */
 
   ctl = _retrogui_get_ctl_by_idc( gui, idc );
   if( NULL == ctl ) {
      /* Elaborate on error from _retrogui_get_ctl_by_idc(). */
      error_printf( "could not size item!" );
      retval = MERROR_GUI;
      goto cleanup;
   }
 
   #define RETROGUI_CTL_TABLE_SZ( idx, c_name, c_fields ) \
      } else if( RETROGUI_CTL_TYPE_ ## c_name == ctl->base.type ) { \
         /* Mark dirty first so redraw can unmark it for animation! */ \
         retval = retrogui_sz_ ## c_name( gui, ctl, p_w, p_h, max_w, max_h ); \
         maug_cleanup_if_not_ok();
   
   if( 0 ) {
   RETROGUI_CTL_TABLE( RETROGUI_CTL_TABLE_SZ )
   }
 
#if RETROGUI_TRACE_LVL > 0
   debug_printf( RETROGUI_TRACE_LVL,
      "sized control " RETROGUI_IDC_FMT " at " SIZE_T_FMT "x" SIZE_T_FMT "...",
      ctl->base.idc, ctl->base.w, ctl->base.h );
#endif /* RETROGUI_TRACE_LVL */
 
cleanup:
 
   return retval;
}
 
/* === Generic Functions === */
 
retrogui_idc_t retrogui_poll_ctls( 
   struct RETROGUI* gui, RETROFLAT_IN_KEY* p_input,
   struct RETROFLAT_INPUT* input_evt
) {
   size_t i = 0;
   retroflat_pxxy_t mouse_x = 0,
      mouse_y = 0;
   retrogui_idc_t idc_out = RETROGUI_IDC_NONE;
   union RETROGUI_CTL* ctl = NULL;
   MERROR_RETVAL retval = MERROR_OK;
 
   if( 0 == mdata_vector_ct( &(gui->ctls) ) ) {
      return RETROGUI_IDC_NONE;
   }
 
   assert( !mdata_vector_is_locked( &((gui)->ctls) ) );
   mdata_vector_lock( &(gui->ctls) );
 
#  if defined( RETROGUI_NATIVE_WIN )
 
   if( 0 == g_retroflat_state->last_idc ) {
      /* No WM_COMMAND to process. */
      goto cleanup;
   }
 
   ctl = retrogui_get_ctl_by_idc( gui, g_retroflat_state->last_idc );
   g_retroflat_state->last_idc = 0;
   if( NULL == ctl ) {
#if RETROGUI_TRACE_LVL > 0
      debug_printf( RETROGUI_TRACE_LVL,
         "invalid IDC: " RETROGUI_IDC_FMT, gui->focus_idc );
#endif /* RETROGUI_TRACE_LVL */
      goto cleanup;
   }
 
#  ifndef  RETROGUI_NO_TEXTBOX
   if( RETROGUI_CTL_TYPE_TEXTBOX == ctl->base.type ) {
      if( SendMessage( ctl->base.hwnd, EM_GETMODIFY, 0, 0 ) ) {
         SendMessage( ctl->base.hwnd, EM_SETMODIFY, 0, 0 );
#if RETROGUI_TRACE_LVL > 0
         debug_printf( RETROGUI_TRACE_LVL, "mod: %d",
            SendMessage( ctl->base.hwnd, EM_GETMODIFY, 0, 0 ) );
#endif /* RETROGUI_TRACE_LVL */
      }
   }
#  endif /* !RETROGUI_NO_TEXTBOX */
 
#  else
 
   /* Use our cross-platform controls. */
 
#     define RETROGUI_CTL_TABLE_CLICK( idx, c_name, c_fields ) \
         } else if( RETROGUI_CTL_TYPE_ ## c_name == ctl->base.type ) { \
            gui->flags |= RETROGUI_FLAGS_DIRTY; \
            idc_out = retrogui_click_ ## c_name( gui, ctl, p_input, input_evt );
 
#     define RETROGUI_CTL_TABLE_KEY( idx, c_name, c_fields ) \
         } else if( RETROGUI_CTL_TYPE_ ## c_name == ctl->base.type ) { \
            gui->flags |= RETROGUI_FLAGS_DIRTY; \
            idc_out = retrogui_key_ ## c_name( gui, ctl, p_input, input_evt );
 
   if( 0 != *p_input ) {
#if RETROGUI_TRACE_LVL > 0
      debug_printf( RETROGUI_TRACE_LVL,
         "focus " RETROGUI_IDC_FMT " input: %d", gui->focus_idc, *p_input );
#endif /* RETROGUI_TRACE_LVL */
   }
 
   /* Don't accept any input until debounce period has expired. */
   if( retroflat_get_ms() < gui->debounce_next ) {
#if RETROGUI_TRACE_LVL > 0
      debug_printf( RETROGUI_TRACE_LVL,
         "debo! %d vs %d", retroflat_get_ms(), gui->debounce_next );
#endif /* RETROGUI_TRACE_LVL */
      goto cleanup;
#if RETROGUI_TRACE_LVL > 0
   } else if( 0 != *p_input ) {
      debug_printf( RETROGUI_TRACE_LVL, "no debo!" );
#endif /* RETROGUI_TRACE_LVL */
   }
 
   if( 0 == *p_input ) {
      /* No input to debounce! */
      goto cleanup;
 
   } else if(
      retroflat_or_key( *p_input, RETROGUI_KEY_ACTIVATE, RETROGUI_PAD_ACTIVATE )
   ) {
 
      if( RETROGUI_IDC_NONE < gui->focus_idc ) {
#if RETROGUI_TRACE_LVL > 0
         debug_printf( RETROGUI_TRACE_LVL,
            "activate on focus IDC: " RETROGUI_IDC_FMT, gui->focus_idc );
#endif /* RETROGUI_TRACE_LVL */
         idc_out = gui->focus_idc;
         /* gui->focus_idc = -1; */
         gui->flags |= RETROGUI_FLAGS_DIRTY;
      }
 
   } else if(
      retroflat_or_key( *p_input, RETROGUI_KEY_NEXT, RETROGUI_PAD_NEXT )
   ) {
      retrogui_focus_next( gui );
 
#if RETROGUI_TRACE_LVL > 0
      debug_printf( RETROGUI_TRACE_LVL, "next: " RETROGUI_IDC_FMT, gui->focus_idc );
#endif /* RETROGUI_TRACE_LVL */
 
      /* Cleanup after the menu. */
      *p_input = 0;
 
   } else if(
      retroflat_or_key( *p_input, RETROGUI_KEY_PREV, RETROGUI_PAD_PREV )
   ) {
      retrogui_focus_prev( gui );
 
#if RETROGUI_TRACE_LVL > 0
      debug_printf( RETROGUI_TRACE_LVL, "prev: " RETROGUI_IDC_FMT, gui->focus_idc );
#endif /* RETROGUI_TRACE_LVL */
 
      /* Cleanup after the menu. */
      *p_input = 0;
 
#     ifndef RETROGUI_NO_MOUSE
   } else if(
      RETROFLAT_MOUSE_B_LEFT == *p_input ||
      RETROFLAT_MOUSE_B_RIGHT == *p_input
   ) {
      /* Handle mouse input. */
 
      /* Remove all focus before testing if a new control has focus. */
#if RETROGUI_TRACE_LVL > 0
      debug_printf( RETROGUI_TRACE_LVL, "resetting focus for mouse click..." );
#endif /* RETROGUI_TRACE_LVL */
      gui->focus_idc = RETROGUI_IDC_NONE;
 
      mouse_x = input_evt->mouse_x - gui->x;
      mouse_y = input_evt->mouse_y - gui->y;
 
      for( i = 0 ; mdata_vector_ct( &(gui->ctls) ) > i ; i++ ) {
         ctl = mdata_vector_get( &(gui->ctls), i, union RETROGUI_CTL );
         if(
            mouse_x < ctl->base.x ||
            mouse_y < ctl->base.y ||
            mouse_x > ctl->base.x + ctl->base.w ||
            mouse_y > ctl->base.y + ctl->base.h
         ) {
            continue;
         }
 
         if( gui->idc_prev == ctl->base.idc ) {
            /* No repeated clicks! */
            /* TODO: Allow exceptions for e.g. scrollbars. */
            idc_out = RETROGUI_IDC_NONE;
            goto cleanup;
         }
 
         gui->idc_prev = ctl->base.idc;
 
#if RETROGUI_TRACE_LVL > 0
         debug_printf( RETROGUI_TRACE_LVL,
            "setting focus to clicked control: " RETROGUI_IDC_FMT,
            ctl->base.idc );
#endif /* RETROGUI_TRACE_LVL */
         gui->focus_idc = ctl->base.idc;
 
         if( 0 ) {
         RETROGUI_CTL_TABLE( RETROGUI_CTL_TABLE_CLICK )
         }
         break;
      }
#     endif /* !RETROGUI_NO_MOUSE */
 
   } else {
 
      if( RETROGUI_IDC_NONE == gui->focus_idc ) {
         error_printf( "no control has focus!" );
         goto cleanup;
      }
 
      /* Send keystrokes to control that has focus. */
 
      ctl = _retrogui_get_ctl_by_idc( gui, gui->focus_idc );
      if( NULL == ctl ) {
         /* This is a debug message because an invalid focus isn't necessarily
          * a game-over situation...
          */
#if RETROGUI_TRACE_LVL > 0
         debug_printf( RETROGUI_TRACE_LVL,
            "invalid focus IDC: " RETROGUI_IDC_FMT, gui->focus_idc );
#endif /* RETROGUI_TRACE_LVL */
         goto cleanup;
      }
 
      if( 0 ) {
      RETROGUI_CTL_TABLE( RETROGUI_CTL_TABLE_KEY )
      }
   }
 
   /* Input must have been valid, so set a debounce backoff time. */
   gui->debounce_next = retroflat_get_ms() + gui->debounce_max; 
 
#  endif
 
cleanup:
 
   if( MERROR_OK != retval ) {
      idc_out = merror_retval_to_sz( retval );
   }
 
   mdata_vector_unlock( &(gui->ctls) );
 
   return idc_out;
}
 
/* === */
 
MERROR_RETVAL retrogui_redraw_ctls( struct RETROGUI* gui ) {
   size_t i = 0;
   union RETROGUI_CTL* ctl = NULL;
   MERROR_RETVAL retval = MERROR_OK;
   int autolock = 0;
 
#if RETROGUI_TRACE_LVL > 0
   debug_printf( RETROGUI_TRACE_LVL, "redrawing controls..." );
#endif /* RETROGUI_TRACE_LVL */
 
#ifndef RETROWIN_NO_BITMAP
   if( RETROGUI_FLAGS_DIRTY != (RETROGUI_FLAGS_DIRTY & gui->flags) ) {
      /* Shortcut! */
      return MERROR_OK;
   }
#endif /* !RETROWIN_NO_BITMAP */
 
   if( 0 == mdata_vector_ct( &(gui->ctls) ) ) {
      return MERROR_OK;
   }
 
   if( !retrogxc_cachable_is_loaded( &(gui->font) ) ) {
      error_printf( "no font has been defined for GUI %p!", gui );
      return MERROR_GUI;
   }
 
   if( !mdata_vector_is_locked( &((gui)->ctls) ) ) {
      mdata_vector_lock( &(gui->ctls) );
      autolock = 1;
   }
 
   if(
      RETROFLAT_COLOR_BLACK != gui->bg_color &&
      0 < gui->w && 0 < gui->h
   ) {
      retroflat_2d_rect( gui->draw_bmp,
         gui->bg_color, gui->x, gui->y, gui->w, gui->h, RETROFLAT_DRAW_FLAG_FILL );
   }
 
   /* Mark the GUI dirty first so redraw can unmark it for animation! */
   gui->flags &= ~RETROGUI_FLAGS_DIRTY;
 
   #define RETROGUI_CTL_TABLE_REDRAW( idx, c_name, c_fields ) \
      } else if( RETROGUI_CTL_TYPE_ ## c_name == ctl->base.type ) { \
         retrogui_redraw_ ## c_name( gui, ctl );
 
   /* Iterate and redraw all controls. */
   for( i = 0 ; mdata_vector_ct( &(gui->ctls) ) > i ; i++ ) {
      ctl = mdata_vector_get( &(gui->ctls), i, union RETROGUI_CTL );
      if( 0 ) {
      RETROGUI_CTL_TABLE( RETROGUI_CTL_TABLE_REDRAW )
      }
   }
 
#if RETROGUI_TRACE_LVL > 0
   debug_printf( RETROGUI_TRACE_LVL, "redrawing controls complete!" );
#endif /* RETROGUI_TRACE_LVL */
 
 
cleanup:
 
   if( autolock ) {
      mdata_vector_unlock( &(gui->ctls) );
   }
 
   return retval;
}
 
/* === */
 
MERROR_RETVAL retrogui_pos_ctl(
   struct RETROGUI* gui, retrogui_idc_t idc,
   retroflat_pxxy_t x, retroflat_pxxy_t y,
   retroflat_pxxy_t w, retroflat_pxxy_t h
) {
   MERROR_RETVAL retval = MERROR_OK;
   union RETROGUI_CTL* ctl = NULL;
   int autolock = 0;
 
   if( !mdata_vector_is_locked( &((gui)->ctls) ) ) {
      mdata_vector_lock( &(gui->ctls) );
      autolock = 1;
   }
 
#if RETROGUI_TRACE_LVL > 0
   debug_printf( RETROGUI_TRACE_LVL,
      "moving control " RETROGUI_IDC_FMT " to: " SIZE_T_FMT ", " SIZE_T_FMT,
      idc, x, y );
#endif /* RETROGUI_TRACE_LVL */
 
   ctl = _retrogui_get_ctl_by_idc( gui, idc );
   if( NULL == ctl ) {
      /* Elaborate on error from _retrogui_get_ctl_by_idc(). */
      error_printf( "could not position control!" );
      retval = MERROR_GUI;
      goto cleanup;
   }
 
   #define RETROGUI_CTL_TABLE_POS( idx, c_name, c_fields ) \
      } else if( RETROGUI_CTL_TYPE_ ## c_name == ctl->base.type ) { \
         /* Mark dirty first so redraw can unmark it for animation! */ \
         retval = retrogui_pos_ ## c_name( gui, ctl, x, y, w, h ); \
         maug_cleanup_if_not_ok();
   
   if( 0 ) {
   RETROGUI_CTL_TABLE( RETROGUI_CTL_TABLE_POS )
   }
 
#if RETROGUI_TRACE_LVL > 0
   debug_printf( RETROGUI_TRACE_LVL,
      "moved control " RETROGUI_IDC_FMT " to " SIZE_T_FMT ", " SIZE_T_FMT
         " and sized to " SIZE_T_FMT "x" SIZE_T_FMT "...",
      ctl->base.idc, gui->x + ctl->base.x, gui->y + ctl->base.y,
         ctl->base.w, ctl->base.h );
#endif /* RETROGUI_TRACE_LVL */
 
   /* New position! Redraw! */
   gui->flags |= RETROGUI_FLAGS_DIRTY;
 
cleanup:
 
   if( autolock ) {
      mdata_vector_unlock( &(gui->ctls) );
   }
 
   return retval;
 
}
 
/* === */
 
MERROR_RETVAL retrogui_push_ctl(
   struct RETROGUI* gui, union RETROGUI_CTL* ctl
) {
   MERROR_RETVAL retval = MERROR_OK;
   int autolock = 0;
 
   assert( 0 < ctl->base.idc );
 
   /* TODO: Hunt for control IDC and fail if duplicate found! */
 
#if RETROGUI_TRACE_LVL > 0
   debug_printf( RETROGUI_TRACE_LVL,
      "gui->ctls_ct: " SIZE_T_FMT, mdata_vector_ct( &(gui->ctls) ) );
#endif /* RETROGUI_TRACE_LVL */
 
   if(
      RETROGUI_CTL_TYPE_IMAGE != ctl->base.type &&
      RETROFLAT_COLOR_NULL == ctl->base.bg_color
   ) {
      retroflat_message( RETROFLAT_MSG_FLAG_ERROR, "Error",
         "invalid background color specified for control " RETROGUI_IDC_FMT "!",
         ctl->base.idc );
      retval = MERROR_GUI;
      goto cleanup;
 
   }
 
   if(
      RETROGUI_CTL_TYPE_IMAGE != ctl->base.type &&
      RETROFLAT_COLOR_NULL == ctl->base.fg_color
   ) {
      retroflat_message( RETROFLAT_MSG_FLAG_ERROR, "Error",
         "invalid foreground color specified for control " RETROGUI_IDC_FMT "!",
         ctl->base.idc );
      retval = MERROR_GUI;
      goto cleanup;
   }
 
   /* Perform the actual push. */
 
#ifdef RETROGUI_TRACE_TOKENS
   debug_printf( RETROGUI_TRACE_LVL,
      "pushing %s " RETROGUI_IDC_FMT " to slot " SIZE_T_FMT "...",
      gc_retrogui_ctl_names[ctl->base.type], ctl->base.idc,
      mdata_vector_ct( &(gui->ctls) ) );
#elif RETROGUI_TRACE_LVL > 0
   debug_printf( RETROGUI_TRACE_LVL,
      "pushing control type %d, " RETROGUI_IDC_FMT " to slot " SIZE_T_FMT "...",
      ctl->base.type, ctl->base.idc, mdata_vector_ct( &(gui->ctls) ) );
#endif /* RETROGUI_TRACE_TOKENS */
 
   mdata_vector_append( &(gui->ctls), ctl, sizeof( union RETROGUI_CTL ) );
 
   gui->flags |= RETROGUI_FLAGS_DIRTY;
 
   /* Now that append is done, lock the vector and grab a pointer to our
    * newly-pushed control to run some fixups on.
    */
   if( !mdata_vector_is_locked( &((gui)->ctls) ) ) {
      mdata_vector_lock( &(gui->ctls) );
      autolock = 1;
   }
 
   /* TODO: More elegant way to grab index. */
   ctl = mdata_vector_get_last( &(gui->ctls),
      union RETROGUI_CTL );
   assert( NULL != ctl );
 
#if RETROGUI_TRACE_LVL > 0
#  define RETROGUI_CTL_TABLE_PUSH( idx, c_name, c_fields ) \
      } else if( RETROGUI_CTL_TYPE_ ## c_name == ctl->base.type ) { \
         debug_printf( RETROGUI_TRACE_LVL, \
            "running " #c_name " push hook..." ); \
         retval = retrogui_push_ ## c_name( ctl ); \
         maug_cleanup_if_not_ok();
#else
#  define RETROGUI_CTL_TABLE_PUSH( idx, c_name, c_fields ) \
      } else if( RETROGUI_CTL_TYPE_ ## c_name == ctl->base.type ) { \
         retval = retrogui_push_ ## c_name( ctl ); \
         maug_cleanup_if_not_ok();
#endif /* RETROGUI_TRACE_LVL */
 
   if( 0 ) {
   RETROGUI_CTL_TABLE( RETROGUI_CTL_TABLE_PUSH )
   }
 
   /* Try to auto-size the control now that the push-hook as set its text
    * or whatever else might be needed to determine an automatic size.
    */
   if( 0 == ctl->base.w || 0 == ctl->base.h ) {
#ifdef RETROGUI_TRACE_TOKENS
      debug_printf( RETROGUI_TRACE_LVL,
         "determining size for new %s control " RETROGUI_IDC_FMT "...",
         gc_retrogui_ctl_names[ctl->base.type], ctl->base.idc );
#elif RETROGUI_TRACE_LVL > 0
      debug_printf( RETROGUI_TRACE_LVL,
         "determining size for new control type %d, " RETROGUI_IDC_FMT "...",
         ctl->base.type, ctl->base.idc );
#endif /* RETROGUI_TRACE_TOKENS */
      retval = _retrogui_sz_ctl(
         gui, ctl->base.idc, &(ctl->base.w), &(ctl->base.h), 0, 0 );
      maug_cleanup_if_not_ok();
   }
 
   if( RETROGUI_IDC_NONE >= gui->focus_idc && retrogui_can_focus_ctl( ctl ) ) {
#if RETROGUI_TRACE_LVL > 0
      debug_printf( RETROGUI_TRACE_LVL,
         "setting focus to control: " RETROGUI_IDC_FMT, ctl->base.idc );
#endif /* RETROGUI_TRACE_LVL */
      gui->focus_idc = ctl->base.idc;
   }
 
cleanup:
 
   if( autolock ) {
      mdata_vector_unlock( &(gui->ctls) );
   }
 
   return retval;
}
 
/* === */
 
MERROR_RETVAL retrogui_remove_ctl( struct RETROGUI* gui, retrogui_idc_t idc ) {
   size_t i = 0;
   union RETROGUI_CTL* ctl = NULL;
   MERROR_RETVAL retval = MERROR_OK;
 
   if( mdata_vector_is_locked( &((gui)->ctls) ) ) {
      error_printf( "GUI is locked!" );
      goto cleanup;
   }
 
   assert( !mdata_vector_is_locked( &((gui)->ctls) ) );
   mdata_vector_lock( &(gui->ctls) );
 
   #define RETROGUI_CTL_TABLE_FREE_CTL( idx, c_name, c_fields ) \
      } else if( RETROGUI_CTL_TYPE_ ## c_name == ctl->base.type ) { \
         retrogui_destroy_ ## c_name( ctl );
 
   for( i = 0 ; mdata_vector_ct( &(gui->ctls) ) > i ; i++ ) {
      ctl = mdata_vector_get( &(gui->ctls), i, union RETROGUI_CTL );
      if( idc != ctl->base.idc ) {
         continue;
      }
 
      /* Free the control data. */
      if( 0 ) {
      RETROGUI_CTL_TABLE( RETROGUI_CTL_TABLE_FREE_CTL )
      }
 
      /* Remove the control. */
      mdata_vector_unlock( &(gui->ctls) );
      mdata_vector_remove( &(gui->ctls), i );
      mdata_vector_lock( &(gui->ctls) );
      break;
   }
 
   mdata_vector_unlock( &(gui->ctls) );
 
cleanup:
 
   return retval;
}
 
/* === */
 
MERROR_RETVAL retrogui_set_font(
   struct RETROGUI* gui, const maug_path font_path
) {
   MERROR_RETVAL retval = MERROR_OK;
 
#ifdef RETROGXC_PRESENT
   if(
      RETROFLAT_STATE_FLAG_USE_GXC ==
      (RETROFLAT_STATE_FLAG_USE_GXC & g_retroflat_state->retroflat_flags)
   ) {
      gui->font.cache_idx = retrogxc_load_font( font_path, 0, 33, 93 );
      maug_cleanup_if_lt(
         gui->font.cache_idx, (ssize_t)0, SSIZE_T_FMT, MERROR_GUI );
   } else {
#endif /* RETROGXC_PRESENT */
   if(
      RETROGUI_FLAGS_FONT_OWNED == (RETROGUI_FLAGS_FONT_OWNED & gui->flags) &&
      (MAUG_MHANDLE)NULL != gui->font.handle
   ) {
      debug_printf( RETROGUI_TRACE_LVL, "freeing existing GUI font..." );
      maug_mfree( gui->font.handle );
   }
   retval = retrofont_load( font_path, &(gui->font.handle), 0, 33, 93 );
   maug_cleanup_if_not_ok();
#ifdef RETROGXC_PRESENT
   }
#endif /* RETROGXC_PRESENT */
 
   gui->flags |= RETROGUI_FLAGS_FONT_OWNED;
 
cleanup:
 
   return retval;
}
 
#ifndef RETROGUI_NO_TEXTBOX
 
MERROR_RETVAL retrogui_get_ctl_text(
   struct RETROGUI* gui, retrogui_idc_t idc, char* buffer, size_t buffer_sz
) {
   MERROR_RETVAL retval = MERROR_OK;
   union RETROGUI_CTL* ctl = NULL;
   int autolock = 0;
 
   if( !mdata_vector_is_locked( &((gui)->ctls) ) ) {
      mdata_vector_lock( &(gui->ctls) );
      autolock = 1;
   }
 
   ctl = _retrogui_get_ctl_by_idc( gui, idc );
   if( NULL == ctl ) {
      /* Elaborate on error from _retrogui_get_ctl_by_idc(). */
      error_printf( "could not get control text!" );
      retval = MERROR_GUI;
      goto cleanup;
   }
   
   if( RETROGUI_CTL_TYPE_TEXTBOX == ctl->base.type ) {
#  if defined( RETROGUI_NATIVE_WIN )
      /* TODO */
#else
      maug_mlock( ctl->TEXTBOX.text_h, ctl->TEXTBOX.text );
      maug_cleanup_if_null_lock( char*, ctl->TEXTBOX.text );
 
      maug_strncpy( buffer, ctl->TEXTBOX.text, buffer_sz );
#  endif
   } else if( RETROGUI_CTL_TYPE_LABEL == ctl->base.type ) {
#  if defined( RETROGUI_NATIVE_WIN )
      /* TODO */
#else
      maug_mlock( ctl->LABEL.label_h, ctl->LABEL.label );
      maug_cleanup_if_null_lock( char*, ctl->LABEL.label );
 
      maug_strncpy( buffer, ctl->LABEL.label, buffer_sz );
#  endif
 
   }
 
cleanup:
 
   if( RETROGUI_CTL_TYPE_TEXTBOX == ctl->base.type ) {
      if( NULL != ctl->TEXTBOX.text ) {
         maug_munlock( ctl->TEXTBOX.text_h, ctl->TEXTBOX.text );
      }
 
   } else if( RETROGUI_CTL_TYPE_LABEL == ctl->base.type ) {
      if( NULL != ctl->LABEL.label ) {
         maug_munlock( ctl->LABEL.label_h, ctl->LABEL.label );
      }
   }
 
   if( autolock ) {
      mdata_vector_unlock( &(gui->ctls) );
   }
 
   return retval;
}
 
#endif /* !RETROGUI_NO_TEXTBOX */
 
/* === */
 
ssize_t retrogui_get_ctl_sel_idx( struct RETROGUI* gui, retrogui_idc_t idc ) {
   ssize_t idx = -1;
   union RETROGUI_CTL* ctl = NULL;
   MERROR_RETVAL retval = MERROR_OK;
   int autolock = 0;
 
   if( !mdata_vector_is_locked( &((gui)->ctls) ) ) {
      mdata_vector_lock( &(gui->ctls) );
      autolock = 1;
   }
 
   ctl = _retrogui_get_ctl_by_idc( gui, idc );
   if( NULL == ctl ) {
      /* Elaborate on error from _retrogui_get_ctl_by_idc(). */
      error_printf( "could not get control selection!" );
      retval = MERROR_GUI;
      goto cleanup;
   }
 
   assert( RETROGUI_CTL_TYPE_LISTBOX == ctl->base.type );
 
#  if defined( RETROGUI_NATIVE_WIN )
   idx = SendMessage( ctl->base.hwnd, LB_GETCARETINDEX, 0, 0 );
#  else
   idx = ctl->LISTBOX.sel_idx;
#  endif
 
cleanup:
 
   if( autolock ) {
      mdata_vector_unlock( &(gui->ctls) );
   }
 
   if( MERROR_OK != retval ) {
      idx = -1 * retval;
   }
 
   return idx;
}
 
/* === */
 
MERROR_RETVAL retrogui_set_ctl_color(
   struct RETROGUI* gui, retrogui_idc_t idc, uint8_t color_key,
   RETROFLAT_COLOR color_val
) {
   MERROR_RETVAL retval = MERROR_OK;
   union RETROGUI_CTL* ctl = NULL;
 
   assert( !mdata_vector_is_locked( &((gui)->ctls) ) );
   mdata_vector_lock( &(gui->ctls) );
 
#if RETROGUI_TRACE_LVL > 0
   debug_printf( RETROGUI_TRACE_LVL,
      "setting control " RETROGUI_IDC_FMT " color %u to: %d",
      idc, color_key, color_val );
#endif /* RETROGUI_TRACE_LVL */
 
   /* Figure out the control to update. */
   ctl = _retrogui_get_ctl_by_idc( gui, idc );
   if( NULL == ctl ) {
      /* Elaborate on error from _retrogui_get_ctl_by_idc(). */
      error_printf( "could not set control color!" );
      retval = MERROR_GUI;
      goto cleanup;
   }
 
   switch( color_key ) {
   case RETROGUI_COLOR_BG: ctl->base.bg_color = color_val; break;
   case RETROGUI_COLOR_FG: ctl->base.fg_color = color_val; break;
   case RETROGUI_COLOR_SEL_BG: ctl->base.sel_bg = color_val; break;
   case RETROGUI_COLOR_SEL_FG: ctl->base.sel_fg = color_val; break;
 
   default:
      error_printf( "invalid color key specified: %u", color_key );
      break;
   }
 
cleanup:
 
   mdata_vector_unlock( &(gui->ctls) );
 
   return retval;
}
 
/* === */
 
MERROR_RETVAL retrogui_set_ctl_text(
   struct RETROGUI* gui, retrogui_idc_t idc, size_t buffer_sz,
   const char* fmt, ...
) {
   MERROR_RETVAL retval = MERROR_OK;
   char* label_tmp = NULL;
   char* buffer = NULL;
   union RETROGUI_CTL* ctl = NULL;
   MAUG_MHANDLE buffer_h = (MAUG_MHANDLE)NULL;
   va_list args;
 
   assert( !mdata_vector_is_locked( &((gui)->ctls) ) );
   mdata_vector_lock( &(gui->ctls) );
 
#if RETROGUI_TRACE_LVL > 0
   debug_printf( RETROGUI_TRACE_LVL,
      "setting control " RETROGUI_IDC_FMT " text to: %s", idc, fmt );
#endif /* RETROGUI_TRACE_LVL */
 
   /* Figure out the control to update. */
   ctl = _retrogui_get_ctl_by_idc( gui, idc );
   if( NULL == ctl ) {
      /* Elaborate on error from _retrogui_get_ctl_by_idc(). */
      error_printf( "could not set control text!" );
      retval = MERROR_GUI;
      goto cleanup;
   }
 
   /* Perform the buffer substitutions. */
   maug_malloc_test( buffer_h, 1, buffer_sz + 1 );
 
   /* Buffer is always at least 1 for \0. */
   maug_mlock( buffer_h, buffer );
   maug_cleanup_if_null_lock( char*, buffer );
   maug_mzero( buffer, buffer_sz + 1 );
 
   if( NULL == fmt ) {
      /* Zero the buffer. */
      maug_mzero( buffer, buffer_sz + 1);
 
   } else {
      /* Format the buffer. */
      va_start( args, fmt );
      maug_vsnprintf( buffer, buffer_sz, fmt, args );
      va_end( args );
   }
 
   /* Perform the actual update. */
   if( RETROGUI_CTL_TYPE_BUTTON == ctl->base.type ) {
      assert( NULL == ctl->BUTTON.label );
      _retrogui_copy_str( label, buffer, ctl->BUTTON, label_tmp, buffer_sz );
   } else if( RETROGUI_CTL_TYPE_LABEL == ctl->base.type ) {
      assert( NULL == ctl->LABEL.label );
      _retrogui_copy_str(
         label, buffer, ctl->LABEL, label_tmp, buffer_sz );
      ctl->LABEL.shown_sz = 1;
      ctl->LABEL.show_ticks =
         RETROGUI_LABEL_FLAG_SHOWINC_SLOW ==
         (RETROGUI_LABEL_FLAG_SHOWINC_SLOW & ctl->LABEL.flags) ?
            RETROGUI_LABEL_SHOW_TICKS_MAX * 2 :
            RETROGUI_LABEL_SHOW_TICKS_MAX;
 
#ifndef RETROGUI_NO_TEXTBOX
   } else if( RETROGUI_CTL_TYPE_TEXTBOX == ctl->base.type ) {
      /* This is slightly different from _retrogui_copy_str, as it handles
       * the sz_max and sz_ fields independently for the TEXTBOX and allocates
       * an extra byte for NULL at the end for safety.
       */
      if( buffer_sz > ctl->TEXTBOX.text_sz_max ) {
#if RETROGUI_TRACE_LVL > 0
         debug_printf( RETROGUI_TRACE_LVL,
            "string size different; creating new buffer..." );
#endif /* RETROGUI_TRACE_LVL */
         if( (MAUG_MHANDLE)NULL != ctl->TEXTBOX.text_h ) {
            /* Free the existing string. */
            maug_mfree( ctl->TEXTBOX.text_h );
         }
 
         /* Allocate new string space. */
         maug_malloc_test( ctl->TEXTBOX.text_h, buffer_sz + 1, 1 );
 
         ctl->TEXTBOX.text_sz_max = buffer_sz;
      }
      ctl->TEXTBOX.text_sz = buffer_sz;
      ctl->TEXTBOX.text_cur = 0;
      maug_mlock( ctl->TEXTBOX.text_h, label_tmp );
      maug_cleanup_if_null_lock( char*, label_tmp );
 
      /* Copy the string over. */
      maug_mzero( label_tmp, buffer_sz + 1 );
#if RETROGUI_TRACE_LVL > 0
      debug_printf( RETROGUI_TRACE_LVL,
         "zeroed str sz for \"%s\": " SIZE_T_FMT, buffer, buffer_sz + 1 );
#endif /* RETROGUI_TRACE_LVL */
      maug_strncpy( label_tmp, buffer, buffer_sz );
#if RETROGUI_TRACE_LVL > 0
      debug_printf( RETROGUI_TRACE_LVL, "copied str as: \"%s\"", label_tmp );
#endif /* RETROGUI_TRACE_LVL */
      maug_munlock( ctl->TEXTBOX.text_h, label_tmp );
 
#endif /* !RETROGUI_NO_TEXTBOX */
   } else {
      error_printf( "invalid control type! no label!" );
      goto cleanup;
   }
 
   /* New text! Redraw! */
   gui->flags |= RETROGUI_FLAGS_DIRTY;
 
cleanup:
 
   if( NULL != buffer ) {
      maug_munlock( buffer_h, buffer );
   }
 
   if( (MAUG_MHANDLE)NULL != buffer_h ) {
      maug_mfree( buffer_h );
   }
 
   mdata_vector_unlock( &(gui->ctls) );
 
   return retval;
}
 
/* === */
 
MERROR_RETVAL retrogui_set_ctl_image(
   struct RETROGUI* gui, retrogui_idc_t idc, const maug_path path, uint8_t flags
) {
   MERROR_RETVAL retval = MERROR_OK;
   union RETROGUI_CTL* ctl = NULL;
   int autolock = 0;
 
   if( !mdata_vector_is_locked( &((gui)->ctls) ) ) {
      mdata_vector_lock( &(gui->ctls) );
      autolock = 1;
   }
 
#if RETROGUI_TRACE_LVL > 0
   debug_printf( RETROGUI_TRACE_LVL,
      "setting control " RETROGUI_IDC_FMT " image to: %s", idc, path );
#endif /* RETROGUI_TRACE_LVL */
 
   /* Figure out the control to update. */
   ctl = _retrogui_get_ctl_by_idc( gui, idc );
   if( NULL == ctl ) {
      /* Elaborate on error from _retrogui_get_ctl_by_idc(). */
      error_printf( "could not set control image!" );
      retval = MERROR_GUI;
      goto cleanup;
   }
 
   /* Perform the actual update. */
   if( RETROGUI_CTL_TYPE_IMAGE == ctl->base.type ) {
      /* Cleanup existing image. */
#  ifdef RETROGXC_PRESENT
      ctl->IMAGE.image_cache_id = -1;
#  endif /* RETROGXC_PRESENT */
      if( retroflat_2d_bitmap_ok( &(ctl->IMAGE.image) ) ) {
         retroflat_2d_destroy_bitmap( &(ctl->IMAGE.image) );
      }
 
      /* Load the replacement image. */
      if( NULL != path && '\0' != path[0] ) {
#  if defined( RETROGXC_PRESENT )
         ctl->IMAGE.image_cache_id = retrogxc_load_bitmap( path, flags );
#  else /* Only use a normal image if cache not present! */
         retroflat_2d_load_bitmap( path, &(ctl->IMAGE.image), flags );
#  endif /* RETROGXC_PRESENT */
      }
   } else {
      error_printf( "invalid control type! no image!" );
      goto cleanup;
   }
 
   /* New text! Redraw! */
   gui->flags |= RETROGUI_FLAGS_DIRTY;
 
cleanup:
 
   if( autolock ) {
      mdata_vector_unlock( &(gui->ctls) );
   }
 
   return retval;
}
 
/* === */
 
MERROR_RETVAL retrogui_set_ctl_image_blit(
   struct RETROGUI* gui, retrogui_idc_t idc, retroflat_blit_t* blit,
   uint8_t flags
) {
   MERROR_RETVAL retval = MERROR_OK;
   union RETROGUI_CTL* ctl = NULL;
   int autolock = 0;
   retroflat_pxxy_t ctl_img_w, ctl_img_h, blit_w, blit_h;
 
   if( !mdata_vector_is_locked( &((gui)->ctls) ) ) {
      mdata_vector_lock( &(gui->ctls) );
      autolock = 1;
   }
 
#if RETROGUI_TRACE_LVL > 0
   debug_printf( RETROGUI_TRACE_LVL,
      "setting control " RETROGUI_IDC_FMT " image to: %p", idc, blit );
#endif /* RETROGUI_TRACE_LVL */
 
   /* Figure out the control to update. */
   ctl = _retrogui_get_ctl_by_idc( gui, idc );
   if( NULL == ctl ) {
      /* Elaborate on error from _retrogui_get_ctl_by_idc(). */
      error_printf( "could not set control image!" );
      retval = MERROR_GUI;
      goto cleanup;
   }
 
   /* Perform the actual update. */
   if( RETROGUI_CTL_TYPE_IMAGE == ctl->base.type ) {
      if( NULL != blit ) {
         /* Cleanup any existing image. */
#  if defined( RETROGXC_PRESENT )
         ctl->IMAGE.image_cache_id = -1;
#  endif /* RETROGXC_PRESENT */
 
         ctl_img_w = retroflat_2d_bitmap_w( &(ctl->IMAGE.image) );
         ctl_img_h = retroflat_2d_bitmap_h( &(ctl->IMAGE.image) );
         blit_w = retroflat_2d_bitmap_w( blit );
         blit_h = retroflat_2d_bitmap_h( blit );
 
         /* Only cleanup a normal image if it's smaller than the one to blit. */
         if(
            retroflat_2d_bitmap_ok( &(ctl->IMAGE.image) ) &&
            (blit_w < ctl_img_w || blit_h < ctl_img_h)
         ) {
            retroflat_2d_destroy_bitmap( &(ctl->IMAGE.image) );
         }
 
#if RETROGUI_TRACE_LVL > 0
         debug_printf( RETROGUI_TRACE_LVL,
            "creating control " RETROGUI_IDC_FMT " image: %u, %u",
            idc, blit_w, blit_h );
#endif /* RETROGUI_TRACE_LVL */
 
         /* Create the new image to blit to. */
         retval = retroflat_2d_create_bitmap(
            blit_w, blit_h, &(ctl->IMAGE.image), 0 );
         maug_cleanup_if_not_ok();
 
         retroflat_2d_lock_bitmap( &(ctl->IMAGE.image) );
 
#if RETROGUI_TRACE_LVL > 0
         debug_printf( RETROGUI_TRACE_LVL,
            "blitting control " RETROGUI_IDC_FMT " image from: %p", idc, blit );
#endif /* RETROGUI_TRACE_LVL */
 
         /* Blit the new image over the old one. */
         retroflat_2d_blit_bitmap(
            &(ctl->IMAGE.image),
            blit,
            0, 0, 0, 0, blit_w, blit_h,
            ctl->IMAGE.instance );
         retroflat_2d_release_bitmap( &(ctl->IMAGE.image) );
      } else {
 
      }
   } else {
      error_printf( "invalid control type! no image!" );
      goto cleanup;
   }
 
   /* New text! Redraw! */
   gui->flags |= RETROGUI_FLAGS_DIRTY;
 
cleanup:
 
   if( autolock ) {
      mdata_vector_unlock( &(gui->ctls) );
   }
 
   return retval;
}
 
/* === */
 
MERROR_RETVAL retrogui_set_ctl_level(
   struct RETROGUI* gui, retrogui_idc_t idc, uint16_t level, uint16_t max,
   uint8_t flags
) {
   MERROR_RETVAL retval = MERROR_OK;
   union RETROGUI_CTL* ctl = NULL;
   int autolock = 0;
 
   if( !mdata_vector_is_locked( &((gui)->ctls) ) ) {
      mdata_vector_lock( &(gui->ctls) );
      autolock = 1;
   }
 
#if RETROGUI_TRACE_LVL > 0
   debug_printf( RETROGUI_TRACE_LVL,
      "setting control " RETROGUI_IDC_FMT " level to: %u", idc, level  );
#endif /* RETROGUI_TRACE_LVL */
 
   /* Figure out the control to update. */
   ctl = _retrogui_get_ctl_by_idc( gui, idc );
   if( NULL == ctl ) {
      /* Elaborate on error from _retrogui_get_ctl_by_idc(). */
      error_printf( "could not set control level!" );
      retval = MERROR_GUI;
      goto cleanup;
   }
 
   /* Perform the actual update. */
   if( RETROGUI_CTL_TYPE_FILLBAR == ctl->base.type ) {
      ctl->FILLBAR.cur = level;
      if( 0 < max ) {
         ctl->FILLBAR.max = max;
      }
   } else {
      error_printf( "invalid control type! no level!" );
      goto cleanup;
   }
 
   /* New level! Redraw! */
   gui->flags |= RETROGUI_FLAGS_DIRTY;
 
cleanup:
 
   if( autolock ) {
      mdata_vector_unlock( &(gui->ctls) );
   }
 
   return retval;
}
 
/* === */
 
MERROR_RETVAL retrogui_init_ctl(
   union RETROGUI_CTL* ctl, uint8_t type, retrogui_idc_t idc
) {
   MERROR_RETVAL retval = MERROR_OK;
 
   if( RETROGUI_IDC_NONE >= idc ) {
      error_printf( "invalid IDC: %d", idc );
      retval = MERROR_GUI;
      goto cleanup;
   }
 
#if RETROGUI_TRACE_LVL > 0
   debug_printf( RETROGUI_TRACE_LVL,
      "initializing control base " RETROGUI_IDC_FMT "...", idc );
#endif /* RETROGUI_TRACE_LVL */
 
   maug_mzero( ctl, sizeof( union RETROGUI_CTL ) );
 
   ctl->base.type = type;
   ctl->base.idc = idc;
   ctl->base.fg_color = RETROFLAT_COLOR_NULL;
   ctl->base.bg_color = RETROFLAT_COLOR_NULL;
   ctl->base.sel_fg = RETROFLAT_COLOR_NULL;
   ctl->base.sel_bg = RETROFLAT_COLOR_NULL;
 
   #define RETROGUI_CTL_TABLE_INITS( idx, c_name, c_fields ) \
      } else if( RETROGUI_CTL_TYPE_ ## c_name == ctl->base.type ) { \
         retrogui_init_ ## c_name( ctl );
 
   if( 0 ) {
   RETROGUI_CTL_TABLE( RETROGUI_CTL_TABLE_INITS )
   }
 
#  ifdef RETROGXC_PRESENT
   if( RETROGUI_CTL_TYPE_IMAGE == type ) {
      ctl->IMAGE.image_cache_id = -1;
   }
#  endif /* !RETROGXC_PRESENT */
 
cleanup:
 
   return retval;
}
 
/* === */
 
MERROR_RETVAL retrogui_destroy( struct RETROGUI* gui ) {
   size_t i = 0;
   union RETROGUI_CTL* ctl = NULL;
   MERROR_RETVAL retval = MERROR_OK;
 
   if( mdata_vector_is_locked( &((gui)->ctls) ) ) {
      error_printf( "GUI is locked!" );
      goto cleanup;
   }
 
   if( 0 == mdata_vector_ct( &(gui->ctls) ) ) {
      goto cleanup;
   }
 
   assert( !mdata_vector_is_locked( &((gui)->ctls) ) );
   mdata_vector_lock( &(gui->ctls) );
 
   #define RETROGUI_CTL_TABLE_FREE( idx, c_name, c_fields ) \
      } else if( RETROGUI_CTL_TYPE_ ## c_name == ctl->base.type ) { \
         retrogui_destroy_ ## c_name( ctl );
 
   for( i = 0 ; mdata_vector_ct( &(gui->ctls) ) > i ; i++ ) {
      ctl = mdata_vector_get( &(gui->ctls), i, union RETROGUI_CTL );
      if( 0 ) {
      RETROGUI_CTL_TABLE( RETROGUI_CTL_TABLE_FREE )
      }
   }
 
   mdata_vector_unlock( &(gui->ctls) );
 
#  ifndef RETROGXC_PRESENT
   if( RETROGUI_FLAGS_FONT_OWNED == (RETROGUI_FLAGS_FONT_OWNED & gui->flags) ) {
      maug_mfree( gui->font.handle );
   }
#  endif /* !RETROGXC_PRESENT */
 
cleanup:
 
   mdata_vector_free( &(gui->ctls) );
 
   return retval;
}
 
/* === */
 
retrogui_idc_t retrogui_focus_iter(
   struct RETROGUI* gui, size_t start, ssize_t incr
) {
   retrogui_idc_t idc_out = RETROGUI_IDC_NONE;
   union RETROGUI_CTL* ctl = NULL;
   MERROR_RETVAL retval = MERROR_OK;
   retrogui_idc_t i = 0;
   ssize_t i_before = -1; /* Index of the current selected IDC. */
   int autolock = 0;
 
   if( 0 == mdata_vector_ct( &(gui->ctls) ) ) {
      goto cleanup;
   }
 
   if( !mdata_vector_is_locked( &((gui)->ctls) ) ) {
      mdata_vector_lock( &(gui->ctls) );
      autolock = 1;
   }
 
   /* Find the currently selected IDC. */
   for(
      i = start ; mdata_vector_ct( &(gui->ctls) ) > i && 0 <= i ; i += incr
   ) {
      ctl = mdata_vector_get( &(gui->ctls), i, union RETROGUI_CTL );
      if( !retrogui_can_focus_ctl( ctl ) ) {
         continue;
      } else if( RETROGUI_IDC_NONE == gui->focus_idc || 0 <= i_before ) {
         /* We're primed to set the new focus, so do that and finish. */
         idc_out = ctl->base.idc;
#if RETROGUI_TRACE_LVL > 0
         debug_printf( RETROGUI_TRACE_LVL,
            "moving focus to control: " RETROGUI_IDC_FMT, idc_out );
#endif /* RETROGUI_TRACE_LVL */
         gui->focus_idc = idc_out;
         goto cleanup;
 
      } else if( ctl->base.idc == gui->focus_idc ) {
         /* We've found the current focus, so prime to select the new focus. */
         i_before = i;
      }
   }
 
   /* We didn't select a focus in the loop above, so we must be wrapping around!
    */
 
   /* Select the next IDC. */
   if( 0 > i ) {
      /* Wrap around to last SELECTABLE item. */
      for( i = mdata_vector_ct( &(gui->ctls) ) - 1 ; 0 <= i ; i-- ) {
         ctl = mdata_vector_get( &(gui->ctls), i, union RETROGUI_CTL );
         if( !retrogui_can_focus_ctl( ctl ) ) {
            /* Skip NON-SELECTABLE items! */
#if RETROGUI_TRACE_LVL > 0
            debug_printf(
               RETROGUI_TRACE_LVL, "skipping: " RETROGUI_IDC_FMT, i );
#endif /* RETROGUI_TRACE_LVL */
            continue;
         } else {
            idc_out = ctl->base.idc;
#if RETROGUI_TRACE_LVL > 0
            debug_printf( RETROGUI_TRACE_LVL,
               "moving focus to control: " RETROGUI_IDC_FMT, idc_out );
#endif /* RETROGUI_TRACE_LVL */
            gui->focus_idc = idc_out;
            break;
         }
      }
 
   } else if( mdata_vector_ct( &(gui->ctls) ) <= i ) {
      /* Wrap around to first SELECTABLE item. */
      for( i = 0 ; mdata_vector_ct( &(gui->ctls) ) > i ; i++ ) {
         ctl = mdata_vector_get( &(gui->ctls), i, union RETROGUI_CTL );
         if( !retrogui_can_focus_ctl( ctl ) ) {
            /* Skip NON-SELECTABLE items! */
#if RETROGUI_TRACE_LVL > 0
            debug_printf(
               RETROGUI_TRACE_LVL, "skipping: " RETROGUI_IDC_FMT, i );
#endif /* RETROGUI_TRACE_LVL */
            continue;
         } else {
            idc_out = ctl->base.idc;
#if RETROGUI_TRACE_LVL > 0
            debug_printf( RETROGUI_TRACE_LVL,
               "moving focus to control: " RETROGUI_IDC_FMT, idc_out );
#endif /* RETROGUI_TRACE_LVL */
            gui->focus_idc = idc_out;
            break;
         }
      }
 
   } else {
      error_printf( "invalid focus: " RETROGUI_IDC_FMT, i );
 
   }
 
cleanup:
 
   /* New focus! Dirty! */
   gui->flags |= RETROGUI_FLAGS_DIRTY;
 
   if( MERROR_OK != retval ) {
      idc_out = merror_retval_to_sz( retval );
   }
 
   if( autolock ) {
      mdata_vector_unlock( &(gui->ctls) );
   }
 
#if RETROGUI_TRACE_LVL > 0
   debug_printf(
      RETROGUI_TRACE_LVL, "selected IDC: " RETROGUI_IDC_FMT, idc_out );
#endif /* RETROGUI_TRACE_LVL */
 
   return idc_out;
}
 
/* === */
 
MERROR_RETVAL retrogui_init( struct RETROGUI* gui ) {
   MERROR_RETVAL retval = MERROR_OK;
 
   maug_mzero( gui, sizeof( struct RETROGUI ) );
 
   gui->bg_color = RETROFLAT_COLOR_BLACK;
   gui->focus_idc = RETROGUI_IDC_NONE;
   gui->debounce_max = RETROGUI_DEBOUNCE_MAX_DEFAULT;
 
#if RETROGUI_TRACE_LVL > 0
   debug_printf( RETROGUI_TRACE_LVL, "initialized GUI" );
#endif /* RETROGUI_TRACE_LVL */
 
   return retval;
}
 
#else
 
#define RETROGUI_CTL_TABLE_CONSTS( idx, c_name, c_fields ) \
   extern MAUG_CONST uint8_t SEG_MCONST RETROGUI_CTL_TYPE_ ## c_name;
 
RETROGUI_CTL_TABLE( RETROGUI_CTL_TABLE_CONSTS )
 
#ifdef RETROGUI_TRACE_TOKENS
extern MAUG_CONST char* gc_retrogui_ctl_names[];
#endif /* RETROGUI_TRACE_TOKENS */
 
#endif /* RETROGUI_C */
 /* maug_retrogui */
 /* maug_retroflt */
 
#endif /* !RETROGUI_H */