/*--------------------------------------------------------------------------*
  Project:    WPAD demo program
  File:       wpadsample.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: wpadsample.c,v $
  Revision 1.3.2.3  2007/12/11 01:49:03  tojo
  (none)

  Revision 1.3.2.2  2007/12/11 01:34:09  tojo
  Fixed syntax error.

  Revision 1.3.2.1  2007/12/11 01:31:47  tojo
  Modified to handle the error code of WPADStatus.

  Revision 1.3  2007/07/19 08:59:54  tojo
  Cleared string buffer before getting the game title.

  Revision 1.2  2007/07/11 11:42:55  tojo
  Added the distance calculation and introduction on serial output.

  Revision 1.1  2007/07/11 09:06:40  tojo
  Initial check-in.


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

#include <revolution.h>
#include <revolution/wpad.h>
#include <revolution/enc.h>
#include <string.h>
#include <math.h>

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

/*---------------------------------------------------------------------------*
 * Local Definitions
 *---------------------------------------------------------------------------*/
#define SCRN_WIDTH      640
#define SCRN_HEIGHT     480
#define FONT_HEIGHT     10
#define CLMN_WIDTH      20 * FONT_HEIGHT
#define CHAN_INDENT     140
#define ITEM_WIDTH      80

#define X_START         10
#define Y_START         16

enum {
    MNU_RUMBLE = 0,
    MNU_INFO,
    MNU_DISCN,
    MNU_ACC,
    MNU_DPD,
    MNU_DPD_FULL,
    MNU_EXTGMK,
    MNU_RDMEM,
    MNU_WRMEM,
    MNU_DMEXT
};

#define SMPBUF_SIZE     120

#define SEPARATION      0.20f   // Meter unit.  
                                // You must modify this value according to your environment.

/*---------------------------------------------------------------------------*
 * Local Data
 *---------------------------------------------------------------------------*/
static WPADCLStatus cl_ringbuffer[WPAD_MAX_CONTROLLERS][SMPBUF_SIZE+4];
static WPADFSStatus fs_ringbuffer[WPAD_MAX_CONTROLLERS][SMPBUF_SIZE+4];
static WPADStatus   co_ringbuffer[WPAD_MAX_CONTROLLERS][SMPBUF_SIZE+4];
static WPADStatusEx ex_ringbuffer[WPAD_MAX_CONTROLLERS][SMPBUF_SIZE+4];
static WPADInfo     infos[WPAD_MAX_CONTROLLERS];

static int rb      [WPAD_MAX_CONTROLLERS];
static int rbCount [WPAD_MAX_CONTROLLERS];
static int acc     [WPAD_MAX_CONTROLLERS];
static int dpd     [WPAD_MAX_CONTROLLERS];
static int dpd_full[WPAD_MAX_CONTROLLERS];
static int extGmk  [WPAD_MAX_CONTROLLERS];
static int dummyExt[WPAD_MAX_CONTROLLERS];

static u8  readBuf [WPAD_MAX_CONTROLLERS][4096];
static u8  writeBuf[WPAD_MAX_CONTROLLERS][4096];

static int col;
static int row;

static u8  smp_pair;
static u8  std_pair;
static u8  reset;
static u8  power;

static u8 rbPattern[64] = {1,1,1,1,1,1,1,1,
                           1,1,1,1,1,1,1,1,
                           1,1,1,1,1,1,1,1,
                           0,0,0,0,0,0,0,0,
                           0,0,0,0,0,0,0,0,
                           0,0,0,0,0,0,0,0,
                           0,0,0,0,0,0,0,0,
                           0,0,0,0,0,0,0,0};


u8 fmt_core1[] = "CORE             ";
u8 fmt_core2[] = "CORE_ACC         ";
u8 fmt_core3[] = "CORE_ACC_DPD     ";
u8 fmt_nun1[]  = "FREESTYLE        ";
u8 fmt_nun2[]  = "FREESTYLE_ACC    ";
u8 fmt_nun3[]  = "FREESTYLE_ACC_DPD";
u8 fmt_clas1[] = "CLASSIC          ";
u8 fmt_clas2[] = "CLASSIC_ACC      ";
u8 fmt_clas3[] = "CLASSIC_ACC_DPD  ";
u8 fmt_full[]  = "CORE_ACC_DPD_FULL";

u8 str_dev_core   [] = "CORE ";
u8 str_dev_extn   [] = "NCHKU";
u8 str_dev_cl     [] = "CLSIC";
u8 str_dev_future [] = "FTURE";
u8 str_dev_notsup [] = "UNSPT";
u8 str_dev_unknown[] = "UNKWN";
u8 str_dev_notfound[]= "NTFND";

u8 str_status_ok  [] = "OK   ";
u8 str_status_none[] = "NONE ";
u8 str_status_busy[] = "BUSY ";
u8 str_status_xfer[] = "TRANS";
u8 str_status_inv [] = "INVLD";
u8 str_status_crpt[] = "CRPTD";
u8 str_status_unk [] = "UNKWN";

u8 dpd_fmt_off  [] = "OFF ";
u8 dpd_fmt_std  [] = "STD ";
u8 dpd_fmt_exp  [] = "EXP ";
u8 dpd_fmt_full [] = "FULL";

u8 sync_std[] = "STD";
u8 sync_smp[] = "SMP";
u8 sync_unk[] = "NONE";


/*---------------------------------------------------------------------------*
 * Function prototypes
 *---------------------------------------------------------------------------*/
static void *myAlloc                ( u32  size );
static u8    myFree                 ( void *ptr );

static void  sysInit                ( void );
static void  sysShutdown            ( void );
static void  appInit                ( void );
static void  wpadInit               ( void );

static void  resetCallback          ( void );
static void  powerCallback          ( void );

static void  samplingCallback       ( s32 chan );
static void  connectCallback        ( s32 chan, s32 reason );
static void  extensionCallback      ( s32 chan, s32 result );
static void  syncButtonCallback     ( s32 result, s32 num  );
static void  syncSimpleCallback     ( s32 result, s32 num  );

static void  update                 ( void );
static void  operate                ( void );
static void  moveCursor             ( void );
static void  resetController        ( s32 chan, u32 type );
static void  renderScreen           ( void );
static void  renderAimings          ( void );
static void  renderStatus           ( void );
static void  renderDots             ( void *ptr );

static u8   *getDevName             ( u32 type );
static u8   *getErrName             ( s8  err  );
static u8   *getDpdFmt              ( u8  fmt  );
static u8   *getSyncName            ( u8  sync );
static u8   *getFormat              ( u32 fmt  );
static f32   getDistance            ( const WPADStatus *stat );

static void  printIntro             ( void );

/*===========================================================================*
 *                   F U N C T I O N    D E F I N I T I O N S
 *===========================================================================*/
