/* Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and /or associated documentation files
 * (the "Materials "), to deal in the Materials without restriction,
 * including without limitation the rights to use, copy, modify, merge,
 * publish, distribute, sublicense, and/or sell copies of the Materials,
 * and to permit persons to whom the Materials are furnished to do so,
 * subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Materials.
 *
 * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE MATERIALS OR
 * THE USE OR OTHER DEALINGS IN THE MATERIALS.
 *
 * Initial Contributors:
 * Nokia Corporation - initial contribution.
 *
 * Contributors:
 *
 * Description:
 *
 */

#ifndef _EGLSURFACE_H_
#define _EGLSURFACE_H_

#include <EGL/egl.h>
#include "eglInternal.h"
#include "EGLStructs.h"
#include "BufferContainer.h"
#include "SurfaceDescriptor.h"

class CEGLContext;
class CEGLConfig;
class CEGLThread;

class CEGLSurface : public RefCountingObject
{
public:
    enum SurfaceType
        {
        WINDOW_SURFACE = 1,
        PBUFFER_SURFACE,
        PIXMAP_SURFACE
        };

protected:
    CEGLSurface( CEGLSurface::SurfaceType type, EGLint colorSpace, EGLint alphaFormat, EGLint renderBuffer, CEGLConfig* config );

public:
	virtual ~CEGLSurface(void);

public:
    void BindToContext( CEGLContext* context );
    inline CEGLContext* BoundContext() const { return m_boundContext; }
    inline void SetThread( CEGLThread* thread ) { m_thread = thread; }
    inline CEGLThread* Thread() const { return m_thread; }
    inline CEGLConfig* Config() const { return m_config; }
    inline CEGLSurface::SurfaceType Type() const { return m_type; }
    inline EGLint RenderBuffer() const { return m_renderBuffer; }
    inline EGLint AlphaFormat() const { return m_alphaFormat; }
    inline EGLint ColorSpace() const { return m_colorSpace; }
    inline EGLint MipmapLevel() const { return m_mipmapLevel; }
    inline EGLint MultisampleResolve() const { return m_multisampleResolve; };
    inline EGLint SwapBehavior() const { return m_swapBehavior; }
	inline EGLITextureBinding& TextureBinding() { return m_textureBinding; }
    
    EGLint Width() const { return m_width; }
    EGLint Height() const { return m_height; }
    void SetStride( EGLint stride ) { m_stride = stride; }
    EGLint Stride() const { return m_stride; }
    bool Resize( EGLint width, EGLint height );
    void Size( int& width, int& height ) { width = m_width; height = m_height; }

    BufferContainer* VGBuffers() { return &m_vgBuffers; }
    BufferContainer* GLESBuffers() { return &m_glesBuffers; }
    void* VGColorBuffer() const { return m_vgBuffers.m_colorBuffer; }
    void* GLESColorBuffer() const { return m_glesBuffers.m_colorBuffer; }
    void* VGClientSurface() const { return m_vgBuffers.m_clientSurface; }
    void* GLESClientSurface() const { return m_glesBuffers.m_clientSurface; }

    SurfaceDescriptor* Descriptor();

    void SetAttribute( EGLint attrib, EGLint value );
    EGLint Attribute( EGLint attrib ) const;

    void Lock();
    void Unlock();
    bool IsLocked() const { return m_isLocked; }
    void SetVGDirty( bool dirty ) { m_vgDirty = dirty; }
    bool IsVGDirty() const { return m_vgDirty; }
    void SetGLES1Dirty( bool dirty ) { m_gles1Dirty = dirty; }
    bool IsGLES1Dirty() const { return m_gles1Dirty; }
    void SetGLES2Dirty( bool dirty ) { m_gles2Dirty = dirty; }
    bool IsGLES2Dirty() const { return m_gles2Dirty; }

private:
	SurfaceType     m_type;
    EGLint          m_colorSpace;
    EGLint          m_alphaFormat;
    EGLint          m_renderBuffer;
    CEGLConfig*     m_config; // not owned
    CEGLContext*    m_boundContext; // not owned
    CEGLThread*     m_thread; // not owned

protected:
    EGLint              m_width;
    EGLint              m_height;
    EGLint              m_stride;
    BufferContainer     m_vgBuffers;
    BufferContainer     m_glesBuffers;
    SurfaceDescriptor   m_surfaceDescriptor;
    EGLint              m_mipmapLevel;
    EGLint              m_multisampleResolve;
    EGLint              m_swapBehavior;
	EGLITextureBinding	m_textureBinding;
    EGLI_LOCK           m_lock;
    bool                m_vgDirty;
    bool                m_gles1Dirty;
    bool                m_gles2Dirty;
    bool                m_isLocked;
};

#endif //_EGLSURFACE_H_