// RemoteTestDlg.cpp : Implementation file
//

#include "stdafx.h"
#include "RemoteTest.h"
#include "RemoteTestDlg.h"
#include "UPnPDlg.h"
#include "VAIBOUPnPClient.h"
#include "UserIdPwdDlg.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif


class CAboutDlg : public CDialog
{
public:
    CAboutDlg();

// Dialog Data
    //{{AFX_DATA(CAboutDlg)
    enum { IDD = IDD_ABOUTBOX };
    //}}AFX_DATA

    //{{AFX_VIRTUAL(CAboutDlg)
    protected:
    virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support
    //}}AFX_VIRTUAL

//  Implementation
protected:
    //{{AFX_MSG(CAboutDlg)
    //}}AFX_MSG
    DECLARE_MESSAGE_MAP()
};

CAboutDlg::CAboutDlg() : CDialog(CAboutDlg::IDD)
{
    //{{AFX_DATA_INIT(CAboutDlg)
    //}}AFX_DATA_INIT
}

void CAboutDlg::DoDataExchange(CDataExchange* pDX)
{
    CDialog::DoDataExchange(pDX);
    //{{AFX_DATA_MAP(CAboutDlg)
    //}}AFX_DATA_MAP
}

BEGIN_MESSAGE_MAP(CAboutDlg, CDialog)
    //{{AFX_MSG_MAP(CAboutDlg)
    //}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CRemoteTestDlg dialog

CRemoteTestDlg::CRemoteTestDlg(CWnd* pParent /*=NULL*/)
    : CDialog(CRemoteTestDlg::IDD, pParent)
{
    //{{AFX_DATA_INIT(CRemoteTestDlg)
    //}}AFX_DATA_INIT
    m_hIcon        = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
    m_vaibo        = NULL;
    m_bConnected   = false;
    m_isControl    = false;
    m_fileTPDlg    = NULL;
    m_imageTPDlg   = NULL;
    m_audioTPDlg   = NULL;
    m_senTPDlg     = NULL;
    m_mriDlg       = NULL;
    m_walkDlg      = NULL;
    m_postureDlg   = NULL;
    m_kickDlg      = NULL;
    m_mtnDlg       = NULL;
    m_3DDlg        = NULL;
    m_isSentpStart = false;
    m_status       = -1;
    m_posture      = -1;
    m_contentsDlg  = NULL;
    m_AutonomyDlg  = NULL;
    m_ClockDlg     = NULL;
    m_EtcDlg       = NULL;
    m_TTSDlg       = NULL;
    m_ProductIDDlg = NULL;
    m_VPRDlg       = NULL;
}

void CRemoteTestDlg::DoDataExchange(CDataExchange* pDX)
{
    CDialog::DoDataExchange(pDX);
    //{{AFX_DATA_MAP(CRemoteTestDlg)
    DDX_Control(pDX, IDC_IPADDRESS, m_ipAddress);
    //}}AFX_DATA_MAP
}

BEGIN_MESSAGE_MAP(CRemoteTestDlg, CDialog)
    //{{AFX_MSG_MAP(CRemoteTestDlg)
    ON_WM_SYSCOMMAND()
    ON_WM_PAINT()
    ON_WM_QUERYDRAGICON()
    ON_WM_CLOSE()
    ON_BN_CLICKED(IDC_BTN_CONNECT, OnBtnConnect)
    ON_BN_CLICKED(IDC_BTN_CONTROL, OnBtnControl)
    ON_BN_CLICKED(IDC_BTN_CONTROL2, OnBtnControl2)
    ON_BN_CLICKED(IDC_BTN_UPNP, OnBtnUPnP)
    ON_BN_CLICKED(IDC_BTN_SENTPDLG, OnBtnSenTPDlg)
    ON_BN_CLICKED(IDC_BTN_ITPDLG, OnBtnITPDlg)
    ON_BN_CLICKED(IDC_BTN_ATPDLG, OnBtnATPDlg)
    ON_BN_CLICKED(IDC_BTN_SHUTDOWN, OnBtnShutDown)
    ON_BN_CLICKED(IDC_BTN_REBOOT, OnBtnReboot)
    ON_BN_CLICKED(IDC_BTN_FTPDLG, OnBtnFTPDlg)
    ON_BN_CLICKED(IDC_BTN_WALKDLG, OnBtnWalkDlg)
    ON_BN_CLICKED(IDC_BTN_KICKDLG, OnBtnKickDlg)
    ON_BN_CLICKED(IDC_BTN_POSTUREDLG, OnBtnPostureDlg)
    ON_BN_CLICKED(IDC_BTN_MTNDLG, OnBtnMtnDlg)
    ON_BN_CLICKED(IDC_BTN_3DDLG, OnBtn3DDlg)
    ON_BN_CLICKED(IDC_BTN_CONTENTS, OnBtnContents)
    ON_BN_CLICKED(IDC_BTN_AUTONOMY, OnBtnAutonomy)
    ON_BN_CLICKED(IDC_BTN_CLOCK, OnBtnClock)
    ON_BN_CLICKED(IDC_BTN_BATTERY, OnBtnBattery)
    ON_BN_CLICKED(IDC_BTN_ISCONNECT, OnBtnIsconnect)
    ON_BN_CLICKED(IDC_BUTTON_TTS, OnBtnTTS)
    ON_BN_CLICKED(IDC_BTN_MRI, OnBtnMRI)
    ON_BN_CLICKED(IDC_BUTTON_PRODUCTID, OnButtonProductID)
    ON_BN_CLICKED(IDC_BUTTON_IDPWD, OnButtonIdpwd)
    ON_BN_CLICKED(IDC_BUTTON_VPR, OnButtonVPR)
    //}}AFX_MSG_MAP
    ON_REGISTERED_MESSAGE(WM_VAIBO_CONNECT, OnVAIBOConnect)
    ON_REGISTERED_MESSAGE(WM_VAIBO_DISCONNECT, OnVAIBODisconnect)
    ON_REGISTERED_MESSAGE(WM_VAIBO_SEMANTICS, OnVAIBOSemantics)
    ON_REGISTERED_MESSAGE(WM_VAIBO_INPUT_SEMANTICS, OnVAIBOInputSemantics)
    ON_REGISTERED_MESSAGE(WM_VAIBO_SENSOR_DATA, OnVAIBOSensorData)
    ON_REGISTERED_MESSAGE(WM_VAIBO_CLIENT_UPDATE, OnVAIBOClientUpdate)
    ON_REGISTERED_MESSAGE(WM_VAIBO_PRODUCTID, OnVAIBOProductID)
    ON_REGISTERED_MESSAGE(WM_VAIBO_BATTERY_LVL, OnVAIBOBatteryLevel)
    ON_REGISTERED_MESSAGE(WM_VAIBO_REMOTE_NOTIFY, OnVAIBORemoteNotify)
    ON_REGISTERED_MESSAGE(WM_MMFTP_SENDING, OnMMFTPSending)
    ON_REGISTERED_MESSAGE(WM_IMAGETP_UPDATE, OnITPImageUpdate)
    ON_REGISTERED_MESSAGE(WM_AUDIOTP_UPDATE, OnATPWaveUpdate)
    ON_REGISTERED_MESSAGE(WM_VAIBO_LOCK, OnVAIBOLock)
    ON_REGISTERED_MESSAGE(WM_VAIBO_SENSOR_ENABLE, OnVAIBOSensorEnable)
    ON_REGISTERED_MESSAGE(WM_VAIBO_SENSOR_DISABLE, OnVAIBOSensorDisable)

