/*

* Copyright (c) 2006-2007 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:

*

*/

#include "aknlayout2hierarchydef.h"

#include "aknlayout2hierarchy.h"

#include <aknlayoutscalable_avkon.cdl.h>

#include <aknlayoutscalable_apps.cdl.h>

#include <layoutmetadata.cdl.h>

#include <CdlEngine.h>

#define AKNLAYOUT_DEFINE_BYTECODE(name,byte) const TUint8 name = byte;

#include "AknLayoutByteCodes.h"

#ifndef EKA2

GLDEF_C TInt E32Dll(TDllReason)

	{

	return KErrNone;

	}

#endif

//

// class TAknLayoutHierarchyComponentHandle

//

TAknLayoutHierarchyComponentHandle::TPrivateData_AknLayout2::TPrivateData_AknLayout2(        

    TInt aApiId,

    TInt aComponentId,

    TInt aOptionIndex,

    TInt aDrawingOrderIndex,

    TInt aVarietyIndex,

    TInt aColumn,

    TInt aRow)

    :

    iApiId(aApiId), 

    iComponentId(aComponentId),

    iOptionIndex(aOptionIndex),

    iDrawingOrderIndex(aDrawingOrderIndex),

    iVarietyIndex(aVarietyIndex),

    iColumn(aColumn),

    iRow(aRow) 

    {

    }

EXPORT_C TAknLayoutHierarchyComponentHandle::TAknLayoutHierarchyComponentHandle()

    :

    iLayoutSystemId(0),    

    iData(0, 0, 0, 0, 0, 0, 0)

    {

    }

EXPORT_C TAknLayoutHierarchyComponentHandle::TAknLayoutHierarchyComponentHandle(TInt aLayoutSystemId, TInt aApiId, TInt aComponentId)

    :

    iLayoutSystemId(aLayoutSystemId),

    iData(aApiId, aComponentId, 0, 0, 0, 0, 0)

    {

    }

EXPORT_C TInt TAknLayoutHierarchyComponentHandle::LayoutSystemId() const

    {

    return iLayoutSystemId;

    }

EXPORT_C TInt TAknLayoutHierarchyComponentHandle::ApiId() const

    {

    return iData.iApiId;

    }

EXPORT_C TInt TAknLayoutHierarchyComponentHandle::ComponentId() const

    {

    return iData.iComponentId;

    }

EXPORT_C TInt TAknLayoutHierarchyComponentHandle::OptionIndex() const

    {

    return iData.iOptionIndex;

    }

EXPORT_C TInt TAknLayoutHierarchyComponentHandle::VarietyIndex() const

    {

    return iData.iVarietyIndex;

    }

EXPORT_C TInt TAknLayoutHierarchyComponentHandle::Column() const

    {

    return iData.iColumn;

    }

EXPORT_C TInt TAknLayoutHierarchyComponentHandle::Row() const

    {

    return iData.iRow;

    }

EXPORT_C void TAknLayoutHierarchyComponentHandle::SetLayoutSystemId(TInt aLayoutSystemId)

    {

    iLayoutSystemId = aLayoutSystemId;

    }

EXPORT_C void TAknLayoutHierarchyComponentHandle::SetApiId(TInt aApiId)

    {

    iData.iApiId = aApiId;

    }

EXPORT_C void TAknLayoutHierarchyComponentHandle::SetComponentId(TInt aComponentId)

    {

    iData.iComponentId = aComponentId;

    }

EXPORT_C void TAknLayoutHierarchyComponentHandle::SetOptionIndex(TInt aOptionIndex)

    {

    iData.iOptionIndex = aOptionIndex;

    }

EXPORT_C void TAknLayoutHierarchyComponentHandle::SetVarietyIndex(TInt aVarietyIndex)

    {

    iData.iVarietyIndex = aVarietyIndex;

    }

EXPORT_C void TAknLayoutHierarchyComponentHandle::SetColumn(TInt aColumn)

    {

    iData.iColumn = aColumn;

    }

EXPORT_C void TAknLayoutHierarchyComponentHandle::SetRow(TInt aRow)

    {

    iData.iRow = aRow;

    }

// 

// class AknLayout2Hierarchy

// 

EXPORT_C TAknLayoutScalableComponentType AknLayout2Hierarchy::GetComponentType(const TAknLayoutHierarchyComponentHandle& aComponentHandle)

    {

    TAknLayoutScalableComponentType type(EAknLayoutScalableComponentTypeUnknown);

    TInt apiId = aComponentHandle.ApiId();

    TInt compId = aComponentHandle.ComponentId();

    TInt specialCompId(-1);

    switch(apiId)

        {

        case AknLayoutScalable_Avkon::KCdlInterfaceUidValue:

            {

            specialCompId = AknLayoutScalable_Avkon::EApiId_GetComponentTypeById;

            break;

            }

        case AknLayoutScalable_Apps::KCdlInterfaceUidValue:

            {

            specialCompId = AknLayoutScalable_Apps::EApiId_GetComponentTypeById;

            break;

            }

        default:

            {

            // and we know it's at ordinal 0 because that's what the layout compiler now does for all new layout interfaces.

            specialCompId = 0;

            break;

            }

        }

    // first of all we find the instance that implements the desired api

    const CCdlInstance* implementor = CdlEngine::Implementor(TUid::Uid(apiId), compId);

    // then we call the special function belonging to that instance

    // the cast is a cheat by using the apps namespace, as we know that the sig will be the same for all other layout interfaces

    type = (*(AknLayoutScalable_Apps::TGetComponentTypeById_sig*)(implementor->GetFunction(specialCompId)))(compId);

    return type;

    }

