/*

* 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:  Description : The class handles formatting of the boxes , refreshes the boxe on the postformatting,

*                adds the active boxes  to the tab list

*

*/

// INCLUDE FILES

#include "BoxFormatHandler.h"

#include "nwx_logger.h"

#include "nwx_settings.h"

#include "LMgrMarkerText.h"

#include "LMgrMarkerImage.h"

#include "LMgrAnonBlock.h"

#include "nw_lmgr_imagemapbox.h"

#include "nw_lmgr_posflowbox.h"

#include <f32file.h>

#include <flogger.h>

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

const TUint KRootBoxInitialHeight = 2;

// MACROS

// LOCAL CONSTANTS AND MACROS

//lint --e{752} local declarator not referenced

#ifdef _DEBUG_LOG

_LIT( KWmlBrowserLogDir, "browser" );

_LIT( KLogFileName, "boxFormat.txt" );

#endif

// MODULE DATA STRUCTURES

// FORWARD DECLARATIONS

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

//

// returns last formatted box

// @return - last formatted box of the box tree

//

NW_LMgr_Box_t* CLMgr_BoxFormatHandler::GetLastBox()

    {

    NW_ADT_Vector_Metric_t numChildren = 0;

    iLastBoxToFormat = iRootBox;

    do

        {

        const NW_ADT_Vector_t* children = NW_LMgr_ContainerBox_GetChildren ((NW_LMgr_ContainerBox_t*)iLastBoxToFormat);

        numChildren = NW_ADT_Vector_GetSize (children );

        if (numChildren == 0 )

            break;

        numChildren --;

        iLastBoxToFormat = *(NW_LMgr_Box_t**) NW_ADT_Vector_ElementAt (children, numChildren );

        }

    while (NW_Object_IsInstanceOf (iLastBoxToFormat ,

                                   &NW_LMgr_ContainerBox_Class));

    NW_ASSERT (iLastBoxToFormat);

    return iLastBoxToFormat;

    }

//

// The method clears all the items on the format stack and sets the current box to

// formatted to NULL

//

void CLMgr_BoxFormatHandler::ClearFormatStack()

    {

    while (!iFormatStack->IsEmpty())

        {

        CFormatStackContext* formatStackContext = iFormatStack->Pop();

        delete formatStackContext ;

        }

    }

void CLMgr_BoxFormatHandler::CFormatStackContext::CleanupStackContext(TAny* aFormatStackContext)

    {

    CFormatStackContext* formatStackContext = (CFormatStackContext*)aFormatStackContext;

    delete formatStackContext;

    }

// deletes the format context if the reference count is zero else if > 0 decrements the reference count

CLMgr_BoxFormatHandler::CFormatStackContext::~CFormatStackContext()

    {

    if (iParentContext->newFormatContext)

        {

        if (iParentContext->newFormatContext != iParentContext &&

	        iParentContext->newFormatContext->referenceCount == 0)

            {

#ifdef _DEBUG

            NW_LOG2(NW_LOG_LEVEL5, "Delete FormatContext :::::Pop box %x , context %x", iBox, iParentContext->newFormatContext);

#endif

            iParentContext->newFormatContext = NULL;

            }

        else

            {

            iParentContext->newFormatContext->referenceCount--;

            }

        }

    }

// default contstructor

CLMgr_BoxFormatHandler::CFormatStackContext::CFormatStackContext(CLMgr_BoxFormatHandler* aBoxFormatHandler) 

    {

    iBoxFormatHandler = aBoxFormatHandler;

    }

// copy constructor

CLMgr_BoxFormatHandler::CFormatStackContext::CFormatStackContext(const CFormatStackContext&

        aFormatStackContext)

    {

    iBox = aFormatStackContext.iBox;

    iParentFormatBox = aFormatStackContext.iParentFormatBox;

    iParentContext = aFormatStackContext.iParentContext;

    iBoxFormatHandler = aFormatStackContext.iBoxFormatHandler ;

    // iParentContext->newFormatContext can be NULL if the box is a container  box

    if(iParentContext->newFormatContext)

      {

      iParentContext->newFormatContext->referenceCount++;

      }

    }

//

// The method handles post formatting on a box

// @param aFormatStackContext- Formatting context instance to be post formatted

//

