/*

* 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_statictablecellboxi.h"

#include "nw_lmgr_statictablerowbox.h"

#include "nw_lmgr_formatcontext.h"

#include "nw_lmgr_cssproperties.h"

#include "nw_lmgr_boxvisitor.h"

#include "nw_lmgr_rootbox.h"

#include "GDIDeviceContext.h"

#include "nwx_math.h"

#include "nw_lmgr_eventhandler.h"

#include "nw_lmgr_activecontainerbox.h"

#include "BrsrStatusCodes.h"

#include "BoxRender.h"

#include "nwx_settings.h"

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

static

void

NW_LMgr_StaticTableCellBox_GetEdge(NW_LMgr_Box_t* box, 

                                   NW_LMgr_StaticTableBorderSide_t side,

                                   NW_LMgr_StaticTableBorderEdge_t* edge) 

{

  NW_LMgr_FrameInfo_t widthInfo; 

  NW_LMgr_FrameInfo_t styleInfo; 

  NW_LMgr_FrameInfo_t colorInfo; 

  NW_LMgr_Property_t  prop;

  TBrowserStatusCode  status;

  NW_LMgr_Box_GetBorderWidth(box, &widthInfo, ELMgrFrameAll );

  NW_LMgr_Box_GetBorderStyle(box, &styleInfo, ELMgrFrameAll );

  NW_LMgr_Box_GetBorderColor(box, &colorInfo);

  switch (side) {

  case left:

    edge->width = widthInfo.left;

    edge->style = styleInfo.left;

    edge->color = colorInfo.left;

    break;

  case right:

    edge->width = widthInfo.right;

    edge->style = styleInfo.right;

    edge->color = colorInfo.right;

    break;

  case top:

    edge->width = widthInfo.top;

    edge->style = styleInfo.top;

    edge->color = colorInfo.top;

    break;

  case bottom:

    edge->width = widthInfo.bottom;

    edge->style = styleInfo.bottom;

    edge->color = colorInfo.bottom;

    break;

  default:

    NW_ASSERT(0);

    break;

  }

  // While in SSM force borders on grid mode tables to 1.

  if (edge->width > 1) {

    status = NW_LMgr_Box_GetProperty(box, NW_CSS_Prop_gridModeApplied, &prop);

    if (status == KBrsrSuccess) {

      NW_LMgr_RootBox_t*  rootBox = NW_LMgr_Box_GetRootBox(box);

      NW_ASSERT (rootBox != NULL);

      if (NW_LMgr_RootBox_GetSmallScreenOn(rootBox)) {

        edge->width = 1;

      }

    }

  }

  return;

}

static

void

NW_LMgr_StaticTableCellBox_UpdateEdge(NW_LMgr_StaticTableBorderEdge_t* edge,

                                      NW_LMgr_StaticTableBorderEdge_t* newEdge) 

    {

    /* If the edge is hidden, no need to update it; simply return */

    if (edge->style == NW_CSS_PropValue_hidden) 

        {

        return;

        }

    /* If the new edge is hidden, store that and return */

    if (newEdge->style == NW_CSS_PropValue_hidden) 

        {

        edge->style = NW_CSS_PropValue_hidden;

        edge->width = 0;

        return;

        }

    /* Everyone can overwrite "style==none" */

    if (newEdge->style == NW_CSS_PropValue_none) 

        {

        return;

        }

    /* According to CSS, the border with the largest width wins.

     If all borders have the same width, then the border with

     the strongest style wins. Here we assume that

     NW_CSS_PropValue_double > ...solid > ...dashed > ...dotted > ...none > */

    if (newEdge->width > edge->width) 

        {

        *edge = *newEdge;

        }

    // comparison of width supercedes comparison of styel

    else if ( newEdge->width == edge->width &&

              newEdge->style > edge->style ) 

        {

        *edge = *newEdge;

        }

    return;

    }

void

NW_LMgr_StaticTableCellBox_GetPadding(NW_LMgr_StaticTableCellBox_t *thisObj,

                                      NW_LMgr_FrameInfo_t *paddingInfo)

