/*

* 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:  Handles object tags in XHTML documents.

*

*/

// INCLUDE FILES

#include <e32std.h>

#include <e32def.h>

#include <webkit.rsg>

#include "nw_xhtml_xhtmlcontenthandler.h"

#include "nw_xhtml_elementhandler.h"

//#include "nw_ecma_contenthandler.h"

#include "nw_evt_accesskeyevent.h"

#include "nw_evt_activateevent.h"

#include "nw_evt_openviewerevent.h"

#include "nw_evt_focusevent.h"

#include "nw_hed_documentroot.h"

#include "HEDDocumentListener.h"

#include "nw_hed_hedeventhandler.h"

#include "nw_lmgr_animatedimagebox.h"

#include "nw_lmgr_propertylist.h"

#include "LMgrObjectBoxOOC.h"

#include "nw_lmgr_rootbox.h"

#include "nw_image_cannedimages.h"

#include "nw_image_virtualimage.h"

#include "nwx_settings.h"

#include "PluginContentHandlerOOC.h"

#include "LMgrObjectBox.h"

#include "PluginContentHandler.h"

#include "ObjectUtils.h"

#include "PluginHandler.h"

#include "StringUtils.h"

#include "ObjectDialog.h"

#include "XhtmlObjectElementHandler.h"

#include "nwx_http_defs.h"

#include "urlloader_urlresponse.h"

// ============================ MEMBER FUNCTIONS ===============================

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

// CXHTMLObjectElementHandler::CXHTMLObjectElementHandler

//

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CXHTMLObjectElementHandler::CXHTMLObjectElementHandler(const NW_XHTML_ElementHandler_t* aElementHandler,

        NW_XHTML_ContentHandler_t* aContentHandler, NW_DOM_ElementNode_t* aElementNode)        

    {

    NW_ASSERT(aElementHandler != NULL);

    NW_ASSERT(aContentHandler != NULL);

    NW_ASSERT(aElementNode != NULL);

    iElementHandler = aElementHandler;

    iContentHandler = aContentHandler;

    iElementNode = aElementNode;

    iLoadedHandlerType = ObjectUtils::EHandlerAny;

    }

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

// CXHTMLObjectElementHandler::ConstructL

//

// Symbian 2nd phase constructor can leave.

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

//

void CXHTMLObjectElementHandler::ConstructL(void)

    {

    }

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

// CXHTMLObjectElementHandler::~CXHTMLObjectElementHandler

//

// Deconstructor.

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

//

CXHTMLObjectElementHandler::~CXHTMLObjectElementHandler()

    {

    // Clear the listener so this isn't notified when the box is destroyed,

    // since this instance will no longer be valid.

    if (iObjectBox)

        {

        NW_LMgr_ObjectBox_GetObjectBox(*iObjectBox)->RemoveBoxDestructionListener(this);

        }

    if (iTransactionId)

        {

        NW_XHTML_ContentHandler_SetLoadObserver(iContentHandler, iTransactionId, NULL);

        }

    delete iContentType;

    delete iContentLength;

    }

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

// CXHTMLObjectElementHandler::NewL

// Two-phased constructor.

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

//

