toolkit.c

Go to the documentation of this file.

/*
 * See Licensing and Copyright notice in naev.h
 */
#include <stdarg.h>
 
#include "naev.h"
#include "toolkit.h"
 
#include "conf.h"
#include "dialogue.h"
#include "input.h"
#include "log.h"
#include "opengl.h"
#include "pause.h"
#include "nmath.h"
#include "tk/toolkit_priv.h"
 
#define INPUT_DELAY      conf.repeat_delay 
#define INPUT_FREQ       conf.repeat_freq 
static unsigned int genwid = 0; 
static int toolkit_needsRender = 1; 
static int toolkit_delayCounter = 0; 
/*
 * window stuff
 */
#define MIN_WINDOWS  4 
static Window *windows = NULL; 
/*
 * simulate keypresses when holding
 */
static SDL_Keycode input_key   = 0; 
static SDL_Keymod input_mod    = 0; 
/*
 * default outline colours
 */
const glColour* toolkit_colLight = &cGrey50; 
const glColour* toolkit_col      = &cGrey20; 
const glColour* toolkit_colDark  = &cGrey5; 
/*
 * Tab colours
 */
const glColour* tab_active    = &cGrey20; 
const glColour* tab_activeB   = &cGrey10; 
const glColour* tab_inactive  = &cGrey15; 
const glColour* tab_inactiveB = &cGrey10; 
const glColour* tab_background= &cBlack; 
/*
 * VBO
 */
static gl_vbo *toolkit_vbo; 
static GLsizei toolkit_vboColourOffset; 
/*
 * static prototypes
 */
/* input */
static int toolkit_mouseEvent( Window *w, SDL_Event* event );
static int toolkit_mouseEventWidget( Window *w, Widget *wgt,
      SDL_Event *event, int x, int y, int rx, int ry );
static int toolkit_keyEvent( Window *wdw, SDL_Event* event );
static int toolkit_textEvent( Window *wdw, SDL_Event* event );
/* Focus */
static int toolkit_isFocusable( const Widget *wgt );
static Widget* toolkit_getFocus( Window *wdw );
static void toolkit_expose( Window *wdw, int expose );
/* render */
static void window_renderBorder( const Window* w );
/* Death. */
static void widget_kill( Widget *wgt );
static void window_cleanup( Window *wdw );
static void window_remove( Window *wdw );
static void toolkit_purgeDead (void);
 
int toolkit_isOpen (void)
{
   /* Check to see if there is any active window. */
   for (Window *wdw = windows; wdw != NULL; wdw = wdw->next)
      if (!window_isFlag( wdw, WINDOW_KILL | WINDOW_NORENDER ))
         return 1;
   return 0;
}
 
void toolkit_delay (void)
{
   toolkit_delayCounter++;
}
 
void toolkit_setPos( const Window *wdw, Widget *wgt, int x, int y )
{
   /* X position. */
   if (x < 0)
      wgt->x = wdw->w - wgt->w + x;
   else
      wgt->x = (double) x;
 
   /* Y position. */
   if (y < 0)
      wgt->y = wdw->h - wgt->h + y;
   else
      wgt->y = (double) y;
}
 
void toolkit_setWindowPos( Window *wdw, int x, int y )
{
   wdw->xrel = -1.;
   wdw->yrel = -1.;
 
   window_rmFlag( wdw, WINDOW_CENTERX );
   window_rmFlag( wdw, WINDOW_CENTERY );
 
   /* x pos */
   if (x == -1) { /* Center */
      wdw->x = (gl_screen.nw - wdw->w)/2.;
      wdw->xrel = 0.5;
      window_setFlag( wdw, WINDOW_CENTERX );
   }
   else if (x < 0)
      wdw->x = gl_screen.nw - wdw->w + (double) x;
   else
      wdw->x = (double) x;
 
   /* y pos */
   if (y == -1) { /* Center */
      wdw->y = (gl_screen.nh - wdw->h)/2.;
      wdw->yrel = 0.5;
      window_setFlag( wdw, WINDOW_CENTERY );
   }
   else if (y < 0)
      wdw->y = gl_screen.nh - wdw->h + (double) y;
   else
      wdw->y = (double) y;
}
 
void window_move( unsigned int wid, int x, int y )
{
   /* Get the window. */
   Window *wdw = window_wget(wid);
   if (wdw == NULL)
      return;
 
   toolkit_setWindowPos( wdw, x, y );
}
 
void window_resize( unsigned int wid, int w, int h )
{
   /* Get the window. */
   Window *wdw = window_wget(wid);
   if (wdw == NULL)
      return;
 
   wdw->w = (w == -1) ? gl_screen.nw : (double) w;
   wdw->h = (h == -1) ? gl_screen.nh : (double) h;
   if ((w == -1) && (h == -1)) {
      window_setFlag( wdw, WINDOW_FULLSCREEN );
      wdw->x = 0.;
      wdw->y = 0.;
      window_setFlag( wdw, WINDOW_CENTERX );
      window_setFlag( wdw, WINDOW_CENTERY );
   }
   else {
      window_rmFlag( wdw, WINDOW_FULLSCREEN );
      if (window_isFlag( wdw, WINDOW_CENTERX ) && window_isFlag( wdw, WINDOW_CENTERY ))
         toolkit_setWindowPos( wdw, -1, -1 );
   }
}
 
Widget* window_newWidget( Window* w, const char *name )
{
   Widget *wgt, *wlast, *wtmp;
   char *saved_name = NULL;
 
   /* NULL protection. */
   if (w==NULL)
      return NULL;
 
   /* Try to find one with the same name first. */
   wlast = NULL;
   for (wgt=w->widgets; wgt!=NULL; wgt=wgt->next) {
 
      /* Must match name. */
      if (strcmp(name, wgt->name)!=0) {
         wlast = wgt;
         continue;
      }
 
      /* Should be destroyed. */
      if (!wgt_isFlag( wgt, WGT_FLAG_KILL )) {
         WARN(_("Trying to create widget '%s' over existing one that hasn't been destroyed"),
               name );
         return NULL;
      }
 
      /* Relink. */
      if (wlast==NULL)
         w->widgets  = wgt->next;
      else
         wlast->next = wgt->next;
 
      /* Prepare and return this widget. */
      saved_name = wgt->name;
      wgt->name  = NULL;
      widget_cleanup(wgt);
      break;
   }
 
   /* Must grow widgets. */
   if (wgt == NULL)
      wgt = malloc( sizeof(Widget) );
 
   /* Safe defaults. */
   memset( wgt, 0, sizeof(Widget) );
   wgt->type   = WIDGET_NULL;
   wgt->status = WIDGET_STATUS_NORMAL;
   wgt->wdw    = w->id;
   if (saved_name != NULL) /* Hack to avoid frees so _getFocus works in the same frame. */
      wgt->name   = saved_name;
   else
      wgt->name   = strdup(name);
   wgt->id     = ++w->idgen;
 
   /* Set up. */
   wlast = NULL;
   for (wtmp=w->widgets; wtmp!=NULL; wtmp=wtmp->next)
      wlast = wtmp;
   if (wlast == NULL)
      w->widgets  = wgt;
   else
      wlast->next = wgt;
 
   toolkit_rerender();
   return wgt;
}
 
Window* window_wget( unsigned int wid )
{
   if (windows == NULL) {
      WARN(_("Window '%u' not found in list!"), wid );
      return NULL;
   }
   Window *w = window_wgetW( wid );
   if (w==NULL)
      WARN(_("Window '%u' not found in list!"), wid );
   return w;
}
 
Window* window_wgetW( unsigned int wid )
{
   for (Window *w = windows; w != NULL; w = w->next)
      if (w->id == wid)
         return w;
   return NULL;
}
 
Window* window_wgetNameW( const char *name )
{
   for (Window *w = windows; w != NULL; w = w->next)
      if (strcmp( w->name, name )==0)
         return w;
   return NULL;
}
 
