// Copyright (c) 2006-2009 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:

// Methods for element node

//

#include <xml/dom/xmlengelement.h>

#include <xml/dom/xmlengdocument.h>

#include <xml/dom/xmlengnamespace.h>

#include <xml/dom/xmlengattr.h>

#include <xml/dom/xmlengnodelist.h>

#include <stdapis/libxml2/libxml2_globals.h>

#include "xmlengdomdefs.h"

#include <xml/utils/xmlengutils.h>

#include <stdapis/libxml2/libxml2_parserinternals.h>

#include <xml/utils/xmlengmem.h>

#include <xml/utils/xmlengxestrings.h>

#include "libxml2_tree_private.h"

#define LIBXML_ELEMENT (static_cast<xmlNodePtr>(iInternal))

void ResetNs(xmlNodePtr node,xmlNsPtr ns)

    {

    if(node->ns == ns)

        {

        node->ns = NULL;

        }

    xmlNodePtr child = node->children;

    while (child)

        {

        if(child->type == XML_ELEMENT_NODE)

            {

            ResetNs(child,ns);

            }

        child = child->next;

        }

    xmlAttrPtr attr = node->properties;

    while (attr)

        {

        if(attr->type == XML_ATTRIBUTE_NODE && attr->ns == ns)

            {

            attr->ns = NULL;

            }

        attr = attr->next;

        }

    };

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

// Creates new attribute node out of any namespace (i.e. it has no prefix),

// sets attribute's value and links it as the last attribute of the current element

//   

// @param  aName   A local name of attribute

// @param  aValue  Value to set for new attribute or NULL (sets value to "")

// @return         A handler to the newly created attribute node;

//

// For adding attribute as the first one, use TXmlEngNode::SetAsFirstSibling() on the attribute:

// @code

//     TXmlEngElement el = ... ; // get some element

//     el.AddNewAttributeL("version","0.1").SetAsFirstSibling();

// @endcode

//   

//   @see   SetAsLastSibling(), MoveBeforeSibling(TXmlEngNode) and MoveAfterSibling(TXmlEngNode)

//

//   @note   - No checks are made that attribute with such name exists

//             Use this method only on newly created elements!

//             Otherwise, use TXmlEngElement::SetAttributeL(..)

//           - Attributes do not inherit default namespace of its element

//             (http://w3.org/TR/REC-xml-names/#defaulting)

//           - attribute's value is the second argument in all AddNewAttributeL(..) methods

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

//

EXPORT_C TXmlEngAttr TXmlEngElement::AddNewAttributeL(

    const TDesC8& aName,

    const TDesC8& aValue )

    {

    if ( !iInternal )

    	{

    	User::Leave(KXmlEngErrNullNode);

    	}

    if ( aName.Length() <= 0 ) 

    	{

    	User::Leave(KXmlEngErrWrongUseOfAPI);

    	}

    //

    xmlChar* name = xmlCharFromDesC8L(aName);

    CleanupStack::PushL(name);

    xmlChar* value = xmlCharFromDesC8L(aValue);

    xmlAttrPtr attr = xmlNewProp( // NOTE: no checks that such attribute already exists

                            LIBXML_ELEMENT,

                            name,

                            value);

    delete value;

    CleanupStack::PopAndDestroy(name);

    OOM_IF_NULL(attr);

    return TXmlEngNode(attr).AsAttr();

    }

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

// Creates new attribute node and add it to the element

//

// Provided handle to namespace declaration is used to set up

// attribute's namespace.

//

// @note If aNsDef is not defined in some of attributes ascendants

//     (including this element), then

//      ReconcileNamespacesL() method must be called on

//      this element later.

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

//

EXPORT_C TXmlEngAttr  TXmlEngElement::AddNewAttributeL(

    const TDesC8& aName,

    const TDesC8& aValue,

    TXmlEngNamespace aNsDef)

    {

    TXmlEngAttr attr = AddNewAttributeL(aName, aValue);

    _LIT(KAutoPrefix,"_pr%d");

    const TInt KMaxPrefLength = 20;

    TBuf<KMaxPrefLength> prefix;

    TUint ind = 0;

    char* prefCh = NULL;

    xmlNsPtr ns;

    if (aNsDef.NotNull())

        {

        if (aNsDef.IsDefault())

            {

            // create new temporary namespace binding (with non-NULL prefix)

            ns = NULL;

            while(!ns)

                {

                // generate prefix

                ++ind;

                prefix.Format(KAutoPrefix,ind);

                prefCh = XmlEngXmlCharFromDesL(prefix);

                TXmlEngConstString pref(prefCh);

                delete prefCh;

        		if(!xmlSearchNs(LIBXML_ELEMENT->doc,

	        					LIBXML_ELEMENT,

	        					CAST_DOMSTRING_TO_XMLCHAR(pref)))

        			{

	                ns = xmlNewNs(

	                        LIBXML_ELEMENT,

	                        INTERNAL_NSPTR(aNsDef)->href,

	                        CAST_DOMSTRING_TO_XMLCHAR(pref));

	                TEST_OOM_FLAG;        			

        			}

                }

            }

        else

            {

            ns = INTERNAL_NSPTR(aNsDef);

            }

        INTERNAL_ATTRPTR(attr)->ns = ns;

        }

    return attr;

    }

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

