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

  Copyright (C) 2005-2006 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: handling.c,v $
  Revision 1.6  08/03/2006 13:33:02  tojo
  Removed old APIs.

  Revision 1.5  07/20/2006 06:40:28  tojo
  (none)

  Revision 1.4  06/17/2006 12:56:54  ekwon
  Added explicit demonstration of handling sampling callback and auto-sampling buffer registratiion for various events.

  Revision 1.3  06/16/2006 14:01:25  ekwon
  Added scrolling debug buffer. Completed event handling. NOTE: Classic controller support is pending, as I don't have one of those yet.

  Revision 1.2  06/15/2006 13:47:44  tojo
  Removed DOLPHIN.
  Swept warnings.

  Revision 1.1  06/15/2006 04:25:35  ekwon
  preliminary checkins for event handling demos.



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

#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  640
#define SCREEN_HEIGHT 480
#define FONT_HEIGHT     8

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


#define SMPBUF_SIZE 100

static WPADFSStatus fs_ringbuffer[WPAD_MAX_CONTROLLERS][SMPBUF_SIZE];
static WPADStatus   co_ringbuffer[WPAD_MAX_CONTROLLERS][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);


// sampling callback
void         samplingCallback        (s32 chan);


// callbacks for CONNECT and EXTENSION events
void         connectCallback         (s32 chan, s32 reason);
void         extensionCallback       (s32 chan, s32 result);

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

static void  renderAimings           (void);


/*===========================================================================*
 *                   F U N C T I O N    D E F I N I T I O N S
 *===========================================================================*/


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

    int i;

    s32 wpad_state;

        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();

        // The WPAD initialization process is asynchronous.
        // So we should wait until it's completed.
        do 
        {
            wpad_state = WPADGetStatus();

        } while (WPAD_STATE_SETUP != wpad_state);


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


        while(1)
        {
            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)
{
#pragma unused (chan, reason)

    s32 status;
    u32 type;


        switch(reason)
        {
            case WPAD_ERR_NONE: 


                // If the connection callback is invoked with status WPAD_ERR_NONE,
                // that means a controller has successfully connected. We must now
                // perform some chores...

                printBuffer("Chan %1d is connected.", chan);

                // 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);

                // Once connected, we must check if the device
                // has an extension attached, and initialize
                // it appropriately. Note that we do not receive
                // an extension callback if an extension is already
                // attached.

                status = WPADProbe(chan, &type);
                switch(type)
                {
                    case WPAD_DEV_CORE:
                        // turn on DPD and accelerometers
                        WPADControlDpd(chan, WPAD_DPD_EXP, NULL);        
                        WPADSetDataFormat(chan, WPAD_FMT_CORE_ACC_DPD);

                        // If we want to use the autosampling buffer feature of WPAD,
                        // we must register the appropriate buffer...
                        WPADSetAutoSamplingBuf(chan, (void *)(&co_ringbuffer[chan][0]), SMPBUF_SIZE);

                        break;

                    case WPAD_DEV_FREESTYLE:

                        // turn on DPD and accelerometers
                        // Note that the DPD command is DIFFERENT for FreeStyle
                        WPADControlDpd(chan, WPAD_DPD_STD, NULL);        
                        WPADSetDataFormat(chan, WPAD_FMT_FREESTYLE_ACC_DPD);

                        // If we want to use the autosampling buffer feature of WPAD,
                        // we must register the appropriate buffer...
                        WPADSetAutoSamplingBuf(chan, (void *)(&fs_ringbuffer[chan][0]), SMPBUF_SIZE);

                        break;

                    case WPAD_DEV_CLASSIC:
                        printBuffer("CLASSIC not supported yet.");
                        break;

                    default:
                        printBuffer("Unknown device on chan %1d.", chan);
                        break;
                } // end switch

                break;

            case WPAD_ERR_NO_CONTROLLER:
                printBuffer("Chan %1d has been disconnected.", chan);

                // 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! 
                printBuffer("Unknown event %d on channel %1d.", reason, chan);
                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)
{
#pragma unused (chan, result)

    OSReport("extension[%d]\n",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.
            printBuffer("Initializing extension on chan %1d...", chan);
            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[chan][0]), SMPBUF_SIZE);

            // We must also re-register the sampling callback
            WPADSetSamplingCallback(chan, samplingCallback);

            printBuffer("Extension removed on chan %1d.", chan);
            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[chan][0]), SMPBUF_SIZE);

            // We must also re-register the sampling callback
            WPADSetSamplingCallback(chan, samplingCallback);
            


            printBuffer("Freestyle initialized on chan %1d.", chan);
            break;

        case WPAD_DEV_CLASSIC:

            // Now that we know the extension type, we must revise
            // the data format and control the DPD accordingly.
            printBuffer("Classic initialized on chan %1d.", chan);
            break;

        case WPAD_DEV_NOT_FOUND:
        default:

            // 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);

            printBuffer("Unknown device on chan %1d.", chan);
            
            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  13*FONT_HEIGHT