/*---------------------------------------------------------------------------*
    Name:           main

    Description:    None.
                    
    Arguments:      None.

    Returns:        None.
 *---------------------------------------------------------------------------*/
void main( void )
{
    sysInit();
    appInit();
    wpadInit();
 
    printIntro();
   
    // main loop
    while( reset && power )
    {        
        DEMOBeforeRender();
        renderScreen();
        renderStatus();
        renderAimings();
        DEMODoneRender();

        DEMOPadRead();
        update();
        operate();
        moveCursor();
    }
    
    sysShutdown();
}

/*---------------------------------------------------------------------------*
    Name:           sysInit

    Description:    Initializes system.
                    
    Arguments:      None.

    Returns:        None.
 *---------------------------------------------------------------------------*/
static void sysInit( void )
{
    const GXColor DARKBLUE  = { 0, 0, 80, 255 };
    
    // Initialize OS
    OSInit();
    // Initialize reset and power process.
    reset = power = 1;
    OSSetResetCallback(resetCallback);
    OSSetPowerCallback(powerCallback);
    // Initialize DEMO
    DEMOInit( &GXNtsc480IntDf );
    DEMOPadInit();
    // Initialize screen setting
    GXSetCopyClear( DARKBLUE, GX_MAX_Z24 );
    GXCopyDisp( DEMOGetCurrentBuffer(), GX_TRUE );
    DEMOInitCaption( DM_FT_XLU, SCRN_WIDTH, SCRN_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

}

/*---------------------------------------------------------------------------*
    Name:           sysShutdown

    Description:    Shutdown system.
                    
    Arguments:      None.

    Returns:        None.
 *---------------------------------------------------------------------------*/
static void sysShutdown( void )
{
    int i;
    
    // Make screen black.
    VISetBlack(TRUE);
    VIFlush();
    for(i=0; i<8; i++)
    {
        VIWaitForRetrace();
    }

    // reset or shutdown.
    if (!reset)
    {
        OSRestart(0);
    }
    if (!power)
    {
        OSShutdownSystem();
    }
}

/*---------------------------------------------------------------------------*
    Name:           resetCallback

    Description:    Function to be called when reset button is pressed.
                    
    Arguments:      None.

    Returns:        None.
 *---------------------------------------------------------------------------*/
static void resetCallback( void )
{
    reset = 0;
}

/*---------------------------------------------------------------------------*
    Name:           powerCallback

    Description:    Function to be called when power button on wii console 
                    is pressed or power button on wii remote registered by 
                    standard pairing.
                    
    Arguments:      None.

    Returns:        None.
 *---------------------------------------------------------------------------*/
static void powerCallback( void )
{
    power = 0;
}

/*---------------------------------------------------------------------------*
    Name:           appInit

    Description:    Initializes application.
                    
    Arguments:      None.

    Returns:        None.
 *---------------------------------------------------------------------------*/
static void appInit( void )
{
    int i;
    
    col = 0;
    row = 0;

    for(i=0; i<WPAD_MAX_CONTROLLERS; i++)
    {
        rb[i]       = 0;
        rbCount[i]  = 0;
        acc[i]      = 0;
        dpd[i]      = 0;
        dpd_full[i] = 0;
        extGmk[i]   = 0;
        dummyExt[i] = 0;
    }
}

/*---------------------------------------------------------------------------*
    Name:           wpadInit

    Description:    Initializes WPAD library.
                    
    Arguments:      None.

    Returns:        None.
 *---------------------------------------------------------------------------*/
static void wpadInit( void )
{
    int   i;
    s32   len;
    u16   utf16_title[16];
    const char game_title[] = "wpad_sample";

    // - 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();
    // Register callback to be called when a controller is connected or disconnected.
    for (i=0; i<WPAD_MAX_CONTROLLERS; i++)
    {
        WPADSetConnectCallback(i, connectCallback);
    }

    // Register callback to be called when sync event occurs.
    smp_pair = 0;
    std_pair = 0;
    WPADSetSyncDeviceCallback(syncButtonCallback);
    WPADSetSimpleSyncCallback(syncSimpleCallback);

    // Set the game title that is written when an application writes
    // the game data into wii remote memory.
    memset(utf16_title, 0, sizeof(utf16_title));
    len = (s32)strlen(game_title);
    ENCConvertStringUtf8ToUtf16(utf16_title, &len, (const u8*)game_title, &len);
    WPADSetGameTitleUtf16(utf16_title);

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

/*---------------------------------------------------------------------------*
    Name:           myAlloc

    Description:    Allocate memory from MEM2.
                    
    Arguments:      size        Memory size

    Returns:        Point to the head address of the allocated memory.
 *---------------------------------------------------------------------------*/
static void *myAlloc( u32 size )
{
    void *ptr = MEMAllocFromAllocator(&DemoAllocator2, size);
    ASSERTMSG(ptr, "Memory allocation failed\n");

    return(ptr);

}

/*---------------------------------------------------------------------------*
    Name:           myFree

    Description:    Free memory.
                    
    Arguments:      ptr         Point to head of the memory address to be freed.

    Returns:        Result, but unused now.
 *---------------------------------------------------------------------------*/
static u8 myFree( void *ptr )
{
    MEMFreeToAllocator(&DemoAllocator2, ptr);

    return(1);

}

/*---------------------------------------------------------------------------*
    Name:           resetController

    Description:    Reset the controller settings such as data foramt,
                    dpd format, and sampling buffer.
                    
    Arguments:      chan        specified channel.
                    type        device type.
    
    Returns:        None.
 *---------------------------------------------------------------------------*/
static void resetController( s32 chan, u32 type )
{
    void *buffer;
    u32   datfmt;
    u8    dpdfmt;

    if (type == WPAD_DEV_UNKNOWN || type == WPAD_DEV_NOT_FOUND)
    {
        return;
    }

    if (dpd_full[chan])
    {
        if (acc[chan])
        {
            datfmt = WPAD_FMT_CORE_ACC_DPD_FULL;
        }
        else
        {
            datfmt = WPAD_FMT_CORE;
        }
        buffer = (void *)&ex_ringbuffer[chan][0];
        dpdfmt = WPAD_DPD_FULL;
    }
    else
    {
        switch(type)
        {
            case WPAD_DEV_CORE:
            case WPAD_DEV_FUTURE:
            case WPAD_DEV_NOT_SUPPORTED:
                buffer = (void *)&co_ringbuffer[chan][0];
                datfmt = (u32)((!acc[chan]) ? WPAD_FMT_CORE :
                               (!dpd[chan]) ? WPAD_FMT_CORE_ACC :
                                              WPAD_FMT_CORE_ACC_DPD);
                dpdfmt = (u8)((dpd[chan])   ? WPAD_DPD_EXP : WPAD_DPD_OFF);
                break;
            case WPAD_DEV_FREESTYLE:
                buffer = (void *)&fs_ringbuffer[chan][0];
                datfmt = (u32)((!acc[chan]) ? WPAD_FMT_FREESTYLE :
                               (!dpd[chan]) ? WPAD_FMT_FREESTYLE_ACC :
                                              WPAD_FMT_FREESTYLE_ACC_DPD);
                dpdfmt = (u8)((dpd[chan])   ? WPAD_DPD_STD : WPAD_DPD_OFF);
                break;

            case WPAD_DEV_CLASSIC:
                buffer = (void *)&cl_ringbuffer[chan][0];
                datfmt = (u32)((!acc[chan]) ? WPAD_FMT_CLASSIC :
                               (!dpd[chan]) ? WPAD_FMT_CLASSIC_ACC :
                                              WPAD_FMT_CLASSIC_ACC_DPD);
                dpdfmt = (u8)((dpd[chan])   ? WPAD_DPD_STD : WPAD_DPD_OFF);
                break;
        }
    }

    WPADControlDpd(chan, dpdfmt, NULL);
    WPADSetDataFormat(chan, datfmt);
    WPADSetAutoSamplingBuf(chan, buffer, SMPBUF_SIZE);
}

/*---------------------------------------------------------------------------*
    Name:           connectCallback

    Description:    Function to be called when a controller is connected or 
                    disconnected.
                    
    Arguments:      chan        Specified channel to be connected/disconnected.
                    reason      Reason of calling this.
                                  if WPAD_ERR_NONE, connected.
                                  if WPAD_ERR_NO_CONTROLLER, disconnected.

    Returns:        None.
 *---------------------------------------------------------------------------*/
static void connectCallback( s32 chan, s32 reason )
{
    // connected!
    if (reason == WPAD_ERR_NONE)
    {
        // Controller works as wii remote only when it is connected.
        // Set the data format, turn on/off DPD and register auto sampling buffer
        // for wii remote.
        resetController( chan, WPAD_DEV_CORE );

        // Register callbacks which are deregistered in disconnection.
        WPADSetExtensionCallback(chan, extensionCallback);
        WPADSetSamplingCallback(chan, samplingCallback);

        if (dummyExt[chan])
        {
            WPADAttachDummyExtension(chan, WPAD_DEV_FUTURE);
        }
    }
}

/*---------------------------------------------------------------------------*
    Name:           extensionCallback

    Description:    Function to be called when an extension is attached or 
                    detached.
                    
    Arguments:      chan        specified channel to be attached/detached.
                    result      new device type.
   
   / ----------------------------------------------------------------------- /
     the meaning of result is below.
      if WPAD_DEV_CORE, an extension is detached.
      if WPAD_DEV_FUTURE, an extension is undefined.
      if WPAD_DEV_NOT_SUPPORTED, an extension is not supported.
      if WPAD_DEV_FREESTYLE, nunchaku extension is attached.
      if WPAD_DEV_CLASSIC, classic controller extension is attached.
      if WPAD_DEV_UNKNOWN, an extension is attached but it is not known yet.

      An extension cannot be recognized shortly when it is attached and
      WPAD_DEV_UNKOWN is returned at first. After a while, the host recognizes
      the currect deveice type and the type is returned.
      
      Note: if WPAD_DEV_FUTRUE and WPAD_DEV_NOT_SUPPORTED is returned, 
            wii remote at least has to work.
   / ----------------------------------------------------------------------- /

    Returns:        None.
 *---------------------------------------------------------------------------*/
static void extensionCallback( s32 chan, s32 result )
{
    resetController( chan, (u32)result );
}

/*---------------------------------------------------------------------------*
    Name:           samplingCallback

    Description:    Function to be called whenever controler data is received.
                    
    Arguments:      chan        specified channel.

    Returns:        None.
 *---------------------------------------------------------------------------*/
static void samplingCallback( s32 chan )
{
#pragma unused(chan)

}

/*---------------------------------------------------------------------------*
    Name:           syncButtonCallback

    Description:    Function to be called when SYNC button on wii console 
                    is pressed.
                    
    Arguments:      result      Sync event
                    num         Number of the registered device in this try.

    Returns:        None.
 *---------------------------------------------------------------------------*/
static void syncButtonCallback( s32 result, s32 num )
{
    BOOL ret;

    if (result == WPAD_SYNC_EVT_START)
    {
        ret = WPADStartSyncDevice();
        if (ret)
        {
            std_pair = 1;
        }
        OSReport("SYNC is pressed.\n");
    }
    else
    {
        std_pair = 0;
        OSReport("sync is done. %d device(s) registered.\n", num);
    }
}

/*---------------------------------------------------------------------------*
    Name:           syncSimpleCallback

    Description:    Function to be called when an application stops 
                    simple pairing.
                    
    Arguments:      result      Sync event
                    num         Number of the registered device in this try.

    Returns:        None.
 *---------------------------------------------------------------------------*/
static void syncSimpleCallback( s32 result, s32 num )
{
    if (result == WPAD_SYNC_EVT_DONE)
    {
        smp_pair = 0;
        OSReport("sync is done. %d device(s) registered.\n", num);
    }
}

/*---------------------------------------------------------------------------*
    Name:           update

    Description:    None.
                    
    Arguments:      None.

    Returns:        None.
 *---------------------------------------------------------------------------*/
static void update( void )
{
    int chan;
    
    for(chan=0; chan<WPAD_MAX_CONTROLLERS; chan++)
    {
        if (rb[chan])
        {
            if (rbPattern[rbCount[chan]])
            {
                WPADStartMotor(chan);
            }
            else
            {
                WPADStopMotor(chan);
            }
            
            if (++rbCount[chan] == sizeof(rbPattern))
            {
                rbCount[chan] = 0;
            }
        }
        else
        {
            WPADStopMotor(chan);
            rbCount[chan] = 0;
        }
    }
}

/*---------------------------------------------------------------------------*
    Name:           moveCursor

    Description:    
                    
    Arguments:      trig        triggered button bit mask.

    Returns:        None.
 *---------------------------------------------------------------------------*/
static void moveCursor( void )
{
    u32 trig = DEMOPadGetButtonDown(0);

    if (trig & PAD_BUTTON_UP)
    {
        col = (col > 0) ? col - 1 : 0;
    }
    if (trig & PAD_BUTTON_DOWN)
    {
        col = (col < MNU_DMEXT) ? col + 1 : col;
    }
    if (trig & PAD_BUTTON_LEFT)
    {
        row = (row > 0) ? row - 1 : 0;;
    }
    if (trig & PAD_BUTTON_RIGHT)
    {
        row = (row < WPAD_MAX_CONTROLLERS) ? row + 1 : row;
    }
}

/*---------------------------------------------------------------------------*
    Name:           operate

    Description:    None.
                    
    Arguments:      None.

    Returns:        None.
 *---------------------------------------------------------------------------*/
static void operate()
{
    int i;
    u32 trig = DEMOPadGetButtonDown(0);
    u32 type;
    u8  chan[4] = {0,0,0,0};
    
    if (trig & PAD_BUTTON_A)
    {
        if (row == 4)
        {
            chan[0] = chan[1] = chan[2] = chan[3] = 1;
        }
        else
        {
            chan[row] = 1;
        }

        for(i=0; i<WPAD_MAX_CONTROLLERS; i++)
        {
            if (!chan[i])
            {
                continue;
            }
            
            WPADProbe(i, &type);

            switch(col)
            {
                case MNU_RUMBLE:
                    rb[i] = (rb[i]) ? 0 : 1;
                    rbCount[i] = 0;
                    break;
                case MNU_INFO:
                    WPADGetInfoAsync(i, &infos[i], NULL);
                    break;
                case MNU_DISCN:
                    WPADDisconnect(i);
                    break;
                case MNU_RDMEM:
                    WPADReadGameData(i, readBuf[i],  3000, 0, NULL);
                    break;
                case MNU_WRMEM:
                    WPADWriteGameData(i, writeBuf[i], 3000, 0, NULL);
                    break;
                case MNU_ACC:
                    acc[i] = (acc[i]) ? 0 : 1;
                    resetController(i, type);
                    break;
                case MNU_DPD:
                    dpd[i] = (dpd[i]) ? 0 : 1;
                    resetController(i, type);
                    break;
                case MNU_DPD_FULL:
                    dpd_full[i] = (dpd_full[i]) ? 0 : 1;
                    resetController(i, type);
                    break;
                case MNU_EXTGMK:    
                    extGmk[i] = (extGmk[i]) ? 0 : 1;
                    WPADControlExtGimmick(i, (u32)((extGmk[i]) ? WPAD_EXTGMK_ON : WPAD_EXTGMK_OFF), NULL);
                    break;
                case MNU_DMEXT:
                    dummyExt[i] = (dummyExt[i]) ? 0 : 1;
                    if (dummyExt[i])
                    {
                        WPADAttachDummyExtension(i, WPAD_DEV_FUTURE);
                    }
                    else
                    {
                        WPADDetachDummyExtension(i);
                    }
                    break;
            }
        }
    }
    if (trig & PAD_TRIGGER_Z)
    {
        if (!smp_pair && !std_pair)
        { 
            smp_pair = 1;
            WPADStartSimpleSync(); 
        }
        else if (smp_pair)
        {
            WPADStopSimpleSync();  
        }
    }
    if (trig & PAD_BUTTON_B)
    {
        WPADSetAcceptConnection((WPADGetAcceptConnection()) ? FALSE : TRUE);
    }
}

/*---------------------------------------------------------------------------*
    Name:           getDevName

    Description:    Get the device name from the device type.
                    
    Arguments:      type        device type.

    Returns:        Point to the device name string.
 *---------------------------------------------------------------------------*/
static u8 *getDevName( u32 type )
{
    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:              ptr = &str_dev_unknown[0];             break;
        default:                            ptr = &str_dev_notfound[0];            break;
    }

    return ptr;

}

/*---------------------------------------------------------------------------*
    Name:           getErrName

    Description:    Get the error name from the error type.
                    
    Arguments:      err         error type.

    Returns:        Point to the error name string.
 *---------------------------------------------------------------------------*/
static u8 *getErrName( s8 err )
{
    u8 *ptr;

    switch(err)
    {
        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;
    }

    return ptr;
    
}

/*---------------------------------------------------------------------------*
    Name:           getDpdFmt

    Description:    Get the dpd format name from the format type.
                    
    Arguments:      fmt         dpd format type.

    Returns:        Point to the dpd format name string.
 *---------------------------------------------------------------------------*/
static u8 *getDpdFmt( u8 fmt )
{
    u8 *ptr;
    
    switch(fmt)
    {
        case WPAD_DPD_OFF:  ptr = &dpd_fmt_off[0];  break;
        case WPAD_DPD_STD:  ptr = &dpd_fmt_std[0];  break;
        case WPAD_DPD_EXP:  ptr = &dpd_fmt_exp[0];  break;
        case WPAD_DPD_FULL: ptr = &dpd_fmt_full[0]; break;
    }
    
    return ptr;
}

/*---------------------------------------------------------------------------*
    Name:           getSyncName

    Description:    Get the connection type name from the sync type.
                    
    Arguments:      sync        sync type.

    Returns:        Point to the connection type name string.
 *---------------------------------------------------------------------------*/
static u8 *getSyncName( u8 sync )
{
    u8 *ptr;
    
    switch(sync)
    {
        case WPAD_SYNC_TYPE_STD: ptr = &sync_std[0];  break;
        case WPAD_SYNC_TYPE_SMP: ptr = &sync_smp[0];  break;
        default:                 ptr = &sync_unk[0];  break;
    }
    
    return ptr;
}

/*---------------------------------------------------------------------------*
    Name:           getFormat

    Description:    Get the data format name from the format type.
                    
    Arguments:      fmt         data format type.

    Returns:        Point to the data format name string.
 *---------------------------------------------------------------------------*/
static u8 *getFormat( u32 fmt )
{
    u8 *ptr;
    
    switch(fmt)
    {
        case WPAD_FMT_CORE:                 ptr = &fmt_core1[0];  break;
        case WPAD_FMT_CORE_ACC:             ptr = &fmt_core2[0];  break;
        case WPAD_FMT_CORE_ACC_DPD:         ptr = &fmt_core3[0];  break;
        case WPAD_FMT_FREESTYLE:            ptr = &fmt_nun1[0];   break;
        case WPAD_FMT_FREESTYLE_ACC:        ptr = &fmt_nun2[0];   break;
        case WPAD_FMT_FREESTYLE_ACC_DPD:    ptr = &fmt_nun3[0];   break;
        case WPAD_FMT_CLASSIC:              ptr = &fmt_clas1[0];  break;
        case WPAD_FMT_CLASSIC_ACC:          ptr = &fmt_clas2[0];  break;
        case WPAD_FMT_CLASSIC_ACC_DPD:      ptr = &fmt_clas3[0];  break;
        case WPAD_FMT_CORE_ACC_DPD_FULL:    ptr = &fmt_full[0];   break;
        default:                            ptr = &fmt_core1[0];  break;
    }
    
    return ptr;
}

/*---------------------------------------------------------------------------*
    Name:           getDistance

    Description:    Get the approx distance between wii remote and sensor bar.
                    
    Arguments:      wpad         controller data.

    Returns:        Distance.
 *---------------------------------------------------------------------------*/
static f32 getDistance( const WPADStatus *wpad )
{
    const f32 PI = 3.141592f;
    const f32 TH = WPAD_DPD_ANGLE / 2 * PI / 180;
    f32 xDiff;
    f32 yDiff;
    f32 dpdDist;

    xDiff   = wpad->obj[0].x - wpad->obj[1].x;
    yDiff   = wpad->obj[0].y - wpad->obj[1].y;
    dpdDist = (f32)sqrt(xDiff * xDiff + yDiff * yDiff);

    if ((wpad->obj[0].size > 0) && (wpad->obj[1].size > 0))
    {
        return (f32)(SEPARATION / 2 / tan(TH) * WPAD_DPD_IMG_RESO_WX / dpdDist);
    }
    else
    {
        return -1.0f;
    }
}

/*---------------------------------------------------------------------------*
    Name:           renderScreen

    Description:    Draw the items of controller status and menu.
                    
    Arguments:      None.

    Returns:        None.
 *---------------------------------------------------------------------------*/
static void renderScreen( void )
{
    s16 x = X_START;
    s16 y = Y_START;
    s16 i;

    DEMOPrintf(x, y, 0, "WPAD Demo -- WPADSAMPLE");

    y+=FONT_HEIGHT*2;

    for(i=0; i<WPAD_MAX_CONTROLLERS; i++)
    {
        DEMOPrintf((s16)(x + CHAN_INDENT * i + ITEM_WIDTH), y, 0, "Ch%d", i);
    }
    
    DEMOPrintf(x, y+=FONT_HEIGHT, 0, "ADDR      ");
    DEMOPrintf(x, y+=FONT_HEIGHT, 0, "TX-STAT   ");
    DEMOPrintf(x, y+=FONT_HEIGHT, 0, "TYPE      ");
    DEMOPrintf(x, y+=FONT_HEIGHT, 0, "FORMAT    ");
    DEMOPrintf(x, y+=FONT_HEIGHT, 0, "RATE      ");
    DEMOPrintf(x, y+=FONT_HEIGHT, 0, "BUTTON    ");
    DEMOPrintf(x, y+=FONT_HEIGHT, 0, "ACC       ");
    DEMOPrintf(x, y+=FONT_HEIGHT, 0, "DPD-0     ");
    DEMOPrintf(x, y+=FONT_HEIGHT, 0, "DPD-1     ");
    DEMOPrintf(x, y+=FONT_HEIGHT, 0, "DPD-2     ");
    DEMOPrintf(x, y+=FONT_HEIGHT, 0, "DPD-3     ");
    DEMOPrintf(x, y+=FONT_HEIGHT, 0, "DPD-ST/FT ");
    DEMOPrintf(x, y+=FONT_HEIGHT, 0, "DISTANCE  ");
    DEMOPrintf(x, y+=FONT_HEIGHT, 0, "DEV       ");
    DEMOPrintf(x, y+=FONT_HEIGHT, 0, "DATA-ERR  ");
    DEMOPrintf(x, y+=FONT_HEIGHT, 0, "BAT/LED   ");
    DEMOPrintf(x, y+=FONT_HEIGHT, 0, "MEM-NM    ");
    DEMOPrintf(x, y+=FONT_HEIGHT, 0, "MEM-TM    ");
    DEMOPrintf(x, y+=FONT_HEIGHT, 0, "EXTENSION ");
    
    y+=FONT_HEIGHT*4;
    
    DEMOPrintf(x, y+=FONT_HEIGHT, 0, "WORKMEM   ");
    DEMOPrintf(x, y+=FONT_HEIGHT, 0, "STD/SMP   ");
    DEMOPrintf(x, y+=FONT_HEIGHT, 0, "BAR-POS   ");
    DEMOPrintf(x, y+=FONT_HEIGHT, 0, "MOTOR     ");
    DEMOPrintf(x, y+=FONT_HEIGHT, 0, "ACCEPT    ");
    DEMOPrintf(x, y+=FONT_HEIGHT, 0, "STD PAIR  ");
    DEMOPrintf(x, y+=FONT_HEIGHT, 0, "SMP PAIR  ");

    x = X_START + 200;
    y = Y_START + FONT_HEIGHT * 25;
    
    DEMOPrintf(x, y+=FONT_HEIGHT, 0, "Rumble            1     2     3     4     A");
    DEMOPrintf(x, y+=FONT_HEIGHT, 0, "Info              1     2     3     4     A");
    DEMOPrintf(x, y+=FONT_HEIGHT, 0, "Disconnect        1     2     3     4     A");
    DEMOPrintf(x, y+=FONT_HEIGHT, 0, "ACC               1     2     3     4     A");
    DEMOPrintf(x, y+=FONT_HEIGHT, 0, "DPD               1     2     3     4     A");
    DEMOPrintf(x, y+=FONT_HEIGHT, 0, "DPD-FULL          1     2     3     4     A");
    DEMOPrintf(x, y+=FONT_HEIGHT, 0, "ExtGimmick        1     2     3     4     A");
    DEMOPrintf(x, y+=FONT_HEIGHT, 0, "Read  mem         1     2     3     4     A");
    DEMOPrintf(x, y+=FONT_HEIGHT, 0, "Write mem         1     2     3     4     A");
    DEMOPrintf(x, y+=FONT_HEIGHT, 0, "Dummy Ext         1     2     3     4     A");

    x = (s16)(X_START + 335 + row * 48);
    y = (s16)(Y_START + FONT_HEIGHT * (26 + col));
    
    DEMOPrintf(x, y, 0, "*");
    
}

/*---------------------------------------------------------------------------*
    Name:           renderStatus

    Description:    Draw each controller status.
                    
    Arguments:      None.

    Returns:        None.
 *---------------------------------------------------------------------------*/
static void renderStatus( void )
{
    WPADStatusEx wpad;
    WPADAcc      acc;
    u8           addr[6];
    u8           game[4][17];
    s32          len = 16;
    OSTime       time;
    OSCalendarTime ct;
    char btn[] = "___________";
    char led[] = "____";
    
    s32  stat;
    u32  type;
    u8   sync;

    s32  i, j;
    s16  x;
    s16  y;

    const u16 *title;


    for (i=0; i<WPAD_MAX_CONTROLLERS; i++)
    {
        stat = WPADProbe(i, &type);
        
        WPADGetAddress(i, addr);

        x = X_START;
        y = Y_START + FONT_HEIGHT * 2;
        
        DEMOPrintf((s16)(x + CHAN_INDENT * i + ITEM_WIDTH), y+=FONT_HEIGHT, 0, "%02x%02x:%02x%02x:%02x%02x", 
            addr[0], addr[1], addr[2], addr[3], addr[4], addr[5]);
        
        DEMOPrintf((s16)(x + CHAN_INDENT * i + ITEM_WIDTH), y+=FONT_HEIGHT, 0, "%s", getErrName((s8)stat));
        DEMOPrintf((s16)(x + CHAN_INDENT * i + ITEM_WIDTH), y+=FONT_HEIGHT, 0, "%s", getDevName(type));
        
        if (stat == WPAD_ERR_NO_CONTROLLER)
        {
            continue;
        }
        
        // Read the latest controller data.
        WPADRead(i, &wpad);
        // Get the connection type.
        WPADGetSyncType(i, &sync);
        // Get the acc calibration for each axis on wii remote.
        WPADGetAccGravityUnit(i, WPAD_DEV_CORE, &acc);
        // Clear string buffer for game title.
        memset(game[i], 0, 17);
        // Get the file info on wii remote memory.
        if (WPADGetGameTitleUtf16(i, &title) == WPAD_ERR_INVALID)
        {
            memcpy(game[i], "----", 5);
        }
        else
        {
            ENCConvertStringUtf16ToUtf8(game[i], &len, title, &len);
        }
        WPADGetGameDataTimeStamp(i, &time);
        OSTicksToCalendarTime(time, &ct);

        // Show controller status
        DEMOPrintf((s16)(x + CHAN_INDENT * i + ITEM_WIDTH + 40), (s16)(y-FONT_HEIGHT*3), 0, "[%s]", getSyncName(sync));
        DEMOPrintf((s16)(x + CHAN_INDENT * i + ITEM_WIDTH),      y+=FONT_HEIGHT,         0, "%s",   getFormat(WPADGetDataFormat(i)));
        DEMOPrintf((s16)(x + CHAN_INDENT * i + ITEM_WIDTH),      y+=FONT_HEIGHT,         0, "%d",   WPADGetRadioSensitivity(i));
        
        // button on wii remote.
        if (wpad.err != WPAD_ERR_INVALID)
        {
            btn[0] = (char)((wpad.button & WPAD_BUTTON_LEFT) ? '<' : '_');
            btn[1] = (char)((wpad.button & WPAD_BUTTON_UP)   ? '^' : '_');
            btn[2] = (char)((wpad.button & WPAD_BUTTON_DOWN) ? 'v' : '_');
            btn[3] = (char)((wpad.button & WPAD_BUTTON_RIGHT)? '>' : '_');
            btn[4] = (char)((wpad.button & WPAD_BUTTON_A)    ? 'A' : '_');
            btn[5] = (char)((wpad.button & WPAD_BUTTON_B)    ? 'B' : '_');
            btn[6] = (char)((wpad.button & WPAD_BUTTON_1)    ? '1' : '_');
            btn[7] = (char)((wpad.button & WPAD_BUTTON_2)    ? '2' : '_');
            btn[8] = (char)((wpad.button & WPAD_BUTTON_PLUS) ? '+' : '_');
            btn[9] = (char)((wpad.button & WPAD_BUTTON_MINUS)? '-' : '_');
            btn[10]= (char)((wpad.button & WPAD_BUTTON_HOME) ? 'H' : '_');
        }
        DEMOPrintf((s16)(x + CHAN_INDENT * i + ITEM_WIDTH),            y+=FONT_HEIGHT, 0, "%s", btn);
        // acc on wii remote.
        if (wpad.err == WPAD_ERR_NONE || wpad.err == WPAD_ERR_CORRUPTED)
        {
            DEMOPrintf((s16)(x + CHAN_INDENT * i + ITEM_WIDTH),      (s16)(y+FONT_HEIGHT), 0, "%1.2lf", (f32)((f32)wpad.accX/(f32)acc.x));
            DEMOPrintf((s16)(x + CHAN_INDENT * i + ITEM_WIDTH + 45), (s16)(y+FONT_HEIGHT), 0, "%1.2lf", (f32)((f32)wpad.accY/(f32)acc.y));
            DEMOPrintf((s16)(x + CHAN_INDENT * i + ITEM_WIDTH + 90),       y+=FONT_HEIGHT, 0, "%1.2lf", (f32)((f32)wpad.accZ/(f32)acc.z));
        }
        else
        {
            DEMOPrintf((s16)(x + CHAN_INDENT * i + ITEM_WIDTH),      (s16)(y+FONT_HEIGHT), 0, "---");
            DEMOPrintf((s16)(x + CHAN_INDENT * i + ITEM_WIDTH + 45), (s16)(y+FONT_HEIGHT), 0, "---");
            DEMOPrintf((s16)(x + CHAN_INDENT * i + ITEM_WIDTH + 90),       y+=FONT_HEIGHT, 0, "---");
        }
        // dpd.
        for(j=0; j<WPAD_DPD_MAX_OBJECTS; j++)
        {
            if (wpad.err == WPAD_ERR_NONE || wpad.err == WPAD_ERR_CORRUPTED)
            {
                DEMOPrintf((s16)(x + CHAN_INDENT * i + ITEM_WIDTH), y+=FONT_HEIGHT, 0, "%04d, %04d, %d", wpad.obj[j].x, wpad.obj[j].y, wpad.obj[j].size);
            }
            else
            {
                DEMOPrintf((s16)(x + CHAN_INDENT * i + ITEM_WIDTH), y+=FONT_HEIGHT, 0, "----, ----, --");
            }
        }
        DEMOPrintf((s16)(x + CHAN_INDENT * i + ITEM_WIDTH), y+=FONT_HEIGHT, 0, "%s / %s", WPADIsDpdEnabled(i) ? "ON " : "OFF", getDpdFmt(WPADGetDpdFormat(i)));
        // distance.
        if (wpad.err == WPAD_ERR_NONE || wpad.err == WPAD_ERR_CORRUPTED)
        {
            DEMOPrintf((s16)(x + CHAN_INDENT * i + ITEM_WIDTH), y+=FONT_HEIGHT, 0, "%.02f", getDistance((const WPADStatus*)&wpad));
        }
        else
        {
            DEMOPrintf((s16)(x + CHAN_INDENT * i + ITEM_WIDTH), y+=FONT_HEIGHT, 0, "----");
        }
        // controller data infomation.
        DEMOPrintf((s16)(x + CHAN_INDENT * i + ITEM_WIDTH), y+=FONT_HEIGHT, 0, "%s", getDevName(wpad.dev));
        DEMOPrintf((s16)(x + CHAN_INDENT * i + ITEM_WIDTH), y+=FONT_HEIGHT, 0, "%s", getErrName(wpad.err));     // This probes whether the data is available or not.
        
        memset(led, '_', sizeof(led)-1);
        for(j=0; j<WPAD_MAX_CONTROLLERS; j++)
        {
            if ((infos[i].led >> j) & 0x1u)
            {
                led[j] = 'o';
            }
        }
        DEMOPrintf((s16)(x + CHAN_INDENT * i + ITEM_WIDTH), y+=FONT_HEIGHT, 0, "%d, %s", infos[i].battery, led);
        
        DEMOPrintf((s16)(x + CHAN_INDENT * i + ITEM_WIDTH), y+=FONT_HEIGHT, 0, "%s", game[i]);
        DEMOPrintf((s16)(x + CHAN_INDENT * i + ITEM_WIDTH), y+=FONT_HEIGHT, 0, "%02d/%02d %02d:%02d", ct.mon+1, ct.mday, ct.hour, ct.min);
        
        switch(type)
        {
            case WPAD_DEV_FREESTYLE:
                {
                    WPADFSStatus *fs = (WPADFSStatus*)&wpad;
                    char cz[] = "__";

                    // Get the acc calibration for each axis on nunchaku.
                    WPADGetAccGravityUnit(i, WPAD_DEV_FREESTYLE, &acc);
                    // button.
                    if (fs->err == WPAD_ERR_NONE)
                    {
                        cz[0] = (char)((fs->button & WPAD_BUTTON_C) ? 'C' : '_');
                        cz[1] = (char)((fs->button & WPAD_BUTTON_Z) ? 'Z' : '_');
                    }
                    DEMOPrintf((s16)(x + CHAN_INDENT * i + ITEM_WIDTH),            y+=FONT_HEIGHT, 0, "%s", cz);
                    // stick
                    if (fs->err == WPAD_ERR_NONE)
                    {
                        DEMOPrintf((s16)(x + CHAN_INDENT * i + ITEM_WIDTH)     , (s16)(y+FONT_HEIGHT), 0, "%04d", fs->fsStickX);
                        DEMOPrintf((s16)(x + CHAN_INDENT * i + ITEM_WIDTH + 45),       y+=FONT_HEIGHT, 0, "%04d", fs->fsStickY);
                    }
                    else
                    {
                        DEMOPrintf((s16)(x + CHAN_INDENT * i + ITEM_WIDTH)     , (s16)(y+FONT_HEIGHT), 0, "----");
                        DEMOPrintf((s16)(x + CHAN_INDENT * i + ITEM_WIDTH + 45),       y+=FONT_HEIGHT, 0, "----");
                    }
                    // acc on nunchaku.
                    if (fs->err == WPAD_ERR_NONE)
                    {
                        DEMOPrintf((s16)(x + CHAN_INDENT * i + ITEM_WIDTH),      (s16)(y+FONT_HEIGHT), 0, "%1.2lf", (f32)((f32)fs->fsAccX/(f32)acc.x));
                        DEMOPrintf((s16)(x + CHAN_INDENT * i + ITEM_WIDTH + 45), (s16)(y+FONT_HEIGHT), 0, "%1.2lf", (f32)((f32)fs->fsAccY/(f32)acc.y));
                        DEMOPrintf((s16)(x + CHAN_INDENT * i + ITEM_WIDTH + 90),       y+=FONT_HEIGHT, 0, "%1.2lf", (f32)((f32)fs->fsAccZ/(f32)acc.z));
                    }
                    else
                    {
                        DEMOPrintf((s16)(x + CHAN_INDENT * i + ITEM_WIDTH),      (s16)(y+FONT_HEIGHT), 0, "----");
                        DEMOPrintf((s16)(x + CHAN_INDENT * i + ITEM_WIDTH + 45), (s16)(y+FONT_HEIGHT), 0, "----");
                        DEMOPrintf((s16)(x + CHAN_INDENT * i + ITEM_WIDTH + 90),       y+=FONT_HEIGHT, 0, "----");
                    }
                }
                y+=FONT_HEIGHT;
                break;
                
            case WPAD_DEV_CLASSIC:
                {
                    WPADCLStatus *cl = (WPADCLStatus*)&wpad;
                    char clb[] = "_______________";

                    // button.
                    if (cl->err == WPAD_ERR_NONE)
                    {
                        clb[0] = (char)((cl->clButton & WPAD_CL_BUTTON_LEFT) ? '<' : '_');
                        clb[1] = (char)((cl->clButton & WPAD_CL_BUTTON_UP)   ? '^' : '_');
                        clb[2] = (char)((cl->clButton & WPAD_CL_BUTTON_DOWN) ? 'v' : '_');
                        clb[3] = (char)((cl->clButton & WPAD_CL_BUTTON_RIGHT)? '>' : '_');
                        clb[4] = (char)((cl->clButton & WPAD_CL_BUTTON_A)    ? 'A' : '_');
                        clb[5] = (char)((cl->clButton & WPAD_CL_BUTTON_B)    ? 'B' : '_');
                        clb[6] = (char)((cl->clButton & WPAD_CL_BUTTON_X)    ? 'X' : '_');
                        clb[7] = (char)((cl->clButton & WPAD_CL_BUTTON_Y)    ? 'Y' : '_');
                        clb[8] = (char)((cl->clButton & WPAD_CL_TRIGGER_L)   ? 'L' : '_');
                        clb[9] = (char)((cl->clButton & WPAD_CL_TRIGGER_R)   ? 'R' : '_');
                        clb[10]= (char)((cl->clButton & WPAD_CL_TRIGGER_ZL)  ? 'z' : '_');
                        clb[11]= (char)((cl->clButton & WPAD_CL_TRIGGER_ZR)  ? 'Z' : '_');
                        clb[12]= (char)((cl->clButton & WPAD_CL_BUTTON_PLUS) ? '+' : '_');
                        clb[13]= (char)((cl->clButton & WPAD_CL_BUTTON_MINUS)? '-' : '_');
                        clb[14]= (char)((cl->clButton & WPAD_CL_BUTTON_HOME) ? 'H' : '_');
                    }
                    DEMOPrintf((s16)(x + CHAN_INDENT * i + ITEM_WIDTH),            y+=FONT_HEIGHT, 0, "%s",   clb);
                    // stick.
                    if (cl->err == WPAD_ERR_NONE)
                    {
                        DEMOPrintf((s16)(x + CHAN_INDENT * i + ITEM_WIDTH)     , (s16)(y+FONT_HEIGHT), 0, "%04d", cl->clLStickX);
                        DEMOPrintf((s16)(x + CHAN_INDENT * i + ITEM_WIDTH + 45),       y+=FONT_HEIGHT, 0, "%04d", cl->clLStickY);
                        DEMOPrintf((s16)(x + CHAN_INDENT * i + ITEM_WIDTH)     , (s16)(y+FONT_HEIGHT), 0, "%04d", cl->clRStickX);
                        DEMOPrintf((s16)(x + CHAN_INDENT * i + ITEM_WIDTH + 45),       y+=FONT_HEIGHT, 0, "%04d", cl->clRStickY);
                    }
                    else
                    {
                        DEMOPrintf((s16)(x + CHAN_INDENT * i + ITEM_WIDTH)     , (s16)(y+FONT_HEIGHT), 0, "----");
                        DEMOPrintf((s16)(x + CHAN_INDENT * i + ITEM_WIDTH + 45),       y+=FONT_HEIGHT, 0, "----");
                        DEMOPrintf((s16)(x + CHAN_INDENT * i + ITEM_WIDTH)     , (s16)(y+FONT_HEIGHT), 0, "----");
                        DEMOPrintf((s16)(x + CHAN_INDENT * i + ITEM_WIDTH + 45),       y+=FONT_HEIGHT, 0, "----");
                    }
                    // trigger.
                    if (cl->err == WPAD_ERR_NONE)
                    {
                        DEMOPrintf((s16)(x + CHAN_INDENT * i + ITEM_WIDTH)     , (s16)(y+FONT_HEIGHT), 0, "%04d", cl->clTriggerL);
                        DEMOPrintf((s16)(x + CHAN_INDENT * i + ITEM_WIDTH + 45),       y+=FONT_HEIGHT, 0, "%04d", cl->clTriggerR);
                    }
                    else
                    {
                        DEMOPrintf((s16)(x + CHAN_INDENT * i + ITEM_WIDTH)     , (s16)(y+FONT_HEIGHT), 0, "----");
                        DEMOPrintf((s16)(x + CHAN_INDENT * i + ITEM_WIDTH + 45),       y+=FONT_HEIGHT, 0, "----");
                    }
                }
                break;
            
            default:
                y+=FONT_HEIGHT*3;
                break;
        }
    }
    
    y = Y_START + FONT_HEIGHT * 25;
    
    DEMOPrintf((s16)(x + ITEM_WIDTH), y+=FONT_HEIGHT, 0, "%d",         WPADGetWorkMemorySize());
    DEMOPrintf((s16)(x + ITEM_WIDTH), y+=FONT_HEIGHT, 0, "%02d, %02d", WPADGetRegisteredDevNum(), WPADGetTemporaryDevNum());
    DEMOPrintf((s16)(x + ITEM_WIDTH), y+=FONT_HEIGHT, 0, "%s",         WPADGetSensorBarPosition() ? "TOP" : "BOTTOM");
    DEMOPrintf((s16)(x + ITEM_WIDTH), y+=FONT_HEIGHT, 0, "%s",         WPADIsMotorEnabled()       ? "ENABLE" : "DISABLE");
    DEMOPrintf((s16)(x + ITEM_WIDTH), y+=FONT_HEIGHT, 0, "%s",         WPADGetAcceptConnection()  ? "OK" : "NG");
    DEMOPrintf((s16)(x + ITEM_WIDTH), y+=FONT_HEIGHT, 0, "%s",         (std_pair)                 ? "STOP" : "START");
    DEMOPrintf((s16)(x + ITEM_WIDTH), y+=FONT_HEIGHT, 0, "%s",         (smp_pair)                 ? "STOP" : "START");
}

/*---------------------------------------------------------------------------*
    Name:           renderDots

    Description:    Draw a dot at the center of the coordinates of two objects.
                    
    Arguments:      ptr         point to the controller data.

    Returns:        None.
 *---------------------------------------------------------------------------*/
static void renderDots( void *ptr )
{
    s16 x;
    s16 y;
    WPADStatus *wpad = (WPADStatus*)ptr;

    // Check the error type of the controller data.
    // The data from dpd is available if the type is WPAD_ERR_NONE or WPAD_ERR_CORRUPTED.
    if (wpad->err == WPAD_ERR_NONE || wpad->err == WPAD_ERR_CORRUPTED)
    {
        x = (s16)(SCRN_WIDTH  - (wpad->obj[0].x + wpad->obj[1].x) / 2 * SCRN_WIDTH  / WPAD_DPD_IMG_RESO_WX);
        y = (s16)(SCRN_HEIGHT - (wpad->obj[0].y + wpad->obj[1].y) / 2 * SCRN_HEIGHT / WPAD_DPD_IMG_RESO_WY);
        DEMOPrintf(x, y, 0, ".");
    }
}

/*---------------------------------------------------------------------------*
    Name:           renderAimings

    Description:    Draw dots using sampled controller data.
                    
    Arguments:      None.

    Returns:        None.
 *---------------------------------------------------------------------------*/
static void renderAimings( void )
{
    u32 latest;
    u32 index;
    
    int i;
    int j;
    
    u8  *ptr;
    u32 size;

    for (j=0; j<WPAD_MAX_CONTROLLERS; j++)
    {
        if (WPADProbe(j, NULL) == WPAD_ERR_NO_CONTROLLER)
        {
            continue;
        }
    
        // Ignore if dpd is disabled.
        if (!WPADIsDpdEnabled(j))
        {
            continue;
        }
        // Get the index of the latest data in sampling buffer.
        latest = WPADGetLatestIndexInBuf(j);
        index  = ((latest - 1) + SMPBUF_SIZE) % SMPBUF_SIZE;
    
        switch (WPADGetDataFormat(j))
        {
            case WPAD_FMT_CORE:
            case WPAD_FMT_CORE_ACC:
            case WPAD_FMT_CORE_ACC_DPD:
                ptr  = (u8 *)(&co_ringbuffer[j][0]);
                size = sizeof(WPADStatus);
                break;
                    
            case WPAD_FMT_CORE_ACC_DPD_FULL:
                ptr  = (u8 *)(&ex_ringbuffer[j][0]);
                size = sizeof(WPADStatusEx);
                break;

            case WPAD_FMT_FREESTYLE:
            case WPAD_FMT_FREESTYLE_ACC:
            case WPAD_FMT_FREESTYLE_ACC_DPD:
                ptr  = (u8 *)(&fs_ringbuffer[j][0]);
                size = sizeof(WPADFSStatus);
                break;

            case WPAD_FMT_CLASSIC:
            case WPAD_FMT_CLASSIC_ACC:
            case WPAD_FMT_CLASSIC_ACC_DPD:
                ptr  = (u8 *)(&cl_ringbuffer[j][0]);
                size = sizeof(WPADCLStatus);
                break;
            
            // not reached here.
            default: 
                ptr  = NULL;
                size = 0;
                break;
        }
        
        for (i=0; i<SMPBUF_SIZE-1; i++)
        {
            renderDots(ptr + size * index);
            index  = ((index - 1) + SMPBUF_SIZE) % SMPBUF_SIZE;
        }
    }
}

/*---------------------------------------------------------------------------*
    Name:           printIntro

    Description:    None.
                    
    Arguments:      None.

    Returns:        None.
 *---------------------------------------------------------------------------*/
static void printIntro( void )
{
    OSReport("========================================\n");
    OSReport(" WPADSAMPLE demo                        \n");
    OSReport("========================================\n");
    OSReport(" Please connect GC controller to Port1. \n");
    OSReport("                                        \n");
    OSReport(" -- Menu --                             \n");
    OSReport(" cursor key: move cursor                \n");
    OSReport("          A: issue command              \n");
    OSReport("          B: accept/reject connection   \n");
    OSReport("          Z: start/stop simple sync     \n");
    OSReport("========================================\n");
}