Widget* window_getwgt( unsigned int wid, const char* name )
{
   /* Get the window. */
   Window *wdw = window_wget(wid);
   if (wdw == NULL) {
      WARN(_("Widget '%s' not found in window '%u'!"), name, wid );
      return NULL;
   }
 
   /* Find the widget. */
   for (Widget *wgt=wdw->widgets; wgt!=NULL; wgt=wgt->next)
      if (strcmp(wgt->name, name)==0)
         return wgt;
 
   WARN(_("Widget '%s' not found in window '%u'!"), name, wid );
   return NULL;
}
 
void window_dimWindow( unsigned int wid, int *w, int *h )
{
   /* Get the window. */
   const Window *wdw = window_wget(wid);
   if (wdw == NULL) {
      *w = -1;
      *h = -1;
      return;
   }
 
   /* Set dimensions. */
   *w = wdw->w;
   *h = wdw->h;
}
 
void window_posWindow( unsigned int wid, int *x, int *y )
{
   /* Get the window. */
   const Window *wdw = window_wget(wid);
   if (wdw == NULL) {
      *x = -1;
      *y = -1;
      return;
   }
 
   /* Set dimensions. */
   *x = wdw->x;
   *y = wdw->y;
}
 
void window_dimWidget( unsigned int wid, const char *name, int *w, int *h )
{
   /* Get widget. */
   const Widget *wgt = window_getwgt(wid, name);
   if (wgt == NULL) {
      if (w!=NULL)
         *w = -1;
      if (h!=NULL)
         *h = -1;
      return;
   }
 
   if (w!=NULL)
      *w = wgt->w;
   if (h!=NULL)
      *h = wgt->h;
}
 
void window_posWidget( unsigned int wid,
      const char* name, int *x, int *y )
{
   /* Get widget. */
   const Widget *wgt = window_getwgt(wid,name);
   if (wgt == NULL)
      return;
 
   /* Return position. */
   if (x != NULL)
      (*x) = wgt->x;
   if (y != NULL)
      (*y) = wgt->y;
}
 
void window_moveWidget( unsigned int wid,
      const char* name, int x, int y )
{
   Window *wdw;
   Widget *wgt;
 
   /* Get window. */
   wdw = window_wget(wid);
   if (wdw == NULL)
      return;
 
   /* Get widget. */
   wgt = window_getwgt(wid,name);
   if (wgt == NULL)
      return;
 
   /* Set position. */
   toolkit_setPos( wdw, wgt, x, y );
}
 
void window_resizeWidget( unsigned int wid,
      const char* name, int w, int h )
{
   Window *wdw;
   Widget *wgt;
 
   /* Get window. */
   wdw = window_wget(wid);
   if (wdw == NULL)
      return;
 
   /* Get widget. */
   wgt = window_getwgt(wid,name);
   if (wgt == NULL)
      return;
 
   /* Set position. */
   wgt->w = w;
   wgt->h = h;
}
 
void window_canFocusWidget( unsigned int wid,
      const char* name, int canfocus )
{
   Window *wdw;
   Widget *wgt;
 
   /* Get window. */
   wdw = window_wget(wid);
   if (wdw == NULL)
      return;
 
   /* Get widget. */
   wgt = window_getwgt(wid,name);
   if (wgt == NULL)
      return;
 
   /* Set position. */
   if (canfocus)
      wgt_setFlag( wgt, WGT_FLAG_CANFOCUS );
   else
      wgt_rmFlag( wgt, WGT_FLAG_CANFOCUS );
}
 
int window_isTop( unsigned int wid )
{
   Window *n, *w = window_wget(wid);
   if (w==NULL)
      return 0;
   n = w->next;
   while (n != NULL) {
      if (!window_isFlag(n,WINDOW_KILL | WINDOW_NORENDER))
         return 0;
      n = n->next;
   }
   return 1;
}
 
int widget_isCovered( unsigned int wid, const char *name, int x, int y )
{
   int bx, by, rx, ry;
   Widget *wgt = window_getwgt( wid, name );
   if (wgt==NULL)
      return 0;
 
   /* Undo transform. */
   bx = x + wgt->x;
   by = y + wgt->y;
 
   /* Find if the point is covered. */
   for (Widget *w=wgt->next; w!=NULL; w=w->next) {
      if ((wgt->render==NULL) || wgt_isFlag(w, WGT_FLAG_KILL))
         continue;
 
      rx = bx-w->x;
      ry = by-w->y;
      if (!((rx < 0) || (rx >= w->w) || (ry < 0) || (ry >= w->h)))
         return 1;
   }
   return 0;
}
 
int window_exists( const char* wdwname )
{
   if (windows == NULL)
      return 0;
   for (Window *w = windows; w != NULL; w = w->next)
      if ((strcmp(w->name,wdwname)==0) && !window_isFlag(w, WINDOW_KILL))
         return 1;
   return 0; /* doesn't exist */
}
 
int window_existsID( unsigned int wid )
{
   if (windows == NULL)
      return 0;
   for (Window *w = windows; w != NULL; w = w->next)
      if ((w->id==wid) && !window_isFlag(w, WINDOW_KILL))
         return 1;
   return 0; /* doesn't exist */
}
 
int window_setDisplayname( unsigned int wid, const char *displayname )
{
   Window *wdw = window_wget(wid);
   if (wdw == NULL)
      return -1;
   free(wdw->displayname);
   wdw->displayname = NULL;
   if (displayname != NULL)
      wdw->displayname  = strdup(displayname);
   return 0;
}
 
void window_setDynamic( unsigned int wid, int dynamic )
{
   Window *wdw = window_wget(wid);
   if (wdw == NULL)
      return;
   if (dynamic)
      wdw->flags |= WINDOW_DYNAMIC;
   else
      wdw->flags &= ~WINDOW_DYNAMIC;
}
 
unsigned int window_get( const char* wdwname )
{
   Window *last;
   if (windows == NULL)
      return 0;
   last = NULL;
   for (Window *w = windows; w != NULL; w = w->next)
      if ((strcmp(w->name,wdwname)==0) && !window_isFlag(w, WINDOW_KILL))
         last = w;
   if (last==NULL)
      return 0;
   return last->id;
}
 
unsigned int window_create( const char* name, const char *displayname,
      const int x, const int y, const int w, const int h )
{
   return window_createFlags( name, displayname, x, y, w, h, 0 );
}
 
unsigned int window_createFlags( const char* name, const char *displayname,
      const int x, const int y, const int w, const int h, unsigned int flags )
{
   Window *wdw = calloc( 1, sizeof(Window) );
 
   const int wid = (++genwid); /* unique id */
 
   /* Create the window. */
   wdw->id           = wid;
   wdw->name         = strdup(name);
   wdw->displayname  = strdup(displayname);
 
   /* Safe defaults. */
   wdw->idgen        = -1;
   wdw->focus        = -1;
   wdw->xrel         = -1.;
   wdw->yrel         = -1.;
   wdw->flags        = flags;
   wdw->exposed      = !window_isFlag(wdw, WINDOW_NOFOCUS);
 
   /* Dimensions. */
   wdw->w            = (w == -1) ? gl_screen.nw : (double) w;
   wdw->h            = (h == -1) ? gl_screen.nh : (double) h;
   if ((w == -1) && (h == -1)) {
      window_setFlag( wdw, WINDOW_FULLSCREEN );
      wdw->x = 0.;
      wdw->y = 0.;
   }
   else
      toolkit_setWindowPos( wdw, x, y );
 
   if (!toolkit_isOpen()) {
      input_mouseShow();
      pause_game();
      gl_defViewport(); /* Reset the default viewport */
   }
 
   /* Clear key repeat. */
   toolkit_clearKey();
 
   /* Add to list. */
   wdw->next = NULL;
   if (windows == NULL)
      windows = wdw;
   else {
      Window *wlast;
      /* Take focus from the old window. */
      if (wdw->exposed) {
         Window *wcur = toolkit_getActiveWindow();
         if (wcur != NULL)
            toolkit_expose( wcur, 0 ); /* wcur is hidden */
      }
 
      wlast = windows;
      while (1) {
         if ((strcmp( wlast->name, name )==0) && !window_isFlag( wlast, WINDOW_KILL )
              && !window_isFlag( wlast, WINDOW_NOFOCUS ))
            WARN( _( "Window with name '%s' already exists!" ), wlast->name );
 
         if (wlast->next == NULL)
            break;
 
         wlast = wlast->next;
      }
 
      wlast->next = wdw;
   }
 
   toolkit_rerender();
   return wid;
}
 
