/*

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

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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:  Content handler for XHTML content type

*

*/

// INCLUDE FILES

#include <e32def.h>  // To avoid NULL redefine warning (no #ifndef NULL)

#include "nw_lmgr_box.h"

#include "nw_lmgr_rootbox.h"

#include "nw_lmgr_marqueebox.h"

#include "nw_lmgr_verticaltablebox.h"

#include "nw_lmgr_verticaltablerowbox.h"

#include "nw_lmgr_verticaltablecellbox.h"

#include "nw_lmgr_bidiflowbox.h"

#include "nw_lmgr_textbox.h"

#include <f32file.h>

#include <flogger.h>

#include <stddef.h>

#include <stdio.h>

#include <string.h>

#include "nwx_string.h"

#include "nw_xhtml_xhtmlcontenthandleri.h"

#include "nw_basicforms_xhtmlformliaison.h"

#include "XhtmlTableElementHandlerOOC.h"

#include "nw_basictables_trelementhandler.h"

#include "nw_basictables_cellelementhandler.h"

#include "nw_xhtml_textelementhandler.h"

#include "nw_text_coretextelementhandler.h"

#include "nw_xhtml_pielementhandler.h"

#include "nw_image_imgelementhandler.h"

#include "nw_hed_documentroot.h"

#include "nw_hed_inumbercollectori.h"

#include "nw_lmgr_bidiflowbox.h"

#include "nw_dom_domvisitor.h"

#include <nw_tinydom.h>

#include <nw_dom_element.h>

#include <nw_dom_document.h>

#include "nw_adt_segmentedvector.h"

#include "nw_adt_resizableobjectvector.h"

#include "nw_adt_mapiterator.h"

#include <nw_xmlp_xmlp2wbxml.h>

#include "nw_htmlp_to_wbxml.h"

#include "nwx_url_utils.h"

#include "nwx_string.h"

#include "nwx_logger.h"

#include "nw_hed_context.h"

#include "NW_Text_Abstract.h"

#include "nw_text_ucs2.h"

#include "nw_xhtml_xhtmlentityset.h"

#include "nwx_ctx.h"

#include "nw_hed_documentroot.h"

#include "HEDDocumentListener.h"

#include "nw_xhtml_xhtml_1_0_tokens.h"

#include "nw_hed_domhelper.h"

#include "nw_msg_messagedispatcher.h"

#include "nw_markup_numbercollector.h"

//R->ul #include "urlloader_urlloaderint.h"

#include "nwx_osu_file.h"

#include "nw_hed_hedeventhandler.h"

#include "nw_lmgr_activecontainerbox.h"

#include "nwx_http_defs.h"

#include "nwx_settings.h"

//#include "nw_ecma_contenthandler.h"

#include "MapElementList.h"

#include "nw_lmgr_simplepropertylist.h"

#include "BrsrStatusCodes.h"

#include "nwx_statuscodeconvert.h"

#include <flogger.h>

#include "nw_markup_wbxmlmodule.h"

#include "nw_structure_scriptelementhandler.h"

#include "XhtmlObjectElementHandlerOOCi.h"

#include "XHTMLMessageListener.h"

#include <bodypart.h>

#include "MVCShell.h"

#include "BrCtl.h"

#include <stddef.h>

#include "CReferrerHelper.h"

#include "CSSVariableStyleSheet.h"

// MODULE DATA STRUCTURES

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

   class definition

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

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

   forward method declarations

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

static

TBrowserStatusCode

NW_XHTML_ContentHandler_MetaRefreshTimerCallback (void* timerData);

// ============================= LOCAL FUNCTIONS ===============================

static

NW_LMgr_ContainerBox_t*

