/*

* Copyright (c) 2006 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:   AppUi class

*

*/

#include <apgtask.h>

#include <AknDoc.h>

#include "alf/alfappui.h"

#include "alf/alfappserver.h"

#include <uiacceltk/HuiEnv.h>

#include <aknenv.h>

#include <AknsConstants.h>

#include <uiacceltk/HuiSkin.h>

#include <uiacceltk/HuiDisplay.h>

#include <uiacceltk/HuiControl.h>

#include <uiacceltk/HuiControlGroup.h>

#include <uiacceltk/HuiEvent.h>

#include <uiacceltk/HuiDeckLayout.h>

#include <uiacceltk/HuiImageVisual.h>

#include <uiacceltk/HuiTransformation.h>

#include <uiacceltk/HuiBorderBrush.h>

#include <uiacceltk/HuiUtil.h>

#include <uiacceltk/HuiTextVisual.h>

#include <uiacceltk/HuiGradientBrush.h>

#include <apgwgnam.h>

#include <akntransitionutils.h>

#include "alfeffectutils.h"

#ifdef ALF_USE_CANVAS

#include <uiacceltk/HuiCanvasVisual.h>

#endif

#include "alflogger.h"

#include "alf/alfappsrvsessionbase.h"

#include "alf/alfappserver.h"

#include "alfsrvresourcemanager.h"

#include "alfsrvsettingshandler.h"

#include <uiacceltk/HuiTextureManager.h>

#include "alfsrvtexturemanager.h"

#include "alfshareddisplaycoecontrol.h"

#include "alfuids.h"

#include "alfbridge.h"

#include "alfstreamerserver.h"

#include "alfdecoderserverclient.h"

#include "alfstreamerconsts.h"

// DISABLE this if you want to use the AHDemoApp layout switch. If this is enabled

// and switch is done through AHDemoApp, the layout will be rotated too much.

#ifdef __WINSCW__

// Use this, if you want the VGA layout to show correctly

#define ALF_USE_EMULATOR_LAYOUT_SWITCH_BUTTON

#endif

_LIT(KAlfEventThreadName,"alfevents");

