/*
* Copyright (c) 2003-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:  ?Description
*
*/

// Using debug macros.
#include <j2me/jdebug.h>

#include <coecntrl.h>
#include <lcdui.h>
//
#include "CMIDDisplayable.h"
#include "CMIDTicker.h"
#include "CMIDForm.h"
// needed for creating alert
#include "CMIDAlert.h"
#include "CMIDCanvas.h"
// needed for creating font
#include "CMIDFont.h"
#include "CMIDItem.h"
#include "CMIDControlItem.h"
// needed for creating image item
#include "CMIDImageItem.h"
// needed for creating string item
#include "CMIDStringItem.h"
// needed for creating date field item
#include "CMIDDateFieldItem.h"
// needed for creating gauge
#include "CMIDGaugeItem.h"
// needed for creating text box control
#include "CMIDTextBoxControl.h"
// needed for creating popup text box control
#include "CMIDTextBoxDialogControl.h"
// needed for creating text field item
#include "CMIDTextFieldItem.h"
// needed for creating utils
#include "CMIDUtils.h"
// for iUIManager member
#include "CMIDUIManager.h"
#include "CMIDCommand.h"
// needed for creating spacer
#include "CMIDSpacer.h"
// needed for creating custom item
#include "CMIDCustomItem.h"
#include "CMIDComponentFactory.h"
// needed for creating list
#include "CMIDList.h"
// needed for creating choice group
#include "CMIDChoiceGroupItem.h"
// needed for creating text editor
#include "CMIDTextEditor.h"
// needed for creating canvas graphics item
#include "CMIDCanvasGraphicsItem.h"
#include "CMIDCanvasGraphicsItemPainter.h"

CMIDComponentFactory::CMIDComponentFactory() : iUtils(NULL)
{
}

CMIDComponentFactory::~CMIDComponentFactory()
{
    displayableCreated = EFalse;
    delete iUIManager;
    if (iUtils)
    {
        iUtils->Dispose();
        iUtils = NULL;
    }
}

/**
 *
 * ComponentFactory implementation
 *
 */
void CMIDComponentFactory::ConstructL(MMIDEnv& aEnv)
{
    iEnv = &aEnv;
    displayableCreated = EFalse;
    iUIManager = CMIDUIManager::NewL(aEnv);
}

MMIDDisplayable* CMIDComponentFactory::CreateDisplayableL()
{
    return CMIDDisplayable::NewL(*iEnv,*iUIManager);
}

MMIDCanvas* CMIDComponentFactory::CreateCanvasL(
    MMIDDisplayable& aDisplayable,MMIDComponent::TType aCanvasType)
{
    CCoeControl& window = static_cast< CMIDDisplayable& >(aDisplayable).ContentWindow();
    displayableCreated = ETrue;
    return CMIDCanvas::NewL(*iEnv, window, aCanvasType);
}

MMIDAlert* CMIDComponentFactory::CreateAlertL(MMIDDisplayable& aDisplayable,MMIDAlert::TAlertType aType,const TDesC& aString,MMIDImage* aImage)
{
    if (!iUIManager->OpenMenuHandlerL()->GetDisplayable() && !displayableCreated)
    {
        iUIManager->OpenDefaultDisplayableL(ETrue);
    }
    return CMIDAlert::NewL(
               *iEnv, aType, aDisplayable, aString, aImage, GetUtils());
}

MMIDForm* CMIDComponentFactory::CreateFormL(MMIDDisplayable& aDisplayable)
{
    displayableCreated = ETrue;
    return CMIDForm::NewL(*iEnv,aDisplayable);
}

MMIDList* CMIDComponentFactory::CreateListL(TInt aType,MMIDDisplayable& aDisplayable,RArray<TPtrC>& aStringArray, RArray<MMIDImage*>& aImageArray)
{
    displayableCreated = ETrue;
    return CMIDList::NewL(*iEnv,aDisplayable,aType,aStringArray,aImageArray);
}

