/*

* Copyright (c) 2000 - 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: 

*

*/

#include "nw_lmgr_containerboxi.h"

#include "nw_lmgr_box.h"

#include "nw_lmgr_flowbox.h"

#include "nw_lmgr_rootbox.h"

#include "nw_lmgr_splittextbox.h"

#include "nw_lmgr_statictablebox.h"

#include "nw_lmgr_statictablerowbox.h"

#include "nw_lmgr_statictablecellbox.h"

#include "nw_lmgr_activecontainerbox.h"

#include "nw_lmgr_cssproperties.h"

#include "nw_adt_resizablevector.h"

#include "nw_lmgr_eventhandler.h"

#include "GDIDeviceContext.h"

#include "nw_lmgr_slavepropertylist.h"

#include "nw_adt_vectoriterator.h"

#include "BrsrStatusCodes.h"

#include "BoxRender.h"

#include "nwx_logger.h"

#include "nwx_settings.h"

#include "ObjectUtils.h"

#include "nw_lmgr_posflowbox.h"

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

   private final methods

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

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

   static data

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

const

NW_LMgr_ContainerBox_Class_t  NW_LMgr_ContainerBox_Class = {

  { /* NW_Object_Core            */

    /* super                     */ &NW_LMgr_Box_Class,

    /* queryInterface            */ _NW_Object_Base_QueryInterface

  },

  { /* NW_Object_Base            */

    /* interfaceList             */ NULL

  },

  { /* NW_Object_Dynamic         */

    /* instanceSize              */ sizeof (NW_LMgr_ContainerBox_t),

    /* construct                 */ _NW_LMgr_ContainerBox_Construct,

    /* destruct                  */ _NW_LMgr_ContainerBox_Destruct

  },

  { /* NW_LMgr_Box               */

    /* split                     */ _NW_LMgr_Box_Split,

    /* resize                    */ _NW_LMgr_ContainerBox_Resize,

    /* postResize                */ _NW_LMgr_Box_PostResize,

    /* getMinimumContentSize     */ _NW_LMgr_Box_GetMinimumContentSize,

    /* hasFixedContentSize       */ _NW_LMgr_Box_HasFixedContentSize,

    /* constrain                 */ _NW_LMgr_Box_Constrain,

    /* draw                      */ _NW_LMgr_Box_Draw,

    /* render                    */ _NW_LMgr_ContainerBox_Render,

    /* getBaseline               */ _NW_LMgr_ContainerBox_GetBaseline,

    /* shift                     */ _NW_LMgr_ContainerBox_Shift,

    /* clone                     */ _NW_LMgr_ContainerBox_Clone

  },

  { /* NW_LMgr_ContainerBox      */

    /* unused                    */ NW_Object_Unused

  }

};

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

   virtual methods

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

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

 * Function:     NW_LMgr_ContainerBox_Construct

 * Description:  The constructor.

 * Returns:      KBrsrSuccess, KBrsrOutOfMemory.

 */

TBrowserStatusCode

_NW_LMgr_ContainerBox_Construct (NW_Object_Dynamic_t* dynamicObject,

                                 va_list* argp)

{

  NW_LMgr_ContainerBox_t* container;

  NW_TRY(status) {

    /* for convenience */

    container = NW_LMgr_ContainerBoxOf (dynamicObject);

    /* invoke our superclass constructor */

    status = _NW_LMgr_Box_Construct (dynamicObject, argp);

    _NW_THROW_ON_ERROR(status);

    /* initialize the member variables */

    container->children = (NW_ADT_DynamicVector_t*)

      NW_ADT_ResizableVector_New (sizeof (NW_LMgr_Box_t*), 0, 5 );

    NW_THROW_OOM_ON_NULL(container->children, status);

  }

  NW_CATCH(status) {

  }

  NW_FINALLY {

    return status;

  }

  NW_END_TRY

}

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

 * Function:     NW_LMgr_ContainerBox_Destruct

 * Description:  The destructor.

 * Returns:      void

 */

void

_NW_LMgr_ContainerBox_Destruct (NW_Object_Dynamic_t* dynamicObject)

{

  NW_LMgr_ContainerBox_t* container;

  NW_ADT_Vector_Metric_t numChildren;

  NW_Int32 index;

  /* for convenience */

  container = NW_LMgr_ContainerBoxOf (dynamicObject);

  if (container->children != NULL) {

    /* before deleting the object, we must delete any children

       contained by us */

    numChildren =

      NW_ADT_Vector_GetSize (container->children);

    for (index = numChildren - 1; index >= 0; index--) {

      NW_LMgr_Box_t* child;

      child = *(NW_LMgr_Box_t**)

        NW_ADT_Vector_ElementAt (container->children,

                                 (NW_ADT_Vector_Metric_t) index);

      NW_Object_Delete (child);

    }

    /* release our resources */

    NW_Object_Delete (container->children);

  } 

}

