/*

* 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:   Handles serializing of data and sending it to alf streamer server.

*

*/

#ifndef CALFSENDBUFFER_H_

#define CALFSENDBUFFER_H_

#include <e32cmn.h>

#include <e32std.h> 

#include <s32mem.h>

#include <gdi.h>

#include <alfwindowstructs.h>

#include <huiwscanvascommands.h>

#include "alfrenderstageutils.h"

#define _OLD_STREAM

const TInt KAlfWsCommandCount = 90; 

const TInt KAlfWsMaxParameterCount = 15;

const TInt KAlfRsSearchRectMaxCount = 9;

class RAlfBridgerClient;

class CAlfCommandDebug;

class TRgb;

class CAlfRenderStage;

class TResourceReader;

class CAlfCompositionCntrlClient;

/**

 *  The class handles data serialization and syncronous sending to server. Multiple renderstages will share the same chunk.

 *

 *  @code

 *   iAlfSendBuffer = CAlfRsSendBuffer::NewL();

 *  @endcode

 *

 *  @lib alfrenderstage.lib

 *  @since S60 v5.2

 */

NONSHARABLE_CLASS(CAlfRsSendBuffer) : public CActive, public MAlfBridge

	{

    public: // New methods

	    /**

	     * NewL

	     * 

	     * Constructor

	     * 

	     * @param aParent   

	     * @param aScreenNumber   

	     * @return  New instance of the class

	     */

		static CAlfRsSendBuffer* NewL( CAlfRenderStage& aParent, TInt aScreenNumber );

	    /**

	     * C++ destructor.

	     */

		virtual ~CAlfRsSendBuffer();

		/**

	     * ConnectL

	     *

	     * Establish connection to AlfStreamerServer.

	     *

	     * @return ETrue, if connection was made or connection was already established. Otherwise returns EFalse

	     */

		TBool ConnectL();

        /**

         * Connected

         *

         * Check connection state

         *

         * @return Connection state

         */

		TBool Connected(){ return iChunk.Handle(); }

        /**

         * WriteIntsL

         * 

         * Convenience function for writing TInt values to the stream

         *

         * @param aCommand  CommandId

         * @param aCount    Amount of TInt values to be streamed

         * @param aFirst    The first value

         * @param ...       variable aCount-1 amount of TInt values

         */

	    void WriteIntsL( const TUint8& aCommand, TInt aCount, TRefByValue<const TInt> aFirst, ...);

	    /**

         * WriteIntL

         * 

         * Convenience function for writing possible unsupported command (depending on its parameters) to the stream 

         *

         * @param aCommand   CommandId

         * @param aValue    parameters value

         */

	    void WriteIntL( const TUint8& aCommand, TInt aValue );

        /**

         * WriteRegionL

         * 

         * Convenience function for writing region to the stream 

         *

         * @param aCommand   CommandId

         * @param aRegion    Region

         */

	    void WriteRegionL( const TUint8& aCommand, const TRegion& aRegion );

	    /**

         * WriteDescriptorAndIntsL

         * 

         * Convenience function for writing TDesC reference and TInt values to the stream.

         * Inserts padding to ensure that text starts on divisible by 4 offset.

         *

         * @param aCommand  CommandId

         * @param aText     Descriptor to be streamed

         * @param aCount    Amount of TInt values to be streamed

         * @param aFirst    The first value

         * @param ...       variable aCount-1 amount of TInt values

         */

        void WriteDescriptorAndIntsL( const TUint8& aCommand, const TDesC& aText, TInt aCount, TRefByValue<const TInt> aFirst,... );

        /**

         * WriteDescriptorL

         * 

         * Convenience function for writing TDesC reference to the stream. 

         * Inserts padding to ensure that text starts on divisible by 4 offset.

         *

         * @param aCommand  CommandId

         * @param aText  Descriptor to be streamed

         * @param aTextParameter    Text parameters

         * @param aCount Amount of Ints to be streamed

         * @param aFirst    The first value

         * @param ...       variable aCount-1 amount of TInt values

         */

        void WriteDescriptorAndIntsL(const TUint8& aCommand, const TDesC& aText, const CGraphicsContext::TTextParameters* aTextParameter, TInt aCount, TRefByValue<const TInt> aFirst, ... );

	    /**

         * WriteCommandL

         * 

         * Convenience function for writing 1 value to the stream

         *

         * @param aCommand  Command

         * @param aSize  Size

         */

        void WriteCommandL( const TUint8& aCommand, TInt aSize = 0);

        /**

         * WritePointArrayL

         * 

         * Convenience function for writing pointer array to the stream

         *

         * @param aCommand  CommandId

         * @param aPoWriteIntList  Point array to be streamed

         */

        void WritePointArrayL( const TUint8& aCommand, const CArrayFix<TPoint>* aPoWriteIntList );

        /**

         * WritePointArrayL

         * 

         * Convenience function for writing pointer array to the stream

         *

         * @param aCommand  CommandId

         * @param aPoWriteIntList  Point array to be streamed

         * @param aNumPoints  Point array to be streamed

         */

        void WritePointArrayL( const TUint8& aCommand, const TPoint* aPoWriteIntList, TInt aNumPoints );

        /**

         * WritePointArrayL

         * 

         * Convenience function for writing pointer array to the stream

         *

         * @param aCommand  CommandId

         * @param aPoWriteIntList  Point array to be streamed

         */

        void WritePointArrayL( const TUint8& aCommand, const TArray<TPoint>* aPoWriteIntList );

        /**

         * WriteFlagsL

         * 

         * Write flags to the stream

         */

        void WriteFlagsL();

	//

	// ARRAY IMPLEMENTATION

	//	

	struct TOffsetElem

	{

	TInt32 iOffset; // offset from beginning of buffer

	TInt32 iSize;   // size of the data.

	TInt32 iLayerId;

    TRect iBoundingRectangle;

    };

	void WriteArrayHeaderTemplateL();

	void InitTOffsetElemArray(RArray<TOffsetElem> &aOffset);

	void WriteArrayHeaderL(const TOffsetElem &aIndexArrayOffset);

	TOffsetElem WriteIndexArrayL(const RArray<TOffsetElem> &aOffset);

	void InitMarker(TInt &aMarker);

	void StartMarkerL(TInt &aMarker, TRect &aRectangle, TInt &aLayer, TRect aBoundingRectangle, TInt aLayerId);

	void EndMarkerL(RArray<TOffsetElem> &aOffset, TInt &aMarker, const TRect &aRectangle, TInt aLayerId);

    void StartMarkerL(TRect aBoundingRectangle, TInt aLayerId);

    void EndMarkerL();

       /**

        * SendL

        *

        * Sends commands to via AlfBridger to AlfStreamerServer. Flushes the buffer.

        * iBufStream is ready for writing after this call.

        *

        * @param aStatus  Request status

        */

        void SendL( TRequestStatus* aStatus );

        /**

         * Commit

         * 

         * Report the last written offset. Reader side may read until

		 * offset.

         * 

         */

        void Commit();

        /**

         * CommitL

         * 

         * Starts the timer for FlushBuffer call. The idea is to deliver bigger 

         * patch of commands to alf in one go and avoid unnecessary IPC calls.

         * 

         */

        void CommitL( );

        /**

         * SetFlag

         * 

         * Set flags

         * 

         * @param aFlag  Flags

         */

        void SetFlag( TAlfSendBufferFrameFlags aFlag );

        /**

         * EndFrameL

         * 

         * Prepares frame for sending

         */

        void EndFrameL();

        /**

         * FrameContainsDataL

         * 

         * @return  ETrue, if data has been serialized to the frame after previous call to PrepareBufferL. this is used for filtering out empty

         *          frames. Wserv might be fixed in the future and this could become obsolete.

         */

        TBool FrameContainsDataL();

        /**

         * SendAsyncCmd

         * 

         * Called by CRsAlfNativeWindowListener::RequestEvent. Used when requesting native window handle from 

         * Alf.

         * 

         * @param aFlag  aCmd

         * @param aFlag  aBuf

         * @param aFlag  aStatus

         */

		void SendAsyncCmd(TInt aCmd, TDes8& aBuf, TRequestStatus& aStatus);

        /**

         * OpenPrimaryChunkForWritingL

         * 

         * Open the stream 

         */

		void OpenPrimaryChunkForWritingL();

        /**

         * PrepareBufferL

         * 

         * Resets buffer. Must be called before Write*L and SendSyncL.

         */

        void PrepareBufferL();

		/**

         * WriteWindowDataL

         *

         * Writes data to the stream

         *

         * @param aWindowUid

         * @param aRegionSize

         * @param aShapeRegionSize

         */

        void WriteWindowDataL(TUint32 aWindowUid, TInt aRegionSize, TInt aShapeRegionSize );

        /**

         * WriteFrameSizeTemplateL

         * 

         * Writes a temporary value to the beginning of a frame. This value is later updated with WriteNextFrameBeginL.

         */

        void WriteFollowingFrameOffsetTemplateL();

        /**

         * WriteFollowingFrameOffsetL

         * 

         * Goes back to header of the drawing commands and updates the offset to the following frame.

         * This is called, when drawing into a single window in a frame is complete.

         * 

         * @return  ETrue, If this frame contains any commands. Otherwise EFalse.

         */

        TBool WriteFollowingFrameOffsetL(TBool aWriteArray= ETrue);

        /**

		 * WriteWindowIdentifierL

		 *

		 * Convience function for writing window id and group id to the stream

		 */

		void WriteWindowIdentifierL();

		/**

		 * FlushBuffer

		 * 

		 * Commands are not passed immediately after they are serialized. There

		 * is a timer, which regularly flushes the buffer. See doFlushBuffer. 

		 *

		 * Buffer is also flushed (or in fact the flushtimer is canceled, and buffer

		 * is flushed) when SendL is called from CAlfRsRenderStage

		 * 

		 */

		void FlushBuffer();

        /**

         * SetSupportedCommand

         * 

         * Sets this command as supported

         * 

         * @param aIndex

         * @param aSupport

         */

		void SetSupportedCommand( TInt aIndex, TInt8 aSupport );

		/**

		 * AppendPatternSearchCache

		 * 

		 * Caches data for the pattern search. This is call from CAlfRsGc. Cache is released by

		 * ResetPatternSearch.

		 * 

         * @param aSourceBitmap

         * @param aMaskBitmap

         * @param aSourceRect

         * @param aDestPos

         * @param aInvertMask

		 */

	    void AppendPatternSearchCache( const CFbsBitmap& aSourceBitmap, const CFbsBitmap* aMaskBitmap,const TRect& aSourceRect, const TPoint& aDestPos, TBool aInvertMask );

        /**

         * PreviousCommand

         * 

         * This is used for filtering out sequential reset commands in window command stream

         * 

         * @return Previous command

         */

        inline TInt PreviousCommand(){ return iPreviousCommand; } 

    public: // From CActive

	    void RunL();

	    void DoCancel();

	private:

       /**

        * CAlfRsSendBuffer

        * 

        * C++ constructor

        * 

        * @param aParent

        * @param aScreenNumber

        */

	    CAlfRsSendBuffer( CAlfRenderStage& aParent, TInt aScreenNumber ) : iParent( aParent), iScreenNumber( aScreenNumber) , CActive( EPriorityStandard ){CActiveScheduler::Add( this ); };

       /**

        * ConstructL

        * 

        * Constructor

        */

        void ConstructL();

        /**

         * ReadNonSupportedCommandsL

         * 

         * It is known that some commands are not/cannot be supported by certain

         * renderers. Each frame is inspected in case of such command and frame 

         * is marked if it has unsupported commands for certain renderer. This

         * information can be in the future used for selecting suitable renderer

         * during runtime.

         * 

         * @todo This table could be shared with multiple renderstages. 

         *       Currently each sendbuffer has own table.

         */

        void ReadNonSupportedCommandsL();

        // only in debug mode

#ifdef _ALF_PRINT_WS_COMMANDS_

        void ReadCommandDescriptionsL();

#endif

		/**

		 * SeekL

		 * 

		 */

	    void SeekL( const TInt aOffset );

	    /**

	     * ConvertToBitsL

	     * 

	     * Converts aCount bytes of data into one byte.

	     * 

	     * @param  aCount  Must be under 7.

	     * @param  aReader

	     * @return Converted result

	     */

	    TUint8 ConvertToBitsL( TInt aCount, TResourceReader* aReader );

        /**

         * JumpToAnotherChunkL

         */

	    void JumpToAnotherChunkL( TInt32 aChunkId, TInt aChunkSize );

        /**

         * WriteInt8L

         */

	    inline void WriteInt8L( const TInt8& aValue )

	        {

#ifdef _OLD_STREAM

	        iBufStream->WriteInt8L( aValue );

#else

	        //memcpy( ( TUint8*)(iStreamPtr->Ptr()+iOffset), (const TUint8*)&aValue, sizeof(TInt8));

	        *(( TUint8*)(iStreamPtr->Ptr()+iOffset)) = aValue;

#endif

            iOffset += sizeof(TInt8);

            }

        /**

         * WriteInt32L

         */

	    inline void WriteInt32L( const TInt32& aValue )

	        {

#ifdef _OLD_STREAM

	        iBufStream->WriteInt32L( aValue );

#else

	        memcpy( ( TUint8*)(iStreamPtr->Ptr()+iOffset), (const TUint8*)&aValue, sizeof(TInt32));

#endif

            iOffset += sizeof(TInt32);

	        }

        /**

         * WriteL

         */

	    inline void WriteL( const TUint8* aPtr, TInt aSize )

	        {

#ifdef _OLD_STREAM	        

	        iBufStream->WriteL( aPtr, aSize );

#else

	        memcpy( ( TUint8*)(iStreamPtr->Ptr()+iOffset), (const TUint8*)aPtr, aSize);

#endif

	        iOffset += aSize;

	        }

        /**

         * DoCreateTemporaryChunkL

         */

		void DoCreateTemporaryChunkL( TInt aMinimumRequiredSize );

	    /**

	     * DoWrapL

	     * 

	     * Wraps the writing in the chunk. This happens when write head has reached the maximum size of the chunk.

	     * After wrapping, writing continues from the beginning of the chunk. If wrap happens during a frame, then 

	     * the frame is split into two parts. The first part is padded (@see InsertPaddingL) 

	     * 

	     */

	    void DoWrapL( TInt aCommandSize, TBool aCreateTempororaryChunk );

	    /**

	     * ReserveSpaceL

	     * 

	     * Checks if there is enough space to stream the command. Calls DoWrap 

	     * or DoWait, if there is not enough space for serializing the command. 

	     * 

	     * @param  aCommandSize

	     */

	    TBool ReserveSpaceL( TInt aCommandSize );

        /**

         * InitCommandL

         */

	    TBool InitCommandL( const TUint8& aCommand, TInt aSize );

        /**

         * CreateTemporaryChunkL

         */

	    TBool CreateTemporaryChunkL( TInt& aSize );

        /**

         * OpenRewindChunkL

         */

	    void OpenRewindChunkL( TInt aSize );