1 /*

     2 * Copyright (c) 2002-2008 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:  EIKON Status Pane model and layouts.

    15 *

    16 */

    17 

    18 

    19 #include <eikspmod.h>

    20 #include <barsread.h>

    21 #include <eikenv.h>

    22 #include <eikcoctl.rsg>

    23 #include <AknSgcc.h>

    24 #include <aknenv.h>

    25 #include <aknlayout.cdl.h>

    26 #include <AknUtils.h>

    27 #include <AknLayout.lag>

    28 #include <applayout.cdl.h>

    29 

    30 #include <aknlayoutscalable_avkon.cdl.h>

    31 #include "layoutmetadata.cdl.h"

    32 

    33 inline TAknWindowComponentLayout DoCompose(TAknWindowComponentLayout aLine1, TAknWindowComponentLayout aLine2) 

    34     { 

    35     return TAknWindowComponentLayout::Compose(aLine1, aLine2); 

    36     }

    37 

    38 inline TAknTextComponentLayout DoComposeText(TAknWindowComponentLayout aLine1, TAknTextComponentLayout aLine2) 

    39     { 

    40     return TAknWindowComponentLayout::ComposeText(aLine1, aLine2); 

    41     }

    42 

    43 const TInt KStatusPaneSetInitGranularity = 4;

    44 const TInt KEikSpanePositionMask = 3;

    45 

    46 

    47 inline TBool TEikStatusPaneInit::Initialized() { return iFlags & KEikStatusPaneInitInitializedBit; }

    48 inline void TEikStatusPaneInit::SetInitialized() { iFlags |= KEikStatusPaneInitInitializedBit; }

    49 

    50 inline CEikStatusPaneLayoutTree::TDirection CEikStatusPaneLayoutTree::Direction() { return (iFlags & KEikStatusPaneDirectionBit) ? EVertical : EHorizontal; }

    51 inline TInt CEikStatusPaneLayoutTree::Size() { return iSize; }

    52 inline TBool CEikStatusPaneLayoutTree::Stretchable() { return iFlags & EEikStatusPaneIsStretchable; }

    53 

    54 

    55 TEikStatusPaneInit::TEikStatusPaneInit()

    56 : iControlId(0), iControlResource(0), iFlags(0)

    57 	{

    58 	}

    59 

    60 TEikStatusPaneInit::TEikStatusPaneInit(const TEikStatusPaneInit& aCopy)

    61 	{

    62 	*this = aCopy;

    63 	}

    64 

    65 TEikStatusPaneInit& TEikStatusPaneInit::operator=(const TEikStatusPaneInit& aCopy)

    66 	{

    67 	// Don't copy id or flags - these will have been set when this structure was first loaded

    68 	if (aCopy.iControlId)

    69 		{

    70 		iControlId = aCopy.iControlId;

    71 		iControlResource = aCopy.iControlResource;

    72 		}

    73 

    74 	return *this;

    75 	}

    76 

    77 void TEikStatusPaneInit::LoadDefaults(TResourceReader& aResource)

    78 	{

    79 	iId = TUid::Uid(aResource.ReadInt32());

    80 	iFlags = aResource.ReadUint16();

    81 	iControlId = aResource.ReadUint16();

    82 	iControlResource = aResource.ReadUint32();

    83 	}

    84 

    85 

    86 

    87 CEikStatusPaneSetInit* CEikStatusPaneSetInit::NewL()

    88 	{

    89 	CEikStatusPaneSetInit* self = new(ELeave) CEikStatusPaneSetInit();

    90 	return self;

    91 	}

    92 

    93 CEikStatusPaneSetInit::~CEikStatusPaneSetInit()

    94 	{

    95 	}

    96 

    97 void CEikStatusPaneSetInit::LoadDefaultsL(TResourceReader& aResource)

    98 	{

    99 	const TBool initialized = (Count() != 0);

   100 	const TInt count=aResource.ReadInt16();

   101 

   102 	for (TInt ii=0;ii<count;++ii)

   103 		{

   104 		TEikStatusPaneInit init;

   105 		init.LoadDefaults(aResource);

   106 		if ( init.ControlResourceId() )

   107 		    {

   108 		    if (initialized)

   109 			    {

   110 			    FindL(init.Id()) = init;

   111 			    }

   112 		    else

   113 			    {

   114 			    AppendL(init);

   115 			    }

   116 		    }

   117 		}

   118 	}

   119 

   120 CEikStatusPaneSetInit::CEikStatusPaneSetInit() 

   121 : CArrayFixFlat<TEikStatusPaneInit>(KStatusPaneSetInitGranularity)

   122 	{

   123 	}

   124 

   125 TEikStatusPaneInit& CEikStatusPaneSetInit::FindL(const TPaneId& aPaneId)

   126 	{

   127 	for (TInt i=0; i<Count(); i++)

   128 		{

   129 		if (At(i).Id() == aPaneId)

   130 			return At(i);

   131 		}

   132 

   133 	User::Leave(KErrNotFound);

   134 	return At(0);	// will never get here

   135 	}

   136 

   137 CEikStatusPaneLayoutTree::~CEikStatusPaneLayoutTree()

   138 	{

   139 	if (iSubPanes)

   140 		iSubPanes->ResetAndDestroy();

   141 	delete iSubPanes;

   142 	}

   143 

   144 CEikStatusPaneLayoutTree* CEikStatusPaneLayoutTree::NewL(CEikStatusPaneLayout* aLayout, TResourceReader& aResource, TDirection aDefaultDirection)

   145 	{

   146 	CEikStatusPaneLayoutTree* self = new(ELeave) CEikStatusPaneLayoutTree(aLayout, aDefaultDirection);

   147 	CleanupStack::PushL(self);

   148 	self->ConstructL(aResource);

   149 	CleanupStack::Pop();

   150 	return self;

   151 	}

   152 

   153 CEikStatusPaneLayoutTree* CEikStatusPaneLayoutTree::Find(const TPaneId& aPaneId)

   154 	{

   155 	if (iId == aPaneId)

   156 		return this;

   157 	else if (iSubPanes)

   158 		{

   159 		for (TInt i=0; i<iSubPanes->Count(); i++)

   160 			{

   161 			CEikStatusPaneLayoutTree* pane = iSubPanes->At(i)->Find(aPaneId);

   162 			if (pane)

   163 				return pane;

   164 			}

   165 		}

   166 

   167 	return NULL;

   168 	}

   169 

   170 CEikStatusPaneLayoutTree::CEikStatusPaneLayoutTree(CEikStatusPaneLayout* aLayout, TDirection aDefaultDirection)

   171 : iLayout(aLayout)

   172 	{

   173 	SetDirection(aDefaultDirection);

   174 	}

   175 

   176 void CEikStatusPaneLayoutTree::ConstructL(TResourceReader& aResource)

   177 	{

   178 	iId.iUid = aResource.ReadInt32();

   179 

   180 	TDirection dir = Direction();

   181 	iFlags = aResource.ReadUint16();

   182 	SetDirection(dir);

   183 

   184 	iSize = aResource.ReadUint16();

   185 

   186 	TDirection subDir = Direction() == EVertical ? EHorizontal : EVertical;	// Change direction for sub panes

   187 

   188 	const TInt count=aResource.ReadInt16();

   189 	if (count > 0)

   190 		{

   191 		iSubPanes = new(ELeave) CSubPaneArray(count);

   192 		for (TInt ii=0;ii<count;++ii)

   193 			{

   194 			CEikStatusPaneLayoutTree* pane = CEikStatusPaneLayoutTree::NewL(iLayout, aResource, subDir);

   195 			CleanupStack::PushL(pane);

   196 			iSubPanes->AppendL(pane);

   197 			CleanupStack::Pop();		// pane

   198 			}

   199 		}

   200 	}

   201 

   202 void CEikStatusPaneLayoutTree::Layout()

   203 	{

   204 	if (!iSubPanes)

   205 		return;

   206 

   207 	TInt unallocedSize = Direction()==EHorizontal ? iRect.Width() : iRect.Height();

   208 	TInt stretchSize = 0;

   209 

   210 	TInt count = iSubPanes->Count();

   211 	TInt i;

   212 	for (i=0; i<count; i++)

   213 		{

   214 		CEikStatusPaneLayoutTree* subPane = iSubPanes->At(i);

   215 

   216 		TInt size = subPane->Size();

   217 

   218 		if (subPane->Stretchable())

   219 			stretchSize += size;

   220 		else

   221 			unallocedSize -= size;

   222 		}

   223 

   224 	TPoint pos( iRect.iTl );

   225 

   226 	for (i=0; i<count; i++)

   227 		{

   228 		CEikStatusPaneLayoutTree* subPane = iSubPanes->At(i);

   229 

   230 		TInt size( subPane->Size() );

   231 

   232 		if (size > 0 && subPane->Stretchable() && stretchSize != 0)

   233 			{

   234 			TInt oldSize = size;

   235 			size = (size * unallocedSize) / stretchSize;

   236 			unallocedSize -= size;

   237 			stretchSize -= oldSize;

   238 			}

   239 

   240 		TSize subSize( iRect.Size() );

   241 		if (Direction()==EHorizontal)

   242 			subSize.iWidth = size;

   243 		else

   244 			subSize.iHeight = size;

   245 		subPane->SetRect(TRect(pos,subSize));

   246 

   247 		if (Direction()==EHorizontal)

   248 			pos.iX += size;

   249 		else

   250 			pos.iY += size;

   251 		}

   252 	}

   253 

   254 void CEikStatusPaneLayoutTree::SetDirection(TDirection aDirection)

   255 	{

   256 	if (aDirection == EVertical)

   257 		iFlags |= KEikStatusPaneDirectionBit;

   258 	else

   259 		iFlags &= ~KEikStatusPaneDirectionBit;

   260 	}

   261 

   262 void CEikStatusPaneLayoutTree::SetStretchable(TBool aStretchable)

   263 	{

   264 	if (aStretchable)

   265 		iFlags |= EEikStatusPaneIsStretchable;

   266 	else

   267 		iFlags &= ~EEikStatusPaneIsStretchable;

   268 	}

   269 

   270 void CEikStatusPaneLayoutTree::SetRect(const TRect& aRect)

   271 	{

   272 	iRect = aRect;

   273 	Layout();

   274 	}

   275 

   276 void CEikStatusPaneLayoutTree::AcceptL(MEikStatusPaneLayoutTreeVisitor* aVisitor)

   277 	{

   278 	if (iId.iUid != 0)

   279 		aVisitor->VisitL(this);

   280 	

   281 	if (iSubPanes)

   282 		{

   283 		for (TInt i=0; i<iSubPanes->Count(); i++)

   284 			{

   285 			iSubPanes->At(i)->AcceptL(aVisitor);

   286 			}

   287 		}

   288 	}

   289 

   290 void CEikStatusPaneLayoutTree::SetAknLayoutUsed(TBool aAknLayoutUsed) 

   291     {

   292     if (aAknLayoutUsed)

   293         {

   294         iFlags |= EEikStatusPaneLayoutAknLafDefined; 

   295         }

   296     else

   297         {

   298         iFlags &= ~EEikStatusPaneLayoutAknLafDefined; 

   299         }

   300     }

   301 

   302 TBool CEikStatusPaneLayoutTree::AknLayoutUsed()

   303     {

   304     if ( iFlags & EEikStatusPaneLayoutAknLafDefined )

   305         {

   306         return ETrue;

   307         }

   308     else

   309         {

   310         return EFalse;

   311         }

   312     }

   313 

   314 

   315 void CEikStatusPaneLayoutTree::Layout(TInt aLayoutId)

   316     {

   317     if (!AknLayoutUsed())

   318         {

   319         Layout();

   320         }

   321     else

   322         {

   323         TRect rectFromAknLayout( AknLayoutRect(aLayoutId, iId) );

   324         if (rectFromAknLayout.Size() != TSize(0,0))

   325             {

   326             iRect = rectFromAknLayout;

   327             }

   328 

   329 	    if (!iSubPanes)

   330 		    return;

   331 

   332 	    TInt count = iSubPanes->Count();

   333 	    TInt i;

   334 	    for (i=0; i<count; i++)

   335 		    {

   336 		    CEikStatusPaneLayoutTree* subPane = iSubPanes->At(i);

   337 		    subPane->SetAknLayoutUsed(ETrue);

   338 		    subPane->Layout(aLayoutId);

   339 		    }

   340         }

   341     }

   342 

   343 TRect CEikStatusPaneLayoutTree::AknLayoutRect(TInt aLayoutId, TPaneId aPaneId)

   344     {

   345     const TBool idleIndicatorsInLandscapeAreVertical = EFalse;

   346 

   347 	// Note that small digital clock cannot be shown in such displays that have smaller aspect ratio than 4:3. 

   348 #ifndef __SERIES60_31__  

   349     TBool smallDigitalClockInStacon = ETrue;

   350 	TBool smallDigitalClockInLandscapeFlatSpUsual = ETrue; 

   351 	TBool smallDigitalClockInLandscapeFlatSpIdle = ETrue;  

   352 #else

   353     TBool smallDigitalClockInStacon = EFalse;

   354 	TBool smallDigitalClockInLandscapeFlatSpUsual = EFalse;

   355 	TBool smallDigitalClockInLandscapeFlatSpIdle = EFalse;

   356 #endif    

   357     

   358     TRect paneRect; // initialises to (0,0,0,0);

   359     TRect parentRect; // initialises to (0,0,0,0);

   360     TAknWindowLineLayout layout;

   361     Mem::FillZ(&layout, sizeof(layout));

   362 

   363     const TRect& screenRect = iLayout->iScreenRect; 

   364     const TRect& mainPaneRect = iLayout->iMainPaneRect;

   365     const TRect& usualStatusPaneRect = iLayout->iUsualStatusPaneRect;

   366     const TRect& applicationWindowRect = iLayout->iApplicationWindowRect;

   367 

   368 	const AknLayout::CInstance& aknLayout = iLayout->iAknLayout;

   369 	const AknLayoutScalable_Avkon::CInstance& aknLayoutScalable_Avkon = iLayout->iAknLayoutScalable_Avkon;

   370 

   371 	switch (aLayoutId)

   372 		{

   373 		case R_AVKON_STATUS_PANE_LAYOUT_USUAL:

   374 		case R_AVKON_STATUS_PANE_LAYOUT_USUAL_MIRRORED:

   375 	        {

   376 	        parentRect = usualStatusPaneRect;

   377 	        switch(aPaneId.iUid)

   378 	            {

   379 	            case EEikStatusPaneUidNavi: 

   380 	                {

   381 	                layout = aknLayoutScalable_Avkon.navi_pane(0).LayoutLine();

   382 	                break;

   383 	                }

   384 	            case EEikStatusPaneUidSignal:

   385 	                {

   386 	                layout = aknLayoutScalable_Avkon.signal_pane(0).LayoutLine();

   387 	                break;

   388 	                }

   389 	            case EEikStatusPaneUidContext:

   390 	                {

   391 	                layout = aknLayoutScalable_Avkon.context_pane(0).LayoutLine();

   392 	                break;

   393 	                }

   394 	            case EEikStatusPaneUidTitle:

   395 	                {

   396 	                layout = aknLayoutScalable_Avkon.title_pane(0).LayoutLine();

   397 	                break;

   398 	                }

   399 	            case EEikStatusPaneUidIndic:

   400 	                {

   401 	                layout = aknLayoutScalable_Avkon.uni_indicator_pane(0).LayoutLine();

   402 	                break;

   403 	                }

   404 	            case EEikStatusPaneUidBattery:

   405 	                {

   406 	                layout = aknLayoutScalable_Avkon.battery_pane(0).LayoutLine();

   407 	                break;

   408 	                }

   409 	            }

   410 	        break;

   411 	        }

   412 

   413 		case R_AVKON_STACON_PANE_LAYOUT_USUAL_SOFTKEYS_LEFT:

   414 		case R_AVKON_STACON_PANE_LAYOUT_USUAL_SOFTKEYS_RIGHT:

   415 	        {

   416 	        // Final check for small digital clock, shown only in resolutions having aspect 

   417 	        // ratio equal or wider than qvga because otherwise there is no space for it.

   418 	        if (smallDigitalClockInStacon)

   419 	        	{

   420 	        	TReal aspectRatio = TReal(screenRect.Width()) / TReal(screenRect.Height());

   421 	        	if (aspectRatio < 1.33)

   422 	        		smallDigitalClockInStacon = EFalse;	        			

   423 	        	}

   424 	        

   425 	        

   426 	        TInt variety = 0;

   427 	        TInt clockVariety = 1;

   428 	        if (aLayoutId == R_AVKON_STACON_PANE_LAYOUT_USUAL_SOFTKEYS_LEFT)

   429 	            {

   430 	            // softkeys left

   431 	            variety = 1; 

   432 	            clockVariety = 3;

   433 	            }

   434 

   435 			const TRect layout1Rect( iLayout->iStaconLayout1Rect );

   436 			const TRect layout2Rect( iLayout->iStaconLayout2Rect );

   437 

   438 	        switch(aPaneId.iUid)

   439 	            {

   440 	            case EEikStatusPaneUidNavi: 

   441 	                {

   442 	                // If clock is shown, then use different variety for navipane

   443                     if (smallDigitalClockInStacon)

   444                     	variety +=2;	

   445 	                

   446 	                parentRect = layout2Rect;

   447 	                layout = aknLayoutScalable_Avkon.navi_pane_stacon(variety).LayoutLine();

   448 	                break;

   449 	                }

   450 	            case EEikStatusPaneUidSignal:

   451 	                {

   452 	                parentRect = layout1Rect;

   453 	                layout = aknLayoutScalable_Avkon.signal_pane_stacon(variety).LayoutLine();

   454 	                break;

   455 	                }

   456 	            case EEikStatusPaneUidTitle:

   457 	                {

   458 	                parentRect = layout1Rect;

   459                     if (smallDigitalClockInStacon)

   460                     	{

   461                     	TInt titleVariety = 4;

   462 			            if (aLayoutId == R_AVKON_STACON_PANE_LAYOUT_USUAL_SOFTKEYS_LEFT)

   463 			                {

   464 							titleVariety = 5;

   465 			                }

   466 		                layout = aknLayoutScalable_Avkon.title_pane_stacon(titleVariety).LayoutLine();                		                    	

   467                     	}

   468                     else

   469                     	{

   470 		                layout = aknLayoutScalable_Avkon.title_pane_stacon(variety).LayoutLine();                		

   471                     	}	

   472 	                break;

   473 	                }

   474 	            case EEikStatusPaneUidIndic:

   475 	                {

   476                     if (smallDigitalClockInStacon)

   477                     	{

   478                     	TInt indicatorVariety = 1;

   479 			            if (aLayoutId == R_AVKON_STACON_PANE_LAYOUT_USUAL_SOFTKEYS_LEFT)

   480 			                {

   481 							indicatorVariety = 5;

   482 			                }

   483 	                    parentRect = layout1Rect;

   484 	                    layout = aknLayoutScalable_Avkon.indicator_nsta_pane_cp2(indicatorVariety).LayoutLine();                		

   485                     	}

   486                     else

   487                     	{	                

   488 	                	parentRect = layout1Rect;

   489 	                	layout = aknLayoutScalable_Avkon.uni_indicator_pane_stacon(variety).LayoutLine();

   490 	                    }

   491 	                break;

   492 	                }

   493 	            case EEikStatusPaneUidBattery:

   494 	                {

   495 	                parentRect = layout2Rect;

   496 	                layout = aknLayoutScalable_Avkon.battery_pane_stacon(variety).LayoutLine();

   497 	                break;

   498 	                }

   499 	            case EEikStatusPaneUidDigitalClock:

   500 	                {

   501 	                if (smallDigitalClockInStacon)

   502 	                	{

   503 		                parentRect = layout2Rect;

   504 	 	               	layout = aknLayoutScalable_Avkon.clock_nsta_pane_cp2(clockVariety).LayoutLine();                		

   505 	                	}

   506 	                break;

   507 	                }	             

   508 	            }

   509 	        break;

   510 	        }

   511 

   512 		case R_AVKON_STATUS_PANE_LAYOUT_SMALL:

   513 	        {	        

   514 	        switch(aPaneId.iUid)

   515 	            {

   516 	            // In this layout navi pane gets the whole small status pane area.

   517 	            case EEikStatusPaneUidNavi: 

   518 	                {

   519 	                paneRect = iLayout->iSmallStatusPaneRect;

   520 	                break;

   521 	                }

   522 	            }

   523 	        break;

   524 	        }

   525 

   526 		case R_AVKON_STATUS_PANE_LAYOUT_SMALL_WITH_SIGNAL_PANE:

   527 		case R_AVKON_STATUS_PANE_LAYOUT_SMALL_WITH_SIGNAL_PANE_MIRRORED:

   528 	        {

   529 	        parentRect = iLayout->iSmallStatusPaneRect;

   530 	        switch(aPaneId.iUid)

   531 	            {

   532 	            case EEikStatusPaneUidNavi: 

   533 	                {

   534 	                // avkon LAF doesn't provide this directly, some calculations are needed.

   535 	                paneRect = parentRect;

   536 	                TAknWindowLineLayout smallStatusSignalLayout(

   537 	                    AknLayoutScalable_Avkon::status_small_pane_g2(0).LayoutLine() );

   538 	                TAknLayoutRect smallStatusSignalLayoutRect;

   539 	                smallStatusSignalLayoutRect.LayoutRect(parentRect, smallStatusSignalLayout);

   540 	                TRect smallStatusSignalRect( smallStatusSignalLayoutRect.Rect() );

   541 

   542 	                if (AknLayoutUtils::LayoutMirrored())

   543 	                    {

   544 	                    paneRect.iBr.iX -= smallStatusSignalRect.Width();

   545 	                    }

   546 	                else

   547 	                    {

   548 	                    paneRect.iTl.iX += smallStatusSignalRect.Width();

   549 	                    }

   550 

   551 	                break;

   552 	                }

   553 	            case EEikStatusPaneUidSignal:

   554 	                {

   555 	                layout = AknLayoutScalable_Avkon::status_small_pane_g2(0).LayoutLine();

   556                     // Adjustment needed for BSK LSC for navi pane and signal pane to be the same height

   557 	                layout.iH = parentRect.Height();

   558 	                break;

   559 	                }

   560 	            }

   561 	        break;

   562 	        }

   563 

   564 		case R_AVKON_STATUS_PANE_LAYOUT_IDLE:

   565 		case R_AVKON_STATUS_PANE_LAYOUT_IDLE_MIRRORED:

   566 	        {

   567 	        // by default "idle" statuspane values have "usual" statuspane as parent in LAF

   568 	        parentRect = usualStatusPaneRect;

   569 	        switch(aPaneId.iUid)

   570 	            {

   571 	            case EEikStatusPaneUidNavi: 

   572 	                {

   573 	                layout = aknLayout.navi_pane(1);                

   574 	                break;

   575 	                }

   576 	            case EEikStatusPaneUidSignal:

   577 	                {

   578 	                layout = aknLayout.signal_pane(parentRect);

   579 	                break;

   580 	                }

   581 

   582 	            case EEikStatusPaneUidBattery:

   583 	                {

   584 	                layout = aknLayout.battery_pane(parentRect);

   585 	                break;

   586 	                }

   587 	            case EEikStatusPaneUidTitle:

   588 	                {

   589 	                layout = aknLayout.title_pane(1);

   590 	                break;

   591 	                }

   592 	            case EEikStatusPaneUidIndic:

   593 	                {

   594 	                // Exceptionally mainpane as parent

   595 	                parentRect = mainPaneRect;

   596 	                layout = aknLayout.indicator_pane();              

   597 	                break;

   598 	                }

   599 	            case EEikStatusPaneUidClock:

   600 	                {

   601 	                // Exceptionally idle statuspane as parent

   602 				    TAknWindowLineLayout idleStatusPaneLayout( aknLayout.status_pane(applicationWindowRect, 1) );

   603 				    TAknLayoutRect idleStatusPaneLayoutRect;

   604 				    idleStatusPaneLayoutRect.LayoutRect(applicationWindowRect, idleStatusPaneLayout);

   605 	                parentRect = idleStatusPaneLayoutRect.Rect(); 

   606 	                layout = aknLayout.context_pane(parentRect, 1);                

   607 	                break;

   608 	                }

   609 	            }

   610 	        break;

   611 	        }

   612 

   613 		case R_AVKON_STATUS_PANE_LAYOUT_POWER_OFF_RECHARGE:

   614 		case R_AVKON_STATUS_PANE_LAYOUT_POWER_OFF_RECHARGE_MIRRORED:

   615 	        {

   616 	        switch(aPaneId.iUid)

   617 	            {

   618 	            case EEikStatusPaneUidBattery: 

   619 	                {

   620 	                if (Layout_Meta_Data::IsLandscapeOrientation())

   621 	                     {

   622 	                     TAknLayoutRect layoutRect;

   623 	                     TAknWindowComponentLayout parentLayout = aknLayoutScalable_Avkon.area_top_pane(8);

   624 	                     layoutRect.LayoutRect(screenRect, parentLayout.LayoutLine());

   625 	                     parentRect = layoutRect.Rect();

   626 	                     layout = aknLayoutScalable_Avkon.battery_pane(2).LayoutLine();

   627 	                     }

   628 	                 else

   629 	                     {

   630 	                     parentRect = usualStatusPaneRect;

   631 	                     layout = aknLayout.battery_pane(parentRect);

   632 	                     }

   633 	                break;

   634 	                }

   635 	            }

   636 	        break;

   637 	        }

   638 

   639 		case R_AVKON_STATUS_PANE_LAYOUT_VT:

   640 		case R_AVKON_STATUS_PANE_LAYOUT_VT_MIRRORED:

   641 	        {

   642 	        parentRect = usualStatusPaneRect;

   643 	        switch(aPaneId.iUid)

   644 	            {

   645 	            case EEikStatusPaneUidNavi: 

   646 	                {

   647 	                layout = aknLayout.navi_pane(1);                

   648 	                break;

   649 	                }

   650 	            case EEikStatusPaneUidSignal:

   651 	                {

   652 	                layout = aknLayout.signal_pane(parentRect);

   653 	                break;

   654 	                }

   655 	            case EEikStatusPaneUidBattery: 

   656 	                {

   657 	                layout = aknLayout.battery_pane(parentRect);

   658 	                break;

   659 	                }

   660 	            case EEikStatusPaneUidContext: 

   661 	                {

   662 	                // note, uses idle version of context pane but needs to 

   663 	                // have usual statuspane as parent to provide correct height.

   664 	                layout = aknLayout.context_pane(parentRect, 1);                

   665 	                break;

   666 	                }

   667 	            case EEikStatusPaneUidTitle: 

   668 	                {

   669 	                // LAF does not anymore define this. We calculate.

   670 	                RRegion titleRegion;                               

   671 	                layout = aknLayout.title_pane(1); // Idle titlepane

   672 

   673 	                TAknLayoutRect LayoutRect;

   674 	                LayoutRect.LayoutRect(parentRect, layout);

   675 	                paneRect = LayoutRect.Rect(); 

   676 	                                 

   677 	                layout = aknLayout.uni_indicator_pane(parentRect);                

   678 	                LayoutRect.LayoutRect(parentRect, layout);

   679 	                TRect indicatorRect( LayoutRect.Rect() );

   680 	                

   681 	                // Title and indicator overlaps, reduce indicator area.

   682 	                titleRegion.AddRect(paneRect);

   683 	                titleRegion.SubRect(indicatorRect);

   684 	                

   685 	                paneRect = titleRegion.BoundingRect();

   686 	                titleRegion.Close();

   687 	                break;

   688 	                }

   689 	            case EEikStatusPaneUidIndic:

   690 	                {

   691 	                layout = aknLayout.uni_indicator_pane(parentRect);                

   692 	                break;

   693 	                }

   694 	            }

   695 			break;

   696 	        }

   697 

   698 		case R_AVKON_STATUS_PANE_LAYOUT_USUAL_WITH_BATTERY_PANE:

   699 	        {

   700 	        parentRect = usualStatusPaneRect;

   701 	        switch(aPaneId.iUid)

   702 	            {

   703 	            case EEikStatusPaneUidNavi: 

   704 	                {

   705 	                layout = aknLayout.navi_pane(0);

   706 	                break;

   707 	                }

   708 	            case EEikStatusPaneUidSignal:

   709 	                {

   710 	                layout = aknLayout.signal_pane(parentRect);

   711 	                break;

   712 	                }

   713 	            case EEikStatusPaneUidContext:

   714 	                {

   715 	                layout = aknLayout.context_pane(parentRect, 0);

   716 	                break;

   717 	                }

   718 	            case EEikStatusPaneUidTitle:

   719 	                {

   720 	                layout = aknLayout.title_pane(0);

   721 	                break;

   722 	                }

   723 	            case EEikStatusPaneUidIndic:

   724 	                {

   725 	                layout = aknLayout.uni_indicator_pane(parentRect);

   726 	                break;

   727 	                }

   728 	            case EEikStatusPaneUidBattery:

   729 	                {

   730 	                layout = aknLayout.battery_pane(parentRect);

   731 	                break;

   732 	                }

   733 	            }

   734 	        break;

   735 	        }

   736 

   737 		case R_AVKON_STACON_PANE_LAYOUT_IDLE_SOFTKEYS_LEFT:

   738 		case R_AVKON_STACON_PANE_LAYOUT_IDLE_SOFTKEYS_RIGHT:

   739 	        {

   740 	        if ( Layout_Meta_Data::IsLandscapeOrientation() )

   741 	            { 

   742 	            

   743 		        // Final check for small digital clock, shown only in resolutions having aspect 

   744 		        // ratio equal or wider than qvga because otherwise there is no space for it.

   745 		        if (smallDigitalClockInStacon)

   746 		        	{

   747 		        	TReal aspectRatio = TReal(screenRect.Width()) / TReal(screenRect.Height());

   748 		        	if (aspectRatio < 1.33)

   749 		        		smallDigitalClockInStacon = EFalse;	        			

   750 		        	}

   751 	               

   752 	            TInt variety = 0;

   753 	            TInt clockVariety = 1;

   754 	            if (aLayoutId == R_AVKON_STACON_PANE_LAYOUT_IDLE_SOFTKEYS_LEFT)

   755 	                {

   756 	                variety = 1; // softkeys left

   757 	                clockVariety = 3;

   758 	                }

   759 

   760 				const TRect layout1Rect( iLayout->iStaconLayout1Rect );

   761 				const TRect layout2Rect( iLayout->iStaconLayout2Rect );

   762 

   763 	            switch(aPaneId.iUid)

   764 	                {

   765 	                case EEikStatusPaneUidNavi: 

   766 	                    {

   767 		                // If clock is shown, then use different variety for navipane                    

   768 	                    if (smallDigitalClockInStacon)

   769 	                    	variety +=2;	

   770 	                    

   771 	                    parentRect = layout2Rect;

   772 	                    layout = aknLayoutScalable_Avkon.navi_pane_stacon(variety).LayoutLine();

   773 	                    break;

   774 	                    }

   775 	                case EEikStatusPaneUidSignal:

   776 	                    {

   777 	                    parentRect = layout1Rect;

   778 	                    layout = aknLayoutScalable_Avkon.signal_pane_stacon(variety).LayoutLine();

   779 	                    break;

   780 	                    }

   781 	                case EEikStatusPaneUidTitle:

   782 	                    {

   783 	                    if (smallDigitalClockInStacon)

   784 	                    	{

   785 		                    parentRect = layout1Rect;

   786 	                    	TInt titleVariety = 4;

   787 				            if (aLayoutId == R_AVKON_STACON_PANE_LAYOUT_IDLE_SOFTKEYS_LEFT)

   788 				                {

   789 								titleVariety = 5;

   790 				                }

   791 			                layout = aknLayoutScalable_Avkon.title_pane_stacon(titleVariety).LayoutLine();                		                    	

   792 	                    	}

   793 	                    else

   794 	                    	{

   795 		                    // LAF does not provide yet variety for idle titlepane so we strecth the

   796 		                    // titlepane here to cover universal indicators too which is not used in this

   797 		                    // layout.

   798 		                    layout = aknLayoutScalable_Avkon.title_pane_stacon(variety).LayoutLine();

   799 		                    TAknLayoutRect LayoutRect;

   800 		                    LayoutRect.LayoutRect(parentRect, layout);

   801 		                    paneRect = LayoutRect.Rect(); 

   802 		                    

   803 		                    TRect tmpParentRect( layout1Rect );

   804 		                    TAknWindowLineLayout tmpLayout( aknLayoutScalable_Avkon.uni_indicator_pane_stacon(variety).LayoutLine() );

   805 		                    TAknLayoutRect tmpLayoutRect;

   806 		                    tmpLayoutRect.LayoutRect(tmpParentRect, tmpLayout);

   807 		                    TRect tmpRect( tmpLayoutRect.Rect() );

   808 

   809 		                    paneRect.BoundingRect(tmpRect);

   810 	                    	}

   811 	                    break;

   812 	                    }

   813 	                case EEikStatusPaneUidIndic:

   814 	                    {            

   815 	                    if (smallDigitalClockInStacon)

   816 	                    	{

   817 	                    	TInt indicatorVariety = 1;

   818 				            if (aLayoutId == R_AVKON_STACON_PANE_LAYOUT_IDLE_SOFTKEYS_LEFT)

   819 				                {

   820 								indicatorVariety = 5;

   821 				                }

   822 		                    parentRect = layout1Rect;

   823 		                    layout = aknLayoutScalable_Avkon.indicator_nsta_pane_cp2(indicatorVariety).LayoutLine();                		

   824 	                    	}

   825 	                    else

   826 	                    	{

   827 		                    // Exceptionally mainpane as parent

   828 		                    parentRect = mainPaneRect;

   829 		                    if (idleIndicatorsInLandscapeAreVertical)

   830 		                    	layout = aknLayoutScalable_Avkon.indicator_pane(3).LayoutLine(); // Vertical status indicators

   831 		                    else

   832 		                    	layout = aknLayoutScalable_Avkon.indicator_pane(1).LayoutLine(); // Horizontal status indicators, always in right side exept in A&H

   833 	                    	}

   834 	                    		

   835 	                    break;

   836 	                    }

   837 	                case EEikStatusPaneUidBattery:

   838 	                    {

   839 	                    parentRect = layout2Rect;

   840 	                    layout = aknLayoutScalable_Avkon.battery_pane_stacon(variety).LayoutLine();

   841 	                    break;

   842 	                    }	                    

   843 		            case EEikStatusPaneUidEmpty:

   844 		                {

   845 		                if (smallDigitalClockInStacon)

   846 		                	{

   847 			                parentRect = layout2Rect;

   848 		 	               	layout = aknLayoutScalable_Avkon.clock_nsta_pane_cp2(clockVariety).LayoutLine();                		

   849 		                	}

   850 		                break;

   851 		                }		                

   852 	                }

   853 	            }

   854 	        break;

   855 	        }

   856 

   857 		case R_AVKON_STATUS_PANE_LAYOUT_USUAL_FLAT:

   858 	        {

   859 	        TAknWindowComponentLayout parentLayout;

   860 			

   861 	        TBool landscapeOrientation(

   862 	            Layout_Meta_Data::IsLandscapeOrientation() );

   863 

   864 	        // Is bottom softkey touch landscape layout in use.

   865 	        TBool touchLsc( landscapeOrientation &&

   866 	                        Layout_Meta_Data::IsPenEnabled() );

   867 

   868 			if ( landscapeOrientation )

   869                 {

   870                 if ( touchLsc )

   871                     {

   872                     parentLayout = aknLayoutScalable_Avkon.area_top_pane( 2 );

   873                     }

   874                 else

   875                     {

   876                     parentLayout = aknLayoutScalable_Avkon.area_top_pane( 8 );

   877                     }

   878                 }

   879 	        else

   880 	        	{

   881 	        	parentLayout = aknLayoutScalable_Avkon.area_top_pane(6);

   882 	        	smallDigitalClockInLandscapeFlatSpUsual = EFalse;

   883 	        	}

   884 	                      

   885 	        TAknLayoutRect layoutRect;

   886 	        layoutRect.LayoutRect(screenRect, parentLayout.LayoutLine());

   887 	        parentRect = layoutRect.Rect();

   888 	        switch(aPaneId.iUid)

   889 	            {

   890 	            case EEikStatusPaneUidNavi: 

   891                     {

   892                     layout =

   893                         aknLayoutScalable_Avkon.navi_pane(

   894                             touchLsc ? 9 : 2 ).LayoutLine();

   895 

   896                     break;

   897                     }

   898 	            case EEikStatusPaneUidSignal:

   899 	                {

   900 	                layout = aknLayoutScalable_Avkon.signal_pane( touchLsc ? 14 : 2 ).LayoutLine();

   901 	                break;

   902 	                }

   903 	            case EEikStatusPaneUidTitle:

   904 	                {

   905                     if ( touchLsc )

   906                         {

   907                         layout = aknLayoutScalable_Avkon.title_pane( 11 ).LayoutLine();

   908                         }

   909                     else if ( landscapeOrientation &&

   910                               smallDigitalClockInLandscapeFlatSpUsual )

   911 	                    {                       

   912 		                // LAF does not provide yet variety for titlepane in this case so we strecth the

   913 		                // titlepane here to cover universal indicators too which is not used in this

   914 		                // layout.

   915 	                    layout = aknLayoutScalable_Avkon.title_pane(2).LayoutLine();

   916 	                    TAknLayoutRect LayoutRect;

   917 	                    LayoutRect.LayoutRect(parentRect, layout);

   918 	                    paneRect = LayoutRect.Rect(); 

   919 	                        

   920 	                    TAknWindowLineLayout tmpLayout( aknLayoutScalable_Avkon.uni_indicator_pane(1).LayoutLine() );

   921 	                    TAknLayoutRect tmpLayoutRect;

   922 	                    tmpLayoutRect.LayoutRect(parentRect, tmpLayout);

   923 	                    TRect tmpRect( tmpLayoutRect.Rect() );

   924 

   925 	                    paneRect.BoundingRect(tmpRect);

   926 	                    }

   927 					else

   928 						{

   929 		                layout = aknLayoutScalable_Avkon.title_pane(2).LayoutLine();                    						

   930 						}

   931 	                break;

   932 	                }

   933 	            case EEikStatusPaneUidIndic:

   934 	                {

   935 	                if ( landscapeOrientation &&

   936 	                     smallDigitalClockInLandscapeFlatSpUsual )

   937 	                    {

   938                     	// Indicators are located in control pane area.

   939 				        TAknWindowComponentLayout bottomArea(

   940 				            AknLayoutScalable_Avkon::area_bottom_pane( touchLsc ? 2 : 6 ) );

   941 				        TAknWindowComponentLayout controlPane(

   942 				            AknLayoutScalable_Avkon::control_pane() );

   943                     	TAknWindowComponentLayout nstaClockIndicPane(

   944                     	    AknLayoutScalable_Avkon::nsta_clock_indic_pane() );

   945                     	TAknWindowComponentLayout indicatorNstaPane(

   946                     	    AknLayoutScalable_Avkon::indicator_nsta_pane_cp() ); 

   947 			        	indicatorNstaPane =

   948                             DoCompose( bottomArea,

   949                                        DoCompose( controlPane,

   950                                                   DoCompose( nstaClockIndicPane,

   951                                                              indicatorNstaPane ) ) );

   952 	                    layout = indicatorNstaPane.LayoutLine();

   953 	                    parentRect = applicationWindowRect;

   954 	                    }

   955 	                else

   956 	                	{

   957 		                layout = aknLayoutScalable_Avkon.uni_indicator_pane(1).LayoutLine();                		

   958 	                	}    

   959 	                break;

   960 	                }

   961 	            case EEikStatusPaneUidBattery:

   962 	                {

   963 	                layout = aknLayoutScalable_Avkon.battery_pane( touchLsc ? 14 : 2 ).LayoutLine();

   964 	                break;

   965 	                }

   966 	            case EEikStatusPaneUidDigitalClock:

   967 	                {

   968 	                if (smallDigitalClockInLandscapeFlatSpUsual)

   969 	                	{

   970 				        TAknWindowComponentLayout bottomArea(

   971                             aknLayoutScalable_Avkon.area_bottom_pane( touchLsc ? 2 : 6 ) );

   972                         TAknWindowComponentLayout controlPane(

   973                             aknLayoutScalable_Avkon.control_pane() );

   974                         TAknWindowComponentLayout nstaClockIndicPane(

   975                             aknLayoutScalable_Avkon.nsta_clock_indic_pane() );

   976                         TAknWindowComponentLayout clockNstaPane(

   977                             aknLayoutScalable_Avkon.clock_nsta_pane_cp() ); 

   978                         clockNstaPane = DoCompose(

   979                             bottomArea,

   980                             DoCompose(

   981                                 controlPane,

   982                                 DoCompose(

   983                                     nstaClockIndicPane, clockNstaPane ) ) );

   984                         layout     = clockNstaPane.LayoutLine();

   985                         parentRect = applicationWindowRect;

   986 	                	}

   987 	                else

   988 	                	{

   989 	                	paneRect = TRect(0,0,0,1);	

   990 	                	}	

   991 	                break;

   992 	                }

   993 	            }

   994 	        break;

   995 	        }

   996 

   997 		case R_AVKON_STATUS_PANE_LAYOUT_IDLE_FLAT:

   998 	        {   

   999 	        TBool landscapeOrientation(

  1000                 Layout_Meta_Data::IsLandscapeOrientation() );

  1001 

  1002             // Is bottom softkey touch landscape layout in use.

  1003             TBool touchLsc( landscapeOrientation &&

  1004                             Layout_Meta_Data::IsPenEnabled() );

  1005 	                        

  1006 	        TAknWindowComponentLayout parentLayout;

  1007 

  1008             if ( landscapeOrientation )

  1009                 {

  1010                 if ( touchLsc )

  1011                     {

  1012                     parentLayout = aknLayoutScalable_Avkon.area_top_pane( 2 );

  1013                     }

  1014                 else

  1015                     {

  1016                     parentLayout = aknLayoutScalable_Avkon.area_top_pane( 8 );    

  1017                     }

  1018                 }

  1019 	        else

  1020 	        	{

  1021 	        	parentLayout = aknLayoutScalable_Avkon.area_top_pane( 6 );

  1022 	        	smallDigitalClockInLandscapeFlatSpIdle = EFalse;	        	

  1023 	        	}     

  1024 	            

  1025 	        TAknLayoutRect layoutRect;

  1026 	        layoutRect.LayoutRect( screenRect, parentLayout.LayoutLine() );

  1027 	        parentRect = layoutRect.Rect();

  1028 

  1029 	        switch ( aPaneId.iUid )

  1030 	            {

  1031 	            case EEikStatusPaneUidNavi: 

  1032 	                {

  1033                     layout =

  1034                         aknLayoutScalable_Avkon.navi_pane(

  1035                             touchLsc ? 9 : 2 ).LayoutLine();

  1036 	                break;

  1037 	                }

  1038 	            case EEikStatusPaneUidSignal:

  1039 	                {

  1040 	                layout = aknLayoutScalable_Avkon.signal_pane( touchLsc ? 14 : 2 ).LayoutLine();

  1041 	                break;

  1042 	                }

  1043 	            case EEikStatusPaneUidTitle:

  1044 	                {

  1045 	                // LAF does not provide yet variety for idle title pane so

  1046 	                // we strecth the title pane here to cover universal

  1047 	                // indicators too which is not used in this layout.

  1048 	                if ( touchLsc )

  1049                         {

  1050                         layout = aknLayoutScalable_Avkon.title_pane( 11 ).LayoutLine();

  1051                         }

  1052 	                else if ( landscapeOrientation )

  1053 	                    {                       

  1054 	                    layout = aknLayoutScalable_Avkon.title_pane( 2 ).LayoutLine();

  1055 	                    TAknLayoutRect LayoutRect;

  1056 	                    LayoutRect.LayoutRect( parentRect, layout );

  1057 	                    paneRect = LayoutRect.Rect(); 

  1058 	                        

  1059 	                    TAknWindowLineLayout tmpLayout(

  1060 	                        aknLayoutScalable_Avkon.uni_indicator_pane( 1 ).LayoutLine() );

  1061 	                    TAknLayoutRect tmpLayoutRect;

  1062 	                    tmpLayoutRect.LayoutRect( parentRect, tmpLayout );

  1063 	                    TRect tmpRect( tmpLayoutRect.Rect() );

  1064 

  1065 	                    paneRect.BoundingRect( tmpRect );

  1066 	                    }

  1067                     else

  1068                         {

  1069                         layout = aknLayoutScalable_Avkon.title_pane( 2 ).LayoutLine();

  1070                         }

  1071 	                break;

  1072 	                }

  1073 	            case EEikStatusPaneUidIndic:

  1074 	                {

  1075 	                // Exceptionally mainpane as parent.

  1076 	                // Note that this is main_pane for flat statuspane.

  1077 	                if ( Layout_Meta_Data::IsLandscapeOrientation() )

  1078 	                    {

  1079 	                    if ( smallDigitalClockInLandscapeFlatSpIdle )

  1080 	                    	{

  1081 	                    	// Indicators are located in control pane area.

  1082                             TAknWindowComponentLayout bottomArea(

  1083 	                            aknLayoutScalable_Avkon.area_bottom_pane( touchLsc ? 2 : 6 ) );

  1084 					        TAknWindowComponentLayout controlPane(

  1085 					            aknLayoutScalable_Avkon.control_pane() );

  1086 	                    	TAknWindowComponentLayout nstaClockIndicPane(

  1087 	                    	    aknLayoutScalable_Avkon.nsta_clock_indic_pane() );

  1088 	                    	TAknWindowComponentLayout indicatorNstaPane(

  1089 	                    	    aknLayoutScalable_Avkon.indicator_nsta_pane_cp() );

  1090 				        	indicatorNstaPane =

  1091 				        	    DoCompose( bottomArea,

  1092 				        	               DoCompose( controlPane,

  1093 				        	                          DoCompose( nstaClockIndicPane,

  1094 				        	                                     indicatorNstaPane ) ) );

  1095 		                    layout     = indicatorNstaPane.LayoutLine();

  1096 		                    parentRect = applicationWindowRect;

  1097 	                    	}

  1098 	                    else

  1099 	                    	{	                    			                                            

  1100 		                    // Exceptionally mainpane as parent

  1101 		                    parentRect = mainPaneRect;

  1102 							if ( idleIndicatorsInLandscapeAreVertical )

  1103 							    {

  1104 							    // Vertical status indicators

  1105 		                    	layout = aknLayoutScalable_Avkon.indicator_pane( 3 ).LayoutLine();

  1106 							    }

  1107 		                    else

  1108 		                        {

  1109 		                        // Horizontal status indicators

  1110 		                    	layout = aknLayoutScalable_Avkon.indicator_pane( 1 ).LayoutLine();

  1111 		                        }

  1112 	                    	}	

  1113 	                    }

  1114 	                else

  1115 	                    {

  1116 	                    layout = aknLayoutScalable_Avkon.uni_indicator_pane( 1 ).LayoutLine();

  1117 	                    }

  1118 

  1119 	                break;

  1120 	                }

  1121 	            case EEikStatusPaneUidDigitalClock:

  1122 	                {

  1123 	                if ( smallDigitalClockInLandscapeFlatSpIdle )

  1124 	                	{

  1125 				        TAknWindowComponentLayout bottomArea(

  1126 				            aknLayoutScalable_Avkon.area_bottom_pane( touchLsc ? 2 : 6 ) );

  1127 				        TAknWindowComponentLayout controlPane(

  1128 				            aknLayoutScalable_Avkon.control_pane() );

  1129                     	TAknWindowComponentLayout nstaClockIndicPane(

  1130                     	    aknLayoutScalable_Avkon.nsta_clock_indic_pane() );

  1131                     	TAknWindowComponentLayout clockNstaPane(

  1132                     	    aknLayoutScalable_Avkon.clock_nsta_pane_cp() ); 

  1133 			        	clockNstaPane = DoCompose(

  1134 			        	    bottomArea,