/*

* Copyright (c) 2007 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:  Outlook Conference

*

*/

// INCLUDE FILES

#include    "BMBubbleManager.h" //for enumerations

#include    "BMBubbleOutlookConference.h"

#include    "BMBubbleImageManager.h"

#include    "BMResourceManager.h"

#include    "BMConfHeader.h"

#include    "BMLayout.h"

#include    "BMUtils.h"

#include    "BMPanic.h"

#include    "BMLayout2.h"

#include    "BMLayout4.h"

#include    <eiklabel.h>  

#include    <eikimage.h>

#include    <eikenv.h>

#include    <AknsUtils.h>

#include    <AknsDrawUtils.h>

// ========================= MEMBER FUNCTIONS ================================

CBubbleOutlookConference::CBubbleOutlookConference( 

    CBubbleManager& aBubbleManager ) 

    : CBubbleOutlook( aBubbleManager )

    {

    }

// ---------------------------------------------------------------------------

// CBubbleOutlookConference::ConstructL

// ---------------------------------------------------------------------------

//

void CBubbleOutlookConference::ConstructL( const TUint8& aCallAmount )

    {

    iPaneAmount = aCallAmount;

    iHeader = NULL;

    // create panes for each call

    CBubbleConfPane* pane;

    iConfPanes = new ( ELeave ) CArrayPtrFlat<CBubbleConfPane>( iPaneAmount );    

    iConfPanes->SetReserveL( iPaneAmount );

    for ( TUint8 i = 0 ; i < iPaneAmount ; i++ )

        {

        pane = new( ELeave ) CBubbleConfPane;

        CleanupStack::PushL( pane );

        pane->SetContainerWindowL( *this );

        pane->ConstructL( iBubbleManager.IsTouchCallHandling() );

        iConfPanes->InsertL( i , pane );

        CleanupStack::Pop( pane );

        }

    // Create space for headers 

    iCalls = new( ELeave ) CArrayPtrFlat<CBubbleCallHeader>( iPaneAmount );

    iCalls->SetReserveL( iPaneAmount );

    CBubbleOutlook::ConstructL();

    ActivateL();

    }

// Destructor

CBubbleOutlookConference::~CBubbleOutlookConference()

    {

    if ( iCalls && iConfPanes )

        {

        Reset();

        }

    if ( iCalls )

        {

        iCalls->Reset( );

        delete iCalls;

        }

    if ( iConfPanes )

        {

        iConfPanes->ResetAndDestroy() ;

        delete iConfPanes;

        }

    iHeader = NULL;

    }

// ---------------------------------------------------------------------------

// CBubbleOutlookConference::Reset

//

//  

// ---------------------------------------------------------------------------

//

void CBubbleOutlookConference::Reset()

    {

    iBubbleManager.ResourceManager().ReleaseEikImage( iBubble );

    iBubbleManager.ResourceManager().ReleaseEikLabel( iTimerCost );

    for ( TUint8 i = 0 ; i < iPaneAmount ; i++ )

        {

        iBubbleManager.ResourceManager().ReleaseEikImage( 

            iConfPanes->At( i )->iCallIndication );

        iBubbleManager.ResourceManager().ReleaseEikImage( 

            iConfPanes->At( i )->iCyphOffImage );

        iBubbleManager.ResourceManager().ReleaseEikLabel( 

            iConfPanes->At( i )->iTextLine );

        iConfPanes->At( i )->Reset( );

        }

    iCalls->Delete( 0 , iCalls->Count() );

    iHeader = NULL;

    }

// ---------------------------------------------------------------------------

// CBubbleOutlookConference::ReadBubbleHeader

//

//  

// ---------------------------------------------------------------------------

//

