/*******************************************************************************

 * Copyright (c) 2005, 2010 Nokia Corporation and/or its subsidiary(-ies).

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 *

 * Contributors:

 *     Nokia Corporation - S60 implementation

 *******************************************************************************/

#include <eikbtgpc.h>

#include <fbs.h>

#include <gulutil.h>

#include <eikon.hrh>

#include <AknUtils.h>

#include <bautils.h>

#include <swtlaffacade.h>

#include "s60commonutils.h"

#include "swtfactory.h"

#include "swtdisplaybase.h"

#include "eswtwidgetsexpanded.h"

#include "eswtmobileextensions.h"

#include "swtevents.h"

#include "swtkeymapper.h"

#include "swttimer.h"

#include "swtimage.h"

#include "swtmidremconobserver.h"

#include "swtjavabufferdrawer.h"

#include "swtfont.h"

#include "swtuiutils.h"

#define ASSERT_JAVAUITHREAD() ASSERT(IsCurrentThreadJavaUi())

#define ASSERT_NATIVEUITHREAD() ASSERT(IsCurrentThreadNativeUi())

// Assuming ResourceLanguageFileNameL inserts DRIVE:/KDC_RESOURCE_FILES_DIR/java/

// Assuming KDC_RESOURCE_FILES_DIR = /resource/java/

_LIT(KSwtResFile, "eswtcore.rsc");

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

/**

 * 2nd phase constructor

 */

void ASwtDisplayBase::ConstructInJavaUiThreadL()

{

    iEventQueue = CSwtEventQueue::NewL(*this);

}

/**

 * UI thread's side constructor

 */

void ASwtDisplayBase::ConstructInNativeUiThreadL()

{

    ASSERT_NATIVEUITHREAD();

    iCoeEnv = CEikonEnv::Static(); // codescanner::eikonenvstatic

    ASSERT(iCoeEnv);

    iFactory = CSwtFactory::NewL();

    iResId = LoadResourceFileL();

    iUiUtils = iFactory->NewUiUtilsL(*this);

    iMenuArranger = iFactory->NewMenuArrangerL(*this);

    iCommandArranger = iFactory->NewCommandArrangerL(*this);

    iKeyMapper = CSwtKeyMapper::NewL();

    iRemConObserver = CSwtMIDRemConObserver::NewL();

    if (iRemConObserver)

    {

        iRemConObserver->AddMediaKeysListenerL(this);

    }

    iJavaBufferDrawer = new(ELeave) CSwtJavaBufferDrawer(*this);

#ifdef RD_SCALABLE_UI_V2

    iLongTapDetector = CAknLongTapDetector::NewL(this);

#endif

}

/**

 * Destructor

 */

ASwtDisplayBase::~ASwtDisplayBase()

{

}

/**

 * Destroys the Display part that runs in the UI thread

 */

void ASwtDisplayBase::DestroyInNativeUiThread()

{

    ASSERT_NATIVEUITHREAD();

    if (iRemConObserver)

    {

        iRemConObserver->RemoveMediaKeysListener(this);

    }

    delete iRemConObserver;

    iRemConObserver = NULL;

    if (iSystemFont)

    {

        iSystemFont->RemoveRef();

        iSystemFont = NULL;

    }

    delete iKeyMapper;

    iKeyMapper = NULL;

    delete iCommandArranger;  // Mobile Extensions

    iCommandArranger = NULL;

    delete iMenuArranger;

    iMenuArranger = NULL;

    delete iUiUtils;          // Core

    iUiUtils = NULL;

    delete iFactory;

    iFactory = NULL;

    iTimers.ResetAndDestroy();

    if (iEventQueue)

        iEventQueue->Flush();

    iResourceChangeObservers.Close();

    iAppFocusObservers.Close();

    delete iJavaBufferDrawer;

    iJavaBufferDrawer = NULL;

#ifdef RD_SCALABLE_UI_V2

    delete iLongTapDetector;

    iLongTapDetector = NULL;

#endif //RD_SCALABLE_UI_V2   

    if (iResId != KErrNotFound)

    {

        iCoeEnv->DeleteResourceFile(iResId);

        iResId = KErrNotFound;

    }

    iCoeEnv = NULL;

}