void window_setParent( unsigned int wid, unsigned int parent )
{
   /* Get the window. */
   Window *wdw = window_wget( wid );
   if (wdw == NULL)
      return;
 
   /* Set the parent. */
   wdw->parent = parent;
}
 
unsigned int window_getParent( unsigned int wid )
{
   /* Get the window. */
   const Window *wdw = window_wget( wid );
   if (wdw == NULL)
      return 0;
 
   /* Get the parent. */
   return wdw->parent;
}
 
void window_onClose( unsigned int wid, void (*fptr)(unsigned int,const char*) )
{
   /* Get the window. */
   Window *wdw = window_wget( wid );
   if (wdw == NULL)
      return;
 
   /* Set the close function. */
   wdw->close_fptr = fptr;
}
 
void window_setAccept( unsigned int wid, void (*accept)(unsigned int,const char*) )
{
   /* Get the window. */
   Window *wdw = window_wget( wid );
   if (wdw == NULL)
      return;
 
   /* Set the accept function. */
   wdw->accept_fptr = accept;
}
 
void window_setCancel( unsigned int wid, void (*cancel)(unsigned int,const char*) )
{
   /* Get the window. */
   Window *wdw = window_wget( wid );
   if (wdw == NULL)
      return;
 
   /* Set the cancel function. */
   wdw->cancel_fptr = cancel;
}
 
void window_setOnFocus( unsigned int wid, void (*focus)(unsigned int) )
{
   /* Get the window. */
   Window *wdw = window_wget( wid );
   if (wdw == NULL)
      return;
 
   /* Set the cancel function. */
   wdw->focus_fptr = focus;
}
 
void window_setData( unsigned int wid, void *data )
{
   /* Get the window. */
   Window *wdw = window_wget( wid );
   if (wdw == NULL)
      return;
 
   /* Set data. */
   wdw->udata = data;
}
 
void* window_getData( unsigned int wid )
{
   /* Get the window. */
   const Window *wdw = window_wget( wid );
   if (wdw == NULL)
      return NULL;
 
   /* Get data. */
   return wdw->udata;
}
 
void window_setBorder( unsigned int wid, int enable )
{
   /* Get the window. */
   Window *wdw = window_wget( wid );
   if (wdw == NULL)
      return;
 
   if (enable)
      window_rmFlag( wdw, WINDOW_NOBORDER );
   else
      window_setFlag( wdw, WINDOW_NOBORDER );
}
 
void window_handleKeys( unsigned int wid,
      int (*keyhandler)(unsigned int,SDL_Keycode,SDL_Keymod,int) )
{
   /* Get the window. */
   Window *wdw = window_wget( wid );
   if (wdw == NULL)
      return;
 
   /* Set key event handler function. */
   wdw->keyevent = keyhandler;
}
 
void window_handleEvents( unsigned int wid,
      int (*eventhandler)(unsigned int,SDL_Event*) )
{
   /* Get the window. */
   Window *wdw = window_wget( wid );
   if (wdw == NULL)
      return;
 
   /* Set key event handler function. */
   wdw->eventevent = eventhandler;
}
 
void widget_cleanup( Widget *widget )
{
   /* Type specific clean up. */
   if (widget->cleanup != NULL)
      widget->cleanup(widget);
 
   /* General freeing. */
   free(widget->name);
}
 
void widget_setStatus( Widget *wgt, WidgetStatus sts )
{
   if (wgt->status != sts)
      toolkit_rerender();
   wgt->status = sts;
}
 
void toolkit_closeAll( void )
{
   for (Window *w = windows; w != NULL; w = w->next)
      window_destroy( w->id );
}
 
void window_close( unsigned int wid, const char *str )
{
   (void) str;
   window_destroy( wid );
}
 
void window_destroy( unsigned int wid )
{
   if (windows == NULL)
      return;
   /* Destroy the window */
   for (Window *wdw = windows; wdw != NULL; wdw = wdw->next) {
      Window *wactive;
 
      /* Not the window we're looking for. */
      if (wdw->id != wid)
         continue;
 
      /* Already being killed, skip. */
      if (window_isFlag( wdw, WINDOW_KILL ))
         continue;
 
      /* Mark children for death. */
      for (Window *w = windows; w != NULL; w = w->next)
         if (w->parent == wid)
            window_destroy( w->id );
 
      /* Clean up. */
      window_cleanup( wdw );
      window_setFlag( wdw, WINDOW_KILL );
      toolkit_rerender();
 
      /* Disable text input, etc. */
      toolkit_focusClear( wdw );
 
      wactive = toolkit_getActiveWindow();
      if (wactive == NULL)
         break;
 
      toolkit_expose( wactive, 1 );
      break;
   }
 
   /* Do focus. */
   for (Window *w = windows; w != NULL; w = w->next) {
      if (!window_isFlag(w, WINDOW_KILL) && (w->focus_fptr!=NULL))
         w->focus_fptr( w->id );
   }
}
 
void window_kill( Window *wdw )
{
   for (Window *w = windows; w != NULL; w = w->next)
      if (w->parent == wdw->id)
         window_kill( w );
   window_cleanup( wdw );
   window_setFlag( wdw, WINDOW_KILL );
   toolkit_rerender();
}
 
static void window_cleanup( Window *wdw )
{
   /* Run the close function first. */
   if (wdw->close_fptr != NULL)
      wdw->close_fptr( wdw->id, wdw->name );
   wdw->close_fptr = NULL;
}
 
static void window_remove( Window *wdw )
{
   Widget *wgt;
 
   /* Destroy the window. */
   free(wdw->name);
   free(wdw->displayname);
   wgt = wdw->widgets;
   while (wgt != NULL) {
      Widget *wgtkill = wgt;
      wgt = wgtkill->next;
      widget_kill(wgtkill);
   }
   free(wdw);
 
   /* Clear key repeat, since toolkit could miss the keyup event. */
   toolkit_clearKey();
}
 
int widget_exists( unsigned int wid, const char* wgtname )
{
   /* Get window. */
   Window *w = window_wget(wid);
   if (w==NULL) {
      WARN(_("window '%d' does not exist"), wid);
      return 0;
   }
 
   /* Check for widget. */
   for (Widget *wgt=w->widgets; wgt!=NULL; wgt=wgt->next)
      if (strcmp(wgtname, wgt->name)==0)
         return !wgt_isFlag(wgt, WGT_FLAG_KILL);
 
   return 0;
}
 
void window_destroyWidget( unsigned int wid, const char* wgtname )
{
   Window *wdw;
   Widget *wgt;
 
   /* Get the window. */
   wdw = window_wget( wid );
   if (wdw == NULL)
      return;
 
   /* Get the widget. */
   for (wgt=wdw->widgets; wgt!=NULL; wgt=wgt->next)
      if (strcmp(wgt->name, wgtname)==0)
         break;
 
   if (wgt == NULL) {
      WARN(_("Widget '%s' not found in window '%s'"), wgtname, wdw->displayname );
      return;
   }
 
   toolkit_defocusWidget( wdw, wgt );
 
   /* There's dead stuff now. */
   wgt_rmFlag( wgt, WGT_FLAG_FOCUSED );
   wgt_setFlag( wgt, WGT_FLAG_KILL );
}
 
static void widget_kill( Widget *wgt )
{
   /* Clean up. */
   widget_cleanup(wgt);
   free(wgt);
}
 
