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

//

/**

 @file

 @test

 @internalComponent - Internal Symbian test code

*/

#ifndef __EGLTEST_SURFACE_H__

#define __EGLTEST_SURFACE_H__

#include <e32base.h>

#include <w32std.h>

#include <graphics/surface.h>

#include <graphics/surfacemanager.h>

#include <graphics/surfaceupdateclient.h>

#include <graphics/suerror.h>

#include <EGL/egl.h>

enum TSurfaceType

    {

    ESurfTypeRaw,

    ESurfTypeEglWindow,

    ESurfTypeRawSingleBuffered,

    ESurfTypePBuffer,

    ESurfTypeMaxTypes  // Should be the last enum.

    };

// Index to Surface Parameters.

enum TSurfaceIndex

    {

    EStandardSurface,

    EBadAttribSurface,

    EEmptyAttribSurface,

    EStandard128sqSurface,

    EUnusualStrideSurface,

    EUnalignedPixelSizeSurface,

    ELargeSurface,

    ELargestPossibleSurface,

    ESmallSurface,

    ETinySurface

    };

// Notification enums - allows us to use one function to request several notifications.

enum TNotification

    {

    ENotifyWhenAvailable,

    ENotifyWhenDisplayed,

    ENotifyWhenDispXTimes,

    };

const TInt KNumAttribs = 3;

// Common between local and remote

struct TSurfaceParamsCommon

    {

    TSurfaceIndex iIndex;   // Check that it matches - or we've got the table wrong.

    TInt iXSize, iYSize;

    TInt iBuffers;

    TInt iAlignment;

    TInt iStrideInBytes;

    TInt iOffsetToFirstBuffer;

    TUidPixelFormat iPixelFormat;

    TBool iUseAttribList; //when false use NULL in at attribute parameter

    EGLint iAttribs[KNumAttribs];

    // Window info.

    TInt iXPos, iYPos;

    TDisplayMode iDisplayMode;

    };

struct TSurfaceParamsRemote

    {

    TSurfaceId           iSurfaceId;

    TSurfaceParamsCommon iCommonParams;

    TSurfaceType         iSurfaceType;

    };

//Interface for creating, drawing to and submitting content for a surface

//Derived classes can implement different types of surface, that can be

//used in the same test code. Ie surface manager surface (raw), egl window

//surface, video surface, viewfinder surface.

class CSurface: public CBase

    {

public:

    // This function is kept for compatibility - new code should use offset

    // form of CreateL... 

    virtual void CreateL(TInt aIndex);

    // Allow an offset for the top left corner of the surface on screen. 

    virtual void CreateL(TInt aIndex, const TPoint& aOffset) = 0;

    virtual void DrawContentL(TInt aImageIndex) = 0;

    virtual void DrawContentL(const TRgb& aColour) = 0;

    virtual void DrawComplexL(const TRgb& aColour) = 0;

    virtual TInt SubmitContent(TBool aShouldWaitForDisplay, TInt aRectIndex = 0) = 0;

    virtual TSurfaceId SurfaceId() const = 0;

    virtual void GetSurfaceParamsL(TSurfaceParamsRemote &aParams) = 0;

    virtual const TText *GetSurfaceTypeStr() const = 0;

    virtual TInt Notify(TNotification aWhen, TRequestStatus &aStatus, TUint32 aXTimes) = 0;

    virtual TInt WaitFor(TNotification aWhen, TRequestStatus &aStatus, TInt aTimeoutInMicroseconds, TUint32& aTimeStamp) = 0;

    virtual TInt SizeInBytes() const;

    TSize Size();

public:

    // Factory function to create a surface of aSurfType.

    static CSurface *SurfaceFactoryL(TSurfaceType aSurfType);

protected:

    TInt  iParamIndex;

    TSize iActualSize;

    };

//Raw surface implements CSurface for basic surface manager surface.