MMIDTextBox* CMIDComponentFactory::CreateTextBoxL(TInt aConstraints, TInt aMaxSize, const TDesC& aText, MMIDDisplayable& aDisplayable)
{
    if (iEnv->MidletAttributeContainsVal(LcduiMidletAttributes::KAttribUIEnhancement, LcduiMidletAttributeValues::KUIEnhFullScreenTextBox))
    {
        return CMIDTextBoxControl::NewL(aConstraints, aText, aMaxSize, &aDisplayable);
    }
    else
    {
        if (!iUIManager->OpenMenuHandlerL()->GetDisplayable() && !displayableCreated)
        {
            iUIManager->OpenDefaultDisplayableL(ETrue);
        }
        return CMIDTextBoxDialogControl::NewL(aConstraints, aText, aMaxSize, &aDisplayable);
    }
}

MMIDImageItem* CMIDComponentFactory::CreateImageItemL(
    const TDesC& aLabel, MMIDImage* aImage, MMIDItem::TLayout aLayout,
    MMIDItem::TAppearance aAppearance, const TDesC& aAltText)
{
    return CMIDImageItem::NewL(aLabel, aImage, aLayout, aAppearance, aAltText, iUIManager);
}

MMIDCustomItem* CMIDComponentFactory::CreateCustomItemL(const TDesC& aLabel)
{
    return CMIDCustomItem::NewL(*iEnv, aLabel, iUIManager);
}

MMIDStringItem* CMIDComponentFactory::CreateStringItemL(const TDesC& aLabel,const TDesC& aText,MMIDItem::TAppearance aAppearance)
{
    return CMIDStringItem::NewL(aLabel, aText, aAppearance, iUIManager);
}

MMIDDateField* CMIDComponentFactory::CreateDateFieldL(
    const TDesC& aLabel, MMIDDateField::TFieldType aFieldType)
{
    return CMIDDateFieldItem::NewL(aLabel, aFieldType, iUIManager);
}

MMIDGauge* CMIDComponentFactory::CreateGaugeL(
    const TDesC& aLabel, TBool aInteractive, TInt aMaxValue, TInt aInitialValue)
{
    if (aInteractive)
    {
        return CMIDInteractiveGauge::NewL(aLabel, aMaxValue, aInitialValue, iUIManager);
    }
    else
    {
        return CMIDNonInteractiveGauge::NewL(aLabel, aMaxValue, aInitialValue , iUIManager);
    }
}

MMIDTextField* CMIDComponentFactory::CreateTextFieldL(
    const TDesC& aLabel, const TDesC& aText, TInt aConstraints, TInt aMaxSize)
{
    if (!iUIManager->OpenMenuHandlerL()->GetDisplayable())
    {
        iUIManager->OpenDefaultDisplayableL(EFalse);
    }
    return CMIDTextFieldItem::NewL(aLabel, aText, aConstraints, aMaxSize, iUIManager);
}

MMIDChoiceGroup* CMIDComponentFactory::CreateChoiceGroupL(
    const TDesC& aLabel, TInt aType, RArray<TPtrC>& aStringArray, RArray<MMIDImage*>& aImageArray)
{
    return CMIDChoiceGroupItem::NewL(
               *iEnv, aLabel, aType, aStringArray, aImageArray, iUIManager);
}

MMIDSpacer* CMIDComponentFactory::CreateSpacerL(const TSize& aMinimumSize)
{
    return CMIDSpacer::NewL(aMinimumSize, iUIManager);
}

MMIDFont* CMIDComponentFactory::CreateFontL(
    TUint aStyle, TUint aSize, TInt aFace, TBool aIsFreeSizeFont)
{
    return CMIDFont::NewL(aStyle, aSize, aFace, iUIManager, aIsFreeSizeFont);
}