NW_XHTML_ContentHandler_GetContainerSpecialCase ( NW_DOM_Node_t* node,

        NW_DOM_Node_t* parentNode,

        NW_LMgr_ContainerBox_t* containerBox)

    {

    NW_ASSERT (parentNode);

    NW_ASSERT (node);

    NW_ASSERT (containerBox);

    // special handling for form inside table

    NW_Uint16 token = NW_HED_DomHelper_GetElementToken (parentNode);

    if (token == NW_XHTML_ElementToken_form)

        {

        // if chunk cuts after form

        token = NW_HED_DomHelper_GetElementToken (node);

        if (token == NW_XHTML_ElementToken_tr ||

            token == NW_XHTML_ElementToken_td ||

            token == NW_XHTML_ElementToken_th)

            {

            containerBox = NW_LMgr_Box_GetParent(containerBox);

            }

        else

            {

            NW_Uint32 type = NW_DOM_Node_getNodeType(node);

            // special handling for text node is under form and form is under table, th, tr

            if (type == NW_DOM_TEXT_NODE)

                {

                NW_DOM_Node_t* tempNode = NW_DOM_Node_getParentNode(parentNode);

                token = NW_HED_DomHelper_GetElementToken (tempNode);

                if (token == NW_XHTML_ElementToken_tr ||

                    token == NW_XHTML_ElementToken_th ||

                    token == NW_XHTML_ElementToken_table)

                    {

                    containerBox = NW_LMgr_Box_GetParent(containerBox);

                    }

                }

            }

        }

    else if (token == NW_XHTML_ElementToken_table)

        {

        // if chunk cuts above form

        token = NW_HED_DomHelper_GetElementToken (node);

        if (token == NW_XHTML_ElementToken_form)

            {

            containerBox = NW_LMgr_Box_GetParent(containerBox);

            }

        } // end of if (token == NW_XHTML_ElementToken_form)

    return containerBox;

    }

static

NW_DOM_Node_t*

NW_XHTML_ContentHandler_GetParentNodeSpecialCase ( NW_DOM_Node_t* node,

        NW_DOM_Node_t* parentNode,

        NW_Bool* formInTable)

    {

    NW_ASSERT (parentNode);

    NW_ASSERT (node);

    NW_Uint16 token = NW_HED_DomHelper_GetElementToken (parentNode);

    if (token == NW_XHTML_ElementToken_form)

        {

        // special handling for form inside table

        token = NW_HED_DomHelper_GetElementToken (node);

        if (token == NW_XHTML_ElementToken_tr ||

            token == NW_XHTML_ElementToken_td ||

            token == NW_XHTML_ElementToken_th)

            {

            parentNode = NW_DOM_Node_getParentNode(parentNode);

            }

        else

            {

            NW_Uint32 type = NW_DOM_Node_getNodeType(node);

            // special handling for text node is under form and form is under table, th, tr

            if (type == NW_DOM_TEXT_NODE)

                {

                NW_DOM_Node_t* tempNode = NW_DOM_Node_getParentNode(parentNode);

                token = NW_HED_DomHelper_GetElementToken (tempNode);

                if (token == NW_XHTML_ElementToken_tr ||

                    token == NW_XHTML_ElementToken_th ||

                    token == NW_XHTML_ElementToken_table)

                    {

                    parentNode = tempNode;

                    }

                }

            }

        }

    else if (token == NW_XHTML_ElementToken_table)

        {

        // if chunk cuts above form

        token = NW_HED_DomHelper_GetElementToken (node);

        if (token == NW_XHTML_ElementToken_form)

            {

            *formInTable = NW_TRUE;

            }

        } // end of if (token == NW_XHTML_ElementToken_form)

    return parentNode;

    }

static

TBrowserStatusCode

