/*---------------------------------------------------------------------------*
  Project:    WPAD demo program
  File:       dummy_checker.c

  Copyright (C) 2007 Nintendo.  All rights reserved.

  These coded instructions, statements, and computer programs contain
  proprietary information of Nintendo of America Inc. and/or Nintendo
  Company Ltd., and are protected by Federal copyright law.  They may
  not be disclosed to third parties or copied or duplicated in any form,
  in whole or in part, without the prior written consent of Nintendo.

  $Log: dummy_checker.c,v $
  Revision 1.5.2.1  2007/12/11 01:14:55  tojo
  Modified to handle the error code of WPADStatus.

  Revision 1.5  2007/07/11 12:47:49  tojo
  (none)

  Revision 1.4  2007/07/10 12:14:46  tojo
  (none)

  Revision 1.3  2007/05/02 07:52:23  tojo
  (none)

  Revision 1.2  2007/04/23 08:16:09  tojo
  (none)

  Revision 1.1  2007/04/18 01:30:48  tojo
  Initial check-in.


 *---------------------------------------------------------------------------*/

#include <stdlib.h>
#include <string.h>
#include <stddef.h>
#include <stdarg.h>
#include <stdio.h>
#include <ctype.h>

#include <revolution.h>
#include <revolution/wpad.h>

#define DEMO_USE_MEMLIB=1 // This turns on the DEMO library's MEM heaps.
#include <demo.h>

/*---------------------------------------------------------------------------*
 * Local Definitions
 *---------------------------------------------------------------------------*/

#define SCREEN_WIDTH  320
#define SCREEN_HEIGHT 240
#define FONT_HEIGHT     8

/*---------------------------------------------------------------------------*
 * Local Data
 *---------------------------------------------------------------------------*/


#define SMPBUF_SIZE 100

static WPADCLStatus cl_ringbuffer[SMPBUF_SIZE];
static WPADFSStatus fs_ringbuffer[SMPBUF_SIZE];
static WPADStatus   co_ringbuffer[SMPBUF_SIZE];


/*---------------------------------------------------------------------------*
 * Function prototypes
 *---------------------------------------------------------------------------*/


// MEM2 memory allocation routines. The application must provide these to 
// WPAD, so it can setup the data transfer buffer. This buffer must reside
// in MEM2. 
static void *myAlloc                 ( u32 size  );
static u8    myFree                  ( void *ptr );

// callbacks
void         connectCallback         ( s32 chan, s32 reason );
void         extensionCallback       ( s32 chan, s32 result );
void         samplingCallback        ( s32 chan );

// internal functions
static void  initialize              ( void );
static void  renderStatus            ( void );
static void  renderAimings           ( void );
static void  printIntro              ( void );
static void  printBuffer             ( char *string, ... );
static u8   *get_dev_name            ( u32 type   );
static u8   *get_status_name         ( s32 status );



/*===========================================================================*
 *                   F U N C T I O N    D E F I N I T I O N S
 *===========================================================================*/
/*---------------------------------------------------------------------------*
 * Name        : printIntro()
 * Description : 
 * Arguments   : None.
 * Returns     : None.
 *---------------------------------------------------------------------------*/
static void printIntro( void )
{
#ifdef _DEBUG
    OSReport("-------------------------------------------------------\n");
    OSReport(" Dummy Extension Demo:                                 \n");
    OSReport("             Button A: Attach the future device.       \n");
    OSReport("             Button X: Attach the unsupported device.  \n");
    OSReport("             Button B: Detach the device.              \n");
    OSReport("-------------------------------------------------------\n");
#else
    OSReport("-------------------------------------------------------\n");
    OSReport("                                                       \n");
    OSReport(" Dummy Extension cannot be used in release build!!!    \n");
    OSReport("                                                       \n");
    OSReport("-------------------------------------------------------\n");
#endif
}

static u8 buffer[WPAD_MEM_GAMEDATA_LEN];

/*---------------------------------------------------------------------------*
 * Name        : main()
 * Description : 
 * Arguments   : None.
 * Returns     : None.
 *---------------------------------------------------------------------------*/
