gui.temp.h

#include "ctl/ctldef.h"
#include "ctl/mstime.h"

#ifndef OPC_H
#include "opc.h"
#endif

#ifndef GUI_H
#include "gui.h"
#endif

#if ( !defined(GUI_SELECT) || !defined(GUI_GetKeyPress) || !defined(GUI_ClearKeyPress) )
#error The GUI_GetKeyPress macro and GUI_SELECT must be defined for GUI to know how to tab and select.
#endif

#if !defined(GUI_GetPointer) && !defined(GUI_TABLEFT) && !defined(GUI_TABRIGHT) && !defined(GUI_TABUP) && !defined(GUI_TABDOWN) && !defined(GUI_TAB) && !defined(GUI_TABBACK)
#error Without a pointer, tabbing must be defined for GUI_getkeybits.  As a minimum, one tab and one select.
#endif

#if !defined(GUI_PICK)
#define GUI_PICK GUI_SELECT
#endif

#if !defined(GUI_MSTime)
#error No realtime function defined
#endif

#if !defined(GUI_RepeatPause)
#define GUI_RepeatPause(rate)   132
#endif

#if !defined(GUI_DefaultRepeat)
#define GUI_DefaultRepeat       66
#endif

#ifndef GUI_Tabsound
#define GUI_Tabsound()
#endif

#ifndef GUI_SelectSound
#define GUI_SelectSound()
#endif

#ifndef GUI_CheckSound
#define GUI_CheckSound()
#endif

#ifndef GUI_UncheckSound
#define GUI_UncheckSound()
#endif

#ifndef GUI_ScrollSound
#define GUI_ScrollSound()
#endif

#ifndef GUI_Font
#define GUI_Font( font )    (font)
#endif

#ifndef GUI_Random
#include <stdlib.h>
#define GUI_Random() rand()
#define GUI_RAND_MAX RAND_MAX
#endif

#ifndef GUI_DrawText
#define GUI_ONELINE 0   
#define GUI_LEFT    0   
#define GUI_CENTER  1   
#define GUI_RIGHT   2   
#define GUI_TOP     0   
#define GUI_VCENTER 4   
#define GUI_BOTTOM  8   
#define GUI_DrawText( opc, prcBounds, flags, sz, count )

#define GUI_MeasureText( prcBounds, flags, sz, count )

#elif !defined(GUI_MeasureText)
#error GUI_MeasureText is required if you define GUI_DrawText
#endif

bool GUI_tableft( GUI* gui )
{
    int tabPrev = gui->focus < 0 ? 0 : gui->focus;
    bool bWrap = false;
    unsigned mask;
    int tab = -1;
    const GUI_Control* control = GUI_Control_Get( gui, tabPrev );
    /* Convert control index to htab index */
    pointer_foreach_const(GUI_Control* const,gui->htab,gui->cControl, curr )
    {
        if( *curr == control )
        {
            tab = tabPrev = (int)(curr - gui->htab);
            break;
        }
    }
    /* We should have found the value */
    assert( tab != -1 );
    /* Search htab for control */
    do
    {
        if( --tab < 0 )
        {
            tab = gui->cControl-1;
            bWrap = true;
        }
        control = gui->htab[tab];
        mask = GUI_Control_Mask( gui, control );
        if( !(mask & (GUICS_INVISIBLE|GUICS_NOFOCUS)) )
            break;
    }
    while( tab != tabPrev );
    /* Convert htab index to control index */
    if( tab != tabPrev )
        _GUI_SetFocus( gui, (int)(control-gui->list) );
    return bWrap;
}

bool GUI_tabright( GUI* gui )
{
    int tabPrev = gui->focus < 0 ? 0 : gui->focus;
    bool bWrap = false;
    unsigned mask;
    int tab = -1;
    const GUI_Control* control = GUI_Control_Get( gui, tabPrev );
    /* Convert control index to htab index */
    pointer_foreach_const(GUI_Control* const,gui->htab,gui->cControl, curr )
    {
        if( *curr == control )
        {
            tab = tabPrev = (int)(curr - gui->htab);
            break;
        }
    }
    /* We should have found the value */
    assert( tab != -1 );
    /* Search htab for control */
    do
    {
        if( ++tab >= gui->cControl )
        {
            tab = 0;
            bWrap = true;
        }
        control = gui->htab[tab];
        mask = GUI_Control_Mask( gui, control );
        if( !(mask & (GUICS_INVISIBLE|GUICS_NOFOCUS)) )
            break;
    }
    while( tab != tabPrev );
    /* Convert htab index to control index */
    if( tab != tabPrev )
        _GUI_SetFocus( gui, (int)(control-gui->list) );
    return bWrap;
}

bool GUI_tabup( GUI* gui )
{
    int tabPrev = gui->focus < 0 ? 0 : gui->focus;
    bool bWrap = false;
    unsigned mask;
    int tab = -1;
    const GUI_Control* control = GUI_Control_Get( gui, tabPrev );
    /* Convert control index to vtab index */
    pointer_foreach_const(GUI_Control* const,gui->vtab,gui->cControl, curr )
    {
        if( *curr == control )
        {
            tab = tabPrev = (int)(curr - gui->vtab);
            break;
        }
    }
    /* We should have found the value */
    assert( tab != -1 );
    /* Search vtab for control */
    do
    {
        if( --tab < 0 )
        {
            tab = gui->cControl-1;
            bWrap = true;
        }
        control = gui->vtab[tab];
        mask = GUI_Control_Mask( gui, control );
        if( !(mask & (GUICS_INVISIBLE|GUICS_NOFOCUS)) )
            break;
    }
    while( tab != tabPrev );
    /* Convert vtab index to control index */
    if( tab != tabPrev )
        _GUI_SetFocus( gui, (int)(control-gui->list) );
    return bWrap;
}

bool GUI_tabdown( GUI* gui )
{
    int tabPrev = gui->focus < 0 ? 0 : gui->focus;
    bool bWrap = false;
    unsigned mask;
    int tab = -1;
    const GUI_Control* control = GUI_Control_Get( gui, tabPrev );
    /* Convert control index to vtab index */
    pointer_foreach_const(GUI_Control* const,gui->vtab,gui->cControl, curr )
    {
        if( *curr == control )
        {
            tab = tabPrev = (int)(curr - gui->vtab);
            break;
        }
    }
    /* We should have found the value */
    assert( tab != -1 );
    /* Search vtab for control */
    do
    {
        if( ++tab >= gui->cControl )
        {
            tab = 0;
            bWrap = true;
        }
        control = gui->vtab[tab];
        mask = GUI_Control_Mask( gui, control );
        if( !(mask & (GUICS_INVISIBLE|GUICS_NOFOCUS)) )
            break;
    }
    while( tab != tabPrev );
    /* Convert vtab index to control index */
    if( tab != tabPrev )
        _GUI_SetFocus( gui, (int)(control-gui->list) );
    return bWrap;
}

#if ( defined(GUI_TABLEFT) || defined(GUI_TABRIGHT) || defined(GUI_TABUP) || defined(GUI_TABDOWN) || defined(GUI_TAB) || defined(GUI_TABBACK) )

bool GUI_tabhandler( struct GUI* gui )
{
    unsigned keypress = GUI_GetKeyPress();
    int prev = gui->focus;
    if( !keypress )
        return false;
#if defined(GUI_TABLEFT)
    else if( keypress == GUI_TABLEFT
#if defined(GUI_TABBACK)
        || keypress == GUI_TABBACK
#endif
        )
    {
        /* If focus wrapped and we have a parent, do focus for parent */
        if( GUI_tableft( gui ) && gui->parent && !GUI_tableft( gui->parent ) )
        {
            gui->focus = -1;
        }
        else
        {
            GUI_ClearKeyPress();
        }
    }
#endif
#if defined(GUI_TABRIGHT)
    else if( keypress == GUI_TABRIGHT
#if defined(GUI_TAB)
        || keypress == GUI_TAB
#endif
        )
    {
        if( GUI_tabright( gui ) && gui->parent && !GUI_tabright( gui->parent ) )
        {
            gui->focus = -1;
        }
        else
        {
            GUI_ClearKeyPress();
        }
    }
#endif
#if defined(GUI_TABUP)
    else if( keypress == GUI_TABUP)
    {
        if( GUI_tabup( gui ) && gui->parent && !GUI_tabup( gui->parent ) )
        {
            gui->focus = -1;
        }
        else
        {
            GUI_ClearKeyPress();
        }
    }
#endif
#if defined(GUI_TABDOWN)
    else if( keypress == GUI_TABDOWN)
    {
        if( GUI_tabdown( gui ) && gui->parent && !GUI_tabdown( gui->parent ) )
        {
            gui->focus = -1;
        }
        else
        {
            GUI_ClearKeyPress();
        }
    }
#endif
    if( gui->focus != prev )
    {
        GUI_Tabsound();
        return true;
    }
    return false;
}
#endif

void _GUI_Dirty_Rect( GUI* gui, const Rect* prc )
{
#ifdef SIMPLE_DIRTY
    RectUnionRect( gui->dirty, *prc )
#else
    /* Assert: There should be a dirty rectangle list */
    assert( gui->cdirty );
    /* 
     * Assert: We shouldn't be adding to dirty list while traversing it. 
     * It leads to hard to track down graphical glitches.
     */
    assert( !(gui->mask & GUIM_INPAINT) );
    ClipRect_add( gui->cdirty, prc );
#endif
}

bool GUI_Control_Paint( const struct GUI* gui, const GUI_Control* control, OPC* opc )
{
    GUI_Control_State* state = GUI_Control_Data( gui, control );
    if( state->mask & GUICS_INVISIBLE )
    {
        return false;
    }
    else
    {
        Rect bound;
        GUI_Control_Bound( gui, control, &bound );
        /* Just take intersection of dirty region and this control, and paint that */
        RectIntRect( bound, gui->dirty );
        if( RectEmpty( bound ) )
            return false;
        OPC_NAMING(Clip)( opc, &gui->opc, &bound );
    }
    return true;
}

bool _GUI_IsOpen( GUI* gui )
{
    return gui && (gui->mask & GUIM_ALIVE);
}

int _GUI_SetFocus( GUI* gui, int ifocus )
{
    int focusPrev;
    assert(gui);
    focusPrev = gui->focus;
    gui->focus = ifocus;
    if( gui->focus >= 0 && gui->focus < gui->cControl )
    {
        if( GUI_Control_IsFocused( gui, gui->list + gui->focus ) )
        {
            if( focusPrev != gui->focus )
            {
                GUI_Control_Dirty( gui, gui->list + gui->focus );
                gui->mask |= GUIM_FOCUSCHANGED;
            }
        }
        else
            GUI_tabright( gui );
    }
    if( focusPrev != gui->focus )
    {
        if( focusPrev >= 0 && focusPrev < gui->cControl )
        {
            GUI_Control_Dirty( gui, gui->list + focusPrev );
            gui->mask |= GUIM_FOCUSCHANGED;
        }
    }
    return focusPrev;
}

