/*

* 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:  CMIDCanvas - Implements the native part of the Canvas class.

*

*/

// Using auto_ptr

#include <memory>

// API used for getting the layout for the network indicator bitmap and for

// retrieving info if pen is enabled (in CMIDCanvas::HandlePointerEventL

// function).

#include <AknUtils.h>

// Using Layout_Meta_Data::IsLandscapeOrientation()

#include <layoutmetadata.cdl.h>

// Using CRepository class used in CMIDCanvas::IsNetworkIndicatorEnabledL

// function.

#include <centralrepository.h>

#ifdef RD_JAVA_NGA_ENABLED

#include <logger.h>

#include <e32cmn.h>

#include <EGL/egl.h>

#include <GLES/gl.h>

#endif // RD_JAVA_NGA_ENABLED

// Using debug macros.

#include <j2me/jdebug.h>

// OMJ storage

#include <securitystoragedatadefs.h>

#include <javastorageentry.h>

#include <javastorage.h>

#include <javastoragenames.h>

#include <javauid.h>

#include <javasymbianoslayer.h>

#include "javaoslayer.h"

// Using constants for S60 LCDUI Plugin internal keys.

#include "S60LCDUIInternalCRKeys.h"

#include "CMIDCanvas.h"

// Using CMIDUIManager for iKeyDecoder and iScaler initialization.

#include "CMIDUIManager.h"

// Using CMIDScaler as member iScaler.

#include "CMIDScaler.h"

// Using CMIDKeyDecoder as member iKeyDecoder.

#include "CMIDKeyDecoder.h"

// Using CMIDNetworkIndicator as member iNetworkIndicator.

#include "CMIDNetworkIndicator.h"

// Using CMIDCallIndicator as member iCallIndicator.

#include "CMIDCallIndicator.h"

// Using CMIDRemConObserver as memeber iRemConObserver.

#include "CMIDRemConObserver.h"

#ifdef RD_TACTILE_FEEDBACK

// Using CMIDTactileFeedbackExtension as member iTactileFeedback.

#include "CMIDTactileFeedbackExtension.h"

#endif // RD_TACTILE_FEEDBACK

#include "MMIDCustomComponent.h"

// Using CoreUiAvkonLcdui for the splash screen

#include "coreuiavkonlcdui.h"

#ifdef DEFER_BITBLT

const TInt KEstCyclesPerPixel = 32;

#endif // DEFER_BITBLT

const TInt KAllowedTimeBetweenDragEvents = 50000; // 50ms

// Used with component controls

const TInt KComponentMainControl = 0;

const TInt KComponentFocusedNone = -1;

// Using enumeration TFocusState.

#include "MMIDTextEditor.h"

#ifdef RD_JAVA_NGA_ENABLED

// Max dimension for openGL texture, must be power of 2

const TInt KMaxBlitSize = 256;

const TInt KTexturesCount = 1;

const TInt KBytesPerPixel = 4;

const TInt KPhoneScreen = 0;

// The color that is used to clear the framebuffer when

// mixing 3D & 2D rendering

#define KTransparentClearColor TRgb(0x000000, 0x0)

#define KOpaqueClearColor      TRgb(0xFFFFFF, 0xFF)

#ifdef _DEBUG

#define ASSERT_GL() AssertGL()

#else

#define ASSERT_GL()

#endif

#endif // RD_JAVA_NGA_ENABLED

#define KZeroSize TSize()

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

// TBitBltData

// BitBlt buffer data datatype.

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

//

struct TBitBltData

{

    TRect iRect;

};

// ======== LOCAL FUNCTIONS ========

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

// BitBltData

// Get BitBlt buffer data from buffered operation passed to buffer processor.

// Used in CMIDCanvas::ProcessL function.

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

//

inline const TBitBltData& BitBltData(const TMIDBufferOp* aOp)

{

    ASSERT(aOp->Size() >= TInt(1 + (

                                   sizeof(TBitBltData) / sizeof(TMIDBufferOp))));

    return *static_cast< const TBitBltData* >(aOp->Data());

}

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

// IsDownScaling

// Check if downscaling in use.

// @param aSourceSize Source rect size.

// @param aDestRect Destination rect.

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

//

inline TBool IsDownScaling(const TSize& aSourceSize, const TRect& aDestRect)

{

    return (aSourceSize.iWidth > aDestRect.Width() ||

            aSourceSize.iHeight > aDestRect.Height());

}

// ======== MEMBER FUNCTIONS ========

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

// CMIDCanvas::NewL

// Two-phased constructor. Use this method to create a CMIDCanvas instance.

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

//

CMIDCanvas* CMIDCanvas::NewL(

    MMIDEnv& aEnv,

    CCoeControl& aWindow,

    MMIDComponent::TType aComponentType,

    TBool aUpdateRequired)

{

    CMIDCanvas* self = new(ELeave) CMIDCanvas(aEnv,

            aComponentType,

            aUpdateRequired);

    CleanupStack::PushL(self);

    self->ConstructL(aWindow);

    CleanupStack::Pop(self);

    return self;

}

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

