/*

* 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 <eikspmod.h>

#include <barsread.h>

#include <eikenv.h>

#include <eikcoctl.rsg>

#include <AknSgcc.h>

#include <aknenv.h>

#include <aknlayout.cdl.h>

#include <AknUtils.h>

#include <AknLayout.lag>

#include <applayout.cdl.h>

#include <aknlayoutscalable_avkon.cdl.h>

#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<count;++ii)

		{

		TEikStatusPaneInit init;

		init.LoadDefaults(aResource);

		if ( init.ControlResourceId() )

		    {

		    if (initialized)

			    {

			    FindL(init.Id()) = init;

			    }

		    else

			    {

			    AppendL(init);

			    }

		    }

		}

	}

CEikStatusPaneSetInit::CEikStatusPaneSetInit() 

: CArrayFixFlat<TEikStatusPaneInit>(KStatusPaneSetInitGranularity)

	{

	}

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

	{

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

		{

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

			return At(i);

		}

	User::Leave(KErrNotFound);

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

	}

CEikStatusPaneLayoutTree::~CEikStatusPaneLayoutTree()

	{

	if (iSubPanes)

		iSubPanes->ResetAndDestroy();

	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; i<iSubPanes->Count(); 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;ii<count;++ii)

			{

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

			CleanupStack::PushL(pane);

			iSubPanes->AppendL(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; i<count; i++)

		{

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

		TInt size = subPane->Size();

		if (subPane->Stretchable())

			stretchSize += size;

		else

			unallocedSize -= size;

		}

	TPoint pos( iRect.iTl );

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

		{

		CEikStatusPaneLayoutTree* subPane = iSubPanes->At(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; i<iSubPanes->Count(); 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; i<count; i++)

		    {

		    CEikStatusPaneLayoutTree* subPane = iSubPanes->At(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:

	        {