TBrowserStatusCode

_NW_LMgr_ContainerBox_Resize( NW_LMgr_Box_t* box, NW_LMgr_FormatContext_t* context )

{

  TBrowserStatusCode status;

  NW_LMgr_ContainerBox_t* container; 

  NW_REQUIRED_PARAM( context );

  NW_ASSERT( box != NULL );

  container = NW_LMgr_ContainerBoxOf( box );

  status = NW_LMgr_ContainerBox_ResizeToChildren( container );

  if (NW_Object_IsInstanceOf(NW_LMgr_BoxOf(NW_LMgr_Box_GetParent(box)),& NW_LMgr_PosFlowBox_Class))

      {

      NW_GDI_Dimension2D_t size;

      NW_LMgr_Box_GetSizeProperties(box, &size);

      if (size.width > box->iFormatBounds.dimension.width)

          {

          box->iFormatBounds.dimension.width = size.width;

          }

      if (size.height > box->iFormatBounds.dimension.height)

          {

          box->iFormatBounds.dimension.height = size.height;

          }

      }

  return status; 

}

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

 * Function:     NW_LMgr_ContainerBox_Shift

 * Description:  ContainerBox::Shift shifts the container and the subtree

 *               below it.

 * Returns:      KBrsrSuccess, KBrsrOutOfMemory.

 */

TBrowserStatusCode

_NW_LMgr_ContainerBox_Shift (NW_LMgr_Box_t* box, 

                             NW_GDI_Point2D_t *delta)

{

  NW_LMgr_BoxVisitor_t * visitor = NULL;

  NW_LMgr_Box_t *child;

  NW_TRY(status) {

    NW_ASSERT(box != NULL);

    visitor = NW_LMgr_ContainerBox_GetBoxVisitor(box);

    NW_THROW_OOM_ON_NULL(visitor, status);

    /* Invoke base-class shift on this box and all children */

    while ((child = NW_LMgr_BoxVisitor_NextBox(visitor, NULL)) != NULL) {

      status = NW_LMgr_Box_Class.NW_LMgr_Box.shift(child, delta);

      _NW_THROW_ON_ERROR(status);

    }

  }

  NW_CATCH(status) {

  }

  NW_FINALLY {

    NW_Object_Delete(visitor);

    return status;

  }

  NW_END_TRY

}

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

 * Function:     NW_LMgr_ContainerBox_Clone

 * Description:  Clones of containers only inherit the property list.  They

 *               also have their "Clone" flag set.  The children are not 

 *               copied into the new box.

 * Returns:      The new box, or NULL in case of an error.

 */

NW_LMgr_Box_t*

_NW_LMgr_ContainerBox_Clone (NW_LMgr_Box_t* box)

{

  NW_LMgr_Box_t *newBox = NULL;

  /* parameter assertion block */

  NW_ASSERT(NW_Object_IsInstanceOf (box, &NW_LMgr_ContainerBox_Class));

  /* Create the new box */

  newBox = (NW_LMgr_Box_t*) NW_LMgr_ContainerBox_New (0);

  if (newBox == NULL) {

    return NULL;

  }

  /* Copy the property list, if one exists */

  if (box->propList != NULL) {

    newBox->propList = NW_LMgr_PropertyList_Clone (box->propList);

  }

  else{

    /* instantiate a new SimplePropertyList object */

    newBox->propList = (NW_LMgr_PropertyList_t*)

              NW_LMgr_SlavePropertyList_New (NULL);

  }

  if (newBox->propList == NULL) {

    NW_Object_Delete (newBox);

    return NULL;

  }

  return newBox;

}

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

   public/protected final methods

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

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

TBrowserStatusCode

NW_LMgr_ContainerBox_Collapse (NW_LMgr_ContainerBox_t* thisObj)