int main( void )
{

    int  i;

    initialize();

    // - We must now register memory allocation/free functions 
    //   for MEM2. 
    // - WPAD requires some memory in MEM2 for data transfers 
    //   between the controller and WPAD driver stack. 
    // - Memory allocation only occurs once, at the initialization. 
    // - Memory usage is on the order of 1KB. 
    // - NOTE: We are using the MEM library allocators defined by 
    //   the DEMO library.
    //    
    WPADRegisterAllocator(myAlloc, myFree);

    // Initialize WPAD!
    WPADInit();

    for (i=0; i<WPAD_MAX_CONTROLLERS; i++)
    {
        // Register a callback for each channel, for 
        // connect and disconnect events.
        WPADSetConnectCallback(i, connectCallback);
    }

    // The WPAD initialization process is asynchronous. 
    // So we should wait until it's completed.
    while(WPADGetStatus() != WPAD_STATE_SETUP)
    {
        ;
    }
    
    printIntro();

    while(1)
    {
#ifdef _DEBUG
        DEMOPadRead();
        
        if (DEMOPadGetButtonDown(0) & PAD_BUTTON_A)
        {
            if (WPADAttachDummyExtension( WPAD_CHAN0, WPAD_DEV_FUTURE ))
            {
                OSReport(" Attach dummy extension [WPAD_DEV_FUTURE]\n");
            }
            else
            {
                OSReport(" Something is already attached\n");
            }
        }
        if (DEMOPadGetButtonDown(0) & PAD_BUTTON_X)
        {
            if (WPADAttachDummyExtension( WPAD_CHAN0, WPAD_DEV_NOT_SUPPORTED ))
            {
                OSReport(" Attach dummy extension [WPAD_DEV_NOT_SUPPORTED]\n");
            }
            else
            {
                OSReport(" Something is already attached\n");
            }
        }
        if (DEMOPadGetButtonDown(0) & PAD_BUTTON_B)
        {
            if (WPADDetachDummyExtension( WPAD_CHAN0 ))
            {
                OSReport(" Detach dummy extension\n");
            }
            else
            {
                OSReport(" Nothing is attached\n");
            }
        }
#endif // _DEBUG

        DEMOBeforeRender();
        renderStatus();
        renderAimings();
        DEMODoneRender();
    }
        
} // end main()

/*---------------------------------------------------------------------------*
 * Name        : connectCallback()
 *
 * Description : This callback is invoked when a controller is connected or 
 *               disconnected. 
 *
 * Arguments   : The channel (chan) for which the event has occurred.
 *               The channel status (reason): 
 *                 WPAD_ERR_NONE means a controller has been connected.
 *                 WPAD_ERR_NO_CONTROLLER means a controller disconnected.
 *
 * Returns     : None.
 *---------------------------------------------------------------------------*/
void connectCallback( s32 chan, s32 reason )
{
    switch(reason)
    {
        case WPAD_ERR_NONE: 
            // Accept a connection to be asigned to CHAN0.
            if (chan != WPAD_CHAN0)
            {
                WPADDisconnect(chan);
                break;
            }

            // If we want to support dynamic attachment/detachment of an 
            // extension, we must register an extension callback.
            WPADSetExtensionCallback(chan, extensionCallback);

            // If we want to use the sampling callback, we need to register 
            // the callback when a device is connected.
            WPADSetSamplingCallback(chan, samplingCallback);

            // Turn on dpd and acc.
            WPADControlDpd(chan, WPAD_DPD_EXP, NULL);        
            WPADSetDataFormat(chan, WPAD_FMT_CORE_ACC_DPD);

            // Note we must reset the auto-sampling buffer so that WPAD 
            // will write into the appropriate buffer
            WPADSetAutoSamplingBuf(chan, (void *)(&co_ringbuffer[0]), SMPBUF_SIZE);

            break;

        case WPAD_ERR_NO_CONTROLLER:
            // We don't have to do anything.
            // Note that all callbacks and the autosampling buffer will be 
            // cleared on disconnect events.
            //
            // Of course, the connect callback will still be valid for this channel.

            break;

        default:
            // unexpected result! 
            break;

    } // end switch

} // end connectCallback()