MMIDTicker* CMIDComponentFactory::CreateTickerL(const TDesC& aText)
{
    return CMIDTicker::NewL(aText);
}

MMIDCommand* CMIDComponentFactory::CreateCommandL(
    const TDesC& aShortLabel, const TDesC& aLongLabel,
    MMIDCommand::TCommandType aCommandType, TInt aPriority, TInt aCommandID)
{
    return CMIDCommand::NewL(aShortLabel,aLongLabel,aCommandType,aPriority,aCommandID);
}

MMIDUtils* CMIDComponentFactory::CreateUtilsL()
{
    return CMIDUtils::NewL(*iEnv, iUIManager);
}

// ---------------------------------------------------------------------------
// CMIDComponentFactory::CreateTextEditorL
// (other items are commented in the header file)
// ---------------------------------------------------------------------------
//
MMIDTextEditor* CMIDComponentFactory::CreateTextEditorL(
    TInt aMaxSize,
    TInt aWidth,
    TInt aHeight,
    TBool aHeightInRows)
{
    DEBUG("CMIDComponentFactory::CreateTextEditorL +");

    CMIDTextEditor::TCtorParams params;

    params.iMaxSize = aMaxSize;
    params.iWidth = aWidth;
    params.iHeight = aHeight;
    params.iHeightInRows = aHeightInRows;
    params.iUtils = GetUtils();

    MMIDTextEditor* editor = CMIDTextEditor::NewL(params);

    DEBUG("CMIDComponentFactory::CreateTextEditorL -");

    return editor;
}

// ---------------------------------------------------------------------------
// CMIDComponentFactory::CreateCanvasGraphicsItemL
// (other items are commented in the header file)
// ---------------------------------------------------------------------------
//
MMIDCanvasGraphicsItem* CMIDComponentFactory::CreateCanvasGraphicsItemL(
    MMIDCanvasGraphicsItemPainter* aItemPainter)
{
    DEBUG("CMIDComponentFactory::CreateCanvasGraphicsItemL +");

    CMIDCanvasGraphicsItem::TCtorParams params;

    params.iPainterHandle =
        static_cast<CMIDCanvasGraphicsItemPainter*>(aItemPainter);
    params.iUtils = GetUtils();

    MMIDCanvasGraphicsItem* item = CMIDCanvasGraphicsItem::NewL(params);

    DEBUG("CMIDComponentFactory::CreateCanvasGraphicsItemL -");

    return item;
}

// ---------------------------------------------------------------------------
// CMIDComponentFactory::CreateCanvasGraphicsItemPainterL
// (other items are commented in the header file)
// ---------------------------------------------------------------------------
//
MMIDCanvasGraphicsItemPainter*
CMIDComponentFactory::CreateCanvasGraphicsItemPainterL(
    TInt aWidth,
    TInt aHeight)
{
    DEBUG("CMIDComponentFactory::CreateCanvasGraphicsItemPainterL +");

    CMIDCanvasGraphicsItemPainter::TCtorParams params;

    params.iWidth = aWidth;
    params.iHeight = aHeight;
    params.iEnv = iEnv;

    MMIDCanvasGraphicsItemPainter* itemPainter =
        CMIDCanvasGraphicsItemPainter::NewL(params);

    DEBUG("CMIDComponentFactory::CreateCanvasGraphicsItemPainterL -");

    return itemPainter;
}

void CMIDComponentFactory::Dispose()
{
    delete this;
}

CMIDUtils* CMIDComponentFactory::GetUtils()
{
    // If iUtils is not initialized, this method will initialized it.
    if (!iUtils)
    {

        TRAPD(err, iUtils = static_cast<CMIDUtils*>(CreateUtilsL()));
        if (err != KErrNone)
        {
            DEBUG_INT("CMIDComponentFactory::GetUtils - error %d", err);
            iUtils = NULL;
        }

    }
    // Return shared instance of CMIDUtils: iUtils.
    return iUtils;
}

// End of File