void CBubbleOutlookConference::ReadBubbleHeader( CBubbleHeader& aHeader )

    {

    if ( !aHeader.IsUsed() || !aHeader.IsConference() )

        {

        return;

        }

    iHeader = static_cast< CBubbleConfHeader* >( &aHeader ); 

    // get call's info. Function returns calls in drawing order.

    iHeader->GetRows( *iCalls );

    __ASSERT_ALWAYS( iCalls->Count( ) == iPaneAmount, 

                                    Panic( EBMPanicInvalidNumberOfHeaders ) );

    iBubble = iBubbleManager.ResourceManager().ReserveEikImage( ETrue );

    if ( !iCallObjectDisplay )

        {

        // Get bubble graphics

        GetCall1BubbleBitmaps();    

        }

    // Get call indicator for each pane.

    TUint32 flags = 0;  

    CBubbleManager::TPhoneCallState state;

    TInt indicationPicture = KErrNotFound;

    TInt indicationPictureMask =KErrNotFound;

    for ( TUint8 i = 0 ; i < iPaneAmount ; i++ )

        {

        flags = iCalls->At( i )->CallFlags( );

        state = iCalls->At( i )->CallState( );

        CEikImage*& image = iConfPanes->At( i )->CallIndicationHandle( );

        indicationPicture = KErrNotFound;

        indicationPictureMask = KErrNotFound;

        if ( state == CBubbleManager::EDisconnected )

            {

            indicationPicture = EQgn_indi_call_disconn_conf;

            indicationPictureMask = EQgn_indi_call_disconn_conf_mask;

            }

        else if ( state == CBubbleManager::EActive ) 

            {

            indicationPicture = EQgn_indi_call_active_conf;

            indicationPictureMask = EQgn_indi_call_active_conf_mask;

            }

        else 

            {

            indicationPicture = EQgn_indi_call_held_conf;

            indicationPictureMask = EQgn_indi_call_held_conf_mask;

            }

        if ( indicationPicture != KErrNotFound )

            {

            image = iBubbleManager.ResourceManager().ReserveEikImage();

            if ( indicationPictureMask == KErrNotFound )

                {

                iBubbleManager.ImageManager().SetBitmapToImage( 

                    image, (TBMIcons) indicationPicture );

                }

            else

                {

                iBubbleManager.ImageManager().SetBitmapToImage( 

                    image, 

                    (TBMIcons) indicationPicture , 

                    (TBMIcons) indicationPictureMask);

                }

            }

        // Cyph off

        if ( flags&CBubbleManager::ENoCiphering )

            {

            iConfPanes->At( i )->iCyphOffImage = 

                iBubbleManager.ResourceManager().ReserveEikImage();

            iBubbleManager.ImageManager().SetBitmapToImage( 

                    iConfPanes->At( i )->iCyphOffImage, 

                    EQgn_indi_call_cyphering_off,

                    EQgn_indi_call_cyphering_off_mask );

            }

        // set CLI to pane

        if ( ( iCalls->At( i )->ParticipantListCLI() == 

              CBubbleManager::EParticipantListCNAP ) &&

             iCalls->At( i )->CNAP().Length() )

            {

            // Phonenumber

            iConfPanes->At( i )->iTextLine = 

                iBubbleManager.ResourceManager().ReserveEikLabel();

            iConfPanes->At( i )->SetText( iCalls->At( i )->CNAP(), 

                                          iCalls->At( i )->CNAPClipDirection( ) );    

            }

        else            

            {

            // CLI text

            iConfPanes->At( i )->iTextLine = 

                iBubbleManager.ResourceManager().ReserveEikLabel();

            iConfPanes->At( i )->SetText( iCalls->At( i )->CLI(), 

                                          iCalls->At( i )->CLIClipDirection( ) );

            }

        iConfPanes->At( i )->iCallObjectDisplay = iCallObjectDisplay;

        }

    // get highlight

    for ( TUint8 t = 0 ; t < iConfPanes->Count() ; t++ )

        {

        iConfPanes->At( t )->SetHighlight( EFalse );

        }

    if ( iHeader->Highlight() != 0 )

        {

        iConfPanes->At( iHeader->Highlight() - 1 )->SetHighlight( ETrue );

        }

    // place timer/cost text to label

    if ( !iBubbleManager.IsTouchCallHandling() )

        {

        iTimerCost = iBubbleManager.ResourceManager().ReserveEikLabel();

        BubbleUtils::ClipToLabel( 

            iHeader->TimerCost( ) , iTimerCost , CBubbleManager::ERight );

        }

    }

