/*
* Copyright (c) 2005 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:  The MUS application's UI class.
*
*/


#include "musuireceivecontainer.h"
#include "musuieventcontroller.h"
#include "musuigeneralview.h"
#include "musuireceiveview.h"
#include "musuiinvitationquery.h"
#include "musuiinvitationqueryobserver.h"
#include "musuiappui.h"
#include "musuidialogutil.h"
#include "musuidefinitions.h"
#include "musui.hrh"
#include "muslogger.h" // debug logging
#include <musui.rsg>

#include <AknsControlContext.h>
#include <AknsBasicBackgroundControlContext.h>
#include <AknsDrawUtils.h>
#include <AknWaitDialog.h>
#include <AknDef.h>


// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
CMusUiReceiveContainer* CMusUiReceiveContainer::NewL(
                                CMusUiReceiveView& aView,
                                const TRect aRect )
    {
    CMusUiReceiveContainer* self
            = new( ELeave ) CMusUiReceiveContainer( aView );

    CleanupStack::PushL( self );
    self->ConstructL( aRect );
    CleanupStack::Pop( self );

    return self;
    }


// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
CMusUiReceiveContainer::~CMusUiReceiveContainer()
    {
    MUS_LOG( "mus: [MUSUI ]  -> CMusUiReceiveContainer::~CMusUiReceiveContainer" );

    if ( iInvitationQuery )
        {
        iInvitationQuery->Cancel();
        delete iInvitationQuery;
        iInvitationQuery = NULL;
        }

    delete iBackGround;
    MUS_LOG( "mus: [MUSUI ]  <- CMusUiReceiveContainer::~CMusUiReceiveContainer" );
    }


// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
CMusUiReceiveContainer::CMusUiReceiveContainer( CMusUiReceiveView& aView )
    : iView( aView )
    {
    }


// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void CMusUiReceiveContainer::ConstructL( const TRect& aRect )
    {
    MUS_LOG( "mus: [MUSUI ]  -> CMusUiReceiveContainer::ConstructL" );
    CreateWindowL();
    iBackGround = CAknsBasicBackgroundControlContext::NewL(
                             KAknsIIDQsnBgAreaMain,
                             aRect,
                             EFalse );
    iFullScreen = EFalse;
    SetRect( aRect );
    ActivateL();
    
    iOperatorSpecificFunctionality = iView.OperatorSpecificFunctionality();
    MUS_LOG( "mus: [MUSUI ]  <- CMusUiReceiveContainer::ConstructL" );
    }


// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void CMusUiReceiveContainer::ShowInvitationQueryL(
                                    const TDesC& aContact,
                                    MMusUiInvitationQueryObserver& aObserver )
    {
    MUS_LOG( "mus: [MUSUI ]  -> CMusUiReceiveContainer::ShowInvitationQueryL" );
    if ( !iInvitationQuery )
        {
        iInvitationQuery = CMusUiInvitationQuery::NewL( aObserver );
        }
    iInvitationQuery->ShowL( aContact );
    MUS_LOG( "mus: [MUSUI ]  <- CMusUiReceiveContainer::ShowInvitationQueryL" );
    }


// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void CMusUiReceiveContainer::DismissInvitationQuery( TBool aDelete )
    {
    if ( iInvitationQuery )
        {
        iInvitationQuery->Cancel();
        if ( aDelete )
            {
            delete iInvitationQuery;        
            iInvitationQuery = NULL;
            }
        }
    }
    

// -----------------------------------------------------------------------------
// Fetches a pointer to the view that owns this container.
// -----------------------------------------------------------------------------
//
CMusUiGeneralView* CMusUiReceiveContainer::MusUiView() const
    {
    MUS_LOG( "mus: [MUSUI ]  -> CMusUiReceiveContainer::MusUiView" );
    MUS_LOG( "mus: [MUSUI ]  <- CMusUiReceiveContainer::MusUiView" );
    return &iView;
    }


// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void CMusUiReceiveContainer::SetFullScreen( TBool aFullScreen, TRect aRect )
    {
    MUS_LOG1( "mus: [MUSUI ]  -> CMusUiReceiveContainer::SetFullScreen: %d",
                            aFullScreen );
    iFullScreen = aFullScreen;
    
    if ( aFullScreen )
        {
        // In order to capture pointer events this container must be visible.
        // Thus we make it as small as possible.
        SetRect( TRect( 0, 0, 0, 0) );
        MakeVisible( ETrue );
        SetGloballyCapturing( ETrue );
        SetPointerCapture( ETrue );    
        }
    else
        {
        SetRect( aRect );
        SetPointerCapture( EFalse );
        MakeVisible( EFalse );
        }
        
    MUS_LOG( "mus: [MUSUI ]  <- CMusUiReceiveContainer::SetFullScreen" );
    }