void toolkit_drawOutlineThick( int x, int y, int w, int h, int b,
      int thick, const glColour* c, const glColour* lc )
{
   GLshort tri[5][4];
   glColour colours[10];
 
   x -= (b - thick);
   w += 2 * (b - thick);
   y -= (b - thick);
   h += 2 * (b - thick);
   lc = lc ? lc : c;
 
   /* Left-up. */
   tri[0][0]     = x;         /* Inner */
   tri[0][1]     = y;
   tri[0][2]     = x-thick;   /* Outer */
   tri[0][3]     = y-thick;
   colours[0]    = *lc;
   colours[1]    = *lc;
 
   /* Left-down. */
   tri[1][0]     = x;         /* Inner. */
   tri[1][1]     = y + h;
   tri[1][2]     = x-thick;   /* Outer. */
   tri[1][3]     = y + h+thick;
   colours[2]    = *c;
   colours[3]    = *c;
 
   /* Right-down. */
   tri[2][0]     = x + w;       /* Inner. */
   tri[2][1]     = y + h;
   tri[2][2]     = x + w+thick; /* Outer. */
   tri[2][3]     = y + h+thick;
   colours[4]    = *c;
   colours[5]    = *c;
 
   /* Right-up. */
   tri[3][0]     = x + w;       /* Inner. */
   tri[3][1]     = y;
   tri[3][2]     = x + w+thick; /* Outer. */
   tri[3][3]     = y-thick;
   colours[6]    = *lc;
   colours[7]    = *lc;
 
   /* Left-up. */
   tri[4][0]     = x;         /* Inner */
   tri[4][1]     = y;
   tri[4][2]     = x-thick;   /* Outer */
   tri[4][3]     = y-thick;
   colours[8]    = *lc;
   colours[9]    = *lc;
 
   /* Upload to the VBO. */
   gl_vboSubData( toolkit_vbo, 0, sizeof(tri), tri );
   gl_vboSubData( toolkit_vbo, toolkit_vboColourOffset, sizeof(colours), colours );
 
   gl_beginSmoothProgram(gl_view_matrix);
   gl_vboActivateAttribOffset( toolkit_vbo, shaders.smooth.vertex, 0, 2, GL_SHORT, 0 );
   gl_vboActivateAttribOffset( toolkit_vbo, shaders.smooth.vertex_colour,
         toolkit_vboColourOffset, 4, GL_FLOAT, 0 );
   glDrawArrays( GL_TRIANGLE_STRIP, 0, 10 );
   gl_endSmoothProgram();
}
 
void toolkit_drawOutline( int x, int y, int w, int h, int b,
      const glColour* c, const glColour* lc )
{
   GLshort lines[4][2];
   glColour colours[4];
 
   x -= b, w += 2 * b;
   y -= b, h += 2 * b;
   lc = lc ? lc : c;
 
   /* Lines. */
   lines[0][0]   = x;  /* left-up */
   lines[0][1]   = y;
   colours[0]    = *lc;
 
   lines[1][0]   = x;      /* left-down */
   lines[1][1]   = y + h;
   colours[1]    = *c;
 
   lines[2][0]   = x + w;  /* right-down */
   lines[2][1]   = y + h;
   colours[2]    = *c;
 
   lines[3][0]   = x + w;  /* right-up */
   lines[3][1]   = y;
   colours[3]    = *lc;
 
   /* Upload to the VBO. */
   gl_vboSubData( toolkit_vbo, 0, sizeof(lines), lines );
   gl_vboSubData( toolkit_vbo, toolkit_vboColourOffset, sizeof(colours), colours );
 
   gl_beginSmoothProgram(gl_view_matrix);
   gl_vboActivateAttribOffset( toolkit_vbo, shaders.smooth.vertex, 0, 2, GL_SHORT, 0 );
   gl_vboActivateAttribOffset( toolkit_vbo, shaders.smooth.vertex_colour,
         toolkit_vboColourOffset, 4, GL_FLOAT, 0 );
   glDrawArrays( GL_LINE_LOOP, 0, 4 );
   gl_endSmoothProgram();
}
void toolkit_drawRect( int x, int y, int w, int h,
      const glColour* c, const glColour* lc )
{
   GLshort vertex[4][2];
   glColour colours[4];
 
   lc = lc == NULL ? c : lc;
 
   /* Set up vertices and colours. */
   vertex[0][0] = x;        /* left-up */
   vertex[0][1] = y;
   colours[0]   = *c;
 
   vertex[1][0] = x;        /* left-down */
   vertex[1][1] = y + h;
   colours[1]   = *lc;
 
   vertex[2][0] = x + w;    /* right-up */
   vertex[2][1] = y;
   colours[2]   = *c;
 
   vertex[3][0] = x + w;    /* right-down */
   vertex[3][1] = y + h;
   colours[3]   = *lc;
 
   /* Upload to the VBO. */
   gl_vboSubData( toolkit_vbo, 0, sizeof(vertex), vertex );
   gl_vboSubData( toolkit_vbo, toolkit_vboColourOffset, sizeof(colours), colours );
 
   gl_beginSmoothProgram(gl_view_matrix);
   gl_vboActivateAttribOffset( toolkit_vbo, shaders.smooth.vertex, 0, 2, GL_SHORT, 0 );
   gl_vboActivateAttribOffset( toolkit_vbo, shaders.smooth.vertex_colour,
         toolkit_vboColourOffset, 4, GL_FLOAT, 0 );
   glDrawArrays( GL_TRIANGLE_STRIP, 0, 4 );
   gl_endSmoothProgram();
}
 
void toolkit_drawTriangle( int x1, int y1, int x2, int y2, int x3, int y3,
                       const glColour* c )
{
   GLshort vertex[3][2];
   glColour colours[3];
 
   /* Set up vertices and colours. */
   vertex[0][0] = x1;        /* left-up */
   vertex[0][1] = y1;
   colours[0]   = *c;
 
   vertex[1][0] = x2;        /* left-down */
   vertex[1][1] = y2;
   colours[1]   = *c;
 
   vertex[2][0] = x3;    /* right-up */
   vertex[2][1] = y3;
   colours[2]   = *c;
 
   /* Upload to the VBO. */
   gl_vboSubData( toolkit_vbo, 0, sizeof(vertex), vertex );
   gl_vboSubData( toolkit_vbo, toolkit_vboColourOffset, sizeof(colours), colours );
 
   gl_beginSmoothProgram(gl_view_matrix);
   gl_vboActivateAttribOffset( toolkit_vbo, shaders.smooth.vertex, 0, 2, GL_SHORT, 0 );
   gl_vboActivateAttribOffset( toolkit_vbo, shaders.smooth.vertex_colour,
         toolkit_vboColourOffset, 4, GL_FLOAT, 0 );
   glDrawArrays( GL_TRIANGLE_STRIP, 0, 3 );
   gl_endSmoothProgram();
}
 
void toolkit_drawAltText( int bx, int by, const char *alt )
{
   double w, h;
   double x, y;
   glColour c;
   glColour c2;
 
   /* We're on top of anything previously drawn. */
   glClear( GL_DEPTH_BUFFER_BIT );
 
   /* Get dimensions. */
   w = MIN( gl_printWidthRaw( &gl_smallFont, alt ), 400 );
   h = gl_printHeightRaw( &gl_smallFont, w, alt );
 
   /* Choose position. */
   x = bx + 10.;
   y = by - h - gl_smallFont.h - 10.;
   if (y < 10.)
      y = 10.;
   if (x+w+10. > gl_screen.nw)
      x -= w;
 
   /* Set colours. */
   c.r = cGrey20.r;
   c.g = cGrey20.g;
   c.b = cGrey20.b;
   c.a = 0.9;
   c2.r = cGrey10.r;
   c2.g = cGrey10.g;
   c2.b = cGrey10.b;
   c2.a = 0.7;
   toolkit_drawRect( x+1, y+1, w+18, h+18, &c2, NULL );
   toolkit_drawRect( x, y, w+18, h+18, &c, NULL );
   gl_printTextRaw( &gl_smallFont, w, h, x + 9, y + 9, 0, &cFontWhite, -1., alt );
}
 