// Creates new attribute on the element. Namespace declaration for the attribute namespace is

// created too.

//

// @note

//     - Namespace declarations are reused if possible (no redundant ones are created)

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

//

EXPORT_C TXmlEngAttr TXmlEngElement::AddNewAttributeL(

    const TDesC8& aName,

    const TDesC8& aValue,

    const TDesC8& aNsUri,

    const TDesC8& aPrefix )

    {

    TXmlEngAttr attr = AddNewAttributeL(aName, aValue);

    if (!aPrefix.Length()) // NULL or "" 	 

        {	  	 

        if (aNsUri.Length()) // !(NULL or "") --> namespace URI is present

            {

            // An attribute cannot have default namespace (Pref = "" AND nsUri!="")

	        WRONG_USE_OF_API;

            }	  	 

        return attr; 	  	  	 

        }

    TXmlEngNamespace nsDef = AddNamespaceDeclarationL(aNsUri, aPrefix);

    INTERNAL_ATTRPTR(attr)->ns = INTERNAL_NSPTR(nsDef);

    return attr;

    }

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

// Creates new attributes using namespace, which is bound to the specified prefix

//

// Please, use this mothod only for construction of new parts of DOM tree, where

// you know for sure that prefix is bound in the given scope.

// @code

//     TXmlEngElement el = parent.AddNewAttributeUsePrefixL("property","ObjName","rdf");

//     el.AddNewAttributeUsePrefixL("type", "xs:integer", "rdf");

// @endcode

//

// Otherwise, you should check that prefix is bound like this example shows:

// @code

//     TXmlEngNamespace boundNS = TXmlEngNamespace::LookupByPrefix(thisElement, prefix);

//     if (boundNS.NotNull()){

//         thisElement.AddNewAttributeUsePrefixL("name", value, prefix);

//     }

// @endcode

//

// @note

//     Use AddNewAttributeNsL(name,value,nsDefNode) as much as you can, because

//     it is most efficient way to create namespaced DOM elements (no additional

//     lookups for namespace declarations are required).

//   

// @code

//     // If namespace with given URI is not in the scope, then it will be declared

//     // and bound to "data" prefix.

//     TXmlEngNamespace nsDef = elem.FindOrCreateNsDeclL("http://../Data", "data");

//     elem.AddNewAttributeL("location", "...", nsDef);

//     elem.AddNewElementL("child", nsDef).AddNewAttributeL("attr","...value...");

//     // the result is

//        ...

//        <elem xmlns:data="http://../Data" data:location="...">

//           <data:child attr="...value..."/>

//        </elem>

//        ...

//     //

// @endcode    

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

//

EXPORT_C TXmlEngAttr TXmlEngElement::AddNewAttributeUsePrefixL(

    const TDesC8& aLocalName,

    const TDesC8& aValue,

    const TDesC8& aPrefix )

    {

    _LIT8(KXml,"xml");

    TXmlEngAttr attr = AddNewAttributeL(aLocalName, aValue);

    // try to locate namespace binding for the same prefix

    xmlChar* prefix = xmlCharFromDesC8L(aPrefix);

    xmlNsPtr ns = xmlSearchNs(

                    LIBXML_ELEMENT->doc,

                    LIBXML_ELEMENT,

                    prefix);

    delete prefix;                

    if (!ns)

        {

        // OOM may happen ONLY for "xml" prefix search

        OOM_IF(!aPrefix.Compare(KXml));

        WRONG_USE_OF_API; // Prefix is not bound

        }

    INTERNAL_ATTRPTR(attr)->ns = ns;

    return attr;

}

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

// Creates new attributes using namespace in the scope, which has specified URI

//   

// Almost the same as AddNewAttributeUsePrefixL(...) but does lookup by namespace URI

//

// @return - NULL attribute if namespace declaration is not found OR newly added to the end of

//     attribute list attribute of this element.

//