void _GUI_CallNotifies( GUI* gui )
{
    /* Now deliver any notifications that were raised */
    assert(gui);
    for( gui->iControl = 0; gui->iControl < gui->cControl; ++gui->iControl )
    {
        GUI_Control_State* data = GUI_Control_Get_Data( gui, gui->iControl );
        if( data->mask & GUICS_NOTIFY )
        {
            gui->handler(gui, GUI_Notify);
            data->mask &= ~GUICS_NOTIFY;
        }
    }
}

void _GUI_Heartbeat( GUI* gui )
{
    /*
     * When layering multiple GUIs...
     * 1. Cycle all GUIs.
     * 2. Do any focus-change notifications
     * 3. Accumulate 'dirty' regions and make all GUI dirty regions the same
     * 4. Paint all GUIs
     * 5. Invoke notifies
     */
    assert(gui);
    if( GUI_IsOpen( gui ) )
        gui->handler( gui, GUI_Cycle );
    if( GUI_IsOpen( gui ) && (gui->mask & GUIM_FOCUSCHANGED) )
    {
        gui->mask &= ~GUIM_FOCUSCHANGED;
        gui->handler( gui, GUI_Focus );
    }
    if( GUI_IsOpen( gui ) )
    {
        gui->handler( gui, GUI_Paint );
#ifndef SIMPLE_DIRTY
        ClipRect_clear( gui->cdirty );
#endif
        _GUI_CallNotifies( gui );
    }
}


bool _GUI_Control_IsFocused( const GUI* gui, const GUI_Control* control )
{
    return (gui->list + gui->focus) == control && !(GUI_Control_Mask( gui, control ) & (GUICS_INVISIBLE|GUICS_NOFOCUS));
}

bool _GUI_Control_IsHidden( const GUI* gui, int index ) 
{
    return 0 != (GUI_Control_Data( gui, GUI_Control_Get( gui, index ) )->mask & GUICS_INVISIBLE);
}

void _GUI_Control_Hide( GUI* gui, int index )
{
    if( !GUI_Control_IsHidden( gui, index ) )
    {
        if( gui->focus == index )
            GUI_tabright( gui );
        GUI_Control_Set_Dirty( gui, index );
        GUI_Control_Data( gui, GUI_Control_Get( gui, index ) )->mask |= GUICS_INVISIBLE;
    }
}

void _GUI_Control_Show( GUI* gui, int index )
{
    if( GUI_Control_IsHidden( gui, index ) )
    {
        GUI_Control_Data( gui, GUI_Control_Get( gui, index ) )->mask &= ~GUICS_INVISIBLE;
        GUI_Control_Set_Dirty( gui, index );
        if( gui->focus == index )
            GUI_tabright( gui );
    }
}

bool _GUI_Control_IsDisabled( const GUI* gui, int index )   
{
    return 0 != (GUI_Control_Data( gui, GUI_Control_Get( gui, index ) )->mask & GUICS_NOFOCUS);
}
void _GUI_Control_Enable( GUI* gui, int index )
{
    if( GUI_Control_IsDisabled( gui, index ) )
    {
        GUI_Control_Data( gui, GUI_Control_Get( gui, index ) )->mask &= ~GUICS_NOFOCUS;
        GUI_Control_Set_Dirty( gui, index );
        if( gui->focus == index )
            GUI_tabright( gui );
    }
}
void _GUI_Control_Disable( GUI* gui, int index )
{
    if( !GUI_Control_IsDisabled( gui, index ) )
    {
        if( gui->focus == index )
            GUI_tabright( gui );
        GUI_Control_Data( gui, GUI_Control_Get( gui, index ) )->mask |= GUICS_NOFOCUS;
        GUI_Control_Set_Dirty( gui, index );
    }
}


bool _GUI_Explode_Set( GUI* gui, int times, int divide, int first, int last )
{
    bool alldone = true;
    assertobjptr(gui);
    assert( first >= 0 && first < gui->cControl );
    assert( last >= first && last < gui->cControl );
    {
        pointer_foreach_const( GUI_Control, gui->list+first, (1+last-first), control )
        {
            GUI_Control_State* state = GUI_Control_Data( gui, control );
            if( state->offx || state->offy )
            {
                Rect bound;
                GUI_Control_Bound( gui, control, &bound );
                if( 
                    (( times > divide ) && !RectOutside(bound,gui->opc.clip)) ||
                    (( times < divide ) && (state->offx || state->offy) ) )
                {
                    GUI_Control_Dirty( gui, control );
                    state->offx = (int16)(state->offx * times / divide);
                    state->offy = (int16)(state->offy * times / divide);
                    GUI_Control_Dirty( gui, control );
                    alldone = false;
                }
            }
        }
    }
    return alldone;
}
bool _GUI_Explode( GUI* gui, int times, int divide )
{
    return _GUI_Explode_Set( gui, times, divide, 0, gui->cControl-1 );
}

void _GUI_Sweep_Set( GUI* gui, int x, int y, int times, int divide, int from, int to )
{
    assertobjptr(gui);
    assert( from >= 0 && from < gui->cControl );
    assert( to >= from && to < gui->cControl );
    {
        pointer_foreach_const( GUI_Control, gui->list + from, 1+to-from, control )
        {
            _GUI_Offset_Control( gui, control, x, y );
            x = x * times / divide;
            y = y * times / divide;
        }
    }
}
void _GUI_Sweep( GUI* gui, int x, int y, int times, int divide )
{
    _GUI_Sweep_Set( gui, x,y, times, divide, 0, gui->cControl-1 );
}

void _GUI_Offset_Group( GUI* gui, int from, int to, int x, int y )
{
    assert( from >= 0 && from < gui->cControl );
    assert( to >= from && to < gui->cControl );
    {
        pointer_foreach_const( GUI_Control, gui->list + from, 1+to-from, control )
            _GUI_Offset_Control( gui, control, x, y );
    }
}

void _GUI_Offset_Control( GUI* gui, const GUI_Control* control, int x, int y )
{
    GUI_Control_State* state = GUI_Control_Data( gui, control );
    GUI_Control_Dirty( gui, control );
    state->offx = (int16)x;
    state->offy = (int16)y;
    GUI_Control_Dirty( gui, control );
}

void _GUI_Control_Set_Offset( GUI* gui, int index, int px, int py )
{
    const GUI_Control* control = GUI_Control_Get( gui, index );
    GUI_Control_State* state = GUI_Control_Data( gui, control );
    GUI_Control_Dirty( gui, control );
    state->offx = (int16)px;
    state->offy = (int16)py;
    GUI_Control_Dirty( gui, control );
}

void _GUI_Move( GUI* gui, int x, int y )
{ 
    if( gui->offx != x || gui->offy != y )
    {
        gui->offx = x; 
        gui->offy = y; 
        GUI_Dirty_Rect( gui, &gui->opc.clip ); 
    }
}


bool _GUI_Motion( GUI* gui, int tx, int ty )
{
    if( gui->offx == tx && gui->offy == ty )
        return true;
    GUI_Dirty( gui );
    gui->offx = (tx + gui->offx) / 2;
    gui->offy = (ty + gui->offy) / 2;
    if( abs(gui->offx - tx) <= 8 && abs(gui->offy - ty) <= 8 )
    {
        gui->offx = tx;
        gui->offy = ty;
    }
    GUI_Dirty( gui );
    return false;
}

#ifndef NDEBUG

const GUI_Control* _GUI_Control_Get( const GUI* gui, int index )
{
    /* Assert we're looking at a valid index */
    assertobjptr(gui);
    assert( index >= 0 && index < gui->cControl );
    return gui->list + index;
}

GUI_Control_State* _GUI_Control_Data( const GUI* gui, const GUI_Control* control )
{
    assertobjptr(gui);
    assertobjptr(control);
    /* The control data shouldn't be inside GUI base record */
    assert( control->offData >= sizeof(GUI) );
    return (GUI_Control_State*)((uint8*)gui + control->offData);
}

#endif

void GUI_Def_State( GUI* gui, const GUI_Control* control, unsigned initmask, unsigned align )
{
    GUI_Control_State* state = GUI_Control_Data( gui, control );
    state->mask = initmask;
    state->offx = state->offy = 0;
    state->text = NULL;
    state->align = align;
    state->frames = control->state;
    state->cFrames = control->cState;
}

void _GUI_Control_SetFrames( GUI* gui, int index, const OPCShape* const* frames, size_t cFrames )
{
    GUI_Control_State* state = (GUI_Control_State*)GUI_Control_Get_Data( gui, index ); 
    state->frames = frames;
    state->cFrames = cFrames;
    GUI_Control_Set_Dirty( gui,index ); 
}

void _GUI_Control_SetText( GUI* gui, int index, const GUI_CHAR* szText)
{ 
    GUI_Control_Get_Data( gui,index )->text = szText; 
    GUI_Control_Set_Dirty( gui,index ); 
}

void _GUI_Control_SetJustify( GUI* gui, int index, unsigned just )
{
    GUI_Control_Get_Data( gui,index )->align = just; 
    GUI_Control_Set_Dirty( gui,index );
}

void _GUI_Control_SetupText( GUI* gui, int index, const GUI_CHAR* szText, unsigned just )
{ 
    GUI_Control_State* state = (GUI_Control_State*)GUI_Control_Get_Data( gui, index ); 
    state->text = szText; 
    state->align = just;
    GUI_Control_Set_Dirty( gui, index ); 
}

void _GUI_Control_Dirty( GUI* gui, const GUI_Control* control )
{
    GUI_Control_State* state = GUI_Control_Data( gui, control );
    if( !(state->mask & GUICS_INVISIBLE) )
    {
        Rect bound = (control)->bound;
        RectMoveBy(bound,gui->offx+state->offx,gui->offy+state->offy);
        GUI_Dirty_Rect( gui, &bound );
    }
}

void _GUI_Control_Bound( GUI* gui, const GUI_Control* control, Rect* bound )
{
    GUI_Control_State* state = GUI_Control_Data( gui, control );
    *bound = (control)->bound;
    RectMoveBy(*bound,gui->offx+state->offx,gui->offy+state->offy);
}




/* Certain controls are pseudo-controls */
#define GUI_Ctrl_ArtResource    GUI_Ctrl_Invalid
#define GUI_Ctrl_PaletteData    GUI_Ctrl_Invalid
#define GUI_Ctrl_Background     GUI_Ctrl_Invalid
#define GUI_Ctrl_Overlay        GUI_Ctrl_Invalid


#define XENUM(tag,verbose,data) static void GUI_Ctrl_##verbose( struct GUI* gui, const struct GUI_Control* control, GUI_Message msg );
EDEF_HANDLERS(XENUM)
#undef XENUM
#define XENUM(tag,verbose,data) GUI_Ctrl_##verbose,
static const GUI_Ctrl_handler lutHandlers[] =
{
    EDEF_HANDLERS(XENUM)
};
#undef XENUM

void GUI_Control_handle( struct GUI* gui, const GUI_Control* control, GUI_Message msg )
{
    assertobjptr(gui);
    assertobjptr(control);
    {
        GUIHandlers index = control->type;
        assert( index >= 0 && index < GUIHandlers_COUNT );
        lutHandlers[index]( gui, control, msg );
    }
}

