/*

* Copyright (c) 2004 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:  Box to handle Netscape plugins

*

*/

// INCLUDE FILES

#include <StringLoader.h> 

#include "nwx_settings.h"

#include "LMgrObjectBox.h"

#include "LMgrObjectBoxListener.h"

#include "LMgrObjectBoxOOC.h"

#include "nw_image_cannedimages.h"

#include "nw_lmgr_activecontainerbox.h"

#include "nw_lmgr_containerbox.h"

#include "LMgrBoxTreeListener.h"

#include "nw_lmgr_rootbox.h"

#include "nw_text_ucs2.h"

#include "nw_text_abstracti.h"

// ============================ LOCAL DEFINES ==================================

#define KDefaultObjectHeight 100

#define KDefaultObjectWidth 100

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

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

// CLMgrObjectBox::CLMgrObjectBox

//

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

// might leave.

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

//

CLMgrObjectBox::CLMgrObjectBox(NW_LMgr_Box_t* aBox) :

        iBox(aBox),

        iShowingPlaceHolder(ETrue),

        iCalculatePlaceHolderClip(ETrue),

        iDestructionListeners(2)

    {

    NW_ASSERT(aBox != NULL);

    }

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

// CLMgrObjectBox::ConstructL

//

// Symbian 2nd phase constructor can leave.

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

//

void CLMgrObjectBox::ConstructL(void)

    {

    }

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

// CLMgrObjectBox::~CLMgrObjectBox

//

// Deconstructor.

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

//

CLMgrObjectBox::~CLMgrObjectBox()

    {

    // Clean up the place holder

    delete iOrigPlaceHolderText;

    delete iPlaceHolderText;

    // Detach the CPluginInst

    DetachPluginInst();

    // Notify the owners that the box is being destroyed.

    for (TInt i = 0; i < iDestructionListeners.Count(); i++)

        {

        iDestructionListeners[i]->Destroyed();

        }

    iDestructionListeners.Reset();

    }

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

// CLMgrObjectBox::NewL

//

// Two-phased constructor.

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

//

