/*

* Copyright (c) 2000 - 2001 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_statictableboxi.h" 

#include "nw_lmgr_statictablerowbox.h"

#include "nw_lmgr_statictablecellbox.h"

#include "nw_lmgr_rootbox.h"

#include "nw_lmgr_cssproperties.h"

#include "nw_lmgr_textbox.h"

#include "nw_lmgr_rulebox.h"

#include "BrsrStatusCodes.h"

#define NW_LMGR_STATICTABLEBOX_MAX_CONSTRAINT (NW_GDI_Metric_t)20000

// min constraint should always be the minimum width of a box

//#define NW_LMGR_STATICTABLEBOX_MIN_CONSTRAINT (NW_GDI_Metric_t)NW_LMGR_BOX_MIN_WIDTH

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

 * Private Methods 

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

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

/* Collapse a cell and set position/size to 0 */

static

TBrowserStatusCode 

NW_LMgr_StaticTableBox_CollapseCell( NW_LMgr_StaticTableBox_t* thisObj, 

                                     NW_LMgr_StaticTableCellBox_t* cellBox )

  {

  NW_LMgr_BoxVisitor_t* visitor; 

  NW_REQUIRED_PARAM( thisObj );

  NW_TRY( status ) 

    {

    NW_LMgr_Box_t*      child;

    NW_GDI_Rectangle_t  zeroRect;

    NW_ASSERT( thisObj != NULL );

    NW_ASSERT( cellBox != NULL );

    // set zero rect for collapse

    zeroRect.point.x = 0;

    zeroRect.point.y = 0;

    zeroRect.dimension.width = 0;

    zeroRect.dimension.height = 0;

    // travell through and collapse all children.

    visitor = NW_LMgr_ContainerBox_GetBoxVisitor( cellBox );

    NW_THROW_OOM_ON_NULL( visitor, status );

    child = NW_LMgr_BoxVisitor_NextBox( visitor, 0 );

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

      {

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

        {

        status = NW_LMgr_ContainerBox_Collapse( NW_LMgr_ContainerBoxOf( child ) );

        }

      else if( NW_Object_IsDerivedFrom( child, &NW_LMgr_TextBox_Class) == NW_TRUE )

        {

        status = NW_LMgr_TextBox_Collapse( NW_LMgr_TextBoxOf( child ) );

        }

      // check if collapse is fine

      NW_THROW_ON_ERROR( status );

      // and then finalize the collapse by setting position/size to 0

      NW_LMgr_Box_SetFormatBounds( child, zeroRect );

      }

    // successful completion 

    status = KBrsrSuccess;

    // set cell to zero

    NW_LMgr_Box_SetFormatBounds( NW_LMgr_BoxOf( cellBox ), zeroRect );

    } 

  NW_CATCH( status ) 

    {

    } 

  NW_FINALLY 

    {

    NW_Object_Delete( visitor );

    return status;

    } 

  NW_END_TRY

  }

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

/* Collapse the table and set colums constraint to 0 */

static

TBrowserStatusCode 

NW_LMgr_StaticTableBox_CollapseTable( NW_LMgr_StaticTableBox_t* thisObj )

  {

  NW_TRY( status ) 

    {

    NW_ADT_Vector_Metric_t          colIndex;

    NW_ADT_Vector_Metric_t          rowIndex;

    NW_LMgr_StaticTableContext_t*   tableContext;

    NW_LMgr_Box_t*                  cellBox;    

    NW_ASSERT( thisObj != NULL );

    tableContext = thisObj->ctx;

    NW_THROW_OOM_ON_NULL( tableContext, status );

    // step through all the cells and collapse them

    for( colIndex = 0; colIndex < tableContext->numCols; colIndex++ )

      {

      for( rowIndex = 0; rowIndex < tableContext->numRows; rowIndex++ )

        {        

        status = NW_LMgr_StaticTableContext_GetCellPtrFromPxPy( tableContext, colIndex, rowIndex, &cellBox );

        NW_THROW_ON_ERROR( status );

        // cellbox can be NULL even if status == KBrsrSuccess

        if( cellBox != NULL )

          {

          // collpase cell

          status = NW_LMgr_StaticTableBox_CollapseCell( thisObj, NW_LMgr_StaticTableCellBoxOf( cellBox ) );

          NW_THROW_ON_ERROR( status );

          }

        }

      // table collapse requires to set column constraint to 0

      NW_LMgr_StaticTableContext_SetColConstraint( tableContext, colIndex, 0 );

      }

    // set table height info to 0

    thisObj->ctx->y = 0;

    thisObj->ctx->contentHeight = 0;

    // all the cells are collapsed

    status = KBrsrSuccess;

    }

  NW_CATCH( status ) 

    {

    } 

  NW_FINALLY 

    {

    return status;

    } 

  NW_END_TRY

  }

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