void GUI_Ctrl_Invalid( struct GUI* gui, const struct GUI_Control* control, GUI_Message msg )
{
}

void GUI_Ctrl_StaticFrame( struct GUI* gui, const struct GUI_Control* control, GUI_Message msg )
{
    switch( msg )
    {
    case GUI_Paint:
        {
            GUI_Control_State* state = GUI_Control_Data( gui, control );
            OPC opc;
            if( ((state->frames && state->cFrames) || (state->text && *state->text)) && GUI_Control_Paint( gui, control, &opc ) )
            {
                Rect bound;
                GUI_Control_Bound( gui, control, &bound );
                if( state->frames && state->cFrames )
                {
                    OPC_NAMING(Shape)( &opc, *state->frames, bound.left, bound.top );
                }
                if( state->text && *state->text )
                {
                    /* Draw any text that goes with the button */
                    GUI_DrawText( &opc, &bound, state->align, state->text, ~0u );
                }
            }
        }
        break;
    case GUI_Init:
        GUI_Def_State(gui,control,GUICS_NOFOCUS,GUI_CENTER|GUI_VCENTER);
        return;

    default:
        break;
    }
}

void GUI_Ctrl_Button( struct GUI* gui, const struct GUI_Control* control, GUI_Message msg )
{
    switch( msg )
    {
    case GUI_Cycle:
        {
            /* Handle keys/events */
            GUI_Button_State* state = (GUI_Button_State*)GUI_Control_Data( gui, control );
            if( !state->basic.frames )
            {
                if( GUI_Control_IsFocused( gui, control ) )
                    GUI_tabright(gui);
                return;
            }
            if( GUI_Control_IsFocused( gui, control ) )
            {
                #if ( defined(GUI_TABLEFT) || defined(GUI_TABRIGHT) || defined(GUI_TABUP) || defined(GUI_TABDOWN) )
                if( GUI_tabhandler( gui ) )
                {
                    state->tracking = guibs_Neutral;
                    return;
                }
                #endif
                switch( state->tracking )
                {
                default:
                case guibs_Neutral:
                    /* We're waiting for focus */
                    state->tracking = guibs_Focus;
                    GUI_Control_Dirty( gui, control );
                    /* Fall-through now that we're focused */
                case guibs_Focus:
                    /* We have focus */
#if defined(GUI_GetPointer)
                    if( GUI_GetKeyPress() & GUI_PICK )
                    {
                        int x,y;
                        Rect bound;
                        GUI_Control_Bound( gui, control, &bound );
                        GUI_GetPointer(x,y);
                        if( !RectPtInRect(bound,x,y) )
                        {
                            break;
                        }
                    }
#endif
#ifdef GUI_GetKeyHeld
                    if( GUI_GetKeyPress() & (GUI_SELECT|GUI_PICK) )
                    {
                        if( state->basic.frames[guibs_Selected] )
                        {
                            state->tracking = guibs_Selected;
                            GUI_ClearKeyPress();
                            GUI_Control_Dirty( gui, control );
                            break;
                        }
#endif
                        state->tracking = guibs_Focus;
                        GUI_Control_Dirty( gui, control );
                        GUI_SelectSound();
                        GUI_Control_Notify( gui, control );
                    }
                    break;

                case guibs_Selected:
#ifdef GUI_GetKeyHeld
#if defined(GUI_GetPointer)
                    if( GUI_GetKeyHeld() == GUI_PICK )
                    {
                        int x,y;
                        Rect bound;
                        GUI_Control_Bound( gui, control, &bound );
                        GUI_GetPointer(x,y);
                        if( !RectPtInRect(bound,x,y) )
                        {
                            state->tracking = guibs_Focus;
                            GUI_Control_Dirty( gui, control );
                            break;
                        }
                    }
#endif
                    if( (GUI_GetKeyHeld() & (GUI_SELECT|GUI_PICK)) )
                        break;
#endif
                    state->tracking = guibs_Focus;
                    GUI_Control_Dirty( gui, control );
                    GUI_SelectSound();
                    GUI_Control_Notify( gui, control );
                    break;
                }
            }
            else
            {
                if( state->tracking != guibs_Neutral )
                {
                    state->tracking = guibs_Neutral;
                    GUI_Control_Dirty( gui, control );
                }
            }
        }
        break;
    case GUI_Paint:
        {
            GUI_Button_State* state = (GUI_Button_State*)GUI_Control_Data( gui, control );
            OPC opc;
            if( state->basic.frames && GUI_Control_Paint( gui, control, &opc ) )
            {
                Rect bound;
                GUI_Control_Bound( gui, control, &bound );
                /* Draw bottom focus, if present */
                if( GUI_Control_IsFocused( gui, control ) )
                    OPC_NAMING(Shape)( &opc, state->basic.frames[guibs_FocusUnder], bound.left,bound.top );
                switch( state->tracking )
                {
                default:
                case guibs_Focus:
                    if( state->basic.frames[guibs_Focus] )
                        OPC_NAMING(Shape)( &opc, state->basic.frames[guibs_Focus], bound.left,bound.top );
                    else if( state->basic.frames[guibs_Neutral] )
                        OPC_NAMING(Shape)( &opc, state->basic.frames[guibs_Neutral], bound.left,bound.top );
                    else
                        OPC_NAMING(Shape)( &opc, state->basic.frames[guibs_Selected], bound.left,bound.top );
                    break;
                case guibs_Neutral:
                    OPC_NAMING(Shape)( &opc, state->basic.frames[guibs_Neutral], bound.left,bound.top );
                    break;
                case guibs_Selected:
                    if( state->basic.frames[guibs_Selected] )
                        OPC_NAMING(Shape)( &opc, state->basic.frames[guibs_Selected], bound.left,bound.top );
                    else if( state->basic.frames[guibs_Focus] )
                        OPC_NAMING(Shape)( &opc, state->basic.frames[guibs_Focus], bound.left,bound.top );
                    else
                        OPC_NAMING(Shape)( &opc, state->basic.frames[guibs_Neutral], bound.left,bound.top );
                    break;
                }
                if( state->basic.text && *state->basic.text )
                {
                    /* Draw any text that goes with the button */
                    GUI_DrawText( &opc, &bound, state->basic.align, state->basic.text, ~0u );
                }
                /* Draw top focus, if present */
                if( GUI_Control_IsFocused( gui, control ) )
                    OPC_NAMING(Shape)( &opc, state->basic.frames[guibs_FocusOver], bound.left,bound.top );
            }
        }
        break;
    case GUI_Init:
        {
            GUI_Button_State* state = (GUI_Button_State*)GUI_Control_Data( gui, control );
            GUI_Def_State(gui,control,GUICS_DEFAULT,GUI_CENTER|GUI_VCENTER);
            state->tracking = guibs_Neutral;
        }
        break;
    default:
        break;
    }
}

void GUI_Ctrl_Checkbox( struct GUI* gui, const struct GUI_Control* control, GUI_Message msg )
{
    switch( msg )
    {
    case GUI_Cycle:
        {
            /* Handle keys/events */
            GUI_Checkbox_State* state = (GUI_Checkbox_State*)GUI_Control_Data( gui, control );
            if( !state->basic.frames )
            {
                if( GUI_Control_IsFocused( gui, control ) )
                    GUI_tabright(gui);
                return;
            }
            if( GUI_Control_IsFocused( gui, control ) )
            {
                #if ( defined(GUI_TABLEFT) || defined(GUI_TABRIGHT) || defined(GUI_TABUP) || defined(GUI_TABDOWN) )
                if( GUI_tabhandler( gui ) )
                    return;
                #endif
                if( GUI_GetKeyPress() & (GUI_SELECT|GUI_PICK) )
                {
                    if( state->bCheck )
                    {
                        state->bCheck = false;
                        GUI_UncheckSound();
                    }
                    else
                    {
                        state->bCheck = true;
                        GUI_CheckSound();
                    }
                    GUI_Control_Notify( gui, control );
                    GUI_Control_Dirty( gui, control );
                    GUI_ClearKeyPress();
                }
            }
        }
        break;
    case GUI_Paint:
        {
            GUI_Checkbox_State* state = (GUI_Checkbox_State*)GUI_Control_Data( gui, control );
            OPC opc;
            if( GUI_Control_Paint( gui, control, &opc ) && state->basic.frames )
            {
                Rect bound;
                GUI_Control_Bound( gui, control, &bound );
                if( state->basic.text && *state->basic.text )
                {
                    /* Draw any text that goes with the button */
                    Rect rCheck;
                    OPC_NAMING(Shape_Bound)( &rCheck, state->basic.frames[state->bCheck ? guics_Checked : guics_Unchecked], bound.left,bound.top );
                    if( GUI_Control_IsFocused( gui, control ) )
                    {
                        Rect rFocus;
                        OPC_NAMING(Shape_Bound)( &rFocus, state->basic.frames[guics_Focus], bound.left,bound.top );
                        RectUnionRect( rCheck, rFocus );
                    }
                    /* state->align is for text alignment, so this looks backwards */
                    switch( state->basic.align & (GUI_LEFT|GUI_CENTER|GUI_RIGHT) )
                    {
                    default:
                    case GUI_LEFT:
                    case GUI_CENTER:
                        RectLeftTo( rCheck, bound.left );
                        bound.left = rCheck.right;
                        break;
                    case GUI_RIGHT:
                        RectRightTo( rCheck, bound.right );
                        bound.right = rCheck.left;
                        break;
                    }
                    switch( state->basic.align & (GUI_TOP|GUI_VCENTER|GUI_BOTTOM) )
                    {
                    default:
                    case GUI_TOP:
                    case GUI_VCENTER:
                        RectBottomTo( rCheck, bound.bottom );
                        bound.bottom = rCheck.top;
                        break;
                    case GUI_BOTTOM:
                        RectTopTo( rCheck, bound.top );
                        bound.top = rCheck.bottom;
                        break;
                    }
                    GUI_DrawText( &opc, &bound, state->basic.align, state->basic.text, ~0u );
                }
                else 
                {
                    OPC_NAMING(Shape)( &opc, state->basic.frames[state->bCheck ? guics_Checked : guics_Unchecked], bound.left,bound.top );
                    if( GUI_Control_IsFocused( gui, control ) )
                        OPC_NAMING(Shape)( &opc, state->basic.frames[guics_Focus], bound.left,bound.top );
                }
            }
        }
        break;
    case GUI_Init:
        {
            GUI_Checkbox_State* state = (GUI_Checkbox_State*)GUI_Control_Data( gui, control );
            GUI_Def_State(gui,control,GUICS_DEFAULT,GUI_LEFT);
            state->bCheck = false;
        }
        break;
    default:
        break;
    }
}

bool _GUI_Checkbox_SetCheck( GUI* gui, int index, bool bCheck)
{
    bool bOld;
    const GUI_Control* control = GUI_Control_Get( gui, index );
    GUI_Checkbox_State* state = (GUI_Checkbox_State*)GUI_Control_Data( gui, control );
    GUI_Assert_Type( gui, index, guih_Checkbox );
    bOld = state->bCheck;
    state->bCheck = 0 != (bCheck);
    if( !(state->basic.mask & (GUICS_INVISIBLE|GUICS_NOFOCUS)) )
        state->basic.mask |= GUICS_NOTIFY;
    GUI_Control_Dirty( gui, control );
    return bOld;
}