// Local MESSAGE
    ON_REGISTERED_MESSAGE(WM_REMOTETEST_MOVEAIBO3D, OnAibo3DMove)
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CRemoteTestDlg message handlers

BOOL CRemoteTestDlg::OnInitDialog()
{
    CDialog::OnInitDialog();

    ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);
    ASSERT(IDM_ABOUTBOX < 0xF000);

    CMenu* pSysMenu = GetSystemMenu(FALSE);
    if (pSysMenu != NULL)
    {
        CString strAboutMenu;
        strAboutMenu.LoadString(IDS_ABOUTBOX);
        if (!strAboutMenu.IsEmpty())
        {
            pSysMenu->AppendMenu(MF_SEPARATOR);
            pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu);
        }
    }

    SetIcon(m_hIcon, TRUE);         // Set big icon
    SetIcon(m_hIcon, FALSE);        // Set small icon

    int     nField0, nField1, nField2, nField3;
    LPCTSTR p;

    if ( m_vaibo == NULL ) {
        m_vaibo = new CVAIBO( this->m_hWnd );
    }
    CRemoteTestApp  *pApp = (CRemoteTestApp*)AfxGetApp();
    p = pApp->m_aiboIP.GetBuffer( pApp->m_aiboIP.GetLength() );
    ::sscanf( p, "%d.%d.%d.%d", &nField0, &nField1, &nField2, &nField3 );
    pApp->m_aiboIP.ReleaseBuffer();
    m_ipAddress.SetAddress( ( BYTE )nField0, ( BYTE )nField1, ( BYTE )nField2, ( BYTE )nField3 );

    return TRUE;   // return TRUE  unless you set the focus to a control
}

void CRemoteTestDlg::OnSysCommand(UINT nID, LPARAM lParam)
{
    if ((nID & 0xFFF0) == IDM_ABOUTBOX)
    {
        CAboutDlg dlgAbout;
        dlgAbout.DoModal();
    }
    else
    {
        CDialog::OnSysCommand(nID, lParam);
    }
}

void CRemoteTestDlg::OnPaint() 
{
    if (IsIconic())
    {
        CPaintDC dc(this);

        SendMessage(WM_ICONERASEBKGND, (WPARAM) dc.GetSafeHdc(), 0);

        int cxIcon = GetSystemMetrics(SM_CXICON);
        int cyIcon = GetSystemMetrics(SM_CYICON);
        CRect rect;
        GetClientRect(&rect);
        int x = (rect.Width() - cxIcon + 1) / 2;
        int y = (rect.Height() - cyIcon + 1) / 2;

        dc.DrawIcon(x, y, m_hIcon);
    }
    else
    {
        CDialog::OnPaint();
    }
}

HCURSOR CRemoteTestDlg::OnQueryDragIcon()
{
    return (HCURSOR) m_hIcon;
}

void CRemoteTestDlg::OnClose() 
{
    // Lead to deal with it before the management of Client, and carry it out 
    // because the thread which used the function of Client inside runs.
    if ( m_audioTPDlg != NULL ) {
        m_audioTPDlg->DestroyWindow();
        delete m_audioTPDlg;
        m_audioTPDlg = NULL;
    }

    m_vaibo->ImageClose();
    m_vaibo->AudioClose();
    if ( m_vaibo != NULL ) {
        if ( m_bConnected ) {
            m_vaibo->Disconnect();
        }
        delete m_vaibo;
    }
    if ( m_senTPDlg != NULL ) {
        m_senTPDlg->DestroyWindow();
        delete m_senTPDlg;
        m_senTPDlg = NULL;
    }
    if ( m_imageTPDlg != NULL ) {
        m_imageTPDlg->DestroyWindow();
        delete m_imageTPDlg;
        m_imageTPDlg = NULL;
    }
    if ( m_fileTPDlg != NULL ) {
        m_fileTPDlg->DestroyWindow();
        delete m_fileTPDlg;
        m_fileTPDlg = NULL;
    }
    if ( m_mriDlg != NULL ) {
        m_mriDlg->DestroyWindow();
        delete m_mriDlg;
        m_mriDlg = NULL;
    }
    if ( m_walkDlg != NULL ) {
        m_walkDlg->DestroyWindow();
        delete m_walkDlg;
        m_walkDlg = NULL;
    }
    if ( m_kickDlg != NULL ) {
        m_kickDlg->DestroyWindow();
        delete m_kickDlg;
        m_kickDlg = NULL;
    }
    if ( m_postureDlg != NULL ) {
        m_postureDlg->DestroyWindow();
        delete m_postureDlg;
        m_postureDlg = NULL;
    }
    if ( m_mtnDlg != NULL ) {
        m_mtnDlg->DestroyWindow();
        delete m_mtnDlg;
        m_mtnDlg = NULL;
    }
    if ( m_3DDlg != NULL ) {
        m_3DDlg->DestroyWindow();
        delete m_3DDlg;
        m_3DDlg = NULL;
    }
    if ( m_contentsDlg != NULL ) {
        m_contentsDlg->DestroyWindow();
        delete m_contentsDlg;
        m_contentsDlg = NULL;
    }
    if ( m_AutonomyDlg != NULL ) {
        m_AutonomyDlg->DestroyWindow();
        delete m_AutonomyDlg;
        m_AutonomyDlg = NULL;
    }
    if ( m_ClockDlg != NULL ) {
        m_ClockDlg->DestroyWindow();
        delete m_ClockDlg;
        m_ClockDlg = NULL;
    }
    if ( m_ProductIDDlg!= NULL ) {
        m_ProductIDDlg->DestroyWindow();
        delete m_ProductIDDlg;
        m_ProductIDDlg = NULL;
    }
    if ( m_VPRDlg ) {
        m_VPRDlg->DestroyWindow();
        delete m_VPRDlg;
        m_VPRDlg = NULL;
    }
    if ( m_TTSDlg ) {
        m_TTSDlg->DestroyWindow();
        delete m_TTSDlg;
        m_TTSDlg = NULL;
    }
    if ( m_EtcDlg ) {
        m_EtcDlg->DestroyWindow();
        delete m_EtcDlg;
        m_EtcDlg = NULL;
    }
    CDialog::OnClose();
}

void CRemoteTestDlg::OnOK() 
{
    OnClose();

    CDialog::OnOK();
}

void CRemoteTestDlg::OnBtnConnect() 
{
    if ( m_vaibo == NULL ) return;

    if ( !m_bConnected ) {
        CRemoteTestApp *app = (CRemoteTestApp*)AfxGetApp();

        UpdateData();

        CString     strIP;
        BYTE        nField0, nField1, nField2, nField3;

        m_ipAddress.GetAddress( nField0, nField1, nField2, nField3 );
        strIP.Format( "%d.%d.%d.%d", nField0, nField1, nField2, nField3 );
        if ( app->m_aiboIP != strIP ) {
            app->m_aiboIP = strIP;
        }
        int nAiboID;
        nAiboID = m_vaibo->Connect( (LPCTSTR)app->m_aiboIP/*, _T("testID"), _T("testPWD")*/ );
        if (nAiboID < 0) {
            CString msgerr;
            msgerr.Format("AIBO connection error (%d), see VAIBODef.h", nAiboID);
            AfxMessageBox(msgerr);
        } else {
            m_aiboID = nAiboID;
        }

        // Until it is connected, button, invalidly
        buttonConnect().SetWindowText( "Connecting" );
        buttonConnect().EnableWindow( false );
        if ( m_mriDlg == NULL ) {
            m_mriDlg = new CMRIDlg( this );
            m_mriDlg->Create( IDD_DLG_MRI );
        }
        m_mriDlg->ShowWindow( SW_SHOW );
    } else {
        if ( m_vaibo->GetStateImageTP() != IMAGETP_STATE_CLOSE ) {
            m_vaibo->ImageClose();
        }
        m_vaibo->Disconnect();
    }
}