class CRawSurface : public CSurface

    {

public:

    static CRawSurface* NewL();

    ~CRawSurface();

    // From CSurface

    virtual void CreateL(TInt aIndex, const TPoint& aOffset);

    void DrawContentL(TInt aIndex);

    void DrawContentL(const TRgb& aColour);

    void DrawComplexL(const TRgb& aColour);

    TInt SubmitContent(TBool aShouldWaitForDisplay, TInt aRectIndex = 0);

    TSurfaceId SurfaceId() const;

    void GetSurfaceParamsL(TSurfaceParamsRemote &aParams);

    virtual const TText *GetSurfaceTypeStr() const;

    virtual TInt Notify(TNotification aWhen, TRequestStatus &aStatus, TUint32 aXTimes);

    virtual TInt WaitFor(TNotification aWhen, TRequestStatus &aStatus, TInt aTimeoutInMicroseconds, TUint32& aTimeStamp);

protected:

    CRawSurface();

    void ConstructL();

    TUint8* MapSurfaceAndGetInfoLC(RSurfaceManager::TSurfaceInfoV01& aInfo);

    void GetSurfAttribs(RSurfaceManager::TSurfaceCreationAttributesBuf &aSurfaceAttribs, TInt aIndex, TInt aSizeIndex);

private:

    static TInt PixelSize(TUidPixelFormat aPixelFormat);

    static TRequestStatus *GetRequestPtr(TNotification aWhen);

private:

    RSurfaceUpdateSession  iSurfaceUpdate;

    TRequestStatus         iAvailable;

    TRequestStatus         iDisplayed;

    TRequestStatus         iDisplayedXTimes;

    TTimeStamp             iTimeStamp;

    TInt                   iDrawBuffer;

    RChunk                 iSurfaceChunk;

protected:

    TInt                   iBuffers;

    RSurfaceManager        iSurfaceManager;

    TSurfaceId             iSurfaceId;

    };

// Simple wrapper to enable a list of "singlebuffer" in the list of buffer types.

class CRawSingleBufferSurface : public CRawSurface

    {

public:

    static CRawSingleBufferSurface* NewL();

    ~CRawSingleBufferSurface();

    virtual void CreateL(TInt aIndex, const TPoint& aOffset);

    virtual const TText *GetSurfaceTypeStr() const;

    };

// Forward declare classes that we do not need to know the content of.

class CWindow;

class CTestVgImage;

class CEglSurfaceBase : public CSurface

    {

public:

    void CreateL(TInt aIndex, const TPoint& aOffset);

    void DrawContentL(TInt aImageIndex);

    void DrawContentL(const TRgb& aColour);

    void DrawComplexL(const TRgb& aColour);

    TInt SubmitContent(TBool aShouldWaitForDisplay, TInt aRectIndex = 0);

    TInt Activate();

    void ActivateL();

    void GetSurfaceParamsL(TSurfaceParamsRemote &aParams);

    virtual TInt Notify(TNotification aWhen, TRequestStatus &aStatus, TUint32 aXTimes);

    virtual TInt WaitFor(TNotification aWhen, TRequestStatus &aStatus, TInt aTimeoutInMicroseconds, TUint32& aTimeStamp);

protected:

    void BaseCreateL(TInt aIndex, EGLint aSurfaceType);

    virtual void DoCreateL(TInt aIndex, const TPoint& aOffset, TInt aSizeIndex) = 0;

    void Destroy();

protected:

    EGLContext iContext;

    EGLSurface iSurface;

    EGLDisplay iDisplay;

    EGLConfig  iConfig;

    };

class CEglWindowSurface : public CEglSurfaceBase

    {

public:

    static CEglWindowSurface* NewL();

    ~CEglWindowSurface();

    TSurfaceId SurfaceId() const;

    virtual const TText *GetSurfaceTypeStr() const;

private:

    CEglWindowSurface();

    void DoCreateL(TInt aIndex, const TPoint& aOffset, TInt aSizeIndex);

    void ConstructL();

private:

    CWindow*   iWindow;

    };

class CEglPBufferSurface : public CEglSurfaceBase

    {

public:

    static CEglPBufferSurface* NewL();

    ~CEglPBufferSurface();

    TSurfaceId SurfaceId() const;

    virtual const TText *GetSurfaceTypeStr() const;

    TInt SizeInBytes() const;

private:

    CEglPBufferSurface();

    void ConstructL();

    void DoCreateL(TInt aIndex, const TPoint& aOffset, TInt aSizeIndex);

    };

#endif