/*

* Copyright (c) 2003-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:  Implements the Form LCDUI component.

*

*/

//RD_SCALABLE_UI definition

#include <bldvariant.hrh>

// using CEikScrollBarFrame API for iSBFrame

#include <eiksbfrm.h>

// API used for retrieving layout for initial alignment (in ConstructL)

#include <centralrepository.h>

// constants used in retrieving layout for initial alignment (in ConstructL)

#include <AvkonInternalCRKeys.h>

// control context that provides a layout background

#include <AknsListBoxBackgroundControlContext.h>

// highlight background

#include <AknsFrameBackgroundControlContext.h>

// API for text formatting used in DrawNoDataStringL function

#include <AknBidiTextUtils.h>

#include "CMIDForm.h"

#include "CMIDFormRow.h"

// API for iDisplayable

#include "CMIDDisplayable.h"

#include "CMIDItem.h"

#include "CMIDControlItem.h"

#include "CMIDGaugeItem.h"

#include "CMIDImageItem.h"

#include "CMIDStringItem.h"

// CMIDLabelContainerItem API used to obtain CMIDStringItem item

#include "CMIDLabelContainerItem.h"

#include "CMIDTextFieldItem.h"

#include "CMIDChoiceGroupItem.h"

#include "CMIDSpacer.h"

#include "CMIDCustomItem.h"

#include "CMIDDateFieldItem.h"

#include "CMIDComponentFactory.h"

#include "CMIDUtils.h"

#include "CMIDItemLabel.h"

#include "CMIDTicker.h"

#include "CMIDFont.h"

#include "CMIDPopupNoteController.h"

// Kinetic scrolling

#include "CMIDFormPhysics.h"

#include <applayout.cdl.h>

// LAF

#include <aknlayoutscalable_avkon.cdl.h>

// LAF

#include <layoutmetadata.cdl.h>

// Api for skin layout

#include <skinlayout.cdl.h>

using namespace SkinLayout;

#include <j2me/jdebug.h>

#undef  TRAP_INSTRUMENTATION_LEAVE

#define TRAP_INSTRUMENTATION_LEAVE(aResult) DEBUG_INT2("In CMIDForm.cpp, trapped method was called at line %D and got exception %D", __LINE__, aResult);

#ifdef RD_SCALABLE_UI_V2

/** Dividers used when the the scroll amount is calculated*/

const TInt KScrollAmountDivider = 4;

const TInt KScrollAmountDividerForThumbDrag = 10;

/** Interval for scrolling when stylus is dragged outside the form and held down */

const TInt KScrollInterval = 100000; // 0,1 sec

#endif //RD_SCALABLE_UI_V2

/** The minimum amount to scroll */

const TInt KMinScrollAmount = 40;

/** The timeout in microseconds for visual updates. When items are added or removed

or modified, the form is not redrawn immediately but only after this timeout. This way

if more items are being added or removed or changed we reduce the number of redraws.

*/

const TInt KLayoutTimeout = 60000; //60 msecs

/** If layout has been requested for a period longer than the cap then perform layout

even if the midlet is still performing form insert/delete operations. */

const TInt KLayoutCap = 1000000; // 1 sec

///////////////////////////////////////////////////////////////////////////////////////////////////

// MMIDForm interface

///////////////////////////////////////////////////////////////////////////////////////////////////

/**

 * Add items list. Note: this is no longer called by framework!!

 */

void CMIDForm::SetAllItemsL(const RArray<MMIDItem*>& aItems)

{

    DEBUG("CMIDForm::SetAllItemsL");

    ASSERT(iItems.Count() == 0);

    //

    TInt count = aItems.Count();

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

    {

        User::LeaveIfError(iItems.Append(aItems[i]));

        CMIDControlItem& ci = ControlItem(i);

        AddItemToFormL(ci);

        ci.MakeVisible(ETrue);

    }

    RequestLayoutL();

}

/**

 * Replaces an item. Keeps the same item focused which had focus before,

 * and if that's the one that this is replacing, then this will be focused

 * if possible.

 */

void CMIDForm::SetItemL(MMIDItem& aItem,TInt aIndex)

