/*

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

#include "nw_lmgr_rootbox.h"

#include "nw_lmgr_marqueebox.h"

#include "nw_lmgr_statictablerowbox.h"

#include "nw_lmgr_statictablecellbox.h"

#include "nw_lmgr_bidiflowbox.h"

#include "nw_lmgr_textbox.h"

#include "nw_lmgr_simplepropertylist.h"

#include "nw_text_ucs2.h"

#include "nwx_string.h"

#include "nwx_logger.h"

#include "nwx_math.h"

#include "nw_gdi_utils.h"

#include "nw_lmgr_activecontainerbox.h"

#include "nw_lmgr_imgcontainerbox.h"

#include "nw_lmgr_posflowbox.h"

#include "nw_lmgr_verticaltablebox.h"

#include "nw_lmgr_verticaltablerowbox.h"

#include "nw_lmgr_verticaltablecellbox.h"

#include "urlloader_urlloaderint.h"

#include "nwx_settings.h"

#include "nw_lmgr_imgcontainerbox.h"

#include "LMgrMarkerImage.h"

#include "LMgrMarkerText.h"

#include "BrsrStatusCodes.h"

#include "LMgrAnonBlock.h"

#include "nw_css_tokentoint.h"

#include "bitdev.h"

#include "LMgrObjectBoxOOC.h"

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

   private final methods

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

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

 * Function:     NW_LMgr_Box_ResolveAbsoluteLength

 * Description:  Resolves a relative length (Cm, Mm, In, Pt, Pc).

 * Returns:      KBrsrSuccess.

 */

static

TBrowserStatusCode

NW_LMgr_Box_ResolveAbsoluteLength(NW_LMgr_Box_t* box, 

                                  NW_LMgr_PropertyName_t propertyName,

                                  NW_LMgr_Property_t *property)

    {

    NW_Float32 val = property->value.decimal;

    NW_REQUIRED_PARAM(box);

    NW_REQUIRED_PARAM(propertyName);

    switch(property->type & NW_CSS_ValueType_Mask)

        {

        case NW_CSS_ValueType_Pc:

            // A pica is equivalent to 12 points

            val = val * 12;

            break;

        case NW_CSS_ValueType_Cm:

            // A centimeter is 28.34 points

            val = val * (NW_Float32)28.34;

            break;

        case NW_CSS_ValueType_Mm:

            // A millimeter is 2.83 points

            val = val * (NW_Float32)2.83;

            break;

        case NW_CSS_ValueType_In:

            // A inch is 72 points

            val = val * 72;

            break;

        case NW_CSS_ValueType_Pt:

        default:

            break;

        }

    property->type = NW_CSS_ValueType_Pt;

    property->value.decimal = val;

    return KBrsrSuccess;

    }

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

 * Function:     NW_LMgr_Box_ResolveRelativeLength

 * Description:  Resolves a relative length (Em, Ex).

 * Returns:      KBrsrSuccess.

 */

static

TBrowserStatusCode

NW_LMgr_Box_ResolveRelativeLength(NW_LMgr_Box_t* box, 

                                  NW_LMgr_PropertyName_t propertyName,

                                  NW_LMgr_Property_t *property)

    {

    NW_LMgr_Box_t *baseBox;

    NW_Int32 val;

    (void) propertyName;

    // Fontsize uses the parent's em

    if (propertyName == NW_CSS_Prop_fontSize) 

        {

        baseBox = (NW_LMgr_Box_t*)NW_LMgr_Box_GetParent(box);

        // This assert is only going to be triggered in the case when

        // there are percentage properties applied to the RootBox.

        // That is an error condition because the RootBox should have

        // no properties.

        NW_ASSERT(baseBox != NULL);

        }

    else 

        {

        baseBox = box;

        }

    // set the absolute font-size

    if (property->type == NW_CSS_ValueType_Em) 

        {

        val = (NW_Int32)(property->value.decimal * NW_LMgr_Box_GetEm(baseBox));

        }

    else 

        {

        val = (NW_Int32)(property->value.decimal * NW_LMgr_Box_GetEx(baseBox));

        }

    if (propertyName == NW_CSS_Prop_fontSize) 

        {

        // we can't use pixels here because in NW_LMgr_Box_ApplyFontProps(),

        // pixel will be adjusted to bigger value 

        CEikonEnv* eikEnv = CEikonEnv::Static();

        CWsScreenDevice& screenDev = *eikEnv->ScreenDevice();

        NW_Float32 valPt = FontUtils::PointsFromTwips(screenDev.VerticalPixelsToTwips(val));

        property->type = NW_CSS_ValueType_Pt;

        property->value.decimal = valPt;

        }

    else

        {

        property->type = NW_CSS_ValueType_Px;

        property->value.integer = val;

        }

    return KBrsrSuccess;

    }

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

 * Function:     NW_LMgr_Box_ResolvePercent

 * Description:  Resolves a relative property (percentage).

 * Returns:      KBrsrSuccess.

 */