void CRemoteTestDlg::OnBtnControl() 
{
    if ( m_vaibo == NULL ) return;

    if ( !m_isControl ) {
        // Control right acquisition request
        if ( m_vaibo->ExternalControl() ) {
            buttonControl().EnableWindow( false );
            buttonControl2().EnableWindow( true );
            m_isControl = true;
            if ( m_AutonomyDlg ) {
                m_AutonomyDlg->SetControlFlag( m_isControl );
            }
        }
    }
}

void CRemoteTestDlg::OnBtnControl2() 
{
    if ( m_vaibo == NULL ) return;

    if ( m_isControl ) {
        // Control right transfer
        if ( m_vaibo->InternalControl() ) {
            buttonControl().EnableWindow( true );
            buttonControl2().EnableWindow( false );
            m_isControl = false;
            if ( m_AutonomyDlg ) {
                m_AutonomyDlg->SetControlFlag( m_isControl );
            }
        }
    }
}

void CRemoteTestDlg::OnBtnUPnP() 
{
    CUPnPDlg    dlg;

    if ( dlg.DoModal() == IDOK ) {
        CRemoteTestApp  *pApp = (CRemoteTestApp*)AfxGetApp();
        BYTE    nField0, nField1, nField2, nField3;
        LPCTSTR p;

        p = pApp->m_aiboIP.GetBuffer( pApp->m_aiboIP.GetLength() );
        ::sscanf( p, "%d.%d.%d.%d", &nField0, &nField1, &nField2, &nField3 );
        pApp->m_aiboIP.ReleaseBuffer();
        m_ipAddress.SetAddress( nField0, nField1, nField2, nField3 );
    }

}

void CRemoteTestDlg::OnBtnSenTPDlg() 
{

    if ( m_senTPDlg == NULL ) {
        m_senTPDlg = new CSenTPDlg( this );
        m_senTPDlg->Create( IDD_DLG_SENTP );
    }
    m_senTPDlg->ShowWindow( SW_SHOW );
    if ( !m_isSentpStart ) {
        m_vaibo->RequestNetService( SENSOR_ID );
        m_isSentpStart = true;
    }
}

void CRemoteTestDlg::OnBtnFTPDlg() 
{

    if ( m_fileTPDlg == NULL ) {
        m_fileTPDlg = new CFTPDlg( m_vaibo );
        m_fileTPDlg->Create( IDD_DLG_FTP );
    }
    m_fileTPDlg->ShowWindow( SW_SHOW );
}

void CRemoteTestDlg::OnBtnITPDlg() 
{

    if ( m_imageTPDlg == NULL ) {
        m_imageTPDlg = new CITPDlg( m_vaibo, this );
        m_imageTPDlg->Create( IDD_DLG_ITP );
    }
    m_imageTPDlg->ShowWindow( SW_SHOW );
    if ( m_vaibo->GetStateImageTP() == IMAGETP_STATE_CLOSE ) {
        if ( m_vaibo->ImageInit() != IMAGETP_STATE_ERR ){
            if ( m_vaibo->ImageOpen() != IMAGETP_STATE_ERR ){
                if ( m_vaibo->RequestNetService( IMAGE_ID ) == IMAGETP_STATE_ERR ){
                }
            }
        }
    }
}

void CRemoteTestDlg::OnBtnATPDlg() 
{

    if ( m_audioTPDlg == NULL ) {
        m_audioTPDlg = new CATPDlg( m_vaibo, this );
        m_audioTPDlg->Create( IDD_DLG_ATP );
        m_vaibo->AudioInit();
        m_audioTPDlg->m_vaibo = m_vaibo;
    }
    m_audioTPDlg->ShowWindow( SW_SHOW );
}

void CRemoteTestDlg::OnBtnWalkDlg() 
{

    if ( m_walkDlg == NULL ) {
        m_walkDlg = new CWalkDlg( m_vaibo, this );
        m_walkDlg->Create( IDD_DLG_WALK );
    }
    m_walkDlg->ShowWindow( SW_SHOW );
}

void CRemoteTestDlg::OnBtnKickDlg() 
{

    if ( m_kickDlg == NULL ) {
        m_kickDlg = new CKickDlg( m_vaibo, this );
        m_kickDlg->Create( IDD_DLG_KICK );
    }
    m_kickDlg->ShowWindow( SW_SHOW );
}

void CRemoteTestDlg::OnBtnPostureDlg() 
{

    if ( m_postureDlg == NULL ) {
        m_postureDlg = new CPostureDlg( m_vaibo, this );
        m_postureDlg->Create( IDD_DLG_POSTURE );
    }
    m_postureDlg->ShowWindow( SW_SHOW );
}

void CRemoteTestDlg::OnBtnMtnDlg() 
{

    if ( m_mtnDlg == NULL ) {
        m_mtnDlg = new CMtnDlg( m_vaibo, this );
        m_mtnDlg->Create( IDD_DLG_MTN );
    }
    m_mtnDlg->ShowWindow( SW_SHOW );
}

void CRemoteTestDlg::OnBtn3DDlg() 
{

    if ( m_3DDlg == NULL ) {
        int robotDesign = m_vaibo->GetRobotDesign();
        m_posture = m_vaibo->GetPosture();
        m_3DDlg = new C3DDlg( robotDesign, Exchange3DPosture( m_posture ), this );
        m_3DDlg->Create( IDD_DLG_3D );
    }
    m_3DDlg->ShowWindow( SW_SHOW );
}

void CRemoteTestDlg::OnBtnShutDown() 
{

    if ( m_vaibo != NULL ) {
        m_vaibo->SendCmd( APPCMD_SHUTDOWN );
    }
}

void CRemoteTestDlg::OnBtnReboot() 
{

    if ( m_vaibo != NULL ) {
        m_vaibo->SendCmd( APPCMD_REBOOT );
    }
}


// It is sent when socket communication is started.
LRESULT CRemoteTestDlg::OnVAIBOConnect( WPARAM wParam, LPARAM lParam )
{
    CString strBtn;
    strBtn.LoadString( IDS_DSCNCT_BTN );    // "Disconnect"
    buttonConnect().SetWindowText( strBtn );
    buttonConnect().EnableWindow();
    buttonControl().EnableWindow();
    buttonControl2().EnableWindow( false );
    buttonAutonomyDlg().EnableWindow();
    buttonFTPDlg().EnableWindow();
    buttonSENTPDlg().EnableWindow();
    buttonITPDlg().EnableWindow();
    buttonATPDlg().EnableWindow();
    buttonWalkDlg().EnableWindow();
    buttonKickDlg().EnableWindow();
    buttonPostureDlg().EnableWindow();
    buttonMtnDlg().EnableWindow();
    buttonContentsDlg().EnableWindow();
    buttonClockDlg().EnableWindow();
    buttonBatteryDlg().EnableWindow();
    buttonMRIDlg().EnableWindow();
    buttonShutdown().EnableWindow();
    buttonReboot().EnableWindow();
    buttonVPR().EnableWindow();
    m_bConnected = true;
    m_isControl = false;
    if ( m_AutonomyDlg ) {
        m_AutonomyDlg->SetControlFlag( m_isControl );
    }
    m_vaibo->SetBatteryLevelNotify();

    return S_OK;
}

