/*

* Copyright (c) 2003-2009 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

*

*/

#include <coemain.h>

#include <eiklabel.h>

#include <hal.h>

#include <AknsDrawUtils.h>// skin

#include <AknsBasicBackgroundControlContext.h> //skin

#ifdef RD_INTELLIGENT_TEXT_INPUT

#include <PtiEngine.h>

#endif //RD_INTELLIGENT_TEXT_INPUT

#include "CMIDForm.h"

#include "CMIDFormPhysics.h"

#include "CMIDCustomItem.h"

// API for iLabelControl

#include "CMIDItemLabel.h"

// API needed for retrieving current displayable from iForm when background drawing

#include "CMIDDisplayable.h"

// retrieving CMIDRemConObserver from CMIDKeyDecoder

#include "CMIDKeyDecoder.h"

// needed for adding (removing) media keys observer to remConObserver

#include "CMIDRemConObserver.h"

#include "CMIDUIManager.h"

#include <eikenv.h>

#include <j2me/jdebug.h>

// LAF

// AknLayoutScalable_Avkon::form2_midp_content_pane

#include <aknlayoutscalable_avkon.cdl.h>

#ifdef RD_JAVA_ADVANCED_TACTILE_FEEDBACK

#include <touchfeedback.h>

#endif //RD_JAVA_ADVANCED_TACTILE_FEEDBACK

/** The custom item uses a different value for limiting the max sizes because

it needs to draw bitmaps with these sizes. @see KMaxScreenSizeFactor */

const TInt KCIMaxScreenSizeFactor = 2;

CMIDCustomItem* CMIDCustomItem::NewL(

    MMIDEnv& aEnv, const TDesC& aLabel, CMIDUIManager* aUIManager)

{

    CMIDCustomItem* item = new(ELeave) CMIDCustomItem(aEnv, aUIManager);

    CleanupStack::PushL(item);

    item->ConstructL(aLabel);

    CleanupStack::Pop(item);

    return item;

}

CMIDCustomItem::CMIDCustomItem(MMIDEnv& aEnv, CMIDUIManager* aUIManager)

        : CMIDControlItem(EDefault, aUIManager)

        , iEntered(EFalse)

        , iSupportsInternalTraversal(ETrue)

        , iEnv(aEnv)

        , iResetFrameBuffer(ETrue)

        , iDirectAreaAddedToDisplayable(EFalse)

        , iS60SelectionKeyCompatibility(EFalse)

#ifndef RD_JAVA_NGA_ENABLED

        , iDirectPaused(ETrue)

#endif

        , iRestoreDirectContentWhenUnfaded(EFalse)

        , iPreviousVisibility(EFalse)

        , iConsumerWaitingForDSAResourcesCallback(NULL)

{

    iMMidItem = this;

    //Default values for PointerEventSuppressor

    iPESPointerMovementInTwips = CMIDUIManager::EPESPointerMovementInTwips;

    iPESTimeInMilliseconds = CMIDUIManager:: EPESTimeInMilliseconds;

}

void CMIDCustomItem::ConstructL(const TDesC& aLabel)

{

    DEBUG("< CMIDCustomItem::ConstructL");

    CMIDControlItem::ConstructL();

    SetLabelL(aLabel);

    UpdateMargins();

    ActivateL();

    // CustomItem listens media key events if CMIDRemConObserver is initialized and media keys keys are enabled

    ASSERT(iMenuHandler);

    ASSERT(iUIManager);

    iKeyDecoder = iUIManager->OpenKeyDecoderL();

    ASSERT(iKeyDecoder);

    iRemConObserver = iKeyDecoder->GetRemConObserver();

    if (iRemConObserver && iKeyDecoder->MediaKeysEnabled())

    {

        iRemConObserver->AddMediaKeysListenerL(static_cast<MMIDMediaKeysListener*>(this));

    }

#ifdef RD_TACTILE_FEEDBACK

    iTactileFeedback = new(ELeave) CMIDTactileFeedbackExtension(this, 2);

#endif

    //Create PointerEventSuppressor with default values or JAD parameter defined values

    iPointerEventSuppressor = CAknPointerEventSuppressor::NewL();

    TInt pointerMovementInPixels =

        ControlEnv()->ScreenDevice()->HorizontalTwipsToPixels(iPESPointerMovementInTwips);

    TSize suppressorValues =

        iUIManager->ReadPointerEventSuppressorValues();

    if (!(suppressorValues.iWidth == KPESErrorValue &&

            suppressorValues.iHeight == KPESErrorValue))

    {

        iPESTimeInMilliseconds = suppressorValues.iHeight;

        pointerMovementInPixels =

            ControlEnv()->ScreenDevice()->HorizontalTwipsToPixels(suppressorValues.iWidth);

    }

    iPointerEventSuppressor->SetMaxTapDuration(iPESTimeInMilliseconds * 1000);

    iPointerEventSuppressor->SetMaxTapMove(TSize(pointerMovementInPixels,

                                           pointerMovementInPixels));

    DEBUG("> CMIDCustomItem::ConstructL");

}