void CLMgr_BoxFormatHandler::PostFormatL(CFormatStackContext& aFormatStackContext)

    {

    TBrowserStatusCode status = KBrsrSuccess;

    TLMgr_BoxFormatter& formatter = GetBoxFormatter(aFormatStackContext.iBox);

    if ((NW_Object_IsInstanceOf (aFormatStackContext.iBox, &NW_LMgr_MarqueeBox_Class) ||

         NW_Object_IsInstanceOf (aFormatStackContext.iBox, &NW_LMgr_BidiFlowBox_Class)) &&

      NW_LMgr_ContainerBox_GetChildCount(NW_LMgr_ContainerBoxOf(aFormatStackContext.iBox )) > 0)

        {

        status = formatter.NW_LMgr_BidiFlowBox_PostFormat(aFormatStackContext.iParentContext->formatBox, NW_LMgr_ContainerBoxOf(aFormatStackContext.iBox ), aFormatStackContext.iParentContext->newFormatContext);

        }

    if (status == KBrsrSuccess)

        {

        status = NW_LMgr_Box_PostResize(aFormatStackContext.iBox);

        if (status == KBrsrSuccess)

            {

            status = formatter.NW_LMgr_FlowBox_PostFormatBox(aFormatStackContext.iParentFormatBox, aFormatStackContext.iBox , aFormatStackContext.iParentContext );

            }

        }

    // interested in OOM , other errors are ignored

    if (status == KBrsrOutOfMemory)

        {

        User::Leave(KErrNoMemory);

        }

    // update display

    NW_LMgr_RootBox_t* rootBox = NW_LMgr_Box_GetRootBox( iRootBox );

    if( NW_LMgr_RootBox_GetSmallScreenOn( NW_LMgr_RootBoxOf( rootBox ) ) )

      {

      NW_LMgr_Property_t prop;

      if (NW_LMgr_Box_GetProperty(aFormatStackContext.iBox, NW_CSS_Prop_gridModeApplied,

          &prop) == KBrsrNotFound)

        {

        // update and refresh display

        UpdateDisplayBounds( aFormatStackContext.iBox );

        RefreshBoxL( aFormatStackContext.iBox );

        // Add it to the tab list

        AddTabItemL( aFormatStackContext.iBox );

        }

      }

    else

      {

      NW_GDI_Rectangle_t bounds = NW_LMgr_Box_GetFormatBounds( aFormatStackContext.iBox );

      // if the box is in a cell, then the x any y coordinates do not get updated until

      // the cellbox has not been resized so

      // do not update until we get the real coordinates

      if( bounds.point.x != 0 && bounds.point.y != 0)

        {

        UpdateDisplayBounds( aFormatStackContext.iBox );

        RefreshBoxL( aFormatStackContext.iBox );

        }      

      }

    }