{

  NW_LMgr_PropertyValue_t value;

  NW_LMgr_Box_t *thisCell = NW_LMgr_BoxOf(thisObj);

  NW_LMgr_Box_t *thisRow = NW_LMgr_BoxOf(thisCell->parent);

  NW_LMgr_StaticTableBox_t *thisSTB = NW_LMgr_StaticTableBoxOf(thisRow->parent);

  NW_LMgr_Box_t *thisTable = NW_LMgr_BoxOf(thisSTB);

  NW_LMgr_Property_t cellPadding;

  NW_GDI_Metric_t px;

  TBrowserStatusCode status;

  NW_GDI_Rectangle_t bounds;

  value.integer = 0;

  NW_LMgr_Box_GetPropertyValue(thisTable, NW_CSS_Prop_flags, NW_CSS_ValueType_Integer, &value);

  if (value.integer & NW_CSS_PropValue_flags_wmlTable) {

    if (paddingInfo != NULL) {

      paddingInfo->left = 1;

      paddingInfo->right = 1;

      paddingInfo->top = 1;

      paddingInfo->bottom = 1;

    }

  }

  else {

    cellPadding.value.integer = 0;

    cellPadding.type = NW_CSS_ValueType_Px;

    status = NW_LMgr_Box_GetRawProperty(thisTable, NW_CSS_Prop_cellPadding, &cellPadding);

    if (status == KBrsrSuccess) {

      if (cellPadding.type == NW_CSS_ValueType_Percentage) {

        bounds = NW_LMgr_Box_GetFormatBounds(thisCell);

        px = (NW_GDI_Metric_t)((cellPadding.value.decimal * bounds.dimension.width) / 100);

      }

      else {

        px = (NW_GDI_Metric_t)cellPadding.value.integer;

      }

      paddingInfo->left = paddingInfo->right = paddingInfo->top = paddingInfo->bottom = px;

    }

    else {

      NW_LMgr_Box_GetPadding(thisCell, paddingInfo, ELMgrFrameAll );

    }

  }

}

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

// NW_LMgr_StaticTableCellBox_UpdateEdgeFromBox() updates the side of an edge with data from a box.

//   The box is presumed to be more specific than the sources applied to the edge thus far.

//   If the box does not specify color data, then the color data in the edge is kept. 

static

void

NW_LMgr_StaticTableCellBox_UpdateEdgeFromBox(NW_LMgr_Box_t* box,  // Source for more specific edge data.

    NW_LMgr_StaticTableBorderSide_t side,  // The side to update.

    NW_LMgr_StaticTableBorderEdge_t* edge) // Cumulative edge data.

    {

    TBrowserStatusCode status;

    NW_LMgr_StaticTableBorderEdge_t tempEdge;

    NW_LMgr_Property_t prop;

    NW_LMgr_PropertyName_t cssPropName;

    NW_LMgr_StaticTableCellBox_GetEdge(box, side, &tempEdge);

    switch(side) {

        case top:

            cssPropName = NW_CSS_Prop_topBorderColor;

            break;

        case left:

            cssPropName = NW_CSS_Prop_leftBorderColor;

            break;

        case right:

            cssPropName = NW_CSS_Prop_rightBorderColor;

            break;

        case bottom:

            cssPropName = NW_CSS_Prop_bottomBorderColor;

            break;

        default:

            return;

        }

    // if the box doesn't specify color, keep value from less specific element.

    if (!edge->color)

        {

        status = NW_LMgr_Box_GetPropertyFromList(box, cssPropName, &prop);

        if (status != KBrsrNotFound) 

            {

            edge->color = prop.value.integer;

            }

        else

            {

            status = NW_LMgr_Box_GetPropertyFromList(box, NW_CSS_Prop_borderColor, &prop);

            if (status != KBrsrNotFound) 

                {

                edge->color = prop.value.integer;

                }

            else

                {

                edge->color = tempEdge.color;

                }

            }

        }

    NW_LMgr_StaticTableCellBox_UpdateEdge(edge, &tempEdge);

    }

/* Public function to get the cell borders */