void  CMIDCustomItem::UpdateMargins()

{

    TAknWindowLineLayout layout =

        AknLayoutScalable_Avkon::form2_midp_content_pane(1).LayoutLine();

    iContentMargins.iTop    = layout.it;

    iContentMargins.iLeft   = layout.il;

    iContentMargins.iRight  = layout.ir;

    iContentMargins.iBottom = layout.ib;

}

/** */

void CMIDCustomItem::ResetBuffers()

{

    delete iFrameBuffer;

    delete iFrameContext;

    delete iFrameDevice;

    iFrameBuffer  = NULL;

    iFrameContext = NULL;

    iFrameDevice  = NULL;

    delete iOffScreenBuffer;

    delete iOffScreenContext;

    delete iOffScreenDevice;

    iOffScreenBuffer  = NULL;

    iOffScreenContext = NULL;

    iOffScreenDevice  = NULL;

}

/** Creates the frame buffer with its associated device and context and the

offscreen buffer with its device and context. They are both of the same size,

the size of the content rect. The skin background is then printed on the

frame buffer via the frame context.

Note: This method is called each time the content size changes. If it leaves

it is trapped in SizeChanged() and then ResetBuffers() is called so that we

are not left in an unconsistent situation in Out Of Memory. So care must be

taken in the code to always check that the buffers or their devices or contextes

do exist - because they may not exist in OOM.

*/

void CMIDCustomItem::CreateBuffersL()

{

    DEBUG("< CMIDCustomItem::CreateBuffersL");

    ResetBuffers();

    TRect rect = TRect(0,0,iContentRect.Size().iWidth, iContentRect.Size().iHeight);

    iFrameBuffer = new(ELeave) CFbsBitmap;

    User::LeaveIfError(iFrameBuffer->Create(rect.Size(), iEnv.DisplayMode()));

    iFrameDevice = CFbsBitmapDevice::NewL(iFrameBuffer);

    User::LeaveIfError(iFrameDevice->CreateContext(iFrameContext));

    iOffScreenBuffer = new(ELeave) CFbsBitmap;

    User::LeaveIfError(iOffScreenBuffer->Create(rect.Size(), iEnv.DisplayMode()));

    iOffScreenDevice = CFbsBitmapDevice::NewL(iOffScreenBuffer);

    User::LeaveIfError(iOffScreenDevice->CreateContext(iOffScreenContext));

    if (iForm)

    {

        AknsDrawUtils::DrawBackground(AknsUtils::SkinInstance(),

                                      iForm->CurrentDisplayable().BackGroundControlContext(), this,

                                      *iFrameContext, TPoint(0,0), iContentRect, KAknsDrawParamDefault);

    }

    DEBUG("> CMIDCustomItem::CreateBuffersL");

}

// Start Direct screen access in order to switch off Transition effects,

// which could damage the DSA (video)

void CMIDCustomItem::SetContainerWindowL(const CCoeControl& aWindow)

{

    DEBUG("< CMIDCustomItem::SetContainerWindowL");

#ifndef RD_JAVA_NGA_ENABLED

    if (iDirectAccess)

    {

        iDirectAccess->Cancel();

        delete iDirectAccess;

        iDirectAccess = NULL;

    }

#endif

    CMIDControlItem::SetContainerWindowL(aWindow);

#ifndef RD_JAVA_NGA_ENABLED

    RWsSession&      session = ControlEnv()->WsSession();

    CWsScreenDevice* device  = ControlEnv()->ScreenDevice();

    iDirectAccess = CDirectScreenAccess::NewL(

                        session,

                        *device,

                        *DrawableWindow(),

                        *this

                    );

#endif

    if (iConsumerWaitingForDSAResourcesCallback)

    {

        // Invoke the pending callback from LCDUI ES thread

        iEnv.ToLcduiObserver().InvokeDSAResourcesCallback(

            *this, *iConsumerWaitingForDSAResourcesCallback);

        iConsumerWaitingForDSAResourcesCallback = NULL;

    }

    DEBUG("> CMIDCustomItem::SetContainerWindowL");

}

CMIDCustomItem::~CMIDCustomItem()