// It is sent when socket communication is finished.
LRESULT CRemoteTestDlg::OnVAIBODisconnect( WPARAM wParam, LPARAM lParam )
{
    CString strBtn;
    strBtn.LoadString( IDS_CNCT_BTN );      // "Connect"
    buttonConnect().SetWindowText( strBtn );
    buttonConnect().EnableWindow();
    buttonControl().EnableWindow( false );
    buttonControl2().EnableWindow( false );
    buttonAutonomyDlg().EnableWindow( false );
    buttonFTPDlg().EnableWindow( false );
    buttonSENTPDlg().EnableWindow( false );
    buttonITPDlg().EnableWindow( false );
    buttonATPDlg().EnableWindow( false );
    buttonWalkDlg().EnableWindow( false );
    buttonKickDlg().EnableWindow( false );
    buttonPostureDlg().EnableWindow( false );
    buttonMtnDlg().EnableWindow( false );
    button3DDlg().EnableWindow( false );
    buttonContentsDlg().EnableWindow( false );
    buttonClockDlg().EnableWindow( false );
    buttonBatteryDlg().EnableWindow( false );
    buttonMRIDlg().EnableWindow( false );
    buttonShutdown().EnableWindow( false );
    buttonReboot().EnableWindow( false );
    buttonProductID().EnableWindow( false );
    buttonVPR().EnableWindow( false );
    m_bConnected = false;
    m_isControl = false;
    if ( m_AutonomyDlg ) {
        m_AutonomyDlg->SetControlFlag( m_isControl );
    }
    m_isSentpStart = false;
    if ( m_mriDlg != NULL ) {
        m_mriDlg->ShowWindow( SW_HIDE );
    }
    if ( m_fileTPDlg != NULL ) {
        m_fileTPDlg->ResetItem();
        m_fileTPDlg->ShowWindow( SW_HIDE );
    }
    if ( m_senTPDlg != NULL ) {
        m_senTPDlg->ShowWindow( SW_HIDE );
    }
    if ( m_imageTPDlg != NULL ) {
        m_imageTPDlg->ShowWindow( SW_HIDE );
    }
    if ( m_audioTPDlg != NULL ) {
        m_audioTPDlg->StopDirectSound();
        m_audioTPDlg->ShowWindow( SW_HIDE );
        m_audioTPDlg->StartAudioTP( false );
        m_audioTPDlg->StartNetAudio( false );
    }
    if ( m_walkDlg != NULL ) {
        m_walkDlg->ShowWindow( SW_HIDE );
    }
    if ( m_kickDlg != NULL ) {
        m_kickDlg->ShowWindow( SW_HIDE );
    }
    if ( m_postureDlg != NULL ) {
        m_postureDlg->ShowWindow( SW_HIDE );
    }
    if ( m_mtnDlg != NULL ) {
        m_mtnDlg->ShowWindow( SW_HIDE );
    }
    if ( m_3DDlg != NULL ) {
        m_3DDlg->ShowWindow( SW_HIDE );
    }
    if ( m_contentsDlg != NULL ) {
        m_contentsDlg->ShowWindow( SW_HIDE );
    }
    if ( m_AutonomyDlg != NULL ) {
        m_AutonomyDlg->ShowWindow( SW_HIDE );
    }
    if ( m_ClockDlg != NULL ) {
        m_ClockDlg->ShowWindow( SW_HIDE );
    }
    if ( m_ProductIDDlg != NULL ) {
        m_ProductIDDlg->ShowWindow( SW_HIDE );
    }
    if ( m_VPRDlg != NULL ) {
        m_VPRDlg->ShowWindow( SW_HIDE );
    }
    if ( m_EtcDlg != NULL ) {
        m_EtcDlg->ShowWindow( SW_HIDE );
    }
    return S_OK;
}