void GUI_Ctrl_Animation( struct GUI* gui, const struct GUI_Control* control, GUI_Message msg )
{
    switch( msg )
    {
    case GUI_Cycle:
        {
            GUI_Animation_State* state = (GUI_Animation_State*)GUI_Control_Data( gui, control );
            unsigned mscurr = (unsigned)GUI_MSTime();
            if( !state->basic.frames || (state->basic.mask & GUICS_INVISIBLE) )
                return;
            if( (mscurr-state->msprev) >= state->msframe )
            {
                switch( state->aDir )
                {
                case gad_Stop:
                default:
                    return;
                case gad_ForwardOneshot:
                    if( ++state->iFrame >= (int)state->basic.cFrames )
                    {
                        state->iFrame = state->basic.cFrames-1;
                        GUI_Control_Notify( gui, control );
                        state->aDir = gad_Stop;
                    }
                    GUI_Control_Dirty( gui, control );
                    break;
                case gad_BackwardOneshot:
                    if( --state->iFrame < 0 )
                    {
                        state->iFrame = 0;
                        GUI_Control_Notify( gui, control );
                        state->aDir = gad_Stop;
                    }
                    GUI_Control_Dirty( gui, control );
                    break;
                case gad_ForwardLoop:
                    if( ++state->iFrame >= (int)state->basic.cFrames )
                        state->iFrame = 0;
                    GUI_Control_Dirty( gui, control );
                    break;
                case gad_BackwardLoop:
                    if( --state->iFrame < 0 )
                        state->iFrame = (int)state->basic.cFrames-1;
                    GUI_Control_Dirty( gui, control );
                    break;
                case gad_ForwardPingPong:
                    if( ++state->iFrame >= (int)state->basic.cFrames-1 )
                    {
                        state->iFrame = (int)state->basic.cFrames-1;
                        state->aDir = gad_BackwardPingPong;
                    }
                    GUI_Control_Dirty( gui, control );
                    break;
                case gad_BackwardPingPong:
                    if( --state->iFrame <= 0 )
                    {
                        state->iFrame = 0;
                        state->aDir = gad_ForwardPingPong;
                        GUI_Control_Dirty( gui, control );
                    }
                    GUI_Control_Dirty( gui, control );
                    break;
                case gad_Random:
                    {
                        int nextFrame;
                        do {
                            nextFrame = GUI_Random() % state->basic.cFrames;
                        } while( nextFrame == state->iFrame );
                        state->iFrame = nextFrame;
                        GUI_Control_Dirty( gui, control );
                    }
                    break;
                }
                state->msprev = mscurr;
            }
        }
        break;
    case GUI_Paint:
        {
            GUI_Animation_State* state = (GUI_Animation_State*)GUI_Control_Data( gui, control );
            OPC opc;
            if( state->basic.frames && state->basic.cFrames && GUI_Control_Paint( gui, control, &opc ) )
            {
                Rect bound;
                GUI_Control_Bound( gui, control, &bound );
                if( state->iFrame < 0 )
                {
                    state->iFrame = 0;
                }
                else if( state->iFrame >= (int)state->basic.cFrames )
                {
                    state->iFrame = state->basic.cFrames-1;
                }
                OPC_NAMING(Shape)( &opc, state->basic.frames[state->iFrame], bound.left,bound.top );
                if( state->basic.text && *state->basic.text )
                {
                    /* Draw any text that goes with the button */
                    GUI_DrawText( &opc, &bound, state->basic.align, state->basic.text, ~0u );
                }
            }
        }
        break;
    case GUI_Init:
        {
            GUI_Animation_State* state = (GUI_Animation_State*)GUI_Control_Data( gui, control );
            GUI_Def_State(gui,control,GUICS_NOFOCUS,GUI_CENTER|GUI_VCENTER);
            state->iFrame = 0;
            state->aDir = state->basic.cFrames > 1 ? gad_ForwardLoop : gad_Stop;
            state->msframe = 100;
            state->msprev = 0;
        }
        break;
    default:
        break;
    }
}

int _GUI_Animation_SetFrame( GUI* gui, int index, int frame )
{
    const GUI_Control* control = GUI_Control_Get( gui, index );
    GUI_Animation_State* state = (GUI_Animation_State*)GUI_Control_Data( gui, control );
    int frPrev = state->iFrame;
    GUI_Assert_Type( gui, index, guih_Animation );
    if( state->basic.cFrames > 0 )
        state->iFrame = (frame + state->basic.cFrames) % state->basic.cFrames;
    else
        state->iFrame = 0;
    state->aDir = gad_Stop;
    if( frPrev != state->iFrame )
        GUI_Control_Dirty( gui, control );
    return frPrev;
}

void _GUI_Animation_SetAnim( GUI* gui, int index, GUI_AnimDir animdir, int startFrame, unsigned msFrameTime )
{
    const GUI_Control* control = GUI_Control_Get( gui, index );
    GUI_Animation_State* state = (GUI_Animation_State*)GUI_Control_Data( gui, control );
    GUI_Assert_Type( gui, index, guih_Animation );
    state->iFrame = max(0,min(startFrame,(int)state->basic.cFrames));
    state->msframe = msFrameTime;
    state->msprev = (unsigned)GUI_MSTime();
    state->aDir = animdir;
    GUI_Control_Dirty( gui, control );
}


void GUI_Ctrl_Scrollbar( struct GUI* gui, const struct GUI_Control* control, GUI_Message msg )
{
    GUI_Scrollbar_State* state = (GUI_Scrollbar_State*)GUI_Control_Data( gui, control );
    const OPCShape* frame = NULL;
    const OPCShape* cthumb = NULL;
    bool bFocus = GUI_Control_IsFocused( gui, control );
    Rect bound;
    int w,h;
    GUI_Control_Bound( gui, control, &bound );
    w = RectWide(bound);
    h = RectHigh(bound);

/* Calculate where to draw cthumb */
#define CalcPos(value,x,y)\
    {\
        int vtotal = state->vmax-state->vmin;\
        int vcurr = min(max(value,state->vmin),state->vmax);\
        if( w > h )\
        {\
            x = bound.left + (w * ((vcurr)-state->vmin) / vtotal);\
            y = bound.top  + (h/2);\
        }\
        else\
        {\
            x = bound.left + (w/2);\
            y = bound.bottom - (h * ((vcurr)-state->vmin) / vtotal);\
        }\
    }

#define CalcThumb(x,y)\
    {\
        x = (x - cthumb->xOff) - (cthumb->wide/2);\
        y = (y - cthumb->yOff) - (cthumb->high/2);\
    }

#if defined(GUI_GetKeyHeld)
#define SB_SETUP_REPEAT(key) \
    if( state->msRepeat && key != state->keyPrev )\
    {\
        state->msPrev = (unsigned)GUI_MSTime() + GUI_RepeatPause(state->msRepeat);\
        state->keyPrev = (key);\
    }
#define SB_REPEAT_CANCEL() \
    {\
        state->msPrev = 0;\
        state->keyPrev = 0;\
    }
#else
#define SB_SETUP_REPEAT(key)
#define SB_REPEAT_CANCEL()
#endif

    switch( msg )
    {
    case GUI_Cycle:
        if( state->basic.frames )
        {
            cthumb = bFocus && state->basic.frames[guisp_ThumbFocus] ? state->basic.frames[guisp_ThumbFocus] : state->basic.frames[guisp_Thumb];
            frame = state->basic.frames[guisp_Frame];
            if( bFocus )
            {
                int value = state->value;
                unsigned keypress;
#if defined(GUI_GetKeyHeld)
                if( state->keyPrev && state->msRepeat )
                {
                    keypress = GUI_GetKeyHeld() & state->keyPrev;
                    if( keypress && state->msPrev )
                    {
                        unsigned mstime = (unsigned)GUI_MSTime();
                        if( mstime > state->msPrev && mstime - state->msPrev >= state->msRepeat )
                        {
                            state->msPrev = mstime;
                        }
                        else
                        {
                            keypress = 0;
                        }
                    }
                    else
                    {
                        SB_REPEAT_CANCEL();
                    }
                }
                else
#endif
                {
                    keypress = GUI_GetKeyPress();
                }

                /*
                 * Take inventory of tabs
                 * If we have only one tab, select will cycle/wrap
                 * If we have two tabs, holding select will move cthumb
                 * Four tabs, moving in directions cthumb travels moves cthumb,
                 *  moving in other directions tabs
                 */
#if defined(GUI_GetPointer)
                {
                    int x, y;
                    GUI_GetPointer(x,y);
                    /*
                     * If we have GUI_GetPointer and GUI_GetKeyHeld, then dragging
                     *  pointer or clicking/tapping moves cthumb
                     * If we have GUI_GetPointer and not GUI_GetKeyHeld, then
                     *  only clicking/tapping moves cthumb
                     */
                    if( RectPtInRect( bound, x, y ) )
                    {
                    #if defined(GUI_GetKeyHeld)
                        if( GUI_PICK == GUI_GetKeyPress() || GUI_PICK == GUI_GetKeyHeld() )
                    #else
                        if( GUI_PICK == GUI_GetKeyPress() && RectPtInRect( bound, x, y ) )
                    #endif
                        {
                            /* Pointer/cursor is inside, mouse is held */
                            int vtotal = state->vmax-state->vmin;
                            if( w > h )
                            {
                                int offset = x - bound.left;
                                int mod = max(h/vtotal,1);
                                int offsetdown = offset/mod*mod;
                                int offsetup = (offset+mod)/mod*mod;
                                if( offset-offsetdown < offsetup-offset )
                                    value = (vtotal * offsetdown / w );
                                else
                                    value = (vtotal * offsetup / w );
                            }
                            else
                            {
                                int offset = bound.bottom - y;
                                int mod = max(h/vtotal,1);
                                int offsetdown = offset/mod*mod;
                                int offsetup = (offset+mod)/mod*mod;
                                if( offset-offsetdown < offsetup-offset )
                                    value = (vtotal * offsetdown / h );
                                else
                                    value = (vtotal * offsetup / h );
                            }
                        }
                    }
                }
#endif
#if (defined(GUI_TABLEFT) && defined(GUI_TABRIGHT) && defined(GUI_TABUP) && defined(GUI_TABDOWN))
                if( w > h )
                {
                    if( GUI_TABLEFT == keypress )
                    {
                        value--;
                        if( value < state->vmin )
                            value = state->vmin;
                        SB_SETUP_REPEAT(keypress);
                    }
                    else if( GUI_TABRIGHT == keypress )
                    {
                        value++;
                        if( value > state->vmax )
                            value = state->vmax;
                        SB_SETUP_REPEAT(keypress);
                    }
                    else if( GUI_tabhandler( gui ) )
                    {
                        SB_REPEAT_CANCEL();
                        state->oldValue = state->value+1;
                    }
                }
                else
                {
                    if( GUI_TABUP == keypress )
                    {
                        value++;
                        if( value > state->vmax )
                            value = state->vmax;
                        SB_SETUP_REPEAT(keypress);
                    }
                    else if( GUI_TABDOWN == keypress )
                    {
                        value--;
                        if( value < state->vmin )
                            value = state->vmin;
                        SB_SETUP_REPEAT(keypress);
                    }
                    else if( GUI_SELECT == keypress )
                    {
                        value++;
                        if( value > state->vmax )
                            value = state->vmin;
                        SB_SETUP_REPEAT(keypress);
                    }
                    else if( GUI_tabhandler( gui ) )
                    {
                        SB_REPEAT_CANCEL();
                        state->oldValue = state->value+1;
                    }
                }
#elif !defined(GUI_GetPointer) && (defined(GUI_TAB) || defined(GUI_TABLEFT) || defined(GUI_TABRIGHT) || defined(GUI_TABUP) || defined(GUI_TABDOWN))
                /* For less than 4-way tab, select cycles through scrolling, and other tabs skip over */
                if( GUI_SELECT == keypress )
                {
                    value++;
                    if( value > state->vmax )
                        value = state->vmin;
                    SB_SETUP_REPEAT(keypress);
                }
                else 
                {
                    SB_REPEAT_CANCEL();
                    if( GUI_tabhandler( gui ) )
                    {
                        state->oldValue = state->value+1;
                    }
                }
#endif
                /* Nothing bailed? Set new value */
                state->value = value;
            }
            else
            {
                SB_REPEAT_CANCEL();
            }
            if( state->oldValue != state->value )
            {
                Rect rthumb;
                int x,y;

                /* Mark control bounds dirty */
                GUI_Dirty_Rect( gui, &bound );

                /* Mark old cthumb position dirty */
                CalcPos(state->oldValue, x,y);
                CalcThumb(x,y);
                OPC_NAMING(Shape_Bound)( &rthumb, cthumb, x, y );
                GUI_Dirty_Rect( gui, &rthumb );

                /* Mark new cthumb position dirty */
                CalcPos(state->value, x,y);
                CalcThumb(x,y);
                OPC_NAMING(Shape_Bound)( &rthumb, cthumb, x, y );
                GUI_Dirty_Rect( gui, &rthumb );

                state->oldValue = state->value;

                /* Make noise, if defined */
                GUI_ScrollSound();
                GUI_Control_Notify( gui, control );
            }
        }
        else
        {
            if( GUI_Control_IsFocused( gui, control ) )
                GUI_tabright(gui);
            SB_REPEAT_CANCEL();
            return;
        }
        break;

    case GUI_Paint:
        if( state->basic.frames )
        {
            OPC opc;
            if( GUI_Control_Paint( gui, control, &opc ) )
            {
                int x,y;
                const OPCShape* shape;
                cthumb = bFocus && state->basic.frames[guisp_ThumbFocus] ? state->basic.frames[guisp_ThumbFocus] : state->basic.frames[guisp_Thumb];
                frame = bFocus && state->basic.frames[guisp_Focus] ? state->basic.frames[guisp_Focus] : state->basic.frames[guisp_Frame];
                CalcPos(state->value, x,y);

                /* Draw frame, if present */
                OPC_NAMING(Shape)( &opc, frame, bound.left,bound.top );

                /* Draw focus underlay, if present */
                if( bFocus )
                    OPC_NAMING(Shape)( &opc, state->basic.frames[guisp_FocusUnder], bound.left,bound.top );

                /* Draw low half of fill */
                shape = state->basic.frames[guisp_Fill1];
                if( shape )
                {
                    OPC clip;
                    Rect scaling;
                    OPC_NAMING(Shape_Bound)( &scaling, shape, bound.left,bound.top );
                    if( w > h )
                        scaling.right = x+1;
                    else
                        scaling.bottom = y+1;
                    OPC_NAMING(Clip)( &clip, &opc, &scaling );
                    OPC_NAMING(Shape)( &clip, shape, bound.left,bound.top );
                }

                /* Draw high half of fill */
                shape = state->basic.frames[guisp_Fill2];
                if( shape )
                {
                    OPC clip;
                    Rect scaling;
                    if( w > h )
                        scaling.left = x;
                    else
                        scaling.top = y;
                    OPC_NAMING(Shape_Bound)( &scaling, shape, bound.left,bound.top );
                    OPC_NAMING(Clip)( &clip, &opc, &scaling );
                    OPC_NAMING(Shape)( &clip, shape, bound.left,bound.top );
                }

                if( state->basic.text && *state->basic.text )
                {
                    /* Draw any text that goes with the control */
                    GUI_DrawText( &opc, &bound, state->basic.align, state->basic.text, ~0u );
                }

                /* Draw focus highlight, if present */
                if( bFocus )
                    OPC_NAMING(Shape)( &opc, state->basic.frames[guisp_FocusOver], bound.left,bound.top );

                /* Draw thumb */
                CalcThumb(x,y);
                OPC_NAMING(Shape)( &gui->opc, cthumb, x,y ); /* deliberately uses 'gui' clipping instead of control clipping */
            }
        }
        break;
    case GUI_Init:
        {
            GUI_Def_State(gui,control,GUICS_DEFAULT,GUI_CENTER|GUI_VCENTER);
            SB_REPEAT_CANCEL();
            state->msRepeat = GUI_DefaultRepeat;
            state->vmax = 10;
            state->value = 5;
            state->vmin = 0;
            state->oldValue = -1;
        }
        break;
    default:
        break;
    }
#undef CalcThumb
#undef CalcPos
#undef SB_SETUP_REPEAT
#undef SB_REPEAT_CANCEL
}

