FCL/sf/mw/classicui: comparison uifw/EikStd/coctlsrc/eikcba.cpp

equal deleted inserted replaced

-:aabf2c525e0f
+:9f56a4e1b8ab
 #include <AknTasHook.h>
 #include <akncbacontentobserver.h>
 #include <aknitemactionmenu.h>
 #include "akncollectionobserver.h"
 #include "aknitemactionmenuregister.h"
+#include "akntrace.h"
 /**
 * Color value for transparent pixel (ARGB format).
 */
 const TUint32 KAknCbaColorKey = 0x00000000;
 #include <touchfeedback.h>
 inline TAknWindowComponentLayout DoCompose(TAknWindowComponentLayout aLine1,
 TAknWindowComponentLayout aLine2)
 {
+_AKNTRACE_FUNC_ENTER;
+_AKNTRACE_FUNC_EXIT;
 return TAknWindowComponentLayout::Compose(aLine1, aLine2);
 }
 inline TAknTextComponentLayout DoComposeText(TAknWindowComponentLayout aLine1,
 TAknTextComponentLayout aLine2)
 {
+_AKNTRACE_FUNC_ENTER;
+_AKNTRACE_FUNC_EXIT;
 return TAknWindowComponentLayout::ComposeText(aLine1, aLine2);
 }
 /**
 * Checks if right side pane is active.
 * @return ETrue if right side pane is active, EFalse otherwise.
 */
 static TBool IsAreaSideRightPaneActive()
 {
+_AKNTRACE_FUNC_ENTER;
+_AKNTRACE_FUNC_EXIT;
 return EFalse;
 }
 /**
 * Checks if MSK-enabled layout is in use.
 */
 static TBool IsMskEnabledLayoutActive()
 {
+_AKNTRACE_FUNC_ENTER;
 TBool result( EFalse );
 if ( Layout_Meta_Data::IsMSKEnabled() )
 {
 // First check if MSK is enabled in the layout metadata.
 // these status pane layouts an exception is made.
 result = ETrue;
 }
 }
+_AKNTRACE_FUNC_EXIT;
 return result;
 }
 /*
 * Checks if bitmap must be updated, i.e. bitmap does not exist or
 * expected size does not match with actual size.
 */
 static TBool IsBitmapUpdateNeeded( CFbsBitmap* aOldBitmap, const TSize& aSize )
 {
+_AKNTRACE_FUNC_ENTER;
+_AKNTRACE_FUNC_EXIT;
 return !aOldBitmap || ( aOldBitmap->SizeInPixels() != aSize );
 }
 /**
 iCbaBgIIDSetExt( EFalse )
 ,iLeftFrameMask( NULL ),
 iRightFrameMask( NULL ),
 iItemActionMenu( NULL )
 {
+_AKNTRACE_FUNC_ENTER;
+_AKNTRACE_FUNC_EXIT;
 };
 static CEikCbaExtension* NewL( CEikCba& aOwner )
 {
+_AKNTRACE_FUNC_ENTER;
 CEikCbaExtension* self = new (ELeave) CEikCbaExtension( aOwner );
 CleanupStack::PushL( self );
 self->ConstructL();
 CleanupStack::Pop( self );
+_AKNTRACE_FUNC_EXIT;
 return self;
 }
 void ConstructL()
 {
+_AKNTRACE_FUNC_ENTER;
 // Wallpaper is not drawn by embedded CBA.
 if ( !iOwner.Flags().IsSet( ECbaEmbedded ) )
 {
 iRepository = CRepository::NewL( KCRUidPersonalisation );
 iRepository->Get( KPslnWallpaperType, iWallpaperInUse );
 if ( iOwner.Flags().IsSet( ECbaSingleClickEnabled ) )
 {
 AknItemActionMenuRegister::RegisterCollectionObserverL(
 *this );
 }
+_AKNTRACE_FUNC_EXIT;
 }
 ~CEikCbaExtension()
 {
+_AKNTRACE_FUNC_ENTER;
 if ( iOwner.Flags().IsSet( ECbaSingleClickEnabled ) )
 {
 AknItemActionMenuRegister::UnregisterCollectionObserver( *this );
 }
 if ( iCRListener )
 delete iLeftFrameMask;
 delete iRightFrameMask;
 delete iLskPostingOverlayBitmap;
 delete iRskPostingOverlayBitmap;
 delete iBmpFile;
+_AKNTRACE_FUNC_EXIT;
 }
 /** From base class MCenRepNotifyHandlerCallback */
 void HandleNotifyInt( TUint32 /*aId*/, TInt aNewValue )
 {
+_AKNTRACE_FUNC_ENTER;
 iWallpaperInUse = aNewValue;
 iOwner.SetSkinBackgroundId( KAknsIIDNone );
+_AKNTRACE_FUNC_EXIT;
 }
 void UpdateSoftkeyFrameL( TBool aForcedUpdate )
 {
+_AKNTRACE_FUNC_ENTER;
 if ( !AknLayoutUtils::PenEnabled() )
 {
+_AKNTRACE_FUNC_EXIT;
 return;
 }
 TAknLayoutRect cbarect;
 TRect screen;
 iUpdateFrameOuterRect = outerRect;
 iUpdateFrameInnerRect = innerRect;
 iUpdateMSKFrameOuterRect = mskOuterRect;
 iUpdateMskFrameInnerRect = mskInnerRect;
+_AKNTRACE_FUNC_EXIT;
 }
 * @param aMask mask to be merged.
 * @param aDestBitmap bitmap to merge mask with.
 */
 static void MergeMaskInto16MA( CFbsBitmap* aMask, CFbsBitmap* aDestBitmap )
 {
+_AKNTRACE_FUNC_ENTER;
 // aMask display mode must be EGray256.
 // aMask must not be compressed in RAM.
 // aDestBitmap display mode must be EColor16MA.
 // aDestBitmap must not be compressed in RAM.
 // aMask size must equal to aDestBitmap size.
 }
 }
 }
 aDestBitmap->UnlockHeap();
 aMask->UnlockHeap();
+_AKNTRACE_FUNC_EXIT;
 }
 /**
 * Updates posting overlay bitmap.
 * @internal
 void UpdatePostingOverlayBitmapL(
 CFbsBitmap*& aBitmap,
 const TRect& aRect,
 CEikCbaButton* aButton )
 {
+_AKNTRACE_FUNC_ENTER;
 delete aBitmap;
 aBitmap = NULL;
 // If you modify this method, please make sure that assumptions
 // mentioned in MergeMaskInto16MA still hold.
 }
 CleanupStack::PopAndDestroy( 2, bitmapDevice );
 CleanupStack::Pop( bitmap );
 aBitmap = bitmap;
+_AKNTRACE_FUNC_EXIT;
 }
 /**
 * Updates posting overlay bitmaps.
 * @param aCbaRect cba rect.
 const TRect& aCbaRect,
 CEikCbaButton* aLeftButton,
 CEikCbaButton* aRightButton,
 TInt aAknLayoutFlags )
 {
+_AKNTRACE_FUNC_ENTER;
 TRect rightSoftKeyButtonRect;
 TRect leftSoftKeyButtonRect;
 if( aAknLayoutFlags & EAknLayoutCbaInRightPane )
 {
 // Read right (top in landscape) softkey layout.
 aLeftButton );
 UpdatePostingOverlayBitmapL(
 iRskPostingOverlayBitmap,
 rightSoftKeyButtonRect,
 aRightButton );
+_AKNTRACE_FUNC_EXIT;
 }
 /**
 * From MAknCollectionObserver.
 * This method is used to set the item action menu to observer.
 *
 * @param aItemActionMenu Item action menu.
 */
 void SetItemActionMenu( CAknItemActionMenu* aItemActionMenu )
 {
+_AKNTRACE_FUNC_ENTER;
 iItemActionMenu = aItemActionMenu;
+_AKNTRACE_FUNC_EXIT;
 }
 /**
 * From MAknCollectionObserver.
 * This method is called when there are changes in collection state.
 *
 * @param aCollectionVisible ETrue if changed collection is visible.
 */
 void CollectionChanged( TBool aCollectionVisible )
 {
+_AKNTRACE_FUNC_ENTER;
 // Do not update state if invisible collection tries to enable sk
 if ( aCollectionVisible
 || iOwner.Flags().IsClear( ECbaItemSoftkeyDisabled ) )
 {
 iOwner.UpdateItemSpecificSoftkey();
 }
+_AKNTRACE_FUNC_EXIT;
 }
 /**
 * From MAknCollectionObserver.
 * This method returns ETrue if collection observer is active.
 *
 * @return ETrue if observer is active.
 */
 TBool Active() const
 {
+_AKNTRACE_FUNC_ENTER;
+_AKNTRACE_FUNC_EXIT;
 return iOwner.IsVisible() && !iOwner.IsEmpty();
 }
 /*
 * Using the special theme Id draw background
 */
-void DrawSemiTransparencyL(CWindowGc& aGc,
+void DrawSemiTransparency( CWindowGc& aGc,
-const TRect& aRect)
+const TRect& aRect )
-	{
+{
+_AKNTRACE_FUNC_ENTER;
 aGc.SetBrushStyle( CGraphicsContext::ESolidBrush );
 aGc.SetBrushColor( TRgb(128, 128, 128, 64) );
 aGc.Clear();
 TAknsItemID SemiButtonID = KAknsIIDQgnHomeButtonWidget;
 iRightFrameOuterRect,
 innerRect,//iRightFrameInnerRect,
 SemiButtonID,
 SemiButtonCenterID);
 }
-	}
+_AKNTRACE_FUNC_EXIT;
+}
 public:
 CEikCba&               iOwner;
 CRepository*           iRepository;
 CCenRepNotifyHandler*  iCRListener;
 CEikCba* CEikCba::NewL(const CEikCba* aPrevious, MEikCommandObserver* aCommandObserver,
 RWindowGroup* aParentWg)
 {
+_AKNTRACE_FUNC_ENTER;
 CEikCba* self = CEikCba::NewLC(aPrevious, aCommandObserver, aParentWg); // static
 CleanupStack::Pop( self );
+_AKNTRACE_FUNC_EXIT;
 return self;
 }
 CEikCba* CEikCba::NewL(TInt aResourceId, const CEikCba* aPrevious,
 MEikCommandObserver* aCommandObserver, RWindowGroup* aParentWg)
 {
+_AKNTRACE_FUNC_ENTER;
 CEikCba* self = CEikCba::NewLC(aResourceId, aPrevious, aCommandObserver, aParentWg); // static
 CleanupStack::Pop( self );
+_AKNTRACE_FUNC_EXIT;
 return self;
 }
 CEikCba* CEikCba::NewLC(const CEikCba* aPrevious, MEikCommandObserver* aCommandObserver,
 RWindowGroup* aParentWg)
 {
+_AKNTRACE_FUNC_ENTER;
+_AKNTRACE_FUNC_EXIT;
 return CEikCba::NewLC(KNoResource, aPrevious, aCommandObserver, aParentWg); // static
 }
 CEikCba* CEikCba::NewLC(const CEikCba* aPrevious,
 MEikCommandObserver* aCommandObserver, RWindowGroup* aParentWg,
 TUint aFlags)
 {
+_AKNTRACE_FUNC_ENTER;
+_AKNTRACE_FUNC_EXIT;
 return CEikCba::NewLC(KNoResource, aPrevious, aCommandObserver,
 aParentWg, aFlags);
 }
 CEikCba* CEikCba::NewLC(TInt aResourceId, const CEikCba* aPrevious,
 MEikCommandObserver* aCommandObserver, RWindowGroup* aParentWg)
 {
+_AKNTRACE_FUNC_ENTER;
 CEikCba* self = new(ELeave) CEikCba(aPrevious, aCommandObserver, aParentWg); // static
 CleanupStack::PushL(self);
 self->ConstructL(aResourceId);
 AKNTASHOOK_ADDL( self, "CEikCba" );
+_AKNTRACE_FUNC_EXIT;
 return self;
 }
 CEikCba* CEikCba::NewLC(TInt aResourceId, const CEikCba* aPrevious,
 MEikCommandObserver* aCommandObserver, RWindowGroup* aParentWg,
 TUint aFlags)
 {
+_AKNTRACE_FUNC_ENTER;
 CEikCba* self = new(ELeave) CEikCba(aPrevious, aCommandObserver,
 aParentWg, aFlags);
 CleanupStack::PushL(self);
 self->ConstructL(aResourceId);
 AKNTASHOOK_ADDL( self, "CEikCba" );
+_AKNTRACE_FUNC_EXIT;
 return self;
 }
 /**
 * Destructor.
 */
 CEikCba::~CEikCba()
 {
+_AKNTRACE_FUNC_ENTER;
 AKNTASHOOK_REMOVE();
 // Revert the clock and indicator pane area of status pane
 // to use the previous skin background.
 CEikStatusPaneBase* sp = CEikStatusPaneBase::Current();
 if ( sp &&
 #ifdef RD_ENHANCED_CBA
 delete iCommandTable;
 #endif // RD_ENHANCED_CBA
 delete iExtension;
+_AKNTRACE_FUNC_EXIT;
 }
 /**
 * Constructor.
 */
 CEikCba::CEikCba(const CEikCba* aPrevious,
 MEikCommandObserver* aCommandObserver, RWindowGroup* aParentWg,
 TUint aFlags)
 : iLink(aPrevious), iCommandObserver(aCommandObserver), iParentWg(aParentWg)
 {
+_AKNTRACE_FUNC_ENTER;
 if (aFlags & CEikButtonGroupContainer::EIsEmbedded)
 {
 // CBA is embedded in another component (eg. dialog/popup/setting page
 iFlags.Set(ECbaEmbedded);
 }
 if ( aFlags & CEikButtonGroupContainer::EParentIsControl )
 {
 iFlags.Set( ECbaParentAsControl );
 }
-	if ( aFlags & CEikButtonGroupContainer::EDelayActivation )
+if ( aFlags & CEikButtonGroupContainer::EDelayActivation )
 {
 iFlags.Set( ECbaActivationDelayed );
 }
 CAknAppUi* appUi = static_cast<CAknAppUi*>( iCoeEnv->AppUi() );
 iFlags.Set( ECbaSingleClickEnabled );
 iFlags.Set( ECbaItemSpecificSoftkeyInUse );
 }
 SetNonFocusing();
+_AKNTRACE_FUNC_EXIT;
 }
 void CEikCba::SetContainerWindowL( const CCoeControl& aContainer )
 {
+_AKNTRACE_FUNC_ENTER;
 // CCoeControl::SetContainerWindowL closes the previously own window and
 // deactivates control. Therefore store the activation status and re-set
 // it after the container window has been set.
 // Removed to enable drawing of Query Input in one phase
 }
 else
 {
 CCoeControl::SetContainerWindowL( aContainer );
 }
