ScreenMapEditor.cpp

Go to the documentation of this file.

#include "global.h"
#include "MercuryMath.h"
#include "ScreenMapEditor.h"
#include "MercuryTheme.h"
#include "MercuryInput.h"
#include "MercuryLoadableModel.h"
#include "MercuryDisplay.h"

#include "MercuryObjectFactory.h"
REGISTER_SCREEN_CLASS( ScreenMapEditor )

#define     MC_INPUTMAPPED      1       //convention: MESSAGE CODE
#define     MC_INPUTUNMAPPED    2
#define     MC_RESPFilename     3
#define     MC_RESPWorldname    4
#define     MC_RESPObjectname   5
#define     MC_RESPJumpToSel    6
#define     MC_RESPSetGravity   7
#define     MC_RESPFilename2    8
#define     MC_RESPDensity      9
#define     MC_RESPType         10
#define     MC_RESPLength       11
#define     MC_RESPRadius       12
#define     MC_RESPScale        13

#define     MC_NewObjectName    14
#define     MC_DeleteConfirm    15


KeyMappingWithCode( button_shift, "0-16" );
KeyMappingWithCode( button_ctrl, "0-17" );
KeyMappingWithCode( button_alt, "0-18" );
KeyMappingWithCode( button_mouse1, "0-1" );
KeyMappingWithCode( button_mouse2, "0-2" );

KeyMappingWithCode( button_up, "0-273" );
KeyMappingWithCode( button_down, "0-274" );
KeyMappingWithCode( button_right, "0-275" );
KeyMappingWithCode( button_left, "0-276" );

KeyMappingWithCode( button_c, "0-99" );
KeyMappingWithCode( button_d, "0-100" );

KeyMappingWithCode( button_F1, "0-282" );
KeyMappingWithCode( button_F2, "0-283" );
KeyMappingWithCode( button_F3, "0-284" );

const MString sPromptedInput = "PromptedInput";

/*


L = LoadFile
W = LoadWorld
O = LoadObject Class
S = Save Current
I = List contents of File

G = Jump to Piece #
Home = First Piece
PgUp = Previous Piece
PgDn = Next Piece
End = Last Piece
<- = Deselect object

C = Down
D = Up

N = New Piece       ************* NOT YET IMPLEMENTED *************
DEL = Delete Piece  ************* NOT YET IMPLEMENTED *************
R = Reset Camera

Button 1 = Control on Object

Position Normally (When Button1 is pressed)
Ctrl: Control Rotation
Shift: Control Z

---Piece Only Commands---
U = Set/Reset uses ODE
V = Set/Reset is Visible
F = Set Filename
E = Set Density
T = Set Type

J = Length
K = Radius (If applicable, or Scale if applicable)

---World Only Commands---
V = Set Gravity
B = Set/Reset Bodied

  */
ScreenMapEditor::~ScreenMapEditor()
{
    DISPLAY->RemoveLight(&m_light);
}

void ScreenMapEditor::Init()
{
    MercuryScreen::Init();
    MercurySprite* background = new MercurySprite;
    m_pBackground = background;
    background->SetName(m_name + " background");
    background->Init();
    background->LoadImage( THEME.GetMetricS( m_name, "background" ));
    background->MoveX(320);
    background->MoveY(240);

    //Set the mouse to start
    INPUTMAN->GetCursorPosition( m_iOldMouseX, m_iOldMouseY );

    m_fODEables.SetName( "MapEditor_ODEables" );
    m_fODEables.Init();
    //m_fODEables.SetProjectionType( PERSPECTIVE );
    AddPerspObject( &m_fODEables );

    m_fVisibles.SetName( "MapEditor_Visibles" );
    m_fVisibles.Init();
    //m_fODEables.SetProjectionType( PERSPECTIVE );
    AddPerspObject( &m_fVisibles );

    m_pCameraPos.SetX(-100);
    m_qCamera.w = 1;

    m_bShowingElems = false;

    m_fOverlays.SetName( "ScreenMapEditorOverlays" );
    m_fOverlays.Init();
    AddOrthoObject( &m_fOverlays );

    m_pOverlay.SetName( "ObjectControlPane" );
    m_pOverlay.Init();
    m_fOverlays.AddObject( &m_pOverlay );

    m_pPrompt.SetName( "EditorTextPrompt" );
    m_pPrompt.Init();
    m_fOverlays.AddObject( &m_pPrompt );

    m_tMessage.SetName( "TextMessage" );
    m_tMessage.Init();
    m_tMessage.SetFont( THEME.GetMetricS( GetName(), "Font" ) );
    m_tMessage.Tweening.AddCommand( THEME.GetMetricS( GetName(), "TextMessageActiveCommand" ), MercuryTweenState::LOCAL, "ActiveCommand" );
    m_fOverlays.AddObject( &m_tMessage );

    m_tElems.SetName( "ListOfKeys" );
    m_tElems.Init();
    m_fOverlays.AddObject( &m_tElems );

    m_oSelectedPart = NULL;
    m_iSelectedPart = -1;
    m_bObjectLoaded = false;
    m_bWorldLoaded = false;

    m_pCamera = new MercuryCamera;
    m_pCamera->SetName( "Camera" );
    m_pCamera->Init();
    m_pCamera->SetPosition( MercuryPoint( 500,100,900) );
    m_pCamera->SetUp(MercuryPoint(0,0,1));
    AddObject( m_pCamera );

    //Setup a light
    m_light.Init();
    m_light.SetY(100);
    m_light.SetX(-100);
    m_light.SetZ(110);
    m_light.SetAttenuation(0.001f, Attenuation::LINEAR);
    m_light.SetStatic(true);
    DISPLAY->AddLight(&m_light);

    RegisterMessage( MC_INPUTUNMAPPED, "unmappedinput" );
    RegisterMessage( MC_INPUTMAPPED, "mappedinput" );
}

MercuryObject * ScreenMapEditor::GetSelectedHandleODE()
{
    if ( SelectedObject() < 0 )
        return NULL;
    if (m_bWorldLoaded)
    {
        if (m_vODEObjs[SelectedObject()])
            return m_vODEObjs[SelectedObject()];
    }
    else if(m_bObjectLoaded)
    {
        if(m_vLastODE[SelectedObject()])
            return m_vLastODE[SelectedObject()];
    }
    return NULL;
}

MercuryObject * ScreenMapEditor::GetSelectedHandleVis()
{
    if ( SelectedObject() < 0 )
        return NULL;
    if (m_bWorldLoaded)
    {
        if (m_vVisObjs[SelectedObject()])
            return m_vVisObjs[SelectedObject()];
    }
    else if(m_bObjectLoaded)
    {
        if(m_vLastVis[SelectedObject()])
            return m_vLastVis[SelectedObject()];
    }
    return NULL;
}