int _GUI_Scrollbar_SetValue( struct GUI* gui, int idControl, int newValue, int minValue, int maxValue )
{
    int oldvalue;
    GUI_Scrollbar_State* tmpScrollbarState = (GUI_Scrollbar_State*)GUI_Control_Get_Data( (gui), (idControl) );
    GUI_Assert_Type( (gui), (idControl), guih_Scrollbar );
    tmpScrollbarState->vmin = (minValue);
    tmpScrollbarState->vmax = (maxValue);
    tmpScrollbarState->oldValue = -1-newValue;
    oldvalue = tmpScrollbarState->value;
    tmpScrollbarState->value = newValue;
    if( !(tmpScrollbarState->basic.mask & (GUICS_INVISIBLE|GUICS_NOFOCUS)) )
        tmpScrollbarState->basic.mask |= GUICS_NOTIFY;
    return oldvalue;
}


void GUI_Ctrl_Ticker( struct GUI* gui, const struct GUI_Control* control, GUI_Message msg )
{
    switch( msg )
    {
    case GUI_Cycle:
        {
            GUI_Ticker_State* state = (GUI_Ticker_State*)GUI_Control_Data( gui, control );
            unsigned mscurr = (unsigned)GUI_MSTime();
            if( (!state->basic.frames && !state->basic.text) || (state->basic.mask & GUICS_INVISIBLE) )
                return;
            if( mscurr < state->msprev )
            {
                /* Delay or wrap? */
                if( state->msprev - mscurr > 30000u )
                    state->msprev = mscurr;
                else
                    return;
            }
            if( (mscurr-state->msprev) >= state->msframe )
            {
                if( state->tWide > RectWide(control->bound) )
                {
                    state->offset++;
                    if( state->offset > state->tWide )
                    {
                        if( state->szNext )
                        {
                            /* If we have 'next' text, notify when it's used (and more text can be set) */
                            /* Otherwise, it just loops the same thing forever without notifying */
                            GUI_Ticker_SetText( gui, GUI_Control_Index( gui, control ), state->szNext );
                            state->szNext = NULL;
                            GUI_Control_Notify( gui, control );
                        }
                        else
                        {
                            state->offset = 0;
                        }
                    }
                    GUI_Control_Dirty( gui, control );
                }
                state->msprev = mscurr;
            }
        }
        break;
    case GUI_Paint:
        {
            OPC opc;
            if( GUI_Control_Paint( gui, control, &opc ) )
            {
                GUI_Ticker_State* state = (GUI_Ticker_State*)GUI_Control_Data( gui, control );
                Rect bound;
                GUI_Control_Bound( gui, control, &bound );
                if( state->basic.text )
                {
                    /* If total width is greater than bounding box, scroll it. */
                    /* Just draw it twice and let clipping take care of the rest */
                    Rect tBound = bound;
                    tBound.left = tBound.left - state->offset;
                    tBound.right = tBound.left + state->tWide;
                    GUI_DrawText( &opc, &tBound, GUI_ONELINE|GUI_VCENTER, state->basic.text, ~0u );
                    tBound.left += state->tWide;
                    tBound.right += state->tWide;
                    if( tBound.left < bound.right )
                        GUI_DrawText( &opc, &tBound, GUI_ONELINE|GUI_VCENTER, state->basic.text, ~0u );
                }
                else
                {
                    /* If total width is greater than bounding box, scroll it. */
                    /* Just draw it twice and let clipping take care of the rest */
                    int xOff = bound.left - state->offset;
                    {
                        pointer_foreach_const( OPCShape*, state->basic.frames, control->cState, shape )
                        {
                            OPC_NAMING(Shape)( &opc, *shape, xOff-(*shape)->xOff, bound.top - (*shape)->yOff );
                            xOff += (*shape)->wide;
                        }
                    }
                    if( xOff < bound.right )
                    {
                        pointer_foreach_const( OPCShape*, state->basic.frames, control->cState, shape )
                        {
                            OPC_NAMING(Shape)( &opc, *shape, xOff-(*shape)->xOff, bound.top - (*shape)->yOff );
                            xOff += (*shape)->wide;
                        }
                    }
                }
            }
        }
        break;
    case GUI_Init:
        {
            GUI_Ticker_State* state = (GUI_Ticker_State*)GUI_Control_Data( gui, control );
            GUI_Def_State(gui,control,GUICS_NOFOCUS,GUI_LEFT);
            GUI_Ticker_SetText( gui, GUI_Control_Index(gui,control), NULL );
            state->msframe = 33; /*(About 30FPS, when timed by video, will always be 'time') */
            state->msprev = (unsigned)GUI_MSTime() + 3000u;
            state->szNext = NULL;
        }
        break;
    default:
        break;
    }
}

void _GUI_Ticker_SetText( struct GUI* gui, int idControl, const GUI_CHAR* sz )
{
    const GUI_Control* control = GUI_Control_Get( gui, idControl );
    GUI_Ticker_State* state = (GUI_Ticker_State*)GUI_Control_Data( gui, control );
    GUI_Assert_Type( gui, idControl, guih_Ticker );
    if( sz )
    {
        Rect bounds = RectAutoClear();
        GUI_MeasureText( &bounds, GUI_ONELINE, sz, ~0u );
        state->basic.text = sz;
        state->offset = 0;
        state->tWide = RectWide(bounds);
    }
    else
    {
        state->basic.text = NULL;
        state->offset = 0;
        state->tWide = 0;
        {
            pointer_foreach_const( OPCShape*, state->basic.frames, control->cState, curr )
                state->tWide += (*curr)->wide;
        }
    }
}