+_AKNTRACE_FUNC_EXIT;
 }
 void CEikCba::ActivateL()
 {
+_AKNTRACE_FUNC_ENTER;
 CCoeControl::ActivateL();
+_AKNTRACE_FUNC_EXIT;
 }
 void CEikCba::BaseConstructL()
 {
+_AKNTRACE_FUNC_ENTER;
 if ( iFlags.IsSet( ECbaEmbedded ) && iFlags.IsSet( ECbaParentAsControl ) )
 {
 __ASSERT_DEBUG( iParentWg, User::Invariant() );
 CreateWindowL( (CCoeControl*)iParentWg );
 EnableWindowTransparency();
 // Default value.
 iClockIndicBgIID = KAknsIIDQsnBgAreaControl;
 }
 }
 }
+_AKNTRACE_FUNC_EXIT;
 }
 void CEikCba::ConstructL(TInt aResourceId)
 {
+_AKNTRACE_FUNC_ENTER;
 if (aResourceId != KNoResource)
 {
 TResourceReader reader;
 iCoeEnv->CreateResourceReaderLC(reader, aResourceId);
 iCbaFlags = reader.ReadInt32();        // flags resource
-const TUid KActiveIdle2Uid = {0x102750F0};
-CEikApplication* app = CEikonEnv::Static()->EikAppUi()->Application();
-if ( app && app->AppDllUid() == KActiveIdle2Uid )
-{
-//it's intereting that the transparent can't not be set after the CBA was created for a while.
-//it just can be done in the CBA constructor, maybe some defect in Window server, but I'm not sure
-//about that, in order to fix the defect I have hardcode the transparent flag for homescreen the only usercase.
-//it should be fixed later.
-iCbaFlags |= EEikCbaFlagSemiTransparent;
-}
 // If using enhanced cba.
 if ( (iCbaFlags & EEikEnhancedButtonGroup) == EEikEnhancedButtonGroup )
 {
 #ifdef RD_ENHANCED_CBA
 iCommandTable = CEikCommandTable::NewL();
 }
 }
 // Set CBA faded in case the softkeys are empty.
 SetFadeState();
+_AKNTRACE_FUNC_EXIT;
 }
 void CEikCba::ConstructFromResourceL(TResourceReader& aReader)
 {
+_AKNTRACE_FUNC_ENTER;
 BaseConstructL();
 CreateScrollBarFrameL();
 TGulAlignmentValue anAlignment[3] = {EHLeftVCenter, EHRightVCenter, EHCenterVCenter};
 iCbaFlags = aReader.ReadInt32(); // flags resource
 iSize.iWidth = aReader.ReadInt16();
 }
 }
 // Set CBA faded in case the softkeys are empty.
 SetFadeState();
+_AKNTRACE_FUNC_EXIT;
 }
 TInt CEikCba::MaxCommands() const
 {
+_AKNTRACE_FUNC_ENTER;
+_AKNTRACE_FUNC_EXIT;
 return KMaxSeries60Softkeys;
 }
 TInt CEikCba::MSKEnabledInPlatform() const
 {
+_AKNTRACE_FUNC_ENTER;
+_AKNTRACE_FUNC_EXIT;
 return iMSKEnabledInPlatform;
 }
 // ---------------------------------------------------------------------------
 // Sets the middle softkey icon.
 // ---------------------------------------------------------------------------
 //
 void CEikCba::SetMSKIconL()
 {
+_AKNTRACE_FUNC_ENTER;
 // MSK is not supported by dialog-embedded CBAs.
 if ( iFlags.IsSet( ECbaInsideDialog ) || iFlags.IsSet( ECbaEmbedded ) )
 {
+_AKNTRACE_FUNC_EXIT;
 return;
 }
 if ( !MskAllowed() )
 {
+_AKNTRACE_FUNC_EXIT;
 return;
 }
 MAknsSkinInstance* skin = AknsUtils::SkinInstance();
 if ( !skin )
 {
+_AKNTRACE_FUNC_EXIT;
 return;
 }
 if( iExtension->iIfMskIconSet )
 {
-//	UpdateIconL();
+//    UpdateIconL();
-	return;
+_AKNTRACE_FUNC_EXIT;
+return;
 }
 TEikGroupControl &gCtrl = iControlArray->At( KControlArrayCBAButtonMSKPosn );
 CEikCbaButton *button = static_cast<CEikCbaButton*>( gCtrl.iControl );
 if ( !button )
 {
+_AKNTRACE_FUNC_EXIT;
 return;
 }
 CFbsBitmap *bitmap = NULL;
 CFbsBitmap *mask = NULL;
 {
 button->ReplaceImageByLabel(); // remove old image
 }
 button->SetContainerWindowL( *this );
+_AKNTRACE_FUNC_EXIT;
 }
 EXPORT_C TBool CEikCba::UpdateMSKIconL( const TAknsItemID& aId,
 const TDesC& aBmpFile,
 const TInt32 aBmp,
 const TInt32 aBmpM,
 TBool aEnable )
 {
+_AKNTRACE_FUNC_ENTER;
 iExtension->iIfMskIconSet = EFalse;
 // MSK is not supported by dialog-embedded CBAs.
 if (!aEnable)
 {
-	SetMSKIconL();
+SetMSKIconL();
-	return ETrue;
+_AKNTRACE_FUNC_EXIT;
+return ETrue;
 }
 delete iExtension->iBmpFile;
 iExtension->iBmpFile = NULL;
 iExtension->iBmpFile = aBmpFile.AllocL();
 iExtension->iMSKSkinID = aId;
 iExtension->iBmp = aBmp;
 iExtension->iBmpM = aBmpM;
+_AKNTRACE_FUNC_EXIT;
 return UpdateIconL();
 }
 // ----------------------------------------------------------------------------
 // CEikCba::EnableItemSpecificSoftkey
 // ----------------------------------------------------------------------------
 //
 EXPORT_C void CEikCba::EnableItemSpecificSoftkey( TBool aEnable )
 {
+_AKNTRACE_FUNC_ENTER;
 if ( iFlags.IsSet( ECbaSingleClickEnabled ) )
 {
 iFlags.Assign( ECbaItemSpecificSoftkeyInUse, aEnable );
 if ( aEnable )
 leftSoftkey.iControl->SetDimmed( EFalse );
 leftSoftkey.iControl->DrawDeferred();
 }
 }
 }
+_AKNTRACE_FUNC_EXIT;
 }
 void CEikCba::SetMSKCommandObserver(MEikCommandObserver* aCommandObserver)
 {
+_AKNTRACE_FUNC_ENTER;
 // aCommandObserver set to NULL when removing observer.
 iMSKCommandObserver = aCommandObserver;
+_AKNTRACE_FUNC_EXIT;
 }
 void CEikCba::UpdateCbaLabels(TBool aScrollerOn)
 {
+_AKNTRACE_FUNC_ENTER;
 // This method is called only from scrollbar that has nothing to do with
 // dialog-embedded CBAs -> ignore the call.
 if ( iFlags.IsSet( ECbaInsideDialog ) )
 {
+_AKNTRACE_FUNC_EXIT;
 return;
 }
 // Communicate change to CBA buttons.
 for (TInt ii = 0; ii < iControlArray->Count(); ii++)
 }
 }
 // Change of text may affect layout.
 SizeChanged();
 DrawDeferred() ;
+_AKNTRACE_FUNC_EXIT;
 }
 void CEikCba::SetSBFrameObserver(MEikScrollBarObserver* aObserver)
 {
+_AKNTRACE_FUNC_ENTER;
 if(iSBFrame)
 {
 iSBFrame->SetScrollBarFrameObserver(aObserver);
 }
+_AKNTRACE_FUNC_EXIT;
 }
 void CEikCba::SetScrollBarModelL(TEikScrollBarModel* aModel)
 {
+_AKNTRACE_FUNC_ENTER;
 if(iSBFrame)
 {
 VScrollBarAsControl()->SetModelL(aModel);
 }
+_AKNTRACE_FUNC_EXIT;
 }
 const CEikCbaScrollBarFrame* CEikCba::ScrollBarFrame() const
 {
+_AKNTRACE_FUNC_ENTER;
+_AKNTRACE_FUNC_EXIT;
 return STATIC_CAST(const CEikCbaScrollBarFrame*, iSBFrame);
 }
 CAknScrollBar* CEikCba::VScrollBarAsControl()
 {
+_AKNTRACE_FUNC_ENTER;
+_AKNTRACE_FUNC_EXIT;
 return STATIC_CAST(CAknScrollBar*, VScrollBarAsGroupControl().iControl);
 }
 void CEikCba::InsertControlL(TEikGroupControl& aGroupControl,TInt aIndex)
 {
+_AKNTRACE_FUNC_ENTER;
 iControlArray->InsertL(aIndex,aGroupControl); // Takes ownership at this point.
+_AKNTRACE_FUNC_EXIT;
 }
 void CEikCba::SetCommandL( TInt aPosition,
 TInt aCommandId,
 const TDesC* aText,
 const CFbsBitmap* /*aBitmap*/,
 const CFbsBitmap* /*aMask*/ )
 {
+_AKNTRACE_FUNC_ENTER;
 // We need to check if this call changes the softkeys from being
 // empty to having a command or vice versa to be able to maintain
 // correct fade state.
 TBool isEmptyBefore( IsEmpty() );
 {
 SetFadeState();
 }
 ReportContentChangedEvent();
+_AKNTRACE_FUNC_EXIT;
 }
 void CEikCba::SetCommandL(TInt aPosition,TInt aResourceId)
 {
+_AKNTRACE_FUNC_ENTER;
 TResourceReader reader;
 iCoeEnv->CreateResourceReaderLC(reader,aResourceId);
 TInt version = reader.ReadInt8(); // version
 #ifdef RD_ENHANCED_CBA
 TPtrC text = reader.ReadTPtrC();
 SetCommandL(aPosition, commandId, &text, NULL, NULL);
 CleanupStack::PopAndDestroy(); // reader
 ReportContentChangedEvent();
+_AKNTRACE_FUNC_EXIT;
 }
 /**
 * Installs a new set of commands to be associated with the cba buttons.
 * The previous command set is restored if there is an error while adding
 * the new command set.
 */
 void CEikCba::SetCommandSetL(TInt aResourceId)
 {
+_AKNTRACE_FUNC_ENTER;
 TResourceReader reader;
 iCoeEnv->CreateResourceReaderLC(reader, aResourceId);
 iCbaFlags = reader.ReadInt32();
 if ( ( iCbaFlags & EEikEnhancedButtonGroup ) == EEikEnhancedButtonGroup )
 {
 CleanupStack::PopAndDestroy(); // reader
 OfferCommandListL( aResourceId );
+_AKNTRACE_FUNC_EXIT;
 return;
 }
 SetButtonGroupFlags( iCbaFlags );
 reader.ReadInt16(); // Skip width resource.
 CleanupStack::PopAndDestroy(); // reader
 // Force labels to be re-formatted...
 SizeChanged();
 ReportContentChangedEvent();
+_AKNTRACE_FUNC_EXIT;
 }
 void CEikCba::AddCommandL(TInt /*aPosition*/, TInt /*aCommandId*/, const TDesC* /*aText*/,
 const CFbsBitmap* /*aBitmap*/, const CFbsBitmap* /*aMask*/)
 {
+_AKNTRACE_FUNC_ENTER;
 User::Leave(KErrNotSupported);
+_AKNTRACE_FUNC_EXIT;
 }
 void CEikCba::AddCommandToStackWithoutSizeChangedL(TInt aPosition,
 TInt aCommandId,
 const TDesC* aText)
 {
+_AKNTRACE_FUNC_ENTER;
 // We need to check if this call changes the softkeys from being
 // empty to having a command or vice versa to be able to maintain
 // correct fade state.
 TBool isEmptyBefore( IsEmpty() );
 {
 SetFadeState();
 }
 ReportContentChangedEvent();
+_AKNTRACE_FUNC_EXIT;
 }
 void CEikCba::AddCommandToStackL( TInt aPosition,
 TInt aCommandId,
 const TDesC* aText,
 const CFbsBitmap* /*aBitmap*/,
 const CFbsBitmap* /*aMask*/ )
 {
+_AKNTRACE_FUNC_ENTER;
 AddCommandToStackWithoutSizeChangedL( aPosition, aCommandId, aText);
 // Force labels to be re-formatted...
 SizeChanged();
+_AKNTRACE_FUNC_EXIT;
 }
 void CEikCba::AddCommandToStackL(TInt aPosition, TInt aResourceId)
 {
+_AKNTRACE_FUNC_ENTER;
 TResourceReader reader;
 iCoeEnv->CreateResourceReaderLC(reader,aResourceId);
 TUint8 version = (TUint8)reader.ReadInt8();
 TInt commandId(0);
 if (version == KAknCbaVersion)
 TPtrC text=reader.ReadTPtrC();
 AddCommandToStackL(aPosition, commandId, &text, NULL, NULL);
 CleanupStack::PopAndDestroy(); // reader
 ReportContentChangedEvent();
+_AKNTRACE_FUNC_EXIT;
 }
 void CEikCba::AddCommandSetToStackL(TInt aResourceId)
 {
+_AKNTRACE_FUNC_ENTER;
 TResourceReader reader;
 iCoeEnv->CreateResourceReaderLC(reader,aResourceId);
 iCbaFlags = reader.ReadInt32(); // Flags resource.
 reader.ReadInt16();             // Skip width resource.
 CleanupStack::PopAndDestroy(); // reader
 // Force labels to be re-formatted...
 SizeChanged();
 ReportContentChangedEvent();
+_AKNTRACE_FUNC_EXIT;
 }
 void CEikCba::SetDefaultCommand(TInt /*aCommandId*/)
 {
+_AKNTRACE_FUNC_ENTER;
+_AKNTRACE_FUNC_EXIT;
 }
 TSize CEikCba::CalcMinimumSizeL(TInt /*aResourceId*/)
 {
+_AKNTRACE_FUNC_ENTER;
+_AKNTRACE_FUNC_EXIT;
 return MinimumSize();
 }
 void CEikCba::RemoveCommandFromStack( TInt aPosition, TInt aCommandId )
 {
+_AKNTRACE_FUNC_ENTER;
 // We need to check if this call changes the softkeys from being
 // empty to having a command or vice versa to be able to maintain
 // correct fade state.
 TBool isEmptyBefore( IsEmpty() );
 SetFadeState();
 }
 DrawDeferred();
 ReportContentChangedEvent();
