/*

* Copyright (c) 2005 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:

*

*/

package com.nokia.microedition.m2g;

import org.w3c.dom.*;

import org.w3c.dom.svg.*;

import org.w3c.dom.events.*;

import com.nokia.mj.impl.rt.legacy.ToolkitInvoker;

import java.io.IOException;

import org.eclipse.swt.widgets.*;

import org.eclipse.swt.widgets.Display;

import com.nokia.mj.impl.rt.legacy.LegacyRtPort;

import com.nokia.mj.impl.utils.Logger;

public class M2GSVGElement extends M2GObject implements SVGElement

{

    //--------------------------------------------------

    // STATIC CONSTANTS

    //--------------------------------------------------

    // Error constants

    static final String TYPE_IS_NULL_ESTR =

        "The type is null.";

    static final String LISTENER_IS_NULL_ESTR =

        "The listener is null.";

    static final String CAPTURE_NOT_SUPPORTED_ESTR =

        "The capture phase is not supported in SVG Tiny.";

    static final String ESWT_PACKAGE =

        "org.eclipse.swt.widgets.Display" ;

    static boolean iIsToolkitAvailable     = false;

    static boolean iStaticUIToolkit        = LCDUI_TOOLKIT;

    /* Optimization: static finals changed to local variables

    static final String TRAIT_IS_NULL_ESTR =

      "The trait is null.";

    static final String TRAIT_NOT_SUPPORTED_ON_ELEM_ESTR =

      "The trait is not supported on this element.";

    static final String TRAIT_NOT_SUPPORTED_IN_NS_ESTR =

      "The trait is not supported in this namespace.";

    static final String GET_FLOAT_MISMATCH_ESTR =

      "Trait's computed value cannot be converted to a float.";

    static final String SET_FLOAT_MISMATCH_ESTR =

      "Trait's value cannot be specified as a float.";

    static final String GET_MATRIX_MISMATCH_ESTR =

      "Trait's computed value cannot be converted to a SVGMatrix.";

    static final String SET_MATRIX_MISMATCH_ESTR =

      "Trait's value cannot be specified as a SVGMatrix.";

    static final String GET_PATH_MISMATCH_ESTR =

      "Trait's computed value cannot be converted to a SVGPath.";

    static final String SET_PATH_MISMATCH_ESTR =

      "Trait's value cannot be specified as a SVGPath.";

    static final String GET_RECT_MISMATCH_ESTR =

      "Trait's computed value cannot be converted to a SVGRect.";

    static final String SET_RECT_MISMATCH_ESTR =

      "Trait's value cannot be specified as a SVGRect.";

    static final String GET_RGB_MISMATCH_ESTR =

      "Trait's computed value cannot be converted to a SVGRGBColor.";

    static final String SET_RGB_MISMATCH_ESTR =

      "Trait's value cannot be specified as a SVGRGBColor.";

    static final String NS_NOT_SUPPORTED_ESTR =

      "The namespace is not supported.";

    static final String GET_TRAIT_NS_STRING_MISMATCH_ESTR =

      "Trait's computed value cannot be converted to a String.";

    static final String SET_TRAIT_NS_STRING_MISMATCH_ESTR =

      "Trait's value cannot be specified as a String.";

    static final String ID_IS_NULL_ESTR =

      "The id is null.";

    static final String EXISTING_ELEM_ID_CHANGE_ESTR =

      "Existing element id cannot be changed.";

    static final String ELEM_ID_EXIST_IN_DOCUMENT_ESTR =

      "Element id already exists in the document.";

    static final String INVALID_INPUT_VALUE_ESTR =

      "The input value is an invalid value for the given trait.";

    static final String VALUE_IS_NULL_ESTR =

      "Value cannot be set to null.";

    static final String SET_READONLY_MISMATCH_ESTR =

      "Attempt to change readonly trait.";

    static final String INVALID_VALUE_ESTR =

      "The value is invalid.";

    static final String INVALID_USE_ELEMENT_ESTR =

      "The <use> element is hooked into the document tree and the the value of xlink:href is set invalid.";

    static final String CANNOT_REMOVE_NODE_ESTR =

      "Cannot remove this type of node.";

    static final String CANNOT_REMOVE_NOT_CHILD_ESTR =

      "Not a child of this node.";

    static final String CANNOT_REMOVE_NON_NULL_ID_ESTR =

      "The element being removed or one of its decendants have non-null id.";

    static final String INSERT_NODE_OF_THAT_TYPE_ESTR =

      "Cannot insert node of that type.";

    static final String APPEND_DOCUMENT_ESTR =

      "Cannot append Document elements.";

    static final String DOCUMENT_HIERARCHY_ESTR =

      "Hierarchy request error in Document.";

    static final String CHILD_IS_WRONG_TYPE_ESTR =

      "Child is wrong type (Document).";

    static final String CHILD_BELONG_TO_DIFFERENT_DOCUMENT_ESTR =

      "Child belongs to different document.";

    static final String CHILD_NOT_FOUND_ESTR =

      "The child to insert before doesn't exist in this current node.";

    static final String INVALID_ELEMENT_ID_VALUE =

      "Invalid element id value.";

    */