void CLMgr_BoxFormatHandler::UpdateDisplayBounds( NW_LMgr_Box_t* aBox )

  {

  NW_GDI_Rectangle_t bounds;

  NW_LMgr_RootBox_t* rootBox = NW_LMgr_Box_GetRootBox( iRootBox );

  NW_Bool smallscreeOn = NW_LMgr_RootBox_GetSmallScreenOn( rootBox );

  if( !iBackgroundFormat )

    {

    if( NW_Object_IsInstanceOf( aBox, &NW_LMgr_ContainerBox_Class ) == NW_TRUE )

      {

      NW_LMgr_ContainerBox_t* container = NW_LMgr_ContainerBoxOf( aBox );

      NW_ADT_Vector_Metric_t numChildren = NW_LMgr_ContainerBox_GetChildCount( container );

      for( NW_ADT_Vector_Metric_t index = 0; index < numChildren; index++ )

        {

        NW_LMgr_Box_t* child = NW_LMgr_ContainerBox_GetChild( container, index );

        if( NW_Object_IsInstanceOf( child, &NW_LMgr_ContainerBox_Class ) == NW_TRUE )

          {

            // If you have the following markup: <a><div>Text</div></a>, The parentFlow is the div 

            // box - that gets formatted, but not the container for <a>. We need to add extra code to 

            // Resize the container. According to CSS, an inline container cannot have a block level

            // box and InitializeTree normalizes the tree. So, we wouldn't be in this situation in normal mode.

            // But in small screen mode, initialize tree is not run - so we need to handle that.

          if( smallscreeOn )

              {

              // that means that the child is either Container or ActiveContainer

              if (!NW_Object_IsInstanceOf(child, &NW_LMgr_FormatBox_Class))

                  {

                  bounds = NW_LMgr_Box_GetFormatBounds( child );

                  if ((bounds.dimension.width == 0) || (bounds.dimension.height == 0))

                      {

                      (void)NW_LMgr_ContainerBox_ResizeToChildren(NW_LMgr_ContainerBoxOf(child));

                      }

                  }

              }

          UpdateDisplayBounds( child );

          // Add table cellbox to the table list while in normal screen mode or 

          // when the cellbox is in a grid mode table.

          NW_LMgr_Property_t prop;

          if( !smallscreeOn || (NW_LMgr_Box_GetProperty(child, NW_CSS_Prop_gridModeApplied,

              &prop) == KBrsrSuccess))

            {

			//if (!NW_Object_IsInstanceOf(child, &NW_LMgr_FormatBox_Class))

				if (NW_Object_IsInstanceOf(child, &NW_LMgr_ActiveContainerBox_Class))

				{

					NW_LMgr_Box_t* tmpParent = (NW_LMgr_Box_t*)NW_LMgr_Box_GetParent(child);

					NW_LMgr_Box_t* tmpGrandParent = (NW_LMgr_Box_t*)NW_LMgr_Box_GetParent(tmpParent);

					if (NW_Object_IsInstanceOf(tmpParent, &NW_LMgr_BidiFlowBox_Class) &&

						NW_Object_IsInstanceOf(tmpGrandParent, &NW_LMgr_RootBox_Class))

					{

						// we need to add active boxes contained within the ContainerBox.

						// Active boxes within the FormatBox were added when PostFormat

						// was called

						AddSubTreeTabItemsL(child);// and add it to the tab list

					}

				}

				else

				{

					// and add it to the tab list

					AddTabItemL( child );

				}

			}

          }

        else if (NW_Object_IsClass (child->parent, &NW_LMgr_MarqueeBox_Class) )

        {

          bounds = NW_LMgr_Box_GetFormatBounds( child );

          NW_LMgr_Box_SetFormatBounds( NW_LMgr_BoxOf( child->parent ), bounds );

        }

        else

          {

          bounds = NW_LMgr_Box_GetFormatBounds( child );

          NW_LMgr_Box_UpdateDisplayBounds( child, bounds );

          }

        }

      }

    bounds = NW_LMgr_Box_GetFormatBounds( aBox );

    NW_LMgr_Box_UpdateDisplayBounds( aBox, bounds );

    }

  }

//

// A two phase constructor that constructs  and initializes CLMgr_BoxFormatHandler class

// leaves KErrNoMemory if out of memory

// @param aRootBox - flowBox to be formatted

// @param aSelectiveFormatting is ETrue if only a flowBox  and its children needs to be formatted

// @return CLMgr_BoxFormatHandler* - pointer to the instance of  class CLMgr_BoxFormatHandler

//

CLMgr_BoxFormatHandler* CLMgr_BoxFormatHandler::NewL(NW_LMgr_Box_t* aRootBox, TBool aSelectiveFormatting)

    {

    CLMgr_BoxFormatHandler* self = new (ELeave)CLMgr_BoxFormatHandler;

    CleanupStack::PushL(self );

    self->ConstructL(aRootBox, aSelectiveFormatting);

    CleanupStack::Pop();

    return self;

    }

// default contructor

CLMgr_BoxFormatHandler::CLMgr_BoxFormatHandler(): CActive( EPriorityLow + 2 )

    {

    iFormattingPriority = ((CActive::TPriority)( CActive::EPriorityLow + 2 ));

    iBackgroundFormat = EFalse;  

	iFormattingCompleted = EFalse;

    }

// CLMgr_BoxFormatHandler initializer , creates iFormatStack and adds the instance

// to CActiveScheduler

void CLMgr_BoxFormatHandler::ConstructL(NW_LMgr_Box_t* aRootBox, TBool aSelectiveFormatting)

    {

    iFormatStack = new (ELeave)CStack<CFormatStackContext, ETrue>;

    iFormatContextRef = new (ELeave)CArrayPtrFlat<NW_LMgr_FormatContext_t>(2);

    iRootBox = aRootBox;

    iFormatBox = NULL;

    iSelectiveFormatting = aSelectiveFormatting;

    CActiveScheduler::Add(this);

    }

// initialize the flowbox and its children

TBrowserStatusCode CLMgr_BoxFormatHandler::InitializeBox(NW_LMgr_BidiFlowBox_t *flow)

    {

    return iTLMgr_BoxFormatter.NW_LMgr_BidiFlowBox_Initialize(flow);

    }

// initialize the flowbox and its children in small screen mode

TBrowserStatusCode CLMgr_BoxFormatHandler::InitializeBoxSSL(NW_LMgr_BidiFlowBox_t*)

    {

    return KBrsrSuccess;

    }