/* Set the current width of a container by getting its children size         */

/* please note that this function needs revise when arabic-hebrew comes to   */

/* the picture.                                                              */

static

TBrowserStatusCode

NW_LMgr_StaticTableBox_CalculateContainerWidth( NW_LMgr_ContainerBox_t* containerBox )

  {

  NW_TRY( status ) 

    {

    NW_GDI_Metric_t        boxWidth = NW_LMGR_BOX_MIN_WIDTH;

    NW_GDI_Metric_t        lineWidth = 0;

    NW_GDI_Metric_t        nextBoxX = 0;

    NW_LMgr_Box_t*         childBox;

    NW_GDI_Rectangle_t     boxBounds;

    NW_ADT_Vector_Metric_t childIndex;

    NW_ADT_Vector_Metric_t childCount;

    NW_LMgr_FrameInfo_t    frameInfo;

    NW_LMgr_FrameInfo_t    tempframeInfo;    

    NW_ASSERT( containerBox != NULL );

    childCount = NW_LMgr_ContainerBox_GetChildCount( containerBox );

    // travell through all boxes in this container and set the longest line as the box's width

    for( childIndex = 0; childIndex < childCount; childIndex++ ) 

      { 

      childBox = NW_LMgr_ContainerBox_GetChild( NW_LMgr_ContainerBoxOf( containerBox ), childIndex );

      NW_THROW_OOM_ON_NULL( childBox, status );

      // if this container includes an other container, then call that one first to find out the width.

      // However if the container is a table box (nested tables) then no need to call its children as 

      // at this point all nested tables are all set.

      if( NW_Object_IsDerivedFrom( childBox, &NW_LMgr_ContainerBox_Class ) == NW_TRUE &&

          NW_Object_IsClass( childBox, &NW_LMgr_StaticTableBox_Class ) == NW_FALSE )

        {

        status = NW_LMgr_StaticTableBox_CalculateContainerWidth( NW_LMgr_ContainerBoxOf( childBox ) );

        NW_THROW_ON_ERROR( status );

        }

      boxBounds = NW_LMgr_Box_GetFormatBounds( childBox );

      // fix rulebox and boxes far too small

      if( NW_Object_IsDerivedFrom( childBox, &NW_LMgr_RuleBox_Class ) == NW_TRUE || 

         boxBounds.dimension.width < NW_LMGR_BOX_MIN_WIDTH )

        {

        boxBounds.dimension.width = NW_LMGR_BOX_MIN_WIDTH;

        NW_LMgr_Box_SetFormatBounds( childBox, boxBounds );

        }

      // check if this box is inline with those previous boxes

      if( boxBounds.dimension.width > 0 )

        {

        // nextBoxX indicates where the next box is supposed to be if it was in same line

        // note that this is not right-to-left proof!

        if( boxBounds.point.x < nextBoxX )

          {

          // this box is in the next line

          lineWidth = 0;

          }

        // calculate where the next box should be if it was in line

        nextBoxX = boxBounds.point.x + boxBounds.dimension.width;

        // add up the line width

        lineWidth+= boxBounds.dimension.width;

        // get the widest line

        if( lineWidth > boxWidth )

          {

          boxWidth = lineWidth;

          }

        }

      }

    NW_GDI_Rectangle_t containerBoxBounds = NW_LMgr_Box_GetFormatBounds( NW_LMgr_BoxOf( containerBox ) );

    // set width 

    containerBoxBounds.dimension.width = boxWidth;

    // adjust width with borders and margins

    NW_LMgr_Box_GetBorderWidth( NW_LMgr_BoxOf( containerBox ), &frameInfo, ELMgrFrameLeft|ELMgrFrameRight );

    containerBoxBounds.dimension.width+=( frameInfo.left + frameInfo.right );

    NW_LMgr_Box_GetMargins( NW_LMgr_BoxOf( containerBox ), &frameInfo, &tempframeInfo, 

      ELMgrFrameLeft|ELMgrFrameRight );

    containerBoxBounds.dimension.width+=( frameInfo.left + frameInfo.right );

    NW_LMgr_Box_GetPadding( NW_LMgr_BoxOf( containerBox ), &frameInfo, ELMgrFrameLeft|ELMgrFrameRight );

    containerBoxBounds.dimension.width+=( frameInfo.left + frameInfo.right );

    NW_LMgr_Box_SetFormatBounds( NW_LMgr_BoxOf( containerBox ), containerBoxBounds );

    status = KBrsrSuccess;

    }

  NW_CATCH( status ) 

    {

    } 

  NW_FINALLY 

    {

    return status;

    } 

  NW_END_TRY

  }

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