void ScreenMapEditor::Update( const float dTime )
{

    int cX, cY;
    INPUTMAN->GetCursorPosition( cX, cY );
    int dX = cX - m_iOldMouseX;
    int dY = cY - m_iOldMouseY;
    m_iOldMouseX = cX;
    m_iOldMouseY = cY;  //Update mouse location regardless as to if we have focus so we don't jump

    if ( m_pPrompt.m_bPromptingForText )
    {
        m_pPrompt.Update( dTime );
        return;
    }

    if ( m_oSelectedPart )
        m_oSelectedPart->SetDiffuse( MercuryColor( 0.0f,1.0f,0.0f,0.5f ) );

    // OK The next few lines should use Quaternions.
    // Seriously... they REALLY shouldn't be done this way.
    // if ANYONE WANTS... FEEL FREE TO EDIT THIS!
    float qX = 0;
    float qY = 0;

    //Camera Position
    if ( INPUTMAN->IsButtonDown( button_up ) )
        qY++;
    if ( INPUTMAN->IsButtonDown( button_down ) )
        qY--;
    if ( INPUTMAN->IsButtonDown( button_left ) )
        qX++;
    if ( INPUTMAN->IsButtonDown( button_right ) )
        qX--;

    float AngleToGo=m_pCameraRot.x;

    //I commented out these lines of code so that you don't move the camera up and down with the arrow keys
    //m_pCamera.z += SIN(m_pCameraRot.y)*qY;
    m_pCameraPos.x += (COS(AngleToGo+(3.141592653589f/2))*qX + COS(AngleToGo)*qY);//*SQRT(1-SIN(m_pCameraRot.y)*SIN(m_pCameraRot.y));
    m_pCameraPos.y += (SIN(AngleToGo+(3.141592653589f/2))*qX + SIN(AngleToGo)*qY);//*SQRT(1-SIN(m_pCameraRot.y)*SIN(m_pCameraRot.y));

    if ( INPUTMAN->IsButtonDown( button_c ) )
        m_pCameraPos.z--;
    if ( INPUTMAN->IsButtonDown( button_d ) )
        m_pCameraPos.z++;

    if ( INPUTMAN->IsButtonDown( button_mouse1 ) )
    {
        if ( SelectedObject() >= 0 && ( m_bObjectLoaded || m_bWorldLoaded ) )
        {
            float dx = 0, dy = 0, dz = 0;
            if ( INPUTMAN->IsButtonDown( button_F3 ) )
                dz += dY;
            else if ( INPUTMAN->IsButtonDown( button_F1 ) )
                dx += dY;
            else if ( INPUTMAN->IsButtonDown( button_F2 ) )
                dy += dY;
            else
            {
                //dx -= dY;
                //dy -= dX;
                //Now we do it based on world coordinates
                dx = -(COS(m_pCameraRot.x+(3.141592653589f/2))*dX + COS(m_pCameraRot.x)*dY);
                dy = -(SIN(m_pCameraRot.x+(3.141592653589f/2))*dX + SIN(m_pCameraRot.x)*dY);
            }
            float x,y,z;
            if ( INPUTMAN->IsButtonDown( button_ctrl ) )
            {
                float magnitude = 0.25;
                x = m_iTightFile.GetValueF( m_sEditingName, ssprintf( "Piece%dRotX", SelectedObject() + 1 ) ) + (dx * magnitude);
                y = m_iTightFile.GetValueF( m_sEditingName, ssprintf( "Piece%dRotY", SelectedObject() + 1 ) ) + (dy * magnitude);
                z = m_iTightFile.GetValueF( m_sEditingName, ssprintf( "Piece%dRotZ", SelectedObject() + 1 ) ) + (dz * magnitude);
                if ( x < 0 ) x = 360;
                if ( x > 360 ) x = 0;
                if ( y < 0 ) y = 360;
                if ( y > 360 ) y = 0;
                if ( z < 0 ) z = 360;
                if ( z > 360 ) z = 0;
                SetIni( m_sEditingName, ssprintf( "Piece%dRotX", SelectedObject() + 1 ), ssprintf( "%f", x ) );
                SetIni( m_sEditingName, ssprintf( "Piece%dRotY", SelectedObject() + 1 ), ssprintf( "%f", y ) );
                SetIni( m_sEditingName, ssprintf( "Piece%dRotZ", SelectedObject() + 1 ), ssprintf( "%f", z ) );
                if ( GetSelectedHandleVis() ) GetSelectedHandleVis()->SetRot(MercuryPoint(x, y, z));
                if ( GetSelectedHandleODE() ) GetSelectedHandleODE()->SetRot(MercuryPoint(x, y, z));
            }
            else
            {
                float magnitude = CameraDistance()/100;
                x = m_iTightFile.GetValueF( m_sEditingName, ssprintf( "Piece%dX", SelectedObject() + 1 ) ) + (dx * magnitude);
                y = m_iTightFile.GetValueF( m_sEditingName, ssprintf( "Piece%dY", SelectedObject() + 1 ) ) + (dy * magnitude);
                z = m_iTightFile.GetValueF( m_sEditingName, ssprintf( "Piece%dZ", SelectedObject() + 1 ) ) + (dz * magnitude);
                SetIni( m_sEditingName, ssprintf( "Piece%dX", SelectedObject() + 1 ), ssprintf( "%f", x ) );
                SetIni( m_sEditingName, ssprintf( "Piece%dY", SelectedObject() + 1 ), ssprintf( "%f", y ) );
                SetIni( m_sEditingName, ssprintf( "Piece%dZ", SelectedObject() + 1 ), ssprintf( "%f", z ) );
                if ( GetSelectedHandleVis() ) GetSelectedHandleVis()->SetPosition(MercuryPoint(x, y, z));
                if ( GetSelectedHandleODE() ) GetSelectedHandleODE()->SetPosition(MercuryPoint(x, y, z));
            }
        }
    }
    else
    {
        m_pCameraRot.x -= float(dX)/100.0f;
        m_pCameraRot.y -= float(dY)/100.0f;
        m_pCameraRot.y = Clamp( m_pCameraRot.y, -1.57f,1.57f );
    }

    MercuryScreen::Update( dTime );
}

void ScreenMapEditor::Render()
{
    MercuryPoint pAt;

    pAt.z = SIN(m_pCameraRot.y);
    float fProdA = (pAt.z*pAt.z);
    pAt.x = COS(m_pCameraRot.x) * SQRT(1-fProdA);
    pAt.y = SIN(m_pCameraRot.x) * SQRT(1-fProdA);
    
    MercuryPoint pUp = MercuryPoint( -COS(m_pCameraRot.x)*pAt.z,-SIN(m_pCameraRot.x)*pAt.z, SQRT(1-fProdA) );

    m_pCamera->SetPosition( m_pCameraPos );
    m_pCamera->SetTarget( m_pCameraPos + pAt );
    m_pCamera->SetUp( pUp );
    MercuryScreen::Render();
}

void ScreenMapEditor::LoadFile( const MString & sFilename )
{
    if ( !m_iWorldFile.Open( THEME.GetPathToFile( sFilename ), true, true ) || !m_iTightFile.Open( THEME.GetPathToFile( sFilename ), false, true ) )
    {
        NotifyMessage( "Failed to load file." );
        return;
    }

    m_bFileLoaded = true;
    m_bWorldLoaded = false;
    m_bObjectLoaded = false;
    m_sFilename = sFilename;

    MVector< MString > vsKeys;
    m_iTightFile.EnumerateKeys( vsKeys );
    m_tElems.SetupList( vsKeys );
    
    ClearOutArea();

    NotifyMessage( "Loaded file." );
}

void ScreenMapEditor::LoadWorld( const MString & sWorldname )
{
    MString sTmp;
    if ( !m_iTightFile.GetValue( sWorldname, "Gravity", sTmp ) )
    {
        NotifyMessage( "\"" + sWorldname + "\" does not describe a world." );
        return;
    }

    ClearOutArea();
    for ( unsigned i = 0; i < (unsigned int)m_iTightFile.GetValueI( sWorldname, "NumElements", 0 ); i++ )
    {
        MakeWorldPiece( i, sWorldname );
    }

    m_sEditingName = sWorldname;
    m_bWorldLoaded = true;
    m_bObjectLoaded = false;
    NotifyMessage( "Loaded World." );
}