TBrowserStatusCode

NW_LMgr_StaticTableCellBox_CalculateBorders(NW_LMgr_StaticTableCellBox_t *thisObj,

                                            NW_Uint16 currentCol, 

                                            NW_Uint16 currentRow, 

                                            NW_Uint16 colSpan, 

                                            NW_Uint16 rowSpan,

                                            NW_LMgr_StaticTableBorderEdge_t *leftEdge,

                                            NW_LMgr_StaticTableBorderEdge_t *rightEdge,

                                            NW_LMgr_StaticTableBorderEdge_t *topEdge,

                                            NW_LMgr_StaticTableBorderEdge_t *bottomEdge)

    {

    NW_LMgr_Box_t *thisCell = NW_LMgr_BoxOf(thisObj);

    NW_LMgr_Box_t *thisRow = NW_LMgr_BoxOf(thisCell->parent);

    NW_LMgr_StaticTableBox_t *thisSTB = NW_LMgr_StaticTableBoxOf(thisRow->parent);

    NW_LMgr_Box_t *thisTable = NW_LMgr_BoxOf(thisSTB);

    NW_LMgr_Box_t *tempBox = NULL;

    NW_LMgr_StaticTableContext_t *context = thisSTB->ctx;

    NW_LMgr_StaticTableBorderEdge_t tempEdge;

    NW_ADT_Vector_Metric_t numCols = NW_LMgr_StaticTableContext_GetNumCols(context);

    NW_ADT_Vector_Metric_t numRows = NW_LMgr_StaticTableContext_GetNumRows(context);

    NW_LMgr_PropertyValue_t value;

    NW_TRY(status) 

        {

        /* Optimization for WML tables */

        value.integer = 0;

        NW_LMgr_Box_GetPropertyValue(thisTable, NW_CSS_Prop_flags, NW_CSS_ValueType_Integer, &value);

        if (value.integer & NW_CSS_PropValue_flags_wmlTable) 

            {

            if (leftEdge) 

                {

                leftEdge->width = 1;

                leftEdge->style = NW_CSS_PropValue_solid;

                leftEdge->color = 0x000000;

                }

            if (rightEdge) 

                {

                rightEdge->width = 1;

                rightEdge->style = NW_CSS_PropValue_solid;

                rightEdge->color = 0x000000;

                }

            if (topEdge) 

                {

                topEdge->width = 1;

                topEdge->style = NW_CSS_PropValue_solid;

                topEdge->color = 0x000000;

                }

            if (bottomEdge) 

                {

                bottomEdge->width = 1;

                bottomEdge->style = NW_CSS_PropValue_solid;

                bottomEdge->color = 0x000000;

                }

            NW_THROW_SUCCESS(status);

            }

        /* Get left border */

        if (leftEdge) 

            {

            NW_Mem_memset(leftEdge, 0, sizeof(NW_LMgr_StaticTableBorderEdge_t));

            // Our cell wall has the highest priority.

            NW_LMgr_StaticTableCellBox_UpdateEdgeFromBox(thisCell, left, leftEdge);

            if (currentCol > 0) 

                {

                /* Update with the right edge of the neighbor on the left */

                status = NW_LMgr_StaticTableContext_GetCellPtrFromPxPy

                    (context, (NW_Uint16)(currentCol - 1), currentRow, &tempBox);

                NW_ASSERT(status != KBrsrNotFound);

                NW_THROW_ON_ERROR(status);

                NW_LMgr_StaticTableCellBox_UpdateEdgeFromBox(tempBox, right, leftEdge);

                }

            else

                {

                // Now look at our row

                NW_LMgr_StaticTableCellBox_UpdateEdgeFromBox(thisRow, left, leftEdge);

                /* Check the table border */

                NW_LMgr_StaticTableCellBox_GetEdge(thisTable, left, &tempEdge);

                NW_LMgr_StaticTableCellBox_UpdateEdge(leftEdge, &tempEdge);

                }

            }

        /* Get right border */

        if (rightEdge) 

            {

            NW_Mem_memset(rightEdge, 0, sizeof(NW_LMgr_StaticTableBorderEdge_t));

            // Our own cell walls have the highest priority.

            NW_LMgr_StaticTableCellBox_UpdateEdgeFromBox(thisCell, right, rightEdge);

            if (currentCol + colSpan < numCols) 

                {

                /* Update with the left edge of the neighbor on the right */

                status = NW_LMgr_StaticTableContext_GetCellPtrFromPxPy

                    (context, (NW_Uint16)(currentCol + colSpan), currentRow, &tempBox);

                NW_ASSERT(status != KBrsrNotFound);

                NW_THROW_ON_ERROR(status);

                NW_LMgr_StaticTableCellBox_UpdateEdgeFromBox(tempBox, left, rightEdge);

                }

            else

                {

                // Now look at our row

                NW_LMgr_StaticTableCellBox_UpdateEdgeFromBox(thisRow, right, rightEdge);

                //If we are the last cell in the row, look at the table border 

                NW_LMgr_StaticTableCellBox_GetEdge(thisTable, right, &tempEdge);

                NW_LMgr_StaticTableCellBox_UpdateEdge(rightEdge, &tempEdge);

                }

            }

        /* Get top border */

        if (topEdge) 

            {

            NW_Mem_memset(topEdge, 0, sizeof(NW_LMgr_StaticTableBorderEdge_t));

            /* Initialize to our own cell walls */

            NW_LMgr_StaticTableCellBox_UpdateEdgeFromBox(thisCell, top, topEdge);

            /* Now look at our row */

            NW_LMgr_StaticTableCellBox_UpdateEdgeFromBox(thisRow, top, topEdge);

            if (currentRow > 0)

                {       

                // Look at row immediately before us

                tempBox = NW_LMgr_StaticTableBox_GetRow(thisSTB, (NW_Uint16)(currentRow - 1));

                NW_THROW_OOM_ON_NULL (tempBox, status);                    

                NW_LMgr_StaticTableCellBox_UpdateEdgeFromBox(tempBox, bottom, topEdge);

                /* Look at the cell immediately above us */

                status = NW_LMgr_StaticTableContext_GetCellPtrFromPxPy

                    (context, currentCol, (NW_Uint16)(currentRow - 1), &tempBox);

                NW_ASSERT(status != KBrsrNotFound);

                NW_THROW_ON_ERROR(status);

                NW_LMgr_StaticTableCellBox_UpdateEdgeFromBox(tempBox, bottom, topEdge);

                }

            else

                {

                /* Default to  the table border */

                NW_LMgr_StaticTableCellBox_GetEdge(thisTable, top, &tempEdge);

                NW_LMgr_StaticTableCellBox_UpdateEdge(topEdge, &tempEdge);

                }

            }

        /* Get bottom border */

        if (bottomEdge) 

            {

            NW_Mem_memset(bottomEdge, 0, sizeof(NW_LMgr_StaticTableBorderEdge_t));

            /* Default to our own cell walls */

            NW_LMgr_StaticTableCellBox_UpdateEdgeFromBox(thisCell, bottom, bottomEdge);

            /* Next look at our row */

            NW_LMgr_StaticTableCellBox_UpdateEdgeFromBox(thisRow, bottom, bottomEdge);

            if (currentRow + rowSpan < numRows) 

                {

                /* Look at row immediately after us */

                tempBox = NW_LMgr_StaticTableBox_GetRow(thisSTB, (NW_Uint16)(currentRow + rowSpan));

                NW_THROW_OOM_ON_NULL (tempBox, status);

                NW_LMgr_StaticTableCellBox_UpdateEdgeFromBox(tempBox, top, bottomEdge);            

                /* And the cell immediately below us */

                status = NW_LMgr_StaticTableContext_GetCellPtrFromPxPy

                    (context, currentCol, (NW_Uint16)(currentRow + rowSpan), &tempBox);

                NW_ASSERT(status != KBrsrNotFound);

                NW_THROW_ON_ERROR(status);

                NW_LMgr_StaticTableCellBox_UpdateEdgeFromBox(tempBox, top, bottomEdge);

                }

            else

                {

                NW_LMgr_StaticTableCellBox_GetEdge(thisTable, bottom, &tempEdge);

                NW_LMgr_StaticTableCellBox_UpdateEdge(bottomEdge, &tempEdge);

                }

            }

        }

    NW_CATCH(status) 

        {

        }

    NW_FINALLY 

        {

        return status;

        }

    NW_END_TRY

    }

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