CXHTMLObjectElementHandler* CXHTMLObjectElementHandler::NewL(const NW_XHTML_ElementHandler_t* 

        aElementHandler, NW_XHTML_ContentHandler_t* aContentHandler, 

        NW_DOM_ElementNode_t* aElementNode)

    {

    CXHTMLObjectElementHandler* self = new(ELeave) CXHTMLObjectElementHandler(aElementHandler,

            aContentHandler, aElementNode);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// CPluginContentHandler::Destroyed

//

// Recieves notifications when the box has been destroyed. 

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

//

void CXHTMLObjectElementHandler::Destroyed()

    {

    // Forget about the destroyed box.

    iObjectBox = NULL;

    }

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

// CXHTMLObjectElementHandler::HeadCompleted

//

// Passes a HEAD response to the observer.

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

//

void CXHTMLObjectElementHandler::HeadCompleted(TUint16 aTransactionId, 

        const NW_Url_Resp_t& aResponse, const NW_HED_UrlRequest_t& /*aUrlRequest*/,

        void* /*aClientData*/)

    {

    NW_Ucs2*  temp = NULL;

    NW_TRY (status)

        {

        NW_XHTML_ContentHandler_SetLoadObserver(iContentHandler, aTransactionId, NULL);

        iTransactionId = 0;

        // Ensure iObjectBox isn't NULL.

        NW_THROW_ON_NULL(iObjectBox, status, KBrsrUnexpectedError);

        // Allow the server to override iContentType if it was never set from 

        // the type attribute or it was set but set to a type that isn't supported

        // (this give the server a chance to set the type if a valid type wasn't 

        // set in the tag).

        /*//R->embed

        if (!iContentType || !ObjectUtils::IsSupported(iContentType, 

                NULL, ObjectUtils::EHandlerAny))

            {

            NW_THROW_ON_NULL(aResponse.contentTypeString, status, KBrsrUnexpectedError);

            temp = StringUtils::CopyAsciiToUsc2(aResponse.contentTypeString);

            NW_THROW_OOM_ON_NULL(temp, status);

            delete iContentType;

            iContentType = NULL;

            iContentType = HBufC16::New(User::StringLength(temp));

            NW_THROW_OOM_ON_NULL(iContentType, status);

            iContentType->Des().Append(temp, User::StringLength(temp));

            delete temp;

            temp = NULL;

        	}

		*/

        // Extract and set the new content-length.

        TUint kiloLen = aResponse.contentLength / 1024;

        status = StringUtils::ConvertUintToUcs2(kiloLen > 0 ? kiloLen: 1, &temp);

        NW_THROW_ON_ERROR(status);

        delete iContentLength;

        iContentLength = NULL;

        iContentLength = HBufC16::New(User::StringLength(temp));

        NW_THROW_OOM_ON_NULL(iContentLength, status);

        iContentLength->Des().Append(temp, User::StringLength(temp));

        delete temp;

        temp = NULL;

        // Apply the new values as properties.

        ApplyInfoProperties(*iObjectBox);

        // This flag is set now that it has a valid content type and size.  The

        // flag is used later to skip any future validating head request that may

        // normally be done when the box tree is created.

        iObjectInfoValidated = ETrue;

        // Set the place holder text to "Unsupported" if the verified content-type 

        // isn't supported by a plugin or external-app.

        /*//R->embed

        if (!ObjectUtils::IsSupported(iContentType, NULL, ObjectUtils::EHandlerAny))

            {

            status = SetPlaceHolderText(*iObjectBox, R_XHTML_OBJECT_UNSUPPORTED);

            NW_THROW_ON_ERROR(status);

            }

        */    

        }

    NW_CATCH (status) 

        {

        delete temp;

        }

    NW_FINALLY 

        {

        } NW_END_TRY

    }

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

// CXHTMLObjectElementHandler::ChunkReceived

//

// Passes a chunk of a response to the observer.

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

//

void CXHTMLObjectElementHandler::ChunkReceived(TUint16 /*aTransactionId*/, TUint32 /*aChunkIndex*/,

        const NW_Url_Resp_t& /*aResponse*/, const NW_HED_UrlRequest_t& /*aUrlRequest*/, 

        void* /*aClientData*/)

    {

    }

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

// CXHTMLObjectElementHandler::LoadCompleted

//

// Called when a response completes successfully or in error.

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

//

void CXHTMLObjectElementHandler::LoadCompleted(TInt16 /*aStatusClass*/, TBrowserStatusCode aStatus, 

        TUint16 aTransactionId, const NW_HED_UrlRequest_t& /*aUrlRequest*/, 

        void* /*aClientData*/)

    {

    NW_XHTML_ContentHandler_SetLoadObserver(iContentHandler, aTransactionId, NULL);

    iTransactionId = 0;

    if (iObjectBox)

        {

        // Reset the place holder upon a successful load of a resouce for an external application.

        if ((aStatus == KBrsrSuccess) && (iLoadedHandlerType == ObjectUtils::EHandlerExternalApp))

            {

            CLMgrObjectBox* theBox = NULL;

            theBox = NW_LMgr_ObjectBox_GetObjectBox(*iObjectBox);

            if (!theBox || (theBox->IsShowingPlaceHolder()))

                {

                (void) SetPlaceHolderText(*iObjectBox, R_XHTML_OBJECT_SELECT_TO_DOWNLOAD);

                }

            }

        // Reset the place holder upon failure -- unless this was an image load, or plugin was already 

        else if (aStatus != KBrsrSuccess)

            {

            CLMgrObjectBox* theBox = NULL;

            theBox = NW_LMgr_ObjectBox_GetObjectBox(*iObjectBox);

            if (!theBox || (theBox->IsShowingPlaceHolder()))

                {

                (void) SetPlaceHolderText(*iObjectBox, R_XHTML_OBJECT_UNSUPPORTED);

                }

            }

        }

    iIsDownloading = EFalse;

    }

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

// CXHTMLObjectElementHandler::Initialize

//

// Initializes the ElementHandler.

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

//

TBrowserStatusCode CXHTMLObjectElementHandler::Initialize(void)

    {

    TDesC*  type = NULL;

    TDesC*  data = NULL;

    NW_TRY (status)

        {

        // If this element is the last element in the chunk and this isn't the

        // last chunk then initialize it later.  This only applies to objects not embeds,

        // since embed elements don't have children elements.

        NW_Uint16   element = NW_HED_DomHelper_GetElementToken(iElementNode);

        if ((element == NW_XHTML_ElementToken_object) &&

                (!NW_XHTML_ElementHandler_NextSiblingExists(iContentHandler, iElementNode, NW_TRUE)))

            {

            NW_THROW_SUCCESS (status);

            }

        if (iSelectedElementNode)

            {

            NW_THROW_SUCCESS (status);

            }

        // Determine which element node will be used.  See comment on SelectElement...

        status = SelectElement();

        NW_THROW_ON_ERROR(status);

        // Get the mime-type and url

        (void) GetTypeAttribute(&type);

        (void) GetSrcAttribute(&data);

		/*//R->embed

        if (type || data)

            {

            // Load it now if it is an image unless a plugin can also handle it.

            if (!ObjectUtils::IsSupported(type, data, ObjectUtils::EHandlerPlugin))

                {

                if (ObjectUtils::IsSupported(type, data, ObjectUtils::EHandlerImage))

                    {

                    (void) LoadObjectResource(type, data, ObjectUtils::EHandlerImage);

                    }

                }

            }

		*/

        // If it gets to here it has processed a valid object element.  skipToNode

        // is set so any embedded elements are skipped.

        iContentHandler->skipToNode = NW_DOM_Node_getNextSibling(iElementNode);

        }

    NW_CATCH (status) 

        {

        }

    NW_FINALLY 

        {

        delete type;

        delete data;

        return status;

        } NW_END_TRY

    }

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

// CXHTMLObjectElementHandler::CreateBoxTree

//

// Creates the box-tree associated with the tag.

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

//

TBrowserStatusCode CXHTMLObjectElementHandler::CreateBoxTree(NW_LMgr_ContainerBox_t& /*aParentBox*/)

    {

    NW_HED_DocumentRoot_t*     documentRoot = NULL;

    NW_HED_ContentHandler_t*   contentHandler = NULL;

    NW_LMgr_RootBox_t*         rootBox = NULL;

    NW_LMgr_EventHandler_t*    eventHandler = NULL;

    NW_LMgr_Box_t*             objectBox = NULL;

    NW_LMgr_Box_t*             tempBox = NULL;

    NW_LMgr_Box_t*             innerBox = NULL;

    NW_Image_AbstractImage_t*  image = NULL;

    TDesC*                     contentType = NULL;

    TDesC*                     data = NULL;

    TBool                      safeToDeleteObjectBox = ETrue;

    TBool                      isImage = EFalse;

    TBrowserStatusCode		   status = 0;

	/*

    NW_TRY (status) 

        {

        // If this element is the last element in the chunk and this isn't the

        // last chunk then initialize it later.  This only applies to objects not embeds,

        // since embed elements don't have children elements.

        NW_Uint16   element = NW_HED_DomHelper_GetElementToken(iElementNode);

        if ((element == NW_XHTML_ElementToken_object) &&

                (!NW_XHTML_ElementHandler_NextSiblingExists(iContentHandler, iElementNode, NW_FALSE)))

            {

            NW_THROW_SUCCESS (status);

            }

        // Get the associated content handler if any 

        contentHandler = AssociatedContentHandler();

        // Get the root box

        documentRoot = (NW_HED_DocumentRoot_t*) NW_HED_DocumentNode_GetRootNode(iContentHandler);

        rootBox = NW_HED_DocumentRoot_GetRootBox(documentRoot);

        // Get the content-type and url.

        if (iObjectInfoValidated)

            {

            contentType = iContentType->Alloc();

            NW_THROW_OOM_ON_NULL(contentType, status);

            }

        else

            {

            (void) GetTypeAttribute(&contentType);

            }

        (void) GetSrcAttribute(&data);            

        // If the content-type is a supported image type and a plugin can't handle it

        // then create a ImageBox to support the object.

        if (!ObjectUtils::IsSupported(contentType, data, ObjectUtils::EHandlerPlugin) &&

                ObjectUtils::IsSupported(contentType, data, ObjectUtils::EHandlerImage))

            {

            isImage = ETrue;

            // Get the image box from the ImageCH_Epoc32ContentHandler.

            if (contentHandler)

                {

                status = NW_HED_DocumentNode_GetBoxTree(contentHandler, &objectBox);

                NW_THROW_ON_ERROR(status);

                // Don't allow this box to be deleted because it is owned by 

                // a ImageCH_Epoc32ContentHandler.

                safeToDeleteObjectBox = EFalse;

                }

            // Otherwise create a place holder image that will be used by the

            // ImageCH_Epoc32ContentHandler to display the image once it loads.

            else

                {

                const NW_Image_AbstractImage_t* cannedImage;

                cannedImage = (NW_Image_AbstractImage_t*) NW_Image_CannedImages_GetImage(

                        rootBox->cannedImages, NW_Image_Missing);

                NW_THROW_ON_NULL((void*) cannedImage, status, KBrsrUnexpectedError);

                image = (NW_Image_AbstractImage_t*) NW_Image_Virtual_New(

                        const_cast<NW_Image_AbstractImage_t*>(cannedImage));

                NW_THROW_OOM_ON_NULL(image, status);

                objectBox = (NW_LMgr_Box_t*) NW_LMgr_AnimatedImageBox_New(0, 

                        image, NULL, NW_TRUE);

                NW_THROW_OOM_ON_NULL(objectBox, status);

                image = NULL;

                }

            }

        // Otherwise create a CLMgrObjectBox to support the object.

        else

            {

            if (!InHyperLink())

                {

                // Create an eventHandler to process events targeted at this box

                eventHandler = (NW_LMgr_EventHandler_t*) NW_HED_EventHandler_New(

                        NW_HED_DocumentNodeOf(iContentHandler), iElementNode);

                NW_THROW_OOM_ON_NULL(eventHandler, status);

                }

            status = CLMgrObjectBox::NewBox(eventHandler, &objectBox, &innerBox);

            NW_THROW_ON_ERROR(status);

            eventHandler = NULL;

            // Save the content-type.  This will be used later in ApplyInfoProperties

            // to set the content-type property.  This step is skipped if the content 

            // type has already been validated.

            if (contentType && !iObjectInfoValidated)

                {

                delete iContentType;

                iContentType = NULL;

                iContentType = HBufC::New(contentType->Length());

                NW_THROW_OOM_ON_NULL(iContentType, status);

                iContentType->Des().Append(*contentType);

                }

            // Set the object box

            iObjectBox = innerBox;

            // Add the element handler as box destruction listener.

            TRAPD(err, NW_LMgr_ObjectBox_GetObjectBox(*iObjectBox)->AddBoxDestructionListenerL(this));

            NW_THROW_ON_TRAP_ERROR(err, status);

            // If a content handler is already present just place the new CLMgrObjectBox 

            // (innerBox) in an active state by clearing the place holder.

            if (contentHandler)

                {

                if (NW_Object_IsInstanceOf(contentHandler, &NW_Plugin_ContentHandler_Class))

                    {

                    NW_Plugin_ContentHandler_t*  pluginContentHandler = NULL;

                    // Pass the object box to the plugin content handler.

                    pluginContentHandler = (NW_Plugin_ContentHandler_t*) contentHandler;

                    pluginContentHandler->iContentHandler->SetObjectBox(*innerBox);

                    // Removes the place holder which clears the box so the PluginInst

                    // can draw into it.

                    RemovePlaceHolder(*innerBox);

                    }

                }

            // Otherwise set the place holder and request the object's info.

            else

                {

                // If data or both content type and data are missing then this object 

                // is unsupported.

                if (!data || (!contentType && !data))

                    {

                    status = SetPlaceHolderText(*innerBox, R_XHTML_OBJECT_UNSUPPORTED);

                    NW_THROW_ON_ERROR(status);

                    }

                // Otherwise set the place holder text and fetch the object's info.

                else

                    {

                    // Set the place holder text to "Select to Download"

                    status = SetPlaceHolderText(*innerBox, R_XHTML_OBJECT_SELECT_TO_DOWNLOAD);

                    NW_THROW_ON_ERROR(status);

                    // Fetch the object's information if it hasn't already been validated.

                    // This occurs when a element handler is "resumed" from being previously 

                    // "suspended".

                    if (!iObjectInfoValidated)

                        {

                        // Errors are purposely ignored to allow the box-tree to be created even 

                        // if information about an object can't be fetched.

                        if (ObjectUtils::IsSupported(contentType, data, ObjectUtils::EHandlerPlugin) &&