void ScreenMapEditor::MakeWorldPiece( int i, const MString & sWorldname, int iTempSelect  )
{
        MString sPieceName = ssprintf( "Piece%d", i+1 );
        int iObjNum = GenerateObject( m_iTightFile.GetValueS( sWorldname, sPieceName ), iTempSelect );
        if ( iTempSelect >= 0 )
            iObjNum = iTempSelect;
        MercuryObject * oODE = m_vODEObjs[iObjNum];
        MercuryObject * oVis = m_vVisObjs[iObjNum];

        float fX = m_iTightFile.GetValueF( sWorldname, sPieceName+"X" );
        float fY = m_iTightFile.GetValueF( sWorldname, sPieceName+"Y" );
        float fZ = m_iTightFile.GetValueF( sWorldname, sPieceName+"Z" );
        float fRX = m_iTightFile.GetValueF( sWorldname, sPieceName+"RotX" );
        float fRY = m_iTightFile.GetValueF( sWorldname, sPieceName+"RotY" );
        float fRZ = m_iTightFile.GetValueF( sWorldname, sPieceName+"RotZ" );
        if ( oODE )
        {
            oODE->SetPosition( MercuryPoint( fX, fY, fZ ) );
            oODE->SetRot( MercuryPoint( fRX, fRY, fRZ ) );
        }
        if ( oVis )
        {
            oVis->SetPosition( MercuryPoint( fX, fY, fZ ) );
            oVis->SetRot( MercuryPoint( fRX, fRY, fRZ ) );
        }
}

void ScreenMapEditor::LoadObject( const MString & sObjectname )
{
    MString sTmp;
    if ( m_iTightFile.GetValue( sObjectname, "Gravity", sTmp ) )
    {
        NotifyMessage( "\"" + sObjectname + "\" is already a world!" );
        return;
    }

    ClearOutArea();
    int iObjNum = GenerateObject( sObjectname );

    if ( iObjNum == -1 )
    {
        SetIni( sObjectname, "NumPieces", "0" );
        ClearOutArea();
        int iRetry = GenerateObject( sObjectname );
        if ( iRetry == -1 ) //FIXME (iRetry = -1)
        {
            NotifyMessage( "Object Creation Failed." );
            return;
        }
        m_sEditingName = sObjectname;
        m_bWorldLoaded = false;
        m_bObjectLoaded = true;
        NotifyMessage( "Object Created" );
    } 
    else
    {
        m_sEditingName = sObjectname;
        m_bWorldLoaded = false;
        m_bObjectLoaded = true;
        NotifyMessage( "Object Loaded." );
    }
}

void ScreenMapEditor::NotifyMessage( const MString & sMessage )
{
    m_tMessage.SetText( sMessage );
    m_tMessage.Tweening.StopTweening();
    m_tMessage.Tweening.ExecuteCommand( "ActiveCommand", PStack() );
}

int ScreenMapEditor::GenerateObject( MString sObjectIn, int iPieceToReplace )
{
    unsigned int iPieces = m_iWorldFile.GetValueI( sObjectIn, "NumPieces", 0, true );

    if ( iPieceToReplace != -1 )
    {
        m_fODEables.RemoveObject( m_vODEObjs[iPieceToReplace] );
        m_fVisibles.RemoveObject( m_vVisObjs[iPieceToReplace] );
    }

    m_vLastODE.resize( iPieces );
    m_vLastVis.resize( iPieces );

    MercuryObject * pODEObj = NULL;
    MercuryObject * pVisObj = NULL;

    for ( unsigned i = 0; i < iPieces; i++ )
    {
        m_vLastODE[i] = NULL;   //Reset these here incase something is wrong with the part.
        m_vLastVis[i] = NULL;

        MString sPName = ssprintf( "Piece%d", i+1 );
        int iType = m_iWorldFile.GetValueI( sObjectIn, sPName + "Type", -1 );
        if ( iType < 0 )
        {
            NotifyMessage( ssprintf( "Could not load piece #%d of object '%s'.", i, sObjectIn.c_str() ) );
            continue;
        }
        
        //Cores
        MString sFilename = m_iWorldFile.GetValueS( sObjectIn, sPName + "Filename" );
        bool    bUsesODE = m_iWorldFile.GetValueB( sObjectIn, sPName + "UsesODE" );
        bool    bVisible = m_iWorldFile.GetValueB( sObjectIn, sPName + "Visible" );
//      float   fDensity =  m_iWorldFile.GetValueF( sObjectIn, sPName + "Density" );
        
        //Optionals
        float   fX = m_iWorldFile.GetValueF( sObjectIn, sPName + "X" );
        float   fY = m_iWorldFile.GetValueF( sObjectIn, sPName + "Y" );
        float   fZ = m_iWorldFile.GetValueF( sObjectIn, sPName + "Z" );

        float   fRotX = m_iWorldFile.GetValueF( sObjectIn, sPName + "RotX" );
        float   fRotY = m_iWorldFile.GetValueF( sObjectIn, sPName + "RotY" );
        float   fRotZ = m_iWorldFile.GetValueF( sObjectIn, sPName + "RotZ" );

        if ( !bUsesODE && !bVisible )
            continue;

        //If we are both ODE and VISIBLE, do it twice, otherwise, once.
        for ( unsigned j = 0; j < ((bVisible&&bUsesODE)?2:1); j++ )
        {
            MercuryObject * co = NULL;

            //NOTE: The next few lines are exactly as they are found in MercuryODE.

            switch ( iType )
            {
            case 0:     //Sphere
                {
                MercuryShape * s = new MercuryShape;
                s->SetName( sObjectIn + sPName );
                s->Init();
                //Make a sphere with stacks/slices based on the INI file
                s->MakeSphere(  m_iWorldFile.GetValueI( sObjectIn, sPName + "Stacks", 6 ),
                                m_iWorldFile.GetValueI( sObjectIn, sPName + "Slices", 12 ) );
                
                //Load the PNG file based on the theme
                s->LoadImage( THEME.GetPathToGraphic( sFilename ) );

                //Set all other information for the sphere here
                float fRadius = m_iWorldFile.GetValueF( sObjectIn, sPName + "Radius", 1 );
                s->SetScale( MercuryPoint( fRadius, fRadius, fRadius ) );

                //Put our sphere in the vector of objects so it gets deleted in the end.
                co = s;
                break;
                }
            case 1:     //Cylinder
                {
                    //For info, refer to sphere
                MercuryShape * s = new MercuryShape;
                s->SetName( sPName + sObjectIn );
                s->Init();
                s->MakeCylinder(m_iWorldFile.GetValueI( sObjectIn, sPName + "Stacks", 6 ),
                                m_iWorldFile.GetValueI( sObjectIn, sPName + "Slices", 12 ) );
                s->LoadImage( THEME.GetPathToGraphic( sFilename ) );
                float fRadius = m_iWorldFile.GetValueF( sObjectIn, sPName + "Radius", 1 );
                float fLength = m_iWorldFile.GetValueF( sObjectIn, sPName + "Length", 1 );
                s->SetScale( MercuryPoint( fRadius, fRadius, fLength ) );
                co = s;
                break;
                }
            case 2:
                {
                    //For info, refer to sphere
                MercuryShape * s = new MercuryShape;
                s->SetName( sPName + sObjectIn );
                s->Init();
                s->MakeBox( );
                s->LoadImage( THEME.GetPathToGraphic( sFilename ) );
                s->SetScaleX( m_iWorldFile.GetValueF( sObjectIn, sPName + "LengthX", 1 ) );
                s->SetScaleY( m_iWorldFile.GetValueF( sObjectIn, sPName + "LengthY", 1 ) );
                s->SetScaleZ( m_iWorldFile.GetValueF( sObjectIn, sPName + "LengthZ", 1 ) );
                co = s;
                break;
                }
            case 3: //Model
                {
                    //Refer to sphere
                MercuryLoadableModel * s = new MercuryLoadableModel();
                s->SetName( sPName + sObjectIn );
                s->Init();
                s->Load( THEME.GetPathToModel( sFilename ) );
                s->SetScaleX( m_iWorldFile.GetValueF( sObjectIn, sPName + "LengthX", 1 ) );
                s->SetScaleY( m_iWorldFile.GetValueF( sObjectIn, sPName + "LengthY", 1 ) );
                s->SetScaleZ( m_iWorldFile.GetValueF( sObjectIn, sPName + "LengthZ", 1 ) );
                co = s;
                break;
                }
            };

            if ( !co )
            {
                NotifyMessage( "Warning: Could not load ["+sObjectIn+"]:"+sPName );
                continue;
            }
            co->SetX(fX);
            co->SetY(fY);
            co->SetZ(fZ);
            co->SetRotX(fRotX);
            co->SetRotY(fRotY);
            co->SetRotZ(fRotZ);

            if ( bUsesODE && ( j == 0 ) )
            {
                //ODE
                if ( !pODEObj )
                    pODEObj = new MercuryObject;
                pODEObj->SetName( "AddedODE" );
                pODEObj->Init();
                pODEObj->AddObject( co, true );
                m_vLastODE[i] = co;
            } 
            else 
            {
                //Visible
                if ( !pVisObj )
                    pVisObj = new MercuryObject;
                pVisObj->SetName( "AddedVisible" );
                pVisObj->Init();
                pVisObj->AddObject( co, true );
                m_vLastVis[i] = co;
            }
        }
    }

    if ( iPieceToReplace == -1 )
    {
        m_vODEObjs.push_back( pODEObj );
        m_vVisObjs.push_back( pVisObj );
    } else {
        m_vODEObjs[iPieceToReplace] = pODEObj;
        m_vVisObjs[iPieceToReplace] = pVisObj;
    }

    if ( pODEObj )
        m_fODEables.AddObject( pODEObj, true );

    if ( pVisObj )
        m_fVisibles.AddObject( pVisObj, true );

    return m_vODEObjs.size()-1;
}