NONSHARABLE_CLASS(CAlfEventCatcher): public CActive

    { // this class does not actually catch the events but moves the wg so that alf can get pointer events

    public:

    CAlfEventCatcher(RWsSession& aWsSession, 

                     RWindowGroup& aWindowGroup, RWindow* aWindow, CWsScreenDevice* aScreenDevice)

                     :CActive(CActive::EPriorityStandard), 

                     iWsSession(aWsSession),

                     iWindowGroup(aWindowGroup),

                     iWindow(aWindow),

                     iScreenDevice(aScreenDevice),

                     iThread(RThread().Id())

        {

        CActiveScheduler::Add(this);

        iSema.CreateLocal();

        DoActivate();

        }

    ~CAlfEventCatcher()

        {

        Cancel();

        iSema.Close();

        }

    void DoActivate()

        {

        SetActive();

        iStatus = KRequestPending;        

        }

    void AdjustWindowGroupPositionL(TInt aParentIdentifier, TInt aPosition)

        {

        iSema.Wait();

        // ok to update previous values even they were not applied by ao

        iParentIdentifier = aParentIdentifier;

        iPosition = aPosition;

        if (IsActive() && iStatus == KRequestPending)

            {

            RThread t;

            TInt err = t.Open(iThread);

            if (err)

                {

                __ALFLOGSTRING1( "CAlfEventCatcher::Trigger() ignore RThread::Open() error: %d", err );

                }

            TRequestStatus* status = &iStatus;

            __ALFLOGSTRING("CAlfEventCatcher::Trigger - completing  CAlfEventCatcher");

            t.RequestComplete(status, err);

            t.Close();

            }

        iSema.Signal();

        }

    void RunL()

        {

        iSema.Wait();

        if (iStatus.Int() == KErrNone)

            {

            TRAPD(err, DoAdjustPositionL());

            if (err)

                {

                __ALFLOGSTRING1("ALF: WG Parent not found, err %d", err);

                }

            }

        DoActivate();

        iSema.Signal();

        }

    void DoAdjustPositionL()

        {

         __ALFLOGSTRING1("ALF: DoAdjustPositionL() %d", iPosition);

        if (iPosition == CAlfAppServer::EAbsoluteBackground) // just for convenience

            {

            __ALFLOGSTRING("CAlfEventCatcher::DoAdjustPositionL - CAlfAppServer::EAbsoluteBackground");

            iWindowGroup.SetOrdinalPosition(-1,ECoeWinPriorityNeverAtFront);

            iWsSession.Flush();

            return;

            }

        else if (iPosition == CAlfAppServer::EAlfWindowSize ) // just for developer convenience

            {

            __ALFLOGSTRING("CAlfEventCatcher::DoAdjustPositionL - CAlfAppServer::EAlfWindowSize");

             // update window size when layout changes    

            iScreenDevice->SetAppScreenMode(iScreenDevice->CurrentScreenMode());

            iWindow->SetSize(iScreenDevice->SizeInPixels());

            __ALFLOGSTRING2("ALF EventWin: Size(%d,%d)", iWindow->Size().iWidth, iWindow->Size().iHeight );

            return;

            }

        TInt parentPriority = 

            iWsSession.GetWindowGroupOrdinalPriority(iParentIdentifier);

        // perhaps we should maintain wg-list elsewhere

        CArrayFixFlat<TInt>* wgs = new (ELeave) CArrayFixFlat<TInt>(1); 

        CleanupStack::PushL(wgs);

        iWsSession.WindowGroupList(parentPriority,wgs);

        TInt pos = KErrNotFound;

        TInt movingWgOldPos = KErrNotFound;

        TInt wgCount = wgs->Count();

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

            {

            if (iParentIdentifier == wgs->At(i))

                {

                if ( iPosition == CAlfAppServer::EOnTopOfParent )

                    {

                    pos = i;

                    }

                else

                    {

                    pos = i+1;

                    }

                }

            if ( iWindowGroup.WindowGroupId() == wgs->At(i))

                {

                movingWgOldPos = i;

                }

            if ( pos != KErrNotFound && movingWgOldPos != KErrNotFound )

                {

                // Both found already.

                break;

                }

            }

        // If the moving window group has already been before the parent

        // we need to adjust the new position

        if ( movingWgOldPos < pos && movingWgOldPos != KErrNotFound )

            {

            pos--;

            }

        User::LeaveIfError(pos); // parent not found, leave

        CleanupStack::PopAndDestroy(wgs);        

        iWindowGroup.SetOrdinalPosition(pos, parentPriority);

        iWsSession.Flush();

        }

    void DoCancel()

        {

        // do not..

        }

    RWsSession& iWsSession;

    RWindowGroup& iWindowGroup;

    RWindow* iWindow;

    CWsScreenDevice* iScreenDevice;

    TThreadId iThread;

    RCriticalSection iSema;

    TInt iPosition;

    TInt iParentIdentifier;

    };