{

    DEBUG("CMIDForm::SetItemL");

    CMIDControlItem& oldCi = ControlItem(aIndex);

    RemoveItemFromForm(oldCi);

    iItems[aIndex] = &aItem;

    CMIDControlItem& ci = ControlItem(aIndex);

    AddItemToFormL(ci);

    ci.MakeVisible(ETrue);

    if (iFocused == aIndex)

    {

        iDisplayable.MenuHandler()->HideMenuIfVisible();

        if (ci.IsSelectable())

        {

            SetFocusedItem(aIndex);

        }

        else

        {

            SetFocusedItem(KErrNotFound);

        }

    }

    RequestLayoutL();

}

/**

 * Inserts a new Item.

 */

void CMIDForm::InsertItemL(MMIDItem& aItem,TInt aIndex)

{

    DEBUG("CMIDForm::InsertItemL");

    User::LeaveIfError(iItems.Insert(&aItem,aIndex));

    CMIDControlItem& ci = ControlItem(aIndex);

    AddItemToFormL(ci);

    ci.MakeVisible(ETrue);

    // if insert item then index of pointed control is increase

    if (aIndex <= iIndexPointedControl)

    {

        iIndexPointedControl++;

    }

    // If there isn't any focused item yet, we have to set focus

    // to first item which is focusable. Once the item has focus,

    // we can skip this step.

    if (iFocused == KErrNotFound)

    {

        SetFocusedItem(ci.IsSelectable() ? aIndex : KErrNotFound);

    }

    RequestLayoutL();

}

void CMIDForm::DeleteItemL(TInt aIndex)

{

    DEBUG("CMIDForm::DeleteItemL");

    TBool updateFocused = EFalse;

    // if delete item then index of pointed control is decrease

    if (iIndexPointedControl > aIndex)

    {

        iIndexPointedControl--;

    }

    else

        // if delete item is same as index of pointed control then index is set to not active

    {

        if (iIndexPointedControl == aIndex)

        {

            iIndexPointedControl = -1;

        }

    }

    if (iFocused > aIndex)

    {

        iFocused--;

    }

    else if (iFocused == aIndex)

    {

        iDisplayable.MenuHandler()->HideMenuIfVisible();

        ReplaceFocusedItem();

        updateFocused = ETrue;

    }

    CMIDControlItem& ci = ControlItem(aIndex);

    RemoveItemFromForm(ci);

    if (&ci == iPointedControl)

    {

        iPointedControl = NULL;

    }

    iItems.Remove(aIndex);

    if (iFocused != KErrNotFound && updateFocused)

    {

        iFocused--;

    }

    RequestLayoutL();

}

void CMIDForm::DeleteAllItemsL()

{

    DEBUG("CMIDForm::DeleteAllItemsL");

    iDisplayable.MenuHandler()->HideMenuIfVisible();

    SetFocusedItem(KErrNotFound);

    TInt itemCount = iItems.Count();

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

    {

        CMIDControlItem& ci = ControlItem(i);

        RemoveItemFromForm(ci);

    }

    iItems.Reset();

    iScroll = 0;

    // if delete all then index of pointed control is set to not active

    iIndexPointedControl = -1;

    iPointedControl = NULL;

    RequestLayoutL();

}

/**

 * Called when the item has changed its appearance in some way.

 */

void CMIDForm::RefreshItemL(TInt aIndex)

{

    DEBUG("CMIDForm::RefreshItemL");

    if (aIndex != KErrNotFound)

    {

        RequestLayoutL();

    }

}

/**

 * Returns whether the item is actually visible to the user. Must therefore take into

 * account the visibility of the entire form, and whether the specific item is scrolled

 * in/out of the viewable area.

 */

TBool CMIDForm::IsItemVisible(TInt aIndex)

{

    DEBUG("CMIDForm::IsItemVisible");

    CMIDControlItem& control = ControlItem(aIndex);

    if ((control.Position().iY > Height()) ||

            ((control.Position().iY + control.Size().iHeight) < 0))

    {

        return EFalse;

    }

    return ETrue;

}

/**

 * Called prior to the Form itself being made the current Displayable.

 * It provides an opportunity to prepare the form such that this item will

 * be visible and focused when the form is eventually made current

 */

void CMIDForm::SetCurrentItemL(TInt aIndex)