{

    DEBUG("< CMIDCustomItem::~CMIDCustomItem");

    if (iDirectContent)

    {

        iDirectContent->MdcContainerDestroyed();

    }

#ifndef RD_JAVA_NGA_ENABLED

    if (iDirectAccess)

    {

        iDirectAccess->Cancel();

        delete iDirectAccess;

        iDirectAccess = NULL;

    }

#endif

    ResetBuffers();

    // CustomItem removes itself from the CMIDRemConObserver.

    ASSERT(iKeyDecoder);

    if (iRemConObserver && iKeyDecoder->MediaKeysEnabled())

    {

        iRemConObserver->RemoveMediaKeysListener(static_cast<MMIDMediaKeysListener*>(this));

    }

#ifdef RD_TACTILE_FEEDBACK

    delete iTactileFeedback;

#endif

    if (iPointerEventSuppressor)

    {

        delete iPointerEventSuppressor;

        iPointerEventSuppressor = NULL;

    }

    DEBUG("> CMIDCustomItem::~CMIDCustomItem");

}

/**

 *

 */

TInt CMIDCustomItem::ItemPreferredHeightWithoutLabel()

{

    return PreferredContentSize().iHeight + iContentMargins.iTop + iContentMargins.iBottom;

}

/**

 * Gets the available interaction modes. This method is intended to be called by

 * CustomItem subclass code in order for it to determine what kinds of input are

 * available from this device

 */

TInt CMIDCustomItem::InteractionModes() const

{

    DEBUG("< CMIDCustomItem::InteractionModes");

    TInt modes = 0;

    if (AknLayoutUtils::PenEnabled())

    {

        // Drag is not supported if physics scrolling is in use

        if (CMIDFormPhysics::FeatureEnabled())

        {

            modes |= ETraverseHorizontal | ETraverseVertical |

                     EPointerPress | EPointerRelease;

        }

        else

        {

            modes |= ETraverseHorizontal | ETraverseVertical |

                     EPointerPress | EPointerRelease | EPointerDrag;

        }

    }

    TRAP_IGNORE(modes |= KeyboardInteractionModesL());

    DEBUG_INT("> CMIDCustomItem::InteractionModes = %d", modes);

    return modes;

}

TInt CMIDCustomItem::KeyboardInteractionModesL() const

{

    DEBUG("< CMIDCustomItem::KeyboardInteractionModesL");

    TInt modes = 0;

#ifdef RD_INTELLIGENT_TEXT_INPUT

    RArray<TPtiKeyboardType> keyboards;

    CleanupClosePushL(keyboards);

    CPtiEngine* ptiEngine = CPtiEngine::NewL();

    CleanupStack::PushL(ptiEngine);

    ptiEngine->ListAvailablePhysicalKeyboardsL(keyboards);

    if (keyboards.Count() > 0)

    {

        modes |= ETraverseHorizontal | ETraverseVertical |

                 EKeyPress | EKeyRelease | EKeyRepeat;

    }

    CleanupStack::PopAndDestroy(ptiEngine);

    CleanupStack::PopAndDestroy(&keyboards);

#endif //RD_INTELLIGENT_TEXT_INPUT    

    DEBUG_INT("> CMIDCustomItem::KeyboardInteractionModesL = %d", modes);

    return modes;

}

TBool CMIDCustomItem::SupportsInternalTraversal() const

{

    return iSupportsInternalTraversal;

}

/**

 * This is a return value from Traverse method in Java.

 * It returns whether it should traverse within the CustomItem and Rect that it should

 * traverse to until it returns false and traverse out of CustomItem

 */

void CMIDCustomItem::SetFocusAndScroll(TBool aFocus,const TRect* aRect,TInt aDirection)

{

    DEBUG("< CMIDCustomItem::SetFocusAndScroll");

    // Make sure we know if this CustomItem subclass supports internal traversal.

    // When the item is entered for the very first time, check what the traverse

    // method returned. If false, there is no internal traversal and we will

    // handle this based on aFocus.

    // If true, the item supports internal traversal and additional code is needed

    if (!iEntered)

    {

        // iSupportsInternalTraversal is sampled on the first call only

        iEntered = ETrue;

        iSupportsInternalTraversal = aFocus;

        // this will ensure that we get the focus on first traverse

        aFocus = ETrue;

        // Form must be updated when the focus enters to the non-traversal CustomItem for the first time.

        // The reason is that the default value of iSupportsInternalTraversal is ETrue,

        // which means that CMIDCustomItem::Draw() function has not updated focus before.

        if (iForm && !iSupportsInternalTraversal)

        {

            iForm->DrawNow();

        }

    }

    // Handle focus for items that do not support internal traversal

    if (!iSupportsInternalTraversal)

    {

        // The focus is passed from java side

        if (!aFocus && iForm)

        {

            iForm->Traverse((CMIDForm::TDirection)aDirection);

        }

        return;

    }

    // This calculates top/bottom rect for Form to scroll to.

    if (aRect && aFocus && iForm)

    {

        TRect  view = iForm->GetClientArea();

        if (aRect->iTl.iY < view.iTl.iY) //top is off screen

        {

            // scroll up so that the focused area top is at the screen top

            TInt scrollUp = view.iTl.iY - aRect->iTl.iY ;

            if (iForm)

            {

                iForm->RawScroll(scrollUp);

            }

        }

        else if (aRect->iBr.iY > view.iBr.iY) //bottom is off screen

        {

            // scroll down so that the focused area bottom is at the screen bottom

            TInt scrollDown = view.iBr.iY - aRect->iBr.iY ;

            if (iForm)

            {

                iForm->RawScroll(scrollDown);

            }

        }

    }

    // If losing focus, tell the Form to advance focus

    //

    if (!aFocus && iForm)

    {

        iForm->Traverse((CMIDForm::TDirection)aDirection);

    }

    DEBUG("> CMIDCustomItem::SetFocusAndScroll");

}