NONSHARABLE_CLASS(CAlfEventBridge): public CActive

    {

    public:

    CAlfEventBridge(CAlfAppUi& aAppUi, CHuiDisplay& aDisplay)

        :CActive(CActive::EPriorityUserInput), 

        iAppUi(aAppUi), 

        iDisplay(aDisplay),

        iThread(RThread().Id())

        {

        CActiveScheduler::Add(this);

        iSema.CreateLocal();

        TPixelsAndRotation rot;

        CWsScreenDevice* sd = CHuiStatic::ScreenDevice();

        sd->GetScreenModeSizeAndRotation(sd->CurrentScreenMode(),rot);

        iVirtualSize = rot.iPixelSize; // for pointer event re-mapping

        RequestEventNotification();

        }

    ~CAlfEventBridge()

        {

        Cancel();

        iSema.Close();

        iQueue1.Close();

        iQueue2.Close();

        }        

    void RequestEventNotification()

    /** Asks WSERV proxy to give notification when an event is waiting */

        {

        iSema.Wait();

        iQueueSelection++;

        iQueueSelection%=2;

        iStatus = KRequestPending;

        SetActive();

        iSema.Signal();            

        }

    void AdjustWindowGroupPositionL(TInt aParentIdentifier, TInt aPosition)

        {

        if (iEventCatcher)

            {

            iEventCatcher->AdjustWindowGroupPositionL(aParentIdentifier, aPosition);

            }

        }

    void Trigger(TInt aReason)

        {

        if (IsActive() && iStatus == KRequestPending)

            {

            RThread t;

            TInt err = t.Open(iThread);

            if (err)

                {

                __ALFLOGSTRING1( "CAlfEventBridge::Trigger() ignore RThread::Open() error: %d", err );

                }

            TRequestStatus* status = &iStatus;

            __ALFLOGSTRING("CAlfEventBridge::Trigger - completing  CAlfEventBridge")

            t.RequestComplete(status, err?err:aReason);

            t.Close();

            }

        }

    void AddEventL(TWsEvent& aEvent)

        {  

        iSema.Wait();    

        User::LeaveIfError((!iQueueSelection?iQueue1:iQueue2).Append(aEvent));

        Trigger(KErrNone);

        iSema.Signal();

        }

    // Todo: Should cache entries

    TBool GetEvent(TWsEvent& aEvent)

        {

        if ((iQueueSelection?iQueue1:iQueue2).Count())    

            {

            aEvent = (iQueueSelection?iQueue1:iQueue2)[0];

            (iQueueSelection?iQueue1:iQueue2).Remove(0);

            return ETrue;

            }

        return EFalse;    

        }

    void RunL()

        {

        switch (iStatus.Int())

            {

        case KErrNone:

            break;

        case KErrCancel:

        case KErrServerTerminated:

            return;

        default:

            // Let bridge object know the event window group so that it is able reorder window groups correctly

            if (iStatus.Int() > KErrNone)

                {    

                iAppUi.SetAlfWindowGroupId(iStatus.Int());

                }

            break;

            }

        RequestEventNotification();

        TWsEvent event;

        while (GetEvent(event))

            {

            TRAPD(err,DoHandleEventL(event))

                if (err)

                {

                __ALFLOGSTRING2("ALF: Error in handling WSEvent: event: %d err: %d", err, event.Type());    

                }

            }    

        }

    void DoHandleEventL(TWsEvent& aEvent)

        {

        iAppUi.HandleWsEventL(aEvent, 0);

        if (aEvent.Type() >= EEventPointer && aEvent.Type() <=  EEventDragDrop )

            {

            // twiddle pointer coordinates

            THuiEvent huiEvent(&iDisplay, *aEvent.Pointer());

            // Send events received here only to the associated display    

            iDisplay.Roster().HandleEventL(huiEvent);        

            iAppUi.EndPointerEventHandling(); // flush here

            }

        }

    void DoCancel()

        {

        }

    CAlfAppUi& iAppUi;

    CHuiDisplay& iDisplay; // if we ever need to support touch events from multiple displays, this needs to change

                           // of course we could have several event fetchers on that scnario..  

    RArray<TWsEvent> iQueue1;

    RArray<TWsEvent> iQueue2;

    TInt iQueueSelection;

    RCriticalSection iSema;

    TThreadId iThread;

    CAlfEventCatcher* iEventCatcher;

    TSize iVirtualSize;

    };

// ===========ALF WINDOW THREAD================