float ScreenMapEditor::CameraDistance()
{
    MercuryPoint pObject;
    if ( GetSelectedHandleVis() ) pObject = GetSelectedHandleVis()->GetPosition();
    if ( GetSelectedHandleODE() ) pObject = GetSelectedHandleODE()->GetPosition();

    pObject = m_pCameraPos - pObject;
    return pObject.Magnitude();
}

void ScreenMapEditor::ClearOutArea()
{
    unsigned i;
    for ( i = 0; i < m_vODEObjs.size(); i++ )
        m_fODEables.RemoveObject( m_vODEObjs[i] );

    m_vODEObjs.resize(0);

    for ( i = 0; i < m_vVisObjs.size(); i++ )
        m_fVisibles.RemoveObject( m_vVisObjs[i] );

    m_vVisObjs.resize(0);

    m_pOverlay.SetObject( NULL, 0, 0 );
    m_oSelectedPart = NULL;
}

void ScreenMapEditor::Message( int Message, PStack & data, const MString &name )
{
    MercuryScreen::Message( Message, data, name );

    if ( m_pPrompt.m_bPromptingForText )
    {
        m_pPrompt.Message( Message, data, name );
        return;
    }

    switch ( Message )
    {
    case MC_INPUTMAPPED:
    case MC_INPUTUNMAPPED:
        if ( data.PeekItem( 0 ).GetValueI() != 0 )
            break;
        if ( data.PeekItem( 2 ).GetValueI() == IET_RELEASE )
            break;
        switch ( data.PeekItem( 1 ).GetValueI() )
        {
        case 'b':
            if ( m_bWorldLoaded )
                if ( SelectedObject() >= 0 && SelectedObject() < (int)m_vODEObjs.size() )
                {
                    MString sPName = ssprintf( "Piece%dBodied", SelectedObject()+1 );
                    bool bDidHaveBody = m_iTightFile.GetValueB( m_sEditingName, sPName );

                    SetIni( m_sEditingName, sPName, ssprintf( "%d", !bDidHaveBody ) );
                    SelectObject( SelectedObject() );   //Refresh any necessiary data.
                }
                else
                    NotifyMessage( "No piece selected." );
            else
                NotifyMessage( "No World loaded." );
            break;
        case 'e':
            if ( m_bObjectLoaded )
                m_pPrompt.PromptForText( MC_RESPDensity, this, "Enter Object Density", m_iTightFile.GetValueS( m_sEditingName, ssprintf( "Piece%dDensity", SelectedObject()+1 ) ), true );
            else
                NotifyMessage( "No object loaded." );
            break;
        case 'f':
            if ( m_bObjectLoaded )
                m_pPrompt.PromptForText( MC_RESPFilename2, this, "Enter Object Filename", m_iTightFile.GetValueS( m_sEditingName, ssprintf( "Piece%dFilename", SelectedObject()+1 ) ), true );
            else
                NotifyMessage( "No object loaded." );
            break;
        case 'g':
            m_pPrompt.PromptForText( MC_RESPJumpToSel, this, "Enter Object # to jump to.", ssprintf("%d",SelectedObject()), true );
            break;
        case 'i':
            //this is counting both down and up, it should only count one of the two
            if ( !m_bFileLoaded )
                NotifyMessage( "You must first load a file." );
            else
            {
                m_bShowingElems = !m_bShowingElems;
                if ( m_bShowingElems )
                {
                    m_tElems.Tweening.FinishTweening();
                    m_tElems.Show();
                }
                else
                {
                    m_tElems.Tweening.FinishTweening();
                    m_tElems.Hide();
                }
            }
            break;
        case 'j':
            if ( m_bObjectLoaded )
                m_pPrompt.PromptForText( MC_RESPLength, this, "Enter Object Length", m_iTightFile.GetValueS( m_sEditingName, ssprintf( "Piece%dLength", SelectedObject()+1 ) ) );
            else
                NotifyMessage( "No object loaded." );
            break;
        case 'k':
            if ( m_bObjectLoaded )
                if ( m_iTightFile.GetValueI( m_sEditingName, ssprintf( "Piece%iType", SelectedObject() + 1 ) ) < 2 )
                    m_pPrompt.PromptForText( MC_RESPRadius, this, "Enter Object Radius", m_iTightFile.GetValueS( m_sEditingName, ssprintf( "Piece%dRadius", SelectedObject()+1 ) ), true );
                else
                {
                    MString sPName = ssprintf( "Piece%iLength", SelectedObject() + 1 );
                    MString sInitial =  m_iTightFile.GetValueS( m_sEditingName, sPName + "X" ) + "," + 
                                        m_iTightFile.GetValueS( m_sEditingName, sPName + "Y" ) + "," + 
                                        m_iTightFile.GetValueS( m_sEditingName, sPName + "Z" );
                    m_pPrompt.PromptForText( MC_RESPScale, this, "Enter Object Scale x,y,z", sInitial, true );
                }
            else
                NotifyMessage( "No object loaded." );
            break;
        case 'l':
            m_pPrompt.PromptForText( MC_RESPFilename, this, "Enter Filename to Load", "myworld.ini", true );
            break;
        case 'n':
            if ( m_bWorldLoaded )
                m_pPrompt.PromptForText( MC_NewObjectName, this, "Enter new type for object.", "", true );
            else if ( m_bObjectLoaded )
            {
                MercuryShape * c = new MercuryShape;
                c->SetName( m_sEditingName+ssprintf("AddedObj%d",m_vLastODE.size()+2) );
                c->MakeSphere();
                m_vLastODE.push_back( NULL );
                m_vLastVis.push_back( c );

                if ( m_vVisObjs.size() < 1 )
                    m_vVisObjs.resize( 1 );
                if ( !m_vVisObjs[0] )
                    m_vVisObjs[0] = new MercuryObject;

                m_vVisObjs[0]->AddObject( c, true );

                SelectObject( m_vLastVis.size() - 1 );

                SetIni( m_sEditingName, ssprintf( "Piece%dType", m_vLastODE.size() ), "0" );
                SetIni( m_sEditingName, ssprintf( "Piece%dVisible", m_vLastODE.size() ), "1" );
                SetIni( m_sEditingName, ssprintf( "Piece%dUsesODE", m_vLastODE.size() ), "0" );
                SetIni( m_sEditingName, "NumPieces", ssprintf( "%ld", m_iTightFile.GetValueI( m_sEditingName, "NumPieces" ) + 1 ) );
                NotifyMessage( "Piece Created." );
            }
            else
                NotifyMessage( "You must already have an object or world loaded to do this." );
            break;
        case 'o':
            if ( !m_bFileLoaded )
                NotifyMessage( "You must first load a file." );
            else
                m_pPrompt.PromptForText( MC_RESPObjectname, this, "Enter Object to Load/Create.", "", true );
            break;
        case 'r':
            m_pCameraRot = MercuryPoint( 0, 0, 0 );
            m_pCameraPos = MercuryPoint( -100, 0, 0);
            NotifyMessage( "Camera Reset." );
            break;
        case 's':
            if ( m_iTightFile.Save() )
                NotifyMessage( "Save Successful." );
            else
                NotifyMessage( "Save Failed." );
            break;
        case 't':
            if ( m_bObjectLoaded )
                m_pPrompt.PromptForText( MC_RESPType, this, "Enter Type Number (0:Sphere, 1:Cylinder, 2:Box, 3:Model)", m_iTightFile.GetValueS( m_sEditingName, ssprintf( "Piece%dType", SelectedObject()+1 ) ) );
            else
                NotifyMessage( "No object loaded." );
            break;
        case 'u':
            if ( m_bObjectLoaded )
                if ( SelectedObject() >= 0 && SelectedObject() < (int)m_vLastODE.size() )
                {
                    MString sPName = ssprintf( "Piece%dUsesODE", SelectedObject()+1 );
                    bool bDidUseODE = m_iTightFile.GetValueB( m_sEditingName, sPName );
                    if ( !m_vLastVis[SelectedObject()] && bDidUseODE )
                    {
                        NotifyMessage( "An object must be visible and/or be ODEized" );
                        break;
                    }

                    SetIni( m_sEditingName, sPName, ssprintf( "%d", !bDidUseODE ) );
                    if ( bDidUseODE )
                        m_vLastODE[SelectedObject()] = NULL;
                    else 
                        m_vLastODE[SelectedObject()] = m_vLastVis[SelectedObject()];
                    SelectObject( SelectedObject() );   //Refresh any necessiary data.
                }
                else
                    NotifyMessage( "No piece selected." );
            else
                NotifyMessage( "No object loaded." );
            break;
        case 'v':
            if ( m_bObjectLoaded )
            {
                if ( SelectedObject() >= 0 && SelectedObject() < (int)m_vLastODE.size() )
                {
                    MString sPName = ssprintf( "Piece%dVisible", SelectedObject()+1 );
                    bool bWasVisible = m_iTightFile.GetValueB( m_sEditingName, sPName );
                    if ( !m_vLastODE[SelectedObject()] && bWasVisible )
                    {
                        NotifyMessage( "An object must be visible and/or be ODEized" );
                        break;
                    }

                    SetIni( m_sEditingName, sPName, ssprintf( "%d", !bWasVisible ) );
                    if ( bWasVisible )
                        m_vLastVis[SelectedObject()] = NULL;
                    else 
                        m_vLastVis[SelectedObject()] = m_vLastODE[SelectedObject()];
                    SelectObject( SelectedObject() );   //Refresh any necessiary data.
                }
                else
                    NotifyMessage( "No piece selected." );
            }
            else if ( m_bWorldLoaded )
            {
                m_pPrompt.PromptForText( MC_RESPSetGravity, this, "Enter Gravity.", m_iTightFile.GetValueS( m_sEditingName, "Gravity" ), true );
            } else
                NotifyMessage( "You must either have a world or object loaded." );
            break;
        case 'w':
            if ( !m_bFileLoaded )
                NotifyMessage( "You must first load a world." );
            else
                m_pPrompt.PromptForText( MC_RESPWorldname, this, "Enter World to Load", "", true );
            break;
        case 127:
            {
            if ( SelectedObject() < 0 )
            {
                NotifyMessage( "No object selected.");
                return;
            }
            if ( (!m_bObjectLoaded) && (!m_bWorldLoaded) )
            {
                NotifyMessage( "No Object or World loaded." );
                return;
            }

            map< MString, MString > values;
            m_iTightFile.EnumerateValues( m_sEditingName, values );
            int iNumInFile = 0;
            
            if ( m_bWorldLoaded )
                iNumInFile = m_vODEObjs.size();
            else if ( m_bObjectLoaded )
                iNumInFile = m_vLastODE.size();

            for ( int i = SelectedObject(); i < iNumInFile; i++ )
            {
                MString sPrefix = ssprintf( "Piece%d", i+1 );
                map< MString, MString >::iterator t = values.begin();

                while ( t != values.end() )
                {
                    MString cur = t->first;
                    if ( cur.substr( 0, sPrefix.length() ).compare( sPrefix ) == 0 )
                    {
                        m_iTightFile.RemoveValue( m_sEditingName, (t->first) );
                        m_iWorldFile.RemoveValue( m_sEditingName, (t->first) );
                    }
                    t++;
                }

                t = values.begin();
                MString sPrefix2 = ssprintf( "Piece%d", i+2 );
                
                while ( t != values.end() )
                {
                    if ( ((t->first).substr( 0, sPrefix2.length() )).compare( sPrefix2 ) == 0 )
                    {
                        MString sOnS = (t->first).substr( sPrefix2.length() );
                        SetIni( m_sEditingName, sPrefix + sOnS, t->second );
                    }
                    t++;
                }
            }

            if ( m_bWorldLoaded )
            {
                SetIni( m_sEditingName, "NumElements", ssprintf( "%d", m_vODEObjs.size() - 1 ) );
                if ( m_vODEObjs[SelectedObject()] )
                    m_fODEables.RemoveObject( m_vODEObjs[SelectedObject()] );
                if ( m_vVisObjs[SelectedObject()] )
                    m_fVisibles.RemoveObject( m_vVisObjs[SelectedObject()] );
                m_vODEObjs.erase( m_vODEObjs.begin() + SelectedObject() );
                m_vVisObjs.erase( m_vVisObjs.begin() + SelectedObject() );
            } 
            else if ( m_bObjectLoaded )
            {
                SetIni( m_sEditingName, "NumPieces", ssprintf( "%d", m_vLastODE.size() - 1 ) );
                RewriteCurrent();
            } 
            }
        case 278:           //Home
            SelectObject( 0 );
            break;
        case 279:           //End
            SelectObject( GetNumObjects() - 1 );
            break;
        case 280:           //PgUp
            if ( SelectedObject() > 0 )
                SelectObject( SelectedObject() - 1 );
            break;
        case 281:           //PgDn
            if ( SelectedObject() < ( GetNumObjects() - 1 ) )
                SelectObject( SelectedObject() + 1 );
            break;
        case 8:             //Back Space
            SelectObject();
            break;
        };
        break;
    case MC_RESPFilename:
        if ( data.PeekItem( 1 ).GetValueI() )
            LoadFile( data.PeekItem( 0 ).GetValueS() );
        break;
    case MC_RESPWorldname:
        if ( data.PeekItem( 1 ).GetValueI() )
            LoadWorld( data.PeekItem( 0 ).GetValueS() );
        break;
    case MC_RESPObjectname:
        if ( data.PeekItem( 1 ).GetValueI() )
            LoadObject( data.PeekItem( 0 ).GetValueS() );
        break;
    case MC_RESPJumpToSel:
        if ( data.PeekItem( 1 ).GetValueI() )
            SelectObject(( data.PeekItem( 0 ).GetValueI() ));
        break;
    case MC_RESPSetGravity:
        if ( data.PeekItem( 1 ).GetValueI() )
            SetIni( m_sEditingName, "Gravity", data.PeekItem( 0 ).GetValueS() );
        break;
    case MC_RESPFilename2:
        if ( data.PeekItem( 1 ).GetValueI() )
        {
            SetIni( m_sEditingName, ssprintf( "Piece%dFilename", SelectedObject()+1 ), data.PeekItem( 0 ).GetValueS() );
            RewriteCurrent();
        }
        break;
    case MC_RESPDensity:
        if ( data.PeekItem( 1 ).GetValueI() )
            SetIni( m_sEditingName, ssprintf( "Piece%dDensity", SelectedObject()+1 ), data.PeekItem( 0 ).GetValueS() );
        break;
    case MC_RESPType:
        if ( data.PeekItem( 1 ).GetValueI() )
        {
            SetIni( m_sEditingName, ssprintf( "Piece%dType", SelectedObject()+1 ), data.PeekItem( 0 ).GetValueS() );
            RewriteCurrent();
        }
        break;
    case MC_RESPLength:
        if ( data.PeekItem( 1 ).GetValueI() )
        {
            SetIni( m_sEditingName, ssprintf( "Piece%dLength", SelectedObject()+1 ), data.PeekItem( 0 ).GetValueS() );
            RewriteCurrent();
        }
        break;
    case MC_RESPRadius:
        if ( data.PeekItem( 1 ).GetValueI() )
        {
            SetIni( m_sEditingName, ssprintf( "Piece%dRadius", SelectedObject()+1 ), data.PeekItem( 0 ).GetValueS() );
            RewriteCurrent();
        }
        break;
    case MC_RESPScale:
        if ( data.PeekItem( 1 ).GetValueI() )
        {
            float x,y,z;
            int ret = sscanf( data.PeekItem( 0 ).GetValueS().c_str(), "%f,%f,%f", &x, &y, &z );
            if ( ret != 3 )
            {
                NotifyMessage( "Invalid format." );
                break;
            }
            SetIni( m_sEditingName, ssprintf( "Piece%dLengthX", SelectedObject()+1 ), ssprintf( "%f", x ) );
            SetIni( m_sEditingName, ssprintf( "Piece%dLengthY", SelectedObject()+1 ), ssprintf( "%f", y ) );
            SetIni( m_sEditingName, ssprintf( "Piece%dLengthZ", SelectedObject()+1 ), ssprintf( "%f", z ) );
            RewriteCurrent();
        }
        break;
    case MC_NewObjectName:
        if ( data.PeekItem( 1 ).GetValueI() )
        {
            int ret = GenerateObject( data.PeekItem( 0 ).GetValueS() );
            if ( ret < 0 )
                break;
            SetIni( m_sEditingName, "NumElements", ssprintf( "%ld", m_iTightFile.GetValueI( m_sEditingName, "NumElements" ) + 1 ) );
            SetIni( m_sEditingName, ssprintf( "Piece%d", ret+1), data.PeekItem( 0 ).GetValueS() );
            SelectObject( ret );
            RewriteCurrent();
        }
        break;
    }
}