CFbsBitmap* CMIDCustomItem::FrameBuffer() const

{

    return iFrameBuffer;

}

void CMIDCustomItem::SetLabelL(const TDesC& aLabel)

{

    CMIDControlItem::SetLabelL(aLabel);

    SetPreferredSizeL(iRequestedPreferredSize);

}

/** */

void CMIDCustomItem::SetPreferredSizeL(const TSize& aSize)

{

    DEBUG("< CMIDCustomItem::SetPreferredSizeL");

    DEBUG_INT2("+ CMIDCustomItem::SetPreferredSizeL - requested size = ( %d x %d )", aSize.iWidth, aSize.iHeight);

    iRequestedPreferredSize = CheckRequestedSize(aSize);

    if (iRequestedPreferredSize.iWidth == -1)

    { // Width is not locked

        iPreferredSize.iWidth = Min(FormClientAreaWidth(),

                                    PreferredContentSize().iWidth + iContentMargins.iLeft + iContentMargins.iRight);

    }

    else

    {

        iPreferredSize.iWidth  = Min(FormClientAreaWidth(),

                                     Max(MinimumSize().iWidth, iRequestedPreferredSize.iWidth));

    }

    if (iLabelControl)

    {

        iLabelControl->SetWidthL(iPreferredSize.iWidth);

    }

    if (iRequestedPreferredSize.iHeight == -1)

    { // Height is not locked

        iPreferredSize.iHeight = PreferredContentSize().iHeight + iContentMargins.iTop

                                 + iContentMargins.iBottom + LabelHeight();

    }

    else

    {

        iPreferredSize.iHeight = Max(MinimumSize().iHeight, iRequestedPreferredSize.iHeight);

    }

    DEBUG_INT2("+ CMIDCustomItem::SetPreferredSizeL - preferred size = ( %d x %d )", iPreferredSize.iWidth, iPreferredSize.iHeight);

    TRAP_IGNORE(AdjustToSizeL(iPreferredSize));

    DEBUG("> CMIDCustomItem::SetPreferredSizeL");

}

/**

* Parameter aSize includes margins

*/

void CMIDCustomItem::AdjustToSizeL(const TSize& aSize)

{

    DEBUG("< CMIDCustomItem::AdjustToSizeL");

    TInt availableHeight = aSize.iHeight - iContentMargins.iTop - iContentMargins.iBottom;

    DEBUG_INT("+ CMIDCustomItem::AdjustToSizeL - available height = %d", availableHeight);

    TInt requestedHeight = PreferredContentSize().iHeight + LabelHeight();

    DEBUG_INT("+ CMIDCustomItem::AdjustToSizeL - requested height = %d", requestedHeight);

    if (requestedHeight > availableHeight)

    {// label + control do not fit

        if (iLabelControl && iLabelControl->Text()->Length() > 0)

        {

            //reserve one line to the control

            TInt heightForLabel =

                ((availableHeight - PreferredContentSize().iHeight) > OneLineLabelHeight()) ?

                availableHeight - PreferredContentSize().iHeight :

                availableHeight - MinimumContentSize().iHeight;

            //By setting a temporary max number of lines and then calling

            //SetWidthL() we limit the number of lines to the temporary max number

            //However then the max number must be resetted

            TInt oldMaxNumLabelLines = iLabelControl->MaxNumLines();

            iLabelControl->SetMaxNumLines(

                (heightForLabel - iLabelControl->ItemLabelMargin()) / iLabelControl->LineHeight());

            iLabelControl->SetWidthL(aSize.iWidth);

            iLabelControl->SetMaxNumLines(oldMaxNumLabelLines);

        }

    }

    DEBUG("> CMIDCustomItem::AdjustToSizeL");

}

/**

 * Updates CustomItem with new MinContentSize and PrefContentSize received

 * from CustomItem subclass

 *

 * Parameters doesn't include margins. iMinimumContentSize and iPreferredContentSize

 * doesn't include margins.

 */

void CMIDCustomItem::Invalidate(const TSize& aMinSize, const TSize& aPrefSize)

{

    DEBUG("< CMIDCustomItem::Invalidate");