NONSHARABLE_CLASS(CAlfEventFetcher): public CActive

    {

    public:

    CAlfEventFetcher(RWsSession& aWsSession, 

                     CAlfEventBridge* aBridge )

        :CActive(CActive::EPriorityUserInput), 

        iWsSession(aWsSession),

        iWindowGroup(aWsSession),

        iBridge(aBridge)

        {

        CActiveScheduler::Add(this);

        }

    ~CAlfEventFetcher()

        {

        Cancel();

        delete iWindowGc;

        if (iWindow)

            {

            iWindow->Close();    

            delete iWindow;

            }

        iWindowGroup.Close();    

        delete iScreenDevice;

        }    

    static CAlfEventFetcher* NewLC(RWsSession& aWsSession, 

                     CAlfEventBridge* aBridge )

        {

        CAlfEventFetcher* ret = new (ELeave)CAlfEventFetcher(aWsSession,aBridge);

        CleanupStack::PushL(ret);

        ret->CreateWindowAndStartL();    

        return ret;

        }     

    void CreateWindowAndStartL()

        {

        iWsSession.ComputeMode(RWsSession::EPriorityControlDisabled);

        RThread thread; 

        iScreenDevice =new(ELeave) CWsScreenDevice(iWsSession);

        iScreenDevice->Construct(0); // For main display only

        User::LeaveIfError(iWindowGroup.Construct((TUint32)iScreenDevice, EFalse,iScreenDevice));                   

        iWindowGroup.EnableReceiptOfFocus(EFalse); 

        // disable pointer events based autoforwarding

        iWindowGroup.AutoForeground(EFalse);

        iWindowGroup.EnableScreenChangeEvents();

        CApaWindowGroupName* wgName = CApaWindowGroupName::NewLC(iWsSession);

        wgName->SetHidden(ETrue); // hides us from FSW and protects us from OOM FW etc.

        wgName->SetSystem(ETrue); // Allow only application with PowerManagement cap to shut us down    

        wgName->SetCaptionL(_L("ALF Event"));

        wgName->SetAppUid(KNullUid);

        wgName->SetWindowGroupName(iWindowGroup);

        CleanupStack::PopAndDestroy();

        iWindow = new (ELeave) RWindow(iWsSession);

        iWindow->Construct(iWindowGroup,0x000FAB11); // FYI: multiple display support neglegted atm

        iWindow->SetExtent(TPoint(0,0),iScreenDevice->SizeInPixels()); // FYI: multiple display support neglegted atm            

        iWindow->EnableAdvancedPointers();

        iWindow->PointerFilter(EPointerFilterDrag,0);

        iWindow->SetPointerGrab(ETrue);

        iWindow->Activate();

        iWindow->SetVisible(ETrue);            

        iWindow->SetTransparencyAlphaChannel();

        iWindow->SetBackgroundColor(~0);

        iBridge->iEventCatcher = new (ELeave) CAlfEventCatcher(iWsSession, iWindowGroup, iWindow, iScreenDevice);   

        iBridge->Trigger(iWindowGroup.Identifier()); // let appui know our wgid

        //RequestEventNotification();            

        SetActive();

        TRequestStatus* sptr = &iStatus;

        User::RequestComplete(sptr, KErrNone);

        }    

    void RequestEventNotification()

    /** Asks WSERV to give notification when an event is waiting */

        {

        SetActive();

        iWsSession.EventReady(&iStatus);

        }

    void RunL()

        {

        if (!iInitializationComplete)

            { // invalidate window server scene to get the latest drawing commands

              // now that alf is there  

            iWindowGc = new CWindowGc(iScreenDevice);

            if (iWindowGc)

                {

                if(iWindowGc->Construct() == KErrNone)

                    {

                    iWindowGc->Activate(*iWindow);

                    iWindow->BeginRedraw();

                    iWindowGc->SetBrushColor(0xffffffff);

                    iWindowGc->Clear();

                    iWindow->EndRedraw();

                    iWindowGc->Deactivate();

                    }                

                }

            iWindowGroup.SetOrdinalPosition(-1,ECoeWinPriorityNeverAtFront);

            iWsSession.Flush();

            iInitializationComplete = ETrue;

            RequestEventNotification(); 

            return;

            }

        switch (iStatus.Int())

            {

        case KErrNone:

            break;

        case KErrCancel:

        case KErrServerTerminated:

        default:

            return;

            }

        TWsEvent event;

        iWsSession.GetEvent(event);

        if( event.Type() == EEventScreenDeviceChanged  )

            {

#ifdef ALF_USE_EMULATOR_LAYOUT_SWITCH_BUTTON

            // Update window size when layout changes. The ScreenDevice

            // has to be updated separately, otherwise it will always return the orig resolution.

            iScreenDevice->SetAppScreenMode(iScreenDevice->CurrentScreenMode());