/*------------------------------------------------------------------------

 *

 * OpenVG 1.1 Reference Implementation

 * -----------------------------------

 *

 * Copyright (c) 2007 The Khronos Group Inc.

 *

 * 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	Implementation of VGContext functions.

 * \note	

 *//*-------------------------------------------------------------------*/

#include "riContext.h"

namespace OpenVGRI

{

/*-------------------------------------------------------------------*//*!

* \brief	VGContext constructor.

* \param	

* \return	

* \note		

*//*-------------------------------------------------------------------*/

VGContext::VGContext(VGContext* shareContext) :

	// Mode settings

	m_matrixMode(VG_MATRIX_PATH_USER_TO_SURFACE),

	m_fillRule(VG_EVEN_ODD),

	m_imageQuality(VG_IMAGE_QUALITY_FASTER),

	m_renderingQuality(VG_RENDERING_QUALITY_BETTER),

	m_blendMode(VG_BLEND_SRC_OVER),

	m_imageMode(VG_DRAW_IMAGE_NORMAL),

	// Scissor rectangles

	m_scissor(),

	// Stroke parameters

	m_strokeLineWidth(1.0f),

	m_inputStrokeLineWidth(1.0f),

	m_strokeCapStyle(VG_CAP_BUTT),

	m_strokeJoinStyle(VG_JOIN_MITER),

	m_strokeMiterLimit(4.0f),

	m_inputStrokeMiterLimit(4.0f),

	m_strokeDashPattern(),

	m_inputStrokeDashPattern(),

	m_strokeDashPhase(0.0f),

	m_inputStrokeDashPhase(0.0f),

	m_strokeDashPhaseReset(VG_FALSE),

	// Edge fill color for vgConvolve and pattern paint

	m_tileFillColor(0,0,0,0, Color::sRGBA),

	m_inputTileFillColor(0,0,0,0, Color::sRGBA),

	// Color for vgClear

	m_clearColor(0,0,0,0, Color::sRGBA),

	m_inputClearColor(0,0,0,0, Color::sRGBA),

    m_glyphOrigin(0.0f, 0.0f),

    m_inputGlyphOrigin(0.0f, 0.0f),

	m_masking(VG_FALSE),

	m_scissoring(VG_FALSE),

	m_pixelLayout(VG_PIXEL_LAYOUT_UNKNOWN),

	m_filterFormatLinear(VG_FALSE),

	m_filterFormatPremultiplied(VG_FALSE),

	m_filterChannelMask(VG_RED|VG_GREEN|VG_BLUE|VG_ALPHA),

	// Matrices

	m_pathUserToSurface(),

	m_imageUserToSurface(),

	m_glyphUserToSurface(),

	m_fillPaintToUser(),

	m_strokePaintToUser(),

	m_fillPaint(VG_INVALID_HANDLE),

	m_strokePaint(VG_INVALID_HANDLE),

    m_colorTransform(VG_FALSE),

    m_colorTransformValues(),

    m_inputColorTransformValues(),

	m_error(VG_NO_ERROR),

	m_imageManager(NULL),

	m_pathManager(NULL),

	m_paintManager(NULL),

	m_fontManager(NULL),

	m_maskLayerManager(NULL),