int ScreenMapEditor::SelectObject( int ObjectNumber )
{
    MercuryObject * oOldObject = NULL;
    MercuryObject * oNewObject = NULL;
    if ( m_bObjectLoaded )
    {
        if ( m_iSelectedPart >= 0 && m_iSelectedPart < (int)m_vLastODE.size() )
        {
            if ( m_vLastODE[m_iSelectedPart] != NULL )
                oOldObject = m_vLastODE[m_iSelectedPart];
            else if ( m_vLastVis[m_iSelectedPart] != NULL )
                oOldObject = m_vLastVis[m_iSelectedPart];
        }
        
        if ( ObjectNumber >= 0 && ObjectNumber < (int)m_vLastODE.size() )
        {
            if ( m_vLastODE[ObjectNumber] != NULL )
                oNewObject = m_vLastODE[ObjectNumber];
            else if ( m_vLastVis[ObjectNumber] != NULL )
                oNewObject = m_vLastVis[ObjectNumber];
        } else
            return -1;
    }
    else if ( m_bWorldLoaded )
    {
        if ( m_iSelectedPart >= 0 && m_iSelectedPart < (int)m_vODEObjs.size() )
        {
            if ( m_vODEObjs[m_iSelectedPart] != NULL )
                oOldObject = m_vODEObjs[m_iSelectedPart];
            else if ( m_vVisObjs[m_iSelectedPart] != NULL )
                oOldObject = m_vVisObjs[m_iSelectedPart];
        }
        
        if ( ObjectNumber >= 0 && ObjectNumber < (int)m_vODEObjs.size() )
        {
            if ( m_vODEObjs[ObjectNumber] != NULL )
                oNewObject = m_vODEObjs[ObjectNumber];
            else if ( m_vVisObjs[ObjectNumber] != NULL )
                oNewObject = m_vVisObjs[ObjectNumber];
        } else
            return -1;
    }
    else
    {
        NotifyMessage( "No World or Object loaded." );
        return -1;
    }

    m_pOverlay.SetObject( oNewObject, 0, 0 );
    m_iSelectedPart = ObjectNumber;
    m_oSelectedPart = oNewObject;

    MString sAttributes = ssprintf( "%d", ObjectNumber );

    if ( m_bObjectLoaded )
    {
        if ( m_iTightFile.GetValueB( m_sEditingName, ssprintf( "Piece%dVisible", ObjectNumber+1 ) ) )
            sAttributes += " Visible";
        if ( m_iTightFile.GetValueB( m_sEditingName, ssprintf( "Piece%dUsesODE", ObjectNumber+1 ) ) )
            sAttributes += " UsesODE";
    }

    if ( m_bWorldLoaded )
    {
        if ( m_iTightFile.GetValueB( m_sEditingName, ssprintf( "Piece%dBodied", ObjectNumber+1 ) ) )
            sAttributes += " Bodied";
    }

    m_pOverlay.SetAttributes( sAttributes );

    MercuryColor c = MercuryColor( 1.0f,1.0f,1.0f,1.0f );
    if ( oOldObject != NULL )
        oOldObject->SetDiffuse( c );

    if( oNewObject != NULL )
        oNewObject->SetDiffuse( MercuryColor( 1,0,0,1 ) );

    return m_iSelectedPart;
}

