/*

* Copyright (c) 2006 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:   Factory for visuals and layouts.

*

*/

#include "alf/alfvisualfactory.h"  // Class definition

#include "alf/alftextvisual.h"

#include "alf/alflcttextvisual.h"

#include "alf/alfanchorlayout.h"

#include "alf/alfviewportlayout.h"

#include "alf/alfdecklayout.h"

#include "alf/alfflowlayout.h"

#include "alf/alfimagevisual.h"

#include "alf/alfgridlayout.h"

#include "alf/alflctgridlayout.h"

#include "alf/alfcurvepathlayout.h"

#include "alf/alfconstants.h"

#include "alf/alflinevisual.h"

#include "alf/alflctanchorlayout.h"

#include "alf/alfmeshvisual.h"

#include "alf/alfcanvasvisual.h"

#include "alfuids.h"

#include "alf/alfcontrol.h"

// ---------------------------------------------------------------------------

// Creates new visual

// ---------------------------------------------------------------------------

//

EXPORT_C CAlfVisual* AlfVisualFactory::NewVisualL(

        TAlfVisualType aVisualType,

	    CAlfLayout* aParentLayout,

	    CAlfControl& aOwner,

	    CAlfEnv& aEnv,

	    TInt aImplementationUid)

    {

    CAlfVisual* visual = NewVisualLC(aVisualType, aParentLayout, aOwner, aEnv, aImplementationUid);

    CleanupStack::Pop(visual);

    return visual;

    }

// ---------------------------------------------------------------------------

// Creates new visual

// ---------------------------------------------------------------------------

//   

EXPORT_C CAlfVisual* AlfVisualFactory::NewVisualLC(

        TAlfVisualType aVisualType,

	    CAlfLayout* aParentLayout,

	    CAlfControl& aOwner,

	    CAlfEnv& /*aEnv*/,

	    TInt aImplementationUid)

	{

    CAlfVisual* visual = NULL;

    TInt mappedType = KErrNotFound;

    switch(aVisualType)

        {

        case EAlfVisualTypeVisual:

            {

            if (aImplementationUid == 0)

                mappedType = EAlfVisualCreate;

            visual = new (ELeave) CAlfVisual();

            break;

            }

        case EAlfVisualTypeLine:

            if (aImplementationUid == 0)

                mappedType = EAlfLineVisualCreate;

            visual = new (ELeave) CAlfLineVisual();

            break;

        /*case EAlfVisualTypeGradient:

            visual = new (ELeave) CAlfGradientVisual();

            break;*/

        case EAlfVisualTypeText:

            {

            if (aImplementationUid == 0)

                mappedType = EAlfTextVisualCreate;

            visual = new (ELeave) CAlfTextVisual();

            break;    

            }

#ifdef RD_ALF_IN_PLATFORM            

        case EAlfVisualTypeLCTText:

            {

            if (aImplementationUid == 0)

                mappedType = EAlfLCTTextVisualCreate;

            visual = new (ELeave) CAlfLCTTextVisual();

            break;    

            }

#endif // RD_ALF_IN_PLATFORM

        case EAlfVisualTypeImage:

            {

            if (aImplementationUid == 0)

                mappedType = EAlfImageVisualCreate;

            visual = new (ELeave) CAlfImageVisual();

            break;

            }

        case EAlfVisualTypeMesh:

            if (aImplementationUid == 0)

                mappedType = EAlfMeshVisualCreate;

            visual = new (ELeave) CAlfMeshVisual();

            break;

        case EAlfVisualTypeCanvas:

            if (aImplementationUid == 0)

                mappedType = EAlfCanvasVisualCreate;

            visual = new (ELeave) CAlfCanvasVisual();

            break;

        default: // todo: should we leave or should extensions to be created via here?

            User::Leave(KErrNotFound);

        }

    CleanupStack::PushL(visual);

    ASSERT(aOwner.Identifier());

    TInt parentlayouthandle = 0;

    if (aParentLayout)

        {

        parentlayouthandle = aParentLayout->Identifier();

        }

    TInt2 inputParams(aOwner.Identifier(), parentlayouthandle);

    TPckg<TInt2> paramBuf(inputParams);

    visual->ConstructL( aOwner, 

                        (mappedType==KErrNotFound)?aVisualType:mappedType, 

                        aImplementationUid, paramBuf );

    return visual;    

    }