/*---------------------------------------------------------------------------*
 * Name        : extensionCallback()
 *
 * Description : This callback is invoked when an Extension has been attached.
 *
 * Arguments   : The channel (chan) for which the extension event occurred.
 *               The device type (result): 
 *
 *                 WPAD_DEV_UNKNOWN means that something has been attached, but 
 *                 it's being initialized, and we won't know what it is until 
 *                 initialization is complete. 
 *
 *                 WPAD_DEV_CORE means that an extension has been removed and 
 *                 we're back to just the core device.
 *
 *                 WPAD_DEV_FREESTYLE means that the "NUNCHAK" extension has 
 *                 been attached and initialized.
 *
 *                 WPAD_DEV_CLASSIC means that the "CLASSIC" extension has been 
 *                 attached and initialized.
 *
 * Returns     : None.
 *---------------------------------------------------------------------------*/
void extensionCallback( s32 chan, s32 result )
{
    switch(result)
    {
        case WPAD_DEV_UNKNOWN:  
            // in this case, the extension has been attached by the user
            // but we don't know what type it is yet. Initialization of 
            // the attachment may take a few seconds, during which time 
            // button presses, the DPD, and accelerometers will be affected. 
            // This event is provided so applications can notify the 
            // user of the interruption and/or pause the game. 
            break;

        case WPAD_DEV_CORE:
            // In this case, the user has disconnected an extension. 
            // So, the device type will revert to "core only". 
            WPADControlDpd(chan, WPAD_DPD_EXP, NULL);        
            WPADSetDataFormat(chan, WPAD_FMT_CORE_ACC_DPD);

            // Note we must reset the auto-sampling buffer so that WPAD 
            // will write into the appropriate buffer
            WPADSetAutoSamplingBuf(chan, (void *)(&co_ringbuffer[0]), SMPBUF_SIZE);
            break;

        case WPAD_DEV_FREESTYLE:
            // Now that we know the extension type, we must revise 
            // the data format and control the DPD accordingly. 
            WPADControlDpd(chan, WPAD_DPD_STD, NULL);        
            WPADSetDataFormat(chan, WPAD_FMT_FREESTYLE_ACC_DPD);

            // Note we must reset the auto-sampling buffer so that WPAD 
            // will write into the appropriate buffer
            WPADSetAutoSamplingBuf(chan, (void *)(&fs_ringbuffer[0]), SMPBUF_SIZE);
            break;

        case WPAD_DEV_CLASSIC:

            // Now that we know the extension type, we must revise 
            // the data format and control the DPD accordingly. 
            WPADControlDpd(chan, WPAD_DPD_STD, NULL);        
            WPADSetDataFormat(chan, WPAD_FMT_CLASSIC_ACC_DPD);

            // Note we must reset the auto-sampling buffer so that WPAD 
            // will write into the appropriate buffer
            WPADSetAutoSamplingBuf(chan, (void *)(&cl_ringbuffer[0]), SMPBUF_SIZE);
            break;

        case WPAD_DEV_FUTURE:
            // Now that we don't know the extension type, we should ignore the extension and
            // we must revise the data format and control the DPD accordingly. 
            WPADControlDpd(chan, WPAD_DPD_EXP, NULL);        
            WPADSetDataFormat(chan, WPAD_FMT_CORE_ACC_DPD);

            // Note we must reset the auto-sampling buffer so that WPAD 
            // will write into the appropriate buffer
            WPADSetAutoSamplingBuf(chan, (void *)(&co_ringbuffer[0]), SMPBUF_SIZE);
            break;

        case WPAD_DEV_NOT_SUPPORTED:
            // The user plugged in something weird. 
            // The safe thing to do is revert to Core-only operation. 
            WPADControlDpd(chan, WPAD_DPD_EXP, NULL);        
            WPADSetDataFormat(chan, WPAD_FMT_CORE_ACC_DPD);

            // Note we must reset the auto-sampling buffer so that WPAD 
            // will write into the appropriate buffer
            WPADSetAutoSamplingBuf(chan, (void *)(&co_ringbuffer[0]), SMPBUF_SIZE);
            break;

        default:
            // Here is WPAD_DEV_NOT_FOUND.
            // If the controller is disconnected while the extension is initializing
            // it reaches here. There is nothing to do.
            break;

    } // end

} // end extensionCallback()