/* Public function to get the cell background */

void

NW_LMgr_StaticTableCellBox_GetBackground(NW_LMgr_StaticTableCellBox_t *thisObj,

                                         NW_LMgr_Property_t *backgroundProp)

{ 

  NW_LMgr_Box_t *thisCell = NW_LMgr_BoxOf(thisObj);

  NW_LMgr_Box_t *thisRow = NW_LMgr_BoxOf(thisCell->parent);

  NW_LMgr_Box_t *thisTable = NW_LMgr_BoxOf(thisRow->parent);

  NW_LMgr_Property_t prop;

  TBrowserStatusCode status;

  /* Find background color */

  if (backgroundProp != NULL) {

    /* First check the table background */

    prop.type = NW_CSS_ValueType_Token;

    prop.value.token = NW_CSS_PropValue_transparent;

    status = NW_LMgr_Box_GetProperty(thisTable, NW_CSS_Prop_backgroundColor, &prop);

    *backgroundProp = prop;

    /* Next the row background */

    prop.type = NW_CSS_ValueType_Token;

    prop.value.token = NW_CSS_PropValue_transparent;

    status = NW_LMgr_Box_GetProperty(thisRow, NW_CSS_Prop_backgroundColor, &prop);

    if (status == KBrsrSuccess && prop.type == NW_CSS_ValueType_Color) {

      *backgroundProp = prop;

    }

    /* Finally the cellbox */

    prop.type = NW_CSS_ValueType_Token;

    prop.value.token = NW_CSS_PropValue_transparent;

    status = NW_LMgr_Box_GetProperty(thisCell, NW_CSS_Prop_backgroundColor, &prop);

    if (status == KBrsrSuccess && prop.type == NW_CSS_ValueType_Color) {

      *backgroundProp = prop;

    }

  }

}

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