/* Set the current width of a container by getting its children size         */

/* please note that this function needs revise when arabic-hebrew comes to   */

/* the picture.                                                              */

static

TBrowserStatusCode

NW_LMgr_StaticTableBox_CalculateContainerMinWidth( NW_LMgr_ContainerBox_t* containerBox, 

                                                   NW_GDI_Metric_t* containerWidth )

  {

  NW_TRY( status ) 

    {

    NW_GDI_Metric_t        minWidth = 0;

    NW_ADT_Vector_Metric_t childIndex;

    NW_ADT_Vector_Metric_t childCount;

    NW_LMgr_Box_t*         childBox;

    NW_GDI_Dimension2D_t   boxMinSize;

    NW_LMgr_FrameInfo_t    frameInfo;

    NW_LMgr_FrameInfo_t    tempframeInfo;    

    NW_ASSERT( containerBox != NULL );

    childCount = NW_LMgr_ContainerBox_GetChildCount( containerBox );

    *containerWidth = NW_LMGR_BOX_MIN_WIDTH;

    // travell through all boxes in this container and set the longest line as the box's width

    for( childIndex = 0; childIndex < childCount; childIndex++ ) 

      { 

      childBox = NW_LMgr_ContainerBox_GetChild( NW_LMgr_ContainerBoxOf( containerBox ), childIndex );    

      NW_THROW_OOM_ON_NULL( childBox, status );

      // if this container includes an other container, then call that one first to find out the width.

      // However if the container is a table box (nested tables) then no need to call its children as 

      // at this point all nested tables are all set.

      if( NW_Object_IsDerivedFrom( childBox, &NW_LMgr_ContainerBox_Class ) == NW_TRUE )

        {

        if( NW_Object_IsClass( childBox, &NW_LMgr_StaticTableBox_Class ) == NW_TRUE )

          {

          NW_LMgr_StaticTableBox_t* tableBox = NW_LMgr_StaticTableBoxOf( childBox );

          if( tableBox->ctx == NULL )

            {

            // context should always be initialized.

            status = KBrsrUnexpectedError;

            }

          else

            {

            minWidth = tableBox->ctx->tableMinWidth;          

            }

          }

        else

          {

          status = NW_LMgr_StaticTableBox_CalculateContainerMinWidth( NW_LMgr_ContainerBoxOf( childBox ), &minWidth );

          }

        NW_THROW_ON_ERROR( status );

        }

      else if( 

               NW_Object_IsDerivedFrom( childBox, &NW_LMgr_RuleBox_Class ) == NW_TRUE )

        {

        minWidth = NW_LMGR_BOX_MIN_WIDTH;

        }

      else

        {

        (void) NW_LMgr_Box_GetMinimumContentSize( childBox, &boxMinSize );

		if(boxMinSize.width == NW_LMGR_BOX_MIN_WIDTH && (NW_Object_IsInstanceOf (childBox, &NW_LMgr_AbstractTextBox_Class))){

			NW_LMgr_AbstractTextBox_GetMinimumSizeByWord(NW_LMgr_AbstractTextBoxOf(childBox), &boxMinSize );

		}

		minWidth = boxMinSize.width;

        }

      if( minWidth > *containerWidth )

        {

        *containerWidth = minWidth;

        }

      }

    // adjust minimum width with borders and margins

    NW_LMgr_Box_GetBorderWidth( NW_LMgr_BoxOf( containerBox ), &frameInfo, ELMgrFrameLeft|ELMgrFrameRight );

    *containerWidth+=( frameInfo.left + frameInfo.right );

    NW_LMgr_Box_GetMargins( NW_LMgr_BoxOf( containerBox ), &frameInfo, &tempframeInfo, 

      ELMgrFrameLeft|ELMgrFrameRight );

    *containerWidth+=( frameInfo.left + frameInfo.right );

    NW_LMgr_Box_GetPadding( NW_LMgr_BoxOf( containerBox ), &frameInfo, ELMgrFrameLeft|ELMgrFrameRight );

    *containerWidth+=( frameInfo.left + frameInfo.right );

    status = KBrsrSuccess;

    }

  NW_CATCH( status ) 

    {

    } 

  NW_FINALLY 

    {

    return status;

    } 

  NW_END_TRY

  }

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