    //--------------------------------------------------

    // VARIABLES

    //--------------------------------------------------

    protected M2GDocument iDocument;

    protected short iElementTypeId;

    //--------------------------------------------------

    // METHODS

    //--------------------------------------------------

    /**

     * Constructor

     * @param aHandle is native element handle

     * @param aDocument is a reference to a document that owns this element.

     */

    M2GSVGElement(int aElementHandle, M2GDocument aDocument)

    {

        super(aElementHandle);

        iDocument = aDocument;

        doConstruct();

    }

    /**

     * @see org.w3c.dom.events.EventTarget#addEventListener()

     */

    public void addEventListener(String type, EventListener listener, boolean useCapture)

    {

        if (type == null || type.equals(""))

        {

            throw new NullPointerException(TYPE_IS_NULL_ESTR);

        }

        if (listener == null)

        {

            throw new NullPointerException(LISTENER_IS_NULL_ESTR);

        }

        if (useCapture == true)

        {

            throw new DOMException(

                DOMException.NOT_SUPPORTED_ERR,

                CAPTURE_NOT_SUPPORTED_ESTR);

        }

        iDocument.register(this, type, listener);

    }

    /**

     * @see org.w3c.dom.Node#appendChild()

     */

    public Node appendChild(Node newChild)

    {

        // If refChild is null, newChild is inserted at the end of the list

        return insertBefore(newChild, null);  // will inform about DOM changes

    }

    /**

     * Checks attribute validity

     * @param aAttributeTypeName

     * @return attribute's type id

     * @throws DOMException

     */

    protected short check(String aAttributeTypeName) throws DOMException

    {

        short attributeTypeId = M2GSVGConstants.AT_UNDEFINED;

        if (aAttributeTypeName == null || aAttributeTypeName.equals(""))

        {

            Logger.ELOG(Logger.EJavaUI,

                        "check() exception: " + /*SF*/"The trait is null."/*SF*/);

            throw new DOMException(

                DOMException.NOT_SUPPORTED_ERR,

                /*SF*/"The trait is null."/*SF*/);

        }

        // Converts attribute's name

        attributeTypeId = M2GSVGConstants.parseAttributeTypeId(aAttributeTypeName);

        // Checks that element has this attribute

        if (!M2GSVGConstants.checkElementAttribute(attributeTypeId, iElementTypeId))

        {

            Logger.ELOG(Logger.EJavaUI,

                        "check() exception: " + /*SF*/"The trait is not supported on this element."/*SF*/);

            throw new DOMException(

                DOMException.NOT_SUPPORTED_ERR,

                /*SF*/"The trait is not supported on this element."/*SF*/);

        }

        return attributeTypeId;

    }

    /**

     * @see com.nokia.microedition.m2g.M2GObject#doCheckValidity()

     */

    public boolean doCheckValidity()

    {

        try

        {

            if (super.doCheckValidity() &&

                    (iDocument != null) &&

                    (iElementTypeId != M2GSVGConstants.EL_UNDEFINED))

            {

                return true;

            }

        }

        catch (IOException e)

        {

        }

        return false;

    }

    /**

     * @see com.nokia.microedition.m2g.M2GObject#doCleanup()

     */

    protected void doCleanup()

    {

        iDocument = null;

        iElementTypeId = M2GSVGConstants.EL_UNDEFINED;

        resetHandles();

    }

    /**

     * @see com.nokia.microedition.m2g.M2GObject#doConstruct()

     */

    public void doConstruct()

    {

        // No need to register for finalization

        // super.doConstruct();

        iElementTypeId = _getElementTypeId(

                             getNativeEventSourceHandle(),

                             getNativeSVGProxyHandle(), getHandle(), iUIToolkit);

    }

    /**

     * Returns a document

     */

    public M2GDocument getDocument()

    {

        return iDocument;

    }

    /*

     * Retuns element's type id

     * @return  element's type id

     */

    public short getElementTypeId()

    {

        return iElementTypeId;

    }

    /**

     * @see org.w3c.dom.svg.SVGElement#getFirstElementChild()

     */

    public Element getFirstElementChild() throws DOMException