+_AKNTRACE_FUNC_EXIT;
 }
 void CEikCba::RemovePreviousCommandWithoutSizeChanged(TInt aPosition)
 {
+_AKNTRACE_FUNC_ENTER;
 TEikGroupControl& groupCtrl = (*iControlArray)[aPosition];
 STATIC_CAST(CEikCbaButton*, groupCtrl.iControl)->RemovePreviousCommand();
+_AKNTRACE_FUNC_EXIT;
 }
 void CEikCba::RemovePreviousCommand(TInt aPosition)
 {
+_AKNTRACE_FUNC_ENTER;
 RemovePreviousCommandWithoutSizeChanged( aPosition );
 // If MSK or left CBA was changed, this sets MSK icon accordingly.
 TRAP_IGNORE( SetMSKIconL() );
 // Force labels to be re-formatted...
 SizeChanged();
 ReportContentChangedEvent();
+_AKNTRACE_FUNC_EXIT;
 }
 TInt CEikCba::CommandPos(TInt aCommandId) const
 {
+_AKNTRACE_FUNC_ENTER;
+_AKNTRACE_FUNC_EXIT;
 return IndexById(aCommandId);
 }
 void CEikCba::DimCommand(TInt aCommandId,TBool aDimmed)
 {
+_AKNTRACE_FUNC_ENTER;
 CCoeControl* control( ButtonById( aCommandId ) );
 if ( control )
 {
 if ( SoftkeyStatusChangeAllowed( IndexById( aCommandId ), aDimmed ) )
 {
 control->SetDimmed( aDimmed );
 }
 }
+_AKNTRACE_FUNC_EXIT;
 }
 TBool CEikCba::IsCommandDimmed(TInt aCommandId) const
 {
+_AKNTRACE_FUNC_ENTER;
 if( ButtonById(aCommandId) )
 {
+_AKNTRACE_FUNC_EXIT;
 return ButtonById(aCommandId)->IsDimmed();
 }
+_AKNTRACE_FUNC_EXIT;
 return EFalse;
 }
 void CEikCba::MakeCommandVisible(TInt aCommandId, TBool aVisible)
 {
+_AKNTRACE_FUNC_ENTER;
 CCoeControl* control( ButtonById( aCommandId ) );
 if ( control )
 {
 if ( SoftkeyStatusChangeAllowed( IndexById( aCommandId ), !aVisible ) )
 {
 control->MakeVisible( aVisible );
 }
 }
+_AKNTRACE_FUNC_EXIT;
 }
 TBool CEikCba::IsCommandVisible(TInt aCommandId) const
 {
+_AKNTRACE_FUNC_ENTER;
 if( ButtonById(aCommandId) )
 {
+_AKNTRACE_FUNC_EXIT;
 return ButtonById(aCommandId)->IsVisible();
 }
+_AKNTRACE_FUNC_EXIT;
 return EFalse;
 }
 void CEikCba::AnimateCommand(TInt /*aCommandId*/)
 {
+_AKNTRACE_FUNC_ENTER;
+_AKNTRACE_FUNC_EXIT;
 }
 // ---------------------------------------------------------------------------
 // Sets the dimming status of a button with the specified position.
 // ---------------------------------------------------------------------------
 //
 void CEikCba::DimCommandByPosition( TInt aPosition, TBool aDimmed )
 {
+_AKNTRACE_FUNC_ENTER;
 if ( aPosition >= iControlArray->Count() )
 {
+_AKNTRACE_FUNC_EXIT;
 return;
 }
 if ( SoftkeyStatusChangeAllowed( aPosition, aDimmed ) )
 {
 TEikGroupControl& groupCtrl = ( *iControlArray )[ aPosition ];
 groupCtrl.iControl->SetDimmed( aDimmed );
 }
+_AKNTRACE_FUNC_EXIT;
 }
 // ---------------------------------------------------------------------------
 // Returns the dimming status of a button with the specified position.
 // ---------------------------------------------------------------------------
 //
 TBool CEikCba::IsCommandDimmedByPosition( TInt aPosition ) const
 {
+_AKNTRACE_FUNC_ENTER;
 if ( aPosition >= iControlArray->Count() )
 {
+_AKNTRACE_FUNC_EXIT;
 return EFalse;
 }
 TEikGroupControl& groupCtrl = (*iControlArray)[aPosition];
+_AKNTRACE_FUNC_EXIT;
 return groupCtrl.iControl->IsDimmed();
 }
 // ---------------------------------------------------------------------------
 // Sets the visibility of a button with the specified position.
 // ---------------------------------------------------------------------------
 //
 void CEikCba::MakeCommandVisibleByPosition( TInt aPosition, TBool aVisible )
 {
+_AKNTRACE_FUNC_ENTER;
 if ( aPosition >= iControlArray->Count() )
 {
+_AKNTRACE_FUNC_EXIT;
 return;
 }
 if ( SoftkeyStatusChangeAllowed( aPosition, !aVisible ) )
 {
 // Just dim the button, don't hide it.
 groupCtrl.iControl->SetDimmed( !aVisible );
 groupCtrl.iControl->DrawDeferred();
 }
 }
+_AKNTRACE_FUNC_EXIT;
 }
 TBool CEikCba::IsCommandVisibleByPosition(TInt aPosition) const
 {
+_AKNTRACE_FUNC_ENTER;
 if (aPosition >= iControlArray->Count())
 {
+_AKNTRACE_FUNC_EXIT;
 return EFalse;
 }
 TEikGroupControl& groupCtrl = (*iControlArray)[aPosition];
 if ( !iFlags.IsSet( ECbaInsideDialog ) )
 {
+_AKNTRACE_FUNC_EXIT;
 return STATIC_CAST(CEikCbaButton*, groupCtrl.iControl)->IsVisible();
 }
+_AKNTRACE_FUNC_EXIT;
 return !groupCtrl.iControl->IsDimmed();
 }
 void CEikCba::AnimateCommandByPosition(TInt /*aPosition*/)
 {
+_AKNTRACE_FUNC_ENTER;
+_AKNTRACE_FUNC_EXIT;
 }
 /*CCoeControl* CEikCba::GroupControlByPosition(TInt aPosition) const
 {
 if (aPosition >= iControlArray->Count())
 // Gets a CBA button rectangle.
 // ---------------------------------------------------------------------------
 //
 TRect CEikCba::ButtonRectByPosition( TInt aPosition, TBool aRelativeToScreen )
 {
+_AKNTRACE_FUNC_ENTER;
 TRect rect( 0, 0, 0, 0 );
 if ( aPosition >= iControlArray->Count() || aPosition < 0 )
 {
+_AKNTRACE_FUNC_EXIT;
 return rect;
 }
 if ( !AknLayoutUtils::PenEnabled() )
 {
 break;
 }
 }
 }
+_AKNTRACE_FUNC_EXIT;
 return rect;
 }
 CCoeControl* CEikCba::AsControl()
 {
+_AKNTRACE_FUNC_ENTER;
+_AKNTRACE_FUNC_EXIT;
 return this;
 }
 const CCoeControl* CEikCba::AsControl() const
 {
+_AKNTRACE_FUNC_ENTER;
+_AKNTRACE_FUNC_EXIT;
 return this;
 }
 void CEikCba::SetBoundingRect( const TRect& /*aBoundingRect*/ )
 {
+_AKNTRACE_FUNC_ENTER;
 if ( iFlags.IsSet( ECbaEmbedded ) )
 {
+_AKNTRACE_FUNC_EXIT;
 return;
 }
 // If background skin id has not been set from outside CBA,
 // update it in case status pane layout has changed
 // If CBA is inserted into a query dialog then it is positioned by the
 // query control.
 if ( iFlags.IsSet( ECbaInsideDialog ) )
 {
+_AKNTRACE_FUNC_EXIT;
 return;
 }
 TRect oldRect( Rect() );
 SetMSKVisibility( EFalse );
 }
 DrawDeferred();
 }
+_AKNTRACE_FUNC_EXIT;
 }
 // ---------------------------------------------------------------------------
 // Subtracts the area occupied by the button group from the specified
 // bounding rectangle.
 // ---------------------------------------------------------------------------
 //
 void CEikCba::ReduceRect( TRect& aBoundingRect ) const
 {
+_AKNTRACE_FUNC_ENTER;
 // CBA inside Popup/Query Input does not reduce bounding rect
 if ( iFlags.IsSet( ECbaEmbedded ) || iFlags.IsSet( ECbaInsideDialog ) )
 {
+_AKNTRACE_FUNC_EXIT;
 return;
 }
 if ( !IsVisible() )
 {
+_AKNTRACE_FUNC_EXIT;
 return;
 }
 const TInt aknLayoutFlags = AknLayoutFlags();
 aBoundingRect = largestBoundingRect;
 boundingRegion.Close();
 }
 }
 }