void ScreenMapEditor::SetIni( const MString & key, const MString & value, const MString & data )
{
    m_iTightFile.SetValue( key, value, data );
    m_iWorldFile.SetValue( key, value, data );
}

void ScreenMapEditor::RewriteCurrent()
{
    int iTempSelect = SelectedObject();
    if ( m_bWorldLoaded )
    {
        MakeWorldPiece( iTempSelect, m_sEditingName, iTempSelect );
    //  ClearOutArea();
    //  GenerateObject( m_iTightFile.GetValueS( m_sEditingName, ssprintf( "Piece%d", iTempSelect+1 ) ), iTempSelect );
    }
    if ( m_bObjectLoaded )
    {
        ClearOutArea();
        GenerateObject( m_sEditingName );
    }
    SelectObject( iTempSelect );
}

int ScreenMapEditor::GetNumObjects()
{
    if (m_bObjectLoaded)
        return m_vLastVis.size();
    else if(m_bWorldLoaded)
        return m_vVisObjs.size();
    return -1;
}








/****************************** TEXT PROMPT **********************************/

void MercuryTextPrompt::Init()
{
    MercuryObject::Init();

    m_bPromptingForText = false;
    m_sTextInOverlay.SetName( "TextInOverlay" );
    m_sTextInOverlay.Init();
    m_sTextInOverlay.LoadImage( THEME.GetMetricS( GetName(), "TextInOverlay" ) );
    m_sTextInOverlay.Tweening.AddCommand( THEME.GetMetricS( GetName(), "OverlaySpriteOnCommand" ), MercuryTweenState::LOCAL, "OnCommand" );
    m_sTextInOverlay.Tweening.AddCommand( THEME.GetMetricS( GetName(), "OverlaySpriteOffCommand" ), MercuryTweenState::LOCAL, "OffCommand" );
    m_sTextInOverlay.SetHide( true );
    AddObject( &m_sTextInOverlay );

    m_tTextInOverlayPrompt.SetName( "TextInOverlayPrompt" );
    m_tTextInOverlayPrompt.Init();
    m_tTextInOverlayPrompt.SetFont( THEME.GetMetricS( GetName(), "Font" ) );
    m_tTextInOverlayPrompt.SetHide( true );
    m_tTextInOverlayPrompt.Tweening.AddCommand( THEME.GetMetricS( GetName(), "OverlayPromptOnCommand" ), MercuryTweenState::LOCAL, "OnCommand" );
    m_tTextInOverlayPrompt.Tweening.AddCommand( THEME.GetMetricS( GetName(), "OverlayPromptOffCommand" ), MercuryTweenState::LOCAL, "OffCommand" );
    AddObject( &m_tTextInOverlayPrompt );

    m_tTextInOverlayText.SetName( "TextInOverlayText" );
    m_tTextInOverlayText.Init();
    m_tTextInOverlayText.Tweening.AddCommand( THEME.GetMetricS( GetName(), "OverlayTextOnCommand" ), MercuryTweenState::LOCAL, "OnCommand" );
    m_tTextInOverlayText.Tweening.AddCommand( THEME.GetMetricS( GetName(), "OverlayTextOffCommand" ), MercuryTweenState::LOCAL, "OffCommand" );
    m_tTextInOverlayText.SetFont( THEME.GetMetricS( GetName(), "Font" ) );
    m_tTextInOverlayText.SetHide( true );
    AddObject( &m_tTextInOverlayText );
}

