/* Copyright (c) 2009-2010 The Khronos Group Inc.

 * Portions copyright (c) 2009-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.

 */

/*! \ingroup wfc

 *  \file wfcelement.c

 *

 *  \brief SI Element handling

 */

#include <stdio.h>

#include <stdlib.h>

#include <math.h>

#include <string.h>

#include <WF/wfc.h>

#include "wfcelement.h"

#include "wfccontext.h"

#include "wfcdevice.h"

#include "wfcstructs.h"

#include "wfcimageprovider.h"

#include "owfnativestream.h"

#include "owfattributes.h"

#include "owfmemory.h"

#include "owfobject.h"

#include "owfdebug.h"

#ifdef __cplusplus

extern "C" {

#endif

#define FIRST_ELEMENT_HANDLE    3000

#define FAIL_IF(c,e)        if (c) { return e; }

static const WFCbitfield    validTransparencyModes[] = {

                                WFC_TRANSPARENCY_NONE,

                                WFC_TRANSPARENCY_ELEMENT_GLOBAL_ALPHA,

                                WFC_TRANSPARENCY_SOURCE,

                                WFC_TRANSPARENCY_MASK,

                                WFC_TRANSPARENCY_ELEMENT_GLOBAL_ALPHA |

                                    WFC_TRANSPARENCY_SOURCE,

                                WFC_TRANSPARENCY_ELEMENT_GLOBAL_ALPHA |

                                    WFC_TRANSPARENCY_MASK

                            };

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

 *

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

void

WFC_Element_Initialize(WFC_ELEMENT* element)

{

    element->dstRect[0]         = 0;

    element->dstRect[1]         = 0;

    element->dstRect[2]         = 0;

    element->dstRect[3]         = 0;

    element->srcRect[0]         = 0;

    element->srcRect[1]         = 0;

    element->srcRect[2]         = 0;

    element->srcRect[3]         = 0;

    element->source             = WFC_INVALID_HANDLE;

    element->sourceFlip         = WFC_FALSE;

    element->sourceRotation     = WFC_ROTATION_0;

    element->sourceScaleFilter  = WFC_SCALE_FILTER_NONE;

    element->transparencyTypes  = 0;

    element->globalAlpha        = OWF_ALPHA_MAX_VALUE;

    element->maskHandle         = WFC_INVALID_HANDLE;

    element->sourceHandle       = WFC_INVALID_HANDLE;

}

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

 *

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

OWF_API_CALL void

WFC_Element_Destroy(WFC_ELEMENT* element)

{

    if (element)

    {

        DPRINT(("WFC_Element_Destroy"));

        DPRINT(("  element = %p (%d)", element, element->handle));

        DESTROY(element->cachedSource);

        DESTROY(element->cachedMask);

        DPRINT(("  cachedSource = %p (%d)", element->cachedSource,

                                            element->cachedSource ?

                                                element->cachedSource->handle :

                                                0));

        DPRINT(("  cachedMask = %p (%d)", element->cachedMask,

                                          element->cachedMask ?

                                              element->cachedMask->handle :

                                              0));

        DESTROY(element->source);

        DESTROY(element->mask);

        DPRINT(("  source = %p (%d)", element->source,

                                      element->source ?

                                          element->source->handle :

                                          0));

        DPRINT(("  mask = %p (%d)", element->mask,

                                    element->mask ?

                                        element->mask->handle :

                                        0));

        DESTROY(element->context);

        OWF_Pool_PutObject(element);

    }

}

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

 *  Create new element into context

 *

 *  \param context Context into which to create the element

 *

 *  \return New element object or NULL

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

OWF_API_CALL WFC_ELEMENT*

WFC_Element_Create(WFC_CONTEXT* context)

{

    static WFCint           nextElementHandle = FIRST_ELEMENT_HANDLE;

    WFC_ELEMENT*            element;

	OWF_ASSERT(context);

    element = (WFC_ELEMENT*)OWF_Pool_GetObject(context->elementPool);

    if (element)

    {

        WFC_Element_Initialize(element);

        element->handle = nextElementHandle++;

        ADDREF(element->context, context);

        element->device = context->device;

    }

    return element;

}

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

 *

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

OWF_API_CALL WFC_ELEMENT*

WFC_Element_Clone(WFC_ELEMENT* element)

{

    WFC_ELEMENT*        clone;

    WFC_CONTEXT*        context;

    OWF_ASSERT(element);

    DPRINT(("WFC_Element_Clone: element = %d, context = %d", element->handle,

            element->context->handle));

    context = CONTEXT(element->context);

    clone = (WFC_ELEMENT*)OWF_Pool_GetObject(context->elementPool);

    if (clone)

    {

        WFC_Element_Initialize(clone);

        clone->handle           = element->handle;

        clone->sourceFlip       = element->sourceFlip;

        clone->sourceRotation   = element->sourceRotation;

        clone->sourceScaleFilter= element->sourceScaleFilter;

        clone->transparencyTypes= element->transparencyTypes;

        clone->globalAlpha      = element->globalAlpha;

        clone->maskHandle       = element->maskHandle;

        clone->sourceHandle     = element->sourceHandle;

        ADDREF(clone->cachedMask, element->cachedMask);

        ADDREF(clone->cachedSource, element->cachedSource);

        ADDREF(clone->mask,     element->mask);

        ADDREF(clone->source,   element->source);

        clone->device = element->device;

        ADDREF(clone->context,  element->context);

        memcpy(clone->srcRect,  element->srcRect, 4 * sizeof(WFCfloat));

        memcpy(clone->dstRect,  element->dstRect, 4 * sizeof(WFCfloat));

    }

    return clone;

}

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

 *

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

static WFCboolean WFC_Element_ClampRectangle(const char* rtype,

                                             WFCfloat* rect)

{

    /*

     * int -> float conversion:

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

     *

     * above 2^24 we start to lose precision when performing

     * conversions between floats & ints, thus we must clamp

     * values above in order to avoid nasty sign-change effects

     * and other weird side-effects.

     *

     */

    const WFCfloat          LIMIT = 1.6777216E7f;

    WFCint                  i;

    WFCboolean              clamped = WFC_FALSE;

    /* Prevent compiler warning when DPRINT is disabled */

    (void) rtype;

    for (i = 0; i < 4; i++)

    {

        if (fabs(rect[i]) > LIMIT)

        {

#ifdef DEBUG

            static const char* coord[4] = {"x", "y", "width", "height"};

            (void)coord[0];

#endif

            DPRINT(("  Warning: Precision loss in element's %s rectangle's "

                    "%s coordinate.",

                    rtype, coord[i]));

            rect[i] = rect[i] < 0 ? -LIMIT : LIMIT;

            clamped = WFC_TRUE;

        }

    }

    return clamped;

}

/*===========================================================================

 *

 * Attribute set-time checking functions. These are used for checking

 * the attributes before saving them into elements. Attributes are validated

 * for 2nd time during commit, where e.g. destination rectangle size vs.

 * mask size dependency is checked.

 *

 *============================================================================*/

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

 *

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

static WFCErrorCode

WFC_Element_ValidateSourceRectangle(WFC_ELEMENT* element,

                                    WFCfloat* rect)

{

    WFCErrorCode            result = WFC_ERROR_NONE;

#ifndef DEBUG

    (void) element;

#endif    

    OWF_ASSERT(element);

    OWF_ASSERT(rect);

    if (rect[0] < 0.0f || rect[1] < 0.0f || rect[2] < 0.0f || rect[3] < 0.0f)

    {

        result = WFC_ERROR_ILLEGAL_ARGUMENT;

    }

    else if (WFC_Element_ClampRectangle("source", rect))

    {

        result = WFC_ERROR_NONE;

    }

    return result;

}

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

 *

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

static WFCErrorCode

WFC_Element_ValidateDestinationRectangle(WFC_ELEMENT* element,

                                         WFCfloat* rect)

{

    WFCErrorCode            result = WFC_ERROR_NONE;

#ifndef DEBUG

    (void) element;

#endif    

    OWF_ASSERT(element);

    OWF_ASSERT(rect);

    DPRINT(("WFC_Element_ValidateDestinationRectangle(element = %d)",

            element->handle));

    if (rect[2] < 0.0f || rect[3] < 0.0f)

    {

        result = WFC_ERROR_ILLEGAL_ARGUMENT;

    }

    else if (WFC_Element_ClampRectangle("destination", rect))

    {

        /* ... return error or something here? */

        result = WFC_ERROR_NONE;

    }

    /* Hmm.. let's clamp the rectangle even more! To 16k*16k at max;

     * in OWF_Image_Create we calculate the byte size of the image buffer

     * required, and if we have 4bpp, we get overflow for pixelcounts

     * >= 65536*16384. */

    rect[2] = CLAMP(rect[2], 0, 16384);

    rect[3] = CLAMP(rect[3], 0, 16384);

    return result;

}

#define BOOLEAN_TO_ERROR(x) ((x) ? WFC_ERROR_NONE : WFC_ERROR_ILLEGAL_ARGUMENT)

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

 *

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

static WFCErrorCode

WFC_Element_ValidateScalarAttributei(WFC_ELEMENT* element,

                                     WFCElementAttrib attrib,

                                     WFCint value)

{

    WFCErrorCode            result = WFC_ERROR_NONE;

    OWF_ASSERT(element);

    switch (attrib)

    {

        case WFC_ELEMENT_SOURCE:

        {

            WFC_IMAGE_PROVIDER* source;

            source = WFC_Device_FindImageProvider(element->device,

                                                  value,

                                                  WFC_IMAGE_SOURCE);

            result = BOOLEAN_TO_ERROR((WFC_INVALID_HANDLE == value) ||

                                      ((WFC_INVALID_HANDLE != value) &&

                                       (NULL != source)));

            break;

        }

        case WFC_ELEMENT_MASK:

        {

            WFC_IMAGE_PROVIDER* mask;

            mask = WFC_Device_FindImageProvider(element->device,

                                                value,

                                                WFC_IMAGE_MASK);

            result = BOOLEAN_TO_ERROR((WFC_INVALID_HANDLE == value) ||

                                      ((WFC_INVALID_HANDLE != value) &&

                                       (NULL != mask)));

            break;

        }

        case WFC_ELEMENT_SOURCE_ROTATION:

        {

            WFCRotation rotation = (WFCRotation) value;

            result = BOOLEAN_TO_ERROR((WFC_ROTATION_0    == rotation ||

                                       WFC_ROTATION_90   == rotation ||

                                       WFC_ROTATION_180  == rotation ||

                                       WFC_ROTATION_270  == rotation));

            break;

        }

        case WFC_ELEMENT_SOURCE_SCALE_FILTER:

        {

            WFCScaleFilter  filter = (WFCScaleFilter) value;

            result = BOOLEAN_TO_ERROR((WFC_SCALE_FILTER_NONE     == filter ||

                                       WFC_SCALE_FILTER_FASTER   == filter ||

                                       WFC_SCALE_FILTER_BETTER   == filter));

            break;

        }

        case WFC_ELEMENT_SOURCE_FLIP:

        {

            result = WFC_ERROR_NONE;

            break;

        }

        case WFC_ELEMENT_TRANSPARENCY_TYPES:

        {

            WFCint          ii;

            WFCint          count = sizeof(validTransparencyModes) /

                                    sizeof(WFCbitfield);

            WFCbitfield     types = (WFCbitfield) value;

            result = WFC_ERROR_ILLEGAL_ARGUMENT;

            for (ii = 0; ii < count; ii++) {

                if (types == validTransparencyModes[ii])

                {

                    result = WFC_ERROR_NONE;

                    break;

                }

            }

            break;

        }

        default:

        {

            result = WFC_ERROR_BAD_ATTRIBUTE;

            break;

        }

    }

    return result;

}

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

 *

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

static WFCErrorCode

WFC_Element_ValidateScalarAttributef(WFC_ELEMENT* element,

                                     WFCElementAttrib attrib,

                                     WFCfloat value)

{

    WFCErrorCode          result = WFC_ERROR_NONE;

#ifndef DEBUG

    (void) element;

#endif

    OWF_ASSERT(element);

    switch (attrib)

    {

        case WFC_ELEMENT_GLOBAL_ALPHA:

        {

            result = BOOLEAN_TO_ERROR(value >= OWF_ALPHA_MIN_VALUE &&

                                      value <= OWF_ALPHA_MAX_VALUE);

            break;

        }

        /* SPECIAL CASES */

        case WFC_ELEMENT_SOURCE_FLIP:

        case WFC_ELEMENT_SOURCE_ROTATION:

        case WFC_ELEMENT_SOURCE_SCALE_FILTER:

        case WFC_ELEMENT_TRANSPARENCY_TYPES:

        case WFC_ELEMENT_SOURCE:

        case WFC_ELEMENT_MASK:

        {

            /* NOTE! special early out here. */

            result = WFC_ERROR_BAD_ATTRIBUTE;

            break;

        }

        default:

        {

            result = WFC_ERROR_ILLEGAL_ARGUMENT;

            break;

        }

    }

    return result;

}

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

 *

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

static void

WFC_Element_SetElementImageProvider(WFC_ELEMENT* element,

                                    WFC_IMAGE_PROVIDER_TYPE type,

                                    WFCHandle handle)

{

    WFC_IMAGE_PROVIDER*     provider;

    OWF_ASSERT(element);

    provider = WFC_Device_FindImageProvider(element->device, handle, type);

    switch (type)

    {

        case WFC_IMAGE_SOURCE:

        {

            DESTROY(element->cachedSource);

            ADDREF(element->cachedSource, provider);

            element->sourceHandle = handle;

            break;

        }

        case WFC_IMAGE_MASK:

        {

            DESTROY(element->cachedMask);

            ADDREF(element->cachedMask, provider);

            element->maskHandle = handle;

            break;

        }

    }

}

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

 *  \brief Set vector integer attribute for an element

 *

 *  \param element          Element

 *  \param attrib           Attribute name

 *  \param count            Attribute size

 *  \param values           Attribute vector value

 *

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

OWF_API_CALL WFCErrorCode

WFC_Element_SetAttribiv(WFC_ELEMENT* element,

                        WFCElementAttrib attrib,

                        WFCint count,

                        const WFCint* values)

{

    WFCErrorCode            result = WFC_ERROR_NONE;

    FAIL_IF(NULL == values, WFC_ERROR_ILLEGAL_ARGUMENT);

    switch (attrib)

    {

        /* Vector attributes */

        case WFC_ELEMENT_SOURCE_RECTANGLE:

        case WFC_ELEMENT_DESTINATION_RECTANGLE:

        {

            WFCfloat                rect[4];

            rect[0] = values[0];

            rect[1] = values[1];

            rect[2] = values[2];

            rect[3] = values[3];

            result = WFC_Element_SetAttribfv(element, attrib, count, rect);

            break;

        }

        case WFC_ELEMENT_GLOBAL_ALPHA:

        {

            WFCfloat    fvalue = values[0] /

                                 (WFCfloat) OWF_BYTE_MAX_VALUE;

            result = WFC_Element_SetAttribfv(element,

                                             attrib,

                                             1,

                                             &fvalue);

            break;

        }

        /* Scalar attributes */

        default:

        {

            WFCint          value;

            FAIL_IF(1 != count, WFC_ERROR_ILLEGAL_ARGUMENT);

            value = values[0];

            /* Validate the value thus ensuring it is safe to change it */

            result = WFC_Element_ValidateScalarAttributei(element,

                                                          attrib,

                                                          value);

            if (WFC_ERROR_NONE != result)

            {

                break;

            }

            switch (attrib)

            {

                case WFC_ELEMENT_SOURCE:

                {

                    WFC_Element_SetElementImageProvider(element,

                                                        WFC_IMAGE_SOURCE,

                                                        value);

                    break;

                }

                case WFC_ELEMENT_MASK:

                {

                    WFC_Element_SetElementImageProvider(element,

                                                        WFC_IMAGE_MASK,

                                                        value);

                    break;

                }

                case WFC_ELEMENT_SOURCE_FLIP:

                {

                    element->sourceFlip = (WFCboolean)value;

                    break;

                }

                case WFC_ELEMENT_SOURCE_ROTATION:

                {

                    element->sourceRotation = (WFCRotation)value;

                    break;

                }

                case WFC_ELEMENT_SOURCE_SCALE_FILTER:

                {

                    element->sourceScaleFilter = (WFCScaleFilter)value;

                    break;

                }

                case WFC_ELEMENT_TRANSPARENCY_TYPES:

                {

                    element->transparencyTypes = value;

                    break;

                }

                default:

                {

                    result = WFC_ERROR_BAD_ATTRIBUTE;

                    break;

                }

            }

            break;

        }

    }

    return result;

}

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

 *

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

OWF_API_CALL WFCErrorCode

WFC_Element_SetAttribfv(WFC_ELEMENT* element,

                        WFCElementAttrib attrib,

                        WFCint count,

                        const WFCfloat* values)

{

    WFCErrorCode            result = WFC_ERROR_NONE;

    FAIL_IF(NULL == values, WFC_ERROR_ILLEGAL_ARGUMENT);

    switch (attrib)

    {

        /* Vector attributes */

        case WFC_ELEMENT_SOURCE_RECTANGLE:

        case WFC_ELEMENT_DESTINATION_RECTANGLE:

        {

            WFCfloat        clamped[4];

            FAIL_IF(4 != count, WFC_ERROR_ILLEGAL_ARGUMENT);

            memcpy(clamped, values, 4 * sizeof(WFCfloat));

            if (WFC_ELEMENT_SOURCE_RECTANGLE == attrib)

            {

                /* this clamps the rectangle, in case it has values that

                 * cause precision loss or other fuzzy behaviour. */

                result = WFC_Element_ValidateSourceRectangle(element, clamped);

                if (WFC_ERROR_NONE == result)

                {

                    memcpy(element->srcRect, clamped, 4 * sizeof(WFCfloat));

                    DPRINT(("  Source rectangle set to (%.2f,%.2f,%.2f,%.2f)",

                            clamped[0], clamped[1], clamped[2], clamped[3]));

                }

                else

                {

                    DPRINT(("  Source rectangle (%.2f,%.2f,%.2f,%.2f) is " \

                            "invalid",

                            values[0], values[1], values[2], values[3]));

                }

            }

            else

            {

                result = WFC_Element_ValidateDestinationRectangle(element,

                                                                  clamped);

                if (WFC_ERROR_NONE == result)

                {

                    memcpy(element->dstRect, clamped, 4 * sizeof(WFCfloat));

                    DPRINT(("  Destination rectangle set to " \

                            "(%.2f,%.2f,%.2f,%.2f)",

                            clamped[0], clamped[1], clamped[2], clamped[3]));

                }

                else

                {

                    DPRINT(("  Destination rectangle (%.2f,%.2f,%.2f,%.2f) is "

                            "invalid",

                            values[0], values[1], values[2], values[3]));

                }

            }

            break;

        }

        /* scalar attributes */

        case WFC_ELEMENT_GLOBAL_ALPHA:

        {

            /* values[0] must be [0, 1] */

            WFCfloat        value = values[0];

            /* value is [0, 1] map to [0, OWF_ALPHA_MAX] */

            value = value * OWF_ALPHA_MAX_VALUE;

            /* validate the value */

            result = WFC_Element_ValidateScalarAttributef(element,

                                                          attrib,

                                                          value);

            if (WFC_ERROR_NONE != result)

            {

                /* invalid value for attribute, out we go */

                break;

            }

            element->globalAlpha = value;

            break;

        }

        default:

        {

            result = WFC_ERROR_BAD_ATTRIBUTE;

            break;

        }

    }

    return result;

}

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

 * Attribute getters

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

OWF_API_CALL WFCErrorCode

WFC_Element_GetAttribiv(WFC_ELEMENT* element,

                        WFCElementAttrib attrib,

                        WFCint count,

                        WFCint* values)

{

    WFCErrorCode            result = WFC_ERROR_NONE;

    FAIL_IF(NULL == values, WFC_ERROR_ILLEGAL_ARGUMENT);

    switch (attrib)

    {

        /* Vector attributes */

        case WFC_ELEMENT_SOURCE_RECTANGLE:

        case WFC_ELEMENT_DESTINATION_RECTANGLE:

        {

            WFCfloat        rect[4] = {0.0, 0.0, 0.0, 0.0};

            result = WFC_Element_GetAttribfv(element, attrib, count, rect);

            if (WFC_ERROR_NONE == result)

            {

                values[0] = floor(rect[0]);

                values[1] = floor(rect[1]);

                values[2] = floor(rect[2]);

                values[3] = floor(rect[3]);

            }

            break;

        }

        /* Scalar attributes */

        default:

        {

            FAIL_IF(1 != count, WFC_ERROR_ILLEGAL_ARGUMENT);

            switch (attrib)

            {

                /* pure int attributes */

                case WFC_ELEMENT_SOURCE:

                {

                    *values = element->sourceHandle;

                    break;

                }

                case WFC_ELEMENT_MASK:

                {

                    *values = element->maskHandle;

                    break;

                }

                case WFC_ELEMENT_SOURCE_FLIP:

                {

                    *values = element->sourceFlip;

                    break;

                }

                case WFC_ELEMENT_SOURCE_ROTATION:

                {

                    *values = element->sourceRotation;

                    break;

                }

                case WFC_ELEMENT_SOURCE_SCALE_FILTER:

                {

                    *values = element->sourceScaleFilter;

                    break;

                }

                case WFC_ELEMENT_TRANSPARENCY_TYPES:

                {

                    *values = element->transparencyTypes;

                    break;

                }

                case WFC_ELEMENT_GLOBAL_ALPHA:

                {

                    WFCfloat    fvalue;

                    WFC_Element_GetAttribfv(element, attrib, 1, &fvalue);

                    *values = floor(OWF_BYTE_MAX_VALUE * fvalue /

                                    OWF_ALPHA_MAX_VALUE);

                    break;

                }

                default:

                {

                    result = WFC_ERROR_BAD_ATTRIBUTE;

                    break;

                }

            }

            break;

        }

    }

    return result;

}

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

 *

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

OWF_API_CALL WFCErrorCode

WFC_Element_GetAttribfv(WFC_ELEMENT* element,

                        WFCElementAttrib attrib,

                        WFCint count,

                        WFCfloat* values)

{

    WFCErrorCode            result = WFC_ERROR_NONE;

    FAIL_IF(NULL == values, WFC_ERROR_ILLEGAL_ARGUMENT);

    switch (attrib)

    {

        /* Vector attributes */

        case WFC_ELEMENT_SOURCE_RECTANGLE:

        case WFC_ELEMENT_DESTINATION_RECTANGLE:

        {

            FAIL_IF(4 != count, WFC_ERROR_ILLEGAL_ARGUMENT);

            if (WFC_ELEMENT_SOURCE_RECTANGLE == attrib)

            {

                values[0] = element->srcRect[0];

                values[1] = element->srcRect[1];

                values[2] = element->srcRect[2];

                values[3] = element->srcRect[3];

            }

            else

            {

                values[0] = element->dstRect[0];

                values[1] = element->dstRect[1];

                values[2] = element->dstRect[2];

                values[3] = element->dstRect[3];

            }

            break;

        }

        /* Scalar attributes */

        default:

        {

            switch (attrib)

            {

                case WFC_ELEMENT_GLOBAL_ALPHA:

                {

                    *values = element->globalAlpha;

                    break;

                }

                default:

                {

                    result = WFC_ERROR_BAD_ATTRIBUTE;

                    break;

                }

            }

            break;

        }

    }

    return result;

}

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

 *  Attribute checkers to use during commit to check element

 *  for inconsistencies.

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

static WFCboolean

WFC_Element_CheckAttribute(WFC_ELEMENT* element,

                           WFCElementAttrib attrib)

{

#define VALIDATE_SCALAR_I(v)    \

    (WFC_Element_ValidateScalarAttributei(element, attrib, v) == \

            WFC_ERROR_NONE ? WFC_TRUE : WFC_FALSE)

#define VALIDATE_SCALAR_F(v)    \

    (WFC_Element_ValidateScalarAttributef(element, attrib, v) == \

            WFC_ERROR_NONE ? WFC_TRUE : WFC_FALSE)

    WFCboolean              result = WFC_TRUE;

    DPRINT(("WFC_Element_CheckAttribute(%08x,%0x)",

           element, attrib));

    switch (attrib)

    {

        /*

        INTEGER-ATTRIBUTES

        */

        case WFC_ELEMENT_SOURCE:

        {

            /* Validated when the attribute was modified */

            break;

        }

        case WFC_ELEMENT_MASK:

        {

            /* Validated when the attribute was modified */

            break;

        }

        case WFC_ELEMENT_SOURCE_FLIP:

        {

            result = VALIDATE_SCALAR_I(element->sourceFlip) ? WFC_TRUE: WFC_FALSE;

            if (!result)

            {

                DPRINT(("  Element source flipping is invalid (%d)",

                        element->sourceFlip));

            }

            break;

        }

        case WFC_ELEMENT_SOURCE_ROTATION:

        {

            result = VALIDATE_SCALAR_I(element->sourceRotation) ? WFC_TRUE: WFC_FALSE;

            if (!result)

            {

                DPRINT(("  Element source rotation is invalid (%d)",

                        element->sourceRotation));

            }

            break;

        }

        case WFC_ELEMENT_SOURCE_SCALE_FILTER:

        {

            result = VALIDATE_SCALAR_I(element->sourceScaleFilter) ? WFC_TRUE: WFC_FALSE;

            if (!result)

            {

                DPRINT(("  Element source scale filter is invalid (%d)",

                        element->sourceScaleFilter));

            }

            break;

        }

        case WFC_ELEMENT_TRANSPARENCY_TYPES:

        {

            result = VALIDATE_SCALAR_I(element->transparencyTypes) ? WFC_TRUE: WFC_FALSE;

            if (!result)

            {

                DPRINT(("  Element transparency type is invalid (%x)",

                        element->transparencyTypes));

            }

            break;

        }

        case WFC_ELEMENT_GLOBAL_ALPHA:

        {

            result = VALIDATE_SCALAR_F(element->globalAlpha) ? WFC_TRUE: WFC_FALSE;

            if (!result)

            {

                DPRINT(("  Element global alpha is invalid (%d)",

                        element->globalAlpha));

            }

            break;

        }

        case WFC_ELEMENT_DESTINATION_RECTANGLE:

        {

            WFC_IMAGE_PROVIDER* mask;

            /* The <0 test is repeated in SetAttribfv ValidateDestinationRectangle */

           if (element->dstRect[2] < 0 || element->dstRect[3] < 0)

            {

                DPRINT(("  Element destination rectangle has negative "

                        "width/height"));

                result = WFC_FALSE;

                break;

            }

            if (element->maskHandle!=WFC_INVALID_HANDLE)

            {

                result = WFC_Element_CheckAttribute(element, WFC_ELEMENT_MASK);

                if (result)

                {

                    mask = WFC_Device_FindMask(element->device,

                                               element->maskHandle);