static void window_renderBorder( const Window* w )
{
   /* Position */
   double x = w->x;
   double y = w->y;
 
   /*
    * Case fullscreen.
    */
   if (window_isFlag( w, WINDOW_FULLSCREEN )) {
      /* Background. */
      toolkit_drawRect( x, y, w->w, w->h, toolkit_col, NULL );
      /* Name. */
      gl_printMidRaw( &gl_defFont, w->w,
            x,
            y + w->h - 20.,
            &cFontWhite, -1., w->displayname );
      return;
   }
 
   toolkit_drawRect( x, y, w->w, w->h, toolkit_col, NULL );
   toolkit_drawOutlineThick( x, y, w->w, w->h, 1, 2, toolkit_colDark, NULL );
   toolkit_drawOutline( x + 3, y + 2, w->w - 5, w->h - 5, 1, toolkit_colLight, NULL );
 
   /*
    * render window name
    */
   gl_printMidRaw( &gl_defFont, w->w,
         x,
         y + w->h - 20.,
         &cFontWhite, -1., w->displayname );
}
 
void window_render( Window *w, int top )
{
   /* We're on top of anything previously drawn. */
   glClear( GL_DEPTH_BUFFER_BIT );
 
   /* See if needs border. */
   if (!window_isFlag( w, WINDOW_NOBORDER ))
      window_renderBorder(w);
 
   /* Iterate over widgets. */
   for (Widget *wgt=w->widgets; wgt!=NULL; wgt=wgt->next) {
      if (wgt->render==NULL)
         continue;
      if (wgt_isFlag(wgt, WGT_FLAG_KILL))
         continue;
 
      /* Only render non-dynamics. */
      if (!wgt_isFlag(wgt, WGT_FLAG_DYNAMIC) || !top)
         wgt->render( wgt, w->x, w->y );
 
      if (wgt->id == w->focus) {
         double wx  = w->x + wgt->x - 2;
         double wy  = w->y + wgt->y - 2;
         toolkit_drawOutlineThick( wx, wy, wgt->w+4, wgt->h+4, 0, 2, (wgt->type == WIDGET_BUTTON ? &cGrey70 : &cGrey30), NULL );
      }
   }
}
 
void window_renderDynamic( Window *w )
{
   /* Iterate over widgets. */
   for (Widget *wgt=w->widgets; wgt!=NULL; wgt=wgt->next) {
      if (wgt->render==NULL)
         continue;
      if (wgt_isFlag(wgt, WGT_FLAG_KILL))
         continue;
      if (wgt_isFlag(wgt, WGT_FLAG_DYNAMIC) || window_isFlag(w, WINDOW_DYNAMIC))
         wgt->render( wgt, w->x, w->y );
      if (wgt->renderDynamic != NULL)
         wgt->renderDynamic( wgt, w->x, w->y );
   }
}
 
void window_renderOverlay( Window *w )
{
   /* Draw overlays. */
   for (Widget *wgt=w->widgets; wgt!=NULL; wgt=wgt->next)
      if ((wgt->renderOverlay != NULL) && !wgt_isFlag(wgt, WGT_FLAG_KILL))
         wgt->renderOverlay( wgt, w->x, w->y );
}
 
void toolkit_drawScrollbar( int x, int y, int w, int h, double pos )
{
   double sy;
 
   /* scrollbar background */
   toolkit_drawRect( x, y, w, h, &cGrey10, NULL );
 
   /* Bar itself. */
   sy = y + (h - 30.) * (1.-pos);
   toolkit_drawRect( x, sy, w, 30., toolkit_colLight, NULL );
   toolkit_drawOutline( x+1, sy, w-2, 30., 0., toolkit_colDark, NULL );
}
 
void toolkit_render( double dt )
{
   (void) dt;
   Window *top = toolkit_getActiveWindow();
 
   if (toolkit_needsRender) {
      toolkit_needsRender = 0;
 
      glBindFramebuffer( GL_FRAMEBUFFER, gl_screen.fbo[3] );
      glClearColor( 0., 0., 0., 0. );
      glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
      glBlendFuncSeparate( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA );
 
      /* Render base. */
      for (Window *w = windows; w!=NULL; w = w->next) {
         if (window_isFlag(w, WINDOW_NORENDER | WINDOW_KILL))
            continue;
         if ((w==top) && window_isFlag(w,WINDOW_DYNAMIC))
            continue;
 
         /* The actual rendering. */
         window_render( w, w==top );
      }
 
      glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
      glBindFramebuffer(GL_FRAMEBUFFER, gl_screen.current_fbo);
      glClearColor( 0., 0., 0., 1. );
   }
 
   glUseProgram(shaders.texture.program);
 
   /* Set texture. */
   glActiveTexture( GL_TEXTURE0 );
   glBindTexture( GL_TEXTURE_2D, gl_screen.fbo_tex[3] );
   glUniform1i(shaders.texture.sampler, 0);
 
   /* Set vertex data. */
   glEnableVertexAttribArray( shaders.texture.vertex );
   gl_vboActivateAttribOffset( gl_squareVBO, shaders.texture.vertex,
         0, 2, GL_FLOAT, 0 );
 
   /* Set shader uniforms. */
   gl_uniformColour(shaders.texture.colour, &cWhite);
   const mat4 ortho = mat4_ortho(0., 1., 0., 1., 1., -1.);
   const mat4 I = mat4_identity();
   gl_uniformMat4(shaders.texture.projection, &ortho);
   gl_uniformMat4(shaders.texture.tex_mat, &I);
 
   /* Draw. */
   glDrawArrays( GL_TRIANGLE_STRIP, 0, 4 );
 
   /* Clean up. */
   glDisableVertexAttribArray( shaders.texture.vertex );
   glBindTexture( GL_TEXTURE_2D, 0 );
   gl_checkErr();
   glUseProgram(0);
 
   /* We render only the active window dynamically, otherwise we wouldn't be able to respect the order.
    * However, since the dynamic stuff is also rendered to the framebuffer below, it shouldn't be too bad. */
   if ((top != NULL) && !window_isFlag(top, WINDOW_NORENDER | WINDOW_KILL)) {
      window_renderDynamic( top );
      window_renderOverlay( top );
   }
}
 
void toolkit_rerender (void)
{
   toolkit_needsRender = 1;
}
 
int toolkit_input( SDL_Event* event )
{
   /* Get window that can be focused. */
   Window *wdw = toolkit_getActiveWindow();
   if (wdw == NULL)
      return 0;
 
   /* Pass event to window. */
   return toolkit_inputWindow( wdw, event, 1 );
}
 
int toolkit_inputWindow( Window *wdw, SDL_Event *event, int purge )
{
   int ret;
 
   /* See if widget needs event. */
   for (Widget *wgt=wdw->widgets; wgt!=NULL; wgt=wgt->next) {
      if (!wgt_isFlag( wgt, WGT_FLAG_RAWINPUT ))
         continue;
      if (wgt->rawevent==NULL)
         continue;
      ret = wgt->rawevent( wgt, event );
      if (ret != 0) {
         toolkit_rerender();
         return ret;
      }
   }
 
   /* Event handler. */
   if (wdw->eventevent != NULL) {
      ret = wdw->eventevent( wdw->id, event );
      if (ret != 0) {
         toolkit_rerender();
         return ret;
      }
   }
 
   /* Hack in case window got destroyed in eventevent. */
   ret = 0;
   if (!window_isFlag(wdw, WINDOW_KILL)) {
      /* Pass it on. */
      switch (event->type) {
         case SDL_MOUSEMOTION:
         case SDL_MOUSEBUTTONDOWN:
         case SDL_MOUSEBUTTONUP:
         case SDL_MOUSEWHEEL:
            ret |= toolkit_mouseEvent(wdw, event);
            break;
 
         case SDL_KEYDOWN:
         case SDL_KEYUP:
            ret |= toolkit_keyEvent(wdw, event);
            break;
 
         case SDL_TEXTINPUT:
            ret |= toolkit_textEvent(wdw, event);
            break;
         case SDL_TEXTEDITING:
            break;
      }
   }
   if (ret)
      toolkit_rerender();
 
   /* Clean up the dead if needed. */
   if (purge && !dialogue_isOpen()) { /* Hack, since dialogues use secondary loop. */
      if (toolkit_delayCounter > 0)
         toolkit_delayCounter--;
      else
         toolkit_purgeDead();
   }
 
   return ret; /* don't block input */
}
 