// ---------------------------------------------------------------------------

// CBubbleOutlookConference::SizeChanged

// called by framwork when the view size is changed

// Works with all the conference situations.

// ---------------------------------------------------------------------------

//

void CBubbleOutlookConference::SizeChanged()

    {

    if( !iHeader )

        {

        return;

        }

    AknsUtils::RegisterControlPosition( this );

    if ( iBubbleManager.IsTouchCallHandling() )

        {

        TRAPD( err, DoCall4LayoutL() );

        if ( err )    

            {

            iBubble->SetPicture( NULL, NULL );

            MAknsSkinInstance* skin = AknsUtils::SkinInstance();

            AknsDrawUtils::PrepareFrame( skin,

                                         iOuterRect,

                                         iInnerRect,

                                         iFrameId,

                                         KAknsIIDDefault );

            }

        }

    else if ( !iCallObjectDisplay )

        {

        DoCall1Layout();    

        }

    else

        {

        TRAPD( err, DoCall2LayoutL() );

        if ( err )    

            {

            iBubble->SetPicture( NULL, NULL );

            MAknsSkinInstance* skin = AknsUtils::SkinInstance();

            AknsDrawUtils::PrepareFrame( skin,

                                         iOuterRect,

                                         iInnerRect,

                                         iFrameId,

                                         KAknsIIDDefault );

            }  

        }      

    }

// ---------------------------------------------------------------------------

// CBubbleOutlookConference::CountComponentControls

//

//  

// ---------------------------------------------------------------------------

//

TInt CBubbleOutlookConference::CountComponentControls() const

    {

    if ( iTimerCost )

        {

        return 1 + iConfPanes->Count( );

        }

    return iConfPanes->Count( );

    }

// ---------------------------------------------------------------------------

// CBubbleOutlookConference::ComponentControl

//

//  

// ---------------------------------------------------------------------------

//

CCoeControl* CBubbleOutlookConference::ComponentControl(TInt aIndex) const

    {

    if ( iTimerCost )

        {

        if ( aIndex < iConfPanes->Count( ) ) 

            {

            return iConfPanes->At( aIndex );

            }

        else if ( aIndex == iConfPanes->Count( ) ) 

            {

            return iTimerCost;

            }

        else 

            {

            return NULL;

            }

        }

    return iConfPanes->At( aIndex );

    }

// ---------------------------------------------------------------------------

// CBubbleOutlookConference::Draw

// 

//  

// ---------------------------------------------------------------------------

//

void CBubbleOutlookConference::Draw( const TRect& /*aRect*/ ) const

    {

    }

// ---------------------------------------------------------------------------

// CBubbleOutlookConference::DrawTimerCostNow

//

//  

// ---------------------------------------------------------------------------

//

void CBubbleOutlookConference::DrawTimerCostNow()

    {

    if ( iHeader == NULL || iTimerCost == NULL )

        {

        return;

        }

    if ( iHeader->CallState() != CBubbleManager::EActive 

        || iTimerCost->Text()->Compare( iHeader->TimerCost() ) == 0 )

        {

        return;

        }

    BubbleUtils::ClipToLabel( 

        iHeader->TimerCost() , iTimerCost , CBubbleManager::ERight );

    DrawLabelNow( iTimerCost );

    }

// ---------------------------------------------------------------------------

// CBubbleOutlookConference::DrawCLINow

//

//  

// ---------------------------------------------------------------------------

//

void CBubbleOutlookConference::DrawCLINow()

    {

    }

// ---------------------------------------------------------------------------