+_AKNTRACE_FUNC_EXIT;
 }
 CCoeControl* CEikCba::GroupControlById(TInt aCommandId)
 {
+_AKNTRACE_FUNC_ENTER;
+_AKNTRACE_FUNC_EXIT;
 return ButtonById(aCommandId);
 }
 CCoeControl* CEikCba::GroupControlById(TInt aCommandId) const
 {
+_AKNTRACE_FUNC_ENTER;
+_AKNTRACE_FUNC_EXIT;
 return ButtonById(aCommandId);
 }
 TInt CEikCba::CommandId(TInt aCommandPos) const
 {
+_AKNTRACE_FUNC_ENTER;
+_AKNTRACE_FUNC_EXIT;
 return (*iControlArray)[aCommandPos].iId;
 }
 TInt CEikCba::ButtonCount() const
 {
+_AKNTRACE_FUNC_ENTER;
+_AKNTRACE_FUNC_EXIT;
 return (iControlArray->Count()-1); // -1 for scroll bar;
 }
 CEikCommandButton* CEikCba::GroupControlAsButton(TInt /*aCommandId*/) const
 {
+_AKNTRACE_FUNC_ENTER;
 // It is not possible to convert a CBA button to a CEikCommandButton.
 // Please use an interface that does not use a CEikCommandButton conversion,
 // e.g. CEikButtonGroupContainer::SetCommandL().
 #if defined(_DEBUG)
 Panic(EEikPanicCBACannotConvertToCEikCommandButton);
 #endif
+_AKNTRACE_FUNC_EXIT;
 return NULL;
 }
 TUint CEikCba::ButtonGroupFlags() const
 {
+_AKNTRACE_FUNC_ENTER;
+_AKNTRACE_FUNC_EXIT;
 return iCbaFlags ;
 }
 EXPORT_C void CEikCba::SetButtonGroupFlags(TInt aFlags)
 {
+_AKNTRACE_FUNC_ENTER;
 iCbaFlags = aFlags;
+//has not supported semi-transparent, ignore the flag at this moment.
+//TODO: if the tranparent style CBA is approved and the new icon was delivered, open it again.
+iCbaFlags &= ~EEikCbaFlagSemiTransparent;
 if (( iCbaFlags & EEikCbaFlagTransparent || iCbaFlags & EEikCbaFlagSemiTransparent ) &&
 CAknEnv::Static()->TransparencyEnabled() )
 {
 Window().SetRequiredDisplayMode( EColor16MA );
 TInt err = Window().SetTransparencyAlphaChannel();
 if( err == KErrNone )
 {
 Window().SetBackgroundColor( ~0 );
 if ( iExtension && iExtension->iEnablePostingTransparency )
 {
-	iExtension->iEnablePostingTransparency = EFalse;
+iExtension->iEnablePostingTransparency = EFalse;
-	delete iExtension->iLskPostingOverlayBitmap;
+delete iExtension->iLskPostingOverlayBitmap;
-	iExtension->iLskPostingOverlayBitmap = NULL;
+iExtension->iLskPostingOverlayBitmap = NULL;
-	delete iExtension->iRskPostingOverlayBitmap;
+delete iExtension->iRskPostingOverlayBitmap;
-	iExtension->iRskPostingOverlayBitmap = NULL;
+iExtension->iRskPostingOverlayBitmap = NULL;
-	BroadcastPostingTransparency( EFalse );
+BroadcastPostingTransparency( EFalse );
-	}
+}
 }
 else
 {
 iCbaFlags &= ~EEikCbaFlagTransparent;
 }
 {
 iCbaFlags &= ~EEikCbaFlagTransparent;
 }
 UpdateFonts();
+_AKNTRACE_FUNC_EXIT;
 }
 // -----------------------------------------------------------------------------
 // CEikCba::SetSkinBackgroundId
 //
 // -----------------------------------------------------------------------------
 //
 EXPORT_C void CEikCba::SetSkinBackgroundId( const TAknsItemID& aIID )
 {
+_AKNTRACE_FUNC_ENTER;
 // Skin background is not drawn by embedded CBA.
 if ( iFlags.IsSet( ECbaEmbedded ) )
 {
+	iPopupVisible = ETrue;
+	_AKNTRACE_FUNC_EXIT;
 return;
+}
+else
+{
+iPopupVisible = EFalse;
 }
 if ( iBgIID != KAknsIIDNone )
 {
 if ( iBgIID != aIID )
 {
 statusPane->SetCbaAreaBackgroundID(
 iBgIID,
 CEikStatusPaneBase::EDrawDeferred );
 }
+_AKNTRACE_FUNC_EXIT;
 }
 TKeyResponse CEikCba::OfferKeyEventL(const TKeyEvent& aKeyEvent,TEventCode aType)
 {
+_AKNTRACE_FUNC_ENTER;
 if (aType != EEventKey)
 {
+_AKNTRACE_FUNC_EXIT;
 return EKeyWasNotConsumed;
 }
 // Return immediately if the control is invisible.
 if (!IsVisible() && !(iCbaFlags&EAknCBAFlagRespondWhenInvisible))
 {
+_AKNTRACE_FUNC_EXIT;
 return EKeyWasNotConsumed;
 }
 TBool shiftControlPressed =
 (aKeyEvent.iModifiers & EModifierShift) ||
 // Return immediately if the button is invisible
 if ( (*iControlArray)[KControlArrayCBAButton1Posn].iControl &&
 !(*iControlArray)[KControlArrayCBAButton1Posn].iControl->IsVisible() &&
 !(iCbaFlags & EAknCBAFlagRespondWhenInvisible) )
 {
+_AKNTRACE_FUNC_EXIT;
 return EKeyWasConsumed;
 }
 TInt shortCommand = (*iControlArray)[KControlArrayCBAButton1Posn].iId;
 TInt longCommand = (*iControlArray)[KControlArrayCBAButton1Posn].iLongId;
 // This will pass key event to application - no softkey command is processed.
 if (shortCommand == EAknSoftkeyForwardKeyEvent)
 {
+_AKNTRACE_FUNC_EXIT;
 return EKeyWasNotConsumed;
 }
 if (aKeyEvent.iRepeats == 0 && shortCommand)
 {
 // Return immediately if the button is invisible.
 if ( (*iControlArray)[KControlArrayCBAButton2Posn].iControl &&
 !(*iControlArray)[KControlArrayCBAButton2Posn].iControl->IsVisible() &&
 !(iCbaFlags&EAknCBAFlagRespondWhenInvisible) )
 {
+_AKNTRACE_FUNC_EXIT;
 return EKeyWasConsumed;
 }
 TInt shortCommand = (*iControlArray)[KControlArrayCBAButton2Posn].iId;
 TInt longCommand = (*iControlArray)[KControlArrayCBAButton2Posn].iLongId;
 }
 // This will pass key event to application - no softkey command is processed.
 if (shortCommand == EAknSoftkeyForwardKeyEvent)
 {
+_AKNTRACE_FUNC_EXIT;
 return EKeyWasNotConsumed;
 }
 if (aKeyEvent.iRepeats == 0 && shortCommand)
 {
 // Return immediately if the button is invisible.
 if ( (*iControlArray)[KControlArrayCBAButtonMSKPosn].iControl &&
 !(*iControlArray)[KControlArrayCBAButtonMSKPosn].iControl->IsVisible() &&
 !(iCbaFlags&EAknCBAFlagRespondWhenInvisible) )
 {
+_AKNTRACE_FUNC_EXIT;
 return EKeyWasConsumed;
 }
 TInt shortCommand = (*iControlArray)[KControlArrayCBAButtonMSKPosn].iId;
 TInt longCommand = (*iControlArray)[KControlArrayCBAButtonMSKPosn].iLongId;
 // This will pass key event to application - no softkey command is processed.
 if (shortCommand == EAknSoftkeyForwardKeyEvent)
 {
+_AKNTRACE_FUNC_EXIT;
 return EKeyWasNotConsumed;
 }
 if (aKeyEvent.iRepeats == 0 && shortCommand)
 {
 // Return immediately if the button is invisible.
 if ( (*iControlArray)[KControlArrayCBAButton1Posn].iControl &&
 !(*iControlArray)[KControlArrayCBAButton1Posn].iControl->IsVisible() &&
 !(iCbaFlags&EAknCBAFlagRespondWhenInvisible) )
 {
+_AKNTRACE_FUNC_EXIT;
 return EKeyWasConsumed;
 }
 TInt shortCommand = (*iControlArray)[KControlArrayCBAButton1Posn].iId;
 TInt longCommand = (*iControlArray)[KControlArrayCBAButton1Posn].iLongId;
 // This will pass key event to application - no softkey command is processed.
 if (shortCommand == EAknSoftkeyForwardKeyEvent)
 {
+_AKNTRACE_FUNC_EXIT;
 return EKeyWasNotConsumed;
 }
 if (aKeyEvent.iRepeats == 0 && shortCommand)
 {
 }
 response = EKeyWasConsumed;
 }
 }
+_AKNTRACE_FUNC_EXIT;
 return response;
 }
 EXPORT_C void* CEikCba::ExtensionInterface( TUid /*aInterface*/ )
 {
+_AKNTRACE_FUNC_ENTER;
+_AKNTRACE_FUNC_EXIT;
 return NULL;
 }
 // ---------------------------------------------------------------------------
 // command observer if a cba button was tapped.
 // ---------------------------------------------------------------------------
 //
 void CEikCba::HandlePointerEventL( const TPointerEvent& aPointerEvent )
 {
+_AKNTRACE_FUNC_ENTER;
 if ( !AknLayoutUtils::PenEnabled() )
 {
+_AKNTRACE_FUNC_EXIT;
 return;
 }
 else if ( iFlags.IsSet( ECbaInsideDialog ) )
 {
 CCoeControl::HandlePointerEventL( aPointerEvent );
+_AKNTRACE_FUNC_EXIT;
 return;
 }
 // If a child control is grabbing the pointer, we store the object pointer
 // before calling base class implementation. This is because the up event
 // If hits the left softkey.
 if ( button1Rect.Contains( aPointerEvent.iPosition ) && !button1Empty )
 {
 if( button1->IsDimmed() )
 {
-	CCoeControl::HandlePointerEventL( aPointerEvent );
+CCoeControl::HandlePointerEventL( aPointerEvent );
-	return;
+return;
 }
 if ( button1->IsVisible() )
 {
 if ( aPointerEvent.iType == TPointerEvent::EButton1Down )
 {
 }
 else if ( button2Rect.Contains( aPointerEvent.iPosition ) && !button2Empty )
 {
 if( button2->IsDimmed() )
 {
-	CCoeControl::HandlePointerEventL( aPointerEvent );
+CCoeControl::HandlePointerEventL( aPointerEvent );
-	return;
+return;
 }
 if ( button2->IsVisible() )
 {
 if ( aPointerEvent.iType == TPointerEvent::EButton1Down )
 {
 !buttonMSKEmpty &&
 buttonMSKRect.Contains( aPointerEvent.iPosition ) )
 {
 if( buttonMSK->IsDimmed() )
 {
-	CCoeControl::HandlePointerEventL( aPointerEvent );
+CCoeControl::HandlePointerEventL( aPointerEvent );
-	return;
+return;
 }
 if  ( buttonMSK->IsVisible() )
 {
 if ( aPointerEvent.iType == TPointerEvent::EButton1Down )
 {
 for ( TInt i = 0; i < buttoncount; i++ )
 {
 if ( (*iControlArray)[i].iControl == grabber )
 {
 if ( !IsVisible() )
+{
+_AKNTRACE_FUNC_EXIT;
 return;
+}
 // Send the button command to command observer.
 TInt shortCommand = (*iControlArray)[i].iId;
 if ( shortCommand &&
 i == KControlArrayCBAButtonMSKPosn &&
 iMSKCommandObserver )
 break;
 }
 }
 }
 }
+_AKNTRACE_FUNC_EXIT;
 }
 TSize CEikCba::MinimumSize()
 {
+_AKNTRACE_FUNC_ENTER;
 TSize size = CEikControlGroup::MinimumSize();
 size.iWidth = iAvkonAppUi->ApplicationRect().Width();
 const TInt count = iControlArray->Count();
 for (TInt ii = 0; ii < count; ii++)
 {
 }
 if (iLink)
 {
 size.iHeight = Max(size.iHeight, iLink->Size().iHeight);
 }
+_AKNTRACE_FUNC_EXIT;
 // Add a standard margin from the laf.
 return size;
 }
 /**
 *
 * @since ER5U
 */
 void CEikCba::GetColorUseListL(CArrayFix<TCoeColorUse>& aColorUseList) const
 {
+_AKNTRACE_FUNC_ENTER;
 CEikControlGroup::GetColorUseListL(aColorUseList);
 TInt commonAttributes = TCoeColorUse::ESurrounds|TCoeColorUse::EActive|TCoeColorUse::ENormal|
 TCoeColorUse::ENeutral;
 aColorUseList.AppendL(colorUse);
 colorUse.SetLogicalColor(EColorToolbarBackground);
 colorUse.SetUse(TCoeColorUse::EBack|commonAttributes);
 aColorUseList.AppendL(colorUse);
+_AKNTRACE_FUNC_EXIT;
 }
 // ---------------------------------------------------------------------------
 // Handles a change to the control's resources of type aType
 // which are shared across the environment, e.g. colors or fonts.
 // ---------------------------------------------------------------------------
 //
 void CEikCba::HandleResourceChange( TInt aType )
 {
+_AKNTRACE_FUNC_ENTER;
 CEikControlGroup::HandleResourceChange( aType );
 switch ( aType )
 {
 case KAknsMessageSkinChange:
 case KAknMessageFocusLost:
 {
 if ( iFlags.IsSet( ECbaInsideDialog ) )
 {
+_AKNTRACE_FUNC_EXIT;
 return;
 }
 CEikCbaButton* button1 =
 default:
 {
 break;
 }
 }
+_AKNTRACE_FUNC_EXIT;
 }
 void CEikCba::DoSkinChange()
 {
+_AKNTRACE_FUNC_ENTER;
 iExtension->iIfSkinChanged = ETrue;
 DoSetLayers( KAknsIIDNone );
 iExtension->iIfSkinChanged = EFalse;
 if ( iExtension )
 {
 SizeChanged();
 //Skin change uses DrawNow to flus draw cache before layoutchange.
 DrawNow();
 iFlags.Clear(ECbaChangeRecordedSkin);
+_AKNTRACE_FUNC_EXIT;
 }
 void CEikCba::DoColorChange()
 {
+_AKNTRACE_FUNC_ENTER;
 iBrushAndPenContext->SetBrushColor(iEikonEnv->ControlColor(EColorToolbarBackground, *this));
 iBrushAndPenContext->SetPenColor(iEikonEnv->ControlColor(EColorToolbarText, *this));
 Window().SetBackgroundColor(iEikonEnv->ControlColor(EColorToolbarBackground, *this));
 // This is required for skin resource changes (as well as color resource change).
 CheckSkinAndUpdateContext();
 TRAP_IGNORE( SetMSKIconL() );
 SizeChanged();
 iFlags.Clear(ECbaChangeRecordedColor);
+_AKNTRACE_FUNC_EXIT;
 }
 void CEikCba::DoLayoutChange()
 {
+_AKNTRACE_FUNC_ENTER;
 SetBoundingRect( TRect() );
 UpdateFonts();
 TBool mskAllowed( MskAllowed() );
 {
 TRAP_IGNORE( iExtension->UpdateSoftkeyFrameL( EFalse ) );
 }
 iFlags.Clear( ECbaChangeRecordedLayout );
+_AKNTRACE_FUNC_EXIT;
 }
 void CEikCba::HandleScrollEventL(CEikScrollBar* /*aScrollBar*/, TEikScrollEvent /*aEventType*/)
 {
+_AKNTRACE_FUNC_ENTER;
 User::Leave(KErrNotSupported);
+_AKNTRACE_FUNC_EXIT;
 }
 TTypeUid::Ptr CEikCba::MopSupplyObject(TTypeUid aId)
 {
+_AKNTRACE_FUNC_ENTER;
 if (aId.iUid == MAknsControlContext::ETypeId)
 {
 if ( AknLayoutFlags() & EAknLayoutCbaInControlPane ||
 AknLayoutFlags() & EAknLayoutCbaInRightPane )
 {
+_AKNTRACE_FUNC_EXIT;
 return MAknsControlContext::SupplyMopObject( aId, iMLBgContext );
 }
 else
 {
 // Always provide top object to mop-chain.
 // Bottom is parent of Top, so bottom is re-drawn
 // automatically when top is drawn.
+_AKNTRACE_FUNC_EXIT;
 return MAknsControlContext::SupplyMopObject( aId, iStaconBgContextTop );
 }
 }
 if ( aId.iUid == CEikCba::ETypeId )
 {
+_AKNTRACE_FUNC_EXIT;
 return aId.MakePtr( this );
 }
+_AKNTRACE_FUNC_EXIT;
 return CEikControlGroup::MopSupplyObject(aId);
 }
 void CEikCba::Draw( const TRect& aRect ) const
 {
+_AKNTRACE_FUNC_ENTER;
 // Embedded CBA doesn't draw anything
 if ( iFlags.IsSet( ECbaInsideDialog ) )
 {
 return;
 }
-if ( iCbaFlags & EEikCbaFlagSemiTransparent )
+//    if ( iCbaFlags & EEikCbaFlagSemiTransparent )
-{
+//        {
-CWindowGc &gc = SystemGc();
+//        CWindowGc &gc = SystemGc();
+//
-iExtension->DrawSemiTransparencyL( gc, Rect() );
+//        iExtension->DrawSemiTransparency( gc, Rect() );
-return;
+//        return;
-}
+//        }
 MAknsSkinInstance* skin = AknsUtils::SkinInstance();
 const TRect rect( Rect() );
 CWindowGc& gc = SystemGc();
 CEikCbaButton* button1 = static_cast<CEikCbaButton*>(
 (*iControlArray)[KControlArrayCBAButton1Posn].iControl );
 CEikCbaButton* button2 = static_cast<CEikCbaButton*>(
 (*iControlArray)[KControlArrayCBAButton2Posn].iControl );
-		        if ( IsMskEnabledLayoutActive() )
+if ( IsMskEnabledLayoutActive() )
 {
 CEikCbaButton* buttonMSK = static_cast<CEikCbaButton*>(
 (*iControlArray)[KControlArrayCBAButtonMSKPosn].iControl );
 CFbsBitmap* middleMask =
 AknsUtils::GetCachedBitmap( skin, KAknsIIDQgnIndiSctrlSkMaskMiddlePrt );
-AknIconUtils::SetSize( middleMask, middleSKSize, EAspectRatioNotPreserved );
+if ( middleMask )
+{
+AknIconUtils::SetSize( middleMask,
+middleSKSize, EAspectRatioNotPreserved );
+}
 if( buttonMSK && buttonMSK->PressedDown() )
 {
 AknsDrawUtils::DrawFrame( AknsUtils::SkinInstance(),
 gc,
 }
 }
 }
 }
 gc.SetOpaque( EFalse );
+_AKNTRACE_FUNC_EXIT;
 }
 // ---------------------------------------------------------------------------
 // Gets a button control by the specified command ID.
 // ---------------------------------------------------------------------------
 //
 CCoeControl* CEikCba::ButtonById( TInt aCommandId ) const
 {
+_AKNTRACE_FUNC_ENTER;
+_AKNTRACE_FUNC_EXIT;
 return ControlById( aCommandId );
 }
 // ---------------------------------------------------------------------------
 // Creates the scroll bar frame & sets up the scroll bar.
 // ---------------------------------------------------------------------------
 //
 void CEikCba::CreateScrollBarFrameL()
 {
+_AKNTRACE_FUNC_ENTER;
 if ( !iSBFrame )
 {
 iSBFrame = new (ELeave) CEikCbaScrollBarFrame( this, this, ETrue );
 }
 iSBFrame->ConstructL();
+_AKNTRACE_FUNC_EXIT;
 }
 TEikGroupControl CEikCba::VScrollBarAsGroupControl()
 {
+_AKNTRACE_FUNC_ENTER;
 // Extracts vertical scroll bar from the scroll bar frame.
 TEikGroupControl groupCtrl(iSBFrame->VerticalScrollBar(), 0,
 KCbaScrollBarButtonWidth,TEikGroupControl::ESetLength);
+_AKNTRACE_FUNC_EXIT;
 return groupCtrl;
 }
 void CEikCba::InsertScrollBarL()
 {
+_AKNTRACE_FUNC_ENTER;
 TEikGroupControl SBGroupCtrl = VScrollBarAsGroupControl();
 // Insert vertical scroll bar into cba control group.
 InsertControlL(SBGroupCtrl, KControlArrayScrollBarPosn);
+_AKNTRACE_FUNC_EXIT;
 }
 // ---------------------------------------------------------------------------
 // Replaces empty scroll bar with actual arrow head scroll bar.
 // ---------------------------------------------------------------------------
 //
 void CEikCba::CreateArrowHeadScrollBarL()
 {
+_AKNTRACE_FUNC_ENTER;
 if ( iSBFrame )
 {
 iSBFrame->SwitchToArrowHeadScrollBarL();
 iSBFrame->VerticalScrollBar()->SetContainingCba( this );
 if ( iControlArray->Count() > KControlArrayScrollBarPosn )
 {
 iControlArray->Delete( KControlArrayScrollBarPosn );
 }
 InsertScrollBarL();
 }
+_AKNTRACE_FUNC_EXIT;
 }
 void CEikCba::SizeChanged()
 {
+_AKNTRACE_FUNC_ENTER;
 if ( iFlags.IsSet( ECbaInsideDialog ) )
 {
 Window().SetNonFading( EFalse );
 SizeChangedInsideDialog();
+_AKNTRACE_FUNC_EXIT;
 return;
 }
 else if ( iFlags.IsSet( ECbaEmbedded ) )
 {
 Window().SetNonFading( EFalse );
 SizeChangedInPopup();
+_AKNTRACE_FUNC_EXIT;
 return;
 }
 const TInt aknLayoutFlags = AknLayoutFlags();
 }
 // Broadcast current state to CEikCbaButtons
 BroadcastPostingTransparency( enabled );
 }
+_AKNTRACE_FUNC_EXIT;
 }
 // -----------------------------------------------------------------------------
 // CEikCba::CheckSkinAndUpdateContext
 //
 // -----------------------------------------------------------------------------
 //
 void CEikCba::CheckSkinAndUpdateContext()
 {
+_AKNTRACE_FUNC_ENTER;
 if (AknsUtils::SkinInstance())
 {
 // Use ENullBrush if there is skin background available.
 iBrushAndPenContext->SetBrushStyle(CGraphicsContext::ENullBrush);
 }
 else
 {
 iBrushAndPenContext->SetBrushStyle(CGraphicsContext::ESolidBrush);
 }
+_AKNTRACE_FUNC_EXIT;
 }
 void CEikCba::Reserved_MtsmPosition()
 {
+_AKNTRACE_FUNC_ENTER;
+_AKNTRACE_FUNC_EXIT;
 }
 void CEikCba::Reserved_MtsmObject()
 {
+_AKNTRACE_FUNC_ENTER;
+_AKNTRACE_FUNC_EXIT;
 }
 TInt CEikCba::AknLayoutFlags() const
 {
+_AKNTRACE_FUNC_ENTER;
 TInt flags = 0;
 TBool controlPane = ETrue;
 TBool staconPane = EFalse;
 TBool staconPaneLeft = EFalse;
 if (rightPane)
 {
 flags |= EAknLayoutCbaInRightPane;
 }
+_AKNTRACE_FUNC_EXIT;
 return flags;
 }
 // ---------------------------------------------------------------------------
 // Handles size change events in bottom softkey layout.
 // ---------------------------------------------------------------------------
 //
 void CEikCba::SizeChangedInControlPane()
 {
+_AKNTRACE_FUNC_ENTER;
 TRect screen;
 AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EScreen, screen );
 TBool isLandscape( Layout_Meta_Data::IsLandscapeOrientation() );
 TBool flatLscLayout( isLandscape &&
 {
 layoutRect.LayoutRect(
 rect,
 AknLayoutScalable_Avkon::bg_sctrl_sk_pane_cp1().LayoutLine() );
 frameSizeChanged = layoutRect.Rect() != iExtension->iRightFrameOuterRect;
-				iExtension->iRightFrameOuterRect = layoutRect.Rect();
+iExtension->iRightFrameOuterRect = layoutRect.Rect();
 layoutRect.LayoutRect( iExtension->iRightFrameOuterRect,
 AknLayoutScalable_Avkon::bg_sctrl_sk_pane_g1()
 .LayoutLine() );
 iExtension->iRightFrameInnerRect = layoutRect.Rect();
 DrawDeferred();
 }
 AknsUtils::RegisterControlPosition( this, posInScreen.iTl );
+_AKNTRACE_FUNC_EXIT;
 }
 void CEikCba::SizeChangedInStaconPane()
 {
+_AKNTRACE_FUNC_ENTER;
 TRect screen( iAvkonAppUi->ApplicationRect() );
 TBool softKeysUpAndDownMirrored = EFalse;
 TInt variety = 0;
 if (AknLayoutFlags() & EAknLayoutCbaInStaconPaneLeft)
 DrawDeferred();
 }
 AknsUtils::RegisterControlPosition( this, TPoint(0,0) );
+_AKNTRACE_FUNC_EXIT;
 }
 //------------------------------------------------------------------------------
 // CEikCba::SizeChangedInRightPane()
 //------------------------------------------------------------------------------
 //
 void CEikCba::SizeChangedInRightPane()
 {
+_AKNTRACE_FUNC_ENTER;
 TRect screen;
 AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EScreen, screen );
 TAknWindowComponentLayout rightAreaLayout(
 AknLayoutScalable_Avkon::area_side_right_pane( 0 ) );
 DrawDeferred();
 }
 AknsUtils::RegisterControlPosition( this, TPoint( 0, 0 ) );
+_AKNTRACE_FUNC_EXIT;
 }
 void CEikCba::SizeChangedInsideDialog()
 {
+_AKNTRACE_FUNC_ENTER;
 // Give both LSK and RSK buttons half of the available space.
 //
 if ( iControlArray )
 {
 TRect buttonRect1( Rect() );
 if ( (*iControlArray)[KControlArrayCBAButton2Posn].iControl )
 {
 (*iControlArray)[KControlArrayCBAButton2Posn].iControl->SetRect( buttonRect2 );
 }
 }
+_AKNTRACE_FUNC_EXIT;
 }
 void CEikCba::SizeChangedInPopup()
 {
+_AKNTRACE_FUNC_ENTER;
 TRAP_IGNORE( iExtension->UpdateSoftkeyFrameL( EFalse ) );
 TAknLayoutRect layoutRect;
 TRect rect ( Rect() );
 layoutRect.LayoutRect( iExtension->iLeftFrameOuterRect,
 AknLayoutScalable_Avkon::bg_sctrl_sk_pane_g1()
 .LayoutLine() );
 iExtension->iLeftFrameInnerRect = layoutRect.Rect();
-UpdateLabels( ETrue );
 layoutRect.LayoutRect( iExtension->iRightFrameOuterRect,
 AknLayoutScalable_Avkon::bg_sctrl_sk_pane_g1()
 .LayoutLine() );
 iExtension->iRightFrameInnerRect = layoutRect.Rect();
 if ( msk )
 {
 msk->SetRect( TRect() );
 }
 }
+_AKNTRACE_FUNC_EXIT;
 }
 void CEikCba::UpdateFonts()
 {
+_AKNTRACE_FUNC_ENTER;
 // Control pane:
 // Use the layout dll to get the right font for the CBA.
 TAknTextLineLayout layout(
 AknLayoutScalable_Avkon::control_pane_t1(
 Layout_Meta_Data::IsLandscapeOrientation() ? 2 : 0 ).LayoutLine() );
 }
 const CFont* rightPaneCustomFont = 0;
 iRightPaneLabelFont =
 AknLayoutUtils::FontFromId(
 rightPaneTextLayout.FontId(), rightPaneCustomFont );
+_AKNTRACE_FUNC_EXIT;
 }
 // Enhanced CBA
 // -----------------------------------------------------------------------------
 // @since 5.0
 // -----------------------------------------------------------------------------
 #ifdef RD_ENHANCED_CBA
 EXPORT_C void CEikCba::OfferCommandListL(const RArray<TInt>& aCommandList)
 {
+_AKNTRACE_FUNC_ENTER;
 if( !iCommandTable )
 {
 iCommandTable = CEikCommandTable::NewL();
 }
 else
 RemovePreviousCommand( controlId );
 }
 }
 CleanupStack::PopAndDestroy(); // previousIds