void _GUI_Ticker_SetSpeed( struct GUI* gui, int idControl, unsigned msDelay, unsigned msframe )
{
    const GUI_Control* control = GUI_Control_Get( gui, idControl );
    GUI_Ticker_State* state = (GUI_Ticker_State*)GUI_Control_Data( gui, control );
    state->msframe = msframe;
    state->msprev = (unsigned)GUI_MSTime() + msDelay;
}

/*
 * Do shape in tumbler window, heeding alignment
 */
static void GUI_AlignShape( const OPC* opc, const Rect* rBound, const OPCShape* shape, unsigned mask )
{
    Rect rAligned = *rBound;
    Rect rShape;
    OPC_NAMING(Shape_Bound)( &rShape, shape, rBound->left, rBound->top );
    rAligned = rShape;
    switch( mask & 0xc ) 
    {
    case GUI_VCENTER:
        RectCenterOnY(rAligned,RectCenterY(*rBound));
        break;
    case GUI_BOTTOM:
        RectBottomTo(rAligned,rBound->bottom);
        break;
    default:
        break;
    }
    switch( mask & 3 )
    {
    default:
        break;
    case GUI_CENTER:
        RectCenterOnX(rAligned,RectCenterX(*rBound));
        break;
    case GUI_RIGHT:
        RectRightTo(rAligned,rBound->right);
        break;
    }
    OPC_NAMING(Shape)( opc, shape, rBound->left+(rAligned.left-rShape.left), rBound->top+(rAligned.top-rShape.top) );
    
}

/*
 * Work out where control parts are, and what the clipping window should be, based on what images are defined
 */
static void GUI_Ctrl_Tumbler_Rects( struct GUI* gui, const struct GUI_Control* control, Rect* rWin, Rect* rLeft, Rect* rRight )
{
    GUI_Tumbler_State* state = (GUI_Tumbler_State*)GUI_Control_Data( gui, control );
    Rect bound;
    GUI_Control_Bound( gui, control, &bound );
    OPC_NAMING(Shape_Bound)( rLeft, state->basic.frames[guitb_LBn]?state->basic.frames[guitb_LBn]:state->basic.frames[guitb_LBnHi], bound.left, bound.top );
    OPC_NAMING(Shape_Bound)( rRight, state->basic.frames[guitb_RBn]?state->basic.frames[guitb_RBn]:state->basic.frames[guitb_RBnHi], bound.left, bound.top );
    if( control->params )
    {
        *rWin = *((const Rect*)control->params);
        RectMoveBy(*rWin, bound.left, bound.top );
    }
    else
    {
        if( state->basic.frames[guitb_Overlay] )
            OPC_NAMING(Shape_Bound)( rWin, state->basic.frames[guitb_Overlay], bound.left, bound.top );
        else if( state->basic.frames[guitb_FocusOver] )
            OPC_NAMING(Shape_Bound)( rWin, state->basic.frames[guitb_FocusOver], bound.left, bound.top );
        else if( state->basic.frames[guitb_Under] )
            OPC_NAMING(Shape_Bound)( rWin, state->basic.frames[guitb_Under], bound.left, bound.top );
        else if( state->basic.frames[guitb_FocusUnder] )
            OPC_NAMING(Shape_Bound)( rWin, state->basic.frames[guitb_FocusUnder], bound.left, bound.top );
        else
            *rWin = bound;
    }
}

void GUI_Ctrl_Tumbler( struct GUI* gui, const struct GUI_Control* control, GUI_Message msg )
{
    GUI_Tumbler_State* state = (GUI_Tumbler_State*)GUI_Control_Data( gui, control );
    Rect bound;
    GUI_Control_Bound( gui, control, &bound );
#if defined(GUI_GetKeyHeld)
#define TB_SETUP_REPEAT(key) \
    if( state->msRepeat && key != state->keyPrev )\
    {\
        state->msPrev = (unsigned)GUI_MSTime() + GUI_RepeatPause(state->msRepeat);\
        state->keyPrev = (key);\
    }
#define TB_REPEAT_CANCEL() \
    {\
        state->msPrev = 0;\
        state->keyPrev = 0;\
    }
#else
#define TB_SETUP_REPEAT(key)
#define TB_REPEAT_CANCEL()
#endif
    switch( msg )
    {
    case GUI_Cycle:
        if( (state->basic.mask & (GUICS_INVISIBLE|GUICS_NOFOCUS)) )
            return;
        if( state->cStates )
        {
            Rect rRightArrow, rLeftArrow, rWin;
            GUI_Ctrl_Tumbler_Rects( gui, control, &rWin, &rLeftArrow, &rRightArrow );
            if( state->stateCurr != state->statePrev )
            {
                GUI_Control_Dirty( gui, control );
                /* 
                 * Transition states from one to another
                 * Take state->cTransition cycles to do it
                 */
                if( state->cTransition > 0 )
                {
                    state->offPrev += RectWide(rWin) / state->cTransition;
                    if( state->cTransition && state->offPrev >= RectWide(rWin) )
                    {
                        /*
                         * Finished (or no) transition, so carry on with cyclic duties
                         */
                        state->statePrev = state->stateCurr;
                        state->offPrev = 0;
                        return;
                    }
                    else
                    {
                        /*
                         * Don't accept more input until scroll's done
                         */
                        return;
                    }
                }
                else
                {
                    state->statePrev = state->stateCurr;
                    state->offPrev = 0;
                }
            }
            if( GUI_Control_IsFocused( gui, control ) )
            {
                unsigned keypress;
#if defined(GUI_GetKeyHeld)
                if( state->keyPrev && state->msRepeat )
                {
                    keypress = GUI_GetKeyHeld() & state->keyPrev;
                    if( keypress && state->msPrev )
                    {
                        unsigned mstime = (unsigned)GUI_MSTime();
                        if( mstime > state->msPrev && mstime - state->msPrev >= state->msRepeat )
                        {
                            state->msPrev = mstime;
                        }
                        else
                        {
                            keypress = 0;
                        }
                    }
                    else
                    {
                        TB_REPEAT_CANCEL();
                    }
                }
                else
#endif
                {
                    keypress = GUI_GetKeyPress();
                }

                /*
                 * If this has focus, take over 
                 */
#if defined(GUI_GetPointer)
                if( keypress == GUI_PICK )
                {
                    int x,y;
                    GUI_GetPointer(x,y);
                    if( RectPtInRect( rRightArrow, x,y) )
                    {
                        state->stateCurr++;
                        if( state->stateCurr >= state->cStates )
                            state->stateCurr = 0;
                        GUI_ClearKeyPress();
                        TB_SETUP_REPEAT(keypress);
                    }
                    else if( RectPtInRect( rLeftArrow, x,y ) )
                    {
                        state->stateCurr--;
                        if( state->stateCurr < 0 )
                            state->stateCurr = state->cStates - 1;
                        GUI_ClearKeyPress();
                        TB_SETUP_REPEAT(keypress);
                    }
                    else
                    {
                        TB_REPEAT_CANCEL();
                    }
                }
#endif
#if (defined(GUI_TABLEFT) && defined(GUI_TABRIGHT) && defined(GUI_TABUP) && defined(GUI_TABDOWN))
                if( abs(rLeftArrow.top - rRightArrow.top) > abs(rLeftArrow.left - rRightArrow.left) )
                {
                    if( GUI_TABUP == keypress )
                    {
                        state->stateCurr--;
                        if( state->stateCurr < 0 )
                            state->stateCurr = state->cStates - 1;
                        GUI_ClearKeyPress();
                        TB_SETUP_REPEAT(keypress);
                    }
                    else if( GUI_TABDOWN == keypress )
                    {
                        state->stateCurr++;
                        if( state->stateCurr >= state->cStates )
                            state->stateCurr = 0;
                        GUI_ClearKeyPress();
                        TB_SETUP_REPEAT(keypress);
                    }
                    else if( GUI_tabhandler( gui ) )
                    {
                        TB_REPEAT_CANCEL();
                        return;
                    }
                }
                else
                {
                    if( GUI_TABLEFT == keypress )
                    {
                        state->stateCurr--;
                        if( state->stateCurr < 0 )
                            state->stateCurr = state->cStates - 1;
                        GUI_ClearKeyPress();
                        TB_SETUP_REPEAT(keypress);
                    }
                    else if( GUI_TABRIGHT == keypress )
                    {
                        state->stateCurr++;
                        if( state->stateCurr >= state->cStates )
                            state->stateCurr = 0;
                        GUI_ClearKeyPress();
                        TB_SETUP_REPEAT(keypress);
                    }
                    else if( GUI_tabhandler( gui ) )
                    {
                        TB_REPEAT_CANCEL();
                        return;
                    }
                }
#elif !defined(GUI_GetPointer) && (defined(GUI_TAB) || defined(GUI_TABLEFT) || defined(GUI_TABRIGHT) || defined(GUI_TABUP) || defined(GUI_TABDOWN))
                /*
                 * If we don't have more than one or two tab buttons, don't waste them on the emulation
                 */
                if( GUI_SELECT == keypress )
                {
                    state->stateCurr++;
                    if( state->stateCurr >= state->cStates )
                        state->stateCurr = 0;
                    GUI_ClearKeyPress();
                    TB_SETUP_REPEAT(keypress);
                }
                else if( GUI_tabhandler( gui ) )
                {
                    TB_REPEAT_CANCEL();
                    return;
                }
#endif
                if( state->stateCurr != state->statePrev )
                {
                    GUI_Tabsound();
                    GUI_Control_Notify( gui, control );
                }
            }
            else
            {
                TB_REPEAT_CANCEL();
            }
        }
        else 
        {
            if( GUI_Control_IsFocused( gui, control ) )
                GUI_tabright(gui);
            TB_REPEAT_CANCEL();
            return;
        }
        break;
    case GUI_Paint:
        {
            OPC opc;
            if( !state->cStates || !state->basic.frames || (state->basic.mask & GUICS_INVISIBLE) )
                return;
            if( GUI_Control_Paint( gui, control, &opc ) )
            {
                Rect rRightArrow, rLeftArrow, rWin;
                bool bFocus = GUI_Control_IsFocused( gui, control );
                const OPCShape* la = state->basic.frames[guitb_LBn];
                const OPCShape* ra = state->basic.frames[guitb_RBn];
                int offx = 0,offy = 0;
                GUI_Ctrl_Tumbler_Rects( gui, control, &rWin, &rLeftArrow, &rRightArrow );
                if( bFocus && state->basic.frames[guitb_FocusUnder] )
                {
                    OPC_NAMING(Shape)( &opc, state->basic.frames[guitb_FocusUnder], bound.left, bound.top );
                }
                else
                {
                    OPC_NAMING(Shape)( &opc, state->basic.frames[guitb_Under], bound.left, bound.top );
                }
                if( state->offPrev )
                {
                    if( state->statePrev == 0 && state->stateCurr == state->cStates-1 )
                    {
                        /* Wrapped least to max */
                        la = state->basic.frames[guitb_LBnHi];
                        if( rLeftArrow.bottom < rRightArrow.top )
                        {
                            /* Vertical orientation */
                            offy = state->offPrev;
                        }
                        else
                        {
                            /* Horizontal orientation */
                            offx = state->offPrev;
                        }
                    }
                    else if( state->statePrev == state->cStates-1 && state->stateCurr == 0 )
                    {
                        /* Wrapped max to least */
                        ra = state->basic.frames[guitb_RBnHi];
                        if( rLeftArrow.bottom < rRightArrow.top )
                        {
                            /* Vertical orientation */
                            offy = -state->offPrev;
                        }
                        else
                        {
                            /* Horizontal orientation */
                            offx = -state->offPrev;
                        }
                    }
                    else if( state->statePrev < state->stateCurr )
                    {
                        /* Went bigger */
                        ra = state->basic.frames[guitb_RBnHi];
                        if( rLeftArrow.bottom < rRightArrow.top )
                        {
                            /* Vertical orientation */
                            offy = -state->offPrev;
                        }
                        else
                        {
                            /* Horizontal orientation */
                            offx = -state->offPrev;
                        }
                    }
                    else if( state->statePrev > state->stateCurr )
                    {
                        /* Went smaller */
                        la = state->basic.frames[guitb_LBnHi];
                        if( rLeftArrow.bottom < rRightArrow.top )
                        {
                            /* Vertical orientation */
                            offy = state->offPrev;
                        }
                        else
                        {
                            /* Horizontal orientation */
                            offx = state->offPrev;
                        }
                    }
                }
                /* Draw previous and current at offset */
                if( state->states || state->tstates )
                {
                    OPC opcbound;
                    OPC_NAMING(Clip)( &opcbound, &opc, &rWin );
                    if( offx )
                    {
                        RectLeftTo( rWin, rWin.left+offx );
                    }
                    else if( offy )
                    {
                        RectTopTo( rWin, rWin.top+offy );
                    }
                    if( offx || offy )
                    {
                        if( state->states )
                            GUI_AlignShape( &opcbound, &rWin, state->states[state->statePrev], state->ialign );
                        if( state->tstates )
                            GUI_DrawText( &opcbound, &rWin, state->basic.align, state->tstates[state->statePrev], ~0u );
                    }
                    if( offx < 0 )
                    {
                        RectLeftTo( rWin, rWin.left+RectWide(rWin) );
                    }
                    else if( offx > 0 )
                    {
                        RectLeftTo( rWin, rWin.left-RectWide(rWin) );
                    }
                    if( offy < 0 )
                    {
                        RectTopTo( rWin, rWin.top+RectHigh(rWin) );
                    }
                    else if( offy > 0 )
                    {
                        RectTopTo( rWin, rWin.top-RectHigh(rWin) );
                    }
                    if( state->states )
                        GUI_AlignShape( &opcbound, &rWin, state->states[state->stateCurr], state->ialign );
                    if( state->tstates )
                        GUI_DrawText( &opcbound, &rWin, state->basic.align, state->tstates[state->stateCurr], ~0u );
                }
                OPC_NAMING(Shape)( &opc, state->basic.frames[guitb_Overlay], bound.left, bound.top );
                if( state->basic.text && *state->basic.text )
                {
                    /* Draw any text that goes with the button */
                    GUI_DrawText( &opc, &bound, state->basic.align, state->basic.text, ~0u );
                }
                if( bFocus )
                {
                    OPC_NAMING(Shape)( &opc, state->basic.frames[guitb_FocusOver], bound.left, bound.top );
                    /* Show arrows when focused, hide when not */
                    OPC_NAMING(Shape)( &opc, la, bound.left, bound.top );
                    OPC_NAMING(Shape)( &opc, ra, bound.left, bound.top );
                }
            }
        }
        break;
    case GUI_Init:
        {
            GUI_Def_State(gui,control,GUICS_DEFAULT,GUI_CENTER|GUI_BOTTOM);
            TB_REPEAT_CANCEL();
            if( state->basic.cFrames > GUITumblerParts_COUNT )
            {
                GUI_Tumbler_Setup( gui, GUI_Control_Index( gui, control ), state->basic.frames + GUITumblerParts_COUNT, GUI_CENTER|GUI_VCENTER, NULL, GUI_CENTER|GUI_BOTTOM, state->basic.cFrames - GUITumblerParts_COUNT, 8, 0 );
            }
            else
            {
                GUI_Tumbler_Setup( gui, GUI_Control_Index( gui, control ), NULL, GUI_CENTER|GUI_VCENTER, NULL, GUI_CENTER|GUI_BOTTOM, 0, 5, 0 );
            }
        }
        break;
    default:
        break;
    }
#undef TB_SETUP_REPEAT
#undef TB_REPEAT_CANCEL
}