/*---------------------------------------------------------------------------*
 * Name        : samplingCallback()
 * Description : Invoked by WPAD every time data is available for WPADRead().
 * Arguments   : Channel for which data is available.
 * Returns     : None.
 *---------------------------------------------------------------------------*/
void samplingCallback( s32 chan )
{
#pragma unused(chan)

    // for this demo, we're not actually doing anything here. 
    // Normally, you can call WPADProbe() and WPADRead() to retrieve 
    // the WPAD Status block for the indicated channel. 
    // 
    // However, since we're using the auto sampling buffer, we won't bother. 
    // 
    // We are using this empty function to demonstrate how to handle 
    // registration of sampling callback during connect/attach events.
    //


} // end sampling Callback



/*---------------------------------------------------------------------------*
 * Name        : myAlloc()
 * Description : Callback needed by WPAD to allocate mem from MEM2 heap
 * Arguments   : size of block, in bytes.
 * Returns     : pointer to allocated block.
 *---------------------------------------------------------------------------*/
static void *myAlloc( u32 size )
{
    void *ptr;
    
    ptr = MEMAllocFromAllocator(&DemoAllocator2, size);
    ASSERTMSG(ptr, "Memory allocation failed\n");

    return(ptr);

} // myAlloc()

/*---------------------------------------------------------------------------*
 * Name        : myFree()
 * Description : Callback needed by WPAD to free mem from MEM2 heap
 * Arguments   : None.
 * Returns     : Always 1.
 *---------------------------------------------------------------------------*/
static u8 myFree( void *ptr )
{
    
    MEMFreeToAllocator(&DemoAllocator2, ptr);

    // we should ensure that memory is free'd properly, but oh well
    return(1);

} // myFree()



/*===========================================================================*
 *                     I N T E R N A L    F U N C T I O N S 
 *===========================================================================*/
/*---------------------------------------------------------------------------*
 * The following functions handle the status display of this demo. 
 * They aren't really relevant to the demonstration of the CONNECT 
 * and EXTENSION callbacks. 
 *---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*
 * Local Data
 *---------------------------------------------------------------------------*/

#define COL_WIDTH  6*FONT_HEIGHT
#define X_START    10
#define Y_START    10

