arswindow.cpp

Go to the documentation of this file.

#include "SdlArs.h"

namespace Ars
{
Window::Window( void )
: clientRect( 0 , 0 , 0 , 0 ) , m_MouseButton( 0 )
, paintAlreadySent( false ) , parentWindow( 0 ) , bkgnd( 0 ) , toolTip( 0 )
{
        MessageServer::Instance().RegisterMessageClient( this , Message::SETUP_WINDOW );
}

Window::~Window( void )
{
        MessageServer::Instance().DeregisterMessageClient( this );

        if( bkgnd )
        {       
                if( GetGDI() )
                {
                        XRect   r( 0 , 0 , bkgnd->w , bkgnd->h );
                        SDL_BlitSurface( bkgnd , &r , GetGDI() , static_cast<SDL_Rect *>( this ) );
                }
                SDL_FreeSurface( bkgnd );
        }
        bkgnd = 0;

        // Each child window is deleted, and should in their destructors call back to this object to Deregister themselves
        unsigned int iSanityCheck = static_cast<unsigned int>( size() );
        while( size() > 0 && iSanityCheck > 0 )
        {
                Window  *w = *(begin());
                delete w;
                --iSanityCheck;
        }
        TraceIf( iSanityCheck != 0, "Sanity check failed in CWindow destructor!" );
        TraceIf( !empty(), "CWindow children not empty at end of destructor!" );
        clear();
        SetParent( 0 );

        if( toolTip )
                delete toolTip;
        toolTip = 0;
}

const bool Window::SetupWindow( const Message &msg )
{
        Painter::SetupWindow( msg );
        MessageServer::Instance().DeregisterMessageClient( this , Message::SETUP_WINDOW );
        MessageServer::Instance().RegisterMessageClient(this, Message::APP_PAINT);

        if( toolTip )
                toolTip->SetupWindow( msg );

        return true;
}

void Window::Init( icstring &aStr )
{
        Painter::Init( aStr );
        icstring tmp = Rsrc::FindCrdOf( aStr , "str" );
        SetWndText( Rsrc::GetStr( tmp , GetWindowText() ) );
        
        tmp = Rsrc::FindCrdOf( aStr , "sound" );
        soundName = Rsrc::GetId(tmp );

        tmp = Rsrc::FindCrdOf( aStr , "tooltip" );
        if( !tmp.empty() )
        {

                toolTip = new XToolTip( this );
                //      next one in sequence
                toolTip->Init( tmp );
        }
}

const bool Window::ShowWindow( void )
{
        ResetFlags( F_HIDETREE );
        for_each( begin() , end() , mem_fun( &Window::ShowWindow ) );

        return true;
}

const bool Window::HideWindow( void )
{
        SetFlags( F_HIDETREE );
        for_each( begin() , end() , mem_fun( &Window::HideWindow ) );

        return true;
}

XRect Window::GetClientRect( void )
{
        XRect ClientRect( GetWindowRect().TopLeft() + clientRect.TopLeft(), GetWindowRect().TopLeft() + clientRect.BottomRight());
        ClientRect.ClipTo( GetWindowRect() );
        return ClientRect;
}

Window *Window::GetRoot( void ) const
{
        if( parentWindow )
        {
                Window *pWindow = GetParent();

                while( pWindow->GetParent() )
                        pWindow = pWindow->GetParent();

                return pWindow;
        }
        else
                return const_cast< Window *>( this );
}

const bool Window::SetParent( Window *pNewParent)
{
//      if( parentWindow )
//              ArsPostMessage( CtrlMessage( Message::DEREG_CHILD , parentWindow , this ) );
//              parentWindow->DeregisterChildWindow( this );

        if( pNewParent )
        {
                if( parentWindow )
                        parentWindow->DeregisterChildWindow( this );
                pNewParent->RegisterChildWindow( this );
                SetGDI( pNewParent->GetRoot()->GetGDI() );
        }
        else
        {
                MessageServer::Instance().DeregisterMessageClient( this );
                MessageServer::Instance().RegisterMessageClient( this , Message::SETUP_WINDOW );
                for_each( begin() , end() , mem_fun( &Window::ResetChildren ) );

                clear();

                if( parentWindow )
                        parentWindow->DeregisterChildWindow( this );
        }

        parentWindow = pNewParent;

        return true;
}

const bool Window::ResetChildren( void )
{
        parentWindow = 0;

        MessageServer::Instance().DeregisterMessageClient( this );
        MessageServer::Instance().RegisterMessageClient( this , Message::SETUP_WINDOW );

        for_each( begin() , end() , mem_fun( &Window::ResetChildren ) );
        
        clear();

        return true;
}

void Window::RegisterChildWindow( Window *window)
{
        push_back( window );
}


void Window::DeregisterChildWindow( Window *window )
{
        remove( window );
}

const bool Window::DeregChild( const CtrlMessage &msg )
{
        DeregisterChildWindow( (Window *)msg.source );
        return true;
}

void Window::UpdateWindow( const bool aNow )
{
        if( aNow )
                ArsSendMessage( Message( Message::APP_PAINT  , this ) );
        else if( !paintAlreadySent )
        {
                ArsPostMessage( Message( Message::APP_PAINT  , this ) );
                paintAlreadySent = true;
        }
}

void Window::DrawBG( void )
{
        if( bkgnd == 0 && GetGDI() )
        {
                bkgnd = Graf::NewSurface( Width() + 1 , Height() + 1 , GetGDI() );
                XRect   r( 0 , 0 , bkgnd->w , bkgnd->h );
                XRect   t( *this );
                t.w += 1;
                t.h += 1;
                SDL_BlitSurface( GetGDI() , &t , bkgnd , &r );
        }

        if( (GetStates() & S_TRANSPARENT) == 0 ) 
                DrawRect( GetWindowRect() , true , GetBgColor() , GetBgColor() );
}

void Window::Draw( void )
{
}

void Window::DrawChildren( void )
{
        if( !empty() )
        {
                int     n = size();
                for_each( begin() , end() , mem_fun( &Window::DrawProc ) );
        }
}

const bool Window::DrawProc( void )
{
        if( IsVisible() )
        {
                AdjustColors();

                DrawBG();
                Draw();

                RestoreColors();

                DrawChildren();
        }
        
        SetDirty( false );

        return IsVisible();
}

const bool Window::wmPaint( const Message &m )
{
        if( IsVisible() )
        {
                DrawProc();
                SDL_UpdateRect( GetGDI() , x , y , w  , h );
                paintAlreadySent = false;
        }
        else if( GetGDI() && bkgnd )
        {
                XRect   r( 0 , 0 , bkgnd->w , bkgnd->h );
                XRect   t( *this );
                t.w += 1;
                t.h += 1;
                SDL_BlitSurface( bkgnd , &r , GetGDI() , &t );
                SDL_UpdateRect( GetGDI() , x , y , w , h );
                paintAlreadySent = false;
                SDL_FreeSurface( bkgnd );
                bkgnd = 0;
        }

        SetDirty( false );

        return (m.Destination() == this);
}

const bool Window::HandleMessage( const Message &msg )
{
        const bool ans = Thing::HandleMessage( msg );
        
        if( msg.MessageType() != Message::SETUP_WINDOW )
                if( IsDirty() )
                        UpdateWindow( true );

        return ans;
}

const bool Window::evMouseButtonDown( const MouseMessage &msg )
{
        bool ans = Painter::evMouseButtonDown( msg );

        if( (GetStates() & S_DISABLED) != S_DISABLED )
        {
                if( FindWindow( &msg.Point ) == this )
                {               
                        m_MouseButton = msg.Button;
                
                        if( ArsApplication::GetInstance()->GetKeyFocus() != this && (GetFlags() & MAY_GAINFOCUS) != 0 )
                                ArsApplication::GetInstance()->SetKeyFocus( this );

                        ans = true;
                }
        }
        return ans;
}

const bool Window::evMouseButtonUp( const MouseMessage &msg )
{
        bool ans = Painter::evMouseButtonUp( msg );

        if( (GetStates() & S_DISABLED) != S_DISABLED )
        {
                if( FindWindow( &msg.Point ) == this && m_MouseButton == msg.Button  )
                {
                        Message::EMessageType MessageType =  Message::UNKNOWN;
                        switch( m_MouseButton )
                        {
                        case MouseMessage::LEFT:
                                // send an extra message to itself
                                MessageType = Message::CTRL_LCLICK;
                                break;
                        case MouseMessage::RIGHT:
                                MessageType = Message::CTRL_RCLICK;
                                break;
                        case MouseMessage::MIDDLE:
                                MessageType = Message::CTRL_MCLICK;
                                break;
                        }
                        if( !soundName.empty() )
                                GetSound( soundName ).Play();
                        
                        ArsSendMessage( CtrlMessage( MessageType , this , this, 0 ) );

                        ans = true;
                }
        }
        return ans;
}

const bool Window::RelposInside( const XPoint *pt )
{
        return HitTest( *pt ) == RELPOS_INSIDE;
}

Window *Window::FindWindow( const XPoint *pt )
{
        if( HitTest( *pt ) == RELPOS_INSIDE )
        {
                std::list<Window *>::iterator at = find_if( begin() , end() , bind2nd( mem_fun( &Window::RelposInside ) , pt ) );
                if( at != end() && (*at)->IsVisible() )
                        return(*at)->FindWindow( pt );
                return this;
        }
        return 0;
}

const bool Window::IsChild( Window *wnd )
{
        if( !empty() )
                for( std::list<Window *>::iterator it = begin() ; it != end() ; ++it )
                        if( (*it) == wnd )
                                return true;
                        else if( (*it)->IsChild( wnd ) )
                                return true;
        return false;
}

}

---