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