// It is sent when Semantics is received.
LRESULT CRemoteTestDlg::OnVAIBOSemantics( WPARAM msg, LPARAM data )
{
    int     nAiboID = HIWORD( msg );
    msg = LOWORD( msg );

    TRACE( "OnVAIBOSemantics invoked.\n" );
    if ( msg == SEM_START ) {
        int     nProtocolVersion[ 4 ];
        if ( data == START_IMAGETP ) {
            m_vaibo->GetProtocolVersion( IMAGE_ID, nProtocolVersion );
            TRACE( "Start ImageTP service(%d, %d, %d, %d)\n", nProtocolVersion[ 0 ],nProtocolVersion[ 1 ], nProtocolVersion[ 2 ], nProtocolVersion[ 3 ]  );
            m_vaibo->SendCmd( APPCMD_IMAGE_SETPARAM, true, CMDSID_PROFILE, IMAGE_PROFILE_MID );
            if ( (m_vaibo->GetStateAudioTP() != AUDIOTP_STATE_CLOSE)&&
                (m_vaibo->GetStateNetAudio() != AUDIOTP_STATE_CLOSE) &&
                (m_vaibo->GetStateSensorTP() != SENSORTP_STATE_CLOSE) ) {
            }
        }
        if ( data == START_AUDIOINTP ) {
            m_vaibo->GetProtocolVersion( AUDIO_IN_ID, nProtocolVersion );
            TRACE( "Start AudioTP(IN) service(%d, %d, %d, %d)\n", nProtocolVersion[ 0 ],nProtocolVersion[ 1 ], nProtocolVersion[ 2 ], nProtocolVersion[ 3 ]  );
            if ( m_audioTPDlg != NULL ) {
                m_audioTPDlg->StartAudioTP( true );
            }
            if ( (m_vaibo->GetStateImageTP() != IMAGETP_STATE_CLOSE)&&
                (m_vaibo->GetStateNetAudio() != AUDIOTP_STATE_CLOSE) &&
                (m_vaibo->GetStateSensorTP() != SENSORTP_STATE_CLOSE) ) {
            }
        }
        if ( data == START_NETAUDIO ) {
            m_vaibo->GetProtocolVersion( NETAUDIO_ID, nProtocolVersion );
            TRACE( "Start NetAudio service(%d, %d, %d, %d)\n", nProtocolVersion[ 0 ],nProtocolVersion[ 1 ], nProtocolVersion[ 2 ], nProtocolVersion[ 3 ] );
            if ( m_audioTPDlg != NULL ) {
                m_audioTPDlg->StartNetAudio( true );
            }
            if ( (m_vaibo->GetStateImageTP() != IMAGETP_STATE_CLOSE)&&
                (m_vaibo->GetStateAudioTP() != AUDIOTP_STATE_CLOSE) &&
                (m_vaibo->GetStateSensorTP() != SENSORTP_STATE_CLOSE) ) {
            }
        }
        if ( data == START_SENSORTP ) {
            m_vaibo->GetProtocolVersion( SENSOR_ID, nProtocolVersion );
            TRACE( "Start SensorTP service(%d, %d, %d, %d)\n", nProtocolVersion[ 0 ],nProtocolVersion[ 1 ], nProtocolVersion[ 2 ], nProtocolVersion[ 3 ] );
            button3DDlg().EnableWindow();               // It is the place where ModelDesign was confirmed, and try to open a 3D dialog.
            if ( (m_vaibo->GetStateImageTP() != IMAGETP_STATE_CLOSE)&&
                (m_vaibo->GetStateAudioTP() != AUDIOTP_STATE_CLOSE) &&
                (m_vaibo->GetStateNetAudio() != AUDIOTP_STATE_CLOSE) ) {
            }
        }
        if ( data == START_FTP ) {
            m_vaibo->GetProtocolVersion( FTP_ID, nProtocolVersion );
            TRACE( "Start FTP service(%d, %d, %d, %d)\n", nProtocolVersion[ 0 ],nProtocolVersion[ 1 ], nProtocolVersion[ 2 ], nProtocolVersion[ 3 ] );
        }
    } else if ( msg == SEM_DONE ) {
        CString     msg;
        switch ( LOWORD( data ) ) {
        case DONE_SEND_CMD :
            msg = "Command execute finished\r\n";
            if ( m_mriDlg != NULL ) {
                m_mriDlg->DisplayOutput( msg );
            }
            break;

        case DONE_CHANGE_HEAD :
            msg = "ChangeHeadAngle() finished\r\n";
            if ( m_mriDlg != NULL ) {
                m_mriDlg->DisplayOutput( msg );
            }
            break;

        case DONE_KICK :
            msg = "DoKick() finished\r\n";
            if ( m_mriDlg != NULL ) {
                m_mriDlg->DisplayOutput( msg );
            }
            break;

        case DONE_HEADER :
            msg = "DoHeader() finished\r\n";
            if ( m_mriDlg != NULL ) {
                m_mriDlg->DisplayOutput( msg );
            }
            break;

        case DONE_WALKING :
            msg = "DoWalking() finished\r\n";
            if ( m_mriDlg != NULL ) {
                m_mriDlg->DisplayOutput( msg );
            }
            break;

        case DONE_SET_POSTURE :
            msg = "SetPosture() finished\r\n";
            if ( m_mriDlg != NULL ) {
                m_mriDlg->DisplayOutput( msg );
            }
            break;

        case DONE_SEND_WAV :
            msg = "WAVE file transfer finished\r\n";
            if ( m_mriDlg != NULL ) {
                m_mriDlg->DisplayOutput( msg );
            }
        
            if ( m_fileTPDlg != NULL ) {
                m_fileTPDlg->NotifyFTPStatus( FTP_DONE_TRANSMIT );
            }

            break;

        case DONE_PLAY_WAV :
            msg = "WAVE file play finished\r\n";
            if ( m_mriDlg != NULL ) {
                m_mriDlg->DisplayOutput( msg );
            }
            if ( m_TTSDlg != NULL ) {
                m_TTSDlg->NotifyPlayWave( DONE_PLAY_WAV );
            }
            break;

        case DONE_PLAY_MOTION :
            msg = "PlayMotion() finished\r\n";
            if ( m_mriDlg != NULL ) {
                m_mriDlg->DisplayOutput( msg );
            }
            break;

        case DONE_TURN_BODY :
            msg = "TurnBody() finished\r\n";
            if ( m_mriDlg != NULL ) {
                m_mriDlg->DisplayOutput( msg );
            }
            break;

        case DONE_SET_CLOCK :
            msg = "SetClock() finished\r\n";
            if ( m_mriDlg != NULL ) {
                m_mriDlg->DisplayOutput( msg );
            }
            break;

        case DONE_NETAUDIO :
            if ( data == RESULT_COMPLETE ) {
                msg = "NetAudio() start\r\n";
            }
            else {
                msg = "NetAudio() finished\r\n";
            }
            if ( m_mriDlg != NULL ) {
                m_mriDlg->DisplayOutput( msg );
            }
            break;

        default:
            break;
        }
    } else if ( msg == SEM_STATUS ) {   // Condition transition notice

        unsigned short  status, posture;

        status = LOWORD( data );
        posture = HIWORD( data );

        if ( m_posture != posture ) {
            if ( m_3DDlg != NULL ) {
                m_3DDlg->SetPosture( Exchange3DPosture( posture ) );
            }
        }
        TRACE("pos, status (%x,%x)->(%x,%x)\n",m_posture,m_status,posture,status);
        if ( ( m_posture != posture ) || ( m_status != status ) ) {
            m_status = status;
            m_posture = posture;
            DisplayStatusMessage();
        }
    } else if ( msg == SEM_RESULT ) {   // Result notice
        DisplaySemanticsMessage( msg, data );
    } else if ( msg == SEM_FINISHED ) { // AIBO function result notice
        DisplaySemanticsMessage( msg, data );
    } else if ( msg == SEM_ERROR ) {
        CString strMsg;
        switch ( data ) {
        case ERROR_LOOKUP_IMAGETP :
            strMsg = "ImageTP service lookup error.";
            break;

        case ERROR_REQ_IMAGETP :
            strMsg = "ImageTP request connection error.";
            break;

        case ERROR_LOOKUP_AUDIOIN :
            strMsg = "AudioTP(AIBO->PC) service lookup error.";
            break;

        case ERROR_REQ_AUDIOIN :
            strMsg = "AudioTP(AIBO->PC) request connection error.";
            break;

        case ERROR_LOOKUP_NETAUDIO :
            strMsg = "NetAudio(PC->AIBO) service lookup error.";
            break;

        case ERROR_REQ_NETAUDIO :
            strMsg = "NetAudio(PC->AIBO) request connection error.";
            break;
        case ERROR_LOOKUP_FTP :
            strMsg = "Ftp(PC->AIBO) request connection error.";
            break;
        case ERROR_REQ_FTP :
            strMsg = "ReqFtp(PC->AIBO) request connection error.";
            break;
        default:
            strMsg = "default(PC->AIBO) request connection error.";
            break;
        }
        AfxMessageBox( strMsg );
    }
    return S_OK;
}

// It is sent when Semantics is received.
LRESULT CRemoteTestDlg::OnVAIBOInputSemantics( WPARAM msg, LPARAM data )
{
    DisplayInputSemantics();
    return S_OK;
}

// It is sent when sensor data are received.
LRESULT CRemoteTestDlg::OnVAIBOSensorData( WPARAM wParam, LPARAM recArray )
{
    int     numOfData, aiboID;
    aiboID = HIWORD( wParam );
    numOfData = LOWORD( wParam );

    if ( m_vaibo == NULL ) {
        return S_OK;
    }
    if ( m_bConnected && (m_vaibo->GetStateSensorTP() != SENSORTP_STATE_CLOSE) && m_isSentpStart ) {
        m_senTPDlg->SetSensorValue( numOfData, (SensorRec*)recArray );  // The indication of the sensor data
    }
    if ( m_bConnected && (m_vaibo->GetStateSensorTP() != SENSORTP_STATE_CLOSE) && m_imageTPDlg != NULL ) {
        m_imageTPDlg->SetPSDValue( numOfData, (SensorRec*)recArray );   // The indication of the sensor data
    }
    if ( m_bConnected && (m_vaibo->GetStateSensorTP() != SENSORTP_STATE_CLOSE) && m_3DDlg != NULL ) {
        m_3DDlg->UpdateSensorValue( numOfData, (SensorRec*)recArray );  // The renewal of the sensor data
    }
    return S_OK;
}

