CopperWindow.cpp

Go to the documentation of this file.

#include "CopperWindow.h"
#include "MercuryTheme.h"

std::map< MString, NewCopperFunction >  *ToMakeWindows;

CopperWindow::~CopperWindow()
{
    for ( unsigned i = 0; i < m_vWindows.size(); i++ )
        SAFE_DELETE( m_vWindows[i] );
}

void CopperWindow::Init( CopperWindow * pParent, const MString & sName )
{
    MercuryObject::Init();

    m_pParent = pParent;
    SetName( sName );
    m_iCurrentFocus = 0;
    m_iLastMouseWindow = -1;

    m_pBrdOverOn.Message = THEME.GetMetricS( sName, "MouseOverOnMessage" );
    m_pBrdOverOn.Data = THEME.GetMetricS( sName, "MouseOverOnData" );

    m_pBrdOverOff.Message = THEME.GetMetricS( sName, "MouseOverOffMessage" );
    m_pBrdOverOff.Data = THEME.GetMetricS( sName, "MouseOverOffData" );

    m_pBrdUpInTarget.Message = THEME.GetMetricS( sName, "MouseUpInTargetMessage" );
    m_pBrdUpInTarget.Data = THEME.GetMetricS( sName, "MouseUpInTargetData" );

    m_pBrdUpOutTarget.Message = THEME.GetMetricS( sName, "MouseUpOutTargetMessage" );
    m_pBrdUpOutTarget.Data = THEME.GetMetricS( sName, "MouseUpOutTargetData" );

    m_pBrdDown.Message = THEME.GetMetricS( sName, "MouseDownMessage" );
    m_pBrdDown.Data = THEME.GetMetricS( sName, "MouseDownData" );

    Tweening.AddCommand( THEME.GetMetricS( sName, "OnCommand" ) );
}

void CopperWindow::KeyPress( const CopperKeypress & pKeypress )
{   
    if ( m_vWindows.size() > 0 )
        m_vWindows[m_iCurrentFocus]->KeyPress( pKeypress );
}

bool CopperWindow::MouseEvent( const CopperMouseEvent & pMouseEvent )
{
    if ( pMouseEvent.pType == CopperMouseEvent::MOUSE_IN )
        m_pBrdOverOn.Broadcast();

    if ( pMouseEvent.pType == CopperMouseEvent::MOUSE_OUT )
        m_pBrdOverOff.Broadcast();

    if ( pMouseEvent.pType == CopperMouseEvent::MOUSE_DOWN )
        m_pBrdDown.Broadcast();

    if ( pMouseEvent.pType == CopperMouseEvent::MOUSE_UP )
    {
        if ( IsMouseEventOnTarget( pMouseEvent ) )
            m_pBrdUpInTarget.Broadcast();
        else
            m_pBrdUpOutTarget.Broadcast();

        for ( unsigned i = 0; i < m_vWindows.size(); i++ )
        {
            CopperMouseEvent pNewMouse = pMouseEvent;
            pNewMouse.x -= (int)m_vWindows[i]->GetX();
            pNewMouse.y -= (int)m_vWindows[i]->GetY();
            m_vWindows[i]->MouseEvent( pNewMouse );
        }
        return true;    //Since it doesn't actually matter
    }

    for ( unsigned i = 0; i < m_vWindows.size(); i++ )
    {
        CopperMouseEvent pNewMouse = pMouseEvent;
        pNewMouse.x -= (int)m_vWindows[i]->GetX();
        pNewMouse.y -= (int)m_vWindows[i]->GetY();
        if ( m_vWindows[i]->IsMouseEventOnTarget( pNewMouse ) )
        {
            m_vWindows[i]->MouseEvent( pNewMouse );

            if ( (unsigned)m_iLastMouseWindow != i )
            {
                pNewMouse.pType = CopperMouseEvent::MOUSE_OUT;
                if ( m_iLastMouseWindow >=0 && (unsigned)m_iLastMouseWindow < m_vWindows.size() )
                    m_vWindows[m_iLastMouseWindow]->MouseEvent( pNewMouse );
                pNewMouse.pType = CopperMouseEvent::MOUSE_IN;
                m_vWindows[i]->MouseEvent( pNewMouse );
                m_iLastMouseWindow = i;
            }
            return true;
        }
    }

    if ( m_iLastMouseWindow >= 0 && (unsigned)m_iLastMouseWindow<m_vWindows.size() )
    {
        CopperMouseEvent pNewMouse = pMouseEvent;
        pNewMouse.x -= (int)m_vWindows[m_iLastMouseWindow]->GetX();
        pNewMouse.y -= (int)m_vWindows[m_iLastMouseWindow]->GetY();
        pNewMouse.pType = CopperMouseEvent::MOUSE_OUT;
        m_vWindows[m_iLastMouseWindow]->MouseEvent( pNewMouse );
        m_iLastMouseWindow = -1;
    }

    return false;
}

bool CopperWindow::IsMouseEventOnTarget( const CopperMouseEvent & pMouseEvent )
{
    return ( pMouseEvent.x >= 0 && pMouseEvent.y >= 0 && pMouseEvent.x < m_fWidth && pMouseEvent.y < m_fHeight );
}

MString CopperWindow::GetFocus()
{
    return m_vWindows[m_iCurrentFocus]->GetName();
}

void CopperWindow::SetFocus( const MString & sFocus )
{
    for ( unsigned i = 0; i < m_vWindows.size(); i++ )
        if ( m_vWindows[i]->GetName() == sFocus )
        {
            m_iCurrentFocus = i;
            return;
        }
}

CopperWindow * GetCopperByClass( const MString & sClassName, const MString & sWindowName ) {
    if ( ToMakeWindows->find( sClassName ) == ToMakeWindows->end() )
        return NULL;
    return (*ToMakeWindows)[sClassName](sWindowName);
}

void RegisterCopperWindow( const MString& sClassName, NewCopperFunction pfn )
{
    if ( ToMakeWindows == NULL )
        ToMakeWindows = new std::map< MString, NewCopperFunction >;
    (*ToMakeWindows)[sClassName] = pfn;
}

/*
 * (c) 2006 Charles Lohr
 * All rights reserved.
 * 
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, and/or sell copies of the Software, and to permit persons to
 * whom the Software is furnished to do so, provided that the above
 * copyright notice(s) and this permission notice appear in all copies of
 * the Software and that both the above copyright notice(s) and this
 * permission notice appear in supporting documentation.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF
 * THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS
 * INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT
 * OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
 * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
 * OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 * PERFORMANCE OF THIS SOFTWARE.
 */

---

Hosted by