{

  NW_LMgr_PropertyList_t* propertyList;

  NW_LMgr_Property_t prop;

  NW_LMgr_ContainerBox_t* siblingBox;

  NW_LMgr_Box_t* childBox;

  TBrowserStatusCode status = KBrsrSuccess;

  /* parameter assertion block */

  NW_ASSERT (NW_Object_IsInstanceOf (thisObj, &NW_LMgr_ContainerBox_Class));

  propertyList = NW_LMgr_Box_PropListGet(NW_LMgr_BoxOf(thisObj));

  if (propertyList == NULL){

    return KBrsrSuccess;

  }

  NW_ASSERT (NW_Object_IsInstanceOf (propertyList, &NW_LMgr_PropertyList_Class));

  /* the master box will take care of coolapsing the slave boxes */

  if (NW_Object_IsInstanceOf(propertyList, &NW_LMgr_SlavePropertyList_Class)){

    return KBrsrSuccess;

  }

  /* if the propertylist is not slave propertylist, it definitely is a simple

     property list, and this box is a master box - so start collapse

   */

  /* implement collapse */

  /* Get sibling box */

  prop.value.object = NULL;

  (void)NW_LMgr_PropertyList_Get(propertyList, NW_CSS_Prop_sibling, &prop);

  if (prop.value.object == NULL){

    return KBrsrSuccess;

  }

  while(prop.value.object)

  {

    NW_ADT_Vector_Metric_t childCount;

    siblingBox = NW_LMgr_ContainerBoxOf(prop.value.object);

    /* This condition should never happen unless sibling boxes are not created

    properly. Should it be an ASSERT instead?? */

    if (!NW_Object_IsInstanceOf(NW_LMgr_BoxOf(siblingBox)->propList, 

                               &NW_LMgr_SlavePropertyList_Class))

    {

      return KBrsrFailure;

    }

    /* Insert your sibling's children in master container box */

    /* PROBLEM: Make Container_GetChild recognize NW_ADT_Vector_AtEnd */

    childCount = NW_LMgr_ContainerBox_GetChildCount(siblingBox);

    while (childCount > 0)

    {

      childCount--;

      childBox = NW_LMgr_ContainerBox_GetChild(siblingBox, childCount);

      NW_ASSERT(childBox);

      /* Insert ChildAt will remove the child from the old parent 

         which is the sibling box

         */

      /* The following method should be more efficient - we get the child

         from the old box, and then again search for it to remove it. 

         RemoveChild should return a box, so that we can use that box to 

         attach it somewhere else */

      status = NW_LMgr_ContainerBox_InsertChildAt(thisObj, childBox, 0);

      if (status != KBrsrSuccess) {

        return status;

      }

    }

    /* Get next sibling box */

    propertyList = NW_LMgr_Box_PropListGet(NW_LMgr_BoxOf(siblingBox));

    NW_ASSERT (NW_Object_IsInstanceOf (propertyList, &NW_LMgr_PropertyList_Class));

    prop.value.object = NULL;

    (void)NW_LMgr_PropertyList_Get(propertyList, NW_CSS_Prop_sibling, &prop);

    /* delete the sibling box */

    NW_Object_Delete(siblingBox);

    /* If we come back in a loop to the master box, then stop */

    if (prop.value.object == thisObj)

      break;

  }

  /* We also want to remove the sibling property on the master box,

     since we are collapsing the split containers */

  (void)NW_LMgr_Box_RemoveProperty(NW_LMgr_BoxOf(thisObj), NW_CSS_Prop_sibling);

  return KBrsrSuccess;

}

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

 * Function:     NW_LMgr_ContainerBox_InsertChildAt     

 * Description:  Inserts a child at the given index.  If a child is already

 *               attached to a parent, it detaches it first.

 * Returns:      KBrsrSuccess if successful, KBrsrFailure if the index 

 *               is out of bounds, KBrsrOutOfMemory.

 */

TBrowserStatusCode

NW_LMgr_ContainerBox_InsertChildAt (NW_LMgr_ContainerBox_t* container,

                                    NW_LMgr_Box_t* child,

                                    NW_ADT_Vector_Metric_t where)

{

  NW_LMgr_ContainerBox_t* parent;

  NW_TRY(status) {

    NW_ASSERT(child != NULL);

    /* Remove the child from its existing parent, if necessary */

    parent = NW_LMgr_Box_GetParent (child);

    if (parent != NULL) {

      status = NW_LMgr_ContainerBox_RemoveChild (parent, child);

      _NW_THROW_ON_ERROR(status);

    }

    /* Insert the child into our 'children' vector */

    NW_THROW_OOM_ON_NULL(NW_ADT_DynamicVector_InsertAt(container->children,

                                                       &child, where),

                         status);

    /* Set the parent field of the Box - note that we do this as

       a 'friend' class */

    NW_LMgr_Box_SetParent (child, container);

  }

  NW_CATCH(status) {

  }

  NW_FINALLY {

    return status;

  }

  NW_END_TRY

}

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

 * Function:     NW_LMgr_ContainerBox_AddChild   

 * Description:  Adds a child to the end of the container.

 * Returns:      KBrsrSuccess, KBrsrOutOfMemory.

 */