/**

 * Sleeps until an event is received

 *

 * Must be executed in the main thread.

 *

 * @return <code>ETrue</code> if the reason for awakening is reception of an

 *         event; <code>EFalse</code> otherwise.

 */

TBool ASwtDisplayBase::Sleep()

{

    ASSERT_JAVAUITHREAD();

    // Must be set before checking if the queue is empty so that if an event

    // arrives between the moment we checked the queue and when we call

    // WaitForRequest(), we won't go to sleep.

    iRequestStatus = KRequestPending;

    if (!iEventQueue->IsEmpty()) //lint !e613

        return ETrue;

    User::WaitForRequest(iRequestStatus);

    return ETrue;

}

/**

 * Creates a new timer that will auto-destruct. It will also register with

 * <code>RegisterTimerL()</code>, in case we need to exit and the timer is

 * still running.

 */

void ASwtDisplayBase::AddTimerL(TInt aDelayInMilliSeconds, TInt aTimerHandle)

{

    CSwtTimer* timer = CSwtTimer::NewL(*this);

    timer->ExecuteAfterLD(aDelayInMilliSeconds, aTimerHandle);

}

/**

 * Adds a new timer to the java side timer list

 */

void ASwtDisplayBase::RegisterTimerL(const CSwtTimer* aTimer)

{

    UnRegisterTimer(aTimer); //prevents duplicating timers

    User::LeaveIfError(iTimers.Append(aTimer));

}

/**

 * Removes the timer from the java side timer list

 */

void ASwtDisplayBase::UnRegisterTimer(const CSwtTimer* aTimer)

{

    TInt pos = iTimers.Find(aTimer);

    if (pos >= 0)

    {

        iTimers.Remove(pos);

    }

}

/**

 * Awakens the display because of reception of a new event.

 *

 * Must be executed from within the App UI's thread.

 */

void ASwtDisplayBase::HandleNewEvent()

{

    ASSERT_NATIVEUITHREAD();

    DoWake(ETrue);

}

/**

 * Awakens the display (i.e. the main thread)

 */

void ASwtDisplayBase::DoWake(TBool aBecauseOfEvent)

{

    if (iRequestStatus == KRequestPending)

    {

        TRequestStatus* statusPtr = &iRequestStatus;

        iJavaUiThread.RequestComplete(statusPtr, aBecauseOfEvent);

    }

}

/**

 * Returns the maximum allowed depth of icons

 *

 * Must be executed from within the App UI's thread.

 */

TInt ASwtDisplayBase::GetIconDepth() const

{

    ASSERT_NATIVEUITHREAD();

    return TDisplayModeUtils::NumDisplayModeBitsPerPixel(iCoeEnv->ScreenDevice()->DisplayMode());

}

/**

 * Returns the double click time

 *

 * Must be executed from within the App UI's thread.

 */

TInt ASwtDisplayBase::GetDoubleClickTime() const

{

    ASSERT_NATIVEUITHREAD();

    TTimeIntervalMicroSeconds32 interval(0);

    TInt distance(0);

    iCoeEnv->WsSession().GetDoubleClickSettings(interval, distance);

    return interval.Int();

}

/**

 * Emits a beep

 *

 * Must be executed from within the App UI's thread.

 */

void ASwtDisplayBase::Beep() const

{

    ASSERT_NATIVEUITHREAD();

    iCoeEnv->Beep();

}

/**

 * Posts an asynchronous event.

 *

 * @param aData  SWT data of the key event.

 *

 * This method should be able to post events of type KeyDown or KeyUp.

 */

void ASwtDisplayBase::PostL(const TSwtKeyEventData& aData)