/* Set the current width of a cell by getting its children size, plus it checks 

 * additional propeties such as cell padding and borders                        

 */

static

TBrowserStatusCode

NW_LMgr_StaticTableBox_CalculateCellWidth( NW_LMgr_StaticTableBox_t* thisObj, NW_LMgr_ContainerBox_t* cellBox, 

                                           NW_GDI_Metric_t* cellWidth, NW_Bool minSize )

  {

  NW_TRY( status ) 

    {

    NW_LMgr_FrameInfo_t            padding;

    NW_LMgr_FrameInfo_t            borderWidth; 

    NW_LMgr_Property_t             prop;

    NW_LMgr_StaticTableContext_t*  tableContext;

    NW_ASSERT( cellBox != NULL );

    NW_ASSERT( thisObj != NULL );

    tableContext = thisObj->ctx;

    NW_THROW_OOM_ON_NULL( tableContext, status );

    // get the cell's width

    if( minSize == NW_TRUE )

      {

      status = NW_LMgr_StaticTableBox_CalculateContainerMinWidth( cellBox, cellWidth );

      }

    else

      { 

      status = NW_LMgr_StaticTableBox_CalculateContainerWidth( cellBox );

      NW_GDI_Rectangle_t boxBounds = NW_LMgr_Box_GetFormatBounds( NW_LMgr_BoxOf( cellBox ) );

      *cellWidth = boxBounds.dimension.width; 

      }

    // check return value

    NW_THROW_ON_ERROR( status );

    // add padding

    NW_LMgr_StaticTableCellBox_GetPadding( NW_LMgr_StaticTableCellBoxOf( cellBox ), &padding );

    // and borders

    status = NW_LMgr_StaticTableContext_GetCellBordersFromPtr( tableContext, NW_LMgr_BoxOf( cellBox ), &borderWidth, NULL, NULL ); 

    NW_THROW_ON_ERROR(status);

    // what about cellSpacing?

    *cellWidth = *cellWidth + (NW_GDI_Metric_t)

    ( borderWidth.left + borderWidth.right + padding.left + padding.right );

        if( NW_LMgr_Box_GetProperty( NW_LMgr_BoxOf( cellBox ), NW_CSS_Prop_width, &prop ) == KBrsrSuccess )

      {

      NW_LMgr_Property_t  origProp;

      // do not take percentage type into account (as we do not know about the 100% size ) 

      // unless the table width is set

      // get the original property as NW_LMgr_Box_GetProperty calls resolve on the property

      status = NW_LMgr_Box_GetRawProperty( NW_LMgr_BoxOf( cellBox ), NW_CSS_Prop_width, &origProp );

      if( status != KBrsrSuccess )

        {

        // if getting raw property fails then we should use the 

        // result of the getPropery instead. 

        origProp.type = prop.type;

        }

      // adjust pixel cell width

      if( origProp.type != NW_CSS_ValueType_Percentage )

        {

        if( (NW_GDI_Metric_t)prop.value.integer > *cellWidth )

          {

          *cellWidth = (NW_GDI_Metric_t)prop.value.integer;

          }

        }

      // adjust percentage cell width

      else 

        {

        NW_LMgr_Property_t  tableProp;

        // get the table width to resolve the cell's percentage value

        if( NW_LMgr_Box_GetRawProperty( NW_LMgr_BoxOf( thisObj ), NW_CSS_Prop_width, &tableProp ) == KBrsrSuccess )

          {

          // works only if we've got the pixel value

          if( tableProp.type == NW_CSS_ValueType_Px )

            {            

            // calculate new cellWidth

            NW_GDI_Metric_t newCellWidth = (NW_GDI_Metric_t) ( 

              (NW_Float32)tableProp.value.integer / 100 * (NW_Float32)origProp.value.decimal );

            if( newCellWidth > *cellWidth )

              {

              *cellWidth = newCellWidth;

              }

            }

          }

        }

      }

    // for some formatting reason, container width cannot be less than NW_LMGR_BOX_MIN_WIDTH

    if( *cellWidth < NW_LMGR_BOX_MIN_WIDTH )

      {

      *cellWidth = NW_LMGR_BOX_MIN_WIDTH;

      }

    }

  NW_CATCH( status ) 

    {

    } 

  NW_FINALLY 

    {

    return status;

    } 

  NW_END_TRY

  }

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