void _GUI_Tumbler_Setup( GUI* gui, int id, const OPCShape* const* shapes, unsigned shapeAlign, const GUI_CHAR* const* szz, unsigned szzAlign, size_t count, int transition, int curr )
{
    const GUI_Control* control = GUI_Control_Get( gui, id );
    GUI_Tumbler_State* state = (GUI_Tumbler_State*)GUI_Control_Data( gui, control );
    GUI_Assert_Type( gui, id, guih_Tumbler );
    state->basic.align = szzAlign;
    state->offPrev = 0;
    state->states = shapes;
    state->tstates = szz;
    state->cStates = (int)count;
    state->cTransition = transition;
    state->ialign = shapeAlign;
    state->stateCurr = state->statePrev = curr;
    state->msRepeat = GUI_DefaultRepeat;
    if( count && !(state->basic.mask & (GUICS_INVISIBLE|GUICS_NOFOCUS)) )
        state->basic.mask |= GUICS_NOTIFY;
    GUI_Control_Dirty( gui, control );
}

void _GUI_Tumbler_SetFrame( GUI* gui, int id, int curr )
{
    const GUI_Control* control = GUI_Control_Get( gui, id );
    GUI_Tumbler_State* state = (GUI_Tumbler_State*)GUI_Control_Data( gui, control );
    GUI_Assert_Type( gui, id, guih_Tumbler );
    state->offPrev = 0;
    state->stateCurr = curr;
    state->basic.mask |= GUICS_NOTIFY;
    GUI_Control_Dirty( gui, control );
}


void GUI_Ctrl_GUI( struct GUI* gui, const struct GUI_Control* control, GUI_Message msg )
{
    GUI_Control_State* state = GUI_Control_Data( gui, control );
    GUI* pGui = (GUI*)(state+1);
    /*
     * Rather than assert the order of initialization, just make sure gui's set up
     */
    pGui->parent = gui;
    pGui->control = control;
    switch( msg )
    {
    case GUI_PaintCtrl:
    case GUI_CycleCtrl:
        return;

    case GUI_Focus:
        /* Embedded GUI control focus */
        if( GUI_Control_IsFocused( gui, control ) )
        {
            /* We have gained focus */
            if( pGui->focus < 0 )
            {
                GUI_SetFocus(pGui,0);
                GUI_Control_Dirty( gui, control );
            }
        }
        else
        {
            /* We have lost focus */
            if( pGui->focus != -1 )
            {
                /* De-focus this it we were embedded, and lost focus */
                pGui->focus = -1;
                GUI_Control_Dirty( gui, control );
            }
        }
        return;

    case GUI_Cycle:
        /* Dump out of cycle */
        if( state->mask & GUICS_INVISIBLE )
            return;

        /* Cycle GUI handler */
        pGui->offx = gui->offx + state->offx + control->bound.left;
        pGui->offy = gui->offy + state->offy + control->bound.top;
        if( (state->mask & (GUICS_INVISIBLE|GUICS_NOFOCUS)) != (GUICS_INVISIBLE|GUICS_NOFOCUS) )
            pGui->handler( pGui, GUI_Cycle );
        /* Do notifies in contained gui */
        GUI_CallNotifies(pGui);
#ifdef SIMPLE_DIRTY
        RectUnionRect( gui->dirty, pGui->dirty );
#endif
        return;

    case GUI_Paint:
        /* Offset to match parent panning */
        pGui->dirty = gui->dirty;
        pGui->offx = gui->offx + state->offx + control->bound.left;
        pGui->offy = gui->offy + state->offy + control->bound.top;
        pGui->handler( pGui, GUI_Paint );
        return;

    case GUI_Init:
        /* Actual initialization should be invoked by user's GUI_Init handler */
        GUI_Def_State(gui,control,GUICS_DEFAULT,GUI_LEFT);
        return;

    case GUI_Destroy:
    default:
        break;
    }
    pGui->handler( pGui, msg );
}