CLMgrObjectBox* CLMgrObjectBox::NewL(NW_LMgr_Box_t* aBox)

    {

    CLMgrObjectBox* self = new(ELeave) CLMgrObjectBox(aBox);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// CLMgrObjectBox::NewActiveBox

//

// Creates a Object box-tree, an active container box with a single ObjectBox as a child.

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

//

TBrowserStatusCode CLMgrObjectBox::NewBox(NW_LMgr_EventHandler_t* aEventHandler, 

        NW_LMgr_Box_t** aPluginContainerBox, NW_LMgr_Box_t** aPluginBox)

    {

    NW_LMgr_Box_t*  containerBox = NULL;

    NW_LMgr_Box_t*  pluginBox = NULL;

    NW_ASSERT(aPluginContainerBox != NULL);

    NW_ASSERT(aPluginBox != NULL);

    TBool inHyperLink = EFalse;

    NW_TRY (status) 

        {

        if (aEventHandler)

            {

            // Create an ActiveContainer box to hold the boxtree, setting the

            // action type for object box.

            containerBox = (NW_LMgr_Box_t*) NW_LMgr_ActiveContainerBox_New(

                0, aEventHandler, NW_LMgr_ActionType_OpenObject);

            NW_THROW_OOM_ON_NULL(containerBox, status);

            aEventHandler = NULL;

            }

        else

            {

            inHyperLink = ETrue;

            containerBox = (NW_LMgr_Box_t*) NW_LMgr_ContainerBox_New(0);

            NW_THROW_OOM_ON_NULL(containerBox, status);

            }

        // Create the CLMgrObjectBox

        pluginBox = (NW_LMgr_Box_t*) NW_LMgr_ObjectBox_New(0);

        NW_THROW_OOM_ON_NULL(pluginBox, status);

        NW_LMgr_ObjectBox_GetObjectBox((NW_LMgr_ObjectBox_t&)(*pluginBox))->iInHyperLink = inHyperLink;

        // Add the pluginBox to the activeContainerBox

        status = NW_LMgr_ContainerBox_AddChild(NW_LMgr_ContainerBoxOf(containerBox), pluginBox);

        NW_THROW_ON_ERROR(status);

        *aPluginBox = pluginBox;

        pluginBox = NULL;

        }

    NW_CATCH (status) 

        {

        if (NW_Object_IsInstanceOf(containerBox, &NW_LMgr_ActiveContainerBox_Class))

            {

            // Orphan aEventHandler before deleting the active container box.

            ((NW_LMgr_ActiveContainerBox_t*) containerBox)->eventHandler = NULL;

            }

        NW_Object_Delete(containerBox);  

        NW_Object_Delete(pluginBox);

        containerBox = NULL;

        *aPluginBox = NULL;

        }

    NW_FINALLY 

        {

        *aPluginContainerBox = containerBox;

        return status;

        } NW_END_TRY

    }

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

// CLMgrObjectBox::Split

//

// Allows the box to be placed on the on a new line and grows

// the box to the width of "space" if the box doesn't have 

// a width property.

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

//

TBrowserStatusCode CLMgrObjectBox::Split(NW_GDI_Metric_t aSpace, 

        NW_LMgr_Box_t** aSplitBox, NW_Uint8 aFlags)

    {

    TBrowserStatusCode status;

    NW_LMgr_PropertyValue_t sizeVal;

    NW_ASSERT(aSplitBox != NULL);

    *aSplitBox = NULL;

    // If box does not fit in the space and the box is not on the new line the 

    // box needs to be pushed on the new line.

    if ((iBox->iFormatBounds.dimension.width > aSpace) && !(aFlags & NW_LMgr_Box_SplitFlags_AtNewLine))

        {

        return KBrsrLmgrNoSplit;

        }

    // If width was specified we do not want to change it.

    status = NW_LMgr_Box_GetPropertyValue(iBox, NW_CSS_Prop_width, NW_CSS_ValueType_Px, &sizeVal);

    if (status == KBrsrSuccess)

        {

        return KBrsrSuccess;

        }

    // Get the box's padding and margin

    NW_LMgr_FrameInfo_t  info;

    TInt                 padding = 0;

    TInt                 border = 0;

    TInt                 margin = 0;

    // NW_LMgr_Box_GetPadding(iBox, &info);

    //padding = info.right;

    // Use the parent's border because it has the border not the object box.

    NW_ASSERT(NW_Object_IsInstanceOf (iBox->parent, &NW_LMgr_ActiveContainerBox_Class) ||

        NW_Object_IsInstanceOf (iBox->parent, &NW_LMgr_ContainerBox_Class));

    NW_LMgr_Box_GetBorderWidth((NW_LMgr_Box_t*) iBox->parent, &info, ELMgrFrameRight );

    border = info.right;

    NW_LMgr_Box_GetMargins(iBox, &info, NULL, ELMgrFrameRight );

    if (info.right != NW_LMgr_FrameInfo_Auto)

        {

        margin = info.right;

        }

    // Set the box's width to the available space minus the border and padding.

    aSpace -= (border + padding + margin);

    iBox->iFormatBounds.dimension.width = aSpace;

    return KBrsrSuccess;

    }

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

// CLMgrObjectBox::GetMinimumContentSizeL

//

// Calculates the minimum size needed for the box.

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

//

void CLMgrObjectBox::GetMinimumContentSize(NW_GDI_Dimension2D_t& aSize)

    {

    NW_LMgr_PropertyValue_t sizeVal;

    // Set the default size

    aSize.height = KDefaultObjectHeight;

    aSize.width = KDefaultObjectWidth;

    // Adjust the default size if the width or height props are present.

    if (NW_LMgr_Box_GetPropertyValue(iBox, NW_CSS_Prop_width, 

            NW_CSS_ValueType_Px, &sizeVal) == KBrsrSuccess)

        {

        aSize.width = (NW_GDI_Metric_t) sizeVal.integer;

        }

    if (NW_LMgr_Box_GetPropertyValue(iBox, NW_CSS_Prop_height, 

                NW_CSS_ValueType_Px, &sizeVal) == KBrsrSuccess)

        {

        aSize.height = (NW_GDI_Metric_t) sizeVal.integer;

        }

    // If the browser is in small screen mode scale aSize to fit on the screen

    NW_LMgr_RootBox_t* rootBox = NW_LMgr_Box_GetRootBox( iBox );

    if( NW_LMgr_RootBox_GetSmallScreenOn( rootBox ) )

        {

        NW_GDI_Dimension2D_t aOrigSize = aSize;

        // Scale aSize to the screen.

        HandleVerticalLayout(aOrigSize, aSize);

        }

    }

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

// CLMgrObjectBox::Draw

//

// Draws the border, background and place holder (while the place

// holder is shown).

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

//

TBrowserStatusCode CLMgrObjectBox::Draw(const CGDIDeviceContext& aDeviceContext,

        NW_Bool aHasFocus)

    {

    CGDIDeviceContext*      deviceContext = NULL;

    NW_GDI_Dimension3D_t    imageSize;

    NW_GDI_Rectangle_t      innerRect;

    NW_GDI_Point2D_t        pos;

    NW_GDI_FlowDirection_t  dir = NW_GDI_FlowDirection_LeftRight;

    CGDIFont*               font = NULL;

    NW_GDI_Color_t          oldForgroundColor = 0;

    NW_GDI_Color_t          color;

    NW_LMgr_PropertyValue_t value;

    NW_TRY (status)

        {

        // For convenience.

        deviceContext = CONST_CAST(CGDIDeviceContext*, &aDeviceContext);

        // Get the initial colors -- must be done before any throw statement...

        oldForgroundColor = deviceContext->ForegroundColor();        

        // Invoke our superclass

        status = NW_LMgr_MediaBox_Class.NW_LMgr_Box.draw(iBox, 

                deviceContext, aHasFocus);

        NW_THROW_ON_ERROR(status);

        // If the place holder isn't being shown then its done.

        if (!iShowingPlaceHolder)

            {

            if (iBoxListener)

                {

                if (iPluginAttached)

                    {

                    iBoxListener->RefreshPlugin();

                    }

                }

            NW_THROW_SUCCESS(status);

            }

        // If necessary get the image place holder.

        if (!iPlaceHolderImage)

            {

            NW_LMgr_RootBox_t*  rootBox = NULL;

            rootBox = NW_LMgr_Box_GetRootBox(iBox);

            NW_THROW_ON_NULL(rootBox, status, KBrsrUnexpectedError);

            if (!iInHyperLink)

                {

                iPlaceHolderImage = NW_Image_CannedImages_GetImage(

                        rootBox->cannedImages, NW_Image_Object);

                }

            else

                {

                // If the <object> is in a hyperlink, treat it as if it was an image

                iPlaceHolderImage = NW_Image_CannedImages_GetImage(

                        rootBox->cannedImages, NW_Image_Broken);

                }

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

            }

        // Get the rect it is allowed to draw in

        NW_LMgr_Box_GetInnerRectangle(iBox, &innerRect);

        // Get the image size.

        status = NW_Image_AbstractImage_GetSize(iPlaceHolderImage, &imageSize);

        NW_THROW_ON_ERROR(status);

        if (innerRect.dimension.width < imageSize.width)

            {

            imageSize.width = innerRect.dimension.width;

            }

        if (innerRect.dimension.height < imageSize.height)

            {

            imageSize.height = innerRect.dimension.height;

            }

        // If necessary recalculate the clipped place holder text.

        if (iOrigPlaceHolderText && iCalculatePlaceHolderClip)

            {

            // Discard the old text

            delete iPlaceHolderText;

            iPlaceHolderText = NULL;

            iPlaceHolderText = ClipText(*iOrigPlaceHolderText, *deviceContext,

                    innerRect.dimension.width - imageSize.width, ETrue);

            iCalculatePlaceHolderClip = EFalse;

            }

        // Draw Image place holder.

        pos.x = innerRect.point.x;

        pos.y = innerRect.point.y;

        status = NW_Image_AbstractImage_DrawScaled(

                CONST_CAST(NW_Image_AbstractImage_t *, iPlaceHolderImage), 

                deviceContext, &pos, &imageSize);

        NW_THROW_ON_ERROR(status);

        // Draw the text only if the <object> is not in hyperlink

        if (!iInHyperLink)

            {

            font = NW_LMgr_Box_GetFont(iBox);

            NW_THROW_ON_NULL(font, status, KBrsrUnexpectedError);

            // Set the foreground color

            status = NW_LMgr_Box_GetPropertyValue(iBox, NW_CSS_Prop_color,

                    NW_CSS_ValueType_Color, &value);

            if (status == KBrsrSuccess)

                {

                color = value.integer;

                deviceContext->SwitchAgainstBG(&color);

                deviceContext->SetForegroundColor(color);

                }

            // Draw the text place holder.

            if (iPlaceHolderText)

                {

                NW_Text_UCS2_t nwText;

                NW_GDI_Rectangle_t oldClip = {{0, 0}, {0, 0}};

                status = NW_Text_UCS2_Initialize(&nwText, (void*) iPlaceHolderText->Ptr(), 

                        iPlaceHolderText->Length(), 0);

                NW_THROW_ON_ERROR (status);

                pos.x = innerRect.point.x + imageSize.width;

                pos.y = innerRect.point.y;

                /* Save the old clip rect */

                oldClip = aDeviceContext.ClipRect();

                /* Clip to the inner rect so the text doesn't spill outside of the rect */

                const_cast<CGDIDeviceContext &>(aDeviceContext).SetClipRect(&innerRect);

                status = deviceContext->DrawText(&pos, (NW_Text_t*)(&nwText), font, 0, 

                        (NW_GDI_TextDecoration_e) 0, dir, 

                        innerRect.dimension.width - imageSize.width);

                /* Restore the clip BEFORE checking the status */

                const_cast<CGDIDeviceContext &>(aDeviceContext).SetClipRect(&oldClip);

                NW_THROW_ON_ERROR (status);

                }

            }

        }

    NW_CATCH (status) 

        {

        } 

    NW_FINALLY 

        {

        deviceContext->SetForegroundColor(oldForgroundColor);

        return status;

        } 

    NW_END_TRY

    }

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

// CLMgrObjectBox::Render

//

// If necessary it positions the CPluginInst to match the box's 

// bounds and renders the box.

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

//

TBrowserStatusCode CLMgrObjectBox::Render(const CGDIDeviceContext& aDeviceContext,

        const NW_LMgr_RootBox_t& aRootBox, const NW_GDI_Rectangle_t& aClipRect, 

        const NW_LMgr_Box_t* aCurrentBox, NW_Uint8 aFlags, NW_Bool& aHasFocus, 

        NW_Bool& aSkipChildren)

    {

    NW_TRY (status)

        {

        // Invoke our superclass

        status = NW_LMgr_MediaBox_Class.NW_LMgr_Box.render(iBox, 

                CONST_CAST(CGDIDeviceContext*, &aDeviceContext), 

                CONST_CAST(NW_GDI_Rectangle_t*, &aClipRect), CONST_CAST(NW_LMgr_Box_t*, 

                aCurrentBox), aFlags, &aHasFocus, &aSkipChildren, 

                CONST_CAST(NW_LMgr_RootBox_t*, &aRootBox));

        NW_THROW_ON_ERROR(status);

        // The PluginInst must be synchronized with the box's new scroll adjusted 

        // location -- the size of the PluginInst may also need to be adjusted.

        // This method is called even if the place holder is shown because it may

        // need to recalculate the clip of the place holder text.

        SyncPluginInstBounds(aDeviceContext);

        }

    NW_CATCH (status) 

        {

        } 

    NW_FINALLY 

        {

        return status;

        } 

    NW_END_TRY

    }

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

// CLMgrObjectBox::SetBoxListener

//

// Sets the box's listener

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

//

void CLMgrObjectBox::SetBoxListener(MLMgrObjectBoxListener* aListener)

    {

    iBoxListener = aListener;

    }

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

// CLMgrObjectBox::AddBoxDestructionListenerL

//

// Adds a box's destruction listener

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

//

void CLMgrObjectBox::AddBoxDestructionListenerL(MLMgrBoxDestructionListener* aListener)

    {

    User::LeaveIfError(iDestructionListeners.Append(aListener));

    }

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

// CLMgrObjectBox::RemoveBoxDestructionListenerL

//

// Removes a box's destruction listener

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

//

void CLMgrObjectBox::RemoveBoxDestructionListener(MLMgrBoxDestructionListener* aListener)

    {

    TInt index;

    index = iDestructionListeners.Find(aListener);

    if (index != KErrNotFound)

        {

        iDestructionListeners.Remove(index);

        }

    }

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