{

    DEBUG("CMIDForm::SetCurrentItemL");

    // If it is pending request for layout, than layout now.

    if (LayoutPending())

    {

        LayoutAndDrawL();

    }

    // Set focus of item to aIndex and scroll to it.

    SetFocusedItem(aIndex);

}

//

// End of MMIDForm interface

//

TInt CMIDForm::CountComponentControls() const

{

    return iRows.Count();

}

CCoeControl* CMIDForm::ComponentControl(TInt aIndex) const

{

    return iRows[aIndex];

}

TKeyResponse CMIDForm::OfferKeyEventL(const TKeyEvent& aKeyEvent,TEventCode aType)

{

    DEBUG("< CMIDForm::OfferKeyEventL");

    TBool isArrowKey = (aKeyEvent.iCode == EKeyDownArrow || aKeyEvent.iCode == EKeyUpArrow ||

                        aKeyEvent.iCode == EKeyLeftArrow || aKeyEvent.iCode == EKeyRightArrow);

    if (iFocused != KErrNotFound)

    {

        CMIDControlItem& controlItem = ControlItem(iFocused);

        TRect controlRect = GetControlRect(iFocused);

        TBool visible = RectPartiallyVisible(controlRect);

        // arrow key events are not sent to the hidden focused item

        if ((visible || !isArrowKey) &&

                controlItem.OfferKeyEventL(aKeyEvent,aType) == EKeyWasConsumed)

        {

            DEBUG("CMIDForm::OfferKeyEventL - out after item consumed key");

#ifdef RD_SCALABLE_UI_V2

            // If focused TextField or DateField item is at least partly out of

            // Form viewport, then key event (excluding arrow keys and soft keys)

            // scrolls the item completely visible. This situation

            // is possible when scrolling has been done with scrollbar.

            // Soft keys and arrow keys are ignored. Filtering must be done comparing

            // scan codes because the aEventType.iCode is not available for all key presses.

            TBool ignoreKey = (aKeyEvent.iScanCode == EStdKeyRightArrow ||

                               aKeyEvent.iScanCode == EStdKeyUpArrow ||

                               aKeyEvent.iScanCode == EStdKeyDownArrow ||

                               aKeyEvent.iScanCode == EStdKeyLeftArrow ||

                               aKeyEvent.iScanCode == EStdKeyDevice0 ||

                               aKeyEvent.iScanCode == EStdKeyDevice1 ||

                               aKeyEvent.iScanCode == EStdKeyDevice3);

            if ((controlItem.Type() == MMIDComponent::ETextField ||

                    controlItem.Type() == MMIDComponent::EDateField) &&

                    !RectFullyVisible(controlRect) && !ignoreKey)

            {

                // Scroll up if controlItem is above the Form viewport.

                // Otherwise scroll down.

                if (controlRect.iTl.iY < 0)

                {

                    ScrollToFocused(EUp, ETrue);

                }

                else

                {

                    ScrollToFocused(EDown, ETrue);

                }

            }

#endif // RD_SCALABLE_UI_V2

            return EKeyWasConsumed;

        }

    }

    DEBUG("CMIDForm::OfferKeyEventL - got chance to scroll");

    if ((aType == EEventKey) && isArrowKey && (iItems.Count() > 0))

    {

        DEBUG("CMIDForm::OfferKeyEventL - about to call Traverse");

        Traverse(ConvertKeyToDirection(aKeyEvent.iCode));

        DEBUG("CMIDForm::OfferKeyEventL - out after Traverse");

        return EKeyWasConsumed;

    }

    // msk: this is needed if MSK is not enabled

    if ((aType == EEventKey) &&

            ((aKeyEvent.iScanCode == EStdKeyDevice3) || (aKeyEvent.iCode == EKeyEnter))

       )

    {

        if (!DoDefaultCommand())

        {

            iDisplayable.ShowOkOptionsMenuL();

        }

        DEBUG("CMIDForm::OfferKeyEventL - out after default command or ok menu");

        return EKeyWasConsumed;

    }

    // end msk

    DEBUG("> CMIDForm::OfferKeyEventL");

    return EKeyWasNotConsumed;

}

