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


// CEikonEnv API used in CheckRequestedSize to obtain screen size
#include <eikenv.h>

#include "CMIDComponentFactory.h"
#include "CMIDItem.h"
// API related to command list
#include "CMIDCommandList.h"
#include "CMIDCommand.h"
#include "CMIDUtils.h"
// API related to form (iForm)
#include "CMIDForm.h"
// TlsStruct for retrieving menu handler from it
// CMIDMenuHandler::GetInstance in NotifyFormAboutCommandChange
#include "CMIDMenuHandler.h"
#include "CMIDUIManager.h"

/** If the application requests a preferred size for an item,
then this size cannot be bigger than this factor times the screen
width or height. This prevents OOM situations if applications require
crazy sizes. Note: some items may further limit this maximum values,
for example custom item does. @see CheckRequestedSize */
const TInt KMaxScreenSizeFactor = 10;

void CMIDItem::ConstructL()
//
// Zero length descriptor created, even though when a label is set this will
// be subsequently destroyed. This is to simplify code, i.e. don't need to check
// for null. When all Items set their labels in their construction, then this won't
// be necessary
//
{
    iCommandList = new(ELeave) CMIDCommandList();
    iLabel = TPtrC().AllocL();
    ASSERT(iUIManager);
    iMenuHandler = iUIManager->OpenMenuHandlerL();
}

void CMIDItem::SetLabelL(const TDesC& aLabel)
{
    delete iLabel;
    iLabel = NULL;
    iLabel = aLabel.AllocL();
}

CMIDItem::CMIDItem(MMIDItem::TLayout aLayout, CMIDUIManager* aUIManager)
        :iLayout(aLayout),
        iDefaultCommand(NULL),
        iPreferredSize(-1,-1),
        iRequestedPreferredSize(-1, -1),
        iUIManager(aUIManager)
{
}

CMIDItem::~CMIDItem()
{
    delete iLabel;
    delete iCommandList;
}

void CMIDItem::AddCommandL(MMIDCommand* aCommand, TBool aFormNotification)
{
    iCommandList->AddL(aCommand);
    if (iCommandList->Count() == 1)
    {
        SetFocusing(ETrue);
        if (iForm)
        {
            iForm->SetFocusedItemIfNone(this);
        }
    }
    if (aFormNotification)
    {
        NotifyFormAboutCommandChange();
    }
}

void CMIDItem::RemoveCommand(MMIDCommand* aCommand, TBool aFormNotification)
{
    iCommandList->Remove(aCommand);
    if (iCommandList->Count() == 0)
    {
        if ((iMMidItem->Type() == MMIDComponent::EImageItem) ||
                (iMMidItem->Type() == MMIDComponent::ECustomItem) ||
                (iMMidItem->Type() == MMIDComponent::EStringItem))
        {
            SetFocusing(EFalse);
            if (iForm)
            {
                iForm->RemoveFocusIfFocused(this);
            }
        }
        if (iForm)
        {
            DrawDeferred(); //because these items change appearance when no cmds
        }
    }
    if (aFormNotification)
    {
        NotifyFormAboutCommandChange();
    }
}

/**
 * Default implementation is empty. Subclasses provide meaningful implementations.
 **/
TBool CMIDItem::ProcessCommandL(CMIDCommand* /* aCommand */)
{
    return ETrue;
}

CMIDUIManager* CMIDItem::GetUIManager() const
{
    return iUIManager;
}

void CMIDItem::SetDefaultCommand(MMIDCommand* aCommand)
{
    iDefaultCommand = static_cast<CMIDCommand*>(aCommand);
    NotifyFormAboutCommandChange();
}

void CMIDItem::SetBuiltInMSKCommand(CMIDCommand* aCommand)
{
    iBuiltInMSKCommand = aCommand;
    NotifyFormAboutCommandChange();
}

CMIDCommand* CMIDItem::GetMSKCommand() const
{
    CMIDCommand* mskCmd = iBuiltInMSKCommand ? iBuiltInMSKCommand : iDefaultCommand;
    return mskCmd;
}

void CMIDItem::NotifyFormAboutCommandChange()
{
    if (iForm && iForm->IsCurrentItem(this))
    {
        iForm->UpdateItemCommands(iCommandList, GetMSKCommand());
        TRAP_IGNORE(iMenuHandler->UpdateMenuIfVisibleL());
    }
}

void CMIDItem::SetPreferredSize(const TSize& aSize,const TSize& aMinimumSize)
{
    iRequestedPreferredSize = CheckRequestedSize(aSize);

    // If aSize is less than aMinimumSize (per dimension), then the minimum size is used
    iPreferredSize.iHeight = Max(aSize.iHeight,aMinimumSize.iHeight);
    iPreferredSize.iWidth = Max(aSize.iWidth,aMinimumSize.iWidth);
    // Once the item has been added to a form, it's preferred size can be clipped
    // to the width of the form.
    if (iForm)
    {
        iPreferredSize.iWidth = Min(iForm->Width(),iPreferredSize.iWidth);
    }
}

void CMIDItem::SetForm(CMIDForm* aForm)
{
    iForm = aForm;
}

/** If the specified height or width or the requested size are bigger that the
screen height or width times KMaxScreenSizeFactor then return these limit values.
Otherwise return the size unchanged. @see KMaxScreenSizeFactor */
TSize CMIDItem::CheckRequestedSize(const TSize& aRequestedSize) const
{
    TSize size = aRequestedSize;
    const TSize screenSize = iEikonEnv->ScreenDevice()->SizeInPixels();

    size.iWidth = size.iWidth < KMaxScreenSizeFactor * screenSize.iWidth ?
                  size.iWidth : KMaxScreenSizeFactor * screenSize.iWidth;

    size.iHeight = size.iHeight < KMaxScreenSizeFactor * screenSize.iHeight ?
                   size.iHeight : KMaxScreenSizeFactor * screenSize.iHeight;

    return size;
}

TPtrC CMIDItem::Label() const
{
    return *iLabel;
}

void CMIDItem::SetLayoutL(MMIDItem::TLayout aLayout)
{
    iLayout = aLayout;
}

TInt CMIDItem::Type()
{
    if (iMMidItem)
    {
        return (TInt)(iMMidItem->Type());
    }
    return 0;
}

MMIDItem::TLayout CMIDItem::Layout() const
{
    return iLayout;
}

CMIDCommandList* CMIDItem::CommandList() const
{
    return iCommandList;
}

CMIDCommand* CMIDItem::DefaultCommand() const
{
    return iDefaultCommand;
}

CMIDForm* CMIDItem::Form() const
{
    return iForm;
}

void CMIDItem::ItemAddedToFormL()
{
}

void CMIDItem::ItemRemovedFromForm()
{
}

void CMIDItem::HandleCurrentL(TBool /*aCurrent*/)
{
}

void CMIDItem::NotifyScrollingCompleted()
{
}

TSize CMIDItem::PreferredSize()
{
    TInt height = Max(iPreferredSize.iHeight, MinimumSize().iHeight);
    TInt width = Max(iPreferredSize.iWidth, MinimumSize().iWidth);
    return TSize(width, height);
}

MMIDItem::TLayout CMIDItem::Layout()
{
    return iLayout;
}

void CMIDItem::SetPreferredWidth(TInt aWidth)
{
    iPreferredSize.iWidth = aWidth;
}

void CMIDItem::SetPreferredHeight(TInt aHeight)
{
    iPreferredSize.iHeight = aHeight;
}

// End of File