// It is sent when socket communication is started.
LRESULT CRemoteTestDlg::OnVAIBOClientUpdate( WPARAM wParam, LPARAM lParam )
{
    int     nOn, aiboID;
    aiboID = HIWORD( wParam );
    nOn = LOWORD( wParam );

    if ( nOn ) {
        OnVAIBOConnect( 0, 0 );
    } else {
        OnVAIBODisconnect( 0, 0 );
    }

    return S_OK;
}

LRESULT CRemoteTestDlg::OnVAIBOProductID( WPARAM wParam, LPARAM lParam )
{
    buttonProductID().EnableWindow();
    if ( m_ProductIDDlg != NULL ) {
        m_ProductIDDlg->SetProductID();
    }

    return S_OK;
}

LRESULT CRemoteTestDlg::OnVAIBOBatteryLevel( WPARAM wParam, LPARAM lParam )
{
    if ( m_mriDlg != NULL ) {
        m_mriDlg->DisplayBatteryLevel( lParam );
    }
    return S_OK;
}

LRESULT CRemoteTestDlg::OnVAIBORemoteNotify( WPARAM wParam, LPARAM lParam )
{
#if 0
    if ( m_mriDlg != NULL ) {
        CString msg;
        if ( lParam == 0 ) {
            msg = _T("Notify Autonomy");            
        } else {
            msg = _T("Notify Remote");
        }
        AfxMessageBox( msg );
    }
#endif
    return S_OK;
}

LRESULT CRemoteTestDlg::OnMMFTPSending( WPARAM wParam, LPARAM sendSize )
{
    if (sendSize == -1) {
        AfxMessageBox(_T("MMFTP: Size error"));
        m_fileTPDlg->NotifyFTPStatus( FTP_NOW_TRANSMITTING, -1 );
        m_fileTPDlg->ResetItem();
        m_vaibo->SendCmd( APPCMD_RELOAD );
    }
    if ( m_fileTPDlg != NULL ) {
        m_fileTPDlg->NotifyFTPStatus( FTP_NOW_TRANSMITTING, sendSize );
    }

    return S_OK;
}

LRESULT CRemoteTestDlg::OnITPImageUpdate( WPARAM wParam, LPARAM recvLen )
{
    return S_OK;
}

LRESULT CRemoteTestDlg::OnVAIBOLock( WPARAM wParam, LPARAM recvLen )
{
    return S_OK;
}

LRESULT CRemoteTestDlg::OnVAIBOSensorEnable( WPARAM wParam, LPARAM recvLen )
{
    return S_OK;
}

LRESULT CRemoteTestDlg::OnVAIBOSensorDisable( WPARAM wParam, LPARAM recvLen )
{
    return S_OK;
}

LRESULT CRemoteTestDlg::OnATPWaveUpdate( WPARAM wParam, LPARAM recvLen )
{
    if ( m_audioTPDlg != NULL ) {

        unsigned char   *recvBuf = NULL;

        recvBuf = (unsigned char*)::calloc( 1, recvLen );
        m_vaibo->AudioGetData( recvBuf, recvLen );
        m_audioTPDlg->OutputWaveData( recvBuf, recvLen );
        ::free( recvBuf );
    }

    return S_OK;
}