+_AKNTRACE_FUNC_EXIT;
 }
 #else // !RD_ENHANCED_CBA
 EXPORT_C void CEikCba::OfferCommandListL(const RArray<TInt>& /*aCommandList*/)
 {
+_AKNTRACE_FUNC_ENTER;
 User::Leave( KErrNotSupported );
+_AKNTRACE_FUNC_EXIT;
 }
 #endif // RD_ENHANCED_CBA
 // -----------------------------------------------------------------------------
 // Used to offer list of commands for softkeys.
 // @since 5.0
 // -----------------------------------------------------------------------------
 #ifdef RD_ENHANCED_CBA
 EXPORT_C void CEikCba::OfferCommandListL(const TInt aResourceId)
 {
+_AKNTRACE_FUNC_ENTER;
 if ( !iCommandTable ) // This is needed if cba was not constructed with enhanced cba.
 {
 iCommandTable = CEikCommandTable::NewL();
 }
 RemovePreviousCommand( controlId );
 }
 }
 CleanupStack::PopAndDestroy(); // previousIds
+_AKNTRACE_FUNC_EXIT;
 }
 #else // !RD_ENHANCED_CBA
 EXPORT_C void CEikCba::OfferCommandListL(const TInt /*aResourceId*/)
 {
+_AKNTRACE_FUNC_ENTER;
 User::Leave( KErrNotSupported );
+_AKNTRACE_FUNC_EXIT;
 }
 #endif // RD_ENHANCED_CBA
 // -----------------------------------------------------------------------------
 // Used to check if a certain command have been approved to the current command set.
 // @since 5.0
 // -----------------------------------------------------------------------------
 #ifdef RD_ENHANCED_CBA
 EXPORT_C TBool CEikCba::IsCommandInGroup(const TInt aCommandId) const
 {
+_AKNTRACE_FUNC_ENTER;
+_AKNTRACE_FUNC_EXIT;
 return ButtonById(aCommandId) ? ETrue : EFalse; // check the iControlArray
 }
 #else // !RD_ENHANCED_CBA
 EXPORT_C TBool CEikCba::IsCommandInGroup(const TInt /*aCommandId*/) const
 {
+_AKNTRACE_FUNC_ENTER;
+_AKNTRACE_FUNC_EXIT;
 return EFalse;
 }
 #endif // RD_ENHANCED_CBA
 // -----------------------------------------------------------------------------
 // @since 5.0
 // -----------------------------------------------------------------------------
 #ifdef RD_ENHANCED_CBA
 EXPORT_C void CEikCba::ReplaceCommand(const TInt aReplaceCommandId, const TInt aResourceId)
 {
+_AKNTRACE_FUNC_ENTER;
 TInt index = IndexById( aReplaceCommandId );
 TRAPD(err, SetCommandL( index, aResourceId ) );
+_AKNTRACE_FUNC_EXIT;
 }
 #else
 EXPORT_C void CEikCba::ReplaceCommand(const TInt /*aReplaceCommandId*/, const TInt /*aResourceId*/)
 {
+_AKNTRACE_FUNC_ENTER;
+_AKNTRACE_FUNC_EXIT;
 }
 #endif // RD_ENHANCED_CBA
 void CEikCba::HandleControlEventL( CCoeControl* aControl, TCoeEvent aEventType )
 {
+_AKNTRACE_FUNC_ENTER;
 if ( !iFlags.IsSet( ECbaInsideDialog ) )
 {
 //User::Panic( _L( "CBA inside dialog" ), KErrNotSupported );
+_AKNTRACE_FUNC_EXIT;
 return;
 }
 if ( aEventType == EEventStateChanged )
 {
 if( command )
 {
 iCommandObserver->ProcessCommandL( command );
 }
 }
+_AKNTRACE_FUNC_EXIT;
 }
 void CEikCba::MakeVisible( TBool aVisible )
 {
+_AKNTRACE_FUNC_ENTER;
 if ( aVisible )
 {
 TBool redrawNeeded( EFalse );
 if ( AknLayoutUtils::PenEnabled() )
 Window().ClearRedrawStore();
 CEikControlGroup::MakeVisible( aVisible );
 }
 ReportContentChangedEvent();
+_AKNTRACE_FUNC_EXIT;
 }
 // -----------------------------------------------------------------------------
 // Sets layer images and rects.
 // @since 5.0
 // -----------------------------------------------------------------------------
 void CEikCba::DoSetLayers( const TAknsItemID& aIID )
 {
+_AKNTRACE_FUNC_ENTER;
 // Skin background is not drawn by embedded CBA.
 if ( iFlags.IsSet( ECbaEmbedded ) )
 {
+_AKNTRACE_FUNC_EXIT;
 return;
 }
 TAknLayoutRect cbarect;
 TRect screen;
 TRAP_IGNORE( iMLBgContext->SetLayerMaskAndSizeL( maskIID, cbaRect ) );
 }
 DrawDeferred();
