path: root/src/vg/Context.cpp

/*------------------------------------------------------------------------
 *
 * 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 "Context.h"

namespace tgOpenVG
{

/*-------------------------------------------------------------------*//*!
* \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(tgOpenVG::ResourceManager<Image>, ());	//throws bad_alloc
			m_pathManager = RI_NEW(tgOpenVG::ResourceManager<Path>, ());	//throws bad_alloc
			m_paintManager = RI_NEW(tgOpenVG::ResourceManager<Paint>, ());	//throws bad_alloc
			m_fontManager = RI_NEW(tgOpenVG::ResourceManager<Font>, ());	//throws bad_alloc
			m_maskLayerManager = RI_NEW(tgOpenVG::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 tgOpenVG