    m_eglDrawable(NULL)

{

	if(shareContext)

	{

		m_imageManager = shareContext->m_imageManager;

		m_pathManager = shareContext->m_pathManager;

		m_paintManager = shareContext->m_paintManager;

		m_fontManager = shareContext->m_fontManager;

		m_maskLayerManager = shareContext->m_maskLayerManager;

	}

	else

	{

		try

		{

			m_imageManager = RI_NEW(OpenVGRI::ResourceManager<Image>, ());	//throws bad_alloc

			m_pathManager = RI_NEW(OpenVGRI::ResourceManager<Path>, ());	//throws bad_alloc

			m_paintManager = RI_NEW(OpenVGRI::ResourceManager<Paint>, ());	//throws bad_alloc

			m_fontManager = RI_NEW(OpenVGRI::ResourceManager<Font>, ());	//throws bad_alloc

			m_maskLayerManager = RI_NEW(OpenVGRI::ResourceManager<Surface>, ());	//throws bad_alloc

		}

		catch(std::bad_alloc)

		{

			RI_DELETE(m_imageManager);

			RI_DELETE(m_pathManager);

			RI_DELETE(m_paintManager);

			RI_DELETE(m_fontManager);

			RI_DELETE(m_maskLayerManager);

			throw;

		}

	}

	RI_ASSERT(m_imageManager);

	RI_ASSERT(m_pathManager);

	RI_ASSERT(m_paintManager);

	RI_ASSERT(m_fontManager);

	RI_ASSERT(m_maskLayerManager);

	m_imageManager->addReference();

	m_pathManager->addReference();

	m_paintManager->addReference();

	m_fontManager->addReference();

	m_maskLayerManager->addReference();

    m_inputColorTransformValues[0] = 1.0f;

    m_inputColorTransformValues[1] = 1.0f;

    m_inputColorTransformValues[2] = 1.0f;

    m_inputColorTransformValues[3] = 1.0f;

    m_inputColorTransformValues[4] = 0.0f;

    m_inputColorTransformValues[5] = 0.0f;

    m_inputColorTransformValues[6] = 0.0f;

    m_inputColorTransformValues[7] = 0.0f;

    m_colorTransformValues[0] = 1.0f;

    m_colorTransformValues[1] = 1.0f;

    m_colorTransformValues[2] = 1.0f;

    m_colorTransformValues[3] = 1.0f;

    m_colorTransformValues[4] = 0.0f;

    m_colorTransformValues[5] = 0.0f;

    m_colorTransformValues[6] = 0.0f;

    m_colorTransformValues[7] = 0.0f;

}

/*-------------------------------------------------------------------*//*!

* \brief	VGContext destructor.

* \param	

* \return	

* \note		

*//*-------------------------------------------------------------------*/

VGContext::~VGContext()

{

	releasePaint(VG_FILL_PATH | VG_STROKE_PATH);

    setDefaultDrawable(NULL);

	//destroy own images, paths and paints

	while(Image* i = m_imageManager->getFirstResource(this))

		m_imageManager->removeResource(i);

	while(Path* p = m_pathManager->getFirstResource(this))

		m_pathManager->removeResource(p);

	while(Paint* t = m_paintManager->getFirstResource(this))

		m_paintManager->removeResource(t);

	while(Font* t = m_fontManager->getFirstResource(this))

		m_fontManager->removeResource(t);

	while(Surface* t = m_maskLayerManager->getFirstResource(this))

		m_maskLayerManager->removeResource(t);

	//decrease the reference count of resource managers

	if(!m_imageManager->removeReference())

		RI_DELETE(m_imageManager);

	if(!m_pathManager->removeReference())

		RI_DELETE(m_pathManager);

	if(!m_paintManager->removeReference())

		RI_DELETE(m_paintManager);

	if(!m_fontManager->removeReference())

		RI_DELETE(m_fontManager);

	if(!m_maskLayerManager->removeReference())

		RI_DELETE(m_maskLayerManager);

}

/*-------------------------------------------------------------------*//*!

* \brief	Sets new default drawable.

* \param	drawable New drawable or NULL when context is unbound

* \return	

* \note		

*//*-------------------------------------------------------------------*/

void VGContext::setDefaultDrawable(Drawable* drawable)

{

	if(m_eglDrawable)

	{

		if(!m_eglDrawable->removeReference())

			RI_DELETE(m_eglDrawable);

	}

	m_eglDrawable = drawable;

	if(m_eglDrawable)

	{

		m_eglDrawable->addReference();

	}

}

/*-------------------------------------------------------------------*//*!

* \brief	Returns true if the given image is generated through any

*			context that is shared with this one.

* \param	

* \return	

* \note		

*//*-------------------------------------------------------------------*/

bool VGContext::isValidImage(VGImage image)

{

	return m_imageManager->isValid((Image*)image);

}

/*-------------------------------------------------------------------*//*!

* \brief	Returns true if the given path is generated through any

*			context that is shared with this one.

* \param	

* \return	

* \note		

*//*-------------------------------------------------------------------*/

bool VGContext::isValidPath(VGPath path)

{

	return m_pathManager->isValid((Path*)path);

}

/*-------------------------------------------------------------------*//*!

* \brief	Returns true if the given paint is generated through any

*			context that is shared with this one.

* \param	

* \return	

* \note		

*//*-------------------------------------------------------------------*/

bool VGContext::isValidPaint(VGPaint paint)

{

	return m_paintManager->isValid((Paint*)paint);

}

/*-------------------------------------------------------------------*//*!

* \brief	Returns true if the given font is generated through any

*			context that is shared with this one.

* \param	

* \return	

* \note		

*//*-------------------------------------------------------------------*/

bool VGContext::isValidFont(VGFont font)

{

	return m_fontManager->isValid((Font*)font);

}

/*-------------------------------------------------------------------*//*!

* \brief	Returns true if the given mask layer is generated through any

*			context that is shared with this one.

* \param	

* \return	

* \note		

*//*-------------------------------------------------------------------*/

bool VGContext::isValidMaskLayer(VGMaskLayer layer)

{

	return m_maskLayerManager->isValid((Surface*)layer);

}

/*-------------------------------------------------------------------*//*!

* \brief	Releases the given paint objects of the context.

* \param	

* \return	

* \note		

*//*-------------------------------------------------------------------*/

void VGContext::releasePaint(VGbitfield paintModes)

{

	if(paintModes & VG_FILL_PATH)

	{

		//release previous paint

		Paint* prev = (Paint*)m_fillPaint;

		if(prev)

		{

			if(!prev->removeReference())

				RI_DELETE(prev);

		}

		m_fillPaint = VG_INVALID_HANDLE;

	}

	if(paintModes & VG_STROKE_PATH)

	{

		//release previous paint

		Paint* prev = (Paint*)m_strokePaint;

		if(prev)

		{

			if(!prev->removeReference())

				RI_DELETE(prev);

		}

		m_strokePaint = VG_INVALID_HANDLE;

	}

}

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

}	//namespace OpenVGRI