/**  Handle a focus change. Make sure there is no layout pending and if there is

one then do it, see TrappedLayoutAndDraw(). This is because when there is a layout

pending we are in a temporary inconsistent phase with no rows and the rows are the

intermediary to the items via the CountComponentControl() and ComponentControl() calls.

Then pass on focus to our children according to the value stored in iFocused. Finally

update the scroll bars if gaining focus and draw. */

void CMIDForm::FocusChanged(TDrawNow /*aDrawNow*/)

{

    DEBUG("CMIDForm::FocusChanged");

    TrappedLayoutAndDraw(ETrue);

    TInt i = -1;

    TInt itemCount = iItems.Count();

    while (++i < itemCount)

    {

        if (i == iFocused)

        {

            ControlItem(iFocused).SetFocus(IsFocused());

        }

        else

        {

            ControlItem(i).SetFocus(EFalse);

        }

    }

    // make sure scrollbar is up to date when we get focus

    if (IsFocused())

    {

        UpdateScrollBar();

    }

    DrawNow();

}

void CMIDForm::SizeChanged()

{

    DEBUG("CMIDForm::SizeChanged");

    iBackgroundControlContext->SetParentPos(PositionRelativeToScreen()) ;

    iBackgroundControlContext->SetRect(Rect()) ;

}

/** Before calling CCoeControl::InputCapabilities(), make sure there is

no outstanding layout. This is because if there is one outstanding, we have

no rows and hence ComponentControls() returns zero. This means that, for example

if there are any editors in the items, CCoeControl::InputCapabilities() will not

reach them and the FEP will not be initialised. @see TrappedLayoutAndDraw(),

CCoeControl::InputCapabilities(), CAknFepManager::HandleChangeInFocusL() and

CCoeAppUi::InputCapabilities() */

TCoeInputCapabilities CMIDForm::InputCapabilities() const

{

    if (iFocused != KErrNotFound)

    {

        return ControlItem(iFocused).InputCapabilities();

    }

    return     CCoeControl::InputCapabilities(); //TCoeInputCapabilities::ENone

}

TTypeUid::Ptr CMIDForm::MopSupplyObject(TTypeUid aId)

{

    if (aId.iUid == MAknsControlContext::ETypeId && iBackgroundControlContext)

    {

        return MAknsControlContext::SupplyMopObject(aId, iBackgroundControlContext);

    }

    CMIDMenuHandler* menuHandler = iDisplayable.MenuHandler();

    return SupplyMopObject(aId, menuHandler->Cba(), menuHandler->MenuBar());

}

#ifdef RD_SCALABLE_UI_V2

void CMIDForm::HandlePointerEventL(const TPointerEvent& aPointerEvent)

{

    if (!AknLayoutUtils::PenEnabled())

    {

        return;

    }

    if (iPhysics)

    {

        HandlePhysicsPointerEventL(aPointerEvent);

        return;

    }

    switch (aPointerEvent.iType)

    {

    case TPointerEvent::EButton1Down:

    {

        DEBUG_INT3("CMIDForm::HandlePointerEventL(): event=%D, x,y=%D,%D",

                   aPointerEvent.iType, aPointerEvent.iPosition.iX, aPointerEvent.iPosition.iY);

        iLastValidPointerEvent = aPointerEvent;

        CMIDControlItem* ci = ControlItemAtPoint(aPointerEvent.iPosition);

        // stored on ButtonDown value

        if (ci && ci->IsSelectable())

        {

            TInt itemIndex = ItemIndex(*ci);

            iIndexPointedControl = itemIndex;

            iLastValidPointedItemPosition = ci->Position();

            TBool changeFocus = (itemIndex != iFocused);

            if (changeFocus)

            {

                // changing the focused item by dragging must start from unfocused item

                iCanDragFocus = ETrue;

                iFocusChangingWithPen = ETrue;

                // give basic tactile feedback on button down when move focus

#ifdef RD_TACTILE_FEEDBACK

                DoFeedbackOnFocusChange(*ci);

#endif // RD_TACTILE_FEEDBACK

                SetFocusedItem(itemIndex, ENone, EFalse);

            }

            TInt scroll = ScrollDistanceToTappedItem(ci);

            iScrollOnPointerDown = (scroll != 0);