void _GUI_Default( struct GUI* gui, GUI_Message msg )
{
    switch( msg )
    {

    case GUI_CycleCtrl:
        /*
            Cycle a control:
                Control ID is in iControl
                Call default before/after your hook to control (or never) how your handling is mixed with the control
        */
        GUI_Control_handle( gui, GUI_Control_Get( gui, gui->iControl ), GUI_Cycle );
        break;

    case GUI_PaintCtrl:
        /*
            Paint a control:
                Control ID is in iControl
                Call default before/after your hook to control (or never) how your content is mixed with the control
        */
        GUI_Control_handle( gui, GUI_Control_Get( gui, gui->iControl ), GUI_Paint );
        break;

    case GUI_Cycle:
        {
            /* Clear notifies */
            pointer_foreach_const( GUI_Control, gui->list, gui->cControl, control )
            {
                GUI_Control_State* state = GUI_Control_Data( gui, control );
                state->mask &= ~GUICS_NOTIFY;
            }
        }
#ifdef GUI_GetPointer
        /* Do pointer/mouse/finger focus magic */
        if( !gui->parent || GUI_Control_IsFocused( gui->parent, gui->control ) )
        {
            int x, y;
            Rect bound;
            GUI_GetPointer( x, y );
            {
                pointer_foreach_const_reverse( GUI_Control, gui->list, gui->cControl, control )
                {
                    GUI_Control_Bound( gui, control, &bound );
                    if( !(GUI_Control_Data( gui, control )->mask & (GUICS_INVISIBLE|GUICS_NOFOCUS)) && RectPtInRect( bound, x, y ) )
                    {
                        if( gui->focus >= 0 )
                        {
                            const GUI_Control* oldFocus = GUI_Control_Get( gui, gui->focus );
                            if( oldFocus != control )
                            {
                                GUI_Control_Dirty( gui, oldFocus );
                                GUI_Control_Dirty( gui, control );
                                gui->focus = control - gui->list;
                                gui->mask |= GUIM_FOCUSCHANGED;
                            }
                        }
                        else
                        {
                            gui->focus = control - gui->list;
                            GUI_Control_Dirty( gui, control );
                            gui->mask |= GUIM_FOCUSCHANGED;
                        }
                        break;
                    }
                }
            }
        }
#endif
        /* Now cycle the controls */
        for( gui->iControl = 0; gui->iControl < gui->cControl; ++gui->iControl )
            gui->handler(gui, GUI_CycleCtrl);
        break;

    case GUI_Paint: 
        /*
            Redraw the GUI, if it's dirty
            Hook and call GUI_Default afterwards to draw things behind under application control
            Hook and call GUI_Default before to draw things on top under application control
            Use GUI_PaintCtrl, or define a sf_, if you have something specific to do in the middle
        */
        {
            OPC opc;
            const Rect* curr;
#ifdef SIMPLE_DIRTY
            if( RectEmpty(gui->dirty) )
            {
                return;
            }
            else
            {
                curr = &gui->dirty;
            }
            gui->mask |= GUIM_INPAINT;
#else
            int cDirty;
            if( gui->parent )
            {
                /* Child windows don't iterate the dirty list recursively */
                curr = &gui->parent->dirty;
                cDirty = 1;
            }
            else
            {
                /* Top-level windows need to iterate whole list */
                curr = gui->cdirty->dirty;
                cDirty = gui->cdirty->cDirty;
            }
            /* Let external code know that paint is going on */
            gui->mask |= GUIM_INPAINT;
            while( cDirty-- )
#endif  
            {
                /* Set our 'dirty' rectangle */
                gui->dirty = *curr;
                OPC_NAMING(Clip)( &opc, &gui->opc, curr );
                /* Render background */
                OPC_NAMING(Shape)( &opc, gui->bg, gui->offx,gui->offy );
                /* Render controls in order */
                for( gui->iControl = 0; gui->iControl < gui->cControl; ++gui->iControl )
                {

                    if( !( GUI_Control_Get_Mask( gui, gui->iControl ) & GUICS_INVISIBLE) )
                    {
                        gui->handler(gui, GUI_PaintCtrl);
                    }
                }
                /* Render overlay */
                OPC_NAMING(Shape)( &opc, gui->ov, gui->offx,gui->offy );
                curr++;
            }
            /* Let external code know that paint is finished */
            gui->mask &= ~GUIM_INPAINT;
            /* It's up to external code to clear the dirty list */
        }
        RectClear(gui->dirty);
        break;

    case GUI_Init:  /* Do initializations, if it's dirty */
        {
            /* Initialize trivial dirty rectangle handler */
            GUI_Dirty( gui );
            {
                /* Initialize controls */
                pointer_foreach_const( GUI_Control, gui->list, gui->cControl, control )
                    GUI_Control_handle( gui, control, GUI_Init );
            }
            /* Set focus at earliest enabled, visible control */
            GUI_SetFocus( gui, 0 );
            gui->mask = GUIM_ALIVE;
        }
        break;

    case GUI_Destroy: /* If anything grabbed up a resource, release it. */
        {
            pointer_foreach_const( GUI_Control, gui->list, gui->cControl, control )
                GUI_Control_handle( gui, control, GUI_Destroy );
            GUI_Dirty_Rect( gui, &gui->opc.clip );
            gui->cControl = 0; /* Note, if we were in Cycle, Notify, Paint, etc. loops, this stops it. */
            gui->mask = 0;
        }
        break;

    /* Eatme events */
    case GUI_Focus:
    case GUI_Notify:
    default:
        break;
    }
}

#ifndef NO_GUI_BLIB

#include "ctl/blib.h"
/*
 * Lookup how big various mutable data for controls are in memory
 */
#define XENUM(tag,verbose,data) sizeof(data),
static const size_t lutRequirements[] =
{
    EDEF_HANDLERS(XENUM)
};
#undef XENUM

size_t GUI_BlibNeeds( const void* pData, size_t size, size_t myExtra )
{
    /*
     * Data is BLIB of BLIBs.
     * Tally what each control needs for a total, either so you can allocate
     * or so you can assert some static buffer has enough.
     */
    const BLIB* blib = pData;
    if( BLIB_Valid( blib, size ) && BLIB_User(blib) == *((uint32*)"GUI") )
    {
        size_t ret = (sizeof(GUI) + myExtra + 7) & ~7u;
        BLIB_foreach(blib,curr)
        {
            const BLIB* blibCurr = (const BLIB*)curr;
            uint32 user = BLIB_User( blibCurr );
            if( user >= GUIHandlers_COUNT )
                return 0;
            /* That's size of control data, sizeof control struct in list, sizeof vtab entry, sizeof sprite table */
            switch( user )
            {
            case guih_Invalid: default:
                return 0;

            case guih_Background:
            case guih_Overlay:
                break;

            case guih_GUI:
            case guih_ArtResource:
            case guih_StaticFrame:
            case guih_Button:
            case guih_Checkbox:
            case guih_Animation:
            case guih_Scrollbar:
            case guih_Ticker:
            case guih_Tumbler:
                ret += lutRequirements[user] + sizeof(GUI_Control) + sizeof(GUI_Control*) + sizeof(GUI_Control*) + (BLIB_Count( blibCurr ) * sizeof(OPCShape*));
                break;

            }
        }
        return ret;
    }
    return 0;
}

/* Sort by x, then y */
int qsGCA_vtab( const GUI_Control** p1, const GUI_Control** p2 )
{
    int diffX, diffY, x1, y1, x2, y2;
    RectCenterPt((*p1)->bound,x1,y1);
    RectCenterPt((*p2)->bound,x2,y2);
    diffY = y1-y2;
    diffX = x1-x2;
    if( abs( diffX ) > GUI_TAB_IGNORE )
        return diffX;
    return diffY;
}


/* Sort by y, then x */
int qsGCA_htab( const GUI_Control** p1, const GUI_Control** p2 )
{
    int diffX, diffY, x1, y1, x2, y2;
    RectCenterPt((*p1)->bound,x1,y1);
    RectCenterPt((*p2)->bound,x2,y2);
    diffY = y1-y2;
    diffX = x1-x2;
    if( abs(diffY) > GUI_TAB_IGNORE )
        return diffY;
    return diffX;
}

GUI* GUI_BlibInit( const void* pData, size_t size, size_t myExtra, void* pguiBuff, GUI_handler handler, void* param, const OPC* opc
#ifdef SIMPLE_DIRTY
    )
#else
  , ClipRect* cliprect )
#endif
{
    GUI* gui = (GUI*)pguiBuff;
    const BLIB* blib = pData;
    myExtra = (myExtra + 7) & ~7;
    if( BLIB_Valid( blib, size ) && BLIB_User(blib) == *((uint32*)"GUI") )
    {
        /*
         * Pass 1: Work out where things begin and end
         */
        GUI_Control* list;          /* Main control table */
        GUI_Control** htab;         /* Main control table */
        GUI_Control** vtab;         /* Vertical tab table */
        const OPCShape** sptab;     /* Sprite lookup table */
        {
            size_t offset = (sizeof(GUI) + myExtra + 7) & ~7u;
            size_t count = 0;
            size_t cControl = 0;
            BLIB_foreach(blib,curr)
            {
                const BLIB* blibCurr = (const BLIB*)curr;
                GUIHandlers user = (GUIHandlers)BLIB_User( blibCurr );
                if( user >= GUIHandlers_COUNT )
                    return 0;
                switch( user )
                {
                case guih_Invalid: default:
                    return NULL;

                case guih_Background:
                    gui->bg = (const OPCShape*)(BLIB_SIZE( blib ) ? BLIB_ELEMENT_PTR( blibCurr, 0 ) : NULL);
                    break;
                case guih_Overlay:
                    gui->ov = (const OPCShape*)(BLIB_SIZE( blib ) ? BLIB_ELEMENT_PTR( blibCurr, 0 ) : NULL);
                    break;

                case guih_ArtResource:
                    count++;
                    break;
                case guih_GUI:
                    user = guih_StaticFrame;
                case guih_StaticFrame:
                case guih_Button:
                case guih_Checkbox:
                case guih_Animation:
                case guih_Scrollbar:
                case guih_Ticker:
                case guih_Tumbler:
                    offset += lutRequirements[user];
                    count++;
                    cControl++;
                    break;
                }
            }
            /* Work out beginnings of various tables */
            gui->parent = NULL;
            gui->list = list = (GUI_Control*)((uint8*)pguiBuff + offset);
            gui->htab = htab = (GUI_Control**)(list + count);
            gui->vtab = vtab = (GUI_Control**)(htab + count);
            sptab = (const OPCShape**)(vtab + count);
            gui->bg = gui->ov = NULL;
            gui->cControl = cControl;
            gui->focus = 0;
            gui->offx = gui->offy = 0;
            gui->opc = *opc;
            gui->param = param;
#ifndef GUI_NO_GENERATOR
            state_init( gui->state );
#endif
            gui->dirty = opc->clip;
#ifndef SIMPLE_DIRTY
            gui->cdirty = cliprect;
#endif
            gui->handler = handler ? handler : _GUI_Default;
        }
        /*
         * Pass 2: Now that we know where things go, put things in it
         */
        {
            size_t offset = sizeof(GUI);
            BLIB_foreach(blib,curr)
            {
                const BLIB* blibCurr = (const BLIB*)curr;
                GUIHandlers user = (GUIHandlers)BLIB_User( blibCurr );
                switch( user )
                {
                case guih_Invalid: default:
                    return NULL;

                case guih_Background:
                    gui->bg = (const OPCShape*)(BLIB_SIZE( blib ) ? BLIB_ELEMENT_PTR( blibCurr, 0 ) : NULL);
                    break;
                case guih_Overlay:
                    gui->ov = (const OPCShape*)(BLIB_SIZE( blib ) ? BLIB_ELEMENT_PTR( blibCurr, 0 ) : NULL);
                    break;

                case guih_GUI:
                    user = guih_StaticFrame;
                case guih_ArtResource:
                case guih_StaticFrame:
                case guih_Button:
                case guih_Checkbox:
                case guih_Animation:
                case guih_Scrollbar:
                case guih_Ticker:
                case guih_Tumbler:
                    list->type = user;
                    list->offData = offset;
                    /*
                     * Element 0 of the BLIB is the bounding box for the control
                     * Element 1~BLIB_COUNT( blib ) are sprites
                     */     
                    assert( BLIB_COUNT( blibCurr ) >= 1 );
                    list->cState = BLIB_COUNT( blibCurr )-1;
                    list->state = list->cState ? sptab : NULL;
                    assert( BLIB_ELEMENT_SIZE( blibCurr, 0 ) == sizeof(Rect) );
                    list->bound = *((const Rect*)BLIB_ELEMENT_PTR( blibCurr, 0 ));
                    list->params = NULL;
                    {
                        size_t ishape;
                        for( ishape = 1; ishape <= list->cState; ++ishape )
                        {
                            const OPCShape* shape = (const OPCShape*)(BLIB_ELEMENT_SIZE( blibCurr, ishape ) ? BLIB_ELEMENT_PTR( blibCurr, ishape ) : NULL);
                            *sptab++ = shape;
                        }
                    }
                    offset += lutRequirements[user];
                    *htab++ = list;
                    *vtab++ = list++;
                    break;
                }
            }
        }
        /* Sort tabbing arrays */
        array_qsort( GUI_Control*, (GUI_Control**)gui->htab, gui->cControl, qsGCA_htab );
        array_qsort( GUI_Control*, (GUI_Control**)gui->vtab, gui->cControl, qsGCA_vtab );

        /* We built it, so initialize it & run with it */
        gui->handler(gui,GUI_Init);
        return gui;
    }
    return NULL;
}
#endif /* NO_GUI_BLIB */