// -----------------------------------------------------------------------------
// Called by framework when the view size is changed
// -----------------------------------------------------------------------------
//
void CMusUiReceiveContainer::SizeChanged()
    {
    TRect parentRect(Rect());
    if (iBackGround)
        {
        (static_cast<CAknsBasicBackgroundControlContext*>(iBackGround))->SetRect(parentRect);
        }
    MakeVisible( EFalse );
    }


// -----------------------------------------------------------------------------
// Called by framework when to retrieve the no. of controls.
// -----------------------------------------------------------------------------
//
TInt CMusUiReceiveContainer::CountComponentControls() const
    {
    return 0; // return nbr of controls inside this container
    }


// -----------------------------------------------------------------------------
// Called by framework to retrieve the control specified by index.
// -----------------------------------------------------------------------------
//
CCoeControl* CMusUiReceiveContainer::ComponentControl( TInt aIndex ) const
    {
    switch ( aIndex )
        {
        default:
            return NULL;
        }
    }


// -----------------------------------------------------------------------------
// Called by framework to redraw the screen area.
// -----------------------------------------------------------------------------
//
void CMusUiReceiveContainer::Draw( const TRect& aRect ) const
    {
    CWindowGc& gc = SystemGc();

    gc.Clear( aRect );
    MAknsSkinInstance* skin = AknsUtils::SkinInstance();
    MAknsControlContext* cc = AknsDrawUtils::ControlContext( this );
    if(!AknsDrawUtils::Background( skin, cc,this,gc,aRect,KAknsDrawParamDefault ))
        {
        gc.SetBrushColor( iEikonEnv->ControlColor( EColorWindowBackground, *this ) );
        gc.SetBrushStyle( CGraphicsContext::ESolidBrush );
        gc.Clear( aRect );
        }
    }


// -----------------------------------------------------------------------------
// Called by framework
// -----------------------------------------------------------------------------
//
TKeyResponse CMusUiReceiveContainer::OfferKeyEventL( const TKeyEvent& aEvent,
                                                     TEventCode aType )
    {
    MUS_LOG( "mus: [MUSUI ]  -> CMusUiReceiveContainer::OfferKeyEventL" );
    
    if ( iFullScreen && aType == EEventKey )
        {
        // We respond to whatever key by returning from fullscreen
        if( MUS_NO_TOOLBAR )
            {
            (static_cast <CMusUiReceiveView*> 
                (MusUiView()))->HandleCommandL( EMusuiCmdViewFullScreen );            
            }
        else
            {
            (static_cast <CMusUiReceiveView*> 
                (MusUiView()))->HandleCommandL( EMusuiCmdToolbarFullScreen );
            }
         return EKeyWasConsumed;
        }
        
    switch ( aEvent.iCode )
        {
        // Volume Control
        case EKeyLeftArrow:
            {
            (static_cast <CMusUiReceiveView*> 
                    (MusUiView()))->HandleCommandL( EMusuiCmdViewVolumeDown );
            return EKeyWasConsumed;
            }
        case EKeyRightArrow:
            {
            (static_cast <CMusUiReceiveView*> 
                    (MusUiView()))->HandleCommandL( EMusuiCmdViewVolumeUp );
            return EKeyWasConsumed;
            }

        //  TODO:
        case EKeyUpArrow:
            {
            break;
            }
        case EKeyDownArrow:
            {
            break;
            }
        default:
            return EKeyWasNotConsumed;
        }

    MUS_LOG( "mus: [MUSUI ]  <- CMusUiReceiveContainer::OfferKeyEventL" );
    return EKeyWasNotConsumed;
    }


// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void CMusUiReceiveContainer::HandlePointerEventL( const TPointerEvent& )
    {
    if ( iFullScreen )
        {
        // We respond to whatever pointer event by returning from fullscreen
        (static_cast <CMusUiReceiveView*> 
                (MusUiView()))->HandleCommandL( EMusuiCmdToolbarFullScreen );
        }
    }


// end of file