#define X_START    30
#define Y_START    51

#define BUFFER_SIZE_BYTES 128
#define BUFFER_SIZE_LINES  10
static char __buffer[BUFFER_SIZE_LINES][BUFFER_SIZE_BYTES];
static u32  __curr_line = 0;



static void renderStatus(void)
{

    WPADCLStatus  status_block[WPAD_MAX_CONTROLLERS];
    WPADStatus   *wpad_ptr;
    WPADCLStatus *cl_ptr;
    WPADFSStatus *fs_ptr;

    s32 status;
    u32 type;

    s32 i;
    s16 x;
    s16 y;

    u32 line;


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

        x = X_START;
        y = Y_START;

        DEMOPrintf(30, 20, 0, "WPAD Asynchronous Event Handling Demo");


        DEMOPrintf(x, y, 0, "                Chan0       Chan1        Chan2        Chan3");
        y+=FONT_HEIGHT; 
        DEMOPrintf(x, y, 0, "             ----------   ----------   ----------   ----------");
                                          
        y+=FONT_HEIGHT;
        DEMOPrintf(x, y, 0, "     Status :"); y+=FONT_HEIGHT;
        DEMOPrintf(x, y, 0, "     Type   :"); y+=FONT_HEIGHT; y+=FONT_HEIGHT;

        DEMOPrintf(x, y, 0, "     Buttons:"); y+=FONT_HEIGHT; y+=FONT_HEIGHT; y+=FONT_HEIGHT;

        DEMOPrintf(x, y, 0, "     DPD0-x :"); y+=FONT_HEIGHT;
        DEMOPrintf(x, y, 0, "     DPD0-y :"); y+=FONT_HEIGHT;
        DEMOPrintf(x, y, 0, "     DPD1-x :"); y+=FONT_HEIGHT;
        DEMOPrintf(x, y, 0, "     DPD1-y :"); y+=FONT_HEIGHT; y+=FONT_HEIGHT;
              
        DEMOPrintf(x, y, 0, "     ACC-X  :"); y+=FONT_HEIGHT;
        DEMOPrintf(x, y, 0, "     ACC-Y  :"); y+=FONT_HEIGHT;
        DEMOPrintf(x, y, 0, "     ACC-Z  :"); y+=FONT_HEIGHT; y+=FONT_HEIGHT;

        DEMOPrintf(x, y, 0, "     StickX :"); y+=FONT_HEIGHT;
        DEMOPrintf(x, y, 0, "     StickY :"); y+=FONT_HEIGHT; y+=FONT_HEIGHT;

        DEMOPrintf(x, y, 0, "     ACC-X  :"); y+=FONT_HEIGHT;
        DEMOPrintf(x, y, 0, "     ACC-Y  :"); y+=FONT_HEIGHT;
        DEMOPrintf(x, y, 0, "     ACC-Z  :"); y+=FONT_HEIGHT; y+=FONT_HEIGHT;

        for (i=0; i<WPAD_MAX_CONTROLLERS; i++)
        {

            char buf1[] = "________";
            char buf2[] = "___";

                x = (s16)(X_START + ((1+i) * COL_WIDTH));
                y = (s16)(Y_START + 2 * FONT_HEIGHT);

                status = WPADProbe(i, &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; y+=FONT_HEIGHT;

                if (WPAD_ERR_NONE == status)
                {

                    WPADRead(i, &status_block[i]);
                    wpad_ptr = (WPADStatus   *)(&status_block[i]);
                    cl_ptr   = (WPADCLStatus *)(&status_block[i]);
                    fs_ptr   = (WPADFSStatus *)(&status_block[i]);

                    if( wpad_ptr->button & WPAD_BUTTON_LEFT   ) buf1[ 0] = '<';
                    if( wpad_ptr->button & WPAD_BUTTON_UP     ) buf1[ 1] = '^';
                    if( wpad_ptr->button & WPAD_BUTTON_DOWN   ) buf1[ 2] = 'v';
                    if( wpad_ptr->button & WPAD_BUTTON_RIGHT  ) buf1[ 3] = '>';

                    if( wpad_ptr->button & WPAD_BUTTON_START  ) buf1[ 4] = 'S';
                    if( wpad_ptr->button & WPAD_BUTTON_SELECT ) buf1[ 5] = 'T';
                    if( wpad_ptr->button & WPAD_BUTTON_A      ) buf1[ 6] = 'A';
                    if( wpad_ptr->button & WPAD_BUTTON_B      ) buf1[ 7] = 'B';

                    if( wpad_ptr->button & WPAD_BUTTON_SMALL_A) buf2[ 0] = 'a';
                    if( wpad_ptr->button & WPAD_BUTTON_SMALL_B) buf2[ 1] = 'b';
                    if( wpad_ptr->button & WPAD_BUTTON_HOME   ) buf2[ 2] = 'H';

                    DEMOPrintf(x, y, 0, " %s",   buf1); y+= FONT_HEIGHT;
                    DEMOPrintf(x, y, 0, "   %s", buf2); y+= FONT_HEIGHT;

                    y+= FONT_HEIGHT;

                    DEMOPrintf(x, y, 0, "   %04X", (u16)(wpad_ptr->obj[0].x)); y+= FONT_HEIGHT;
                    DEMOPrintf(x, y, 0, "   %04X", (u16)(wpad_ptr->obj[0].y)); y+= FONT_HEIGHT;
                    DEMOPrintf(x, y, 0, "   %04X", (u16)(wpad_ptr->obj[1].x)); y+= FONT_HEIGHT;
                    DEMOPrintf(x, y, 0, "   %04X", (u16)(wpad_ptr->obj[1].y)); y+= FONT_HEIGHT;

                    y+= FONT_HEIGHT;

                    DEMOPrintf(x, y, 0, "   %04X", (u16)(wpad_ptr->accX)); y+= FONT_HEIGHT;
                    DEMOPrintf(x, y, 0, "   %04X", (u16)(wpad_ptr->accY)); y+= FONT_HEIGHT;
                    DEMOPrintf(x, y, 0, "   %04X", (u16)(wpad_ptr->accZ)); y+= FONT_HEIGHT;

                    y+= FONT_HEIGHT;

                    if (WPAD_DEV_FREESTYLE == type)
                    {

                        DEMOPrintf(x, y, 0, "   %04X", (u16)(fs_ptr->fsStickX)); y+= FONT_HEIGHT;
                        DEMOPrintf(x, y, 0, "   %04X", (u16)(fs_ptr->fsStickY)); y+= FONT_HEIGHT;

                        y+= FONT_HEIGHT;

                        DEMOPrintf(x, y, 0, "   %04X", (u16)(fs_ptr->fsAccX)); y+= FONT_HEIGHT;
                        DEMOPrintf(x, y, 0, "   %04X", (u16)(fs_ptr->fsAccY)); y+= FONT_HEIGHT;
                        DEMOPrintf(x, y, 0, "   %04X", (u16)(fs_ptr->fsAccZ)); y+= FONT_HEIGHT;

                        y+= FONT_HEIGHT;

                    } // if freestyle

                } // if no error

            
        } // for...WPAD_MAX_CONTROLLERS


        // for scrolling debug-message buffer
        // it's convenient to see past event messages...
        y = 300;

        line = __curr_line;
        for (i=0; i<BUFFER_SIZE_LINES; i++)
        {
            DEMOPrintf(15, y, 0, ">> %s", &__buffer[line][0]);
            line = (line + 1) % BUFFER_SIZE_LINES;
            y+= FONT_HEIGHT;
        }

        

} // end renderStatus()

static void printBuffer(char *string, ...)
{

    va_list vlist; 

        memset(&__buffer[__curr_line][0], 0, BUFFER_SIZE_BYTES);

        va_start(vlist, string);
        vsprintf((char *)(&__buffer[__curr_line][0]), string, vlist);
        va_end(vlist);

        __curr_line = (__curr_line + 1) % BUFFER_SIZE_LINES;


} // clear and dump string to buffer


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_dol    [] = "  Dolphin ";
    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_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_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];
            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

        memset(__buffer, 0, BUFFER_SIZE_BYTES*BUFFER_SIZE_LINES);

} // end


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

    u32 fmt;

    WPADStatus   *co_ptr;
    WPADFSStatus *fs_ptr;


        for (j=0; j<WPAD_MAX_CONTROLLERS; j++)
        {

            fmt = WPADGetDataFormat(j);

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

                    co_ptr = (WPADStatus *)(&co_ringbuffer[j][0]);
                    
                    latest = WPADGetLatestIndexInBuf(j);
                    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[j][0]);
                    
                    latest = WPADGetLatestIndexInBuf(j);
                    index  = ((latest - 1) + SMPBUF_SIZE) % SMPBUF_SIZE;

                    for (i=0; i<SMPBUF_SIZE-1; i++)
                    {
                        if (WPAD_ERR_NONE == 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;


            } // end switch


        } // end for...max controllers

} // end