static void renderStatus( void )
{
    WPADCLStatus  status_block;
    WPADStatus   *wpad_ptr;
    WPADCLStatus *cl_ptr;
    WPADFSStatus *fs_ptr;

    s32 status;
    u32 type;

    s16 x;
    s16 y;

    char buf[] = "___________";
    char buf2[] = "__";
    char buf3[] = "_______________";


    // clear status block
    memset((void *)(&status_block), 0, sizeof(WPADCLStatus));

    x = X_START;
    y = Y_START;

    DEMOPrintf(x, y, 0, "WPAD Demo -- Dummy checker"); 
    y+=FONT_HEIGHT;
    y+=FONT_HEIGHT;
    DEMOPrintf(x, y, 0, "Status :"); y+=FONT_HEIGHT;
    DEMOPrintf(x, y, 0, "Type   :"); y+=FONT_HEIGHT;
    DEMOPrintf(x, y, 0, "Error  :"); y+=FONT_HEIGHT;
    DEMOPrintf(x, y, 0, "Buttons:"); y+=FONT_HEIGHT;
    DEMOPrintf(x, y, 0, "DPD0-xy:"); y+=FONT_HEIGHT;
    DEMOPrintf(x, y, 0, "DPD1-xy:"); y+=FONT_HEIGHT;
    DEMOPrintf(x, y, 0, "ACC-XYZ:"); y+=FONT_HEIGHT;
    DEMOPrintf(x, y, 0, "--------"); y+=FONT_HEIGHT;
    DEMOPrintf(x, y, 0, "Buttons:"); y+=FONT_HEIGHT;
    DEMOPrintf(x, y, 0, "StickXY:"); y+=FONT_HEIGHT;
    DEMOPrintf(x, y, 0, "ACC-XYZ:"); y+=FONT_HEIGHT;
    DEMOPrintf(x, y, 0, "--------"); y+=FONT_HEIGHT;
    DEMOPrintf(x, y, 0, "Buttons:"); y+=FONT_HEIGHT;
    DEMOPrintf(x, y, 0, "StickXY:"); y+=FONT_HEIGHT;
    DEMOPrintf(x, y, 0, "StickXY:"); y+=FONT_HEIGHT;
    DEMOPrintf(x, y, 0, "TrigLR :"); y+=FONT_HEIGHT;
        
    x = (s16)(X_START + COL_WIDTH);
    y = (s16)(Y_START + FONT_HEIGHT*2);

    status = WPADProbe(WPAD_CHAN0, &type);

    DEMOPrintf(x, y, 0, "%s", get_status_name(status)); y+= FONT_HEIGHT;
    DEMOPrintf(x, y, 0, "%s", get_dev_name(type));      y+= FONT_HEIGHT;

    if (WPAD_ERR_NO_CONTROLLER != status)
    {
        WPADRead(WPAD_CHAN0, &status_block);
        wpad_ptr = (WPADStatus   *)(&status_block);
        cl_ptr   = (WPADCLStatus *)(&status_block);
        fs_ptr   = (WPADFSStatus *)(&status_block);

        DEMOPrintf(x, y, 0, "%s", get_status_name(wpad_ptr->err)); y+= FONT_HEIGHT;

        if( wpad_ptr->err != WPAD_ERR_INVALID )
        {
            if( wpad_ptr->button & WPAD_BUTTON_LEFT   ) buf[ 0] = '<';
            if( wpad_ptr->button & WPAD_BUTTON_UP     ) buf[ 1] = '^';
            if( wpad_ptr->button & WPAD_BUTTON_DOWN   ) buf[ 2] = 'v';
            if( wpad_ptr->button & WPAD_BUTTON_RIGHT  ) buf[ 3] = '>';
            if( wpad_ptr->button & WPAD_BUTTON_A      ) buf[ 4] = 'A';
            if( wpad_ptr->button & WPAD_BUTTON_B      ) buf[ 5] = 'B';
            if( wpad_ptr->button & WPAD_BUTTON_1      ) buf[ 6] = '1';
            if( wpad_ptr->button & WPAD_BUTTON_2      ) buf[ 7] = '2';
            if( wpad_ptr->button & WPAD_BUTTON_MINUS  ) buf[ 8] = '-';
            if( wpad_ptr->button & WPAD_BUTTON_HOME   ) buf[ 9] = 'H';
            if( wpad_ptr->button & WPAD_BUTTON_PLUS   ) buf[10] = '+';
        }
        DEMOPrintf(x, y, 0, "   %s", buf); y+= FONT_HEIGHT;
        
        if( wpad_ptr->err == WPAD_ERR_NONE || wpad_ptr->err == WPAD_ERR_CORRUPTED )
        {
            DEMOPrintf(x, y, 0, "   %04X %04X", (u16)(wpad_ptr->obj[0].x), (u16)(wpad_ptr->obj[0].y)); y+= FONT_HEIGHT;
            DEMOPrintf(x, y, 0, "   %04X %04X", (u16)(wpad_ptr->obj[1].x), (u16)(wpad_ptr->obj[1].y)); y+= FONT_HEIGHT;
            DEMOPrintf(x, y, 0, "   %04X %04X %04X", (u16)(wpad_ptr->accX), (u16)(wpad_ptr->accY), (u16)(wpad_ptr->accZ)); y+= FONT_HEIGHT;
        }
        else
        {
            DEMOPrintf(x, y, 0, "   ---- ----"); y+= FONT_HEIGHT;
            DEMOPrintf(x, y, 0, "   ---- ----"); y+= FONT_HEIGHT;
            DEMOPrintf(x, y, 0, "   ---- ---- ----"); y+= FONT_HEIGHT;
        }
        y+= FONT_HEIGHT;

        if (WPAD_DEV_FREESTYLE == type)
        {
            if( fs_ptr->err == WPAD_ERR_NONE )
            {
                if( fs_ptr->button & WPAD_BUTTON_C) buf2[ 0] = 'C';
                if( fs_ptr->button & WPAD_BUTTON_Z) buf2[ 1] = 'Z';
            }
            DEMOPrintf(x, y, 0, "   %s", buf2); y+= FONT_HEIGHT;

            if( fs_ptr->err == WPAD_ERR_NONE )
            {
                DEMOPrintf(x, y, 0, "   %04X %04X", (u16)(fs_ptr->fsStickX), (u16)(fs_ptr->fsStickY)); y+= FONT_HEIGHT;
                DEMOPrintf(x, y, 0, "   %04X %04X %04X", (u16)(fs_ptr->fsAccX), (u16)(fs_ptr->fsAccY), (u16)(fs_ptr->fsAccZ)); y+= FONT_HEIGHT;
            }
            else
            {
                DEMOPrintf(x, y, 0, "   ---- ----"); y+= FONT_HEIGHT;
                DEMOPrintf(x, y, 0, "   ---- ---- ----"); y+= FONT_HEIGHT;
            }
        } 
        else
        {
            y+= FONT_HEIGHT * 3;
        }
        y+= FONT_HEIGHT;

        if (WPAD_DEV_CLASSIC == type)
        {
            if( cl_ptr->err == WPAD_ERR_NONE )
            {
                if( cl_ptr->clButton & WPAD_CL_BUTTON_LEFT   ) buf3[ 0] = '<';
                if( cl_ptr->clButton & WPAD_CL_BUTTON_UP     ) buf3[ 1] = '^';
                if( cl_ptr->clButton & WPAD_CL_BUTTON_DOWN   ) buf3[ 2] = 'v';
                if( cl_ptr->clButton & WPAD_CL_BUTTON_RIGHT  ) buf3[ 3] = '>';
                if( cl_ptr->clButton & WPAD_CL_BUTTON_A      ) buf3[ 4] = 'A';
                if( cl_ptr->clButton & WPAD_CL_BUTTON_B      ) buf3[ 5] = 'B';
                if( cl_ptr->clButton & WPAD_CL_BUTTON_X      ) buf3[ 6] = 'X';
                if( cl_ptr->clButton & WPAD_CL_BUTTON_Y      ) buf3[ 7] = 'Y';
                if( cl_ptr->clButton & WPAD_CL_TRIGGER_L     ) buf3[ 8] = 'L';
                if( cl_ptr->clButton & WPAD_CL_TRIGGER_R     ) buf3[ 9] = 'R';
                if( cl_ptr->clButton & WPAD_CL_TRIGGER_ZL    ) buf3[10] = 'z';
                if( cl_ptr->clButton & WPAD_CL_TRIGGER_ZR    ) buf3[11] = 'Z';
                if( cl_ptr->clButton & WPAD_CL_BUTTON_MINUS  ) buf3[12] = '-';
                if( cl_ptr->clButton & WPAD_CL_BUTTON_HOME   ) buf3[13] = 'H';
                if( cl_ptr->clButton & WPAD_CL_BUTTON_PLUS   ) buf3[14] = '+';
            }
            DEMOPrintf(x, y, 0, "   %s", buf3); y+= FONT_HEIGHT;
            
            if( cl_ptr->err == WPAD_ERR_NONE )
            {
                DEMOPrintf(x, y, 0, "   %04X %04X", (u16)(cl_ptr->clLStickX), (u16)(cl_ptr->clLStickY)); y+= FONT_HEIGHT;
                DEMOPrintf(x, y, 0, "   %04X %04X", (u16)(cl_ptr->clRStickX), (u16)(cl_ptr->clRStickY)); y+= FONT_HEIGHT;
                DEMOPrintf(x, y, 0, "   %04X %04X", (u16)(cl_ptr->clTriggerL), (u16)(cl_ptr->clTriggerR)); y+= FONT_HEIGHT;
            }
            else
            {
                DEMOPrintf(x, y, 0, "   ---- ----"); y+= FONT_HEIGHT;
                DEMOPrintf(x, y, 0, "   ---- ----"); y+= FONT_HEIGHT;
                DEMOPrintf(x, y, 0, "   ---- ----"); y+= FONT_HEIGHT;
            }
        } // if classic

    } // if no error

} // end renderStatus()