Uint32 toolkit_inputTranslateCoords( const Window *w, SDL_Event *event,
      int *x, int *y, int *rx, int *ry )
{
   /* Extract the position as event. */
   if (event->type==SDL_MOUSEMOTION) {
      *x = event->motion.x;
      *y = event->motion.y;
   }
   else if ((event->type==SDL_MOUSEBUTTONDOWN) || (event->type==SDL_MOUSEBUTTONUP)) {
      *x = event->button.x;
      *y = event->button.y;
   }
   else if (event->type == SDL_MOUSEWHEEL)
      SDL_GetMouseState( x, y );
 
   /* Translate offset. */
   gl_windowToScreenPos( x, y, *x, *y );
 
   /* Transform to relative to window. */
   *x -= w->x;
   *y -= w->y;
 
   /* Relative only matter if mouse motion. */
   if (event->type==SDL_MOUSEMOTION) {
      *ry = (double)event->motion.yrel * gl_screen.mxscale;
      *rx = (double)event->motion.xrel * gl_screen.myscale;
   }
   else {
      *ry = 0;
      *rx = 0;
   }
 
   return event->type;
}
 
static int toolkit_mouseEventSingle( Window *w, SDL_Event* event,
      Widget *wgt, int x, int y, int rx, int ry )
{
   int ret = 0;
   /* Custom widgets take it from here */
   if (wgt->type==WIDGET_CUST) {
      if (wgt->dat.cst.mouse)
         ret = wgt->dat.cst.mouse( w->id, event, x-wgt->x, y-wgt->y, wgt->w, wgt->h, rx, ry,
               wgt->dat.cst.userdata );
   }
   else
      ret = toolkit_mouseEventWidget( w, wgt, event, x, y, rx, ry );
   return ret;
}
static int toolkit_mouseEventReverse( Window *w, SDL_Event* event,
      Widget *wgt, int x, int y, int rx, int ry )
{
   if (wgt->next!=NULL) {
      int ret = toolkit_mouseEventReverse( w, event, wgt->next, x, y, rx, ry );
      if (ret)
         return ret;
   }
 
   return toolkit_mouseEventSingle( w, event, wgt, x, y, rx, ry );
}
static int toolkit_mouseEvent( Window *w, SDL_Event* event )
{
   int x, y, rx, ry;
 
   /* Translate mouse coords. */
   toolkit_inputTranslateCoords( w, event, &x, &y, &rx, &ry );
 
   /* Check each widget. */
   if (w->widgets != NULL)
      return toolkit_mouseEventReverse( w, event, w->widgets, x, y, rx, ry );
   return 0;
}
 
static int toolkit_mouseEventWidget( Window *w, Widget *wgt,
      SDL_Event *event, int x, int y, int rx, int ry )
{
   int ret, inbounds;
   Uint8 button;
 
   /* Widget translations. */
   x -= wgt->x;
   y -= wgt->y;
 
   /* Handle mouse event. */
   if (event->type == SDL_MOUSEMOTION)
      button = event->motion.state;
   else
      button = event->button.button;
 
   /* Check inbounds. */
   inbounds = !((x < 0) || (x >= wgt->w) || (y < 0) || (y >= wgt->h));
 
   /* Regular widgets. */
   ret = 0;
   switch (event->type) {
      case SDL_MOUSEMOTION:
         /* Change the status of the widget if mouse isn't down. */
 
         /* Not scrolling. */
         if (wgt->status != WIDGET_STATUS_SCROLLING) {
            if (inbounds) {
               if (wgt->status != WIDGET_STATUS_MOUSEDOWN)
                  widget_setStatus( wgt, WIDGET_STATUS_MOUSEOVER );
            }
            else
               widget_setStatus( wgt, WIDGET_STATUS_NORMAL );
         }
         else
            inbounds = 1; /* Scrolling is always inbounds. */
 
         /* If always gets the event. */
         if (wgt_isFlag( wgt, WGT_FLAG_ALWAYSMMOVE ))
            inbounds = 1;
 
         /* Try to give the event to the widget. */
         if (inbounds && (wgt->mmoveevent != NULL))
            ret |= (*wgt->mmoveevent)( wgt, x, y, rx, ry );
 
         break;
 
      case SDL_MOUSEWHEEL:
         if (!inbounds)
            break;
 
         /* Try to give the event to the widget. */
         if (wgt->mwheelevent != NULL)
            ret |= (*wgt->mwheelevent)( wgt, event->wheel );
         if (ret)
            toolkit_rerender();
 
         break;
 
      case SDL_MOUSEBUTTONDOWN:
         if (!inbounds)
            break;
 
         /* Update the status. */
         if (button == SDL_BUTTON_LEFT)
            widget_setStatus( wgt, WIDGET_STATUS_MOUSEDOWN );
 
         if (toolkit_isFocusable(wgt)) {
            toolkit_focusClear( w );
            toolkit_focusWidget( w, wgt );
         }
 
         /* Try to give the event to the widget. */
         if (wgt->mdoubleclickevent != NULL && input_isDoubleClick( (void*)wgt ))
            ret |= (*wgt->mdoubleclickevent)( wgt, button, x, y );
         else if (wgt->mclickevent != NULL)
            ret |= (*wgt->mclickevent)( wgt, button, x, y );
         if (ret) {
            input_clicked( (void*)wgt );
            toolkit_rerender();
         }
         break;
 
      case SDL_MOUSEBUTTONUP:
         /* Since basically only buttons are handled here, we ignore
          * it all except the left mouse button. */
         if (button != SDL_BUTTON_LEFT)
            break;
 
         if (wgt->status==WIDGET_STATUS_MOUSEDOWN) {
            /* Soft-disabled buttons will run anyway. */
            if ((wgt->type==WIDGET_BUTTON) && ((wgt->dat.btn.disabled==0) ||
                     (wgt->dat.btn.softdisable))) {
               if (wgt->dat.btn.fptr==NULL)
                  DEBUG(_("Toolkit: Button '%s' of Window '%s' "
                           "doesn't have a function trigger"),
                        wgt->name, w->displayname );
               else {
                  (*wgt->dat.btn.fptr)(w->id, wgt->name);
                  ret = 1;
                  toolkit_rerender();
               }
            }
         }
 
         /* Signal scroll done if necessary. */
         if ((wgt->status == WIDGET_STATUS_SCROLLING) && (wgt->scrolldone != NULL))
            wgt->scrolldone( wgt );
 
         /* Always goes normal unless is below mouse. */
         if (inbounds)
            widget_setStatus( wgt, WIDGET_STATUS_MOUSEOVER );
         else
            widget_setStatus( wgt, WIDGET_STATUS_NORMAL );
 
         break;
   }
 
   return ret;
}
 
static SDL_Keymod toolkit_mapMod( SDL_Keycode key )
{
   switch(key) {
      case SDLK_LCTRL:
         return KMOD_LCTRL;
      case SDLK_RCTRL:
         return KMOD_RCTRL;
      case SDLK_LALT:
         return KMOD_LALT;
      case SDLK_RALT:
         return KMOD_RALT;
      case SDLK_LSHIFT:
         return KMOD_LSHIFT;
      case SDLK_RSHIFT:
         return KMOD_RSHIFT;
      default:
         return 0;
   }
}
 
static void toolkit_regKey( SDL_Keycode key )
{
   /* See if our key is in fact a modifier key, and if it is, convert it to a mod.
    * If it is indeed a mod, do not register a new key but add the modifier to the mod mask instead.
    */
   SDL_Keymod mod = toolkit_mapMod(key);
   if (mod)
      input_mod |= mod;
   /* Don't reset values on repeat keydowns. */
   else
      input_key = key;
}
 