+_AKNTRACE_FUNC_EXIT;
 }
 void CEikCba::LayoutControl( CCoeControl* aControl, const TRect& aRect )
 {
+_AKNTRACE_FUNC_ENTER;
 if ( !iFlags.IsSet( ECbaInsideDialog ) )
 {
 TRect rect( aRect );
 // aid_value_unit2 is 10ux10u rectangle.
 TAknWindowComponentLayout unit( AknLayoutScalable_Avkon::aid_value_unit2() );
 rect.Move( delta, delta );
 }
 aControl->SetRect( rect );
 aControl->ComponentControl( 0 )->SetRect( rect );
 }
+_AKNTRACE_FUNC_EXIT;
 }
 void CEikCba::BroadcastPostingTransparency( TBool aEnable )
 {
+_AKNTRACE_FUNC_ENTER;
 // Communicate change to CBA buttons.
 for ( TInt i = 0; i < iControlArray->Count(); i++ )
 {
 if ( i != KControlArrayScrollBarPosn ) // To avoid tinkering with scrollbar.
 {
 {
 button->SetTextBitmapMode( aEnable );
 }
 }
 }
+_AKNTRACE_FUNC_EXIT;
 }
 // ---------------------------------------------------------------------------
 // CEikCba::SetFadeState
 // Sets the CBA faded if it's contents are empty.
 // ---------------------------------------------------------------------------
 //
 void CEikCba::SetFadeState()
 {
+_AKNTRACE_FUNC_ENTER;
 TBool canBeFaded =
 IsEmpty() && !( ( iCbaFlags & EEikCbaFlagTransparent )
 || ( iExtension && iExtension->iEnablePostingTransparency ) );
 // No unfading when system is faded
 if ( !( !canBeFaded
 && static_cast<CAknAppUi*>( iCoeEnv->AppUi() )->IsFaded() ) )
 {
 Window().SetFaded( canBeFaded, RWindowTreeNode::EFadeIncludeChildren );
 }
+_AKNTRACE_FUNC_EXIT;
 }
 // ---------------------------------------------------------------------------
 // CEikCba::UpdateLabels
 // Updates softkey labels in case of embedded softkeys.
 // ---------------------------------------------------------------------------
 //
 void CEikCba::UpdateLabels( TBool aDrawDeferred )
 {
+_AKNTRACE_FUNC_ENTER;
 if ( iControlArray->Count() != 0)
 {
 CCoeControl *leftSoftkey = ( *iControlArray )
 [ KControlArrayCBAButton1Posn ].iControl;
 CCoeControl *rightSoftkey = ( *iControlArray )
 if ( aDrawDeferred )
 {
 DrawDeferred();
 }
 }
+_AKNTRACE_FUNC_EXIT;
 }
 // -----------------------------------------------------------------------------
 // EikSoftkeyPostingTransparency::MakeTransparent
 //
 EXPORT_C TInt EikSoftkeyPostingTransparency::MakeTransparent(
 CEikButtonGroupContainer& aButtonGroupContainer,
 TBool aEnable )
 {
+_AKNTRACE_FUNC_ENTER;
 CEikCba* cba = dynamic_cast<CEikCba*>( aButtonGroupContainer.ButtonGroup() );
 TInt ret = KErrNone;
 if ( cba )
 {
 if ( aEnable && ( cba->ButtonGroupFlags() & EEikCbaFlagTransparent ) )
 else
 {
 cba->EnablePostingTransparency( aEnable );
 }
 }
+_AKNTRACE_FUNC_EXIT;
 return ret;
 }
 // -----------------------------------------------------------------------------
 // CEikCba::EnablePostingTransparency
 //
 // -----------------------------------------------------------------------------
 //
 void CEikCba::EnablePostingTransparency( TBool aEnable )
 {
+_AKNTRACE_FUNC_ENTER;
 if ( iExtension )
 {
 if ( iExtension->iEnablePostingTransparency != aEnable )
 {
 iExtension->iEnablePostingTransparency = aEnable;
 }
 DrawDeferred();
 }
 }
+_AKNTRACE_FUNC_EXIT;
 }
 // ---------------------------------------------------------------------------
 // CEikCba::IsEmpty
 // Checks if the CBA has no commands.
 // ---------------------------------------------------------------------------
 //
 EXPORT_C TBool CEikCba::IsEmpty() const
 {
+_AKNTRACE_FUNC_ENTER;
 TBool isEmpty( ETrue );
 if ( iFlags.IsSet( ECbaInsideDialog ) )
 {
 // Not supported for full screen query.
 }
 }
 }
 }
+_AKNTRACE_FUNC_EXIT;
 return isEmpty;
 }
 // ---------------------------------------------------------------------------
 // Returns flags.
 // ---------------------------------------------------------------------------
 //
 TBitFlags CEikCba::Flags()
 {
+_AKNTRACE_FUNC_ENTER;
+_AKNTRACE_FUNC_EXIT;
 return iFlags;
 }
 // ---------------------------------------------------------------------------
 // Sets content observer.
 // ---------------------------------------------------------------------------
 //
 void CEikCba::SetContentObserver( TCallBack aCallBack )
 {
+_AKNTRACE_FUNC_ENTER;
 if ( iExtension )
 {
 iExtension->iContentObserver = aCallBack;
 }
+_AKNTRACE_FUNC_EXIT;
 }
 // ---------------------------------------------------------------------------
 // CEikCba::ReportContentChangedEvent
 // or vice versa.
 // ---------------------------------------------------------------------------
 //
 void CEikCba::ReportContentChangedEvent()
 {
+_AKNTRACE_FUNC_ENTER;
 if ( ItemSpecificSoftkey() )
 {
 UpdateItemSpecificSoftkey(
 iExtension->Active() && !Window().IsFaded() );
 }
 if ( !iFlags.IsSet( ECbaEmbedded ) )
 {
+_AKNTRACE_FUNC_EXIT;
 return;
 }
 TBool isEmpty( !IsVisible() || IsEmpty() );
 TBool reportStateChanged( EFalse );
 if ( iExtension && iExtension->iContentObserver.iFunction )
 {
 iExtension->iContentObserver.CallBack(); // return value ignored
 }
 }
+_AKNTRACE_FUNC_EXIT;
 }
 // ---------------------------------------------------------------------------
 // CEikCba::DrawEmbeddedSoftkey
 // Draws embedded softkey
 void CEikCba::DrawEmbeddedSoftkey( TEikGroupControl& aGroupControl,
 const TRect& aRect,
 CWindowGc& aGc,
 CFbsBitmap* /*aMask*/ ) const
 {
+_AKNTRACE_FUNC_ENTER;
 CEikCbaButton* button =
 static_cast<CEikCbaButton*>( aGroupControl.iControl );
 TAknLayoutRect layoutRect;
 TRect innerRect;
 aRect,
 innerRect,
 KAknsIIDQgnFrSctrlSkButton,
 KAknsIIDQgnFrSctrlSkButtonCenter);
 }
+_AKNTRACE_FUNC_EXIT;
 }
 TBool CEikCba::UpdateIconL()
 {
+_AKNTRACE_FUNC_ENTER;
 if ( iFlags.IsSet( ECbaInsideDialog ) )
 {
+_AKNTRACE_FUNC_EXIT;
 return EFalse;
 }
 if ( !iExtension->iIfMskIconSet ||
 !MskAllowed() )
 {
+_AKNTRACE_FUNC_EXIT;
 return EFalse;
 }
 MAknsSkinInstance* skin = AknsUtils::SkinInstance();
 if ( !skin )
 {
+_AKNTRACE_FUNC_EXIT;
 return EFalse;
 }
 TEikGroupControl &gCtrl = iControlArray->At( KControlArrayCBAButtonMSKPosn );
 CEikCbaButton *button = static_cast<CEikCbaButton*>( gCtrl.iControl );
 if ( !button )
 {
+_AKNTRACE_FUNC_EXIT;
 return EFalse;
 }
 CFbsBitmap *bitmap = NULL;
 CFbsBitmap *mask = NULL;
 button->ReplaceImageByLabel(); // remove old image
 }
 button->SetContainerWindowL( *this );
+_AKNTRACE_FUNC_EXIT;
 return ETrue;
 }
 // ---------------------------------------------------------------------------
 // Checks if the middle softkey should be used.
 // when on layout changes etc.
 // ---------------------------------------------------------------------------
 //
 TBool CEikCba::MskAllowed() const
 {
+_AKNTRACE_FUNC_ENTER;
+_AKNTRACE_FUNC_EXIT;
 return ( iMSKEnabledInPlatform &&
 AknLayoutUtils::MSKEnabled() &&
 IsMskEnabledLayoutActive() );
 }
 // ---------------------------------------------------------------------------
 //
 TBool CEikCba::SoftkeyStatusChangeAllowed(
 TInt aSoftkeyPosition, TBool aDisabled )
 {
+_AKNTRACE_FUNC_ENTER;
 TBool allowChange( ETrue );
 if ( aSoftkeyPosition == KControlArrayCBAButton1Posn )
 {
 if ( aDisabled )
 {
 {
 allowChange = EFalse;
 }
 }
 }
+_AKNTRACE_FUNC_EXIT;
 return allowChange;
 }
 // ---------------------------------------------------------------------------
 // Returns item specific softkey control if it state should be updated.
 // ---------------------------------------------------------------------------
 //
 TEikGroupControl* CEikCba::ItemSpecificSoftkey() const
 {
+_AKNTRACE_FUNC_ENTER;
 TEikGroupControl* lsk( NULL );
 if ( iFlags.IsSet( ECbaItemSpecificSoftkeyInUse ) )
 {
 TEikGroupControl& leftSoftkey =
 ( *iControlArray ) [ KControlArrayCBAButton1Posn ];
 || iFlags.IsSet( ECbaItemSoftkeyDisabled ) )
 {
 lsk = &leftSoftkey;
 }
 }
+_AKNTRACE_FUNC_EXIT;
 return lsk;
 }
 // ---------------------------------------------------------------------------
 // Updates item specific softkey.
 // ---------------------------------------------------------------------------
 //
 void CEikCba::UpdateItemSpecificSoftkey( TBool aVisibleCollection )
 {
+_AKNTRACE_FUNC_ENTER;
 if ( iFlags.IsSet( ECbaSingleClickEnabled )
 && iExtension && iExtension->iItemActionMenu )
 {
 TEikGroupControl* leftSk = ItemSpecificSoftkey();
 if ( leftSk )
 iExtension->iItemActionMenu->CollectionSoftkeyVisible(
 aVisibleCollection ) );
 UpdateItemSpecificSoftkey( *leftSk->iControl, enableSk );
 }
 }