// @see AddNewAttributeUsePrefixL(TDesC8,TDesC8,TDesC8)

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

//

EXPORT_C TXmlEngAttr TXmlEngElement::AddNewAttributeWithNsL(

    const TDesC8& aLocalName,

    const TDesC8& aValue,

    const TDesC8& aNsUri )

    {

    _LIT8(KXmlNs,"http://www.w3.org/XML/1998/namespace");

    // try to locate namespace binding for the same prefix

    xmlChar* nsp = xmlCharFromDesC8L(aNsUri);

    xmlNsPtr ns = xmlSearchNsByHref(

                    LIBXML_ELEMENT->doc,

                    LIBXML_ELEMENT,

                    nsp);

    delete nsp;

    if (!ns)

        {

        // OOM may happen ONLY for "xml" prefix search

        OOM_IF(!aNsUri.Compare(KXmlNs));

        TXmlEngAttr attr;

        return attr;

        }

    TXmlEngAttr attr = AddNewAttributeL(aLocalName, aValue);

    INTERNAL_ATTRPTR(attr)->ns = ns;

    return attr;

    }

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

// Adds child element with no namespace

//

// @param aName name of the element

//

// Results in adding element with aName and no prefix.

//

// This method is the best for creation of non-namespace based documents

// or document fragments, where no default namespace declared.

//

// It may be used also as a method for  adding element from default namespace,

// BUT namespace will be assigned ONLY after serialization of the current

// document and parsing it back into a DOM tree!! If you need that default namespace

// was inherited by new element immediately use:

// @code

//     ...

//     TXmlEngNamespace defns = element.DefaultNamespace();

//     TXmlEngElement newEl = element.AddNewElementL("Name",defns);

//     ...

// @endcode

//

// If truly undefined namespace for the element is required, then <b>DO NOT USE</b>

// this method if there is a default namespace in the scope!

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

//

EXPORT_C TXmlEngElement TXmlEngElement::AddNewElementL(

    const TDesC8& aName )

    {

    if ( !iInternal )

    	{

    	User::Leave(KXmlEngErrNullNode);

    	}

    if ( aName.Length() <= 0 ) 

    	{

    	User::Leave(KXmlEngErrWrongUseOfAPI);

    	}

    xmlChar* name = xmlCharFromDesC8L(aName);

    xmlNodePtr element = xmlNewNode(NULL, name);

    delete name;

    //

    OOM_IF_NULL(element);

    //

    element->parent = LIBXML_ELEMENT;

    element->doc = LIBXML_ELEMENT->doc;

    // Link element as the last child

    xmlNodePtr prev = LIBXML_ELEMENT->last;

    LIBXML_ELEMENT->last = element;

    element->prev = prev;

    if (prev)

        {

        prev->next = element;

        }

    if (!(LIBXML_ELEMENT->children))

        {

        LIBXML_ELEMENT->children = element;

        }

    return TXmlEngElement(element);

    }

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

// Creates new child element with provided name, prefix and namespace URI

//

// New namespace declaration will be attached to the parent (this) element and used

// as namespace for newly created child element. If such binding already exists

// (same prefix is bound to same URI), it will be reused. If the prefix is already

// bound to some another namespace URI, it will be rebound by the new namespace

// declaration node.

//

// @param aLocalName Name of the element

// @param aNsUri     URI of element's namespace

// @param aPrefix    Prefix of the element

// @return Created element node (and added as the last child of its parent)

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

//

EXPORT_C TXmlEngElement TXmlEngElement::AddNewElementL(

    const TDesC8& aLocalName,

    const TDesC8& aNsUri,

    const TDesC8& aPrefix )

    {

    TXmlEngElement element = AddNewElementL(aLocalName);

    TXmlEngNamespace nsDef = AddNamespaceDeclarationL(aNsUri, aPrefix);

    INTERNAL_NODEPTR(element)->ns = INTERNAL_NSPTR(nsDef);

    return element;

    }

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

// Creates new child element with provided name and namespace declaration

//

// @param aLocalName Name of the element

// @param aNsDef     Handle of the namespace declaration, that must be retrieved from

//                  one of the ascendant nodes of the new elements (and its prefix

//                  should not be remapped to another namespace URI for the scope

//                  of the new element)

// @return    Created element node (and added as the last child of its parent)

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

//

EXPORT_C TXmlEngElement  TXmlEngElement::AddNewElementL(

    const TDesC8& aLocalName,

    TXmlEngNamespace aNsDef )

    {

    TXmlEngElement element = AddNewElementL(aLocalName);

    INTERNAL_NODEPTR(element)->ns = INTERNAL_NSPTR(aNsDef);

    return element;

    }

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