TBrowserStatusCode

NW_LMgr_ContainerBox_AddChild (NW_LMgr_ContainerBox_t* container,

                               NW_LMgr_Box_t* child)

{

  return NW_LMgr_ContainerBox_InsertChildAt (container, child,

                                             NW_ADT_Vector_AtEnd);

}

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

 * Function:     NW_LMgr_ContainerBox_InsertChild

 * Description:  Inserts a child immediately before the box pointed to by

 *               "where".

 *               If "where" is not a child of the container, KBrsrFailure

 *               is returned.

 * Returns:      KBrsrSuccess, KBrsrFailure, KBrsrOutOfMemory.

 */

TBrowserStatusCode

NW_LMgr_ContainerBox_InsertChild (NW_LMgr_ContainerBox_t* container,

                                  NW_LMgr_Box_t* child,

                                  NW_LMgr_Box_t* where)

{

  NW_ADT_Vector_Metric_t index;

  index = NW_ADT_Vector_GetElementIndex (container->children,

                                         &where);

  if (index == NW_ADT_Vector_AtEnd) {

    return KBrsrFailure;

  }

  return NW_LMgr_ContainerBox_InsertChildAt (container, child, index);

}

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

 * Function:     NW_LMgr_ContainerBox_InsertChildAft

 * Description:  Inserts a child immediately following the box pointed to by 

 *               "where".  If "where" is not a child of the container, 

 *               KBrsrFailure is returned.

 * Returns:      KBrsrSuccess, KBrsrFailure, KBrsrOutOfMemory.

 */

TBrowserStatusCode

NW_LMgr_ContainerBox_InsertChildAft (NW_LMgr_ContainerBox_t* container,

                                     NW_LMgr_Box_t* child,

                                     NW_LMgr_Box_t* where)

{

  NW_ADT_Vector_Metric_t index;

  index = NW_ADT_Vector_GetElementIndex (container->children,

                                         &where);

  if (index == NW_ADT_Vector_AtEnd) {

    return KBrsrFailure; /* TODO: return a more descriptive error code */

  }

  if ((index + 1)

      < NW_ADT_Vector_GetSize(container->children)) {

    return NW_LMgr_ContainerBox_InsertChildAt (container, child, 

                                               ((NW_ADT_Vector_Metric_t)

                                                (index+1)));

  } else {

    return NW_LMgr_ContainerBox_AddChild (container, child);

  }

}

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

 * Function:     NW_LMgr_ContainerBox_AppendChildrenOf   

 * Description:  Appends the children of "source" to the container pointed

 *               to by "container".

 * Returns:      KBrsrSuccess, KBrsrOutOfMemory.

 */

TBrowserStatusCode

NW_LMgr_ContainerBox_AppendChildrenOf (NW_LMgr_ContainerBox_t* container,

                                       NW_LMgr_ContainerBox_t* source)

{

  NW_TRY(status) {

    while (NW_ADT_Vector_GetSize (source->children) != 0) {

      NW_LMgr_Box_t* child;

      child = *(NW_LMgr_Box_t**) NW_ADT_Vector_ElementAt (source->children, 0);

      NW_ASSERT(child != NULL);

      status = NW_LMgr_ContainerBox_AddChild (container, child);

      _NW_THROW_ON_ERROR(status);

    }

  }

  NW_CATCH(status) {

  }

  NW_FINALLY {

    return status;

  }

  NW_END_TRY

}

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

 * Function:     NW_LMgr_ContainerBox_ReplaceChild

 * Description:  Replaces "originalChild" with "newChild".

 * Returns:      KBrsrSuccess, KBrsrFailure if the original child

 *               is not inside "container", KBrsrOutOfMemory.

 */

TBrowserStatusCode

NW_LMgr_ContainerBox_ReplaceChild (NW_LMgr_ContainerBox_t* container,

                                   NW_LMgr_Box_t* originalChild,

                                   NW_LMgr_Box_t* newChild)

{

  NW_ADT_Vector_Metric_t index;

  NW_TRY(status) {

    index = NW_ADT_Vector_GetElementIndex(container->children,

                                          &originalChild);

    if (index == NW_ADT_Vector_AtEnd) {

      NW_THROW_STATUS(status, KBrsrFailure);

    }

    status = NW_LMgr_ContainerBox_InsertChildAt (container, newChild, index);

    _NW_THROW_ON_ERROR(status);

    status = NW_LMgr_ContainerBox_RemoveChild (container, originalChild);

    _NW_THROW_ON_ERROR(status);

  }

  NW_CATCH(status) {

  }

  NW_FINALLY {

    return status;