/*

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

*

*/

#include <graphics/wsgraphicscontext.h>

#include <graphics/wsgraphicdrawerinterface.h>

#include <bitstd.h>

#include <fbs.h>

#include <gdi.h>

#include <e32math.h>

#include <e32hashtab.h>

#include <uiacceltk/HuiUtil.h>

#include "alfhierarchymodel.h"

#include "alfstreamerconsts.h"

#include "alfstreamerserver.h"

#include "alfwindowmanager.h"

#include "alfstreamerbridge.h"

#include "alfwindow.h"

#include "alflogger.h"

#ifdef ALF_DEBUG_TRACK_DRAWING 

#include "alfcommanddebug.h"

#endif

#include "alfnodes.h"

#include "huiwscanvascommands.h"

#include "mwsgraphicscontexttobitgdimappings.h"

const TInt KChunkCommitBatchSize = 10000;

const TInt KChunkMaxSize = 500000;

const TInt KFrameOffsetTemplate = 12345678;

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

// NewL

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

//

CAlfHierarchyModel* CAlfHierarchyModel::NewL(CAlfStreamerServer& aServer)

    {

    CAlfHierarchyModel* self = new(ELeave)CAlfHierarchyModel(aServer);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

// ConstructL

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

//

void CAlfHierarchyModel::ConstructL()

    {

    iWindowPos = TPoint(0, 0 );

    iSema.CreateLocal();

    if (iServer.Bridge())

        {

        iServer.Bridge()->SetBatchObserver(this);

        }                

    #ifdef ALF_DEBUG_TRACK_DRAWING 

    iCommandDebugger = CAlfCommandDebug::NewL();

    #endif

    #ifdef USE_MODULE_TEST_HOOKS_FOR_ALF

    // Initiliaze global data in TLS and Open global module testing chunk and mutex

    User::LeaveIfError(Dll::SetTls(new(ELeave) CAlfModuleTestDataControl()));

    User::LeaveIfError(AMT_CONTROL()->OpenGlobalObjects());

    #endif

	}

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

// AppendScreenL

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

//

void CAlfHierarchyModel::AppendScreen( TInt aScreenNumber )

    {

    __ALFLOGSTRING1("CAlfHierarchyModel::AppendScreenL( %d )", aScreenNumber );

    if ( aScreenNumber > 0 ) // first display comes with the package. only the following are created when requested

        {

        iServer.Bridge()->AddData( EAlfDSCreateNewDisplay, aScreenNumber, 0, NULL );

        }

    }

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

// RemoveScreenL

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

//

void CAlfHierarchyModel::RemoveScreen( TInt aScreenNumber )

    {

    if ( aScreenNumber < 1 ) 

		{

		// The main display cannot be removed.

		return;

		}

    __ALFLOGSTRING1("CAlfHierarchyModel::RemoveDisplayL( %d )", aScreenNumber );

    // NOTE & TODO: This works fine, if we are removing the last added display. If we happen to remove display in the middle,

    // then referring to displays by their indeces would be a major problem

    // TODO: Who destroyes the nodes on this display? wserv?

    iServer.Bridge()->AddData( EAlfDSDestroyDisplay, aScreenNumber, 0, NULL );

    }

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

// destructor

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

//

CAlfHierarchyModel::~CAlfHierarchyModel()

    {

    // we do not complete pending messages 

	iPendingAlfWindowDataMessages.Close(); 

	iNodeHashArray.Close();

    if (iServer.Bridge())

        {

        iServer.Bridge()->SetBatchObserver(0);

        }

    delete iPeriodic;

    iSema.Close();

    if(iStream)

        {

        iStream->Close();

        delete iStream;

        iStream = NULL;

        }

    iChunk.Close();

#ifdef ALF_DEBUG_TRACK_DRAWING 

    delete iCommandDebugger;

#endif

    iUpdateRegion.Close();    

#ifdef USE_MODULE_TEST_HOOKS_FOR_ALF

    delete AMT_CONTROL();

    Dll::FreeTls();

#endif

    }

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

// ReleaseSemaphor

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

//

void ReleaseSemaphor(TAny* aAlfHierarchyModel)

    {

    CAlfHierarchyModel* me = (CAlfHierarchyModel*)aAlfHierarchyModel;

    me->DoReleaseSemaphor();

    }

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

// DoReleaseSemaphor

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

//

void CAlfHierarchyModel::DoReleaseSemaphor()

    {

    iSema.Signal();

    }

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

// RequestPacketEndCallback

// 

// This is used to notify when certain offset in the chunk is freed. To avoid 

// excessive notifications (and callbacks), skip some of the notifications.

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

//

void CAlfHierarchyModel::RequestPacketEndCallback( TInt aOffset )

    {

    if ( aOffset > iPreviousCallbackOffset + KChunkCommitBatchSize || aOffset < iPreviousCallbackOffset )

        {

        iPreviousCallbackOffset = aOffset;

        iServer.Bridge()->RequestCommandReadNotification( aOffset );

        }

    }

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

// RequestFrameEndCallback

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

//

void CAlfHierarchyModel::RequestFrameEndCallback(TBool aCompositionModified)

    {

    __ALFLOGSTRING1( "CAlfHierarchyModel::RequestFrameEndCallback, composition modified: %d", aCompositionModified);

    iServer.Bridge()->StartNewBlock(aCompositionModified);

    }

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

// HandleMessageL

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

//

void CAlfHierarchyModel::HandleMessageL( const RMessage2& aMessage )

    {

    iSema.Wait();

    CleanupStack::PushL(TCleanupItem(ReleaseSemaphor, this));

    TBool doComplete= EFalse;

    // __ALFLOGSTRING1( "CAlfHierarchyModel::HandleMessageL %d", aMessage.Function() );

    switch (aMessage.Function())

        {

        case EAlfBridgerRequestDataBlock:

            {

            ShareChunkL( aMessage );

            return;

            }

        case EDsNotifyNativeWindowData:

            {

            User::Leave(KErrNotSupported);

            return;

            }

        case EAlfBridgerAsyncronousData:

            {

            if ( iChunk.Handle() )

                {

                ExecuteCommandsL(aMessage.Int1());

                if ( iBatchAlreadyCommited )

                    {

                    // This may happen, if alfstreamerbridge happens to process the commands (containing the EAlfCommitBatch) 

                    //  before this asyncronous request is received.

                    __ALFLOGSTRING("Batch already completed. Complete immediately");

                    aMessage.Complete( EAlfBridgerAsyncronousData );

                    iBatchAlreadyCommited = EFalse;

                    }

                else

                    {

                    SetSynchMessage(&aMessage);

                    }

                }

            break;

            }

        case EAlfBridgerBlindSend:

            {

            ExecuteCommandsL();

            CleanupStack::PopAndDestroy(); // releases iSema

            aMessage.Complete( EAlfBridgerBlindSend );

            return;

            }

        case EAlfBridgerSendChunk:

            {

            OpenChunkL( aMessage );

			aMessage.Complete( EAlfBridgerSendChunk );

            return;

            }

        case EAlfSynchronize:

            {

            iServer.Bridge()->AddData( EAlfDSSynchronize, aMessage.Int0() );

            aMessage.Complete( KErrNone );

            }

            break;

        default:

            {

            doComplete= ETrue;

            __ALFLOGSTRING("CAlfHierarchyModel::HandleMessageL, default case reached.");

            break;

            }

        }

    if (doComplete && !aMessage.IsNull())

        {

        aMessage.Complete(KErrNotSupported);

        }

    CleanupStack::PopAndDestroy(); // releases iSema

    }

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

// ShareChunkL

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

//

void CAlfHierarchyModel::ShareChunkL( const RMessage2& aMessage )

    {

    if ( !iChunk.Handle() )

        {

        // For security reasons, alfserver owns the chunk. Because it is nameless, it cannot be accessed

        // unless a handle to the chunk is given by alfserver

        //

        // TODO:CHECK what if somebody else wants to send EAlfBridgerRequestDataBlock. Currently we are giving the chunk

        // to anybody who connects to the server.

        iChunk.CreateDisconnectedGlobal( KNullDesC, 0, KChunkMaxSize, KChunkMaxSize ); //CreateDisconnectedGlobal

        iChunkHeader  = reinterpret_cast<TChunkHeader*>(iChunk.Base());

        memset( iChunkHeader, 0, sizeof( TChunkHeader ) );

        }

    TInt screenNumber = aMessage.Int1();

    TPckg<TInt> pkgLength( KChunkMaxSize );

    AppendScreen( screenNumber );

    aMessage.WriteL(0, pkgLength );

    aMessage.Complete( iChunk );

    if ( iStream )

        {

        iStream->Close();

        }

    else

        {

        iStream = new(ELeave)RMemReadStream;

        }

    iStream->Open( iChunk.Base() + sizeof( TChunkHeader), KChunkMaxSize );

    CleanupStack::PopAndDestroy(); // releases iSema

}

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

// ShareChunkL

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

//

void CAlfHierarchyModel::OpenChunkL( const RMessage2& aMessage )

    {

    TInt size = aMessage.Int0();

    TInt32 handle = aMessage.Int1();

    TBool openForReading = aMessage.Int2();

    iCacheChunks.Insert( handle, RChunk() );

    iCacheChunks.Find( handle )->SetHandle( aMessage.Int1() );

    iCacheChunks.Find( handle )->Open( aMessage, 1, EFalse, EOwnerProcess );

    if ( openForReading ) 

        {

        if (iStream)

            {

            iStream->Close();

            }

        else

            {

            iStream = new(ELeave)RMemReadStream;

            }

        TUint8*  base = iCacheChunks.Find( handle )->Base();

        iStream->Open( base + sizeof( TChunkHeader), size );

        __ALFLOGSTRING1("Chunk in use %d", iChunkInUse );

        iChunkInUse = handle;    

        iChunkHeader  = reinterpret_cast<TChunkHeader*>(base);

        }

    CleanupStack::PopAndDestroy(); // releases iSema

}

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

// CloseChunkL

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

//

void CAlfHierarchyModel::CloseChunk( TInt32 aChunkHandle )

    {

    __ALFLOGSTRING1("CAlfHierarchyModel::CloseChunkL: closing %d", aChunkHandle );

    RChunk* chunk = iCacheChunks.Find( aChunkHandle );

    iCacheChunks.Remove( aChunkHandle );

    if ( chunk )

        {

        chunk->Close();

        }

    else

        {

        __ALFLOGSTRING1( "CAlfHierarchyModel::CloseChunkL - Warning: chunk %d not found!", aChunkHandle );

        }

    }

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

// ReadEndMarkerL

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

//

void CAlfHierarchyModel::ReadEndMarkerL()

    {

    TUint8 marker = iStream->ReadInt8L();

    ASSERT( marker == EAlfCommandEndMarker ) ; // endmarker

    }

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

// ReadRectL

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

//

void CAlfHierarchyModel::ReadRectL( TRect& aRect, RMemReadStream* aStream )

    {

    aStream->ReadL( (TUint8*)&(aRect.iTl.iX), sizeof( TRect) );

    }

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

// ReadRegionL

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

//

void CAlfHierarchyModel::ReadRegionL( RMemReadStream* aStream, RRegion& aRegion, TPoint aWindowPos )

    {

    aRegion.Clear();

    TRect rect;

    TInt count = aStream->ReadInt32L();

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

        {

        ReadRectL( rect, aStream );

        rect.Move(-aWindowPos);

        aRegion.AddRect( rect );

        }

    }

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

// ExecuteCommandsL

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

//

void CAlfHierarchyModel::ExecuteCommandsL( TBool aCompositionModified )

    {

    if ( !iStream )

        {

        return;

        }

    TInt offset = iStream->Source()->TellL( MStreamBuf::ERead ).Offset();

#ifdef _ALF_LOGGING

    TInt commandCount(0);

    TSgcCanvasCommands previousCommand;

#endif

    TSgcCanvasCommands command = EAlfCommandNotInitialized;

    TTime beginTime;

    beginTime.HomeTime();

    __ALFLOGSTRING1( "CAlfHierarchyModel::ExecuteCommandsL - Committed write offset: %d", iChunkHeader->iCommittedWriteOffset );

    while( iChunkHeader->iCommittedWriteOffset != offset )

        {

#ifdef _ALF_LOGGING

        previousCommand = command;

#endif

        TRAPD( err,

                command = (TSgcCanvasCommands)iStream->ReadUint8L();

                iScreenNumber = iStream->ReadUint8L();

            );

        if ( err != KErrNone )

	          {

#ifdef _ALF_LOGGING

	          __ALFLOGSTRING3("CAlfHierarchyModel::ExecuteCommandsL - Cmd: %d, Previous Cmd: %d, Count: %d..", command, previousCommand, commandCount );

#endif	          

	          __ALFLOGSTRING2("..CAlfHierarchyModel::ExecuteCommandsL - Offset: %d, LEAVE WITH ERROR: %d", offset, err  );

              }

#ifdef ALF_DEBUG_TRACK_DRAWING 

        commandCount++;

        iUsedCommands[command]++;

        iCommandDebugger->SetDescription( command );

        __ALFLOGSTRING3("CAlfHierarchyModel::ExecuteCommandsL (%d) %S offset: %d,", command, &iCommandDebugger->Text(), offset );

#endif        

        switch ( command )

            {

        	case EAlfSetWindowId:

                {

                TUint32 nodeId = (TUint32)iStream->ReadUint32L();

                CAlfNodeVisual* node = (CAlfNodeVisual*)FindNode( nodeId );

                if ( node )

                    {

#ifdef ALF_DEBUG_TRACK_DRAWING					

                    if (node->iId == iSearchNode || node->Tracking() )

                        {

                        RDebug::Print( _L( "CAlfHierarchyModel::ExecuteCommandsL - Tracking"));

                        }

#endif						

#ifdef ALF_DEBUG_PRINT_NODE_INFO

                    _LIT( KText, "Drawing");

                    // node->PrintInfo(0, node, TPtrC(KText) , iSearchNode);

#endif

                    node->DrawWindowFrameL( *iStream );

                    }

                else

                    {

                    ProcessUnknownNodeDrawingL( *iStream );

                    }

                break;

                }

            case EAlfNodeCreated:

                {

                DoNodeCreatedL();

                break;

                }

            case EAlfNodeReleased:

                {

                DoNodeReleasedL();

                break;

                }

            case EAlfNodeActivated:

                {

                DoNodeActivatedL();

                break;

                }

            case EAlfNodeExtentChanged:

                {

                DoNodeExtentChangedL();

                break;

                }

            case EAlfNodeSiblingOrderChanged:

                {

                DoNodeSiblingOrderChangedL();

                break;

                }

            case EAlfNodeFlagChanged:

                {

                DoNodeFlagChangedL();

                break;

                }

            case EAlfNodeFadeCountChanged:

                {

                DoNodeFadeCountChangedL();

                break;

                }                

            case EAlfNodeFadeAllChildren:

                {

                DoNodeFadeAllChildrenL();

                break;

                }                

            case EAlfNodeTransparentRegionChanged:

                {

                DoNodeTransparentRegionChangedL();

                break;

                }

            case EAlfNodeLayerAdded:

                {

                DoNodeLayerAddedL();

                break;

                }

            case EAlfNodeLayerExtentChanged:

                 {

                 DoNodeLayerExtentChangedL();

                 break;

                 }