static u8 *get_dev_name( u32 type )
{

    u8 str_dev_core   [] = "   Core   ";
    u8 str_dev_extn   [] = "   Extn   ";
    u8 str_dev_cl     [] = "  Classic ";
    u8 str_dev_future [] = "   Future ";
    u8 str_dev_notsup [] = "  Not sup ";
    u8 str_dev_unknown[] = "  Unknwon ";

    u8 *ptr;

    switch(type)
    {
        case WPAD_DEV_CORE:             ptr = &str_dev_core[0];     break;
        case WPAD_DEV_FREESTYLE:        ptr = &str_dev_extn[0];     break;
        case WPAD_DEV_CLASSIC:          ptr = &str_dev_cl[0];       break;
        case WPAD_DEV_FUTURE:           ptr = &str_dev_future[0];   break;
        case WPAD_DEV_NOT_SUPPORTED:    ptr = &str_dev_notsup[0];   break;
        case WPAD_DEV_UNKNOWN:
        default:                        ptr = &str_dev_unknown[0];  break;

    } // end switch

    return(ptr);

} // end


static u8 *get_status_name( s32 status )
{

    u8 str_status_ok  [] = "    OK    ";
    u8 str_status_none[] = "   NONE   ";
    u8 str_status_busy[] = "   BUSY   ";
    u8 str_status_xfer[] = " Transfer ";
    u8 str_status_inv [] = "  INVALID ";
    u8 str_status_crpt[] = " Corrupted";
    u8 str_status_unk [] = "  UNKNOWN ";

    u8 *ptr;

    switch(status)
    {
        case WPAD_ERR_NONE:             ptr = &str_status_ok[0];    break;
        case WPAD_ERR_NO_CONTROLLER:    ptr = &str_status_none[0];  break;
        case WPAD_ERR_BUSY:             ptr = &str_status_busy[0];  break;
        case WPAD_ERR_TRANSFER:         ptr = &str_status_xfer[0];  break;
        case WPAD_ERR_INVALID:          ptr = &str_status_inv[0];   break;
        case WPAD_ERR_CORRUPTED:        ptr = &str_status_crpt[0];  break;
        default:                        ptr = &str_status_unk[0];   break;

    } // end switch

    return(ptr);

} // end