    {

        // Get child element's handle

        int childHandle = _getFirstElementChild(

                              getNativeEventSourceHandle(), getNativeSVGProxyHandle(), getHandle(), iUIToolkit);

        if (M2GObject.checkHandle(childHandle))

        {

            return (Element)M2GSVGElement.buildElement(childHandle, iDocument);

        }

        return null;

    }

    /**

     * @see org.w3c.dom.svg.SVGElement#getFloatTrait()

     */

    public float getFloatTrait(String name) throws DOMException

    {

        // Optimization: if(!getDocument().getConnectionPolicy().getAccessRight())

        if (!iDocument.iConnectionRight)

        {

            Logger.ELOG(Logger.EJavaUI, "getFloatTrait() - access rights failure");

            throw new SecurityException(M2GSVGConstants.ACCESS_RIGHTS_ESTR);

        }

        short attributeTypeId = check(name);

        if (!M2GSVGConstants.isGetFloatTraitAllowed(attributeTypeId))

        {

            throw new DOMException(

                DOMException.TYPE_MISMATCH_ERR,

                /*SF*/"Trait's computed value cannot be converted to a float."/*SF*/);

        }

        return _getFloatTrait(

                   getNativeEventSourceHandle(),

                   getNativeSVGProxyHandle(), getHandle(), attributeTypeId, iUIToolkit);

    }

    /**

     * @see org.w3c.dom.svg.SVGElement#getId()

     */

    public String getId()

    {

        return _getStringTrait(

                   getNativeEventSourceHandle(),

                   getNativeSVGProxyHandle(), getHandle(), M2GSVGConstants.AT_ID, iUIToolkit);

    }

    /**

     * @see org.w3c.dom.Node#getLocalName()

     */

    public String getLocalName()

    {

        // Optimization: if(!getDocument().getConnectionPolicy().getAccessRight())

        if (!iDocument.iConnectionRight)

        {

            Logger.ELOG(Logger.EJavaUI,

                        "getLocalName() - access rights failure");

            throw new SecurityException(M2GSVGConstants.ACCESS_RIGHTS_ESTR);

        }

        return M2GSVGConstants.parseElementTypeName(iElementTypeId);

    }

    /**

     * @see org.w3c.dom.svg.SVGElement#getMatrixTrait()

     */

    public SVGMatrix getMatrixTrait(String name)

    {

        // Optimization: if(!getDocument().getConnectionPolicy().getAccessRight())

        if (!iDocument.iConnectionRight)

        {

            Logger.ELOG(Logger.EJavaUI,

                        "getMatrixTrait() - access rights failure");

            throw new SecurityException(M2GSVGConstants.ACCESS_RIGHTS_ESTR);

        }

        short attributeTypeId = check(name);

        if (!M2GSVGConstants.isGetMatrixTraitAllowed(attributeTypeId))

        {

            throw new DOMException(

                DOMException.TYPE_MISMATCH_ERR,

                /*SF*/"Trait's computed value cannot be converted to a SVGMatrix."/*SF*/);

        }

        M2GSVGMatrix matrix = new M2GSVGMatrix();

        // If an error is occurred, then no values are put in the

        // matrix array by the native method

        _getMatrixTrait(

            getNativeEventSourceHandle(),

            getNativeSVGProxyHandle(),

            getHandle(),

            attributeTypeId,

            matrix.getComponents(),

            iUIToolkit);

        return matrix;

    }

    /**

     * @see org.w3c.dom.Node#getNamespaceURI()

     */

    public String getNamespaceURI()

    {

        // Optimization: if(!getDocument().getConnectionPolicy().getAccessRight())

        if (!iDocument.iConnectionRight)

        {

            Logger.ELOG(Logger.EJavaUI,

                        "getNamespaceURI() - access rights failure");

            throw new SecurityException(M2GSVGConstants.ACCESS_RIGHTS_ESTR);

        }

        return M2GSVGConstants.SVG_NAMESPACE_URI;

        /*

          return _getStringTrait(

                  getNativeEventSourceHandle(),

                getNativeSVGProxyHandle(),

                getHandle(),

                id);

        */

    }

    /**

     * @see org.w3c.dom.svg.SVGElement#getNextElementSibling()

     */

    public Element getNextElementSibling()

    {

        int elementHandle = _getNextElementSibling(

                                getNativeEventSourceHandle(), getNativeSVGProxyHandle(), getHandle(),iUIToolkit);

        if (M2GObject.checkHandle(elementHandle))

        {

            return M2GSVGElement.buildElement(elementHandle, iDocument);

        }

        return null;

    }

    /**

     * @see org.w3c.dom.svg.SVGElement#getParentNode()

     */

    public Node getParentNode()