static

TBrowserStatusCode

NW_LMgr_Box_ResolvePercent(NW_LMgr_Box_t* box, 

                           NW_LMgr_PropertyName_t propertyName,

						   NW_LMgr_Property_t *property)

    {

    NW_LMgr_Box_t* parentBox;

    NW_GDI_Rectangle_t bounds;

    NW_Float32 val = 0;

    NW_Int32 px = 0;

    NW_LMgr_Property_t parentProp;

    NW_GDI_Dimension2D_t size;

    NW_GDI_Dimension3D_t imgSize;

    TBrowserStatusCode status = KBrsrSuccess;

    NW_Image_AbstractImage_t *image = NULL;

    NW_Int32 fontSizeI = 0;

    NW_Float32 fontSizeD = 0.0;

    NW_LMgr_PropertyValue_t backgroundPropValue;

    val = property->value.decimal;

    switch(propertyName)

        {

        // This property calculate its percentage with respect to the

        // value of the same property of their parent box 

        case NW_CSS_Prop_fontSize:

            {

            // First we need to see if the box is a body box, if so, we need

            // to find what the default CSS font size is.

            NW_LMgr_RootBox_t* rootBox = NW_LMgr_Box_GetRootBox( box );

            // check for body box

            if( NW_LMgr_RootBox_GetBody( rootBox ) == box)

            {

                // TODO query the CSS table for the default font size

                // We know it is 6.5 points

                fontSizeD = (NW_Float32)(val * 6) / 100;

                property->type = NW_CSS_ValueType_Pt;

                property->value.decimal = fontSizeD;

                (void) NW_LMgr_Box_SetProperty (box, NW_CSS_Prop_fontSize, property);

            }

            else

            {

                // calculate the percentage of the parent box's  font size

                parentBox = (NW_LMgr_Box_t*)NW_LMgr_Box_GetParent(box);

                NW_LMgr_Box_GetProperty(NW_LMgr_BoxOf (parentBox), 

                    NW_CSS_Prop_fontSize, &parentProp);

                switch(parentProp.type)

                    {

                    case NW_CSS_ValueType_Em:

                    case NW_CSS_ValueType_Ex:

                    case NW_CSS_ValueType_In:

                    case NW_CSS_ValueType_Cm:

                    case NW_CSS_ValueType_Mm:

                    case NW_CSS_ValueType_Pt:

                    case NW_CSS_ValueType_Pc:

                        fontSizeD = (val * parentProp.value.decimal) / 100;

                        property->type = parentProp.type;

                        property->value.decimal = fontSizeD;

                        (void) NW_LMgr_Box_SetProperty (box, NW_CSS_Prop_fontSize, property);

                        break;

                    case NW_CSS_ValueType_Px: 

                    default:

                        fontSizeI = (NW_Int32) ((val * parentProp.value.integer) / 100);

                        property->type = parentProp.type;

                        property->value.integer = fontSizeI;

                        (void) NW_LMgr_Box_SetProperty (box, NW_CSS_Prop_fontSize, property);

                        break;

                    }

                }

            return status;

            }

        /* These properties calculate their percentage with repect to the

           value of the same property of the surrounding flow */

	    case NW_CSS_Prop_backgroundPosition_x:

	    case NW_CSS_Prop_backgroundPosition_y:

		    {

			    parentBox = box;

			    bounds = NW_LMgr_Box_GetFormatBounds(parentBox);

			    /* check if background-image is defined */

			     backgroundPropValue.object = NULL;

			     NW_LMgr_FrameInfo_t borderWidthInfo;

			     NW_LMgr_Box_GetBorderWidth(parentBox, &borderWidthInfo, ELMgrFrameAll );

			    (void)NW_LMgr_Box_GetPropertyValue(box, NW_CSS_Prop_backgroundImage, NW_CSS_ValueType_Image, &backgroundPropValue);

			    if (backgroundPropValue.object == NULL )

			        {

				    return KBrsrSuccess;

			        }

			    /* check if image is opened */

			    image = (NW_Image_AbstractImage_t*)backgroundPropValue.object;

			    (void) NW_Image_AbstractImage_GetSize(image, &imgSize);

			    if (imgSize.width == 0 || imgSize.height == 0)

			        {

				    return KBrsrSuccess;

			        }

			    if(propertyName == NW_CSS_Prop_backgroundPosition_x)

			        {

				    px = (NW_Int32)(val * (bounds.dimension.width - imgSize.width- borderWidthInfo.right

				     - borderWidthInfo.left) / 100);

			        }

			    else //propertyName == NW_CSS_Prop_backgroundPosition_y)

			        {

				    px = (NW_Int32)(val * (bounds.dimension.height - imgSize.height

				     - borderWidthInfo.top - borderWidthInfo.bottom	) / 100);

			        }

			    break;

		        }

        case NW_CSS_Prop_width:

        case NW_CSS_Prop_height:

        case NW_CSS_Prop_padding:

        case NW_CSS_Prop_leftPadding:

        case NW_CSS_Prop_rightPadding:

        case NW_CSS_Prop_topPadding:

        case NW_CSS_Prop_bottomPadding:

        case NW_CSS_Prop_margin:

        case NW_CSS_Prop_leftMargin:

        case NW_CSS_Prop_rightMargin:

        case NW_CSS_Prop_topMargin:

        case NW_CSS_Prop_bottomMargin:

        case NW_CSS_Prop_border:

        case NW_CSS_Prop_leftBorderWidth:

        case NW_CSS_Prop_rightBorderWidth:

        case NW_CSS_Prop_topBorderWidth:

        case NW_CSS_Prop_bottomBorderWidth:

        case NW_CSS_Prop_textIndent:

        case NW_CSS_Prop_marqueeAmount:

            /* First find the enclosing flow */

            do 

                {  

                parentBox = (NW_LMgr_Box_t*)NW_LMgr_Box_GetParent(box);

                /* This assert is only going to be triggered in the case when

                * there are percentage properties applied to the RootBox.

                * That is an error condition because the RootBox should have

                * no properties.

                */

                NW_ASSERT(parentBox != NULL);

                /* Move one level up */

                box = parentBox;

                } while (!NW_Object_IsInstanceOf(parentBox, &NW_LMgr_FlowBox_Class));

            if ((propertyName == NW_CSS_Prop_height || propertyName == NW_CSS_Prop_width) && 

                NW_Object_IsInstanceOf(parentBox, &NW_LMgr_PosFlowBox_Class))

                {

                NW_LMgr_RootBox_t* rootBox = NW_LMgr_Box_GetRootBox(box);

                CGDIDeviceContext* deviceContext = NW_LMgr_RootBox_GetDeviceContext (rootBox);

                // The width of a positioned box depends on the containing block

                // If the positioned box is nested, the containing box is

                // the parent positioned box, otherwise it is the screen size

                NW_LMgr_PosFlowBox_t* posParent = (NW_LMgr_PosFlowBox_t*)parentBox;

                if (posParent->iContainingBlock == NULL)

                    {

                    bounds = (*deviceContext->DisplayBounds());

                    }

                else

                    {

                    bounds = NW_LMgr_Box_GetFormatBounds(posParent->iContainingBlock);

                    }

                if (propertyName == NW_CSS_Prop_width)

                    {	    

                    NW_LMgr_FrameInfo_t paddingInfo;

                    NW_LMgr_FrameInfo_t borderWidthInfo;

                    NW_LMgr_Box_GetPadding(parentBox, &paddingInfo, ELMgrFrameAll );

                    NW_LMgr_Box_GetBorderWidth(parentBox, &borderWidthInfo, ELMgrFrameAll );

                    NW_GDI_Metric_t containingWidth = (NW_GDI_Metric_t)

                        (bounds.dimension.width - 

                        paddingInfo.left - paddingInfo.right -

                        borderWidthInfo.left - borderWidthInfo.right);

                    px = (NW_Int32)((val * containingWidth) / 100);

                    }

                else // propertyName == NW_CSS_Prop_height

                    { 

                    px = (NW_Int32)((val * bounds.dimension.height) / 100);

                    }

                }

            else

                {

                if (propertyName != NW_CSS_Prop_height) 

                    {

                    bounds = NW_LMgr_Box_GetFormatBounds(parentBox); //  width 

                    // S60 bug fix <PHEN-64EEW3>

                    // If the box needs to have x% of parent box's width,

                    // deduct border, padding width from parent box's width first

                    // then calculate the x% of the remaining width

                    if (propertyName == NW_CSS_Prop_width) 

                        {

                        NW_LMgr_FrameInfo_t paddingInfo;

                        NW_LMgr_FrameInfo_t borderWidthInfo;

                        NW_LMgr_Box_GetPadding(parentBox, &paddingInfo, ELMgrFrameAll );

                        NW_LMgr_Box_GetBorderWidth(parentBox, &borderWidthInfo, ELMgrFrameAll );

                        NW_GDI_Metric_t containingWidth = (NW_GDI_Metric_t)

                            (bounds.dimension.width - 

                            paddingInfo.left - paddingInfo.right -

                            borderWidthInfo.left - borderWidthInfo.right);

                        px = (NW_Int32)((val * containingWidth) / 100);

                        }

                    else 

                        {

                        px = (NW_Int32)((val * bounds.dimension.width) / 100);

                        }

                    }

                else // propertyName == NW_CSS_Prop_height

                    { 

                    if (!NW_Object_IsClass(parentBox, &NW_LMgr_StaticTableCellBox_Class) &&

		                !NW_Object_IsClass(parentBox, &NW_LMgr_VerticalTableCellBox_Class)) 

                    {

                        NW_LMgr_RootBox_t* rootBox = NW_LMgr_Box_GetRootBox(box);

                        CGDIDeviceContext* deviceContext = NW_LMgr_RootBox_GetDeviceContext (rootBox);

                        bounds = (*deviceContext->DisplayBounds());

                        NW_LMgr_FrameInfo_t paddingInfo;

                        NW_LMgr_FrameInfo_t borderWidthInfo;

                        NW_LMgr_Box_GetPadding(parentBox, &paddingInfo, ELMgrFrameAll );

                        NW_LMgr_Box_GetBorderWidth(parentBox, &borderWidthInfo, ELMgrFrameAll );

                        NW_GDI_Metric_t containingHeight = (NW_GDI_Metric_t)

                            (bounds.dimension.height - 

                        paddingInfo.top - paddingInfo.bottom -

                        borderWidthInfo.top - borderWidthInfo.bottom);

                        px = (NW_Int32)((val * containingHeight) / 100);

                    }

                    else

                    {

                   status = NW_LMgr_Box_GetSizeProperties(parentBox, &size);

                    if (status != KBrsrSuccess) 

                        {

                        return status;

                        }

                    if (size.height != -1) 

                        {

                        px = (NW_Int32) ((val * size.height) / 100);

                        }

                    else 

                        {

                        return KBrsrNotFound;

                        } 

                    }

                    }

                }

            break;

        default:

          /* In all other cases return the percentage as is (this useful for v-align) */

          return KBrsrSuccess;

      }

      property->type = NW_CSS_ValueType_Px;

      property->value.integer = px;

      return status;

    }

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

 * Function:     NW_LMgr_Box_ResolveRelativeProperty

 * Description:  Resolves a relative property (percentage, em, ex,).

 * Returns:      KBrsrSuccess.

 */