void CRemoteTestDlg::DisplayInputSemantics( void )
{
    CString str2;
    CString str;
    int     semID;
    int     subInfo[4];
    int     etcInfo[4];
    WORD    wSemID;

    struct InputSemanticsInfo {
        char*   strSemName;
        WORD    wSemID;
    };
    InputSemanticsInfo  sSemInfoTable[] = {
        {   "BALL",                 SEMID_BALL                  },
        {   "FAV",                  SEMID_FAV                   },
        {   "UNFAV",                SEMID_UNFAV                 },
        {   "FLESH",                SEMID_FLESH                 },
        {   "NEWCOL",               SEMID_NEWCOL                },
        {   "DANGER",               SEMID_DANGER                },
        {   "BRIGHT",               SEMID_BRIGHT                },
        {   "BONE",                 SEMID_BONE                  },
        {   "PINK",                 SEMID_PINK                  },
        {   "OBJECT",               SEMID_OBJECT                },
        {   "OBSTACLE",             SEMID_OBSTACLE              },
        {   "HAND",                 SEMID_HAND                  },
        {   "WALL",                 SEMID_WALL                  },
        {   "CLIFF",                SEMID_CLIFF                 },
        {   "BORDER",               SEMID_BORDER                },
        {   "MOVE_OBJ",             SEMID_MOVE_OBJ              },
        {   "MOVEOBJ_ON",           SEMID_MOVEOBJ_ON            },
        {   "FACE",                 SEMID_FACE                  },
        {   "FACE_ID",              SEMID_FACE_ID               },
        {   "VOICE",                SEMID_VOICE                 },
        {   "TONE",                 SEMID_TONE                  },
        {   "VOICE_BEGIN",          SEMID_VOICE_BEGIN           },
        {   "AIBO_SOUND",           SEMID_AIBO_SOUND            },
        {   "LOUD",                 SEMID_LOUD                  },
        {   "NOISY",                SEMID_NOISY                 },
        {   "SPPLAY ",              SEMID_SPPLAY                },
        {   "E_RHYTHM",             SEMID_E_RHYTHM              },
        {   "EXPANSION",            SEMID_EXPANSION             },
        {   "EXTEMP",               SEMID_EXTEMP                },
        {   "INTEMP",               SEMID_INTEMP                },
        {   "BATTERY",              SEMID_BATTERY               },
        {   "FATIGUE",              SEMID_FATIGUE               },
        {   "HIT",                  SEMID_HIT                   },
        {   "PAT",                  SEMID_PAT                   },
        {   "CLICK",                SEMID_CLICK                 },
        {   "LONGPAT",              SEMID_LONGPAT               },
        {   "TOUCH_ON",             SEMID_TOUCH_ON              },
        {   "TOUCH_OFF",            SEMID_TOUCH_OFF             },
        {   "MASTER_TOUCH",         SEMID_MASTER_TOUCH          },
        {   "GO_AUTO",              SEMID_GO_AUTO               },
        {   "GO_VG",                SEMID_GO_VG                 },
        {   "GO_RESET",             SEMID_GO_RESET              },
        {   "MODE4",                SEMID_MODE4                 },
        {   "RESTRAINT",            SEMID_RESTRAINT             },
        {   "REG_START",            SEMID_REG_START             },
        {   "SW_TAIL_R",            SEMID_SW_TAIL_R             },
        {   "SW_TAIL_C",            SEMID_SW_TAIL_C             },
        {   "SW_TAIL_L",            SEMID_SW_TAIL_L             },
        {   "COLLISION",            SEMID_COLLISION             },
        {   "HOLD_IN_MOUTH",        SEMID_HOLD_IN_MOUTH         },
        {   "BACK_F",               SEMID_BACK_F                },
        {   "BACK_M",               SEMID_BACK_M                },
        {   "BACK_R",               SEMID_BACK_R                },
        {   "BACK_FM",              SEMID_BACK_FM               },
        {   "BACK_MR",              SEMID_BACK_MR               },
        {   "BACK_FR",              SEMID_BACK_FR               },
        {   "BACK_FMR",             SEMID_BACK_FMR              },
        {   "SLIDE_FMR",            SEMID_SLIDE_FMR             },
        {   "FCLIFF",               SEMID_FCLIFF                },
        {   "SMARKER",              SEMID_SMARKER               },
        {   "BOOT",                 SEMID_BOOT                  },
        {   "SYS_POSTURE",          SEMID_SYS_POSTURE           },
        {   "TZ_CHANGE",            SEMID_TZ_CHANGE             },
        {   "EMERGENCY",            SEMID_EMERGENCY             },
        {   "JOY",                  SEMID_JOY                   },
        {   "ANGRY",                SEMID_ANGRY                 },
        {   "SAD",                  SEMID_SAD                   },
        {   "FEAR",                 SEMID_FEAR                  },
        {   "DISGUST",              SEMID_DISGUST               },
        {   "SURPRISE",             SEMID_SURPRISE              },
        {   "APPETITE",             SEMID_APPETITE              },
        {   "EXERCISE",             SEMID_EXERCISE              },
        {   "AFFECTION",            SEMID_AFFECTION             },
        {   "CURIOSITY",            SEMID_CURIOSITY             },
        {   "PLEASANT",             SEMID_PLEASANT              },
        {   "SELFISH",              SEMID_SELFISH               },
        {   "REFLECTIVE",           SEMID_REFLECTIVE            },
        {   "AWAKENING",            SEMID_AWAKENING             },
        {   "TIME_EVENT",           SEMID_TIME_EVENT            },
        {   "RISE_POSE",            SEMID_RISE_POSE             },
        {   "SRODAPlay",            SEMID_SRODAPlay             },
        {   "SRONEPlay",            SEMID_SRONEPlay             },
        {   "AM_S_MAIL",            SEMID_AM_S_MAIL             },
        {   "AM_S_MESSAGE",         SEMID_AM_S_MESSAGE          },
        {   "AM_S_WLAN",            SEMID_AM_S_WLAN             },
        {   "AM_S_PHOTO",           SEMID_AM_S_PHOTO            },
        {   "AM_S_TALK",            SEMID_AM_S_TALK             },
        {   "AM_S_CONFIG_NOTIFY",   SEMID_AM_S_CONFIG_NOTIFY    },
        {   "AM_S_MAILINFO",        SEMID_AM_S_MAILINFO         },
        {   "ATPSPPLAY",            SEMID_ATPSPPLAY             },
        {   "EPOLE",                SEMID_EPOLE                 },
        {   "ECARD1",               SEMID_ECARD1                },
        {   "ECARD2",               SEMID_ECARD2                },
        {   "ESCENE1",              SEMID_ESCENE1               },
        {   "ESCENE2",              SEMID_ESCENE2               },
        {   "ESCENE3",              SEMID_ESCENE3               },
        {   "EOBJ",                 SEMID_EOBJ                  },
        {   "EPTN",                 SEMID_EPTN                  },
        {   "VPR_RESULT",           SEMID_VPR_RESULT            },
        {   "MONITOR_PARMIT",       SEMID_MONITOR_PARMIT        },
        {   "VOLUME",               SEMID_VOLUME                },
        {   "TOUCH_BEGIN",          SEMID_TOUCH_BEGIN           },
        {   "STT_SEM",              SEMID_STT_SEM               },
    };
    
    char* comStatus[4] = { "INVALID", "ON", "OFF", "DONTCARE" };

    char*   pString = "???";
    m_vaibo->GetInputSemantics( &semID, subInfo, etcInfo );
    wSemID = LOWORD( semID );

    if( wSemID == SEMID_OBJECT ) return;

    for ( int i = 0; i < sizeof( sSemInfoTable ) / sizeof( InputSemanticsInfo ); i++ ) {
        if ( sSemInfoTable[ i ].wSemID == wSemID ) {
            pString = sSemInfoTable[ i ].strSemName;
            break;
        }
    }
    str.Format("InputSemantics recieved. %s(0x%04X)\r\nSubInfo[0] = 0x%08X,\tSubInfo[1] = 0x%08X\r\nSubInfo[2] = 0x%08X,\tSubInfo[3] = 0x%08X\r\nComStatus=%s Level=0x%X Pitch=0x%X Position=0x%X\r\n",
                        pString, wSemID, subInfo[0], subInfo[1], subInfo[2], subInfo[3], comStatus[etcInfo[0]],etcInfo[1],etcInfo[2],etcInfo[3]   );
    str2 += str;
    if ( m_mriDlg != NULL ) {
        m_mriDlg->DisplayOutput( str2 );
    }

    if( wSemID == SEMID_VOLUME) {
        if ( m_EtcDlg != NULL ) {
            m_EtcDlg->ChangeVolume(subInfo[0]);
        }
    }

// The test of the 3D text indication
    if ( m_3DDlg ) {
        if ( m_3DDlg->m_aibo3D ) {
            m_3DDlg->m_aibo3D->SetDrawText2DString( pString );
            m_3DDlg->m_aibo3D->SetDrawText3DString( pString );
        }
    }
}

void CRemoteTestDlg::DisplaySemanticsMessage( WPARAM msg, LPARAM data )
{
    CString str2;
    CString str;
    int     subInfo[ 4 ];

    m_vaibo->GetSemInfo( subInfo );

    if ( msg == SEM_RESULT ) {

        str.Format( "Result(SerialNo.:%d) : ", subInfo[0] );    

        switch ( data ) {
            case RESULT_COMPLETE :
                str += "Complete"; break;
            case RESULT_INCOMPLETE :
                str += "Incomplete"; break;
            case RESULT_UNKNOWN :
                str += "Unknown"; break;
            case RESULT_FOLLOWFAIL :
                str += "Follow Fail"; break;
            case RESULT_FOLLOWSTART :
                str += "Follow Start"; break;
            case RESULT_FOLLOWEND :
                str += "Follow End"; break;
        }
        str2 += str; str2 += "\r\n";

    }
    else if ( msg == SEM_FINISHED ) {

        str.Format( "AIBO Function Finished(SerialNo.:%d) : ", subInfo[ 0 ] );  

        switch ( data ) {
            case FINISHED_COMPLETE :
                str += "Complete"; break;
            case FINISHED_INCOMPLETE :
                str += "Incomplete"; break;
            case FINISHED_UNKNOWN :
                str += "Unknown"; break;
        }
        str2 += str; str2 += "\r\n";

    }

    if ( m_mriDlg != NULL ) {
        m_mriDlg->DisplayOutput( str2 );
    }
}