// CBubbleOutlookConference::DrawRowNow

//

//  

// ---------------------------------------------------------------------------

//

void CBubbleOutlookConference::DrawRowNow( CBubbleManager::TRowNumber aRow )

    {

    if ( iHeader == NULL || aRow == 0 )

        {

        return;

        }

    // get highlight

    for ( TUint8 t = 0 ; t < iConfPanes->Count() ; t++ )

        {

        iConfPanes->At( t )->SetHighlight( EFalse );

        }

    if ( iHeader->Highlight() != 0 )

        {

        iConfPanes->At( iHeader->Highlight() - 1 )->SetHighlight( ETrue );

        }

    DrawLabelNow( iConfPanes->At( aRow - 1 ) );

    }

// ---------------------------------------------------------------------------

// CBubbleOutlookConference::DrawBitmaps

//

//  

// ---------------------------------------------------------------------------

//

void CBubbleOutlookConference::DrawBitmaps( CBitmapContext& aGc ) const

    {

    // Check that proper conference header is set

    if ( iHeader == NULL )

        {

        return;

        }

    if ( !iHeader->IsUsed() || !iHeader->IsConference( ) ) 

        {

        return;

        }

    aGc.SetBrushColor( AKN_LAF_COLOR( BubbleLayout::LayoutColourWhite() ) );

    if ( !iCallObjectDisplay )

        {

        BubbleUtils::DrawMaskedImage( aGc , iBubble );

        }

    else

        {

        if ( iBubble->Bitmap() )

            {

            BubbleUtils::DrawMaskedImage( aGc , iBubble );    

            }

        else

            {

            // Draw bubble frame

            MAknsSkinInstance* skin = AknsUtils::SkinInstance();

            if ( !AknsDrawUtils::DrawFrame( skin,

                                            (CWindowGc&) aGc,  

                                            iOuterRect,

                                            iInnerRect,

                                            iFrameId,

                                            KAknsIIDDefault ) )

                {

                BubbleUtils::DrawBackgroundRect( aGc, Rect() );

                }        

            }    

        }        

    }

// ---------------------------------------------------------------------------

// CBubbleOutlookConference::HandleAnimationStartL

//

//  

// ---------------------------------------------------------------------------

//

void CBubbleOutlookConference::HandleAnimationStartL() const

    {

    }

// ---------------------------------------------------------------------------

//  CBubbleOutlookConference::DrawCallHeaderText

// ---------------------------------------------------------------------------

//

void CBubbleOutlookConference::DrawCallHeaderText()

    {    

    }

// ---------------------------------------------------------------------------

// CBubbleOutlookConference::DoCall1Layout

// ---------------------------------------------------------------------------

//    

void CBubbleOutlookConference::DoCall1Layout()

    {

    // Deprecated

    }

// ---------------------------------------------------------------------------

// CBubbleOutlookConference::DoCall2Layout

// ---------------------------------------------------------------------------

//

void CBubbleOutlookConference::DoCall2LayoutL()

    {

    iBubble->SetPictureOwnedExternally( EFalse );

    iBubble->SetPicture( NULL, NULL );

    TAknLayoutRect bubbleRect;

    bubbleRect.LayoutRect( 

        Rect(), 

        BubbleLayout2::popup_call2_conf_pane_background() );

    TRect frameRect( TPoint(0,0), bubbleRect.Rect().Size() );

    TRect outerRect;

    TRect innerRect;

    BubbleLayout2::BubbleFrameInnerOuterRects( frameRect, 

                                               outerRect, 

                                               innerRect );

    iFrameId = KAknsIIDQsnFrCall2BubbleFirst;

    TAknsItemID coMaskFrameId = KAknsIIDQsnFrCall2BubbleFirstCoMask;

    iOuterRect = outerRect;

    iOuterRect.Move( Rect().iTl );

    iInnerRect = innerRect;

    iInnerRect.Move( Rect().iTl );