SimulationWindow.cpp

Go to the documentation of this file.

#include "StdAfx.h"
#include "IMovableItemCallback.h"
#include "ISimGUICallback.h"
#include "AnimatBase.h"
#include "SimulationWindow.h"

namespace AnimatSim
{

SimulationWindow::SimulationWindow(void)
{
        m_HWND = 0;
        m_ptPosition.Set(0, 0, 0);
        m_ptSize.Set(500, 500, 0);
        m_bTrackCamera = false;
        m_bStandAlone = true;
}

SimulationWindow::SimulationWindow(HWND win)
{
        m_HWND = win;
        m_ptPosition.Set(0, 0, 0);
        m_ptSize.Set(500, 500, 0);
        m_bTrackCamera = false;
        m_bStandAlone = true;
}

SimulationWindow::~SimulationWindow(void)
{
}

void SimulationWindow::LookAtStructureID(std::string strID) 
{
    if(Std_IsBlank(strID))
        m_bTrackCamera = false;
    else
        m_bTrackCamera = true;

        m_strLookAtStructureID = strID;
        SetupTrackCamera(false);
}

std::string SimulationWindow::LookAtStructureID() {return m_strLookAtStructureID;}

void SimulationWindow::LookAtBodyID(std::string strID) 
{
    m_strLookAtBodyID = strID;
        SetupTrackCamera(false);
}

std::string SimulationWindow::LookAtBodyID() {return m_strLookAtBodyID;}

void SimulationWindow::UsingTrackCamera(bool bVal) 
{
        m_bTrackCamera = bVal;
        SetupTrackCamera(true);
}

bool SimulationWindow::UsingTrackCamera() {return m_bTrackCamera;}

HWND SimulationWindow::WindowID() {return m_HWND;}

void SimulationWindow::WindowID(HWND win) {m_HWND = win;}

bool SimulationWindow::StandAlone() {return m_bStandAlone;}

void SimulationWindow::StandAlone(bool bVal) {m_bStandAlone = bVal;}

#pragma region DataAccesMethods

float *SimulationWindow::GetDataPointer(const std::string &strDataType)
{
        float *lpData=NULL;
        std::string strType = Std_CheckString(strDataType);

        //if(strType == "TIME")
        //      lpData = &m_fltTime;
        //else
                THROW_TEXT_ERROR(Al_Err_lInvalidDataType, Al_Err_strInvalidDataType, "Simulator DataType: " + strDataType);

        return lpData;
}

bool SimulationWindow::SetData(const std::string &strDataType, const std::string &strValue, bool bThrowError)
{
        std::string strType = Std_CheckString(strDataType);
        
        if(AnimatBase::SetData(strDataType, strValue, false))
                return true;

        if(strType == "LOOKATSTRUCTUREID")
        {
                LookAtStructureID(strValue);
                return true;
        }

        if(strType == "LOOKATBODYID")
        {
                LookAtBodyID(strValue);
                return true;
        }

        if(strType == "TRACKCAMERA")
        {
                UsingTrackCamera(Std_ToBool(strValue));
                return true;
        }

        //If it was not one of those above then we have a problem.
        if(bThrowError)
                THROW_PARAM_ERROR(Al_Err_lInvalidDataType, Al_Err_strInvalidDataType, "Data Type", strDataType);

        return false;
}

void SimulationWindow::QueryProperties(CStdPtrArray<TypeProperty> &aryProperties)
{
        AnimatBase::QueryProperties(aryProperties);

        aryProperties.Add(new TypeProperty("LookAtStructureID", AnimatPropertyType::String, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("LookAtBodyID", AnimatPropertyType::String, AnimatPropertyDirection::Set));
        aryProperties.Add(new TypeProperty("TrackCamera", AnimatPropertyType::Boolean, AnimatPropertyDirection::Set));
}

#pragma endregion

void SimulationWindow::SetupTrackCamera(bool bTrackCamera, std::string strLookAtStructureID, std::string strLookAtBodyID)
{
        m_bTrackCamera = bTrackCamera;
        m_strLookAtStructureID = strLookAtStructureID;
        m_strLookAtBodyID = strLookAtBodyID;
        SetupTrackCamera(true);
}

void SimulationWindow::SetCameraLookAt(CStdFPoint oTarget, bool bResetEyePos) {}

void SimulationWindow::SetCameraPositionAndLookAt(CStdFPoint oCameraPos, CStdFPoint oTarget) {}

void SimulationWindow::SetCameraPostion(CStdFPoint vCameraPos) {};

void SimulationWindow::UpdateBackgroundColor() {}

void SimulationWindow::OnGetFocus()
{}

void SimulationWindow::OnLoseFocus()
{}

void SimulationWindow::Load(std::string strXml)
{
        //If it is blank then skip the loading.
        if(Std_IsBlank(strXml))
                return;

        CStdXml oXml;
        oXml.Deserialize(strXml);

        oXml.FindElement("WindowMgr");
        oXml.FindChildElement("Window");

        Load(oXml);
}

void SimulationWindow::Load(CStdXml &oXml)
{
        AnimatBase::Load(oXml);

        oXml.IntoElem(); //Into Window Element

        if(oXml.FindChildElement("Position", false))
                Std_LoadPoint(oXml, "Position", m_ptPosition);
        if(oXml.FindChildElement("Size", false))
                Std_LoadPoint(oXml, "Size", m_ptSize);

        m_bStandAlone = oXml.GetChildBool("StandAlone", m_bStandAlone);

        m_strLookAtStructureID = oXml.GetChildString("LookAtStructureID", m_strLookAtStructureID);      
        m_strLookAtBodyID = oXml.GetChildString("LookAtBodyID", m_strLookAtBodyID);     
        m_bTrackCamera = oXml.GetChildBool("TrackCamera", m_bTrackCamera);

        oXml.OutOfElem(); //OutOf Window Element

        if(m_ptPosition.x < 0 || m_ptPosition.y < 0)
                THROW_TEXT_ERROR(Al_Err_lSimWinPosInvalid, Al_Err_strSimWinPosInvalid, "POS: (" + STR(m_ptPosition.x) + ", " + STR(m_ptPosition.y) + ")");
        if(m_ptSize.x < 0 || m_ptSize.y < 0)
                THROW_TEXT_ERROR(Al_Err_lSimWinSizeInvalid, Al_Err_strSimWinSizeInvalid, "Size: (" + STR(m_ptSize.x) + ", " + STR(m_ptSize.y) + ")");
}

}//end namespace AnimatSim