void CRemoteTestDlg::DisplayStatusMessage()
{
    CString str2;
    CString str;

    str.Format( "Posture, Status: " );

    switch ( m_posture ) {
        case ST_POS_STAND :
            str += "Stand posture, "; break;
        case ST_POS_SIT :
            str += "Sit posture, "; break;
        case ST_POS_LIE :
            str += "Lie posture, "; break;
        case ST_POS_WALK :
            str += "Walk posture, "; break;
        case ST_POS_STATION :
            str += "Station posture, "; break;
        case ST_POS_PSTATION :
            str += "Pstation posture, "; break;
        case ST_POS_LIFT :
            str += "Lift posture, "; break;
        case ST_POS_NEUTRAL :
            str += "Neutral posture, "; break;
        case ST_POS_FALLDOWN :
            str += "Falldown, "; break;
        case ST_POS_MECHALOAD_H :
            str += "Mechaload High, "; break;
        case ST_POS_JAM :
            str += "Jamming, "; break;
        case ST_POS_UNKNOWN:
        case ST_POS_TEMP:
        case ST_POS_UNDEFINE:
        default:
            str += "Undefined posture, "; break;
    }

    switch ( m_status ) {
        case ST_STAT_UNKNOWN:
            str += "Unknown status"; break;
        case ST_STAT_DEFAULT:
            str += "Default status"; break;
        case ST_STAT_PLAY_WAV:
            str += "Play wave status"; break;
        case ST_STAT_PLAY_STREAM:
            str += "Play stream status"; break;
        case ST_STAT_PLAY_MOTION:
            str += "Play motion status"; break;
        case ST_STAT_POS_CHANGE:
            str += "Pos change status"; break;
        case ST_STAT_WALK_SLOW:
            str += "Walk slow status"; break;
        case ST_STAT_WALK_NORMAL:
            str += "Walk normal status"; break;
        case ST_STAT_WALK_FAST:
            str += "Walk fast status"; break;
        case ST_STAT_WALK_BACK:
            str += "Walk back status"; break;
        case ST_STAT_TURN_L_SLOW:
            str += "Turn left slow status"; break;
        case ST_STAT_TURN_L_NORMAL:
            str += "Turn left normal status"; break;
        case ST_STAT_TURN_L_FAST:
            str += "Turn left fast status"; break;
        case ST_STAT_TURN_R_SLOW:
            str += "Turn right slow status"; break;
        case ST_STAT_TURN_R_NORMAL:
            str += "Turn right normal status"; break;
        case ST_STAT_TURN_R_FAST:
            str += "Turn right fast status"; break;
        default:
            str += "Unknown status"; break;
    }


    str2 += str; str2 += "\r\n";
    if ( m_mriDlg != NULL ) {
        m_mriDlg->DisplayOutput( str2 );
    }
}

void CRemoteTestDlg::SensorTransferStart( void )
{
    if ( m_isSentpStart ) {
        m_vaibo->SensorTransferStart();
    }
}

void CRemoteTestDlg::SensorTransferStop( void )
{
    if ( m_isSentpStart ) {
        m_vaibo->SensorTransferStop();
    }
}

void CRemoteTestDlg::SensorSetSkipRate( int skip )
{
    if ( m_isSentpStart ) {
        m_vaibo->SensorSetSkipRate( skip );
    }
}

int CRemoteTestDlg::Exchange3DPosture( int vaiboPosture )
{
    int     posture3D;

    switch ( vaiboPosture ) {
    case ST_POS_STAND :
        posture3D = POSE_3D_STANDUP;
        break;

    case ST_POS_SIT :
        posture3D = POSE_3D_SITDOWN;
        break;

    case ST_POS_LIE :
        posture3D = POSE_3D_LIE;
        break;

    case ST_POS_WALK :
        posture3D = POSE_3D_WALKING;
        break;

    case ST_POS_SHUTDOWN :
        posture3D = POSE_3D_SHUTDOWN;
        break;

    case ST_POS_NEUTRAL :
        posture3D = POSE_3D_NORMAL;
        break;

    case ST_POS_LIFT :
        posture3D = POSE_3D_HOLDUP;
        break;

    case ST_POS_STATION :
        posture3D = POSE_3D_STATION;
        break;

    default :
        posture3D = POSE_3D_NORMAL;
        break;
    }
    return posture3D;
}

void CRemoteTestDlg::OnBtnContents() 
{
    if ( m_contentsDlg == NULL ) {
        m_contentsDlg = new CContentsDlg( m_vaibo );
        m_contentsDlg->Create( IDD_DLG_CONTENTS );
    }
    m_contentsDlg->ShowWindow( SW_SHOW );   
}

void CRemoteTestDlg::OnBtnAutonomy() 
{

    if ( m_AutonomyDlg == NULL ) {
        m_AutonomyDlg = new CAutonomyDlg( m_vaibo );
        m_AutonomyDlg->Create( IDD_DIALOG_BM );
        m_AutonomyDlg->SetControlFlag( m_isControl );
    }
    m_AutonomyDlg->ShowWindow( SW_SHOW );   
}

void CRemoteTestDlg::OnBtnClock() 
{

    if ( m_ClockDlg == NULL ) {
        m_ClockDlg = new CClockDlg( m_vaibo );
        m_ClockDlg->Create( IDD_DIALOG_CLOCK );
    }
    m_ClockDlg->ShowWindow( SW_SHOW );  
}

void CRemoteTestDlg::OnBtnBattery() 
{

    if ( m_EtcDlg == NULL ) {
        m_EtcDlg = new CEtcDlg( m_vaibo );
        m_EtcDlg->Create( IDD_DLG_ETC );
    }
    m_EtcDlg->ShowWindow( SW_SHOW );
}

void CRemoteTestDlg::OnBtnIsconnect() 
{

    if ( m_vaibo == NULL ) {
        return;
    }
    if (m_vaibo->IsConnect()) {
        AfxMessageBox(_T("Yes"));
    } else {
        AfxMessageBox(_T("No"));
    }
}


int CRemoteTestDlg::SensorGetSkipRate()
{
    return m_vaibo->SensorGetSkipRate();
}

LRESULT CRemoteTestDlg::OnAibo3DMove( WPARAM wParam, LPARAM lParam )
{
    if ( m_3DDlg ) {
        m_3DDlg->MoveAIBO( wParam, ( float )lParam );
    }

    return S_OK;
}

void CRemoteTestDlg::OnBtnTTS()
{
    if ( m_TTSDlg == NULL ) {
        m_TTSDlg = new CTTSDlg( this->m_vaibo );
        m_TTSDlg->Create( IDD_DIALOG_TTS );
    }
    m_TTSDlg->ShowWindow( SW_SHOW );
}


void CRemoteTestDlg::OnBtnMRI()
{
    if ( m_mriDlg == NULL ) {
        m_mriDlg = new CMRIDlg( this );
        m_mriDlg->Create( IDD_DLG_MRI );
    }
    m_mriDlg->ShowWindow( SW_SHOW );
}

void    CRemoteTestDlg::OnButtonProductID()
{
    if ( m_ProductIDDlg == NULL ) {
        m_ProductIDDlg = new CProductIDDlg( this->m_vaibo );
        m_ProductIDDlg->Create( IDD_DIALOG_PRODUCTID );
        m_ProductIDDlg->SetProductID();
    }
    m_ProductIDDlg->ShowWindow( SW_SHOW );
}

void    CRemoteTestDlg::SetControlFlag( bool isControl )
{
    m_isControl = isControl;

    if ( m_isControl ) {
        buttonControl().EnableWindow( false );
        buttonControl2().EnableWindow( true );
    }
    else {
        buttonControl().EnableWindow( true );
        buttonControl2().EnableWindow( false );
    }
}


void CRemoteTestDlg::OnButtonIdpwd() 
{

    CUserIdPwdDlg dlg( this->m_vaibo );
    dlg.DoModal();
}

void CRemoteTestDlg::OnButtonVPR()
{
    if ( m_VPRDlg == NULL ) {
        m_VPRDlg = new CVPRDlg( this->m_vaibo );
        m_VPRDlg->Create( IDD_DIALOG_VPR );
    }
    m_VPRDlg->ShowWindow( SW_SHOW );
}