void MercuryTextPrompt::Update( const float dTime )
{
    m_tTextInOverlayText.SetText( m_sPromptedText );
    MercuryObject::Update( dTime );
}

void MercuryTextPrompt::Message( int Message, PStack & data, const MString & name )
{
    if ( m_bPromptingForText )
    {
        switch ( Message )
        {
        case MC_INPUTMAPPED:
        case MC_INPUTUNMAPPED:
            if ( data.PeekItem(2).GetValueI() == IET_DOWN && data.PeekItem(0).GetValueI() == 0 )    //Make sure we're pressing DOWN on the KEYBOARD
            {
                char cPress = data.PeekItem(1).GetValueI();
                if ( cPress == 8 && !m_sPromptedText.empty() )
                    m_sPromptedText = m_sPromptedText.substr( 0, m_sPromptedText.length() - 1 );
                else if ( cPress == 27 && m_bAllowCancel )
                {
                    m_bPromptingForText = false;
                    m_tTextInOverlayPrompt.Tweening.ExecuteCommand( "OffCommand", PStack() );
                    m_tTextInOverlayText.Tweening.ExecuteCommand( "OffCommand", PStack() );
                    m_sTextInOverlay.Tweening.ExecuteCommand( "OffCommand", PStack() );
                    PStack ToSend;
                    ToSend.PushItem( PSElement( false ) );
                    ToSend.PushItem( PSElement(m_sPromptedText ) );
                    m_objNotify->Message( m_iMessageWhenDone, ToSend, sPromptedInput );
                }
                else
                {
                    cPress = KeyToChar( data.PeekItem(1).GetValueI(), INPUTMAN->IsButtonDown( button_shift ) );
                    if ( cPress == 10 )
                    {
                        m_tTextInOverlayPrompt.Tweening.ExecuteCommand( "OffCommand", PStack() );
                        m_tTextInOverlayText.Tweening.ExecuteCommand( "OffCommand", PStack() );
                        m_sTextInOverlay.Tweening.ExecuteCommand( "OffCommand", PStack() );
                        m_bPromptingForText = false;
                        PStack ToSend;
                        ToSend.PushItem( PSElement( true ) );
                        ToSend.PushItem( PSElement(m_sPromptedText ) );
                        m_objNotify->Message( m_iMessageWhenDone, ToSend, sPromptedInput );
                    } else if ( cPress != 0 )
                        if ( m_bSingleChar )
                        {
                            m_tTextInOverlayPrompt.Tweening.ExecuteCommand( "OffCommand", PStack() );
                            m_tTextInOverlayText.Tweening.ExecuteCommand( "OffCommand", PStack() );
                            m_sTextInOverlay.Tweening.ExecuteCommand( "OffCommand", PStack() );
                            m_bPromptingForText = false;
                            PStack ToSend;
                            ToSend.PushItem( PSElement( true ) );
                            ToSend.PushItem( PSElement( MString( cPress ) ) );
                            m_objNotify->Message( m_iMessageWhenDone, ToSend, sPromptedInput );
                        } else
                            m_sPromptedText+= cPress;
                }
            }
            break;
        }
    }
    MercuryObject::Message( Message, data, name );
}

void MercuryTextPrompt::PromptForText( int iMessageWhenDone, MercuryScreen * Notifier, const MString &sPrompt, 
        const MString &sDefaultText, bool bAllowCancel, bool bSingleChar )
{
    m_bAllowCancel = bAllowCancel;
    m_objNotify = Notifier;
    m_iMessageWhenDone = iMessageWhenDone;
    m_bSingleChar = bSingleChar;
    m_bPromptingForText = true;
    m_sPromptedText = sDefaultText;
    m_tTextInOverlayPrompt.SetText( sPrompt );
    m_tTextInOverlayPrompt.SetHide( false );
    m_tTextInOverlayPrompt.Tweening.ExecuteCommand( "OnCommand", PStack() );
    m_tTextInOverlayText.SetText( sDefaultText );
    m_tTextInOverlayText.SetHide( false );
    m_tTextInOverlayText.Tweening.ExecuteCommand( "OnCommand", PStack() );
    m_sTextInOverlay.SetHide( false );
    m_sTextInOverlay.Tweening.ExecuteCommand( "OnCommand", PStack() );
}