// destructor - deletes iFormatStack and removes the instance from CActiveScheduler

CLMgr_BoxFormatHandler::~CLMgr_BoxFormatHandler()

    {

    Cancel();

    if(iFormatContextRef)

        {

        for(TInt index = 0 ; index < iFormatContextRef->Count(); index++)

            {

            NW_Object_Delete(iFormatContextRef->At(index));

            }

        delete iFormatContextRef;

        }

    delete iFormatStack;

    }

void CLMgr_BoxFormatHandler::AppendFormatContextL(NW_LMgr_FormatContext_t* aLMgr_FormatContext_t)

    {

    TBool found = EFalse;

    for(TInt index = 0 ; index < iFormatContextRef->Count(); index++)

        {

        if(iFormatContextRef->At(index) == aLMgr_FormatContext_t)

            {

            found = ETrue;

            break;

            }

        }

    if(!found)

        {

        iFormatContextRef->AppendL(aLMgr_FormatContext_t);    

        }

    }

//

// Finds the format context of the next box of aFormatBox to be formatted

// If the aFormatBox is NULL , then a new FormatContext is created on rootbox and

// the child of the rootbox becomes the next box to be formattec

// Leaves with KErrNoMemory if OOM

//

void CLMgr_BoxFormatHandler::FindFormatContextL(NW_LMgr_Box_t* aFormatBox)

    {

    CFormatStackContext* formatStackContext = NULL;

    iFormatBox = NULL;

    // if the iLastBoxToFormat is NULL , then it is the first request, start formatting

    // from the rootBox

    if (aFormatBox == NULL)

        {

        // removing any existing items from the stack

        ClearFormatStack();

        // get the first child from the box tree

        iFormatBox = NW_LMgr_ContainerBox_GetChild(NW_LMgr_ContainerBoxOf(iRootBox), 0);

        // rootbox is the current flowbox for its child

        iCurrentFlowBox = iRootBox;

        iCurrentFormatContext = NW_LMgr_FormatContext_New();

        User::LeaveIfNull(iCurrentFormatContext );

        (void) NW_LMgr_FormatBox_ApplyFormatProps(NW_LMgr_FormatBoxOf (iCurrentFlowBox ), iCurrentFormatContext);

        // format the rootbox children to TRUE

        // set the formatBox and formatContext to format the rootbox grandchildren

        // the formatbox and formatcontext may be reset on formatting the first child of the

        // rootbox

        iCurrentFormatContext->formatBox = iCurrentFlowBox ;

        iCurrentFormatContext->newFormatContext = iCurrentFormatContext ;

        if( !iSelectiveFormatting )

            {

            (void) NW_LMgr_FormatBox_ApplyFormatProps(NW_LMgr_FormatBoxOf (iCurrentFlowBox ), iCurrentFormatContext);

            iCurrentFormatContext->newFormatContext = iCurrentFormatContext ;

            }

        else

            {

			//do a while loop to find the real parent, there must be a real parent

            NW_LMgr_Box_t* parBox =(NW_LMgr_Box_t*) NW_LMgr_Box_GetParent(iRootBox);

            while (!NW_Object_IsInstanceOf(parBox, &NW_LMgr_FormatBox_Class))

                {

					parBox = (NW_LMgr_Box_t*)NW_LMgr_Box_GetParent(parBox);

                }

            (void) NW_LMgr_FormatBox_ApplyFormatProps(NW_LMgr_FormatBoxOf (parBox ), iCurrentFormatContext);

            // for the formatting after image was opened

            // we need to create newContext to format containing boxes of iRootBox

            // the following block is similar to LMgrFormatBox.cpp Resize(...)

            NW_LMgr_FormatContext_t* newContext = NW_LMgr_FormatContext_New();

            (void) NW_LMgr_FormatBox_ApplyFormatProps(NW_LMgr_FormatBoxOf (iCurrentFlowBox ), newContext);

            iCurrentFormatContext->newFormatContext = newContext ;

            newContext->formatBox = iCurrentFlowBox ;

            newContext->referenceCount = 0;

            // push the parentContext on to the stack

            formatStackContext = new (ELeave)CFormatStackContext(this);

			formatStackContext->iParentFormatBox = parBox;

            formatStackContext->iBox = iRootBox;

            formatStackContext->iParentContext = iCurrentFormatContext;

            iFormatStack->PushL(formatStackContext);

            iCurrentFormatContext = newContext ;

            }

        }

    else

        {

        // find format context from the formatstack

        NW_LMgr_Box_t* box = aFormatBox;

#ifdef _DEBUG_LOG

        for (int index1 = iFormatStack->Count() - 1 ; index1 >= 0; index1--)

            {

            NW_LOG2(NW_LOG_LEVEL5, "Index: %d, box %x ", index1 , iFormatStack->At(index1)->iBox);

            }

#endif

#ifdef _DEBUG_LOG

        // integrity check on format stack

        NW_LMgr_Box_t* tempBox = aFormatBox;

        for (int index = iFormatStack->Count() - 1 ; index >= 0 && NW_LMgr_ContainerBox_IsLastChild(tempBox); index--)

            {

            NW_LOG2(NW_LOG_LEVEL5, "Index: %d, box %x ", index , iFormatStack->At(index)->iBox);

            formatStackContext = iFormatStack->At(index);

            // if the box is an instance of container box then popped item from the stack is the box itseld , the next to check

            // is from the top of the stack  else the next to be check would be the popped item from the stack

            if (tempBox == formatStackContext->iBox)

                {

                tempBox = iFormatStack->Head()->iBox;

                }

            else

                {

                tempBox = formatStackContext->iBox;

                }

            }

        // check the stack, the format stack is not correct

        if (index == -1 && !iContainerSplit )

            {

            NW_LMgr_Box_DumpBoxTree (NW_LMgr_BoxOf(iRootBox));

            }

#endif

        // if the last formatted box is on top of the stack , reformat the box

        // the case is true of the lastbox in the previous chunk was a container box

        if (aFormatBox == iFormatStack->Head()->iBox)

            {

            formatStackContext = iFormatStack->Pop();

            iFormatBox = formatStackContext->iBox;

            iCurrentFlowBox = formatStackContext->iParentFormatBox;

            formatStackContext->iParentContext->newFormatContext->referenceCount ++;

            iCurrentFormatContext = formatStackContext->iParentContext;

            delete formatStackContext;

            }

        // if the container box is split , the split container is on top of the stack

        // and all of its children have been formatted. Complete post formatting of the

        // container from top of the stack and next item on the stack is the containerbox that

        // is split , the children of the container that was split are not formatted ,

        // get the first child from the stack and format the box

        else if (iContainerSplit )

            {

            iContainerSplit = EFalse;

            do

                {

                NW_ASSERT(!iFormatStack->IsEmpty());

                formatStackContext = iFormatStack->Pop();

                CleanupStack::PushL(TCleanupItem(CFormatStackContext::CleanupStackContext,formatStackContext));

                PostFormatL(*formatStackContext);

                CleanupStack::PopAndDestroy(); //formatStackContext

                }

            while ((NW_LMgr_ContainerBox_GetChildCount(NW_LMgr_ContainerBoxOf(iFormatStack->Head()->iBox)) == 0));

            // set the correct context from the item on stack

            formatStackContext = iFormatStack->Head();

            if ((NW_Object_IsInstanceOf (formatStackContext->iBox, &NW_LMgr_BidiFlowBox_Class) ||

                 NW_Object_IsInstanceOf (formatStackContext->iBox, &NW_LMgr_MarqueeBox_Class))&&

                formatStackContext->iParentContext->newFormatContext)

                {

                iCurrentFlowBox = formatStackContext->iParentContext->formatBox;

                iCurrentFormatContext = formatStackContext->iParentContext->newFormatContext;

                }

            else

                {

                iCurrentFlowBox = formatStackContext->iParentFormatBox;

                iCurrentFormatContext = formatStackContext->iParentContext;

                }

            iFormatBox = NW_LMgr_ContainerBox_GetChild(NW_LMgr_ContainerBoxOf(formatStackContext->iBox), 0);

            }

        else

            {

            // first find the next box to be formatted

            // Pop from the stack until the boxes are the last child of its parent

            while (NW_LMgr_ContainerBox_IsLastChild(box) && !iFormatStack->IsEmpty())

                {

                // pop the item from the stack and complete the post formatting

                formatStackContext = iFormatStack->Pop();

#ifdef _DEBUG_LOG

                NW_LOG1(NW_LOG_LEVEL5, "Pop box %x ", formatStackContext->iBox);

#endif

                CleanupStack::PushL(TCleanupItem(CFormatStackContext::CleanupStackContext,formatStackContext));

                PostFormatL(*formatStackContext);

                // if the box is an instance of container box then popped item from the stack is the box itseld , the next to check