static void initialize( void )
{
    const GXColor DARKBLUE = { 0, 0, 40, 255 };

    OSInit();

    DEMOInit( &GXNtsc480IntDf );

    GXSetCopyClear( DARKBLUE, GX_MAX_Z24 );
    GXCopyDisp( DEMOGetCurrentBuffer(), GX_TRUE );
    DEMOInitCaption( DM_FT_XLU, SCREEN_WIDTH, SCREEN_HEIGHT );
    GXSetZMode( GX_ENABLE, GX_ALWAYS, GX_ENABLE );                       // Set pixel processing mode
    GXSetBlendMode( GX_BM_BLEND, GX_BL_ONE, GX_BL_ONE, GX_LO_CLEAR );    // Translucent mode

    DEMOPadInit();

} // end


/*---------------------------------------------------------------------------*
 * Name        : renderAimings()
 * Description : 
 * Arguments   : None.
 * Returns     : None.
 *---------------------------------------------------------------------------*/
static void renderAimings( void )
{
    u32 latest;
    u32 index;
    
    int i;
    u32 fmt;

    WPADStatus   *co_ptr;
    WPADFSStatus *fs_ptr;
    WPADCLStatus *cl_ptr;

    fmt = WPADGetDataFormat(WPAD_CHAN0);

    switch (fmt)
    {
        case WPAD_FMT_CORE:
        case WPAD_FMT_CORE_ACC:
        case WPAD_FMT_CORE_ACC_DPD:

            co_ptr = (WPADStatus *)(&co_ringbuffer[0]);
            
            latest = WPADGetLatestIndexInBuf(WPAD_CHAN0);
            index  = ((latest - 1) + SMPBUF_SIZE) % SMPBUF_SIZE;

            for (i=0; i<SMPBUF_SIZE-1; i++)
            {
                if (WPAD_ERR_NONE == co_ptr[index].err)
                {
                    s16 x=(s16)(SCREEN_WIDTH -(co_ptr[index].obj[0].x+co_ptr[index].obj[1].x)/2*SCREEN_WIDTH /WPAD_DPD_IMG_RESO_WX);
                    s16 y=(s16)(SCREEN_HEIGHT-(co_ptr[index].obj[0].y+co_ptr[index].obj[1].y)/2*SCREEN_HEIGHT/WPAD_DPD_IMG_RESO_WY);  
                    DEMOPrintf(x, y, 0, "."); 		
                }
                index  = ((index - 1) + SMPBUF_SIZE) % SMPBUF_SIZE;
            }
            break;

        case WPAD_FMT_FREESTYLE:
        case WPAD_FMT_FREESTYLE_ACC:
        case WPAD_FMT_FREESTYLE_ACC_DPD:

            fs_ptr = (WPADFSStatus *)(&fs_ringbuffer[0]);
            
            latest = WPADGetLatestIndexInBuf(WPAD_CHAN0);
            index  = ((latest - 1) + SMPBUF_SIZE) % SMPBUF_SIZE;

            for (i=0; i<SMPBUF_SIZE-1; i++)
            {
                if (WPAD_ERR_NONE == fs_ptr[index].err || WPAD_ERR_CORRUPTED == fs_ptr[index].err)
                {
                    s16 x=(s16)(SCREEN_WIDTH -(fs_ptr[index].obj[0].x+fs_ptr[index].obj[1].x)/2*SCREEN_WIDTH /WPAD_DPD_IMG_RESO_WX);
                    s16 y=(s16)(SCREEN_HEIGHT-(fs_ptr[index].obj[0].y+fs_ptr[index].obj[1].y)/2*SCREEN_HEIGHT/WPAD_DPD_IMG_RESO_WY);  
                    DEMOPrintf(x, y, 0, "."); 		
                }
                index  = ((index - 1) + SMPBUF_SIZE) % SMPBUF_SIZE;
            }
            break;

        case WPAD_FMT_CLASSIC:
        case WPAD_FMT_CLASSIC_ACC:
        case WPAD_FMT_CLASSIC_ACC_DPD:
        
            cl_ptr = (WPADCLStatus*)(&cl_ringbuffer[0]);
            
            latest = WPADGetLatestIndexInBuf(WPAD_CHAN0);
            index  = ((latest - 1) + SMPBUF_SIZE) % SMPBUF_SIZE;
            
            for(i=0; i<SMPBUF_SIZE-1; i++)
            {
                if (WPAD_ERR_NONE == cl_ptr[index].err || WPAD_ERR_CORRUPTED == cl_ptr[index].err)
                {
                    s16 x=(s16)(SCREEN_WIDTH -(cl_ptr[index].obj[0].x+cl_ptr[index].obj[1].x)/2*SCREEN_WIDTH /WPAD_DPD_IMG_RESO_WX);
                    s16 y=(s16)(SCREEN_HEIGHT-(cl_ptr[index].obj[0].y+cl_ptr[index].obj[1].y)/2*SCREEN_HEIGHT/WPAD_DPD_IMG_RESO_WY);  
                    DEMOPrintf(x, y, 0, "."); 		
                }
                index  = ((index - 1) + SMPBUF_SIZE) % SMPBUF_SIZE;
            }
            break;

    } // end switch

} // end