static

TBrowserStatusCode

 NW_LMgr_Box_ResolveRelativeProperty(NW_LMgr_Box_t* box, 

                                    NW_LMgr_PropertyName_t propertyName,

                                    NW_LMgr_Property_t *property)  

{

  TBrowserStatusCode status = KBrsrSuccess;

  NW_ASSERT (box);

  NW_ASSERT (property);

  // Remove bit flag so it works for default/variable properties as well

  // as normal ones.

  switch (property->type & NW_CSS_ValueType_Mask)

  {

    case NW_CSS_ValueType_Percentage:

      status = NW_LMgr_Box_ResolvePercent (box, propertyName, property); 

      break;

    case NW_CSS_ValueType_Em:

    case NW_CSS_ValueType_Ex:

      status = NW_LMgr_Box_ResolveRelativeLength (box, propertyName, property);

      break;

    case NW_CSS_ValueType_In:

    case NW_CSS_ValueType_Cm:

    case NW_CSS_ValueType_Mm:

    case NW_CSS_ValueType_Pt:

    case NW_CSS_ValueType_Pc:

      status = NW_LMgr_Box_ResolveAbsoluteLength (box, propertyName, property);

      break;

    default:

      break;

  }

  return status;

}

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

 * Function:     NW_LMgr_Box_ConvertBorderStyle

 * Description:  Converts border style to GDIContext value

 * Returns:      Converted border style

 */

static

NW_GDI_Pattern_t

NW_LMgr_Box_ConvertBorderStyle(NW_LMgr_PropertyValueToken_t style)

{

  NW_GDI_Pattern_t gdiStyle;

  switch (style)

  {

    case NW_CSS_PropValue_solid:

      gdiStyle = NW_GDI_Pattern_Solid;

      break;

    case NW_CSS_PropValue_dashed:

      gdiStyle = NW_GDI_Pattern_Dashed;

      break;

    case NW_CSS_PropValue_dotted: