1 /*

     2 * Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies). 

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  Manager for the whole subsystem

    15 *

    16 */

    17 

    18 

    19 // INCLUDE FILES

    20 

    21 #include    "BMBubbleManager.h"

    22 #include    "BMBubbleImageManager.h"

    23 #include    "BMResourceManager.h"

    24 #include    "BMCustomManager.h"

    25 #include    "BMBubbleOutlook.h"

    26 #include    "BMBubbleOutlookMiddle.h"

    27 #include    "BMBubbleOutlookConference.h"

    28 #include    "BMBubbleOutlookNE.h"

    29 #include    "BMCallHeader.h"

    30 #include    "BMConfHeader.h"

    31 #include    "BMPanic.h"

    32 #include    "BMUtils.h"

    33 #include    "BMLayout.h"

    34 #include    "BMBubbleImage.h"

    35 #include    "BubbleManagerPaths.h"

    36 #include    "BMCallObjectManager.h"

    37 #include    "BMLayout2.h"

    38 #include    "BMLayout3.h"

    39 #include    "BMLayout4.h"

    40 #include    "BMLayout6.h"

    41 #include    "BMCallObjectUtils.h"

    42 #include    "BMVideoController.h"

    43 #include    "BMTouchPane.h"

    44 #include    "BMTouchPaneInterface.h"

    45 #include    "BMMainPaneControl.h"

    46 #include    <eikimage.h>    // for muted-image

    47 #include    <coemain.h>

    48 #include    <PbkFields.hrh> // for field id

    49 #include    <ConeResLoader.h> 

    50 #include    <AknsUtils.h>

    51 #include    <NumberGrouping.h>

    52 #include    <AknDef.h>

    53 #include    <layoutmetadata.cdl.h>

    54 

    55 #include    <featmgr.h> 

    56 #include    <telephonyvariant.hrh>

    57 

    58 #include <centralrepository.h>

    59 #include    <NumberGroupingCRKeys.h>

    60 #ifdef RD_UI_TRANSITION_EFFECTS_PHASE2

    61 #include <gfxtranseffect/gfxtranseffect.h> 

    62 #include <akntransitionutils.h>

    63 #endif

    64 

    65 #include    "BMBubbleDebug.h"

    66 

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

    68 

    69 // ---------------------------------------------------------------------------

    70 // CBubbleManager::NewL

    71 // Symbian OS two phased constructor

    72 // 

    73 // ---------------------------------------------------------------------------

    74 //

    75 EXPORT_C CBubbleManager* CBubbleManager::NewL( const CCoeControl& aContainer, 

    76                                                const TRect& aRect )

    77     {

    78     CBubbleManager* self = new( ELeave )CBubbleManager;    

    79     CleanupStack::PushL( self );

    80     self->ConstructL( aContainer , aRect, EFalse );

    81     CleanupStack::Pop();    // self

    82     return self;

    83     }

    84 

    85 // ---------------------------------------------------------------------------

    86 // CBubbleManager::NewL

    87 // Symbian OS two phased constructor

    88 // 

    89 // ---------------------------------------------------------------------------

    90 //

    91 EXPORT_C CBubbleManager* CBubbleManager::NewL( const CCoeControl& aContainer, 

    92                                                const TRect& aRect,

    93                                                TBool aBigNEInIdle )

    94     {

    95     CBubbleManager* self = new( ELeave )CBubbleManager;    

    96     CleanupStack::PushL( self );

    97     self->ConstructL( aContainer , aRect, aBigNEInIdle );

    98     CleanupStack::Pop();    // self

    99     return self;

   100     }

   101 

   102 // ---------------------------------------------------------------------------

   103 // CBubbleManager::ConstructL

   104 // Symbian OS two phased constructor

   105 // 

   106 // ---------------------------------------------------------------------------

   107 //

   108 

   109 void CBubbleManager::ConstructL( 

   110     const CCoeControl& aContainer, 

   111     const TRect& aRect,

   112     TBool aBigNEInIdle )

   113     {    

   114     // Call object display

   115     if ( FeatureManager::FeatureSupported( KFeatureIdCallImagetext ) )

   116         {

   117         iConfigFlags |= EBMCallObjectDisplay;    

   118         }

   119     

   120     // Bigger number entry window in idle    

   121     if ( aBigNEInIdle )

   122         {

   123         iConfigFlags |= EBMBigNEInIdleState;    

   124         }

   125    

   126      // Touch CallHandling.

   127     if ( FeatureManager::FeatureSupported( KFeatureIdTouchCallHandling ) )

   128         {

   129         iConfigFlags |= EBMTouchCallhandling;    

   130         }

   131                

   132     // set window

   133     SetContainerWindowL( aContainer );

   134     SetParent( const_cast<CCoeControl*>(&aContainer) );

   135     iParentControl = &aContainer;

   136     

   137     // load resource file for animation and number entry component.

   138     RConeResourceLoader resourceLoader( *iCoeEnv ); 

   139     TFileName fileName; 

   140     BubbleUtils::BubbleResourceFileName( fileName ); 

   141     resourceLoader.OpenL(fileName); 

   142     CleanupClosePushL( resourceLoader );

   143     

   144     // create image manager

   145     iImageManager = CBubbleImageManager::NewL(

   146         iConfigFlags & EBMCallObjectDisplay );

   147 

   148     // create resource pool

   149     iResourceManager = CBubbleResourceManager::NewL( *this );

   150     

   151     // create custom manager

   152     iCustomManager = CBubbleCustomManager::NewL(*this);

   153     

   154     // muted image

   155     iIsMuted = EFalse;

   156     iMutedImage = new( ELeave ) CBubbleImage;

   157     iMutedImage->SetContainerWindowL( *this );

   158     iMutedImage->SetParent( this );

   159     iMutedImage->SetPictureOwnedExternally( ETrue );

   160     iMutedImage->MakeVisible( iIsMuted );

   161     

   162     // create array of call headers

   163     CBubbleCallHeader* header;

   164     iCallHeaders = new( ELeave ) CArrayPtrFlat<CBubbleCallHeader>( 1 );

   165     iCallHeaders->SetReserveL( KBubbleCallMaxAmount );

   166     for ( TUint8 i = 0 ; i < KBubbleCallMaxAmount ; i++ )

   167         {

   168         header = CBubbleCallHeader::NewL( i );

   169         iCallHeaders->InsertL( i , header );    // can't leave

   170         }

   171     

   172     // set reserve for active headers

   173     iActiveHeaders = new ( ELeave ) CArrayPtrFlat<CBubbleHeader>( 1 );

   174     // 1 is for conference

   175     iActiveHeaders->SetReserveL( KBubbleCallMaxAmount + 1 ); 

   176         

   177     // create conference header

   178     iConfHeader = CBubbleConfHeader::NewL( KBubbleConferenceId );

   179     

   180     // create number entry

   181     iNumberEntry = new ( ELeave ) CBubbleOutlookNumberEntry( *this, 

   182                                                              *iMutedImage );

   183     iNumberEntry->SetCallObjectDisplay( 

   184         iConfigFlags & EBMCallObjectDisplay );

   185     iNumberEntry->SetContainerWindowL( *this );

   186     iNumberEntry->SetParent( this );

   187     iNumberEntry->ConstructL();

   188     iNumberEntry->MakeVisible( EFalse ); //add

   189     

   190     // create places and their contents ( outlooks )

   191     TInt maxAmount = (iConfigFlags & EBMTouchCallhandling) ?

   192         KBubblePlaceMaxAmountTouch : KBubblePlaceMaxAmount;

   193     CBubblePlace* place;

   194     iBubblePlaces = new ( ELeave ) CArrayPtrFlat<CBubblePlace>( 1 );

   195     iBubblePlaces->SetReserveL( maxAmount );

   196     for ( TUint8 e = 0 ; e < maxAmount ; e++  )

   197         {

   198         place = new ( ELeave ) CBubblePlace;

   199         CleanupStack::PushL( place );

   200         place->SetContainerWindowL( *this );

   201         place->SetParent( this );

   202         place->ConstructL( CBubblePlace::TPhoneBubblePlace ( e ) , *this );

   203         place->GetBubbleOutlook().SetCallObjectDisplay( 

   204             iConfigFlags & EBMCallObjectDisplay );

   205         iBubblePlaces->InsertL( e , place );

   206         CleanupStack::Pop(); //place

   207         }

   208     

   209     // reserve space for active places

   210     iActivePlaces = 

   211         new (ELeave) CArrayPtrFlat<CBubblePlace>( KBubblePlaceMaxVisible );

   212     iActivePlaces->SetReserveL( KBubblePlaceMaxVisible );

   213     

   214     // reserve space for label text

   215     iLabelBuf = HBufC::NewMaxL ( KBubbleLabelMaxLength );

   216 

   217     // call object manager

   218     if ( iConfigFlags & EBMCallObjectDisplay )

   219         {

   220         iCallObjectManager = CBubbleCallObjectManager::NewL( *this );

   221         

   222         // Main pane control is not set as component control,

   223         // it just controls the drawing of the call image to

   224         // the main pane.

   225         iMainPaneControl = CBubbleMainPaneControl::NewL(

   226                 *this,

   227                 *iCallObjectManager );

   228         iMainPaneControl->ActivateL();

   229         iMainPaneControl->SetContainerWindowL( *this );

   230         iMainPaneControl->MakeVisible( EFalse );

   231         }

   232         

   233     // Video ringtone

   234     iVideoController = CBubbleVideoController::NewL( *this );

   235     

   236     // Touch pane

   237     if ( iConfigFlags & EBMTouchCallhandling )

   238         {

   239         iTouchPane = CBubbleTouchPane::NewL();

   240         iTouchPane->SetContainerWindowL( *this );

   241         iTouchPane->SetParent( this );

   242         iTouchPane->MakeVisible( EFalse );

   243         iTouchPane->ActivateL();

   244         }   

   245     

   246     SetRect( aRect );

   247     ActivateL();

   248     iResourceManager->ActivateL();

   249     iIsReadyToDraw = 0;

   250 

   251     // Resource file isn't needed anymore so it can be closed.

   252     CleanupStack::PopAndDestroy(); // resourceLoader   

   253     

   254     TInt pngErr( KErrNone );

   255     TInt pngSupported( 0 );

   256     CRepository* repository = CRepository::NewL( KCRUidNumberGrouping );

   257     pngErr = repository->Get( KNumberGrouping, pngSupported );

   258     delete repository;

   259 

   260     if ( KErrNone == pngErr && pngSupported != 0 )

   261         {

   262         iNumberGrouping = CPNGNumberGrouping::NewL(KBubbleLabelMaxLength);

   263         }

   264 #ifdef RD_UI_TRANSITION_EFFECTS_PHASE2

   265     // Register the number entry popup in the transition server

   266     GfxTransEffect::Register( iNumberEntry, KGfxNumberEntryPopupUid, EFalse );

   267 

   268     CAknTransitionUtils::SetData( (TInt) this, 0 );

   269 #endif

   270     }

   271 

   272 // Destructor

   273 EXPORT_C CBubbleManager::~CBubbleManager()

   274     {

   275 #ifdef RD_UI_TRANSITION_EFFECTS_PHASE2

   276     CAknTransitionUtils::RemoveData( (TInt) this );

   277     GfxTransEffect::Deregister( iNumberEntry );

   278 #endif

   279     AknsUtils::DeregisterControlPosition( this );

   280     

   281     delete iMutedImage;

   282     

   283     if ( iActiveHeaders )

   284         {

   285         iActiveHeaders->Reset( );

   286         delete iActiveHeaders;

   287         }

   288 

   289     delete iLabelBuf;

   290     

   291     if ( iActivePlaces )

   292         {

   293         iActivePlaces->Reset( );

   294         delete iActivePlaces;

   295         }

   296     

   297     if ( iBubblePlaces )

   298         {

   299         iBubblePlaces->ResetAndDestroy() ;

   300         delete iBubblePlaces;

   301         }

   302     

   303     delete iNumberEntry;

   304     

   305     delete iConfHeader;

   306     

   307     

   308     if ( iCallHeaders )

   309         {

   310         iCallHeaders->ResetAndDestroy() ;

   311         delete iCallHeaders;

   312         }

   313 

   314     delete iResourceManager;

   315     

   316     delete iImageManager;

   317     

   318     delete iCustomManager;

   319     

   320     delete iNumberGrouping;

   321 

   322     delete iCallObjectManager;

   323     

   324     delete iMainPaneControl;

   325 

   326     delete iVideoController;

   327     

   328     delete iTouchPane;

   329     }

   330 

   331 // ---------------------------------------------------------------------------

   332 // CBubbleManager::SizeChanged()

   333 // called by framework when the view size is changed

   334 //  

   335 // ---------------------------------------------------------------------------

   336 //

   337 void CBubbleManager::SizeChanged()

   338     {

   339     AknsUtils::RegisterControlPosition( this );

   340     

   341     if ( iConfigFlags & EBMTouchCallhandling )

   342         {

   343         MBubbleTouchPaneInterface* touchPaneIf =

   344             static_cast<MBubbleTouchPaneInterface*> (iTouchPane);             

   345         

   346         if ( iTouchPane->IsVisible() )

   347             {

   348             TInt variety = 0;

   349             // Popups

   350             TAknLayoutRect windowsPane;        

   351             windowsPane.LayoutRect( 

   352                 Rect(), 

   353                 BubbleLayout6::call6_windows_pane(variety));

   354 

   355             iMainPaneControl->SetRect( windowsPane.Rect() );

   356             

   357             DoLayoutCall4Bubbles( windowsPane.Rect() );    

   358             }

   359         else

   360             {

   361             iMainPaneControl->SetRect( Rect() );

   362             

   363             DoLayoutCall4Bubbles( Rect() );    

   364             }            

   365             

   366                     

   367         // Muted icon

   368         AknLayoutUtils::LayoutImage( 

   369             iMutedImage, Rect(), 

   370             BubbleLayout::main_pane_elements_muted( EFalse ) );    

   371         

   372         // Touch pane

   373 

   374         TInt variety = 0;

   375         AknLayoutUtils::LayoutControl( 

   376             iTouchPane, 

   377             Rect(), 

   378             BubbleLayout6::call6_button_grp_pane(variety) );

   379         

   380         }

   381     else if ( iConfigFlags & EBMCallObjectDisplay )

   382         {

   383         // call object layout

   384         iMainPaneControl->SetRect( Rect() );

   385         DoLayoutCall2Bubbles();    

   386         }        

   387     else

   388         {

   389         // old thumbnail layout

   390         DoLayoutCall1Bubbles();    

   391         }

   392     

   393     // Layout number entry

   394     TInt neIndex;

   395     switch ( iNumberEntry->Place() )

   396         {

   397         case CBubbleOutlookNumberEntry::ENEBottomRight:

   398             neIndex = 1;

   399             break;

   400         case CBubbleOutlookNumberEntry::ENEIdleState:

   401             neIndex = 4;

   402             break;

   403         default: // CBubbleOutlookNumberEntry::ENEBottom

   404             neIndex = 0;

   405             break;                        

   406         }

   407 

   408     AknLayoutUtils::LayoutControl( 

   409         iNumberEntry, Rect( ), 

   410         BubbleLayout::popup_number_entry_window( neIndex ) );        

   411     

   412     // Layout muted icon

   413     if ( !(iConfigFlags & EBMTouchCallhandling) )

   414         {

   415         AknLayoutUtils::LayoutImage( 

   416             iMutedImage, Rect(), 

   417             BubbleLayout::main_pane_elements_muted( iNumberEntry->IsUsed() ) );        

   418         }

   419     }

   420 

   421 // ---------------------------------------------------------------------------

   422 // CBubbleManager::DoLayoutCall1Bubbles

   423 // ---------------------------------------------------------------------------

   424 //

   425 void CBubbleManager::DoLayoutCall1Bubbles()

   426     {

   427     CBubblePlace* tempBubblePlace = NULL;

   428     TUint8 placeCount( TUint8( iBubblePlaces->Count( ) ) );

   429     TAknWindowLineLayout placeLayout;

   430     

   431     for ( TUint8 index = 0 ; index < placeCount ; index++  ) 

   432         {

   433         tempBubblePlace = iBubblePlaces->At( index );

   434         CBubblePlace::TPhoneBubblePlace place = 

   435             tempBubblePlace->GetBubblePlace();

   436                     

   437         switch ( place )

   438             {

   439             case CBubblePlace::EBottom:

   440                 placeLayout = BubbleLayout::popup_call_audio_in_window(1);    

   441                 break;

   442                 

   443             case CBubblePlace::EBottomRightActive:

   444                 placeLayout = BubbleLayout::popup_call_audio_second_window(1);

   445                 break;

   446                 

   447             case CBubblePlace::EBottomRightHeld:

   448                 placeLayout = BubbleLayout::popup_call_audio_second_window(2);

   449                 break;

   450                 

   451             case CBubblePlace::EMiddleActive:

   452                 placeLayout = BubbleLayout::popup_call_audio_first_window(3);

   453                 break;

   454                 

   455             case CBubblePlace::EMiddleHeld:

   456                 if ( iBubblePlaces->At( CBubblePlace::EBottomCnap )->IsUsed() )

   457                     {

   458                     placeLayout = BubbleLayout::popup_call_audio_first_window(7);

   459                     }

   460                 else

   461                     {

   462                     placeLayout = BubbleLayout::popup_call_audio_first_window(2);

   463                     }

   464                 break;

   465                 

   466             case CBubblePlace::ETopLeft:

   467                 placeLayout = BubbleLayout::popup_call_audio_first_window(4);

   468                 break;

   469                 

   470             case CBubblePlace::ETopRight:

   471                 placeLayout = BubbleLayout::popup_call_audio_second_window(3);

   472                 break;

   473                 

   474             case CBubblePlace::EHide:

   475                 {

   476                 TInt v = AknLayoutUtils::ScalableLayoutInterfaceAvailable() ?

   477                          5 : 6;

   478                 placeLayout = BubbleLayout::popup_call_audio_first_window(v);

   479                 }

   480                 break;

   481                 

   482             case CBubblePlace::E2InConf:

   483                 placeLayout = BubbleLayout::popup_call_audio_conf_window(1);

   484                 break;

   485                 

   486             case CBubblePlace::E3InConf:

   487                 placeLayout = BubbleLayout::popup_call_audio_conf_window(2);

   488                 break;

   489                 

   490             case CBubblePlace::E4InConf:

   491                 placeLayout = BubbleLayout::popup_call_audio_conf_window(3);

   492                 break;

   493                 

   494             case CBubblePlace::E5InConf:

   495                 placeLayout = BubbleLayout::popup_call_audio_conf_window(4);

   496                 break;

   497                 

   498             case CBubblePlace::EBottomCnap:

   499                 placeLayout = BubbleLayout::popup_call_audio_in_window(3);

   500                 break;

   501                 

   502             case CBubblePlace::EMiddleCnap:

   503                 placeLayout = BubbleLayout::popup_call_audio_in_window(4);

   504                 break;

   505                 

   506             case CBubblePlace::EVideo:

   507                 placeLayout = BubbleLayout3::popup_call3_audio_in_window(0);

   508                 break;

   509 

   510             case CBubblePlace::EVideoCnap:

   511                 placeLayout = BubbleLayout3::popup_call3_audio_in_window(0);

   512                 break;                                                 

   513 

   514             case CBubblePlace::EBottomText: // not active

   515             case CBubblePlace::EBottomImage: // not active

   516             case CBubblePlace::EBottomRightCnap: // not active

   517             case CBubblePlace::EBottomImageCnap: // not active

   518                 placeLayout = BubbleLayout::popup_call_audio_in_window(1);

   519                 break;                 

   520                 

   521             default:

   522                 Panic( EBMPanicPlaceEnumerationDoesNotExist );

   523                 break;

   524             }

   525         

   526         AknLayoutUtils::LayoutControl( tempBubblePlace , Rect() , placeLayout );

   527         }    

   528     }

   529     

   530 // ---------------------------------------------------------------------------

   531 // CBubbleManager::DoLayoutCall2Bubbles

   532 // ---------------------------------------------------------------------------

   533 //

   534 void CBubbleManager::DoLayoutCall2Bubbles()

   535     {

   536     CBubblePlace* tempBubblePlace = NULL;

   537     TUint8 placeCount( TUint8( iBubblePlaces->Count( ) ) );

   538     TAknWindowLineLayout placeLayout;

   539     

   540     for ( TUint8 index = 0 ; index < placeCount ; index++  ) 

   541         {

   542         tempBubblePlace = iBubblePlaces->At( index );

   543         CBubblePlace::TPhoneBubblePlace place = 

   544             tempBubblePlace->GetBubblePlace();

   545         

   546         switch ( place )

   547             {

   548             case CBubblePlace::EBottom:

   549                 placeLayout = BubbleLayout2::popup_call2_audio_in_window(0);

   550                 break;

   551                 

   552             case CBubblePlace::EBottomRightActive:

   553                 placeLayout = BubbleLayout2::popup_call2_audio_second_window(0);

   554                 break;

   555                 

   556             case CBubblePlace::EBottomRightHeld:

   557                 placeLayout = BubbleLayout2::popup_call2_audio_second_window(1);    

   558                 break;

   559                 

   560             case CBubblePlace::EMiddleActive:

   561                 placeLayout = BubbleLayout2::popup_call2_audio_first_window(2);    

   562                 break;

   563                 

   564             case CBubblePlace::EMiddleHeld:

   565                 if ( iBubblePlaces->At( CBubblePlace::EBottomRightCnap )->IsUsed() )

   566                     {

   567                     placeLayout = BubbleLayout2::popup_call2_audio_first_window(18);

   568                     }

   569                 else

   570                     {

   571                     placeLayout = BubbleLayout2::popup_call2_audio_first_window(1);    

   572                     }                    

   573                 break;

   574                 

   575             case CBubblePlace::ETopLeft:

   576                 placeLayout = BubbleLayout2::popup_call2_audio_first_window(3);    

   577                 break;

   578                 

   579             case CBubblePlace::ETopRight:

   580                 placeLayout = BubbleLayout2::popup_call2_audio_second_window(2);    

   581                 break;

   582                 

   583             case CBubblePlace::EHide:

   584                 placeLayout = BubbleLayout2::popup_call2_audio_first_window(4);    

   585                 break;

   586                 

   587             case CBubblePlace::E2InConf:

   588                 placeLayout = BubbleLayout2::popup_call2_audio_conf_window(0);    

   589                 break;

   590                 

   591             case CBubblePlace::E3InConf:

   592                 placeLayout = BubbleLayout2::popup_call2_audio_conf_window(1);       

   593                 break;

   594                 

   595             case CBubblePlace::E4InConf:

   596                 placeLayout = BubbleLayout2::popup_call2_audio_conf_window(2);        

   597                 break;

   598                 

   599             case CBubblePlace::E5InConf:

   600                 placeLayout = BubbleLayout2::popup_call2_audio_conf_window(3);        

   601                 break;

   602                 

   603             case CBubblePlace::EBottomCnap:

   604                 placeLayout = BubbleLayout2::popup_call2_audio_in_window(2);    

   605                 break;

   606                 

   607             case CBubblePlace::EMiddleCnap:

   608                 placeLayout = BubbleLayout2::popup_call2_audio_in_window(3);    

   609                 break;

   610                 

   611             case CBubblePlace::EBottomText:

   612                 placeLayout = BubbleLayout2::popup_call2_audio_in_window(8);

   613                 break;                

   614 

   615             case CBubblePlace::EBottomImage:

   616                 placeLayout = BubbleLayout2::popup_call2_audio_first_window(0);

   617                 break;                

   618                 

   619             case CBubblePlace::EVideo:

   620                 placeLayout = BubbleLayout3::popup_call3_audio_in_window(0);

   621                 break;

   622 

   623             case CBubblePlace::EVideoCnap:

   624                 placeLayout = BubbleLayout3::popup_call3_audio_in_window(0);

   625                 break;

   626 

   627             case CBubblePlace::EBottomRightCnap:

   628                 placeLayout = BubbleLayout2::popup_call2_audio_wait_window(9);    

   629                 break;

   630                 

   631             case CBubblePlace::EBottomImageCnap:

   632                 placeLayout = BubbleLayout2::popup_call2_audio_first_window(0);    

   633                 break;                

   634                 

   635             default:

   636                 Panic( EBMPanicPlaceEnumerationDoesNotExist );

   637                 break;

   638             }

   639        

   640         AknLayoutUtils::LayoutControl( tempBubblePlace , Rect() , placeLayout );

   641         }    

   642     }    

   643 

   644 // ---------------------------------------------------------------------------

   645 // CBubbleManager::DoLayoutCall4Bubbles

   646 // ---------------------------------------------------------------------------

   647 //

   648 void CBubbleManager::DoLayoutCall4Bubbles( const TRect& aWindowPane )

   649     {

   650     CBubblePlace* tempBubblePlace = NULL;

   651     TUint8 placeCount( TUint8( iBubblePlaces->Count( ) ) );

   652     TAknWindowLineLayout placeLayout;

   653     TBool initCall = InitializingCall();

   654     

   655     for ( TUint8 index = 0 ; index < placeCount ; index++  ) 

   656         {

   657         tempBubblePlace = iBubblePlaces->At( index );

   658         CBubblePlace::TPhoneBubblePlace place = 

   659             tempBubblePlace->GetBubblePlace();

   660         

   661         switch ( place )

   662             {

   663             case CBubblePlace::EBottom:

   664             case CBubblePlace::EBottomCnap:

   665                 if ( initCall )

   666                     {

   667                     // in / out

   668                     placeLayout = 

   669                         BubbleLayout4::popup_call4_audio_in_window(4);

   670                     }

   671                 else

   672                     {

   673                     // incall

   674                     placeLayout =

   675                         BubbleLayout6::popup_call6_audio_first_window(0);    

   676                     }

   677                 

   678                 break;

   679                 

   680             // in / out with text

   681             case CBubblePlace::EBottomText:

   682                 placeLayout = BubbleLayout2::popup_call2_audio_in_window(8);

   683                 break;                

   684 

   685             // in with video                

   686             case CBubblePlace::EVideo:

   687             case CBubblePlace::EVideoCnap:

   688                 placeLayout = BubbleLayout3::popup_call3_audio_in_window(0);

   689                 break;

   690 

   691             // first

   692             case CBubblePlace::EBottomImage:

   693             case CBubblePlace::EBottomImageCnap:

   694                 placeLayout = BubbleLayout6::popup_call6_audio_first_window(0);

   695                 break;                

   696 

   697             // two calls - active

   698             case CBubblePlace::EBottomRightActiveTouch:

   699             case CBubblePlace::EBottomRightActiveCnapTouch:                

   700                 placeLayout = BubbleLayout4::popup_call4_audio_second_window(0);

   701                 break;

   702             // two calls - active                

   703             case CBubblePlace::EMiddleHeldTouch:                

   704                 placeLayout = BubbleLayout4::popup_call4_audio_first_window(1);          

   705                 break;                

   706             

   707             // three calls - held

   708             case CBubblePlace::ETopRight:

   709                 placeLayout = BubbleLayout4::popup_call4_audio_second_window(1);    

   710                 break;

   711             // two or three calls - active

   712             case CBubblePlace::ETopLeft:

   713                 placeLayout = BubbleLayout4::popup_call4_audio_first_window(2);    

   714                 break;

   715             // two or three calls - waiting    

   716             case CBubblePlace::EBottomRightActive:

   717             case CBubblePlace::EBottomRightCnap:

   718             case CBubblePlace::EBottomRightHeld:

   719                 placeLayout = BubbleLayout4::popup_call4_audio_wait_window(0);    

   720                 break;

   721             

   722             // conference

   723             case CBubblePlace::E2InConf:

   724                 placeLayout = BubbleLayout4::popup_call4_audio_conference_window(3);    

   725                 break;

   726                 

   727             case CBubblePlace::E3InConf:

   728                 placeLayout = BubbleLayout4::popup_call4_audio_conference_window(2);       

   729                 break;

   730                 

   731             case CBubblePlace::E4InConf:

   732                 placeLayout = BubbleLayout4::popup_call4_audio_conference_window(1);        

   733                 break;

   734                 

   735             case CBubblePlace::E5InConf:

   736                 placeLayout = BubbleLayout4::popup_call4_audio_conference_window(0);        

   737                 break;

   738 

   739             // not used in touch

   740             case CBubblePlace::EMiddleActive:

   741             case CBubblePlace::EMiddleHeld:

   742             case CBubblePlace::EMiddleCnap:

   743             case CBubblePlace::EHide:

   744                 continue;

   745                 

   746             default:

   747                 Panic( EBMPanicPlaceEnumerationDoesNotExist );

   748                 break;

   749             }

   750        

   751         AknLayoutUtils::LayoutControl( tempBubblePlace , aWindowPane , placeLayout );

   752         }    

   753     }    

   754 

   755 

   756 // ---------------------------------------------------------------------------

   757 // CBubbleManager::PositionChanged

   758 // ---------------------------------------------------------------------------

   759 //

   760 void CBubbleManager::PositionChanged()

   761     {

   762     AknsUtils::RegisterControlPosition( this );

   763     }

   764 

   765 // ---------------------------------------------------------------------------

   766 // CBubbleManager::CountComponentControls() const

   767 //

   768 //  Controls: NumberEntry, MutedImage and ActivePlaces

   769 // ---------------------------------------------------------------------------

   770 //

   771 TInt CBubbleManager::CountComponentControls() const

   772     {

   773     if ( ( iConfigFlags & EBMTouchCallhandling ) && 

   774          ( iTouchPane->IsVisible() ) )

   775         {

   776         return 3 + iActivePlaces->Count(); // ne + muted + touchpane + places

   777         }

   778     else

   779         {

   780         return 2 + iActivePlaces->Count(); // ne + muted + places

   781         }       

   782     }

   783 

   784 // ---------------------------------------------------------------------------

   785 // CBubbleManager::ComponentControl(TInt aIndex) const

   786 //

   787 //  First give active places. Then possible NE, muted-image and AnimStarter

   788 // ---------------------------------------------------------------------------

   789 //

   790 CCoeControl* CBubbleManager::ComponentControl( TInt aIndex ) const

   791     {

   792     TInt activePlacesCount = iActivePlaces->Count();

   793 

   794     // If too high value, return NULL

   795     if ( aIndex >= activePlacesCount + 3 )

   796         {

   797         return NULL;

   798         }

   799 

   800     if ( aIndex < activePlacesCount )

   801         {

   802         return iActivePlaces->At( aIndex  );

   803         }

   804 

   805     if ( aIndex == activePlacesCount )

   806         {

   807         return iNumberEntry;

   808         }

   809 

   810     if ( iConfigFlags & EBMTouchCallhandling )

   811         {

   812         if ( aIndex == ( activePlacesCount + 1 ) )

   813             {

   814             return iMutedImage;    

   815             }

   816 

   817         return iTouchPane;

   818         }

   819     else

   820         {

   821         return iMutedImage;    

   822         }

   823     }

   824 

   825 // ---------------------------------------------------------------------------

   826 // CBubbleManager::Draw

   827 // ---------------------------------------------------------------------------

   828 //

   829 void CBubbleManager::Draw( const TRect& aRect ) const

   830     {

   831     // clear the backround area.

   832     CWindowGc& gc = SystemGc();

   833     gc.SetBrushColor( AKN_LAF_COLOR( BubbleLayout::LayoutColourWhite() ) );

   834 

   835     // Draw just the bitmaps

   836     if ( iMainPaneControl &&

   837          iMainPaneControl->IsVisible() )

   838         {

   839         // main pane image

   840         iMainPaneControl->DrawBitmaps( aRect );

   841         }

   842     

   843     for ( TInt i = 0 ; i < iActivePlaces->Count() ; i++ )

   844         {

   845         iActivePlaces->At(i)->GetBubbleOutlook().DrawBitmaps( gc );

   846         }

   847     

   848     if ( iNumberEntry->IsUsed() )

   849         {

   850         iNumberEntry->DrawBitmaps(  gc );

   851         }

   852     }

   853     

   854 // ---------------------------------------------------------------------------

   855 //  CBubbleManager::MakeVisible

   856 //  

   857 // 

   858 // ---------------------------------------------------------------------------

   859 //

   860 void CBubbleManager::MakeVisible( TBool aVisible )

   861     {

   862     CCoeControl::MakeVisible( aVisible );

   863     

   864     if ( aVisible )    

   865         {

   866         StartAnimations();    

   867         }        

   868     }

   869 

   870 // ---------------------------------------------------------------------------

   871 // CBubbleManager::StartChanges

   872 //  

   873 //  Reset all places so there won't be anything wrong left.

   874 // ---------------------------------------------------------------------------

   875 //

   876 EXPORT_C void CBubbleManager::StartChanges( )

   877     {

   878     BM_TRACE_( "[BUBBLEMANAGER] CBubbleManager::StartChanges" );

   879     iIsReadyToDraw++;

   880     if ( iIsReadyToDraw > 1 ) // is this called already?

   881         {

   882         return;

   883         }

   884     

   885     // clear all used areas

   886     CBubblePlace* tempBubblePlace = NULL;

   887     TInt placeCount = iBubblePlaces->Count();

   888     for ( TUint8 index = 0 ; index < placeCount ; index++  ) 

   889         {

   890         tempBubblePlace = iBubblePlaces->At( index );

   891         if ( tempBubblePlace->IsUsed() )

   892             {

   893             Window().Invalidate( tempBubblePlace->Rect() );

   894             tempBubblePlace->SetIsUsed( EFalse );

   895             }

   896         }

   897     

   898     iActivePlaces->Delete( 0 , iActivePlaces->Count() ); // do not compress!!

   899 

   900     if ( iTouchPane )

   901         {

   902         iTouchPane->SetUpdating( ETrue );                

   903         }

   904     }

   905 

   906 // ---------------------------------------------------------------------------

   907 // CBubbleManager::EndChanges

   908 //  

   909 //  Check the situation and decide which outlook to take. 

   910 // ---------------------------------------------------------------------------

   911 //

   912 EXPORT_C void CBubbleManager::EndChanges( )

   913     {

   914     BM_TRACE_( "[BUBBLEMANAGER] CBubbleManager::EndChanges" );

   915      

   916     __ASSERT_ALWAYS( 

   917         iIsReadyToDraw > 0 , Panic( EBMPanicErrorInStartAndEndChanges ) );

   918 

   919     iIsReadyToDraw--;

   920     if ( iIsReadyToDraw != 0 )

   921         {

   922         return;

   923         }

   924 

   925     if ( iConfHeader->IsExpanded() )

   926         {

   927         BuildExpandedConference();

   928         }

   929     else if ( iNumberEntry->IsUsed() && iNumberEntry->IsVisible() )

   930         {

   931         BuildBubblesWithNE();

   932         }

   933     else if ( ( iConfigFlags & EBMTouchCallhandling ) )

   934         {

   935         BuildBubblesForTouch();    

   936         }

   937     else

   938         {

   939         BuildBubbles();

   940         }

   941 

   942     // Stop video if playing and video bubble is not active.

   943     if ( ( iVideoFlags & EBMVideoPlayingVideo ) &&

   944          !( iVideoFlags & EBMVideoBubbleActive ) )

   945         {

   946         StopAndDeleteVideoPlayer();

   947         }                

   948 

   949     // Touch pane        

   950     if ( iConfigFlags & EBMTouchCallhandling )

   951         {

   952         if ( iTouchPaneSetVisible &&        // Client sets

   953              iActiveHeaders->Count() > 0 && // Incall situation                   

   954              !iNumberEntry->IsVisible() )   

   955             {

   956             iTouchPane->MakeVisible( ETrue );

   957             }

   958         else

   959             {

   960             iTouchPane->MakeVisible( EFalse );    

   961             }    

   962         }

   963 

   964     if ( ( iConfigFlags & EBMCallObjectDisplay ) && 

   965          iActiveHeaders->Count() > 0 &&

   966          !( iVideoFlags & EBMVideoBubbleActive ) )

   967         {

   968         // Image is created only for incoming & outgoing

   969         // calls, check is inside method.

   970         BuildMainPaneImage();

   971         }

   972     

   973     SizeChanged();

   974     

   975     // Invalidate the new areas.

   976     for ( TInt i = 0 ; i < iActivePlaces->Count() ; i++ )

   977         {

   978         iActivePlaces->At(i)->GetBubbleOutlook().DrawDeferred();

   979         }

   980     if ( iNumberEntry->IsUsed() )

   981         {

   982         iNumberEntry->DrawDeferred();

   983         iNumberEntry->GetEditor()->DrawDeferred();

   984         }

   985         

   986     if ( iTouchPane )

   987         {

   988         iTouchPane->SetUpdating( EFalse );

   989         }

   990             

   991 #ifdef RD_UI_TRANSITION_EFFECTS_PHASE2

   992     TBool calledBegin = (TBool) CAknTransitionUtils::GetData( ( TInt ) this );

   993     // Only draw parent control if no number entry exists, the number entry is

   994     // used or if begin has not been called.

   995     if ( !iNumberEntry || iNumberEntry->IsUsed() || !calledBegin )

   996         {

   997         // Do redraw. Do not use DrawDeferred() here!

   998         iParentControl->DrawNow();

   999         }

  1000 #else

  1001     // Do redraw. Do not use DrawDeferred() here!

  1002     iParentControl->DrawNow();

  1003 #endif

  1004     // Start animations. 

  1005     StartAnimations();

  1006     

  1007     // Start video if video bubble is active.

  1008     if ( ( iVideoFlags & EBMVideoBubbleActive ) &&

  1009          !( iVideoFlags & EBMVideoPlayingVideo ) )

  1010         {

  1011         CreateVideoPlayerAndPlay();

  1012         }

  1013 #ifdef RD_UI_TRANSITION_EFFECTS_PHASE2

  1014     if ( calledBegin )

  1015         {

  1016         // Initialize transition effect

  1017         CAknTransitionUtils::SetAllParents( iNumberEntry );

  1018         GfxTransEffect::SetDemarcation( iNumberEntry, iNumberEntry->Rect() );

  1019         GfxTransEffect::End( iNumberEntry );

  1020 

  1021         // Reset begin call reminder

  1022         CAknTransitionUtils::SetData( (TInt) this, 0 );

  1023         }

  1024     // SetFocus here instead of in SetNumberEntryVisible

  1025     if ( iNumberEntry->IsVisible() )

  1026         {

  1027         iNumberEntry->SetFocus( ETrue );

  1028         }

  1029 #endif

  1030     return;

  1031     }

  1032 

  1033 

  1034 // ---------------------------------------------------------------------------

  1035 //  CBubbleManager::SetActivePlace

  1036 //  

  1037 //  This helps the EndChanges() to make bubble places active.

  1038 // ---------------------------------------------------------------------------

  1039 //

  1040 void CBubbleManager::SetActivePlace( 

  1041     const CBubblePlace::TPhoneBubblePlace& aPlace , 

  1042     CBubbleHeader& aHeader )

  1043     {

  1044     CBubblePlace* place = iBubblePlaces->At( aPlace );

  1045     place->SetIsUsed( ETrue );

  1046     CBubbleOutlook& bubbleOutlook = place->GetBubbleOutlook( );

  1047     bubbleOutlook.ReadBubbleHeader( aHeader );

  1048     iActivePlaces->InsertL( iActivePlaces->Count( ), place ); // Can't leave

  1049     }

  1050 

  1051 

  1052 void CBubbleManager::BuildExpandedConference()

  1053     {

  1054     iNumberEntry->SetPlace( CBubbleOutlookNumberEntry::ENENone );

  1055     switch ( iConfHeader->RowCount() )

  1056         {

  1057         // Cases mean number of calls in conference.

  1058         case 2:

  1059             SetActivePlace( CBubblePlace::E2InConf , *iConfHeader );

  1060             break;

  1061         case 3:

  1062             SetActivePlace( CBubblePlace::E3InConf , *iConfHeader );

  1063             break;

  1064         case 4:

  1065             SetActivePlace( CBubblePlace::E4InConf , *iConfHeader );

  1066             break;

  1067         case 5:

  1068             SetActivePlace( CBubblePlace::E5InConf , *iConfHeader );

  1069             break;

  1070         default:

  1071             Panic( EBMPanicPlaceEnumerationDoesNotExist );

  1072             break;

  1073         }

  1074     return;

  1075     }

  1076 

  1077 

  1078 // ---------------------------------------------------------------------------

  1079 //  CBubbleManager::FindNextDrawableHeader

  1080 //  

  1081 // 

  1082 // ---------------------------------------------------------------------------

  1083 //

  1084 void CBubbleManager::FindNextDrawableHeader( TUint8& aIndex )

  1085     {

  1086     while( iActiveHeaders->At( aIndex )->IsInConference() ) 

  1087         {

  1088         aIndex++;

  1089         }

  1090     }

  1091 

  1092 // ---------------------------------------------------------------------------

  1093 //  CBubbleManager::ShownHeaderCount

  1094 // ---------------------------------------------------------------------------

  1095 //

  1096 EXPORT_C TUint8 CBubbleManager::ShownHeaderCount() const

  1097     {

  1098     // We have to find headers that are really shown. 

  1099     // That means headers which are 

  1100     // used and are NOT in conference. 

  1101     TUint8 bubbleAmount = 0;

  1102     TUint activeCount = iActiveHeaders->Count();

  1103     for (TUint8 i = 0 ; i < activeCount ; i++ )

  1104         {

  1105         if ( !iActiveHeaders->At(i)->IsInConference() )

  1106             {

  1107             bubbleAmount++;

  1108             }

  1109         }

  1110     return bubbleAmount;

  1111     }

  1112 

  1113 // ---------------------------------------------------------------------------

  1114 //  CBubbleManager::BuildBubbles

  1115 //  

  1116 // 

  1117 // ---------------------------------------------------------------------------

  1118 //

  1119 void CBubbleManager::BuildBubbles()

  1120     { 

  1121     const TUint8 bubbleAmount = ShownHeaderCount();

  1122     iVideoFlags &= ~EBMVideoBubbleActive;

  1123     

  1124     // Without number entry.

  1125     switch ( bubbleAmount )

  1126         {

  1127         case 0:

  1128             break;

  1129         case 1:

  1130             {

  1131             TUint8 index = 0;

  1132             FindNextDrawableHeader( index );

  1133             CBubbleHeader* header = iActiveHeaders->At( index );

  1134             TPhoneCallState callState = header->CallState();