EXPORT_C TAknLayoutScalableParameterLimits AknLayout2Hierarchy::GetParamLimits(const TAknLayoutHierarchyComponentHandle& aComponentHandle)

    {

    TAknLayoutScalableParameterLimits limits;

    TInt apiId = aComponentHandle.ApiId();

    TInt compId = aComponentHandle.ComponentId();

    TInt varietyId = aComponentHandle.VarietyIndex();

    TInt specialCompId(-1);

    switch(apiId)

        {

        case AknLayoutScalable_Avkon::KCdlInterfaceUidValue:

            {

            specialCompId = AknLayoutScalable_Avkon::EApiId_GetParamLimitsById;

            break;

            }

        case AknLayoutScalable_Apps::KCdlInterfaceUidValue:

            {

            specialCompId = AknLayoutScalable_Apps::EApiId_GetParamLimitsById;

            break;

            }

        default:

            {

            // and we know it's at ordinal 1 because that's what the layout compiler now does for all new layout interfaces.

            specialCompId = 1;

            break;

            }

        }

    // first of all we find the instance that implements the desired api

    const CCdlInstance* implementor = CdlEngine::Implementor(TUid::Uid(apiId), compId);

    // then we call the special function belonging to that instance

    // the cast is a cheat by using the apps namespace, as we know that the sig will be the same for all other layout interfaces

    limits = (*(AknLayoutScalable_Apps::TGetParamLimitsById_sig*)(implementor->GetFunction(specialCompId)))(compId, varietyId);

    return limits;

    }

EXPORT_C TAknWindowComponentLayout AknLayout2Hierarchy::GetWindowComponentLayout(const TAknLayoutHierarchyComponentHandle& aComponentHandle)

    {

    TAknWindowComponentLayout layoutW;

    TInt apiId = aComponentHandle.ApiId();

    TInt compId = aComponentHandle.ComponentId();

    TInt varietyId = aComponentHandle.VarietyIndex();

    TInt column = aComponentHandle.Column();

    TInt row = aComponentHandle.Row();

    TInt specialCompId(-1);

    switch(apiId)

        {

        case AknLayoutScalable_Avkon::KCdlInterfaceUidValue:

            {

            specialCompId = AknLayoutScalable_Avkon::EApiId_GetWindowComponentById;

            break;

            }

        case AknLayoutScalable_Apps::KCdlInterfaceUidValue:

            {

            specialCompId = AknLayoutScalable_Apps::EApiId_GetWindowComponentById;

            break;

            }

        default:

            {

            // and we know it's at ordinal 2 because that's what the layout compiler now does for all new layout interfaces.

            specialCompId = 2;

            break;

            }

        }

    // first of all we find the instance that implements the desired api

    const CCdlInstance* implementor = CdlEngine::Implementor(TUid::Uid(apiId), compId);

    // then we call the special function belonging to that instance

    // the cast is a cheat by using the apps namespace, as we know that the sig will be the same for all other layout interfaces

    layoutW = (*(AknLayoutScalable_Apps::TGetWindowComponentById_sig*)(implementor->GetFunction(specialCompId)))(compId, varietyId, column, row);

    return layoutW;

    }

EXPORT_C TAknTextComponentLayout AknLayout2Hierarchy::GetTextComponentLayout(const TAknLayoutHierarchyComponentHandle& aComponentHandle)

    {

    TAknTextComponentLayout layoutT;

    TInt apiId = aComponentHandle.ApiId();

    TInt compId = aComponentHandle.ComponentId();

    TInt varietyId = aComponentHandle.VarietyIndex();

    TInt column = aComponentHandle.Column();

    TInt row = aComponentHandle.Row();

    TInt specialCompId(-1);

    switch(apiId)

        {

        case AknLayoutScalable_Avkon::KCdlInterfaceUidValue:

            {

            specialCompId = AknLayoutScalable_Avkon::EApiId_GetTextComponentById;

            break;

            }

        case AknLayoutScalable_Apps::KCdlInterfaceUidValue:

            {

            specialCompId = AknLayoutScalable_Apps::EApiId_GetTextComponentById;

            break;

            }

        default:

            {

            // cheat by using the apps namespace, as we know that the sig is the same, 

            // and we know it's at ordinal 3 because that's what the layout compiler now does for all new layout interfaces.

            specialCompId = 3;

            break;

            }

        }

    // first of all we find the instance that implements the desired api

    const CCdlInstance* implementor = CdlEngine::Implementor(TUid::Uid(apiId), compId);

    // then we call the special function belonging to that instance

    // the cast is a cheat by using the apps namespace, as we know that the sig will be the same for all other layout interfaces

    layoutT = (*(AknLayoutScalable_Apps::TGetTextComponentById_sig*)(implementor->GetFunction(specialCompId)))(compId, varietyId, column, row);

    return layoutT;

    }

// end of file