diff -r 000000000000 -r 2f259fa3e83a uifw/EikStd/coctlsrc/eikspmod.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/uifw/EikStd/coctlsrc/eikspmod.cpp Tue Feb 02 01:00:49 2010 +0200 @@ -0,0 +1,1904 @@ +/* +* Copyright (c) 2002-2008 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: EIKON Status Pane model and layouts. +* +*/ + + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include "layoutmetadata.cdl.h" + +inline TAknWindowComponentLayout DoCompose(TAknWindowComponentLayout aLine1, TAknWindowComponentLayout aLine2) + { + return TAknWindowComponentLayout::Compose(aLine1, aLine2); + } + +inline TAknTextComponentLayout DoComposeText(TAknWindowComponentLayout aLine1, TAknTextComponentLayout aLine2) + { + return TAknWindowComponentLayout::ComposeText(aLine1, aLine2); + } + +const TInt KStatusPaneSetInitGranularity = 4; +const TInt KEikSpanePositionMask = 3; + + +inline TBool TEikStatusPaneInit::Initialized() { return iFlags & KEikStatusPaneInitInitializedBit; } +inline void TEikStatusPaneInit::SetInitialized() { iFlags |= KEikStatusPaneInitInitializedBit; } + +inline CEikStatusPaneLayoutTree::TDirection CEikStatusPaneLayoutTree::Direction() { return (iFlags & KEikStatusPaneDirectionBit) ? EVertical : EHorizontal; } +inline TInt CEikStatusPaneLayoutTree::Size() { return iSize; } +inline TBool CEikStatusPaneLayoutTree::Stretchable() { return iFlags & EEikStatusPaneIsStretchable; } + + +TEikStatusPaneInit::TEikStatusPaneInit() +: iControlId(0), iControlResource(0), iFlags(0) + { + } + +TEikStatusPaneInit::TEikStatusPaneInit(const TEikStatusPaneInit& aCopy) + { + *this = aCopy; + } + +TEikStatusPaneInit& TEikStatusPaneInit::operator=(const TEikStatusPaneInit& aCopy) + { + // Don't copy id or flags - these will have been set when this structure was first loaded + if (aCopy.iControlId) + { + iControlId = aCopy.iControlId; + iControlResource = aCopy.iControlResource; + } + + return *this; + } + +void TEikStatusPaneInit::LoadDefaults(TResourceReader& aResource) + { + iId = TUid::Uid(aResource.ReadInt32()); + iFlags = aResource.ReadUint16(); + iControlId = aResource.ReadUint16(); + iControlResource = aResource.ReadUint32(); + } + + + +CEikStatusPaneSetInit* CEikStatusPaneSetInit::NewL() + { + CEikStatusPaneSetInit* self = new(ELeave) CEikStatusPaneSetInit(); + return self; + } + +CEikStatusPaneSetInit::~CEikStatusPaneSetInit() + { + } + +void CEikStatusPaneSetInit::LoadDefaultsL(TResourceReader& aResource) + { + const TBool initialized = (Count() != 0); + const TInt count=aResource.ReadInt16(); + + for (TInt ii=0;ii(KStatusPaneSetInitGranularity) + { + } + +TEikStatusPaneInit& CEikStatusPaneSetInit::FindL(const TPaneId& aPaneId) + { + for (TInt i=0; iResetAndDestroy(); + delete iSubPanes; + } + +CEikStatusPaneLayoutTree* CEikStatusPaneLayoutTree::NewL(CEikStatusPaneLayout* aLayout, TResourceReader& aResource, TDirection aDefaultDirection) + { + CEikStatusPaneLayoutTree* self = new(ELeave) CEikStatusPaneLayoutTree(aLayout, aDefaultDirection); + CleanupStack::PushL(self); + self->ConstructL(aResource); + CleanupStack::Pop(); + return self; + } + +CEikStatusPaneLayoutTree* CEikStatusPaneLayoutTree::Find(const TPaneId& aPaneId) + { + if (iId == aPaneId) + return this; + else if (iSubPanes) + { + for (TInt i=0; iCount(); i++) + { + CEikStatusPaneLayoutTree* pane = iSubPanes->At(i)->Find(aPaneId); + if (pane) + return pane; + } + } + + return NULL; + } + +CEikStatusPaneLayoutTree::CEikStatusPaneLayoutTree(CEikStatusPaneLayout* aLayout, TDirection aDefaultDirection) +: iLayout(aLayout) + { + SetDirection(aDefaultDirection); + } + +void CEikStatusPaneLayoutTree::ConstructL(TResourceReader& aResource) + { + iId.iUid = aResource.ReadInt32(); + + TDirection dir = Direction(); + iFlags = aResource.ReadUint16(); + SetDirection(dir); + + iSize = aResource.ReadUint16(); + + TDirection subDir = Direction() == EVertical ? EHorizontal : EVertical; // Change direction for sub panes + + const TInt count=aResource.ReadInt16(); + if (count > 0) + { + iSubPanes = new(ELeave) CSubPaneArray(count); + for (TInt ii=0;iiAppendL(pane); + CleanupStack::Pop(); // pane + } + } + } + +void CEikStatusPaneLayoutTree::Layout() + { + if (!iSubPanes) + return; + + TInt unallocedSize = Direction()==EHorizontal ? iRect.Width() : iRect.Height(); + TInt stretchSize = 0; + + TInt count = iSubPanes->Count(); + TInt i; + for (i=0; iAt(i); + + TInt size = subPane->Size(); + + if (subPane->Stretchable()) + stretchSize += size; + else + unallocedSize -= size; + } + + TPoint pos( iRect.iTl ); + + for (i=0; iAt(i); + + TInt size( subPane->Size() ); + + if (size > 0 && subPane->Stretchable() && stretchSize != 0) + { + TInt oldSize = size; + size = (size * unallocedSize) / stretchSize; + unallocedSize -= size; + stretchSize -= oldSize; + } + + TSize subSize( iRect.Size() ); + if (Direction()==EHorizontal) + subSize.iWidth = size; + else + subSize.iHeight = size; + subPane->SetRect(TRect(pos,subSize)); + + if (Direction()==EHorizontal) + pos.iX += size; + else + pos.iY += size; + } + } + +void CEikStatusPaneLayoutTree::SetDirection(TDirection aDirection) + { + if (aDirection == EVertical) + iFlags |= KEikStatusPaneDirectionBit; + else + iFlags &= ~KEikStatusPaneDirectionBit; + } + +void CEikStatusPaneLayoutTree::SetStretchable(TBool aStretchable) + { + if (aStretchable) + iFlags |= EEikStatusPaneIsStretchable; + else + iFlags &= ~EEikStatusPaneIsStretchable; + } + +void CEikStatusPaneLayoutTree::SetRect(const TRect& aRect) + { + iRect = aRect; + Layout(); + } + +void CEikStatusPaneLayoutTree::AcceptL(MEikStatusPaneLayoutTreeVisitor* aVisitor) + { + if (iId.iUid != 0) + aVisitor->VisitL(this); + + if (iSubPanes) + { + for (TInt i=0; iCount(); i++) + { + iSubPanes->At(i)->AcceptL(aVisitor); + } + } + } + +void CEikStatusPaneLayoutTree::SetAknLayoutUsed(TBool aAknLayoutUsed) + { + if (aAknLayoutUsed) + { + iFlags |= EEikStatusPaneLayoutAknLafDefined; + } + else + { + iFlags &= ~EEikStatusPaneLayoutAknLafDefined; + } + } + +TBool CEikStatusPaneLayoutTree::AknLayoutUsed() + { + if ( iFlags & EEikStatusPaneLayoutAknLafDefined ) + { + return ETrue; + } + else + { + return EFalse; + } + } + + +void CEikStatusPaneLayoutTree::Layout(TInt aLayoutId) + { + if (!AknLayoutUsed()) + { + Layout(); + } + else + { + TRect rectFromAknLayout( AknLayoutRect(aLayoutId, iId) ); + if (rectFromAknLayout.Size() != TSize(0,0)) + { + iRect = rectFromAknLayout; + } + + if (!iSubPanes) + return; + + TInt count = iSubPanes->Count(); + TInt i; + for (i=0; iAt(i); + subPane->SetAknLayoutUsed(ETrue); + subPane->Layout(aLayoutId); + } + } + } + +TRect CEikStatusPaneLayoutTree::AknLayoutRect(TInt aLayoutId, TPaneId aPaneId) + { + const TBool idleIndicatorsInLandscapeAreVertical = EFalse; + + // Note that small digital clock cannot be shown in such displays that have smaller aspect ratio than 4:3. +#ifndef __SERIES60_31__ + TBool smallDigitalClockInStacon = ETrue; + TBool smallDigitalClockInLandscapeFlatSpUsual = ETrue; + TBool smallDigitalClockInLandscapeFlatSpIdle = ETrue; +#else + TBool smallDigitalClockInStacon = EFalse; + TBool smallDigitalClockInLandscapeFlatSpUsual = EFalse; + TBool smallDigitalClockInLandscapeFlatSpIdle = EFalse; +#endif + + TRect paneRect; // initialises to (0,0,0,0); + TRect parentRect; // initialises to (0,0,0,0); + TAknWindowLineLayout layout; + Mem::FillZ(&layout, sizeof(layout)); + + const TRect& screenRect = iLayout->iScreenRect; + const TRect& mainPaneRect = iLayout->iMainPaneRect; + const TRect& usualStatusPaneRect = iLayout->iUsualStatusPaneRect; + const TRect& applicationWindowRect = iLayout->iApplicationWindowRect; + + const AknLayout::CInstance& aknLayout = iLayout->iAknLayout; + const AknLayoutScalable_Avkon::CInstance& aknLayoutScalable_Avkon = iLayout->iAknLayoutScalable_Avkon; + + switch (aLayoutId) + { + case R_AVKON_STATUS_PANE_LAYOUT_USUAL: + case R_AVKON_STATUS_PANE_LAYOUT_USUAL_MIRRORED: + { + parentRect = usualStatusPaneRect; + switch(aPaneId.iUid) + { + case EEikStatusPaneUidNavi: + { + layout = aknLayoutScalable_Avkon.navi_pane(0).LayoutLine(); + break; + } + case EEikStatusPaneUidSignal: + { + layout = aknLayoutScalable_Avkon.signal_pane(0).LayoutLine(); + break; + } + case EEikStatusPaneUidContext: + { + layout = aknLayoutScalable_Avkon.context_pane(0).LayoutLine(); + break; + } + case EEikStatusPaneUidTitle: + { + layout = aknLayoutScalable_Avkon.title_pane(0).LayoutLine(); + break; + } + case EEikStatusPaneUidIndic: + { + layout = aknLayoutScalable_Avkon.uni_indicator_pane(0).LayoutLine(); + break; + } + case EEikStatusPaneUidBattery: + { + layout = aknLayoutScalable_Avkon.battery_pane(0).LayoutLine(); + break; + } + } + break; + } + + case R_AVKON_STACON_PANE_LAYOUT_USUAL_SOFTKEYS_LEFT: + case R_AVKON_STACON_PANE_LAYOUT_USUAL_SOFTKEYS_RIGHT: + { + // Final check for small digital clock, shown only in resolutions having aspect + // ratio equal or wider than qvga because otherwise there is no space for it. + if (smallDigitalClockInStacon) + { + TReal aspectRatio = TReal(screenRect.Width()) / TReal(screenRect.Height()); + if (aspectRatio < 1.33) + smallDigitalClockInStacon = EFalse; + } + + + TInt variety = 0; + TInt clockVariety = 1; + if (aLayoutId == R_AVKON_STACON_PANE_LAYOUT_USUAL_SOFTKEYS_LEFT) + { + // softkeys left + variety = 1; + clockVariety = 3; + } + + const TRect layout1Rect( iLayout->iStaconLayout1Rect ); + const TRect layout2Rect( iLayout->iStaconLayout2Rect ); + + switch(aPaneId.iUid) + { + case EEikStatusPaneUidNavi: + { + // If clock is shown, then use different variety for navipane + if (smallDigitalClockInStacon) + variety +=2; + + parentRect = layout2Rect; + layout = aknLayoutScalable_Avkon.navi_pane_stacon(variety).LayoutLine(); + break; + } + case EEikStatusPaneUidSignal: + { + parentRect = layout1Rect; + layout = aknLayoutScalable_Avkon.signal_pane_stacon(variety).LayoutLine(); + break; + } + case EEikStatusPaneUidTitle: + { + parentRect = layout1Rect; + if (smallDigitalClockInStacon) + { + TInt titleVariety = 4; + if (aLayoutId == R_AVKON_STACON_PANE_LAYOUT_USUAL_SOFTKEYS_LEFT) + { + titleVariety = 5; + } + layout = aknLayoutScalable_Avkon.title_pane_stacon(titleVariety).LayoutLine(); + } + else + { + layout = aknLayoutScalable_Avkon.title_pane_stacon(variety).LayoutLine(); + } + break; + } + case EEikStatusPaneUidIndic: + { + if (smallDigitalClockInStacon) + { + TInt indicatorVariety = 1; + if (aLayoutId == R_AVKON_STACON_PANE_LAYOUT_USUAL_SOFTKEYS_LEFT) + { + indicatorVariety = 5; + } + parentRect = layout1Rect; + layout = aknLayoutScalable_Avkon.indicator_nsta_pane_cp2(indicatorVariety).LayoutLine(); + } + else + { + parentRect = layout1Rect; + layout = aknLayoutScalable_Avkon.uni_indicator_pane_stacon(variety).LayoutLine(); + } + break; + } + case EEikStatusPaneUidBattery: + { + parentRect = layout2Rect; + layout = aknLayoutScalable_Avkon.battery_pane_stacon(variety).LayoutLine(); + break; + } + case EEikStatusPaneUidDigitalClock: + { + if (smallDigitalClockInStacon) + { + parentRect = layout2Rect; + layout = aknLayoutScalable_Avkon.clock_nsta_pane_cp2(clockVariety).LayoutLine(); + } + break; + } + } + break; + } + + case R_AVKON_STATUS_PANE_LAYOUT_SMALL: + { + switch(aPaneId.iUid) + { + // In this layout navi pane gets the whole small status pane area. + case EEikStatusPaneUidNavi: + { + paneRect = iLayout->iSmallStatusPaneRect; + break; + } + } + break; + } + + case R_AVKON_STATUS_PANE_LAYOUT_SMALL_WITH_SIGNAL_PANE: + case R_AVKON_STATUS_PANE_LAYOUT_SMALL_WITH_SIGNAL_PANE_MIRRORED: + { + parentRect = iLayout->iSmallStatusPaneRect; + switch(aPaneId.iUid) + { + case EEikStatusPaneUidNavi: + { + // avkon LAF doesn't provide this directly, some calculations are needed. + paneRect = parentRect; + TAknWindowLineLayout smallStatusSignalLayout( + AknLayoutScalable_Avkon::status_small_pane_g2(0).LayoutLine() ); + TAknLayoutRect smallStatusSignalLayoutRect; + smallStatusSignalLayoutRect.LayoutRect(parentRect, smallStatusSignalLayout); + TRect smallStatusSignalRect( smallStatusSignalLayoutRect.Rect() ); + + if (AknLayoutUtils::LayoutMirrored()) + { + paneRect.iBr.iX -= smallStatusSignalRect.Width(); + } + else + { + paneRect.iTl.iX += smallStatusSignalRect.Width(); + } + + break; + } + case EEikStatusPaneUidSignal: + { + layout = AknLayoutScalable_Avkon::status_small_pane_g2(0).LayoutLine(); + // Adjustment needed for BSK LSC for navi pane and signal pane to be the same height + layout.iH = parentRect.Height(); + break; + } + } + break; + } + + case R_AVKON_STATUS_PANE_LAYOUT_IDLE: + case R_AVKON_STATUS_PANE_LAYOUT_IDLE_MIRRORED: + { + // by default "idle" statuspane values have "usual" statuspane as parent in LAF + parentRect = usualStatusPaneRect; + switch(aPaneId.iUid) + { + case EEikStatusPaneUidNavi: + { + layout = aknLayout.navi_pane(1); + break; + } + case EEikStatusPaneUidSignal: + { + layout = aknLayout.signal_pane(parentRect); + break; + } + + case EEikStatusPaneUidBattery: + { + layout = aknLayout.battery_pane(parentRect); + break; + } + case EEikStatusPaneUidTitle: + { + layout = aknLayout.title_pane(1); + break; + } + case EEikStatusPaneUidIndic: + { + // Exceptionally mainpane as parent + parentRect = mainPaneRect; + layout = aknLayout.indicator_pane(); + break; + } + case EEikStatusPaneUidClock: + { + // Exceptionally idle statuspane as parent + TAknWindowLineLayout idleStatusPaneLayout( aknLayout.status_pane(applicationWindowRect, 1) ); + TAknLayoutRect idleStatusPaneLayoutRect; + idleStatusPaneLayoutRect.LayoutRect(applicationWindowRect, idleStatusPaneLayout); + parentRect = idleStatusPaneLayoutRect.Rect(); + layout = aknLayout.context_pane(parentRect, 1); + break; + } + } + break; + } + + case R_AVKON_STATUS_PANE_LAYOUT_POWER_OFF_RECHARGE: + case R_AVKON_STATUS_PANE_LAYOUT_POWER_OFF_RECHARGE_MIRRORED: + { + switch(aPaneId.iUid) + { + case EEikStatusPaneUidBattery: + { + if (Layout_Meta_Data::IsLandscapeOrientation()) + { + TAknLayoutRect layoutRect; + TAknWindowComponentLayout parentLayout = aknLayoutScalable_Avkon.area_top_pane(8); + layoutRect.LayoutRect(screenRect, parentLayout.LayoutLine()); + parentRect = layoutRect.Rect(); + layout = aknLayoutScalable_Avkon.battery_pane(2).LayoutLine(); + } + else + { + parentRect = usualStatusPaneRect; + layout = aknLayout.battery_pane(parentRect); + } + break; + } + } + break; + } + + case R_AVKON_STATUS_PANE_LAYOUT_VT: + case R_AVKON_STATUS_PANE_LAYOUT_VT_MIRRORED: + { + parentRect = usualStatusPaneRect; + switch(aPaneId.iUid) + { + case EEikStatusPaneUidNavi: + { + layout = aknLayout.navi_pane(1); + break; + } + case EEikStatusPaneUidSignal: + { + layout = aknLayout.signal_pane(parentRect); + break; + } + case EEikStatusPaneUidBattery: + { + layout = aknLayout.battery_pane(parentRect); + break; + } + case EEikStatusPaneUidContext: + { + // note, uses idle version of context pane but needs to + // have usual statuspane as parent to provide correct height. + layout = aknLayout.context_pane(parentRect, 1); + break; + } + case EEikStatusPaneUidTitle: + { + // LAF does not anymore define this. We calculate. + RRegion titleRegion; + layout = aknLayout.title_pane(1); // Idle titlepane + + TAknLayoutRect LayoutRect; + LayoutRect.LayoutRect(parentRect, layout); + paneRect = LayoutRect.Rect(); + + layout = aknLayout.uni_indicator_pane(parentRect); + LayoutRect.LayoutRect(parentRect, layout); + TRect indicatorRect( LayoutRect.Rect() ); + + // Title and indicator overlaps, reduce indicator area. + titleRegion.AddRect(paneRect); + titleRegion.SubRect(indicatorRect); + + paneRect = titleRegion.BoundingRect(); + titleRegion.Close(); + break; + } + case EEikStatusPaneUidIndic: + { + layout = aknLayout.uni_indicator_pane(parentRect); + break; + } + } + break; + } + + case R_AVKON_STATUS_PANE_LAYOUT_USUAL_WITH_BATTERY_PANE: + { + parentRect = usualStatusPaneRect; + switch(aPaneId.iUid) + { + case EEikStatusPaneUidNavi: + { + layout = aknLayout.navi_pane(0); + break; + } + case EEikStatusPaneUidSignal: + { + layout = aknLayout.signal_pane(parentRect); + break; + } + case EEikStatusPaneUidContext: + { + layout = aknLayout.context_pane(parentRect, 0); + break; + } + case EEikStatusPaneUidTitle: + { + layout = aknLayout.title_pane(0); + break; + } + case EEikStatusPaneUidIndic: + { + layout = aknLayout.uni_indicator_pane(parentRect); + break; + } + case EEikStatusPaneUidBattery: + { + layout = aknLayout.battery_pane(parentRect); + break; + } + } + break; + } + + case R_AVKON_STACON_PANE_LAYOUT_IDLE_SOFTKEYS_LEFT: + case R_AVKON_STACON_PANE_LAYOUT_IDLE_SOFTKEYS_RIGHT: + { + if ( Layout_Meta_Data::IsLandscapeOrientation() ) + { + + // Final check for small digital clock, shown only in resolutions having aspect + // ratio equal or wider than qvga because otherwise there is no space for it. + if (smallDigitalClockInStacon) + { + TReal aspectRatio = TReal(screenRect.Width()) / TReal(screenRect.Height()); + if (aspectRatio < 1.33) + smallDigitalClockInStacon = EFalse; + } + + TInt variety = 0; + TInt clockVariety = 1; + if (aLayoutId == R_AVKON_STACON_PANE_LAYOUT_IDLE_SOFTKEYS_LEFT) + { + variety = 1; // softkeys left + clockVariety = 3; + } + + const TRect layout1Rect( iLayout->iStaconLayout1Rect ); + const TRect layout2Rect( iLayout->iStaconLayout2Rect ); + + switch(aPaneId.iUid) + { + case EEikStatusPaneUidNavi: + { + // If clock is shown, then use different variety for navipane + if (smallDigitalClockInStacon) + variety +=2; + + parentRect = layout2Rect; + layout = aknLayoutScalable_Avkon.navi_pane_stacon(variety).LayoutLine(); + break; + } + case EEikStatusPaneUidSignal: + { + parentRect = layout1Rect; + layout = aknLayoutScalable_Avkon.signal_pane_stacon(variety).LayoutLine(); + break; + } + case EEikStatusPaneUidTitle: + { + if (smallDigitalClockInStacon) + { + parentRect = layout1Rect; + TInt titleVariety = 4; + if (aLayoutId == R_AVKON_STACON_PANE_LAYOUT_IDLE_SOFTKEYS_LEFT) + { + titleVariety = 5; + } + layout = aknLayoutScalable_Avkon.title_pane_stacon(titleVariety).LayoutLine(); + } + else + { + // LAF does not provide yet variety for idle titlepane so we strecth the + // titlepane here to cover universal indicators too which is not used in this + // layout. + layout = aknLayoutScalable_Avkon.title_pane_stacon(variety).LayoutLine(); + TAknLayoutRect LayoutRect; + LayoutRect.LayoutRect(parentRect, layout); + paneRect = LayoutRect.Rect(); + + TRect tmpParentRect( layout1Rect ); + TAknWindowLineLayout tmpLayout( aknLayoutScalable_Avkon.uni_indicator_pane_stacon(variety).LayoutLine() ); + TAknLayoutRect tmpLayoutRect; + tmpLayoutRect.LayoutRect(tmpParentRect, tmpLayout); + TRect tmpRect( tmpLayoutRect.Rect() ); + + paneRect.BoundingRect(tmpRect); + } + break; + } + case EEikStatusPaneUidIndic: + { + if (smallDigitalClockInStacon) + { + TInt indicatorVariety = 1; + if (aLayoutId == R_AVKON_STACON_PANE_LAYOUT_IDLE_SOFTKEYS_LEFT) + { + indicatorVariety = 5; + } + parentRect = layout1Rect; + layout = aknLayoutScalable_Avkon.indicator_nsta_pane_cp2(indicatorVariety).LayoutLine(); + } + else + { + // Exceptionally mainpane as parent + parentRect = mainPaneRect; + if (idleIndicatorsInLandscapeAreVertical) + layout = aknLayoutScalable_Avkon.indicator_pane(3).LayoutLine(); // Vertical status indicators + else + layout = aknLayoutScalable_Avkon.indicator_pane(1).LayoutLine(); // Horizontal status indicators, always in right side exept in A&H + } + + break; + } + case EEikStatusPaneUidBattery: + { + parentRect = layout2Rect; + layout = aknLayoutScalable_Avkon.battery_pane_stacon(variety).LayoutLine(); + break; + } + case EEikStatusPaneUidEmpty: + { + if (smallDigitalClockInStacon) + { + parentRect = layout2Rect; + layout = aknLayoutScalable_Avkon.clock_nsta_pane_cp2(clockVariety).LayoutLine(); + } + break; + } + } + } + break; + } + + case R_AVKON_STATUS_PANE_LAYOUT_USUAL_FLAT: + { + TAknWindowComponentLayout parentLayout; + + TBool landscapeOrientation( + Layout_Meta_Data::IsLandscapeOrientation() ); + + // Is bottom softkey touch landscape layout in use. + TBool touchLsc( landscapeOrientation && + Layout_Meta_Data::IsPenEnabled() ); + + if ( landscapeOrientation ) + { + if ( touchLsc ) + { + parentLayout = aknLayoutScalable_Avkon.area_top_pane( 2 ); + } + else + { + parentLayout = aknLayoutScalable_Avkon.area_top_pane( 8 ); + } + } + else + { + parentLayout = aknLayoutScalable_Avkon.area_top_pane(6); + smallDigitalClockInLandscapeFlatSpUsual = EFalse; + } + + TAknLayoutRect layoutRect; + layoutRect.LayoutRect(screenRect, parentLayout.LayoutLine()); + parentRect = layoutRect.Rect(); + switch(aPaneId.iUid) + { + case EEikStatusPaneUidNavi: + { + layout = + aknLayoutScalable_Avkon.navi_pane( + touchLsc ? 9 : 2 ).LayoutLine(); + + break; + } + case EEikStatusPaneUidSignal: + { + layout = aknLayoutScalable_Avkon.signal_pane( touchLsc ? 14 : 2 ).LayoutLine(); + break; + } + case EEikStatusPaneUidTitle: + { + if ( touchLsc ) + { + layout = aknLayoutScalable_Avkon.title_pane( 11 ).LayoutLine(); + } + else if ( landscapeOrientation && + smallDigitalClockInLandscapeFlatSpUsual ) + { + // LAF does not provide yet variety for titlepane in this case so we strecth the + // titlepane here to cover universal indicators too which is not used in this + // layout. + layout = aknLayoutScalable_Avkon.title_pane(2).LayoutLine(); + TAknLayoutRect LayoutRect; + LayoutRect.LayoutRect(parentRect, layout); + paneRect = LayoutRect.Rect(); + + TAknWindowLineLayout tmpLayout( aknLayoutScalable_Avkon.uni_indicator_pane(1).LayoutLine() ); + TAknLayoutRect tmpLayoutRect; + tmpLayoutRect.LayoutRect(parentRect, tmpLayout); + TRect tmpRect( tmpLayoutRect.Rect() ); + + paneRect.BoundingRect(tmpRect); + } + else + { + layout = aknLayoutScalable_Avkon.title_pane(2).LayoutLine(); + } + break; + } + case EEikStatusPaneUidIndic: + { + if ( landscapeOrientation && + smallDigitalClockInLandscapeFlatSpUsual ) + { + // Indicators are located in control pane area. + TAknWindowComponentLayout bottomArea( + AknLayoutScalable_Avkon::area_bottom_pane( touchLsc ? 2 : 6 ) ); + TAknWindowComponentLayout controlPane( + AknLayoutScalable_Avkon::control_pane() ); + TAknWindowComponentLayout nstaClockIndicPane( + AknLayoutScalable_Avkon::nsta_clock_indic_pane() ); + TAknWindowComponentLayout indicatorNstaPane( + AknLayoutScalable_Avkon::indicator_nsta_pane_cp() ); + indicatorNstaPane = + DoCompose( bottomArea, + DoCompose( controlPane, + DoCompose( nstaClockIndicPane, + indicatorNstaPane ) ) ); + layout = indicatorNstaPane.LayoutLine(); + parentRect = applicationWindowRect; + } + else + { + layout = aknLayoutScalable_Avkon.uni_indicator_pane(1).LayoutLine(); + } + break; + } + case EEikStatusPaneUidBattery: + { + layout = aknLayoutScalable_Avkon.battery_pane( touchLsc ? 14 : 2 ).LayoutLine(); + break; + } + case EEikStatusPaneUidDigitalClock: + { + if (smallDigitalClockInLandscapeFlatSpUsual) + { + TAknWindowComponentLayout bottomArea( + aknLayoutScalable_Avkon.area_bottom_pane( touchLsc ? 2 : 6 ) ); + TAknWindowComponentLayout controlPane( + aknLayoutScalable_Avkon.control_pane() ); + TAknWindowComponentLayout nstaClockIndicPane( + aknLayoutScalable_Avkon.nsta_clock_indic_pane() ); + TAknWindowComponentLayout clockNstaPane( + aknLayoutScalable_Avkon.clock_nsta_pane_cp() ); + clockNstaPane = DoCompose( + bottomArea, + DoCompose( + controlPane, + DoCompose( + nstaClockIndicPane, clockNstaPane ) ) ); + layout = clockNstaPane.LayoutLine(); + parentRect = applicationWindowRect; + } + else + { + paneRect = TRect(0,0,0,1); + } + break; + } + } + break; + } + + case R_AVKON_STATUS_PANE_LAYOUT_IDLE_FLAT: + { + TBool landscapeOrientation( + Layout_Meta_Data::IsLandscapeOrientation() ); + + // Is bottom softkey touch landscape layout in use. + TBool touchLsc( landscapeOrientation && + Layout_Meta_Data::IsPenEnabled() ); + + TAknWindowComponentLayout parentLayout; + + if ( landscapeOrientation ) + { + if ( touchLsc ) + { + parentLayout = aknLayoutScalable_Avkon.area_top_pane( 2 ); + } + else + { + parentLayout = aknLayoutScalable_Avkon.area_top_pane( 8 ); + } + } + else + { + parentLayout = aknLayoutScalable_Avkon.area_top_pane( 6 ); + smallDigitalClockInLandscapeFlatSpIdle = EFalse; + } + + TAknLayoutRect layoutRect; + layoutRect.LayoutRect( screenRect, parentLayout.LayoutLine() ); + parentRect = layoutRect.Rect(); + + switch ( aPaneId.iUid ) + { + case EEikStatusPaneUidNavi: + { + layout = + aknLayoutScalable_Avkon.navi_pane( + touchLsc ? 9 : 2 ).LayoutLine(); + break; + } + case EEikStatusPaneUidSignal: + { + layout = aknLayoutScalable_Avkon.signal_pane( touchLsc ? 14 : 2 ).LayoutLine(); + break; + } + case EEikStatusPaneUidTitle: + { + // LAF does not provide yet variety for idle title pane so + // we strecth the title pane here to cover universal + // indicators too which is not used in this layout. + if ( touchLsc ) + { + layout = aknLayoutScalable_Avkon.title_pane( 11 ).LayoutLine(); + } + else if ( landscapeOrientation ) + { + layout = aknLayoutScalable_Avkon.title_pane( 2 ).LayoutLine(); + TAknLayoutRect LayoutRect; + LayoutRect.LayoutRect( parentRect, layout ); + paneRect = LayoutRect.Rect(); + + TAknWindowLineLayout tmpLayout( + aknLayoutScalable_Avkon.uni_indicator_pane( 1 ).LayoutLine() ); + TAknLayoutRect tmpLayoutRect; + tmpLayoutRect.LayoutRect( parentRect, tmpLayout ); + TRect tmpRect( tmpLayoutRect.Rect() ); + + paneRect.BoundingRect( tmpRect ); + } + else + { + layout = aknLayoutScalable_Avkon.title_pane( 2 ).LayoutLine(); + } + break; + } + case EEikStatusPaneUidIndic: + { + // Exceptionally mainpane as parent. + // Note that this is main_pane for flat statuspane. + if ( Layout_Meta_Data::IsLandscapeOrientation() ) + { + if ( smallDigitalClockInLandscapeFlatSpIdle ) + { + // Indicators are located in control pane area. + TAknWindowComponentLayout bottomArea( + aknLayoutScalable_Avkon.area_bottom_pane( touchLsc ? 2 : 6 ) ); + TAknWindowComponentLayout controlPane( + aknLayoutScalable_Avkon.control_pane() ); + TAknWindowComponentLayout nstaClockIndicPane( + aknLayoutScalable_Avkon.nsta_clock_indic_pane() ); + TAknWindowComponentLayout indicatorNstaPane( + aknLayoutScalable_Avkon.indicator_nsta_pane_cp() ); + indicatorNstaPane = + DoCompose( bottomArea, + DoCompose( controlPane, + DoCompose( nstaClockIndicPane, + indicatorNstaPane ) ) ); + layout = indicatorNstaPane.LayoutLine(); + parentRect = applicationWindowRect; + } + else + { + // Exceptionally mainpane as parent + parentRect = mainPaneRect; + if ( idleIndicatorsInLandscapeAreVertical ) + { + // Vertical status indicators + layout = aknLayoutScalable_Avkon.indicator_pane( 3 ).LayoutLine(); + } + else + { + // Horizontal status indicators + layout = aknLayoutScalable_Avkon.indicator_pane( 1 ).LayoutLine(); + } + } + } + else + { + layout = aknLayoutScalable_Avkon.uni_indicator_pane( 1 ).LayoutLine(); + } + + break; + } + case EEikStatusPaneUidDigitalClock: + { + if ( smallDigitalClockInLandscapeFlatSpIdle ) + { + TAknWindowComponentLayout bottomArea( + aknLayoutScalable_Avkon.area_bottom_pane( touchLsc ? 2 : 6 ) ); + TAknWindowComponentLayout controlPane( + aknLayoutScalable_Avkon.control_pane() ); + TAknWindowComponentLayout nstaClockIndicPane( + aknLayoutScalable_Avkon.nsta_clock_indic_pane() ); + TAknWindowComponentLayout clockNstaPane( + aknLayoutScalable_Avkon.clock_nsta_pane_cp() ); + clockNstaPane = DoCompose( + bottomArea, + DoCompose( + controlPane, + DoCompose( + nstaClockIndicPane, clockNstaPane ) ) ); + layout = clockNstaPane.LayoutLine(); + parentRect = applicationWindowRect; + } + else + { + paneRect = TRect(0,0,0,1); + } + + break; + } + case EEikStatusPaneUidBattery: + { + layout = aknLayoutScalable_Avkon.battery_pane( touchLsc ? 14 : 2 ).LayoutLine(); + break; + } + } + break; + } + + case R_AVKON_STATUS_PANE_LAYOUT_USUAL_EXT: + { + // For now we use classic statuspane + parentRect = usualStatusPaneRect; + + if (!Layout_Meta_Data::IsLandscapeOrientation()) + { + switch(aPaneId.iUid) + { + case EEikStatusPaneUidNavi: + { + layout = aknLayoutScalable_Avkon.navi_pane(7).LayoutLine(); // wide navi pane layout + break; + } + case EEikStatusPaneUidSignal: + { + layout = aknLayoutScalable_Avkon.signal_pane(7).LayoutLine(); + break; + } + case EEikStatusPaneUidTitle: + { + layout = aknLayoutScalable_Avkon.title_pane(7).LayoutLine(); + break; + } + case EEikStatusPaneUidIndic: + { + layout = aknLayoutScalable_Avkon.indicator_nsta_pane().LayoutLine(); + break; + } + case EEikStatusPaneUidBattery: + { + layout = aknLayoutScalable_Avkon.battery_pane(7).LayoutLine(); + break; + } + case EEikStatusPaneUidDigitalClock: + { + layout = aknLayoutScalable_Avkon.clock_nsta_pane().LayoutLine(); + break; + } + case EEikStatusPaneUidEmpty: + { + layout = aknLayoutScalable_Avkon.aid_fill_nsta(2).LayoutLine(); // fill for wide navi pane + TAknLayoutRect LayoutRect; + LayoutRect.LayoutRect(parentRect, layout); + paneRect = LayoutRect.Rect(); + + TAknWindowLineLayout tmpLayout( aknLayoutScalable_Avkon.aid_fill_nsta_2(1).LayoutLine() ); + TAknLayoutRect tmpLayoutRect; + tmpLayoutRect.LayoutRect(parentRect, tmpLayout); + TRect tmpRect( tmpLayoutRect.Rect() ); + + paneRect.BoundingRect(tmpRect); + break; + } + } + } + break; + } + case R_AVKON_STATUS_PANE_LAYOUT_IDLE_EXT: + { + // For now we use classic statuspane + parentRect = usualStatusPaneRect; + + if (!Layout_Meta_Data::IsLandscapeOrientation()) + { + switch(aPaneId.iUid) + { + case EEikStatusPaneUidNavi: + { + layout = aknLayoutScalable_Avkon.navi_pane(6).LayoutLine(); + break; + } + case EEikStatusPaneUidSignal: + { + layout = aknLayoutScalable_Avkon.signal_pane(8).LayoutLine(); + break; + } + case EEikStatusPaneUidTitle: + { + layout = aknLayoutScalable_Avkon.title_pane(8).LayoutLine(); + break; + } + case EEikStatusPaneUidIndic: + { + layout = aknLayoutScalable_Avkon.indicator_nsta_pane(1).LayoutLine(); + break; + } + case EEikStatusPaneUidBattery: + { + layout = aknLayoutScalable_Avkon.battery_pane(8).LayoutLine(); + break; + } + case EEikStatusPaneUidClock: + { + layout = aknLayoutScalable_Avkon.popup_clock_digital_window().LayoutLine(); + break; + } + case EEikStatusPaneUidEmpty: + { + layout = aknLayoutScalable_Avkon.aid_fill_nsta(1).LayoutLine(); + break; + } + } + } + break; + } + + case R_AVKON_WIDESCREEN_PANE_LAYOUT_USUAL: + case R_AVKON_WIDESCREEN_PANE_LAYOUT_IDLE: + { + if ( Layout_Meta_Data::IsLandscapeOrientation() ) // only usable in landscape + { + TAknLayoutRect layout1ParentRect; + layout1ParentRect.LayoutRect( + iLayout->iApplicationWindowRect, + iLayout->iAknLayoutScalable_Avkon.area_top_pane( 8 ).LayoutLine() ); + TAknLayoutRect layout1Rect; + layout1Rect.LayoutRect( + layout1ParentRect.Rect(), + iLayout->iAknLayoutScalable_Avkon.status_pane( 1 ).LayoutLine() ); + parentRect = layout1Rect.Rect(); + + switch ( aPaneId.iUid ) + { + case EEikStatusPaneUidNavi: + { + layout = + aknLayoutScalable_Avkon.navi_pane( 8 ).LayoutLine(); + break; + } + case EEikStatusPaneUidSignal: + { + layout = + aknLayoutScalable_Avkon.signal_pane( 10 ).LayoutLine(); + break; + } + case EEikStatusPaneUidTitle: + { + layout = + aknLayoutScalable_Avkon.title_pane( 10 ).LayoutLine(); + break; + } + case EEikStatusPaneUidIndic: + { + if ( TLocale().TimeFormat() == ETime12 ) + { + layout = + aknLayoutScalable_Avkon.indicator_nsta_pane( 3 ).LayoutLine(); + } + else + { + layout = + aknLayoutScalable_Avkon.indicator_nsta_pane_cp_24( 3 ).LayoutLine(); + } + break; + } + case EEikStatusPaneUidBattery: + { + layout = + aknLayoutScalable_Avkon.battery_pane( 10 ).LayoutLine(); + break; + } + case EEikStatusPaneUidDigitalClock: + { + if ( TLocale().TimeFormat() == ETime12 ) + { + layout = + aknLayoutScalable_Avkon.clock_nsta_pane( 2 ).LayoutLine(); + } + else + { + layout = + aknLayoutScalable_Avkon.clock_nsta_pane_cp_24( 2 ).LayoutLine(); + } + break; + } + case EEikStatusPaneUidEmpty: + { + TAknLayoutRect LayoutRect; + LayoutRect.LayoutRect( + parentRect, + aknLayoutScalable_Avkon.aid_fill_nsta( 3 ).LayoutLine() ); + paneRect = LayoutRect.Rect(); + + TAknLayoutRect tmpLayoutRect; + tmpLayoutRect.LayoutRect( + parentRect, + aknLayoutScalable_Avkon.aid_fill_nsta_2( 2 ).LayoutLine() ); + TRect tmpRect( tmpLayoutRect.Rect() ); + + paneRect.BoundingRect( tmpRect ); + + + paneRect = parentRect; + break; + } + } + } + break; + } + + case R_AVKON_WIDESCREEN_PANE_LAYOUT_USUAL_FLAT: // fallthrough + case R_AVKON_WIDESCREEN_PANE_LAYOUT_IDLE_FLAT: + { + if ( Layout_Meta_Data::IsLandscapeOrientation() ) // only usable in landscape + { + TAknLayoutRect layout1ParentRect; + layout1ParentRect.LayoutRect( + iLayout->iApplicationWindowRect, + iLayout->iAknLayoutScalable_Avkon.area_top_pane( 19 ).LayoutLine() ); + TAknLayoutRect layout1Rect; + layout1Rect.LayoutRect( + layout1ParentRect.Rect(), + iLayout->iAknLayoutScalable_Avkon.status_pane( 4 ).LayoutLine() ); + parentRect = layout1Rect.Rect(); + + switch ( aPaneId.iUid ) + { + case EEikStatusPaneUidNavi: + { + layout = + aknLayoutScalable_Avkon.navi_pane( 9 ).LayoutLine(); + break; + } + case EEikStatusPaneUidSignal: + { + layout = + aknLayoutScalable_Avkon.signal_pane( 11 ).LayoutLine(); + break; + } + case EEikStatusPaneUidTitle: + { + layout = + aknLayoutScalable_Avkon.title_pane( 11 ).LayoutLine(); + break; + } + case EEikStatusPaneUidIndic: + { + layout = + aknLayoutScalable_Avkon.uni_indicator_pane( 3 ).LayoutLine(); + break; + } + case EEikStatusPaneUidBattery: + { + layout = + aknLayoutScalable_Avkon.battery_pane( 11 ).LayoutLine(); + break; + } + } + } + break; + } + case R_AVKON_WIDESCREEN_PANE_LAYOUT_USUAL_FLAT_NO_SOFTKEYS: // fallthrough + case R_AVKON_WIDESCREEN_PANE_LAYOUT_IDLE_FLAT_NO_SOFTKEYS: + { + if ( Layout_Meta_Data::IsLandscapeOrientation() ) // only usable in landscape + { + TAknLayoutRect layout1ParentRect; + layout1ParentRect.LayoutRect( + iLayout->iApplicationWindowRect, + iLayout->iAknLayoutScalable_Avkon.area_top_pane( 20 ).LayoutLine() ); + TAknLayoutRect layout1Rect; + layout1Rect.LayoutRect( + layout1ParentRect.Rect(), + iLayout->iAknLayoutScalable_Avkon.status_pane( 5 ).LayoutLine() ); + parentRect = layout1Rect.Rect(); + + switch ( aPaneId.iUid ) + { + case EEikStatusPaneUidNavi: + { + layout = + aknLayoutScalable_Avkon.navi_pane( 11 ).LayoutLine(); + break; + } + case EEikStatusPaneUidSignal: + { + layout = + aknLayoutScalable_Avkon.signal_pane( 13 ).LayoutLine(); + break; + } + case EEikStatusPaneUidTitle: + { + layout = + aknLayoutScalable_Avkon.title_pane( 13 ).LayoutLine(); + break; + } + case EEikStatusPaneUidIndic: + { + layout = + aknLayoutScalable_Avkon.uni_indicator_pane( 5 ).LayoutLine(); + break; + } + case EEikStatusPaneUidBattery: + { + layout = + aknLayoutScalable_Avkon.battery_pane( 13 ).LayoutLine(); + break; + } + case EEikStatusPaneUidDigitalClock: + { + if ( TLocale().TimeFormat() == ETime12 ) + { + layout = + aknLayoutScalable_Avkon.clock_nsta_pane( 3 ).LayoutLine(); + } + else + { + layout = + aknLayoutScalable_Avkon.clock_nsta_pane_cp_24( 11 ).LayoutLine(); + } + break; + } + } + } + break; + } + } // end of switch(aLayoutId) + + if ( paneRect.IsEmpty() && layout.iW != 0 && layout.iH != 0 ) + { + TAknLayoutRect LayoutRect; + LayoutRect.LayoutRect( parentRect, layout ); + paneRect = LayoutRect.Rect(); + } + +#ifdef __DEBUG + if ( paneRect == TRect( 0, 0, 0, 0 ) ) + { + RDebug::Print(_L("CEikStatusPaneLayoutTree::GetRectFromAknLayout, Perhaps an unknown paneID = %d",aPaneId)); + RDebug::Print(_L("CEikStatusPaneLayoutTree::GetRectFromAknLayout, LayoutId = %d",aLayoutId)); + } +#endif + + return paneRect; + } + +CEikStatusPaneLayout* CEikStatusPaneLayout::NewL(TResourceReader& aResource, const TRect& aScreenRect) + { + CEikStatusPaneLayout* self = new(ELeave) CEikStatusPaneLayout(); + CleanupStack::PushL(self); + self->ConstructL(aResource, aScreenRect, 0); + CleanupStack::Pop(); + return self; + } + +CEikStatusPaneLayout* CEikStatusPaneLayout::NewL(TResourceReader& aResource, const TRect& aScreenRect, TInt aLayoutId) + { + CEikStatusPaneLayout* self = new(ELeave) CEikStatusPaneLayout(); + CleanupStack::PushL(self); + self->ConstructL(aResource, aScreenRect, aLayoutId); + CleanupStack::Pop(); + return self; + } + +CEikStatusPaneLayout::~CEikStatusPaneLayout() + { + delete iRoot; + } + + +CEikStatusPaneLayout::CEikStatusPaneLayout() +: iAknLayout(AknLayout::CustomisationInstance()), + iAknLayoutScalable_Avkon(AknLayoutScalable_Avkon::CustomisationInstance()) + { + } + +void CEikStatusPaneLayout::ConstructL(TResourceReader& aResource, const TRect& aScreenRect, TInt aLayoutId) + { + TInt position = aResource.ReadUint16(); + + CEikStatusPaneLayoutTree::TDirection dir = CEikStatusPaneLayoutTree::EHorizontal; + if (position & EEikStatusPaneLayoutVertical) + dir = CEikStatusPaneLayoutTree::EVertical; + + iRoot = CEikStatusPaneLayoutTree::NewL(this, aResource, dir); + + TRect rect( aScreenRect ); + TInt size( iRoot->Size() ); + + TAknWindowComponentLayout applicationWindow( AknLayoutScalable_Avkon::application_window( 0 ) ); + TAknWindowComponentLayout topArea( AknLayoutScalable_Avkon::area_top_pane( 1 ) ); + TAknWindowComponentLayout statusPane( AknLayoutScalable_Avkon::status_pane( 0 ) ); + statusPane = DoCompose( applicationWindow, DoCompose( topArea, statusPane ) ); + TAknLayoutRect statusPaneLayoutRect; + + switch (position & KEikSpanePositionMask) + { + case EEikStatusPanePositionTop: + statusPaneLayoutRect.LayoutRect( rect, statusPane.LayoutLine() ); + rect = statusPaneLayoutRect.Rect(); + break; + + case EEikStatusPanePositionBottom: + rect.iTl.iY = rect.iBr.iY - size; + break; + + case EEikStatusPanePositionLeft: + rect.iBr.iX = rect.iTl.iX + size; + break; + + case EEikStatusPanePositionRight: + default: + rect.iTl.iX = rect.iBr.iX - size; + break; + } + +// Make sure the flag is never used if scalabale ui is not available. + if (position & EEikStatusPaneLayoutAknLafDefined) + { + iRoot->SetAknLayoutUsed(ETrue); + AknLayoutRefresh(aLayoutId); + } + + if (!AknLayoutUsed()) + { + iRoot->SetRect(rect); + } + } + +void CEikStatusPaneLayout::AknLayoutRefresh(TInt aLayoutResourceId) + { + // If layout has been defined by the AknLayout, + // then re-define the layout. + if (AknLayoutUsed()) + { + UpdateLayoutData(aLayoutResourceId); + iRoot->Layout(aLayoutResourceId); + } + } + +TBool CEikStatusPaneLayout::AknLayoutUsed() + { + if (iRoot) + { + return iRoot->AknLayoutUsed(); + } + else + { + return EFalse; + } + } + +void CEikStatusPaneLayout::UpdateLayoutData(TInt aLayoutResId) + { + // screen + TAknWindowLineLayout screenLayout( AknLayout::screen() ); + iScreenRect = screenLayout.Rect(); + + // application window + TAknWindowLineLayout applicationWindowLayout( + iAknLayoutScalable_Avkon.application_window( 0 ).LayoutLine() ); + TAknLayoutRect applicationWindowLayoutRect; + applicationWindowLayoutRect.LayoutRect(iScreenRect, applicationWindowLayout); + iApplicationWindowRect = applicationWindowLayoutRect.Rect(); + + // Main pane + TBool landscape = Layout_Meta_Data::IsLandscapeOrientation(); + TInt mainPaneVariety = landscape ? 4 : 3; + TAknWindowLineLayout mainPaneLayout( iAknLayoutScalable_Avkon.main_pane(mainPaneVariety).LayoutLine() ); + TAknLayoutRect mainPaneLayoutRect; + mainPaneLayoutRect.LayoutRect(iApplicationWindowRect, mainPaneLayout); + iMainPaneRect = mainPaneLayoutRect.Rect(); + + // statuspane, usual + TAknWindowComponentLayout topArea( iAknLayoutScalable_Avkon.area_top_pane( 0 ) ); + TAknWindowComponentLayout statusPaneLayout( iAknLayoutScalable_Avkon.status_pane( 0 ) ); + TAknWindowComponentLayout statusPane( + DoCompose( applicationWindowLayout, DoCompose( topArea, statusPaneLayout ).LayoutLine() ) ); + + TAknLayoutRect statusPaneLayoutRect; + statusPaneLayoutRect.LayoutRect( iScreenRect, statusPane.LayoutLine() ); + iUsualStatusPaneRect = statusPaneLayoutRect.Rect(); + + // statuspane, small + TAknWindowLineLayout topAreaLayout; + if ( AknLayoutUtils::CbaLocation() == AknLayoutUtils::EAknCbaLocationBottom && + Layout_Meta_Data::IsLandscapeOrientation() ) + { + // Landscape with bottom softkeys is the only landscape mode + // in which small status pane can be shown. + topAreaLayout = AknLayoutScalable_Avkon::area_top_pane( 2 ).LayoutLine(); + } + else + { + topAreaLayout = AknLayoutScalable_Avkon::area_top_pane( 1 ).LayoutLine(); + } + TAknLayoutRect topAreaLayoutRect; + topAreaLayoutRect.LayoutRect( iApplicationWindowRect, topAreaLayout ); + + // The small status pane fills the whole top area. + iSmallStatusPaneRect = topAreaLayoutRect.Rect(); + + if (aLayoutResId == R_AVKON_STACON_PANE_LAYOUT_USUAL_SOFTKEYS_LEFT || + aLayoutResId == R_AVKON_STACON_PANE_LAYOUT_USUAL_SOFTKEYS_RIGHT || + aLayoutResId == R_AVKON_STACON_PANE_LAYOUT_IDLE_SOFTKEYS_LEFT || + aLayoutResId == R_AVKON_STACON_PANE_LAYOUT_IDLE_SOFTKEYS_RIGHT) + { + TAknWindowComponentLayout layout1parent( iAknLayoutScalable_Avkon.area_top_pane(2) ); + TAknWindowComponentLayout layout1( iAknLayoutScalable_Avkon.stacon_top_pane() ); + TAknLayoutRect layout1ParentRect; + layout1ParentRect.LayoutRect(iScreenRect, layout1parent.LayoutLine()); + TAknLayoutRect layout1Rect; + layout1Rect.LayoutRect(layout1ParentRect.Rect(), layout1.LayoutLine()); + iStaconLayout1Rect = layout1Rect.Rect(); + + TAknWindowComponentLayout layout2parent( iAknLayoutScalable_Avkon.area_bottom_pane(2) ); + TAknWindowComponentLayout layout2( iAknLayoutScalable_Avkon.stacon_bottom_pane() ); + TAknLayoutRect layout2ParentRect; + layout2ParentRect.LayoutRect(iScreenRect, layout2parent.LayoutLine()); + TAknLayoutRect layout2Rect; + layout2Rect.LayoutRect(layout2ParentRect.Rect(), layout2.LayoutLine()); + iStaconLayout2Rect = layout2Rect.Rect(); + } + } + +TRect CEikStatusPaneLayout::AknLayoutRect(TInt aLayoutResourceId, TPaneId aPaneId) + { + return iRoot->AknLayoutRect(aLayoutResourceId, aPaneId); + } + + +EXPORT_C CEikStatusPaneModelBase::~CEikStatusPaneModelBase() + { + delete iPanes; + if (iLayouts) + iLayouts->ResetAndDestroy(); + delete iLayouts; + delete iLegalIds; + } + +EXPORT_C void CEikStatusPaneModelBase::SetLayoutL(TInt aLayoutResId, TBool /*aChangeStatusPaneNow*/) + { + TInt layoutResId = AVKONENV->StatusPaneResIdForCurrentLayout(aLayoutResId); + if (!IsLegalId(layoutResId)) + User::Leave(KErrNotFound); + + CEikStatusPaneLayout* layout = Layout(layoutResId); + if (layout == NULL) + layout = LoadLayoutL(layoutResId); + + iCurrentResId = layoutResId; + iCurrentLayout = layout; + } + +EXPORT_C CEikStatusPaneModelBase::CEikStatusPaneModelBase(CEikonEnv& aEikEnv) +: iEikEnv(aEikEnv) + { + } + +EXPORT_C void CEikStatusPaneModelBase::BaseConstructL(TInt aCoreResId) + { + TResourceReader res; + iEikEnv.CreateResourceReaderLC(res, aCoreResId); + + iPanes = CEikStatusPaneSetInit::NewL(); + iPanes->LoadDefaultsL(res); + + iCurrentResId = AVKONENV->StatusPaneResIdForCurrentLayout(res.ReadUint32()); + + const TInt layoutCount=res.ReadInt16(); + iLegalIds = new(ELeave) CIdSet(layoutCount); + for (TInt ii=0; iiAppendL(layoutRes); + } + + CleanupStack::PopAndDestroy(); // res + } + +TBool CEikStatusPaneModelBase::IsLegalId(TInt aLayoutResId) const + { + for (TInt i=0; iCount(); i++) + { + if (iLegalIds->At(i) == aLayoutResId) + return ETrue; + } + return EFalse; + } + +CEikStatusPaneLayout* CEikStatusPaneModelBase::Layout(TInt aLayoutResId) + { + for (TInt i=0; iCount(); i++) + { + if (iLayouts->At(i)->iResId == aLayoutResId) + return iLayouts->At(i)->iLayout; + } + return NULL; + } + +EXPORT_C CEikStatusPaneLayout* CEikStatusPaneModelBase::LoadLayoutL(TInt aLayoutResId) + { + TResourceReader res; + iEikEnv.CreateResourceReaderLC(res, aLayoutResId); + + TRect rect(TPoint(0,0),TSize(AKN_LAYOUT_WINDOW_screen.iW,AKN_LAYOUT_WINDOW_screen.iH)); + CEikStatusPaneLayout* layout = CEikStatusPaneLayout::NewL(res, rect, aLayoutResId); + + CleanupStack::PushL(layout); + CheckLayoutL(layout); + + CIdLayoutPair* pair = new(ELeave) CIdLayoutPair(aLayoutResId, layout); + CleanupStack::Pop(); // layout + CleanupStack::PushL(pair); + + iLayouts->AppendL(pair); + CleanupStack::Pop(); // pair + + CleanupStack::PopAndDestroy(); // res + + return layout; + } + +void CEikStatusPaneModelBase::CheckLayoutL(CEikStatusPaneLayout* aLayout) + { + TLayoutChecker checker(iPanes); + aLayout->AcceptL(&checker); + } + +EXPORT_C void CEikStatusPaneModelBase::Reserved_1() + { + } + +EXPORT_C TInt CEikStatusPaneModelBase::CurrentLayoutResId() const + { + return iCurrentResId; + } + +void CEikStatusPaneModelBase::AknLayoutRefresh() + { + for (TInt i=0; iCount(); i++) + { + if (iLayouts->At(i)) + { + iLayouts->At(i)->iLayout->AknLayoutRefresh(iLayouts->At(i)->iResId); + } + } + } + +TBool CEikStatusPaneModelBase::AknLayoutUsed(TInt aLayoutId) + { + for (TInt i=0; iCount(); i++) + { + if (iLayouts->At(i) && iLayouts->At(i)->iResId == aLayoutId) + { + return iLayouts->At(i)->iLayout->AknLayoutUsed(); + } + } + return EFalse; + } + + +CEikStatusPaneModelBase::TLayoutChecker::TLayoutChecker(CEikStatusPaneSetInit* aPanes) +: iPanes(aPanes) + { + } + +void CEikStatusPaneModelBase::TLayoutChecker::VisitL(CEikStatusPaneLayoutTree* aNode) + { + iPanes->FindL(aNode->Id()); + } + + +CEikStatusPaneModelBase::CIdLayoutPair::CIdLayoutPair(TInt aResId, CEikStatusPaneLayout* aLayout) +: iResId(aResId), iLayout(aLayout) + { + } + +CEikStatusPaneModelBase::CIdLayoutPair::~CIdLayoutPair() + { + delete iLayout; + } + + + + +CEikAppStatusPaneModel* CEikAppStatusPaneModel::NewL(CEikonEnv& aEikEnv, TInt aCoreResId, TInt aAppResId, TBool aChangeStatusPaneNow) + { + CEikAppStatusPaneModel* self = new(ELeave) CEikAppStatusPaneModel(aEikEnv); + CleanupStack::PushL(self); + self->ConstructL(aCoreResId, aAppResId, aChangeStatusPaneNow); + CleanupStack::Pop(); + return self; + } + +CEikAppStatusPaneModel::~CEikAppStatusPaneModel() + { + } + +void CEikAppStatusPaneModel::SetLayoutL(TInt aLayoutResId, TBool aChangeStatusPaneNow) + { + CEikStatusPaneModelBase::SetLayoutL(aLayoutResId, aChangeStatusPaneNow); + CAknSgcClient::HandleChangeL(); + } + +void CEikAppStatusPaneModel::SetLayoutL(TInt aLayoutResId, TBool aChangeStatusPaneNow, TBool aNotfiyServerSide) + { + CEikStatusPaneModelBase::SetLayoutL(aLayoutResId, aChangeStatusPaneNow); + if (aNotfiyServerSide) + CAknSgcClient::HandleChangeL(); + } + + +CEikAppStatusPaneModel::CEikAppStatusPaneModel(CEikonEnv& aEikEnv) +: CEikStatusPaneModelBase(aEikEnv) + { + } + +void CEikAppStatusPaneModel::ConstructL(TInt aCoreResId, TInt aAppResId, TBool aChangeStatusPaneNow) + { + BaseConstructL(aCoreResId); + + iLayouts = new(ELeave) CLayoutIdSet(1); + + if (aAppResId != EEikStatusPaneUseDefaults && + aAppResId > EEikStatusPaneLayoutAknLafDefined) + { + TResourceReader res; + iEikEnv.CreateResourceReaderLC(res, aAppResId); + + TInt defaultLayout = res.ReadUint32(); + if (defaultLayout != EEikStatusPaneUseDefaults && + defaultLayout > EEikStatusPaneLayoutAknLafDefined) + { + if (IsLegalId(defaultLayout)) + { + iCurrentResId = defaultLayout; + } + else + { + User::Leave(KErrNotFound); + } + } + + PaneInits()->LoadDefaultsL(res); + + CleanupStack::PopAndDestroy(); // res + } + + SetLayoutL(iCurrentResId,aChangeStatusPaneNow); + } + +void CEikAppStatusPaneModel::ApplyCurrentLayoutL() + { + } +