/****************************** CONTROL PANE *********************************/

void AddControlPaneObject( MercuryObject * parent, MercuryText * child, const char * name )
{
    child->SetName( parent->GetName() + name );
    child->Init();
    child->SetFont( THEME.GetMetricS( parent->GetName(), "Font" ) );
    child->Tweening.AddCommand( THEME.GetMetricS( parent->GetName(), MString( name ) + "OnCommand" ) );
    parent->AddObject( child );
}

void ObjectControlPane::Init()
{
    MercuryObject::Init();

//  SetProjectionType( ORTHOGRAPHIC );
    m_objWatch = NULL;
    m_objMimic.SetName( GetName() + "MimicHolder" );
    m_objMimic.Init();
    m_objMimic.SetPosition( MercuryPoint(-1,-1,-1) );
    m_objMimic.SetScale( MercuryPoint(-1,-1,-1) );
    m_objMimic.SetRot( MercuryPoint(-1,-1,-1) );

//  m_sBackground.SetProjectionType( ORTHOGRAPHIC );
    m_sBackground.SetName( GetName() + "Background" );
    m_sBackground.Init();
    m_sBackground.LoadImage( THEME.GetMetricS( GetName(), "Background" ) );
    m_sBackground.Tweening.AddCommand( THEME.GetMetricS( GetName(), "BackgroundOnCommand" ) );
    AddObject( &m_sBackground );

    AddControlPaneObject( this, &m_tName, "Name" );
    AddControlPaneObject( this, &m_tPosition, "Position" );
    AddControlPaneObject( this, &m_tScale, "Scale" );
    AddControlPaneObject( this, &m_tRotation, "Rotation" );
    AddControlPaneObject( this, &m_tAttributes, "Attributes" );

//  SetHide(1);

    Tweening.AddCommand( THEME.GetMetricS( GetName(), "PaneOn", "x,%1;y,%2" ), MercuryTweenState::LOCAL, "PaneOn" );
    Tweening.AddCommand( THEME.GetMetricS( GetName(), "PaneOff", "x,%1;y,%2" ), MercuryTweenState::LOCAL, "PaneOff" );
}

void ObjectControlPane::Update( const float dTime )
{
    if ( m_objWatch )
    {
        if ( m_objMimic.GetPosition() != m_objWatch->GetPosition() )
        {
            MercuryPoint p = m_objWatch->GetPosition();
            m_tPosition.SetText( ssprintf( "(%.4f, %.4f, %.4f)", p.GetX(), p.GetY(), p.GetZ() ) );
        //  m_tPosition.Tweening.AddCommand( THEME.GetMetricS( m_tPosition.GetName(), "Change" ) ); 
            m_objMimic.SetPosition( m_objWatch->GetPosition() );
        }
        if ( m_objMimic.GetScale() != m_objWatch->GetScale() )
        {
            MercuryPoint p = m_objWatch->GetScale();
            m_tScale.SetText( ssprintf( "(%.4f, %.4f, %.4f)", p.GetX(), p.GetY(), p.GetZ() ) );
        //  m_tScale.Tweening.AddCommand( THEME.GetMetricS( m_tScale.GetName(), "Change" ) ); 
            m_objMimic.SetScale( m_objWatch->GetScale() );
        }
        if ( m_objMimic.GetRot() != m_objWatch->GetRot() )
        {
            MercuryPoint p = m_objWatch->GetRot();
            m_tRotation.SetText( ssprintf( "(%.4f, %.4f, %.4f)", p.GetX(), p.GetY(), p.GetZ() ) );
        //  m_tRotation.Tweening.AddCommand( THEME.GetMetricS( m_tRotation.GetName(), "Change" ) ); 
            m_objMimic.SetRot( m_objWatch->GetRot() );
        }
    }
    MercuryObject::Update( dTime );
}

void ObjectControlPane::SetObject( MercuryObject * obj, int LX, int LY )
{
    if ( !obj && m_objWatch )
    {
        Tweening.StopTweening();
        Tweening.ExecuteCommand( "PaneOff", PStack() );
    }
    else if ( obj != m_objWatch  )
    {
        Tweening.StopTweening();
        Tweening.ExecuteCommand( "PaneOn", PStack( PSElement( LX ), PSElement( LY ) ) );
        m_tName.SetText( obj->GetName() );
    } 

    m_objWatch = obj;
    m_tAttributes.SetText( "" );
}

void ObjectControlPane::SetAttributes( const MString & sAttributes )
{
    m_tAttributes.SetText( sAttributes );
}

void TextList::Init()
{
    MercuryObject::Init();
    Tweening.AddCommand( THEME.GetMetricS( GetName(), "TextSetupCommand" ), MercuryTweenState::GLOBAL, "SidebarTextOn" );
}

void TextList::SetupList( MVector< MString > &vsList )
{
    Tweening.AddCommand( THEME.GetMetricS( GetName(), "OffCommand" ) );
    Tweening.FinishTweening();

    m_sBG.SetName( GetName() + "Overlay" );
    m_sBG.Init();
    m_sBG.LoadImage( THEME.GetMetricS( GetName(), "Overlay" ) );
    m_sBG.Tweening.AddCommand( THEME.GetMetricS( GetName(), "GraphicOnCommand" ) );
    AddObject( &m_sBG );

    float dY = THEME.GetMetricF( GetName(), "DeltaY" );
    float cY = THEME.GetMetricF( GetName(), "StartY" );

    UnsetupList();

    m_vTexts.resize( vsList.size() );
    for ( unsigned i = 0; i < vsList.size(); i++ )
    {
        if ( vsList[i] == "AdditionalFiles" )
            continue;
        MercuryText* t = new MercuryText;
        m_vTexts[i] = t;
        t->SetName( ssprintf( "%sText%d", GetName().c_str(), i+1 ) );
        t->Init();
        t->SetFont( THEME.GetMetricS( GetName(), "Font" ) );
        t->Tweening.ExecuteCommand( "SidebarTextOn", PStack( PSElement( cY ) ) );
        t->SetText(vsList[i]);
        AddObject( t, true );
        cY += dY;
    }
}

TextList::~TextList()
{
    UnsetupList();
}

void TextList::UnsetupList()
{
    for ( unsigned i = 0; i < m_vTexts.size(); i++ )
        RemoveObject( m_vTexts[i] );

    m_vTexts.resize(0);
}

void TextList::Show()
{
    Tweening.AddCommand( THEME.GetMetricS( GetName(), "OnCommand" ) );
}

void TextList::Hide()
{
    Tweening.AddCommand( THEME.GetMetricS( GetName(), "OffCommand" ) );
}

/* 
 * Copyright (c) 2006 Charles Lohr
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or
 * without modification, are permitted provided that the following
 * conditions are met:
 *  -   Redistributions of source code must retain the above
 *      copyright notice, this list of conditions and the following disclaimer.
 *  -   Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in
 *      the documentation and/or other materials provided with the distribution.
 *  -   Neither the name of the Mercury Engine nor the names of its
 *      contributors may be used to endorse or promote products derived from
 *      this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

---

Hosted by