+_AKNTRACE_FUNC_EXIT;
 }
 // ---------------------------------------------------------------------------
 // CEikCba::UpdateItemSpecificSoftkey
 // Updates item specific softkey.
 // ---------------------------------------------------------------------------
 //
 void CEikCba::UpdateItemSpecificSoftkey( CCoeControl& aControl, TBool aEnable )
 {
+_AKNTRACE_FUNC_ENTER;
 TBool skEnabled( aControl.IsVisible() && !aControl.IsDimmed() );
 TBool changeState( EFalse );
 if ( !aEnable )
 {
 iFlags.Set( ECbaItemSoftkeyDisabled );
 {
 aControl.SetDimmed( !aEnable );
 aControl.DrawDeferred();
 }
 }
+_AKNTRACE_FUNC_EXIT;
 }
 //
 // class CEikCbaButton
 //
 CEikCbaButton::~CEikCbaButton()
 {
+_AKNTRACE_FUNC_ENTER;
 AKNTASHOOK_REMOVE();
 delete iLabel;
 if ( iImage )
 {
 iImage->SetMask( iMask );
 delete iImage;
 delete iSfeMask;
 delete iButtonOptions;
 delete iText;
+_AKNTRACE_FUNC_EXIT;
 }
 void CEikCbaButton::ConstructL(TGulAlignmentValue aAlignment)
 {
+_AKNTRACE_FUNC_ENTER;
 iLabel = new(ELeave) CEikLabel;
 iPressedDown = EFalse;
 iLabel->SetBufferReserveLengthL(KMaxCbaLabelLength);
 UpdateLabelText(TPtrC());
 iLabel->SetAlignment(aAlignment);
 if ( iUseTextBitmap )
 {
 iLabel->MakeVisible( EFalse );
 }
 AKNTASHOOK_ADDL( this, "CEikCbaButton" );
+_AKNTRACE_FUNC_EXIT;
 }
 void CEikCbaButton::AddCommandL(const TDesC& aText)
 {
+_AKNTRACE_FUNC_ENTER;
 UpdateLabelText(aText);
+_AKNTRACE_FUNC_EXIT;
 }
 struct STempCleanup
 {
 CDesCArray* iText;
 CArrayFix<CEikCbaButton::SButtonOptions>* iButtonOptions;
 };
 LOCAL_C void CleanupTemp(TAny* aPtr)
 {
+_AKNTRACE_FUNC_ENTER;
 STempCleanup& temp = *(STempCleanup*)aPtr;
 const TInt count = temp.iText->Count();
 if (temp.iButtonOptions->Count() == count)
 {
 temp.iButtonOptions->Delete(count - 1);
 }
 temp.iText->Delete(count - 1);
+_AKNTRACE_FUNC_EXIT;
 }
 void CEikCbaButton::PushCommandL(TInt aCommandId,const TDesC& aText)
 {
+_AKNTRACE_FUNC_ENTER;
 if (!iButtonOptions)
 {
 iButtonOptions = new(ELeave) CArrayFixFlat<SButtonOptions>(1);
 }
 if (!iText)
 options.iDimmed = iLabel->IsDimmed();
 iLabel->SetDimmed(EFalse);
 iButtonOptions->AppendL(options);
 UpdateLabelText(aText);
 CleanupStack::Pop(); // temp
+_AKNTRACE_FUNC_EXIT;
 }
 TInt CEikCbaButton::PopCommand()
 {
+_AKNTRACE_FUNC_ENTER;
 if (!iButtonOptions)
 {
+_AKNTRACE_FUNC_EXIT;
 return -1;
 }
 TInt count = iButtonOptions->Count();
 --count;
 if (count < 0)
 {
+_AKNTRACE_FUNC_EXIT;
 return -1;
 }
 const SButtonOptions buttonOptions = (*iButtonOptions)[count];
 iButtonOptions->Delete(count);
 }
 else
 {
 iImage->DrawNow();
 }
+_AKNTRACE_FUNC_EXIT;
 return buttonOptions.iCommandId;
 }
 void CEikCbaButton::RemoveCommand(TInt aCommandId)
 {
+_AKNTRACE_FUNC_ENTER;
 if (!iButtonOptions)
 {
+_AKNTRACE_FUNC_EXIT;
 return;
 }
 TInt index = IndexFromCommandId(aCommandId);
 if (index != KErrNotFound)
 {
 iButtonOptions = NULL;
 delete iText;
 iText = NULL;
 }
 }
+_AKNTRACE_FUNC_EXIT;
 }
 void CEikCbaButton::RemovePreviousCommand()
 {
+_AKNTRACE_FUNC_ENTER;
 if (!iButtonOptions)
 {
+_AKNTRACE_FUNC_EXIT;
 return;
 }
 TInt index = iButtonOptions->Count() - 2;
 if (index >= 0)
 {
 iButtonOptions->Delete(index);
 iText->Delete(index);
 }
+_AKNTRACE_FUNC_EXIT;
 }
 TInt CEikCbaButton::IndexFromCommandId(TInt aCommandId)
 {
+_AKNTRACE_FUNC_ENTER;
 TInt index;
 TKeyArrayFix key(0, ECmpTInt);
 SButtonOptions options;
 options.iCommandId = aCommandId;
 if (iButtonOptions->Find(options, key, index) == KErrNone)
 {
+_AKNTRACE_FUNC_EXIT;
 return index;
 }
 else
 {
+_AKNTRACE_FUNC_EXIT;
 return KErrNotFound;
 }
 }
 void CEikCbaButton::SetContainerWindowL(const CCoeControl& aContainer)
 {
+_AKNTRACE_FUNC_ENTER;
 CCoeControl::SetContainerWindowL(aContainer);
 if (!iDoImage)
 {
 iLabel->SetContainerWindowL(aContainer);
 }
 else
 {
 iImage->SetContainerWindowL(aContainer);
 }
+_AKNTRACE_FUNC_EXIT;
 }
 void CEikCbaButton::ConstructFromResourceL(TResourceReader& aReader, TGulAlignmentValue anAlignment)
 {
+_AKNTRACE_FUNC_ENTER;
 ConstructL(anAlignment);
 UpdateLabelText(aReader.ReadTPtrC());
 aReader.ReadTPtrC(); // bmp filename
 aReader.ReadInt16(); // bmp id
 aReader.ReadInt16(); // bmp mask id
+_AKNTRACE_FUNC_EXIT;
 }
 TSize CEikCbaButton::MinimumSize()
 {
+_AKNTRACE_FUNC_ENTER;
 if (!iDoImage)
 {
+_AKNTRACE_FUNC_EXIT;
 return iLabel->MinimumSize();
 }
 else
 {
+_AKNTRACE_FUNC_EXIT;
 return iImage->MinimumSize();
 }
 }
 TInt CEikCbaButton::CountComponentControls() const
 {
+_AKNTRACE_FUNC_ENTER;
+_AKNTRACE_FUNC_EXIT;
 return 1;
 }
 CCoeControl* CEikCbaButton::ComponentControl(TInt aIndex) const
 {
+_AKNTRACE_FUNC_ENTER;
 if (aIndex==0)
 {
 if (!iDoImage)
 {
+_AKNTRACE_FUNC_EXIT;
 return iLabel;
 }
 else
 {
 // If SfeMask is available, then check the effect state (iPressedDown).
 }
 }
 return iImage;
 }
 }
+_AKNTRACE_FUNC_EXIT;
 return 0;
 }
 // ---------------------------------------------------------------------------
 // Handles size change events for CBA button.
 // ---------------------------------------------------------------------------
 //
 void CEikCbaButton::SizeChanged()
 {
+_AKNTRACE_FUNC_ENTER;
 // Resizing is done at CEikCba::SizeChanged().
 // We cannot resize here because this control has wrong
 // coordinate system available.
+_AKNTRACE_FUNC_EXIT;
 }
 EXPORT_C void CEikCbaButton::HandlePointerEventL(const TPointerEvent& aPointerEvent)
 {
+_AKNTRACE_FUNC_ENTER;
 CCoeControl::HandlePointerEventL(aPointerEvent);
+_AKNTRACE_FUNC_EXIT;
 }
 EXPORT_C void* CEikCbaButton::ExtensionInterface( TUid /*aInterface*/ )
 {
+_AKNTRACE_FUNC_ENTER;
+_AKNTRACE_FUNC_EXIT;
 return NULL;
 }
 void CEikCbaButton::SetDimmed(TBool aDimmed)
 {
+_AKNTRACE_FUNC_ENTER;
 CCoeControl::SetDimmed(aDimmed);
 if (!iDoImage)
 {
 iLabel->SetDimmed(aDimmed);
 }
 else
 {
 // Drawing dimmed CEikImages don't work (problem in uiklaf).
 //iImage->SetDimmed(aDimmed);
 }
+_AKNTRACE_FUNC_EXIT;
 }
 // ---------------------------------------------------------------------------
 // Updates the softkey label.
 // ---------------------------------------------------------------------------
 //
 void CEikCbaButton::UpdateLabelText( TPtrC aLabelText )
 {
+_AKNTRACE_FUNC_ENTER;
 // Updates the label text with the given label, using tab delimited
 // label text to identify normal / alternative labels.
 if ( aLabelText.Length() > KMaxCbaLabelLength )
 {
 // Cannot take more chars than maximum buffer size.
 TRAP_IGNORE( iLabel->SetTextL( iLongLabelText ) );
 if ( IsReadyToDraw() )
 {
 TruncateLabelText();
 }
+_AKNTRACE_FUNC_EXIT;
 }
 void CEikCbaButton::SetTextBitmapMode( TBool aEnableBitmap )
 {
+_AKNTRACE_FUNC_ENTER;
 iUseTextBitmap = aEnableBitmap;
 if ( iLabel )
 {
 iLabel->MakeVisible( !aEnableBitmap );
 }
+_AKNTRACE_FUNC_EXIT;
 }
 void CEikCbaButton::DrawToContext( CBitmapContext& aContext, CBitmapContext& aMaskContext, const TPoint& aOffset ) const
 {
+_AKNTRACE_FUNC_ENTER;
 if ( iLabel )
 {
 // Draw text into EColor16MA bitmap
 aContext.SetOrigin( -aOffset );
 iLabel->DrawToContext( aContext, NULL );
 // The mask should have a black background and the text in white.
 TRgb maskColor = KRgbWhite;
 aMaskContext.SetOrigin( -aOffset );
 iLabel->DrawToContext( aMaskContext, &maskColor );
 }
+_AKNTRACE_FUNC_EXIT;
 }
 void CEikCbaButton::SwitchToShortTextL(TBool aShortText)
 {
+_AKNTRACE_FUNC_ENTER;
 if (aShortText)
 {
 iLabel->SetTextL(iShortLabelText);
 }
 else
 }
 else
 {
 iImage->DrawDeferred();
 }
+_AKNTRACE_FUNC_EXIT;
 }
 void CEikCbaButton::SetLabelFont(const CFont* aLabelFont)
 {
+_AKNTRACE_FUNC_ENTER;
 iLabel->SetFont(aLabelFont);
+_AKNTRACE_FUNC_EXIT;
 }
 void CEikCbaButton::TruncateLabelText()
 {
+_AKNTRACE_FUNC_ENTER;
 // Truncation removed from here, as it was not bidi-text compatible.
 // Let CEikLabel handle truncation instead.
 iLabel->CropText();
+_AKNTRACE_FUNC_EXIT;
 }
 TBool CEikCbaButton::IsEmptyText() const
 {
+_AKNTRACE_FUNC_ENTER;
 if ( iDoImage )
 {
+_AKNTRACE_FUNC_EXIT;
 return EFalse;
 }
 TPtrC text( iFullLabelText );
 TBool allSpaces = ETrue;
 allSpaces = EFalse;
 break;
 }
 }