static void toolkit_unregKey( SDL_Keycode key )
{
   /* See if our key is in fact a modifier key, and if it is, convert it to a mod.
    * If it is indeed a mod, do not unregister the key but subtract the modifier from the mod mask instead.
    */
   SDL_Keymod mod = toolkit_mapMod(key);
   if (mod)
      input_mod         &= ~mod;
   else
      toolkit_clearKey();
}
 
void toolkit_clearKey (void)
{
   input_key         = 0;
}
static int toolkit_keyEvent( Window *wdw, SDL_Event* event )
{
   Widget *wgt;
   SDL_Keycode key;
   SDL_Keymod mod;
   int rep, ret;
 
   /* Event info. */
   key = event->key.keysym.sym;
   mod = event->key.keysym.mod;
   rep = event->key.repeat;
 
   /* Hack to simulate key repetition */
   if (event->type == SDL_KEYDOWN)
      toolkit_regKey(key);
   else if (event->type == SDL_KEYUP)
      toolkit_unregKey(key);
 
   /* See if window is valid. */
   if (wdw == NULL)
      return 0;
 
   /* Get widget. */
   wgt = toolkit_getFocus( wdw );
 
   /* We only want keydown from now on. */
   if (event->type != SDL_KEYDOWN)
      return 0;
 
   /* Trigger event function if exists. */
   if (wgt != NULL) {
      if (wgt->keyevent != NULL) {
         ret = wgt->keyevent( wgt, input_key, input_mod, rep );
         if (ret!=0)
            return ret;
      }
   }
 
   if (input_key != 0 && !rep) {
      /* Handle button hotkeys. We don't want a held-down key to keep activating buttons, so forbid "repeat". */
      for ( wgt = wdw->widgets; wgt != NULL; wgt = wgt->next ) {
         if ( ( wgt->type == WIDGET_BUTTON ) && ( wgt->dat.btn.key == input_key )
               && wgt->keyevent != NULL ) {
            ret = wgt->keyevent( wgt, SDLK_RETURN, input_mod, rep );
            if (ret!=0)
               return ret;
         }
      }
 
      /* Handle other cases where event might be used by the window... and we don't want key-repeat. */
      switch (key) {
         case SDLK_RETURN:
         case SDLK_KP_ENTER:
            if (wdw->accept_fptr != NULL) {
               wdw->accept_fptr( wdw->id, wdw->name );
               return 1;
            }
            break;
 
         case SDLK_ESCAPE:
            if (wdw->cancel_fptr != NULL) {
               wdw->cancel_fptr( wdw->id, wdw->name );
               return 1;
            }
            break;
 
         default:
            break;
      }
   }
 
   /* Finally the stuff gets passed to the custom key handler if it's defined. */
   if (wdw->keyevent != NULL) {
      ret = (*wdw->keyevent)( wdw->id, input_key, input_mod, rep );
      if (ret!=0)
         return ret;
   }
 
   /* Placed here so it can be overriden in console for tab completion. */
   if (key == SDLK_TAB) {
      if (mod & (KMOD_LSHIFT | KMOD_RSHIFT))
         toolkit_prevFocus( wdw );
      else
         toolkit_nextFocus( wdw );
      return 1;
   }
 
   return 0;
}
static int toolkit_textEvent( Window *wdw, SDL_Event* event )
{
   Widget *wgt;
 
   /* See if window is valid. */
   if (wdw == NULL)
      return 0;
 
   /* Get widget. */
   wgt = toolkit_getFocus( wdw );
 
   /* Trigger event function if exists. */
   if ((wgt != NULL) && (wgt->textevent != NULL)) {
      int ret = (*wgt->textevent)( wgt, event->text.text );
      if (ret!=0)
         return ret;
   }
 
   return 0;
}
 
static void toolkit_purgeDead (void)
{
   Window *wdw, *wlast;
 
   /* Must be windows. */
   if (windows == NULL)
      return;
 
   /* Destroy what is needed. */
   wlast = NULL;
   wdw   = windows;
   while (wdw != NULL) {
      if (window_isFlag( wdw, WINDOW_KILL )) {
         /* Save target. */
         Window *wkill = wdw;
         /* Clean up while still in list. */
         window_cleanup( wdw );
         /* Reattach linked list. */
         if (wlast == NULL)
            windows = wdw->next;
         else
            wlast->next = wdw->next;
         wdw = wlast;
         /* Kill target. */
         wkill->next = NULL;
         window_remove( wkill );
      }
      else {
         Widget *wgtlast = NULL;
         Widget *wgt     = wdw->widgets;
         while (wgt != NULL) {
            if (wgt_isFlag( wgt, WGT_FLAG_KILL )) {
               /* Save target. */
               Widget *wgtkill = wgt;
               /* Reattach linked list. */
               if (wgtlast == NULL)
                  wdw->widgets  = wgt->next;
               else
                  wgtlast->next = wgt->next;
               wgt = wgtlast;
               /* Kill target. */
               wgtkill->next = NULL;
               widget_kill( wgtkill );
            }
            /* Save position. */
            wgtlast = wgt;
            if (wgt == NULL)
               wgt = wdw->widgets;
            else
               wgt = wgt->next;
         }
      }
      /* Save position. */
      wlast = wdw;
      if (wdw == NULL)
         wdw = windows;
      else
         wdw = wdw->next;
   }
}
 
void toolkit_update (void)
{
   /* Clean up the dead if needed. */
   if (!dialogue_isOpen()) { /* Hack, since dialogues use secondary loop. */
      if (toolkit_delayCounter > 0)
         toolkit_delayCounter--;
      else
         toolkit_purgeDead();
   }
 
   /* Killed all the windows. */
   if (!toolkit_isOpen()) {
 
      input_mouseHide();
      if (paused && !player_paused)
         unpause_game();
   }
}
 
static void toolkit_expose( Window *wdw, int expose )
{
   if (expose == wdw->exposed)
      return;
   else
      wdw->exposed = expose;
 
   if (expose)
      toolkit_focusSanitize( wdw );
   else
      toolkit_focusClear( wdw );
 
   if (wdw->focus != -1)
      return;
 
   /* Notify widgets (for tabbed children, etc.) */
   for (Widget *wgt = wdw->widgets; wgt != NULL; wgt = wgt->next)
      if (wgt->exposeevent != NULL)
         wgt->exposeevent( wgt, expose );
}
 
void toolkit_focusClear( Window *wdw )
{
   if (wdw->focus == -1)
      return;
 
   for (Widget *wgt=wdw->widgets; wgt!=NULL; wgt=wgt->next)
      toolkit_defocusWidget( wdw, wgt );
}
 
void toolkit_focusSanitize( Window *wdw )
{
   int focus = wdw->focus;
 
   /* Clear focus. */
   toolkit_focusClear( wdw );
 
   /* No focus is always safe. */
   if (focus == -1)
      return;
 
   /* Check focused widget. */
   for (Widget *wgt=wdw->widgets; wgt!=NULL; wgt=wgt->next) {
      if (focus == wgt->id) {
         /* Not focusable. */
         if (!toolkit_isFocusable(wgt))
            toolkit_nextFocus( wdw ); /* Get first focus. */
         else
            toolkit_focusWidget( wdw, wgt );
 
         return;
      }
   }
}
 
void toolkit_nextFocus( Window *wdw )
{
   int next;
 
   /* Clear focus. */
   toolkit_focusClear( wdw );
 
   /* See what to focus. */
   next = (wdw->focus == -1);
   for (Widget *wgt=wdw->widgets; wgt!=NULL; wgt=wgt->next) {
      if (!toolkit_isFocusable(wgt))
         continue;
 
      if (next) {
         toolkit_focusWidget( wdw, wgt );
         return;
      }
      else if (wdw->focus == wgt->id) {
         next = 1;
      }
   }
 
   /* Focus nothing. */
   wdw->focus = -1;
   toolkit_rerender();
   return;
}
 