// CMIDCanvas::~CMIDCanvas

// Destructor.

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

//

CMIDCanvas::~CMIDCanvas()

{

    DEBUG("+ CMIDCanvas::~CMIDCanvas");

    // Notify custom components that this container is disposing.

    TInt customCount = iCustomComponents.Count();

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

    {

        iCustomComponents[i]->CustomComponentContainerDisposing();

    }

    // Close the array. Objects are not owned.

    iCustomComponents.Close();

    // Inform all listeners

    TInt contentsCount(iDirectContents.Count());

    for (TInt j = 0; j < contentsCount; j++)

    {

        iDirectContents[j]->MdcContainerDestroyed();

    }

    iDirectContents.Reset();

    // Unregister the component from the observer

    // if it were previously registered from MdcAddContent.

    iEnv.ToLcduiObserver().UnregisterControl(*this);

#ifdef CANVAS_DIRECT_ACCESS

    StopDirectAccess();

    delete iDirectAccess;

#endif // CANVAS_DIRECT_ACCESS

    // Network indicator

    if (iNetworkIndicator)

    {

        iNetworkIndicator->Close(); // Use cancel here.

        delete iNetworkIndicator;

    }

    // Call indicator

    if (iCallIndicator)

    {

        iCallIndicator->Cancel();

        delete iCallIndicator;

    }

    // Canvas removes itself from the CMIDRemConObserver.

    ASSERT(iKeyDecoder);

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

    {

        iRemConObserver->RemoveMediaKeysListener(this);

    }

    if (iDisplayable)

    {

        if (iScaler)

        {

            iDisplayable->GetUIManager()->CloseScaler(iScaler);

        }

        // Displayable is notified about content control deletion.

        iDisplayable->NotifyContentDestroyed();

    }

#ifdef CANVAS_DOUBLE_BUFFER

    if (iFrameBuffer)

    {

        iEnv.ReleaseCanvasFrameBuffer((*this), iFrameBuffer);

        iFrameBuffer = NULL;

    }

    delete iFrameContext;

    iFrameContext = NULL;

    delete iFrameDevice;

    iFrameDevice = NULL;

#endif // CANVAS_DOUBLE_BUFFER

#ifdef RD_TACTILE_FEEDBACK

    delete iTactileFeedback;

#endif // RD_TACTILE_FEEDBACK

    if (iPointerEventSuppressor)

    {

        delete iPointerEventSuppressor;

        iPointerEventSuppressor = NULL;

    }

#ifdef RD_JAVA_NGA_ENABLED

    CloseEgl();

    DisposePixelSource();

    delete[] iTexturePixels;

    delete[] iVertexArray;

    delete[] iTriangleStrip;

#endif // RD_JAVA_NGA_ENABLED

    DEBUG("- CMIDCanvas::~CMIDCanvas");

}

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

// CMIDCanvas::FullScreen

// Set fullscreen mode on/off.

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

//

void CMIDCanvas::FullScreen(TBool aFullScreen)

{

    DEBUG_INT("CMIDCanvas::FullScreen(%d) ++--", aFullScreen);

    if (iFullScreen != aFullScreen)

    {

        iFullScreen = aFullScreen;

        // We have to inform all components on this Canvas.

        if (iCustomComponents.Count() > 0)

        {

            for (int i = 0; i < iCustomComponents.Count(); i++)

            {

                iCustomComponents[i]->HandleFullscreenModeChange();

            }

        }

    }

}

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

// CMIDCanvas::IsScalingOn

// Tells whether scaling is on or off.

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

//

TBool CMIDCanvas::IsScalingOn()

{

    return iScalingOn;

}

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

// CMIDCanvas::SelectionKeyCompatibility

// Tells whether application attribute

// Nokia-MIDlet-S60-Selection-Key-Compatibility is set true or not.

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

//

TBool CMIDCanvas::SelectionKeyCompatibility()

{

    return iS60SelectionKeyCompatibility;

}

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

// CMIDCanvas::CountComponentControls

// (other items are commented in the header file)

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

//

TInt CMIDCanvas::CountComponentControls() const

{

    return iCustomComponentsControlCount;

}

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

// CMIDCanvas::ComponentControl

// (other items are commented in the header file)

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

//

CCoeControl* CMIDCanvas::ComponentControl(TInt aIndex) const

{

    TInt index = 0;

    TInt count = iCustomComponents.Count();

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

    {

        TInt compoundCount =

            iCustomComponents[i]->CustomComponentControlCount();

        for (int j = 0; j < compoundCount; j++)

        {

            if (index == aIndex)

            {

                return iCustomComponents[i]->CustomComponentControl(j);

            }

            index++;

        }

    }

    return NULL;

}

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

// CMIDCanvas::SetFocusedComponent

// (other items are commented in the header file)

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

//

void CMIDCanvas::SetFocusedComponent(MMIDCustomComponent* aComponent)

{

    if (aComponent == NULL)

    {

        iFocusedComponent = KComponentFocusedNone;

        iPressedComponent = NULL;

    }

    else

    {

        TInt count = iCustomComponents.Count();

        TInt index = iCustomComponents.Find(aComponent);

        if ((index != KErrNotFound) && (iFocusedComponent != index))

        {

            iFocusedComponent = index;

        }

    }

}

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