NW_XHTML_ContentHandler_GetContainerBox ( NW_DOM_Node_t* lastDomNode,

        NW_DOM_Node_t* currentDomNode,

        NW_LMgr_ContainerBox_t** containerBox,

        NW_LMgr_ContainerBox_t* parentBox )

    {

    NW_ASSERT (lastDomNode);

    NW_ASSERT (currentDomNode);

    NW_ASSERT (parentBox);

    // used to track the levels up in the box tree to find the right container box

    NW_LMgr_Box_t* lastBox;

    // check the levels of the current parent node and the last dom node

    NW_DOM_Node_t* currentParentNode = NW_DOM_Node_getParentNode(currentDomNode);

    lastBox = (NW_LMgr_Box_t *)parentBox ;

    // if the currentDomNode's ancestor is the last node, then return the lastContainerBox

    // this can happen when last dom node's children arrives in the next chunk

    if (currentParentNode == lastDomNode)

        {

        // get the last box from the box tree

        do

            {

            NW_ADT_Vector_Metric_t numChildren = NW_LMgr_ContainerBox_GetChildCount(NW_LMgr_ContainerBoxOf(lastBox ));

            // if the box has no children , then break , it could be a box or a last container box

            if (numChildren == 0 )

                {

                break;

                }

            // get the last box in the level

            numChildren --;

            lastBox = NW_LMgr_ContainerBox_GetChild(NW_LMgr_ContainerBoxOf(lastBox), numChildren );

            }

        while (NW_Object_IsInstanceOf (lastBox, &NW_LMgr_ContainerBox_Class));

        // if the last box is not an instance of container box , find the parent box

        // of the last box

        NW_LMgr_ContainerBox_t* lastContainerBox;

        if (!NW_Object_IsInstanceOf (lastBox, &NW_LMgr_ContainerBox_Class))

            {

            lastContainerBox = NW_LMgr_Box_GetParent(lastBox );

            }

        else

            {

            lastContainerBox = NW_LMgr_ContainerBoxOf(lastBox );

            }

        // special handling for form inside table

        *containerBox = NW_XHTML_ContentHandler_GetContainerSpecialCase( currentDomNode,

                        currentParentNode,

                        lastContainerBox);

        }

    else

        {

        // if the container box is not in the parent hirerchy

        NW_Bool formInsideTable = NW_FALSE;

        currentParentNode = NW_XHTML_ContentHandler_GetParentNodeSpecialCase (currentDomNode,

                            currentParentNode,

                            &formInsideTable);

        // traverse the last branch of the box tree

        NW_Bool found = NW_FALSE;

        do

            {

            NW_LMgr_PropertyValue_t value;

            value.object = NULL;

            (void)NW_LMgr_Box_GetPropertyValue(lastBox, NW_CSS_Prop_elementId, NW_CSS_ValueType_Object, &value);

            if (value.object)

                {

                NW_DOM_ElementNode_t* elementNode = (NW_DOM_ElementNode_t*)value.object;

                if (elementNode == currentParentNode)

                    {

                    found = NW_TRUE;

                    break;

                    }

                }

            NW_ADT_Vector_Metric_t numChildren = NW_LMgr_ContainerBox_GetChildCount(NW_LMgr_ContainerBoxOf(lastBox ));

            if (numChildren == 0 )

                {

                break;

                }

            numChildren --;

            lastBox = NW_LMgr_ContainerBox_GetChild(NW_LMgr_ContainerBoxOf(lastBox), numChildren );

            }

        while (NW_Object_IsInstanceOf (lastBox, &NW_LMgr_ContainerBox_Class));

        // could be the case when header occupies first chunk

        if (!found)

            {

            NW_LMgr_Box_t* rootBox = NW_LMgr_BoxOf(NW_LMgr_Box_GetParent(parentBox));

            NW_ASSERT(NW_Object_IsInstanceOf (rootBox, &NW_LMgr_RootBox_Class));

            NW_LMgr_Box_t* bodyBox = NW_LMgr_RootBox_GetBody(NW_LMgr_RootBoxOf(rootBox));

            if (!bodyBox)

                {

                *containerBox = NW_LMgr_ContainerBoxOf(NW_LMgr_ContainerBox_GetChild(NW_LMgr_ContainerBoxOf(rootBox), 0));

                }

            else

                {

                *containerBox = NW_LMgr_ContainerBoxOf(bodyBox);

                }

            }

        else

            {

            if (formInsideTable)

                {

                // if form is under table, attach form to the parent box of table box

                *containerBox = NW_LMgr_Box_GetParent(lastBox);

                }

            else

                {

                *containerBox = NW_LMgr_ContainerBoxOf(lastBox);

                }

            }

        } // end of if (currentParentNode == lastDomNode)

    return KBrsrSuccess;

    }

static

TBrowserStatusCode