+_AKNTRACE_FUNC_EXIT;
 return allSpaces;
 }
 void CEikCbaButton::ConstructEmptyButtonL()
 {
+_AKNTRACE_FUNC_ENTER;
 ConstructL( EHRightVCenter ); // creates label
 _LIT(KEmptyText, "");
 TPtrC16 ptr(KEmptyText);
 UpdateLabelText( ptr );
+_AKNTRACE_FUNC_EXIT;
 }
 TBool CEikCbaButton::PressedDown() const
 {
+_AKNTRACE_FUNC_ENTER;
+_AKNTRACE_FUNC_EXIT;
 return iPressedDown;
 }
 void CEikCbaButton::SetPressedDown( const TBool aPressedDown )
 {
+_AKNTRACE_FUNC_ENTER;
 iPressedDown = aPressedDown;
+_AKNTRACE_FUNC_EXIT;
 }
 // -----------------------------------------------------------------------------
 // EikSoftkeyImage::SetImage
 //
 EXPORT_C void EikSoftkeyImage::SetImage(
 CEikButtonGroupContainer* aButtonGroupContainer,
 CEikImage& aImage,
 TBool aLeft)
 { // static
+_AKNTRACE_FUNC_ENTER;
 TInt commandPos = aLeft ? 0 : 2;
 TInt commandId = aButtonGroupContainer->ButtonGroup()->CommandId(commandPos);
 CEikCbaButton* cbaButton = (CEikCbaButton*) aButtonGroupContainer->ControlOrNull(commandId);
 if ( cbaButton )
 {
 aButtonGroupContainer->SetRect(aButtonGroupContainer->Rect());
 // Draw previosly set image
 cbaButton->DrawNow();
 aButtonGroupContainer->DrawNow();
 }
+_AKNTRACE_FUNC_EXIT;
 }
 // -----------------------------------------------------------------------------
 // EikSoftkeyImage::SetLabel
 //
 //
 EXPORT_C void EikSoftkeyImage::SetLabel(
 CEikButtonGroupContainer* aButtonGroupContainer,
 TBool aLeft)
 { // static
+_AKNTRACE_FUNC_ENTER;
 TInt commandPos = aLeft ? 0 : 2;
 TInt commandId = aButtonGroupContainer->ButtonGroup()->CommandId(commandPos);
 CEikCbaButton* cbaButton = (CEikCbaButton*) aButtonGroupContainer->ControlOrNull(commandId);
 if ( cbaButton )
 {
 aButtonGroupContainer->SetBoundingRect(screenRect);
 // Draw previosly set label
 cbaButton->DrawNow();
 aButtonGroupContainer->DrawNow();
 }
+_AKNTRACE_FUNC_EXIT;
 }
 // -----------------------------------------------------------------------------
 // CEikCbaButton::SetImage
 //
 // -----------------------------------------------------------------------------
 //
 void CEikCbaButton::SetImage(CEikImage &aImage)
 {
+_AKNTRACE_FUNC_ENTER;
 iDoImage = ETrue;
 if ( iImage )
 {
 iImage->SetMask( iMask );
 }
 else
 {
 ReplaceImageByLabel();
 }
+_AKNTRACE_FUNC_EXIT;
 }
 // -----------------------------------------------------------------------------
 // CEikCbaButton::PrepareImageL
 // Prepares Image for softkey feedback effect. Creates needed mask for
 // pressed down state.
 // -----------------------------------------------------------------------------
 //
 void CEikCbaButton::PrepareImageL()
 {
+_AKNTRACE_FUNC_ENTER;
 // 50% transparent pressed down image is made with a alternative mask
 // which is created when a image is set to CEikCbaButton.
 // Original mask is copied and each of its pixels color components is
 // halved. Bit-shifting to the right makes color value to half -->
 // image looks 50% transparent with this mask
 const CFbsBitmap* mask = iImage->Mask();
 iMask = mask;
 if ( !iMask )
 {
+_AKNTRACE_FUNC_EXIT;
 return;
 }
 iSfeMask = new (ELeave) CFbsBitmap;
 User::LeaveIfError( iSfeMask->Create( mask->SizeInPixels(), mask->DisplayMode() ) );
 iSfeMask->UnlockHeap();
 CleanupStack::PopAndDestroy( device ); // device
 delete gc;
+_AKNTRACE_FUNC_EXIT;
 }
 // -----------------------------------------------------------------------------
 // CEikCbaButton::ReplaceImageByLabel
 //
 // -----------------------------------------------------------------------------
 //
 void CEikCbaButton::ReplaceImageByLabel()
 {
+_AKNTRACE_FUNC_ENTER;
 iDoImage = EFalse;
 if ( iImage )
 {
 // avoid mem leak.
 iImage->SetMask( iMask );
 delete iImage;
 iImage = NULL;
 delete iSfeMask;
 iSfeMask = NULL;
 }
+_AKNTRACE_FUNC_EXIT;
 }
 //
 // CEikEnhancedCbaButton
 //
 // -----------------------------------------------------------------------------
 // default constructor
 // -----------------------------------------------------------------------------
 CEikEnhancedCbaButton::CEikEnhancedCbaButton()
 {
+_AKNTRACE_FUNC_ENTER;
+_AKNTRACE_FUNC_EXIT;
 }
 // -----------------------------------------------------------------------------
 // default destructor
 // -----------------------------------------------------------------------------
 CEikEnhancedCbaButton::~CEikEnhancedCbaButton()
 {
+_AKNTRACE_FUNC_ENTER;
+_AKNTRACE_FUNC_EXIT;
 }
 // -----------------------------------------------------------------------------
 // Sets command type for current button
 // @param aCommandType Command type to be set
 // -----------------------------------------------------------------------------
 #ifdef RD_ENHANCED_CBA
 void CEikEnhancedCbaButton::SetCommandType( const TInt aCommandType )
 {
+_AKNTRACE_FUNC_ENTER;
 iCommandType = aCommandType;
+_AKNTRACE_FUNC_EXIT;
 }
 #else
 void CEikEnhancedCbaButton::SetCommandType( const TInt /*aCommandType*/ )
 {
+_AKNTRACE_FUNC_ENTER;
+_AKNTRACE_FUNC_EXIT;
 }
 #endif // RD_ENHANCED_CBA
 // -----------------------------------------------------------------------------
 // returns command's type for current button
 // @return TInt command's type
 // -----------------------------------------------------------------------------
 TInt CEikEnhancedCbaButton::CommandType() const
 {
+_AKNTRACE_FUNC_ENTER;
+_AKNTRACE_FUNC_EXIT;
 #ifdef RD_ENHANCED_CBA
 return iCommandType;
 #else
 return 0;
 #endif // RD_ENHANCED_CBA
 // returns command id for current button
 // @return TInt command's id
 // -----------------------------------------------------------------------------
 TInt CEikEnhancedCbaButton::CommandId() const
 {
+_AKNTRACE_FUNC_ENTER;
+_AKNTRACE_FUNC_EXIT;
 #ifdef RD_ENHANCED_CBA
 return iCommandId;
 #else
 return 0;
 #endif // RD_ENHANCED_CBA
 // @param aReader created resource reader for reading information from resource file
 // -----------------------------------------------------------------------------
 #ifdef RD_ENHANCED_CBA
 void CEikEnhancedCbaButton::ConstructFromResourceL(TResourceReader& aReader)
 {
+_AKNTRACE_FUNC_ENTER
 // Alignment set to right.
 ConstructL( EHRightVCenter ); // creates label
 iCommandType = aReader.ReadUint8();
 iCommandId = aReader.ReadInt16();
 // iFullLabelText.Copy( aReader.ReadTPtrC() );
 UpdateLabelText( aReader.ReadTPtrC() );
 aReader.ReadTPtrC(); // bmp filename
 aReader.ReadInt16(); // bmp id
 aReader.ReadInt16(); // bmp mask id
+_AKNTRACE_FUNC_EXIT;
 }
 #else
 void CEikEnhancedCbaButton::ConstructFromResourceL(TResourceReader&)
 {
+_AKNTRACE_FUNC_ENTER;
+_AKNTRACE_FUNC_EXIT;
 }
 #endif // RD_ENHANCED_CBA
 // -----------------------------------------------------------------------------
 // Constructs empty button with id EAknSoftkeyEmpty
 // -----------------------------------------------------------------------------
 void CEikEnhancedCbaButton::ConstructEmptyButtonL()
 {
+_AKNTRACE_FUNC_ENTER;
+_AKNTRACE_FUNC_EXIT;
 #ifdef RD_ENHANCED_CBA
 ConstructL( EHRightVCenter ); // creates label
 iCommandType = EEikCommandTypeAnyCommand;
 iCommandId = EAknSoftkeyEmpty;
 _LIT(KEmptyText, "");
 // Used to get the label's text for the button
 // @return TPtrC label text
 // -----------------------------------------------------------------------------
 TPtrC* CEikEnhancedCbaButton::LabelText()
 {
+_AKNTRACE_FUNC_ENTER;
+_AKNTRACE_FUNC_EXIT;
 #ifdef RD_ENHANCED_CBA
 return &iLongLabelText;
 #else
 return NULL;
 #endif
 // CEikCommandTable
 //
 CEikCommandTable* CEikCommandTable::NewL()
 {
+_AKNTRACE_FUNC_ENTER;
+_AKNTRACE_FUNC_EXIT;
 #ifdef RD_ENHANCED_CBA
 CEikCommandTable* self = CEikCommandTable::NewLC();
 CleanupStack::Pop( self );
 return self;
 #else
 #endif
 }
 CEikCommandTable* CEikCommandTable::NewLC()
 {
+_AKNTRACE_FUNC_ENTER;
+_AKNTRACE_FUNC_EXIT;
 #ifdef RD_ENHANCED_CBA
 CEikCommandTable* self = new (ELeave) CEikCommandTable;
 CleanupStack::PushL( self );
 self->ConstructL();
 return self;
 // Construction for command table
 // priority configuration is read from the resource file
 // -----------------------------------------------------------------------------
 void CEikCommandTable::ConstructL()
 {
+_AKNTRACE_FUNC_ENTER;
 #ifdef RD_ENHANCED_CBA
 // Get the cba priority configuration
 TResourceReader reader;
 CCoeEnv::Static()->CreateResourceReaderLC( reader, R_EIK_CBA_PRIORITIES );
 iPriorities.Append( arr );
 }
 CleanupStack::PopAndDestroy(); // reader
 #endif
+_AKNTRACE_FUNC_EXIT;
 }
 #ifdef RD_ENHANCED_CBA
 CEikCommandTable::CEikCommandTable() : iPriorities(1)
 #else
 }
 CEikCommandTable::~CEikCommandTable()
 {
+_AKNTRACE_FUNC_ENTER;
 #ifdef RD_ENHANCED_CBA
 iCommandButtons.Reset(); // Reset array
 for(TInt i = 0; i < iPriorities.Count(); i++)
 {
 iPriorities[i].Reset();
 }
 iPriorities.Reset();
 #endif
+_AKNTRACE_FUNC_EXIT;
 }
 // -----------------------------------------------------------------------------
 // Used to add a command to CommandTable
 // @param aButton button to be added
 // -----------------------------------------------------------------------------
 #ifndef RD_ENHANCED_CBA
 TInt CEikCommandTable::AddCommandL(CEikEnhancedCbaButton* /*aButton*/)
 {
+_AKNTRACE_FUNC_ENTER;
+_AKNTRACE_FUNC_EXIT;
 return KErrNone;
 }
 #else
 TInt CEikCommandTable::AddCommandL(CEikEnhancedCbaButton* aButton)
 {
+_AKNTRACE_FUNC_ENTER;
 // CommandType tells in which button this command should be placed
 TInt commandType( aButton->CommandType() );
 TInt index( KErrNotFound );
 // Find button and index for this button.
 if( button == iPriorities.Count() )
 {
 delete aButton;
 aButton = NULL;
 }
+_AKNTRACE_FUNC_EXIT;
 return KErrNone;
 }
 #endif // RD_ENHANCED_CBA
 // -----------------------------------------------------------------------------
 // @param aCommandId Id to be checked.
 // -----------------------------------------------------------------------------
 #ifndef RD_ENHANCED_CBA
 TBool CEikCommandTable::IsCommandPlaced(const TInt /*aCommandId*/) const
 {
+_AKNTRACE_FUNC_ENTER;
 #else // !RD_ENHANCED_CBA
 TBool CEikCommandTable::IsCommandPlaced(const TInt aCommandId) const
 {
+_AKNTRACE_FUNC_ENTER;
 TInt count( iCommandButtons.Count() );
 for ( TInt i = 0; i < count; i++ )
 {
 if ( iCommandButtons[i] )
 {
 if ( iCommandButtons[i]->CommandId() == aCommandId )
 {
+_AKNTRACE_FUNC_EXIT;
 return ETrue;
 }
 }
 }
 #endif // RD_ENHANCED_CBA
+_AKNTRACE_FUNC_EXIT;
 return EFalse; // if no match for command id
 }
 // -----------------------------------------------------------------------------
 // Used to replace command with a new command.
 // @param aResourceId Id for new ENHANCED_CBA_BUTTON resource to be placed in the CommandTable.
 // -----------------------------------------------------------------------------
 #ifndef RD_ENHANCED_CBA
 void CEikCommandTable::ReplaceCommandL( const TInt /*aCommandId*/, const TInt /*aResourceId*/ )
 {
+_AKNTRACE_FUNC_ENTER;
 #else // !RD_ENHANCED_CBA
 void CEikCommandTable::ReplaceCommandL( const TInt aCommandId, const TInt aResourceId )
 {
+_AKNTRACE_FUNC_ENTER;
 // If the command is not in the command table, return.
 if( !IsCommandPlaced( aCommandId ) )
 {
+_AKNTRACE_FUNC_EXIT;
 return;
 }
 TInt index( iCommandButtons.Count() );
 iCommandButtons[index] = button; // transfers ownership
 // Delete old button.
 delete oldButton;
 #endif // !RD_ENHANCED_CBA
+_AKNTRACE_FUNC_EXIT;
 }
 // -----------------------------------------------------------------------------
 // Used to get CEikEnhancedCbaButton for current control button (1-4).
 // @param aCommandIndex Index for requested button, use enum TCommandTableCbaPositions.
 // @return CEikCbaButton for current position, NULL if no button placed in that position.
 // -----------------------------------------------------------------------------
 #ifdef RD_ENHANCED_CBA
 CEikEnhancedCbaButton* CEikCommandTable::Command( const TInt aCommandIndex )
 {
+_AKNTRACE_FUNC_ENTER;
+_AKNTRACE_FUNC_EXIT;
 return iCommandButtons[aCommandIndex];
 }
 #else // RD_ENHANCED_CBA
 CEikEnhancedCbaButton* CEikCommandTable::Command( const TInt /*aCommandIndex*/ )
 {
+_AKNTRACE_FUNC_ENTER;
+_AKNTRACE_FUNC_EXIT;
 return NULL;
 }
 #endif // RD_ENHANCED_CBA
 // -----------------------------------------------------------------------------
 // Reset CommandTable
 // -----------------------------------------------------------------------------
 void CEikCommandTable::Reset()
 {
+_AKNTRACE_FUNC_ENTER;
+_AKNTRACE_FUNC_EXIT;
 #ifdef RD_ENHANCED_CBA
 iCommandButtons.Reset();
 #endif // RD_ENHANCED_CBA
 }
 // -----------------------------------------------------------------------------
 EXPORT_C void AknCbaContentObserver::SetContentObserver(
 CEikCba* aCba,
 TCallBack aCallBack )
 {
+_AKNTRACE_FUNC_ENTER;
 if ( aCba )
 {
 aCba->SetContentObserver( aCallBack );
 }
+_AKNTRACE_FUNC_EXIT;
 }
 // End of file

branch	RCL_3
changeset 10	9f56a4e1b8ab
parent 9	aabf2c525e0f
child 16	71dd06cfe933