    {

        // Optimization: if(!getDocument().getConnectionPolicy().getAccessRight())

        if (!iDocument.iConnectionRight)

        {

            Logger.ELOG(Logger.EJavaUI,

                        "getParentNode() - access rights failure");

            throw new SecurityException(M2GSVGConstants.ACCESS_RIGHTS_ESTR);

        }

        int parentHandle = _getParent(

                               getNativeEventSourceHandle(), getNativeSVGProxyHandle(), getHandle(), iUIToolkit);

        if (M2GObject.checkHandle(parentHandle))

        {

            return M2GSVGElement.buildElement(parentHandle, iDocument);

        }

        return null;

    }

    /**

     * @see org.w3c.dom.svg.SVGElement#getPathTrait()

     */

    public SVGPath getPathTrait(String name)

    {

        // Optimization: if(!getDocument().getConnectionPolicy().getAccessRight())

        if (!iDocument.iConnectionRight)

        {

            Logger.ELOG(Logger.EJavaUI,

                        "getPathTrait() - access rights failure");

            throw new SecurityException(M2GSVGConstants.ACCESS_RIGHTS_ESTR);

        }

        short attributeTypeId = check(name);

        if (!M2GSVGConstants.isGetPathTraitAllowed(attributeTypeId))

        {

            throw new DOMException(

                DOMException.TYPE_MISMATCH_ERR,

                /*SF*/"Trait's computed value cannot be converted to a SVGPath."/*SF*/);

        }

        int pathHandle = _getPathTrait(

                             getNativeEventSourceHandle(),

                             getNativeSVGProxyHandle(),

                             getHandle(),

                             attributeTypeId,

                             iUIToolkit);

        if (pathHandle != 0)

        {

            // Path doesn't own the native object

            return new M2GSVGPath(pathHandle);

        }

        else

        {

            return null;

        }

    }

    /**

     * @see org.w3c.dom.svg.SVGElement#getRectTrait()

     */

    public SVGRect getRectTrait(String name)

    {

        // Optimization: if(!getDocument().getConnectionPolicy().getAccessRight())

        if (!iDocument.iConnectionRight)

        {

            Logger.ELOG(Logger.EJavaUI,

                        "getRectTrait() - access rights failure");

            throw new SecurityException(M2GSVGConstants.ACCESS_RIGHTS_ESTR);

        }

        short attributeTypeId = check(name);

        if (!M2GSVGConstants.isGetRectTraitAllowed(attributeTypeId))

        {

            throw new DOMException(

                DOMException.TYPE_MISMATCH_ERR,

                /*SF*/"Trait's computed value cannot be converted to a SVGRect."/*SF*/);

        }

        M2GSVGRect rect = new M2GSVGRect();

        if (_getRectTrait(

                    getNativeEventSourceHandle(),

                    getNativeSVGProxyHandle(),

                    getHandle(),

                    attributeTypeId,

                    rect.getComponents(),iUIToolkit) == -1)

        {

            Logger.LOG(Logger.EJavaUI, Logger.EInfo,

                       "getRectTrait() - returns null!!");

            return null;

        }

        else

        {

            return rect;

        }

    }

    /**

     * @see org.w3c.dom.svg.SVGElement#getRGBColorTrait()

     */

    public SVGRGBColor getRGBColorTrait(String name)

    {

        // Optimization: if(!getDocument().getConnectionPolicy().getAccessRight())

        if (!iDocument.iConnectionRight)

        {

            Logger.ELOG(Logger.EJavaUI,

                        "getRGBColorTrait() - access rights failure");

            throw new SecurityException(M2GSVGConstants.ACCESS_RIGHTS_ESTR);

        }

        short attributeTypeId = check(name);

        if (!M2GSVGConstants.isGetRgbColorTraitAllowed(attributeTypeId))

        {

            throw new DOMException(

                DOMException.TYPE_MISMATCH_ERR,

                /*SF*/"Trait's computed value cannot be converted to a SVGRGBColor."/*SF*/);

        }

        M2GSVGRGBColor rgb = new M2GSVGRGBColor(0, 0, 0);

        int result = _getColorTrait(

                         getNativeEventSourceHandle(),

                         getNativeSVGProxyHandle(),

                         getHandle(),

                         attributeTypeId,

                         rgb.getComponents(), iUIToolkit);

        if (result == -1)

        {

            if ((attributeTypeId == M2GSVGConstants.AT_FILL) ||

                    (attributeTypeId == M2GSVGConstants.AT_COLOR))

            {

                return new M2GSVGRGBColor(0, 0, 0);

            }

            else

            {

                return null;

            }

        }

        else if (result == 0)

        {

            return null;

        }