void toolkit_prevFocus( Window *wdw )
{
   Widget *prev;
   int focus = wdw->focus;
 
   /* Clear focus. */
   toolkit_focusClear( wdw );
 
   /* See what to focus. */
   prev = NULL;
   for (Widget *wgt=wdw->widgets; wgt!=NULL; wgt=wgt->next) {
      if (!toolkit_isFocusable(wgt))
         continue;
 
      /* See if we found the current one. */
      if (focus == wgt->id) {
         if (prev != NULL)
            toolkit_focusWidget( wdw, prev );
         return;
      }
 
      /* Store last focusable widget. */
      prev = wgt;
   }
 
   /* Focus nothing. */
   if (prev != NULL)
      toolkit_focusWidget( wdw, prev );
 
   return;
}
 
void toolkit_focusWidget( Window *wdw, Widget *wgt )
{
   if (!toolkit_isFocusable(wgt) || wgt_isFlag( wgt, WGT_FLAG_FOCUSED ))
      return;
 
   wdw->focus = wgt->id;
   wgt_setFlag( wgt, WGT_FLAG_FOCUSED );
   if (wgt->focusGain != NULL)
      wgt->focusGain( wgt );
 
   toolkit_rerender();
}
 
void toolkit_defocusWidget( Window *wdw, Widget *wgt )
{
   if (wdw->focus != wgt->id || !wgt_isFlag( wgt, WGT_FLAG_FOCUSED ))
      return;
 
   wdw->focus = -1;
   wgt_rmFlag( wgt, WGT_FLAG_FOCUSED );
   if (wgt->focusLose != NULL)
      wgt->focusLose( wgt );
 
   toolkit_rerender();
}
 
static int toolkit_isFocusable( const Widget *wgt )
{
   if (wgt==NULL)
      return 0;
 
   return wgt_isFlag(wgt, WGT_FLAG_CANFOCUS);
}
 
Window* toolkit_getActiveWindow (void)
{
   /* Get window that can be focused. */
   Window *wlast = NULL;
   for (Window *wdw = windows; wdw!=NULL; wdw = wdw->next)
      if (!window_isFlag(wdw, WINDOW_NOFOCUS) &&
            !window_isFlag(wdw, WINDOW_KILL))
         wlast = wdw;
   return wlast;
}
 
static Widget* toolkit_getFocus( Window *wdw )
{
   /* No focus. */
   if (wdw->focus == -1)
      return NULL;
 
   /* Find focus. */
   for (Widget *wgt=wdw->widgets; wgt!=NULL; wgt=wgt->next)
      if (wdw->focus == wgt->id)
         return wgt;
 
   /* Not found. */
   toolkit_focusClear( wdw );
   wdw->focus = -1;
   return NULL;
}
 
void window_setFocus( unsigned int wid, const char* wgtname )
{
   Window *wdw;
   Widget *wgt;
 
   /* Get window. */
   wdw = window_wget(wid);
   if (wdw == NULL)
      return;
 
   toolkit_focusClear( wdw );
 
   /* Get widget. */
   wgt = wgtname==NULL ? NULL : window_getwgt( wid, wgtname );
   if (wgt == NULL)
      return;
 
   toolkit_focusWidget( wdw, wgt );
}
 
char* window_getFocus( unsigned int wid )
{
   /* Get window. */
   Window *wdw = window_wget(wid);
   if (wdw == NULL)
      return NULL;
 
   /* Find focused widget. */
   for (Widget *wgt=wdw->widgets; wgt!=NULL; wgt=wgt->next)
      if (wgt->id == wdw->focus)
         return strdup( wgt->name );
 
   return NULL;
}
 
void window_raise( unsigned int wid )
{
   Window *wdw, *wtmp, *wprev, *wlast;
 
   wdw = window_wget(wid);
 
   /* Not found, or already top of the stack. */
   if (wdw == NULL || wdw->next == NULL)
      return;
 
   wprev = NULL;
   wlast = NULL;
 
   for (wtmp = windows; wtmp != NULL; wtmp = wtmp->next)
      if (wtmp->next == wdw)
         wprev = wtmp;
      else if (wtmp->next == NULL)
         wlast = wtmp;
 
   if (wprev != NULL)
      wprev->next = wdw->next; /* wdw-1 links to wdw+1 */
 
   if (wlast != NULL)
      wlast->next = wdw;       /* last links to wdw */
 
   wdw->next   = NULL;      /* wdw becomes new last window */
 
   wtmp = toolkit_getActiveWindow();
 
   /* No active window, or window is the same. */
   if (wtmp == NULL || wtmp == wdw)
      return;
 
   toolkit_expose( wtmp, 0 ); /* wtmp is hidden */
   toolkit_expose( wdw, 1 );  /* wdw is visible */
   toolkit_rerender();
}
 
void window_lower( unsigned int wid )
{
   Window *wdw, *wtmp, *wprev;
 
   wdw = window_wget(wid);
 
   /* Not found, or already bottom of the stack. */
   if (wdw == NULL || wdw == windows)
      return;
 
   wprev = NULL;
   for (wtmp = windows; wtmp != NULL; wtmp = wtmp->next)
      if (wtmp->next == wdw)
         wprev = wtmp;
 
   if (wprev != NULL)
      wprev->next = wdw->next; /* wdw-1 links to wdw+1 */
 
   wdw->next   = windows;   /* wdw links to first window */
   windows     = wdw;       /* wdw becomes new first window */
 
   wtmp = toolkit_getActiveWindow();
 
   /* No active window, or window is the same. */
   if (wtmp == NULL || wtmp == wdw)
      return;
 
   toolkit_expose( wtmp, 1 ); /* wtmp is visible */
   toolkit_expose( wdw, 0 );  /* wdw is hidden */
   toolkit_rerender();
}
 
void toolkit_resize (void)
{
   for (Window *w = windows; w != NULL; w = w->next) {
      int xdiff, ydiff;
 
      /* Fullscreen windows must always be full size, though their widgets
       * don't auto-scale. */
      if (window_isFlag( w, WINDOW_FULLSCREEN )) {
         w->w = gl_screen.nw;
         w->h = gl_screen.nh;
         continue;
      }
 
      /* Skip if position is fixed. */
      if (w->xrel == -1. && w->yrel == -1.)
         continue;
 
      xdiff = 0.;
      ydiff = 0.;
 
      if (w->xrel != -1.) {
         int xorig = w->x;
         w->x = (gl_screen.nw - w->w) * w->xrel;
         xdiff = w->x - xorig;
      }
 
      if (w->yrel != -1.) {
         int yorig = w->y;
         w->y = (gl_screen.nh - w->h) * w->yrel;
         ydiff = w->y - yorig;
      }
 
      /* Tabwin children aren't in the stack and must be manually updated. */
      for (Widget *wgt=w->widgets; wgt!=NULL; wgt=wgt->next) {
         if (wgt->type != WIDGET_TABBEDWINDOW)
            continue;
 
         for (int i=0; i<wgt->dat.tab.ntabs; i++) {
            Window *wtmp = window_wget( wgt->dat.tab.windows[i] );
            wtmp->x += xdiff;
            wtmp->y += ydiff;
         }
      }
   }
   toolkit_rerender();
}
 
int toolkit_init (void)
{
   GLsizei size;
 
   /* Create the VBO. */
   toolkit_vboColourOffset = sizeof(GLshort) * 2 * 31;
   size = (sizeof(GLshort)*2 + sizeof(GLfloat)*4) * 31;
   toolkit_vbo = gl_vboCreateStream( size, NULL );
 
   /* Disable the cursor. */
   input_mouseHide();
 
   return 0;
}
 
void toolkit_exit (void)
{
   /* Destroy the windows. */
   while (windows!=NULL) {
      Window *wdw = windows;
      windows  = windows->next;
      window_cleanup(wdw);
      window_remove(wdw);
   }
 
   /* Free the VBO. */
   gl_vboDestroy( toolkit_vbo );
   toolkit_vbo = NULL;
}