{

    ASSERT_NATIVEUITHREAD();

    if ((aData.iType == ESwtEventKeyDown) || (aData.iType == ESwtEventKeyUp))

    {

        MSwtShell* shell = iUiUtils->GetActiveShell();

        if (shell == NULL)

        {

            return;

        }

        MSwtControl* control = shell->FocusControl();

        if (control == NULL)

        {

            return;

        }

        TKeyEvent keyEvent;

        keyEvent.iCode      = 0;

        keyEvent.iRepeats   = 0;

        keyEvent.iModifiers = iKeyMapper->GetSymbianModifier(aData);

        if (aData.iType == ESwtEventKeyUp)

        {

            // Key up event: keyEvent.iCode is set to 0

            keyEvent.iScanCode  = iKeyMapper->GetSymbianScanCode(aData.iKeyCode);

            control->CoeControl().OfferKeyEventL(keyEvent, EEventKeyUp);

        }

        else

        {

            // Key down event in SWT = key down event follows with key event in Symbian

            // If several SWT ESwtEventKeyDown are following,

            // we should post first one Symbian EEventKeyDown

            // and then as many Symbian EEventKey as SWT ESwtEventKeyDown.

            // But posting EEventKeyDown and EEventKey at each time should not cause any problem.

            // Key down event: keyEvent.iCode is set to 0

            TUint code = aData.iCharacter;

            iKeyMapper->GetSymbianCodes(aData.iKeyCode, keyEvent.iScanCode, &code);

            control->CoeControl().OfferKeyEventL(keyEvent, EEventKeyDown);

            // Key event: keyEvent.iCode is not 0.

            keyEvent.iCode = code;

            control->CoeControl().OfferKeyEventL(keyEvent, EEventKey);

        }

    }

}

/**

 * Posts an asynchronous event.

 * @param aData  SWT data of the mouse event.

 * This method should be able to post events of type MouseDown, MouseUp, MouseMove.

 */

TBool ASwtDisplayBase::MousePostL(const TSwtKeyEventData& aData, TPoint point)

{

    ASSERT_NATIVEUITHREAD();

    if (AknLayoutUtils::PenEnabled())

    {

        TRawEvent event;

        if (aData.iType == ESwtEventMouseDown)

        {

            event.Set(TRawEvent::EButton1Down, point.iX, point.iY);

            iCoeEnv->WsSession().SimulateRawEvent(event);

        }

        else if (aData.iType == ESwtEventMouseUp)

        {

            event.Set(TRawEvent::EButton1Up, point.iX, point.iY);

            iCoeEnv->WsSession().SimulateRawEvent(event);

        }

        else if (aData.iType == ESwtEventMouseMove)

        {

            event.Set(TRawEvent::EPointerMove, point.iX, point.iY);

            iCoeEnv->WsSession().SimulateRawEvent(event);

        }

        return ETrue;

    }

    else

    {

        return EFalse;

    }

}

/**

 * Constructs an uninitialised Image

 *

 * @param aSize  The new image's size

 */

MSwtImage* ASwtDisplayBase::NewImageL(const TSize& aSize)

{

    return CSwtImage::NewL(*this, aSize, *this);

}

/**

 * Constructs an Image with initial data

 *

 * @param aData  The data to construct the image from

 */

MSwtImage* ASwtDisplayBase::NewImageFromDataL(const MSwtImageData& aData)

{

    return CSwtImage::NewL(this, aData, this);

}

//

// Own internal event methods

//

void ASwtDisplayBase::PostForegroundEventL(TSwtPeer aPeer, const TBool& aForeground)

{

    ASSERT_NATIVEUITHREAD();

    iEventQueue->PushL(new(ELeave) CSwtForegroundEvent(aPeer, aForeground)); //lint !e613

}

//

// Virtual methods from MSwtDisplay

//

MSwtDevice& ASwtDisplayBase::Device()

{

    return *this;

}

const MSwtFactory& ASwtDisplayBase::Factory() const

{

    ASSERT(iFactory);

    return *iFactory;

}

MSwtUiUtils& ASwtDisplayBase::UiUtils()

{

    ASSERT(iUiUtils!=NULL);

    return *iUiUtils;         //lint !e613

}

MSwtMenuArranger& ASwtDisplayBase::MenuArranger()

{

    ASSERT(iMenuArranger!=NULL);

    return *iMenuArranger;

}

MSwtCommandArranger* ASwtDisplayBase::CommandArranger()

{

    return iCommandArranger;

}

void ASwtDisplayBase::AddResourceChangeObserverL(MSwtResourceChangeObserver* aObserver)

{

    User::LeaveIfError(iResourceChangeObservers.Append(aObserver));

}

void ASwtDisplayBase::RemoveResourceChangeObserver(MSwtResourceChangeObserver* aObserver)

