ScreenCopper.cpp

Go to the documentation of this file.

#include "global.h"
#include "MercuryTheme.h"
#include "ScreenCopper.h"
#include "MercuryInput.h"
#include "MercuryDisplay.h"
#include "MercuryUtil.h"
#include "MercuryLog.h"

#include "MercuryObjectFactory.h"
REGISTER_SCREEN_CLASS( ScreenCopper )
KeyMappingWithCode( button_showmenu, "0-27" );

#define     MC_INPUT            2
#define     MC_LOADOVERLAY      3
#define     MC_UNLOADOVERLAY    4

void ScreenCopper::Init()
{
    MercuryScreen::Init();
//  SetProjectionType(ORTHOGRAPHIC);

    m_sprCursor.SetName( m_name + "::Base::Cursor" );
    m_sprCursor.Init();
    m_sprCursor.LoadImage( THEME.GetMetricS( m_name, "Cursor" ) );
    m_sprCursor.SetDrawOrder(100);
    AddOrthoObject( &m_sprCursor );

    MString sMainWindowName = THEME.GetMetricS( m_name, "MainWindowName", "" );
    m_wndMain = GetCopperByClass( "CopperWindowLoadable", sMainWindowName );
    m_wndMain->Init( NULL, sMainWindowName );
    m_wndMain->SetHeight( DISPLAY->GetDimensions().height );
    m_wndMain->SetWidth( DISPLAY->GetDimensions().width );
    AddOrthoObject( m_wndMain );

    //Get ALL Input regardless of mapped/unmapped nature
    RegisterMessage( MC_INPUT, "unmappedinput" );
    RegisterMessage( MC_INPUT, "mappedinput" );
    RegisterMessage( MC_LOADOVERLAY, "CopperLoadOverlay" );
    RegisterMessage( MC_UNLOADOVERLAY, "CopperUnloadOverlay" );

    m_wndOverlay = NULL;

    this->Tweening.AddCommand(THEME.GetMetricS(m_name, "OnCommand" ));
}

ScreenCopper::~ScreenCopper()
{
    SAFE_DELETE( m_wndMain );
    SAFE_DELETE( m_wndOverlay );
}

void ScreenCopper::Update( const float dTime )
{
//  if ( GetHide() )
    //  return;

    int x,y,dX,dY;
    INPUTMAN->GetCursorPosition( x, y );
    dX = x - m_iOldCoreX;
    dY = y - m_iOldCoreY;
    m_iOldCoreX = x;
    m_iOldCoreY = y;

    if ( ( dY != 0 ) || ( dX != 0 ) )
    {
        m_iOldX += dX;
        m_iOldY += dY;
        m_iOldX = Clamp( m_iOldX, 0, int(DISPLAY->GetBasedDimensions().width)-1 );
        m_iOldY = Clamp( m_iOldY, 0, int(DISPLAY->GetBasedDimensions().height)-1 );

        m_sprCursor.SetX( float(m_iOldX) );
        m_sprCursor.SetY( float(m_iOldY) );
        
        CopperMouseEvent c;
        c.pType = CopperMouseEvent::MOUSE_MOVE;
        c.x = m_iOldX;
        c.y = m_iOldY;
        if ( m_wndOverlay )
            m_wndOverlay->MouseEvent( c );
        m_wndMain->MouseEvent( c ); 
    }
    MercuryScreen::Update( dTime );
}

void ScreenCopper::Message( int Message, PStack & data, const MString & name )
{
    if ( Message == MC_INPUT )
    {
        InputMessageStruct c(data);

        //First check to see if we should be hiding/showing ourselves.
        if ( c.code == button_showmenu && c.type == IET_RELEASE )
            if ( GetHide() )
            {
                this->Tweening.StopTweening();
                this->Tweening.AddCommand(THEME.GetMetricS(m_name, "HideOff" ));
            }
            else
            {
                this->Tweening.StopTweening();
                this->Tweening.AddCommand(THEME.GetMetricS(m_name, "HideOn" ));
            }

        if ( GetHide() )
            return;
        
        //It's a mouse click
        if ( c.button > 0 && c.button < 3 )
        {
            CopperMouseEvent g;
            if ( c.type == IET_DOWN )
                g.pType = CopperMouseEvent::MOUSE_DOWN;
            else if ( c.type == IET_RELEASE )
                g.pType = CopperMouseEvent::MOUSE_UP;
            else
                return; //Bail, this isn't a normal button press type.
                
            g.x = m_iOldX;
            g.y = m_iOldY;
            bool bOverlayGotMouse = false;
            if ( m_wndOverlay )
                bOverlayGotMouse = m_wndOverlay->MouseEvent( g );
            if ( !bOverlayGotMouse || g.pType == CopperMouseEvent::MOUSE_UP )
                m_wndMain->MouseEvent( g ); 
            return;
        }

        //It's a key press
        CopperKeypress cuKP;
        cuKP.cLetter = c.button;
        if ( c.type == IET_DOWN )
            cuKP.pType = CopperKeypress::KEY_DOWN;
        if ( c.type == IET_RELEASE )
            cuKP.pType = CopperKeypress::KEY_UP;
        m_wndMain->KeyPress( cuKP );
        if ( m_wndOverlay )
            m_wndOverlay->KeyPress( cuKP );
    } else if ( Message == MC_LOADOVERLAY ) {
        if ( m_wndOverlay )
        {
            RemoveObject( m_wndOverlay );
            SAFE_DELETE( m_wndOverlay );
        }

        // The following code decodes the comma-delimited string for the data, so it will read [ElementName],[x],[y].
        MString sOverlayData = data.PeekItem(0).GetValueS();
        MString sOverlayWindowName;
        float sX = 0, sY = 0;

        int iBU = BytesUntil( sOverlayData.c_str(), ",", 0, sOverlayData.length(), 1 );

        if ( iBU >= 0 && iBU < (int)sOverlayData.length() )
        {
            sOverlayWindowName = sOverlayData.substr( 0, iBU );
            sOverlayData = sOverlayData.substr( iBU+1 );
            iBU = BytesUntil( sOverlayData.c_str(), ",", 0, sOverlayData.length(), 1 );
            if ( iBU >= 0 )
            {
                sX = (float)atoi( sOverlayData.substr( 0, iBU ).c_str() );
                sOverlayData = sOverlayData.substr( iBU+1 );
                if ( sOverlayData.length() > 0 )
                    sY = (float)atoi( sOverlayData.c_str() );
            }
        } else
            sOverlayWindowName = sOverlayData;

        m_wndOverlay = GetCopperByClass( "CopperWindowLoadable", sOverlayWindowName );
        m_wndOverlay->SetPosition( MercuryPoint( sX, sY, 0 ) );
        m_wndOverlay->Init( NULL, sOverlayWindowName );
        AddOrthoObject( m_wndOverlay );
    } else if ( Message == MC_UNLOADOVERLAY ) {
        if ( m_wndOverlay )
        {
            RemoveObject( m_wndOverlay );
            SAFE_DELETE( m_wndOverlay );
        }
    }
}

void ScreenCopper::Draw()
{
    MercuryScreen::Draw();
}

/* 
 * 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