// Adds child element with same namespace (and prefix if present) as parent element has

//

// @param aLocalName element's name

// @return New element that was added to the end of children list of its parent (this element)

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

//

EXPORT_C TXmlEngElement TXmlEngElement::AddNewElementSameNsL(

    const TDesC8& aLocalName )

    {

    TXmlEngElement element = AddNewElementL(aLocalName);

    INTERNAL_NODEPTR(element)->ns = LIBXML_ELEMENT->ns;

    return element;

    }

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

// Performs lookup for the namespace declaration for specified prefix and

// adds new child element with found namespace.

//

// The assumption is that prefix is bound, otherwise run-time error

// (Symbian's Leave or exception) occurs

//

// @note   Use this method only if there is a binding for the given prefix.

//

// @param aLocalName element's name

// @param aPrefix    prefix to use

// @return new TXmlEngElement that was added to the end of children list of its parent (this element)

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

//

EXPORT_C TXmlEngElement TXmlEngElement::AddNewElementUsePrefixL(

    const TDesC8& aLocalName,

    const TDesC8& aPrefix )

    {

    _LIT8(KXml,"xml");

    TXmlEngElement element = AddNewElementL(aLocalName);

    // Can fail only with XML's namespace

    xmlChar* pref = xmlCharFromDesC8L(aPrefix);

    xmlNsPtr ns = xmlSearchNs(

                    LIBXML_ELEMENT->doc,

                    LIBXML_ELEMENT,

                    pref);

    delete pref;

    //

    OOM_IF(!ns && !aPrefix.Compare(KXml));

    //

    INTERNAL_NODEPTR(element)->ns = ns;

    return element;

    }

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

// Performs lookup for the namespace declaration for specified namespace URI and

// adds new child element with found namespace.

//

// The assumption is that namespace with given URI was declared,

// otherwise run-time error (Symbian' Leave or exception) occurs

//

// @note Use this method only if namespace declaration for the provided URI exists.

//

// @param aLocalName element's name

// @param aNsUri     namespace of element

// @return new TXmlEngElement that was added to the end of children list of its parent (this element)

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

//

EXPORT_C TXmlEngElement TXmlEngElement::AddNewElementWithNsL(

    const TDesC8& aLocalName,

    const TDesC8& aNsUri )

    {

    _LIT8(KXmlNs,"http://www.w3.org/XML/1998/namespace");

    TXmlEngElement element = AddNewElementL(aLocalName);

    /*xmlNsPtr ns = xmlSearchNsByHref(

                    LIBXML_ELEMENT->doc,

                    LIBXML_ELEMENT,

                    CAST_DOMSTRING_TO_XMLCHAR(aNsUri));

    */

    TXmlEngNamespace ns = LookupNamespaceByUriL(aNsUri);

    // May fail only with XML's namespace

    OOM_IF(ns.IsNull() && !aNsUri.Compare(KXmlNs));

    //

    INTERNAL_NODEPTR(element)->ns = INTERNAL_NSPTR(ns);

    return element;

    }

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

// Creates new child element; if there is no a prefix binding for new element's namespace,

// a namespace decaration is created with generated prefix at specified element.

//

// @param aLocalName    Name of the element to create

// @param aNsUri        Namespace URI of the new element

// @param aNsDeclTarget An element where namespace declaraton should be placed

//                     if there is a needed to create new namespace declaration;

//                     NULL is used to specify the created element itself

//

// As aNsDeclTarget any ascendant of the new node may be provided:

// @code

//     el.AddNewElementAutoPrefixL(tagName,uri,NULL); // declare on the new element

//     el.AddNewElementAutoPrefixL(tagName,uri,el);   // declare on the parent element

//     el.AddNewElementAutoPrefixL(tagName,uri,doc.DocumentElement()); // declare on the root element

//     ...

// @endcode

//

// @note

//     The farther namespace declaration up in the document tree,

//     the longer time namespace declaration lookups take.

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

//

EXPORT_C TXmlEngElement TXmlEngElement::AddNewElementAutoPrefixL(

    const TDesC8& aLocalName,

    const TDesC8& aNsUri,

    TXmlEngElement aNsDeclTarget )

    {

    TXmlEngElement elem = AddNewElementL(aLocalName);

    if (aNsDeclTarget.IsNull())

        aNsDeclTarget = elem;

    TXmlEngNamespace ns = aNsDeclTarget.FindOrCreateNsDeclL(aNsUri);

    INTERNAL_NODEPTR(elem)->ns = INTERNAL_NSPTR(ns);

    return elem;

    }

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