application.cpp

Go to the documentation of this file.

#include "application.h"
#include "console.h"
#include "event.h"
#include "eventhandler.h"
#include "hotspot.h"
#include <string.h>
#include <malloc.h>
#include <gccore.h>
#include <ogcsys.h>
#include <wiiuse/wpad.h>
#include <algorithm>
#include <iterator>
#include <vector>

namespace wit {

// default font declarations
struct Sans16_Registrar { Sans16_Registrar(); };
struct Sans16_B_Registrar { Sans16_B_Registrar(); };
struct Sans16_I_Registrar { Sans16_I_Registrar(); };
struct Sans16_B_I_Registrar { Sans16_B_I_Registrar(); };


struct EventHandlerNode {
    EventHandler* handler;
    int controllerID;
    EventHandlerNode* next;
};

struct TimerNode {
    EventHandler* handler;
    int framesRemaining;
    void* data;
    TimerNode* next;
};

class ApplicationPrivate {
friend class Application;
public:
    int features, screenWidth, powerControllerID;
    bool currentBuffer, doShutdown, doReset, doPower, abortGxOnReset;
    bool autoHomeMenu, homeMenuOpen;
    GXRModeObj videoMode;
    void* framebuffer[2];
    void* gxfifo;
    Console* console;
    EventHandlerNode* focus;
    EventHandlerNode* eventFilters;
    TimerNode* timers;
    TimerNode* addTimers;
}; 

static Application* witInstance = 0; 
static ApplicationPrivate* witPrivate = 0;
void wit_render_all();

static void wit_power_button_callback()
{
    witPrivate->doPower = true;
    witPrivate->powerControllerID = -1;
    if(witPrivate->features & UseGX && witPrivate->abortGxOnReset) GX_AbortFrame();
}

static void wit_reset_button_callback()
{
    witPrivate->doReset = true;
    if(witPrivate->features & UseGX && witPrivate->abortGxOnReset) GX_AbortFrame();
}

static void wit_remote_power_button_callback(int id)
{
    witPrivate->doPower = true;
    witPrivate->powerControllerID = id;
    if(witPrivate->features & UseGX && witPrivate->abortGxOnReset) GX_AbortFrame();
}

Application::Application(int features)
{
    // initialize private data
    witInstance = this;
    witPrivate = d = new ApplicationPrivate;
    memset(d, 0, sizeof(ApplicationPrivate));
    d->features = features;
    d->abortGxOnReset = true;

    // initialize framebuffer
    VIDEO_Init();
    VIDEO_GetPreferredMode(&d->videoMode);
    if(CONF_GetAspectRatio() == CONF_ASPECT_16_9) {
        d->videoMode.viWidth = VI_MAX_WIDTH_PAL - 12;
        d->videoMode.viXOrigin = 8;
    }
    VIDEO_Configure(&d->videoMode);
    d->framebuffer[0] = MEM_K0_TO_K1(SYS_AllocateFramebuffer(&d->videoMode));
    VIDEO_ClearFrameBuffer(&d->videoMode, d->framebuffer[0], 0x800080);
    if(features & UseDoubleBuffer) {
        d->framebuffer[1] = MEM_K0_TO_K1(SYS_AllocateFramebuffer(&d->videoMode));
        VIDEO_ClearFrameBuffer(&d->videoMode, d->framebuffer[1], 0x800080);
    }
    d->currentBuffer = false;
    VIDEO_SetNextFramebuffer(d->framebuffer[0]);
    VIDEO_SetBlack(false);
    VIDEO_Flush();

    if(features & UseWiiRemote) {
        WPAD_Init();
        for(int i = 0; i < WPAD_MAX_WIIMOTES; i++) {
            if(features & UsePointer) {
                WPAD_SetDataFormat(i, WPAD_FMT_BTNS_ACC_IR);
                WPAD_SetVRes(i, d->videoMode.fbWidth, d->videoMode.xfbHeight);
            } else if(features & UseMotion) {
                WPAD_SetDataFormat(i, WPAD_FMT_BTNS_ACC);
            }
        }
    }

    if(features & UseGameCube) {
        PAD_Init();
    }

    if(features & UseSound) {
        //InitAudio();
    }

    if(features & UseFAT) {
        //FatInitDefault();
    }

    VIDEO_WaitVSync();
    if(d->videoMode.viTVMode & VI_NON_INTERLACE)
        VIDEO_WaitVSync();

    if(features & UseGX) {
        d->gxfifo = memalign(262144, 32);
        memset(d->gxfifo, 0, 262144);
        GX_Init(d->gxfifo, 262144);
        GX_SetBlendMode(GX_BM_BLEND,GX_BL_SRCALPHA,GX_BL_INVSRCALPHA,GX_LO_CLEAR);
        GX_SetCopyClear((GXColor){ 0, 0, 0, 0xFF }, 0xFFFFFF);
        GX_SetViewport(0, 0, d->videoMode.fbWidth, d->videoMode.efbHeight, 0, 1);
        GX_SetScissor(0, 0, d->videoMode.fbWidth, d->videoMode.efbHeight);
        GX_SetDispCopyGamma(GX_GM_1_0);
        GX_SetCullMode(GX_CULL_NONE);
        GX_SetDispCopyDst(d->videoMode.fbWidth, GX_SetDispCopyYScale(GX_GetYScaleFactor(d->videoMode.efbHeight,d->videoMode.xfbHeight)));
        GX_SetCopyFilter(d->videoMode.aa, d->videoMode.sample_pattern, GX_TRUE, d->videoMode.vfilter);
        GX_SetVtxAttrFmt(GX_VTXFMT7, GX_VA_POS, GX_POS_XY, GX_F32, 0);
        GX_SetVtxAttrFmt(GX_VTXFMT7, GX_VA_CLR0, GX_CLR_RGBA, GX_RGBA8, 0);
        GX_SetVtxAttrFmt(GX_VTXFMT7, GX_VA_TEX0, GX_TEX_ST, GX_F32, 0);
        if(d->videoMode.aa)
            GX_SetPixelFmt(GX_PF_RGB565_Z16, GX_ZC_LINEAR);
        else
            GX_SetPixelFmt(GX_PF_RGB8_Z24, GX_ZC_LINEAR);
        
        // Also load default fonts
        Sans16_Registrar s16r;
        /*Sans16_B_Registrar s16br;
        Sans16_I_Registrar s16ir;
        Sans16_B_I_Registrar s16bir;*/
    }

    if(features & UseConsole) {
        d->console = new Console(&d->videoMode);
    } else {
        d->console = 0;
    }

    // install callbacks
    SYS_SetResetCallback(wit_reset_button_callback);
    SYS_SetPowerCallback(wit_power_button_callback);
    if(features & UseWiiRemote)
        WPAD_SetPowerButtonCallback(wit_remote_power_button_callback);
}

Application::~Application()
{
    // shut down display
    if(d->features & UseGX) {
        GX_AbortFrame();
        GX_Flush();
    }
    VIDEO_Flush();

    // clean up data structures
    EventHandlerNode* next;
    while(d->focus) {
        next = d->focus->next;
        delete d->focus;
        d->focus = next;
    }
    while(d->eventFilters) {
        next = d->eventFilters->next;
        delete d->eventFilters;
        d->eventFilters = next;
    }
    TimerNode* nextTimer;
    while(d->timers) {
        nextTimer = d->timers->next;
        delete d->timers;
        d->timers = nextTimer;
    }
    while(d->addTimers) {
        nextTimer = d->addTimers->next;
        delete d->addTimers;
        d->addTimers = nextTimer;
    }
    delete d->console; 
    free(d->gxfifo);
    delete d;
}

Application* Application::instance()
{
    return witInstance;
}

Console* Application::console() const
{
    return d->console;
}

int Application::features() const
{
    return d->features;
}

void* Application::framebuffer() const
{
    return d->framebuffer[d->currentBuffer ? 1 : 0];
}

int Application::screenWidth() const
{
    return d->videoMode.fbWidth;
}

int Application::screenHeight() const
{
    return d->videoMode.xfbHeight;
}

void Application::setAutoHomeMenu(bool on)
{
    d->autoHomeMenu = on;
}

bool Application::autoHomeMenu() const
{
    return d->autoHomeMenu;
}

void Application::showHomeMenu()
{
    setHomeMenuVisible(true);
}

void Application::hideHomeMenu()
{
    setHomeMenuVisible(false);
}

void Application::homeMenuEvent(Event* event)
{
    // TODO: implement Wii-style home menu
}

void Application::setHomeMenuVisible(bool on)
{
    // TODO: capture framebuffer
    d->homeMenuVisible = on;
}

bool Application::isHomeMenuVisible() const
{
    return d->homeMenuVisible;
}

void Application::reboot()
{
    d->doShutdown = true;
    SYS_ResetSystem(SYS_RESTART, 0, 0);
}

void Application::shutdown(ShutdownMode mode)
{
    d->doShutdown = true;
    if(mode == Shutdown_Idle)
        SYS_ResetSystem(SYS_POWEROFF_IDLE, 0, 0);
    else if(mode == Shutdown_Standby)
        SYS_ResetSystem(SYS_POWEROFF_STANDBY, 0, 0);
    else
        SYS_ResetSystem(SYS_POWEROFF, 0, 0);
}

void Application::returnToMenu()
{
    d->doShutdown = true;
    SYS_ResetSystem(SYS_RETURNTOMENU, 0, 0);
}

void Application::quit()
{
    d->doShutdown = true;
}

static void wit_Application_wpad_cb(s32 chan, const WPADData* data)
{
    static const unsigned int remoteMap[] = {
        0, WPAD_BUTTON_UP, WPAD_BUTTON_DOWN, WPAD_BUTTON_LEFT, WPAD_BUTTON_RIGHT, WPAD_BUTTON_1, WPAD_BUTTON_2,
        WPAD_BUTTON_A, WPAD_BUTTON_B, 0, 0, 0, 0, 0, 0, 0, 0, WPAD_BUTTON_MINUS, WPAD_BUTTON_PLUS, WPAD_BUTTON_HOME, 0
    }; 
    static const unsigned int nunchukMap[] = {
        0, 0, 0, 0, 0, 0, 0, 0, 0, WPAD_NUNCHUK_BUTTON_C, 0, 0, WPAD_NUNCHUK_BUTTON_Z, 0, 0, 0, 0, 0, 0, 0, 0
    }; 
    static const unsigned int classicMap[] = {
        0, WPAD_CLASSIC_BUTTON_UP, WPAD_CLASSIC_BUTTON_DOWN, WPAD_CLASSIC_BUTTON_LEFT, WPAD_CLASSIC_BUTTON_RIGHT,
        0, 0, WPAD_CLASSIC_BUTTON_A, WPAD_CLASSIC_BUTTON_B, 0, WPAD_CLASSIC_BUTTON_X, WPAD_CLASSIC_BUTTON_Y, 0,
        WPAD_CLASSIC_BUTTON_ZL, WPAD_CLASSIC_BUTTON_ZR, WPAD_CLASSIC_BUTTON_FULL_L, WPAD_CLASSIC_BUTTON_FULL_R,
        WPAD_CLASSIC_BUTTON_MINUS, WPAD_CLASSIC_BUTTON_PLUS, WPAD_CLASSIC_BUTTON_HOME, 0
    }; 
    static const unsigned int guitarMap[] = {
        0, WPAD_GUITAR_HERO_3_BUTTON_STRUM_UP, WPAD_GUITAR_HERO_3_BUTTON_STRUM_DOWN, 0, 0,
        WPAD_GUITAR_HERO_3_BUTTON_YELLOW, WPAD_GUITAR_HERO_3_BUTTON_GREEN, WPAD_GUITAR_HERO_3_BUTTON_BLUE,
        WPAD_GUITAR_HERO_3_BUTTON_RED, WPAD_GUITAR_HERO_3_BUTTON_ORANGE, 0, 0, 0, 0, 0, 0, 0,
        WPAD_GUITAR_HERO_3_BUTTON_MINUS, WPAD_GUITAR_HERO_3_BUTTON_PLUS, 0, 0
    }; 

    int features = witInstance->features();

    if(data->btns_d ^ data->btns_u) {
        for(int i = 1; i < Button_Max; i++) {
            if(data->btns_d & remoteMap[i])
                witInstance->postEvent(new ButtonEvent(Event::ButtonPress, WiiRemote, chan, i));
            else if(data->btns_u & remoteMap[i])
                witInstance->postEvent(new ButtonEvent(Event::ButtonRelease, WiiRemote, chan, i));

            if(data->exp.type == WPAD_EXP_NUNCHUK && data->exp.nunchuk.btns & nunchukMap[i])
                witInstance->postEvent(new ButtonEvent(Event::ButtonPress, Nunchuk, chan, i));
            else if(data->exp.type == WPAD_EXP_NUNCHUK && data->exp.nunchuk.btns_released & nunchukMap[i])
                witInstance->postEvent(new ButtonEvent(Event::ButtonRelease, Nunchuk, chan, i));

            if(data->exp.type == WPAD_EXP_CLASSIC && data->exp.classic.btns & classicMap[i])
                witInstance->postEvent(new ButtonEvent(Event::ButtonPress, Classic, chan, i));
            else if(data->exp.type == WPAD_EXP_CLASSIC && data->exp.classic.btns_released & classicMap[i])
                witInstance->postEvent(new ButtonEvent(Event::ButtonRelease, Classic, chan, i));

            if(data->exp.type == WPAD_EXP_GUITARHERO3 && data->exp.gh3.btns & guitarMap[i])
                witInstance->postEvent(new ButtonEvent(Event::ButtonPress, Guitar, chan, i));
            else if(data->exp.type == WPAD_EXP_GUITARHERO3 && data->exp.gh3.btns_released & guitarMap[i])
                witInstance->postEvent(new ButtonEvent(Event::ButtonRelease, Guitar, chan, i));
        }
    }

    if(features & UseJoysticks) {
        // TODO: Only announce joystick events if the values change
        if(data->exp.type == WPAD_EXP_NUNCHUK) {
            JoystickEvent* stickEvent = new JoystickEvent(Nunchuk, chan);
            stickEvent->setByAngle(data->exp.nunchuk.js.ang, data->exp.nunchuk.js.mag);
            witInstance->postEvent(stickEvent);
        } else if(data->exp.type == WPAD_EXP_GUITARHERO3) {
            JoystickEvent* stickEvent = new JoystickEvent(Guitar, chan);
            stickEvent->setByAngle(data->exp.gh3.js.ang, data->exp.gh3.js.mag);
            witInstance->postEvent(stickEvent);
            witInstance->postEvent(new AnalogEvent(Guitar, chan, Analog_Whammy, data->exp.gh3.whammy_bar));
        } else if(data->exp.type == WPAD_EXP_CLASSIC) {
            JoystickEvent* stickEvent = new JoystickEvent(Classic, chan);
            stickEvent->setByAngle(data->exp.classic.ljs.ang, data->exp.classic.ljs.mag);
            witInstance->postEvent(stickEvent);
            stickEvent = new JoystickEvent(Classic, chan, true);
            stickEvent->setByAngle(data->exp.classic.rjs.ang, data->exp.classic.rjs.mag);
            witInstance->postEvent(stickEvent);
            witInstance->postEvent(new AnalogEvent(Classic, chan, Analog_Left, data->exp.classic.l_shoulder));
            witInstance->postEvent(new AnalogEvent(Classic, chan, Analog_Right, data->exp.classic.r_shoulder));
        }
    }

    if(features & UsePointer) {
        if(data->ir.valid) {
            witInstance->postEvent(new PointerEvent(chan, data->ir.x, data->ir.y, data->ir.z));
        } else {
            witInstance->postEvent(new PointerEvent(chan, -1.0f, -1.0f, -1.0f));
        }
    }

    if(features & UseMotion) {
        float x = data->accel.x / 1024.0;
        float y = data->accel.y / 1024.0;
        float z = data->accel.z / 1024.0;
        witInstance->postEvent(new MotionEvent(WiiRemote, chan, x, y, z, data->orient.pitch, data->orient.roll));
        if(data->exp.type == WPAD_EXP_NUNCHUK) {
            x = data->exp.nunchuk.accel.x / 1024.0;
            y = data->exp.nunchuk.accel.y / 1024.0;
            z = data->exp.nunchuk.accel.z / 1024.0;
            witInstance->postEvent(new MotionEvent(Nunchuk, chan, x, y, z, data->exp.nunchuk.orient.pitch, data->exp.nunchuk.orient.roll));
        }
        /*if(data->exp.type == WPAD_EXP_WIIBOARD) {
            // data->exp.wb
            x = data->exp.wb.x;
            y = data->exp.wb.y;
            z = (data->exp.wb.tl + data->exp.wb.tr + data->exp.wb.bl + data->exp.wb.br) / 4.0f; // weight
            witInstance->postEvent(new MotionEvent(BalanceBoard, chan, x, y, z, 0, 0));
        }*/
    }
}

static void wit_Application_gcpad_cb(s32 chan, const PADStatus* data)
{
    static const unsigned int gcMap[] = {
        0, PAD_BUTTON_UP, PAD_BUTTON_DOWN, PAD_BUTTON_LEFT, PAD_BUTTON_RIGHT, 0, 0,
        PAD_BUTTON_A, PAD_BUTTON_B, 0, PAD_BUTTON_X, PAD_BUTTON_Y, PAD_TRIGGER_Z, 0, 0,
        PAD_TRIGGER_L, PAD_TRIGGER_R, 0, 0, 0, PAD_BUTTON_START
    }; 

    static u16 oldbuttons[PAD_CHANMAX] = { 0, 0, 0, 0 };

    if(data->err == PAD_ERR_NO_CONTROLLER) return;

    int features = witInstance->features();

    if(data->button != oldbuttons[chan]) {
        u16 changed = (data->button ^ oldbuttons[chan]);
        u16 press = changed & data->button;
        u16 release = changed & oldbuttons[chan];
        oldbuttons[chan] = data->button;
        for(int i = 0; i < Button_Max; i++) {
            if(press & gcMap[i]) {
                witInstance->postEvent(new ButtonEvent(Event::ButtonPress, GameCube, chan+4, i));
            } else if(release & gcMap[i]) {
                witInstance->postEvent(new ButtonEvent(Event::ButtonRelease, GameCube, chan+4, i));
            }
        }
    }

    if(features & UseJoysticks) {
        // TODO: only output joystick events if the values have changed
        JoystickEvent* stickEvent = new JoystickEvent(GameCube, chan+4);
        stickEvent->setByPosition(data->stickX, data->stickY);
        witInstance->postEvent(stickEvent);
        stickEvent = new JoystickEvent(GameCube, chan+4, true);
        stickEvent->setByPosition(data->substickX, data->substickY);
        witInstance->postEvent(stickEvent);
        witInstance->postEvent(new AnalogEvent(GameCube, chan+4, Analog_Left, data->triggerL / 256.0f));
        witInstance->postEvent(new AnalogEvent(GameCube, chan+4, Analog_Right, data->triggerR / 256.0f));
        witInstance->postEvent(new AnalogEvent(GameCube, chan+4, Analog_A, data->analogA / 256.0f));
        witInstance->postEvent(new AnalogEvent(GameCube, chan+4, Analog_B, data->analogB / 256.0f));
    }
}

static inline bool doStop() { return witPrivate->doShutdown || witPrivate->doPower || witPrivate->doReset; }

void Application::run()
{
    // Create these variables here (even if we're not going to use them) so we
    // have them here on the stack instead of having to allocate them as needed.
    PADStatus gcpad[PAD_CHANMAX];
    WPADData wpadData;

    d->doShutdown = false;
    while(!d->doShutdown) {
        // Handle Wii Remote events
        if(!doStop() && d->features & UseWiiRemote) { 
            for(int i = WPAD_CHAN_0; !doStop() && i < WPAD_MAX_WIIMOTES; i++) {
                while(!doStop() && WPAD_ReadEvent(i, &wpadData) >= WPAD_ERR_NONE) 
                    wit_Application_wpad_cb(i, &wpadData);
            }
        }

        // Handle GameCube controller events
        if(!doStop() && d->features & UseGameCube) {
            PAD_Read(gcpad);
            for(int i = 0; !doStop() && i < PAD_CHANMAX; i++) {
                wit_Application_gcpad_cb(i, &gcpad[i]);
            }
        }

        // Handle power-button presses
        if(d->doPower) {
            powerButtonPressed(d->powerControllerID);
            d->doPower = false;
        } else if(d->doReset) {
            resetButtonPressed();
            d->doReset = false;
        }

        // Do rendering
        wit_render_all();
        if(!d->doShutdown) {
            if(d->features & UseGX) {
                GX_DrawDone();
                GX_SetZMode(GX_TRUE, GX_LEQUAL, GX_TRUE);
                GX_Flush();
                GX_CopyDisp(framebuffer(),GX_TRUE);
            }
            if(d->features & UseDoubleBuffer) {
                VIDEO_SetNextFramebuffer(framebuffer());
                VIDEO_Flush();
                d->currentBuffer = !d->currentBuffer;
                if(d->features & UseConsole)
                    console()->setFramebuffer(framebuffer());
            } else {
                VIDEO_Flush();
            }
            
            // Only process timers if the home menu is not visible
            if(!d->homeMenuVisible) {
                // Add timers scheduled during event handling
                if(d->addTimers) {
                    // Find the end of the linked list
                    TimerNode* timer = d->addTimers;
                    while(timer->next) timer = timer->next;
                    timer->next = d->timers;
                    d->timers = d->addTimers;
                    d->addTimers = 0;
                }

                // Check for expiring timers
                TimerNode* timer = d->timers;
                TimerNode* previousTimer = 0;
                TimerNode* nextTimer;
                while(timer) {
                    if(--timer->framesRemaining < 0) {
                        timer->handler->timerTriggered(timer->data);
                        if(previousTimer) {
                            previousTimer->next = timer->next;
                        } else {
                            d->timers = timer->next;
                        }
                        nextTimer = timer->next;
                        delete timer;
                        timer = nextTimer;
                    } else {
                        previousTimer = timer;
                        timer = timer->next;
                    }
                }

                // Append timers scheduled during timer dispatch
                if(previousTimer) {
                    previousTimer->next = d->addTimers;
                } else {
                    d->timers = d->addTimers;
                }
                d->addTimers = 0;
            }

            VIDEO_WaitVSync();
        }
    }
}

static bool wit_Application_distribute_event(Event* event, EventHandlerNode* node)
{
    while(node) {
        bool cancel = node->handler->event(event);
        if(cancel) return true;
        node = node->next;
    }
    return false;
}

static HotspotList lastHotspots[4];

void Application::postEvent(Event* event)
{
    if(d->homeMenuVisible) {
        homeMenuEvent(event);
        delete event;
        return;
    }

    if(wit_Application_distribute_event(event, d->eventFilters)) {
        delete event;
        return;
    }

    if(event->type() == Event::Pointer) {
        PointerEvent* p = static_cast<PointerEvent*>(event);
        if(p->isValid()) {
            Hotspot* hs;
            std::auto_ptr<HotspotList> spots = Hotspot::findAtPoint(p->x, p->y);
            std::sort(spots->begin(), spots->end());
            HotspotList lostFocus;
            std::set_difference(lastHotspots[p->controllerNumber].begin(), lastHotspots[p->controllerNumber].end(), spots->begin(), spots->end(), std::back_inserter(lostFocus));
            lastHotspots[p->controllerNumber] = *spots;
            if(lostFocus.size() > 0) {
                Hotspot** end = &lostFocus.back();
                for(Hotspot** iter = &lostFocus.front(); iter <= end; iter++) {
                    hs = *iter;
                    PointerLeaveEvent leaveEvent(p->controllerNumber, hs);
                    if(!wit_Application_distribute_event(&leaveEvent, d->eventFilters) && hs->eventHandler())
                        hs->eventHandler()->event(&leaveEvent);
                }
            }
            if(spots->size() > 0) {
                Hotspot** end = &spots->back();
                Hotspot* receiver = 0;
                for(Hotspot** iter = &spots->front(); iter <= end; iter++) {
                    hs = *iter;
                    if(!hs->eventHandler()) continue;
                    if(receiver && hs->zIndex() < receiver->zIndex()) continue;
                    receiver = hs;
                }
                if(receiver)
                    receiver->eventHandler()->event(event);
            }
        }
    } else {
        wit_Application_distribute_event(event, d->focus);
    }
    delete event;
}

void Application::pushFocus(EventHandler* handler, int controllerID)
{
    EventHandlerNode* node = new EventHandlerNode;
    node->controllerID = controllerID;
    node->handler = handler;
    node->next = d->focus;
    d->focus = node;
}

EventHandler* Application::currentFocus(int controllerID) const
{
    if(!d->focus) return 0;
    EventHandlerNode* node = d->focus;
    while(node) {
        if(node->controllerID == controllerID || node->controllerID == -1)
            return node->handler;
        node = node->next;
    }
    return 0;
}

EventHandler* Application::popFocus(int controllerID)
{
    if(!d->focus) return 0;
    EventHandlerNode* node = d->focus;
    EventHandlerNode* lastNode = 0;
    while(node) {
        if(node->controllerID == controllerID) {
            if(lastNode) {
                lastNode->next = node->next;
            } else {
                d->focus = node->next;
            }
            EventHandler* h = node->handler;
            delete node;
            return h;
        }
        lastNode = node;
        node = node->next;
    }
    return 0;
}

void Application::removeFromFocusStack(EventHandler* handler, int controllerID)
{
    EventHandlerNode* node = d->focus;
    EventHandlerNode* lastNode = 0;
    while(node) {
        if(node->handler == handler && (controllerID == -1 || controllerID == node->controllerID)) {
            if(lastNode) {
                lastNode->next = node->next;
            } else {
                d->focus = node->next;
            }
            EventHandlerNode* delNode = node;
            node = node->next;
            delete delNode;
        } else {
            lastNode = node;
            node = node->next;
        }
    }
}

void Application::installEventFilter(EventHandler* handler)
{
    EventHandlerNode* node = new EventHandlerNode;
    node->controllerID = -1;
    node->handler = handler;
    node->next = d->eventFilters;
    d->eventFilters = node;
}

void Application::removeEventFilter(EventHandler* handler)
{
    EventHandlerNode* node = d->eventFilters;
    EventHandlerNode* lastNode = 0;
    while(node) {
        if(node->handler == handler) {
            if(lastNode) {
                lastNode->next = node->next;
            } else {
                d->eventFilters = node->next;
            }
            delete node;
            return;
        }
        lastNode = node;
        node = node->next;
    }
}

void Application::scheduleTimer(int frames, EventHandler* handler, void* data)
{
    TimerNode* timer = new TimerNode;
    timer->handler = handler;
    timer->framesRemaining = frames;
    timer->data = data;

    // We put the new timer in a secondary queue to avoid runaway callbacks if
    // a timer is scheduled during another timer's processing.
    timer->next = d->addTimers;
    d->addTimers = timer;
}

bool Application::abortGxOnReset() const
{
    return d->abortGxOnReset;
}

void Application::setAbortGxOnReset(bool on)
{
    d->abortGxOnReset = on;
}

void Application::resetButtonPressed()
{
    reboot();
}

void Application::powerButtonPressed(int controllerID)
{
    shutdown();
}

}