{

    TInt pos = iResourceChangeObservers.Find(aObserver);

    if (pos != KErrNotFound)

    {

        iResourceChangeObservers.Remove(pos);

    }

}

void ASwtDisplayBase::AddAppFocusObserverL(MSwtAppFocusObserver* aObserver)

{

    User::LeaveIfError(iAppFocusObservers.Append(aObserver));

}

void ASwtDisplayBase::RemoveAppFocusObserver(MSwtAppFocusObserver* aObserver)

{

    TInt pos = iAppFocusObservers.Find(aObserver);

    if (pos != KErrNotFound)

    {

        iAppFocusObservers.Remove(pos);

    }

}

TInt ASwtDisplayBase::GetSymbianScanCode(const TInt aSwtKeyCode) const

{

    return CSwtKeyMapper::GetSymbianScanCode(aSwtKeyCode);

}

TUint ASwtDisplayBase::GetSymbianKeyCode(const TInt aSwtKeyCode) const

{

    TUint keyCode = aSwtKeyCode;

    TInt scanCodeNotNeeded;

    CSwtKeyMapper::GetSymbianCodes(aSwtKeyCode, scanCodeNotNeeded, &keyCode);

    return keyCode;

}

void ASwtDisplayBase::ForceTraverseEventL(MSwtControl& aControl, TSwtTraversal aDetail, TBool aDoIt)

{

    ASSERT_NATIVEUITHREAD();

    TSwtKeyEventData data;

    data.iType      = ESwtEventTraverse;

    data.iCharacter = 0;

    data.iKeyCode   = 0;

    data.iStateMask = 0;

    TKeyEvent keyEvent;

    keyEvent.iCode      = 0;

    keyEvent.iModifiers = 0;

    keyEvent.iRepeats   = 0;

    keyEvent.iScanCode  = 0;

    iEventQueue->PushL(new(ELeave) CSwtTraverseEvent(aControl, aDetail, aDoIt, data, keyEvent, EEventKey)); //lint !e613

}

void ASwtDisplayBase::PostTraverseEventL(MSwtControl& aControl, TSwtTraversal aDetail, const TKeyEvent& aKeyEvent,

        TEventCode aType, TBool aDoIt)

{

    ASSERT_NATIVEUITHREAD();

    ASSERT(iKeyMapper!=NULL);

    TSwtKeyEventData data(iKeyMapper->MapKeyEventL(aKeyEvent, aType)); //lint !e613

    if (data.iType != ESwtEventNone)

        iEventQueue->PushL(new(ELeave) CSwtTraverseEvent(aControl, aDetail, aDoIt, data, aKeyEvent, aType)); //lint !e613

}

void ASwtDisplayBase::PostKeyEventL(MSwtControl& aControl, const TKeyEvent& aKeyEvent, TEventCode aType)

{

    ASSERT_NATIVEUITHREAD();

    ASSERT(iKeyMapper!=NULL);

    ASSERT(aType!=EEventNull);

    // EEventKeyDown can be posted only if the key does not generate EEventKey!

    TSwtKeyEventData data(iKeyMapper->MapKeyEventL(aKeyEvent, aType)); //lint !e613

    if (data.iType != ESwtEventNone)

        iEventQueue->PushL(new(ELeave) CSwtKeyEvent(aControl, data, aKeyEvent, aType)); //lint !e613

}

void ASwtDisplayBase::PostPaintEventL(TSwtPeer aSenderPeer, TSwtPeer aShellPeer, const TRect& aRect, TBool aMergeable)

{

    ASSERT_NATIVEUITHREAD();

    iEventQueue->PushL(new(ELeave) CSwtPaintEvent(aSenderPeer, aShellPeer, aRect, aMergeable)); //lint !e613

}

void ASwtDisplayBase::PostMouseEventL(TSwtPeer aPeer, TSwtEventType aType, TInt aButton, const TPoint& aPos, TInt aStateMask)

{

    ASSERT_NATIVEUITHREAD();

    ASSERT(aType>=ESwtEventMouseDown && aType<=ESwtEventMouseDoubleClick);

    ASSERT(aButton==0 || (aType==ESwtEventMouseDown || aType==ESwtEventMouseUp));

#ifdef RD_SCALABLE_UI_V2