// From class CCoeControl.

// CMIDCanvas::OfferKeyEventL

// Process a key event. We ask the java environment to translate the key event

// and we send it java side only if the translation allows it. The translation

// is controlled by CMIDKeyDecoder via its interface to the java environment.

// CBA keys are special. We only try and send them java side if we are full

// screen and have no commands nor CommandListener, as stated in the specs.

// Otherwise - if we are full screen with at least one command and

// CommandListener we display the options menu or if we are not full screen

// we simply return so that the CBA will process the key event and display the

// options menu if needed. Note that in this context MSK is considered to be a

// softkey, it must not be delivered as a key event to the Java side.

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

//

TKeyResponse CMIDCanvas::OfferKeyEventL(

    const TKeyEvent& aEvent,

    TEventCode aType)

{

    DEBUG("+ CMIDCanvas::OfferKeyEventL");

    DEBUG_INT(

        "+ CMIDCanvas::OfferKeyEventL - received TKeyEvent: iCode = %d",

        aEvent.iCode);

    DEBUG_INT(

        "+ CMIDCanvas::OfferKeyEventL - received TKeyEvent: iModifiers = %d",

        aEvent.iModifiers);

    DEBUG_INT(

        "+ CMIDCanvas::OfferKeyEventL - received TKeyEvent: iRepeats = %d",

        aEvent.iRepeats);

    DEBUG_INT(

        "+ CMIDCanvas::OfferKeyEventL - received TKeyEvent: iScanCode = %d",

        aEvent.iScanCode);

    TKeyResponse response = EKeyWasNotConsumed;

    if ((iFocusedComponent != KComponentFocusedNone) &&

            (iFocusedComponent < iCustomComponents.Count()) &&

            (iCustomComponents[iFocusedComponent]->

             CustomComponentControl(KComponentMainControl)->IsVisible()))

    {

        // Traversal check

        if ((aType == EEventKeyDown) &&

                (((aEvent.iCode == EKeyUpArrow) ||

                  (aEvent.iCode == EKeyDownArrow)) ||

                 ((aEvent.iScanCode == EStdKeyUpArrow) ||

                  (aEvent.iScanCode == EStdKeyDownArrow))))

        {

            // Traversing is not allowed when editing with VKB

            if (iDisplayable && !iDisplayable->IsVKBOnScreen())

            {

                iCustomComponents[iFocusedComponent]->TraverseL(aEvent);

                response = EKeyWasConsumed;

            }

        }

        if (response != EKeyWasConsumed)

        {

            // Passing the keyevent to focused component

            response = iCustomComponents[iFocusedComponent]->

                       CustomComponentControl(KComponentMainControl)->

                       OfferKeyEventL(aEvent, aType);

        }

    }

    // Check if the key event was consumed by the child control.

    if (response == EKeyWasConsumed)

    {

        DEBUG_INT(

            "CMIDCanvas::OfferKeyEventL - key consumed by custom control: %d",

            iFocusedComponent);

        // Return response.

        return response;

    }

    DEBUG("CMIDCanvas::OfferKeyEventL, \

event not consumed by any custom component");

    TInt keycode = aEvent.iScanCode;

    // If there is additional selection key mapping (e.g. to Enter key) and

    // scan code of delivered key is this additional key, flag is set to ETrue

    TBool additionalSelectionKey =

        (iKeyDecoder->AdditionalSelectionKeyMappingCode() != 0) &&

        (keycode == iKeyDecoder->AdditionalSelectionKeyMappingCode());

    if (keycode == EStdKeyDevice0 ||

            keycode == EStdKeyDevice1 ||

            keycode == EStdKeyDevice3 ||

            additionalSelectionKey)

    {

        // CBA keys

        // In S60SelectionKeyCompatibility mode turned on and MSK pressed

        // don't map any command, send key event to Java.

        if (iS60SelectionKeyCompatibility &&

                (keycode == EStdKeyDevice3 || additionalSelectionKey))

        {

            SendKeyEventToJavaSideL(aEvent, aType);

            DEBUG("- CMIDCanvas::OfferKeyEventL = key was not consumed");

            return EKeyWasNotConsumed;

        }

        if (iDisplayable && !iDisplayable->IsFullScreenMode())

        {

            // Pressing selection key is handled in CEikCba so that command

            // mapped to selection (MSK) key is invoked from there.

            // But CEikCba doesn't handle additional selection key

            // mapping, so it is done here.

            if (additionalSelectionKey && aType == EEventKey)

            {

                iDisplayable->ProcessMSKCommandL();

            }

            else if (aType == EEventKeyDown && keycode == EStdKeyDevice3)

            {

                CMIDMenuHandler* menuHandler = iDisplayable->MenuHandler();

                // If there is no additional selection key mapping

                // and scan code of delivered key is MSK then show menu,

                // used when ENavigationKeysFire or MSK were pressed

                if (iDisplayable->NumCommandsForOkOptionsMenu() == 0