#ifndef __RICONTEXT_H
#define __RICONTEXT_H

/*------------------------------------------------------------------------
 *
 * OpenVG 1.1 Reference Implementation
 * -----------------------------------
 *
 * Copyright (c) 2007 The Khronos Group Inc.
 * Portions 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.
 *
 *//**
 * \file
 * \brief	VGContext class. Used for storing OpenVG state.
 * \note
 *//*-------------------------------------------------------------------*/

#ifndef OPENVG_H
#include "openvg.h"
#endif

#ifndef __RIDEFS_H
#include "riDefs.h"
#endif

#ifndef __RIMATH_H
#include "riMath.h"
#endif

#ifndef __RIIMAGE_H
#include "riImage.h"
#endif

#ifndef __RIPATH_H
#include "riPath.h"
#endif

#ifndef __RIFONT_H
#include "riFont.h"
#endif

#ifndef __RIARRAY_H
#include "riArray.h"
#endif

#ifndef __SFDYNAMICBLITTER_H
#   include "sfDynamicBlitter.h"
#endif

//==============================================================================================

namespace OpenVGRI
{

class VGContext;

/*-------------------------------------------------------------------*//*!
* \brief	A list of resources (Images, Paths, or Paints) shared by a
*			set of contexts.
* \param
* \return
* \note
*//*-------------------------------------------------------------------*/

template <class Resource> class ResourceManager
{
public:
    ResourceManager() :
        m_referenceCount(0),
        m_resources()
    {
    }

    ~ResourceManager()
    {
        RI_ASSERT(m_referenceCount == 0);
        RI_ASSERT(m_resources.size() == 0);
    }

    void			addReference()
    {
        m_referenceCount++;
    }

    int				removeReference()
    {
        m_referenceCount--;
        RI_ASSERT(m_referenceCount >= 0);
        return m_referenceCount;
    }

    void			addResource(Resource* resource, VGContext* context)
    {
        Entry r;
        r.resource = resource;
        r.context = context;
        m_resources.push_back(r);	//throws bad_alloc
        resource->addReference();
    }

    void			removeResource(Resource* resource)
    {
        if(!resource->removeReference())
            RI_DELETE(resource);

        int i=0;
        bool found = false;
        for(;i<m_resources.size();i++)
        {
            if(m_resources[i].resource == resource)
            {
                found = true;
                break;
            }
        }
        RI_ASSERT(found);

        for(;i<m_resources.size()-1;i++)
        {
            m_resources[i] = m_resources[i+1];
        }
        m_resources.resize(m_resources.size()-1);
    }

    bool			isValid(Resource* resource)
    {
        for(int i=0;i<m_resources.size();i++)
        {
            if(m_resources[i].resource == resource)
                return true;
        }
        return false;
    }

    Resource*		getFirstResource(VGContext* context)
    {
        for(int i=0;i<m_resources.size();i++)
        {
            if(m_resources[i].context == context)
                return m_resources[i].resource;
        }
        return NULL;
    }

private:
    ResourceManager(const ResourceManager&);
    ResourceManager operator=(const ResourceManager&);

    struct Entry
    {
        Resource*	resource;
        VGContext*	context;
    };

    int				m_referenceCount;
    Array<Entry>	m_resources;
};

/*-------------------------------------------------------------------*//*!
* \brief
* \param
* \return
* \note
*//*-------------------------------------------------------------------*/

class VGContext
{
public:
    VGContext(VGContext* shareContext);	//throws bad_alloc
    ~VGContext();

    void            setDefaultDrawable(Drawable* drawable); //called from EGL
    Drawable*       getCurrentDrawable()        { return m_eglDrawable; }
    DynamicBlitter& getBlitter() { return m_blitter; }

    bool			isValidImage(VGImage image);
    bool			isValidPath(VGPath path);
    bool			isValidPaint(VGPaint paint);
    bool			isValidFont(VGFont font);
    bool			isValidMaskLayer(VGMaskLayer layer);

    void			releasePaint(VGbitfield paintModes);

    void			setError(VGErrorCode error)		{ if(m_error == VG_NO_ERROR) m_error = error; }

    // Mode settings
    VGMatrixMode					m_matrixMode;
    VGFillRule						m_fillRule;
    VGImageQuality					m_imageQuality;
    VGRenderingQuality				m_renderingQuality;
    VGBlendMode						m_blendMode;
    VGImageMode						m_imageMode;

    // Scissor rectangles
    Array<Rectangle>				m_scissor;

    // Stroke parameters
    RIfloat							m_strokeLineWidth;
    RIfloat							m_inputStrokeLineWidth;
    VGCapStyle						m_strokeCapStyle;
    VGJoinStyle						m_strokeJoinStyle;
    RIfloat							m_strokeMiterLimit;
    RIfloat							m_inputStrokeMiterLimit;
    Array<RIfloat>					m_strokeDashPattern;
    Array<RIfloat>					m_inputStrokeDashPattern;
    RIfloat							m_strokeDashPhase;
    RIfloat							m_inputStrokeDashPhase;
    VGboolean						m_strokeDashPhaseReset;

    // Edge fill color for vgConvolve and pattern paint
    Color							m_tileFillColor;
    Color							m_inputTileFillColor;

    // Color for vgClear
    Color							m_clearColor;
    Color							m_inputClearColor;

    Vector2                         m_glyphOrigin;
    Vector2                         m_inputGlyphOrigin;

    VGboolean						m_masking;
    VGboolean						m_scissoring;

    VGPixelLayout					m_pixelLayout;

    VGboolean						m_filterFormatLinear;
    VGboolean						m_filterFormatPremultiplied;
    VGbitfield						m_filterChannelMask;

    // Matrices
    Matrix3x3						m_pathUserToSurface;
    Matrix3x3						m_imageUserToSurface;
    Matrix3x3						m_glyphUserToSurface;
    Matrix3x3						m_fillPaintToUser;
    Matrix3x3						m_strokePaintToUser;

    VGPaint							m_fillPaint;
    VGPaint							m_strokePaint;

    VGboolean                       m_colorTransform;
    RIfloat                         m_colorTransformValues[8];
    RIuint32                        m_iColorTransformValues[8];
    RIfloat                         m_inputColorTransformValues[8];

    VGErrorCode						m_error;

    ResourceManager<Image>*			m_imageManager;
    ResourceManager<Path>*			m_pathManager;
    ResourceManager<Paint>*			m_paintManager;
    ResourceManager<Font>*			m_fontManager;
    ResourceManager<Surface>*		m_maskLayerManager;

    Rasterizer                      m_rasterizer;

    PixelPipe                       m_pixelPipe;
    DynamicBlitter                  m_blitter;

private:
    Drawable*                       m_eglDrawable;

    VGContext(const VGContext&);			//!< Not allowed.
    void operator=(const VGContext&);		//!< Not allowed.
};

//==============================================================================================

}	//namespace OpenVGRI

//==============================================================================================

#endif /* __RICONTEXT_H */