/* Set the current size of a table by getting all cells' size                  */

static

TBrowserStatusCode

NW_LMgr_StaticTableBox_CalculateTableMinMaxWidth( NW_LMgr_StaticTableBox_t* thisObj )

  {

  NW_TRY( status )

    {

    NW_LMgr_StaticTableContext_t*   tableContext;

    NW_ADT_Vector_Metric_t          rowIndex;

    NW_ADT_Vector_Metric_t          colIndex;

    NW_LMgr_Box_t*                  rowBox;

    NW_LMgr_Box_t*                  cellBox;

    NW_GDI_Metric_t                 tableMaxWidth = 0;

    NW_GDI_Metric_t                 tableMinWidth = 0;

    NW_GDI_Metric_t                 maxMaxColWidth;

    NW_GDI_Metric_t                 maxMinColWidth;

    NW_Bool                         sameCell;

    NW_LMgr_Property_t              prop;

    NW_LMgr_PropertyValue_t         visibilityVal;

    NW_LMgr_FrameInfo_t             borderWidth;

    NW_ASSERT( thisObj != NULL );

    tableContext = thisObj->ctx;

    NW_THROW_OOM_ON_NULL( tableContext, status );

    for( colIndex = 0; colIndex < tableContext->numCols; colIndex++ ) 

      {

      maxMaxColWidth = 0;

      maxMinColWidth = 0;

      // get rows

      for( rowIndex = 0; rowIndex < tableContext->numRows; rowIndex++ ) 

        { 

        rowBox = NW_LMgr_ContainerBox_GetChild( NW_LMgr_ContainerBoxOf( thisObj ), rowIndex );

        NW_THROW_OOM_ON_NULL( rowBox, status );

        status = NW_LMgr_StaticTableContext_GetCellPtrFromPxPy( tableContext, colIndex, rowIndex, &cellBox );

        NW_THROW_ON_ERROR( status );

        // if the box is not cellbox skip it

        if(!NW_Object_IsInstanceOf (cellBox, &NW_LMgr_StaticTableCellBox_Class))

          continue;

        // check if this row is visible

        visibilityVal.token = NW_CSS_PropValue_visible;

        (void)NW_LMgr_Box_GetPropertyValue ( rowBox, NW_CSS_Prop_visibility, NW_CSS_ValueType_Token, &visibilityVal );

        if( visibilityVal.token == NW_CSS_PropValue_visible && cellBox != NULL )

          {

          // check colspan too. as we really dont wanna add colspan cells as many times as many colspans we do have here

          sameCell = NW_FALSE;

          prop.value.integer = 1;

          NW_LMgr_Box_GetPropertyFromList( cellBox, NW_CSS_Prop_colSpan, &prop );

          if( (NW_ADT_Vector_Metric_t)prop.value.integer > 1 )

            {

            NW_ADT_Vector_Metric_t    currentCol;

            NW_ADT_Vector_Metric_t    currentRow;

            status = NW_LMgr_StaticTableContext_PxPyToLxLy( tableContext, colIndex, rowIndex, &currentCol, &currentRow );

            NW_THROW_ON_ERROR( status );

            // cell position returns with the real position of the cell and that could be different to the row/col index when

            // colspan is present.

            // for examp: 

            // <tr><td colspan 2>row 1</td></tr>

            // <tr><td>row2 col1</td><td>row2 col2</td></tr>

            // for both columns in the first row, tableContext->cellBoxes[] returns with the very same cell box