NW_XHTML_ContentHandler_CreatePartialBoxTree (NW_XHTML_ContentHandler_t* thisObj,

        NW_LMgr_Box_t** boxTree)

    {

    NW_DOM_Node_t* domNode = NULL;

    NW_DOM_Node_t* lastDomNode;

    const NW_XHTML_ElementHandler_t* elementHandler;

    NW_cXML_DOM_DOMVisitor_t * domDOMVisitor = NULL;

    NW_LOG0( NW_LOG_LEVEL2, "NW_XHTML_ContentHandler_CreatePartialBoxTree START" );

    NW_TRY (status)

        {

        if (thisObj->prevInitializedDomNode == 0)

            NW_THROW_SUCCESS(status);

        // if there are new nodes to create the box tree

        domDOMVisitor =

            NW_cXML_DOM_DOMVisitor_New( NW_HED_DomTree_GetRootNode( thisObj->domTree));

        NW_THROW_ON_NULL( domDOMVisitor, status, KBrsrOutOfMemory );

        // skip DOM nodes for which boxes were created (of the previous chunks)

        domDOMVisitor->currentNode = thisObj->prevInitializedDomNode;

        lastDomNode = thisObj->prevInitializedDomNode;

#ifdef _DEBUG1

        NW_LMgr_Box_DumpBoxTree1((NW_LMgr_Box_t*)*boxTree);

#endif

        // get the next dom node - this will be the first node of the new chunk

        domNode = NW_cXML_DOM_DOMVisitor_Next( domDOMVisitor, NW_DOM_ELEMENT_NODE |

                                               NW_DOM_TEXT_NODE | NW_DOM_PROCESSING_INSTRUCTION_NODE );

        if (domNode == 0) // no new domNode to create a tree

            NW_THROW_SUCCESS(status);

        do

            {

            NW_LMgr_ContainerBox_t* containerBox = NULL;

            // find the correspoding container box for the dom node

            (void)NW_XHTML_ContentHandler_GetContainerBox(lastDomNode, domNode, &containerBox, NW_LMgr_ContainerBoxOf(*boxTree));

            NW_ASSERT(containerBox != NULL);

            NW_ASSERT(NW_Object_IsInstanceOf (containerBox, &NW_LMgr_ContainerBox_Class));

            NW_ASSERT(!NW_Object_IsInstanceOf (containerBox, &NW_LMgr_RootBox_Class));

            // create the box tree for the subtree

            // all the siblings can use the container box to create the box tree

            // traverse the sibling nodes and create the box tree for the sibling nodes.

            // skip the siblings and all its child nodes

            NW_DOM_Node_t* prevDomNode = domNode;

            for (;domNode != NULL ;domNode = NW_DOM_Node_getNextSibling (domNode))

                {

                NW_Uint32 type = NW_DOM_Node_getNodeType(domNode);

                thisObj->prevInitializedDomNode = domNode ;

                if (type == NW_DOM_TEXT_NODE)

                    {

                    NW_DOM_Node_t* parentNode = NW_DOM_Node_getParentNode(domNode);

                    NW_Uint16 token = NW_HED_DomHelper_GetElementToken (parentNode);

                    if (token == NW_XHTML_ElementToken_table ||

                        token == NW_XHTML_ElementToken_tr ||

                        token == NW_XHTML_ElementToken_th)

                        {

                        // special handling for text node under table, th, tr

                        lastDomNode = domNode;

                        continue;

                        }

                    else if (token == NW_XHTML_ElementToken_form &&

                             (NW_Object_IsInstanceOf (containerBox, &NW_LMgr_VerticalTableBox_Class) ||

                              NW_Object_IsInstanceOf (containerBox, &NW_LMgr_VerticalTableRowBox_Class)))

                        {

                        // special handling for text node under form in dom tree

                        // text node is under table, th, tr in box tree

                        lastDomNode = domNode;

                        continue;

                        }

                    }

                elementHandler = NW_XHTML_ContentHandler_GetElementHandler (thisObj,

                                 (NW_DOM_ElementNode_t*) domNode);

                NW_ASSERT(elementHandler != NULL);

                status = NW_XHTML_ElementHandler_CreateBoxTree (elementHandler,

                         thisObj,

                         domNode,

                         containerBox);

                _NW_THROW_ON_ERROR(status);

                lastDomNode = domNode;

                } // end of for (;domNode != NULL

            // go up the hirarchy and process all the dom nodes and all its children

            do

                {

                prevDomNode = NW_DOM_Node_getParentNode(prevDomNode);

                if (prevDomNode && NW_DOM_Node_getNextSibling (prevDomNode))

                    {

                    domNode = NW_DOM_Node_getNextSibling (prevDomNode);

                    break;

                    }

                }

            while (prevDomNode);

#ifdef _DEBUG1

            NW_LMgr_Box_DumpBoxTree((NW_LMgr_Box_t*)*boxTree);

#endif

            }

        while (domNode);

        } // end NW_TRY

    NW_CATCH (status)

    {}

    NW_FINALLY

    {

        if (domDOMVisitor)

        {

        NW_Object_Delete (domDOMVisitor);

            }

        NW_LOG0( NW_LOG_LEVEL2, "NW_XHTML_ContentHandler_CreatePartialBoxTree END" );

        return status;

    }

    NW_END_TRY

    }

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

   private methods

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

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

