/* 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 _VGINTERFACE_H_

#define _VGINTERFACE_H_

#include "ImageTarget.h"

struct SurfaceDescriptor;

struct BufferContainer;

class CColorDescriptor;

typedef void (*fpVGProc)(void);

// EGL services for VG

class IVGtoEGLInterface

    {

public:

    // \todo Descriptions

    virtual void* GetVGContext() = 0;

    virtual bool IsImageInUse( void* image ) = 0;

    virtual bool LockVGSurface( bool read, bool write ) = 0;

    virtual bool UnlockVGSurface() = 0;

    virtual void GetDescForImage( void* image, SurfaceDescriptor& ImageDesc ) = 0;

    virtual void* GetDataForImage( void* image ) = 0;

	virtual void RegisterImageTarget( void* image, EImageTarget target, void* buffer ) = 0;

	virtual void UnregisterImageTarget( void* image, EImageTarget target, void* buffer ) = 0;

    };

// VG services for EGL

class IEGLtoVGInterface

    {

public:

    /* \brief Sets interface for EGL services to VG

     *

     * \param egl Pointer to IVGtoEGLInterface implementation.

     */

    virtual void SetEGLInterface( IVGtoEGLInterface* egl ) = 0;

    /* \brief Used to create internal VG context

     * 

     * \param shareContext  Context to be shared with created context

     *

     * \return  Handle to created context

     */

    virtual void* CreateContext( void* shareContext ) = 0;

    /* \brief Releases internal VG context

     * 

     * \param context   Context to be released

     *

     * \return  true if release succeeded false otherwise

     */

    virtual bool ReleaseContext( void* context ) = 0;

    /* \brief Creates internal VG surface

     * 

     * \param desc      Descriptor describing surface pixel format, size, stride etc.

     * \param buffers   Container for buffers. VG should fill in handle for surface, color buffer and mask buffer.

     * \param image     VG image handle used in surface creation (eglCreatePbufferFromClientBuffer()).

     *

     * \return true if surface creation succeeded false otherwise

     */

    virtual bool CreateSurface( const SurfaceDescriptor* desc, BufferContainer* buffers, void* image ) = 0;

    /* \brief Releases internal VG surface

     * 

     * \param surface   Surface to be released

     *

     * \return  true if surface release succeeded false otherwise

     */

    virtual bool ReleaseSurface( void* surface ) = 0; 

    /* \brief Sets current surface for internal VG context

     * 

     * \param context   Handle to internal VG context

     * \param surface   Handle to internal VG surface to be set current to context.

     *

     * \return  true if succeeded false otherwise

     */

    virtual bool SetCurrentSurface( void* context, void* surface ) = 0;

     /* \brief Resizes internal VG surface

     * 

     * \param context   Handle to internal VG context

     * \param surface   Handle to internal VG surface

     * \param width     New width

     * \param height    New height

     * \param buffers   Container for buffers. VG should fill in handle for surface, color buffer and mask buffer.

     *

     * \return  true if resize succeeded false otherwise

     */

    virtual bool ResizeSurface( void* context, void* surface, int width, int height, BufferContainer* buffers ) =0;

    /* \brief Checks if image handle is valid VGImage

     * 

     * \param image     Handle to VG image

     * \param colorDesc Color descriptor. VG should fill in descriptor describing image.

     * \param width     On return should contain widht of the VG image

     * \param height    On return should contain height of the VG image

     *

     * \return  true if image is valid false otherwise

     */

    virtual bool IsValidImage( void* image, CColorDescriptor* colorDesc, int* width, int* height ) = 0;

    /* \brief Checks if image handle is in use by VG

     *

     * param image      Handle to VG image

     * return true if image is in use false otherwise

     */

    virtual bool IsImageInUse( void* image ) = 0;

    /* \brief Flushes current vg context. Same operation as vgFlush().

     */

    virtual void Flush() = 0;

    /* \brief Finishes VG drawing. Same operation as vgFinish().

     */

    virtual void Finish() = 0;

    /* \brief Used to get address of vg extension function. Called by eglGetProcAddress().

     *

     * \param procname Name of the vg extension function

     *

     * \return  Address of the vg extension function or NULL if extension is not found.

     */

    virtual fpVGProc GetVGProcAddress( const char *procname ) = 0;

    /* \brief Copy VG color buffer into buffer.

     * 

     * \param buffer Buffer to copy data from VG color buffer

     * \param stride Buffer stride

     * \param surface Handle to VG internal surface to copy color buffer from.

     * 

     * \return void

     */

    virtual void CopyBuffers( void* buffer, int stride, void* surface ) = 0;

    /* \brief Updates VG color buffer

     *

     * \param buffer Buffer to copy data from

     * \param stride Stride of buffer

     * \param desc   Surface descriptor describing buffer.

     *

     * \return void

     */

    virtual void UpdateBuffers( void* buffer, int stride, const SurfaceDescriptor* desc ) = 0;

    /* \brief Checks if VG image is root image

     *

     * \param image Handle to VG image

     *

     * \return True if image is root, false otherwise

     */

    virtual bool IsRootImage( void* image ) = 0;

    /* \brief Copies data from VG image

     * 

     * \param image Handle to VG image

     * \param desc  Descriptor describing VG image. Function should fill descriptor.

     * \param data  Pointer to copy data to.

     * 

     * \return void

     */

    virtual void GetImageData( void* image, SurfaceDescriptor& desc, void* data ) = 0;

    /* \brief Add(+1) VG image reference count when EGLimage is created from VGImage

     * 

     * \param image Handle to VG image

     * 

     * \return void

     */

    virtual void AddRef( void* image ) = 0;

    /* \brief Remove(-1) VG image reference count when EGLimage deleted

     * 

     * \param image Handle to VG image

     * 

     * \return void

     */

    virtual void RemoveRef( void* image ) = 0;

    };

typedef IEGLtoVGInterface* (*fpGetVGInterface)(void);

IEGLtoVGInterface* LoadVGInterface( void*& libraryHandle );

#endif // _VGINTERFACE_H_