TBrowserStatusCode

NW_LMgr_StaticTableCellBox_GetMinimumCellSize(NW_LMgr_StaticTableCellBox_t *thisObj,

                                              NW_GDI_Dimension2D_t *minSize)

{

  NW_LMgr_FrameInfo_t borderWidth, paddingInfo;

  NW_LMgr_Box_t *cellBox = NW_LMgr_BoxOf(thisObj);

  NW_LMgr_Box_t *rowBox = NW_LMgr_BoxOf(cellBox->parent);

  NW_LMgr_StaticTableBox_t *tableBox = NW_LMgr_StaticTableBoxOf(rowBox->parent);

  NW_LMgr_StaticTableContext_t *context = tableBox->ctx;

  NW_GDI_Dimension2D_t minContentSize;

  NW_TRY (status) {

    /* Get the border information */

    status = NW_LMgr_StaticTableContext_GetCellBordersFromPtr

                (context, cellBox, &borderWidth, NULL, NULL); 

    NW_THROW_ON_ERROR(status);

    /* Get padding info */

  NW_LMgr_StaticTableCellBox_GetPadding(thisObj, &paddingInfo);

  /* Get the minimum content size */

  status = NW_LMgr_Box_GetMinimumContentSize(cellBox, &minContentSize);

    _NW_THROW_ON_ERROR (status);

  /* Calculate the minimum size for the box */

    minSize->width = (NW_GDI_Metric_t)

      (minContentSize.width +  borderWidth.left + borderWidth.right +

       paddingInfo.left + paddingInfo.right);

    minSize->height = (NW_GDI_Metric_t)

      (minContentSize.height + borderWidth.top + borderWidth.bottom +

       paddingInfo.top + paddingInfo.bottom);

  } NW_CATCH (status) {

  } NW_FINALLY {

  return status;

  } NW_END_TRY

}

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

TBrowserStatusCode