TBrowserStatusCode

NW_XHTML_ContentHandler_CreatePartialDocument( NW_XHTML_ContentHandler_t* contentHandler,

        NW_Url_Resp_t* response, NW_Bool isFirst )

    {

    NW_Buffer_t* domBuffer;

    NW_Uint32 line = 0;

    TBrowserStatusCode status;

    NW_Uint32 codePageSwitchCount = 0;

    NW_Int32 lastValid = -1;

    NW_Bool encodingFound;

    void* WBXMLEncStrTbl = NULL;

    NW_LOG0(NW_LOG_LEVEL2, "NW_XHTML_ContentHandler_CreatePartialDocument");

    status = _NW_HED_CompositeContentHandler_ComputeEncoding(NW_HED_CompositeContentHandlerOf(contentHandler),

             response, &encodingFound);

    if (status != KBrsrSuccess)

        {

        return status;

        }

    if(response->contentLocationString != NULL)

        {

        contentHandler->contentLocation = NW_Str_CvtFromAscii((char *)response->contentLocationString);

        if(contentHandler->contentLocation  == NULL)

            {

            return KBrsrOutOfMemory;

            }

        }

    /* Change done to support saved deck */

    if ((0 == NW_Asc_stricmp((char*)HTTP_text_vnd_wap_wml_string,

                             (char*)response->contentTypeString)) ||

        (0 == NW_Asc_stricmp((char*)HTTP_application_xhtml_xml_string,

                             (char*)response->contentTypeString)) ||

        (0 == NW_Asc_stricmp((char*)HTTP_application_vnd_wap_xhtml_xml_string,

                             (char*)response->contentTypeString)) ||

        (0 == NW_Asc_stricmp((char*)HTTP_text_html_string,

                             (char*)response->contentTypeString)) ||

        (0 == NW_Asc_stricmp((char*)HTTP_application_vnd_wap_wml_plus_xml_string,

                             (char*)response->contentTypeString)))

        {

        NW_HED_CharsetConvContext ctx;

        ctx.contentHandler = NW_HED_CompositeContentHandlerOf( contentHandler );

        ctx.response = response;

        NW_LOG0(NW_LOG_LEVEL2, "CreateDocument: before NW_HTMLP_SegToWbxml ");

        NW_Bool detectEncoding = (encodingFound) ? NW_FALSE : NW_TRUE;

        status = NW_HTMLP_SegToWbxml( response->body, response->charset,

                                      response->byteOrder,

                                      &domBuffer, &line, NW_xhtml_1_0_PublicId,

                                      NW_HTMLP_Get_ElementTableCount(),

                                      NW_HTMLP_Get_ElementDescriptionTable(),

                                      NW_FALSE,       /* consume spaces */

                                      detectEncoding, /* need to detect charset */

                                      isFirst,        /* is this the first segment of a document? */

                                      NW_FALSE,       /* is this the last segment of a document? */

                                      &lastValid,