// ---------------------------------------------------------------------------

// Creates new layout - TODO: Is this obsolete ?

// ---------------------------------------------------------------------------

//   

EXPORT_C CAlfLayout* AlfVisualFactory::NewLayoutL(

        TAlfLayoutType aLayoutType,

	    CAlfLayout* aParentLayout,

	    CAlfControl& aOwner,

	    CAlfEnv& aEnv,

	    TInt aImplementationUid)

    {

    CAlfLayout* layout = NewLayoutLC(aLayoutType, aParentLayout, aOwner, aEnv, aImplementationUid);

    CleanupStack::Pop(layout);

    return layout;

    }

// ---------------------------------------------------------------------------

// Creates new layout

// ---------------------------------------------------------------------------

//      

EXPORT_C CAlfLayout* AlfVisualFactory::NewLayoutLC(	    

        TAlfLayoutType aLayoutType,

	    CAlfLayout* aParentLayout,

	    CAlfControl& aOwner,

	    CAlfEnv& /*aEnv*/,

	    TInt aImplementationUid )

    {

    CAlfLayout* layout = NULL;

    TInt mappedType = KErrNotFound; 

    switch(aLayoutType)

        {

        case EAlfLayoutTypeLayout:

            if (aImplementationUid == 0)

                mappedType = EAlfLayoutCreate;

            layout = new (ELeave) CAlfLayout();

            break;

        case EAlfLayoutTypeGrid:

            if (aImplementationUid == 0)

                {

                mappedType = EAlfGridLayoutCreate;

                }

            layout = new (ELeave) CAlfGridLayout();

            break;

#ifdef RD_ALF_IN_PLATFORM            

        case EAlfLayoutTypeLCTGrid:

            if (aImplementationUid == 0)

                {

                mappedType = EAlfLCTGridLayoutCreate;

                }                

            layout = new (ELeave) CAlfLCTGridLayout();

            break;

#endif // RD_ALF_IN_PLATFORM            

        case EAlfLayoutTypeAnchor:

            if (aImplementationUid == 0)

                {

                mappedType = EAlfAnchorLayoutCreate;

                }                

            layout = new (ELeave) CAlfAnchorLayout();

            break;

#ifdef RD_ALF_IN_PLATFORM            

        case EAlfLayoutTypeLCTAnchor:

            if (aImplementationUid == 0)

                {

                mappedType = EAlfLCTAnchorLayoutCreate;

                }                

            layout = new (ELeave) CAlfLCTAnchorLayout();

            break;

#endif // RD_ALF_IN_PLATFORM            

        case EAlfLayoutTypeDeck:

            if (aImplementationUid == 0)

                {

                mappedType = EAlfDeckLayoutCreate;

                }                

            layout = new (ELeave) CAlfDeckLayout();

            break;

        case EAlfLayoutTypeFlow:

            if (aImplementationUid == 0)

                {

                mappedType = EAlfFlowLayoutCreate;

                }                

            layout = new (ELeave) CAlfFlowLayout();

            break;

        case EAlfLayoutTypeCurvePath:

            if (aImplementationUid == 0)

                {

                mappedType = EAlfCurvePathLayoutCreate;

                }                

            layout = new (ELeave) CAlfCurvePathLayout();

            break;

        case EAlfLayoutTypeViewport:

            if (aImplementationUid == 0)

                {

                mappedType = EAlfViewportLayoutCreate;

                }                

            layout = new (ELeave) CAlfViewportLayout();

            break;            

        default:

            User::Leave(KErrNotFound);

        }

    CleanupStack::PushL(layout);

    ASSERT(aOwner.Identifier());

    TInt parentlayouthandle = 0;

    if (aParentLayout)

        {

        parentlayouthandle = aParentLayout->Identifier();

        }

    TInt2 inputParams(aOwner.Identifier(), parentlayouthandle);

    TPckg<TInt2> paramBuf(inputParams);

    layout->CAlfVisual::ConstructL( aOwner, 

                        (mappedType==KErrNotFound)?aLayoutType:mappedType, 

                        aImplementationUid, paramBuf );

    return layout;    

    }