/*

* 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: 

*

*/

/* Includes */

#include "nwx_string.h"

#include "nwx_url_utils.h"

#include "nw_errnotify.h"

#include "nwx_url_utils.h"

#include "nwx_http_header.h"

#include "nw_wml_api.h"

#include "nw_wml_core.h"

#include "nwx_logger.h"

#include "nw_hed_documentroot.h"

#include "nw_wml1x_wml1xcontenthandler.h"

#include "nw_wml1x_wml1xeventhandler.h"

#include "nw_wml1x_wml1xdefaultstylesheet.h"

#include "nw_lmgr_bidiflowbox.h"

#include "nw_lmgr_cssproperties.h"

#include "nw_lmgr_textbox.h"

#include "nw_lmgr_breakbox.h"

#include "nw_lmgr_emptybox.h"

#include "nw_lmgr_statictablebox.h"

#include "nw_lmgr_statictablerowbox.h"

#include "nw_lmgr_statictablecellbox.h"

#include "nw_lmgr_activecontainerbox.h"

#include "nw_hed_hedeventhandler.h"

#include "nw_image_cannedimages.h"

#include "nw_image_virtualimage.h"

#include "nw_text_ascii.h"

#include "nw_text_ucs2.h"

#include "nw_adt_map.h"

#include "nw_adt_dynamicvector.h"

#include "nw_fbox_formliaison.h"

#include "nw_fbox_checkbox.h"

#include "nw_fbox_radiobox.h"

#include "nw_fbox_inputbox.h"

#include "nw_fbox_passwordbox.h"

#include "nw_wml1x_wml1xactiveevent.h"

#include "nwx_settings.h"

#include "nw_lmgr_accesskey.h"

#include "wml_elm_attr.h"

#include "nw_markup_wmlvalidator.h"

#include "nw_system_optionlist.h"

#include "HEDDocumentListener.h"

#include "nw_lmgr_rootbox.h"

#include "nw_lmgr_imgcontainerbox.h"

#include "nw_lmgr_animatedimagebox.h"

#include "nw_hed_historyvisitor.h"

#include "urlloader_urlloaderint.h"

#include "MVCView.h"

#include "nw_wml1x_wml1xapi.h"

#include "nwx_http_defs.h"

#include "BrsrStatusCodes.h"

#include "MVCShell.h"

#include "BrCtl.h"

/*

**-------------------------------------------------------------------------

**  Local Macros

**-------------------------------------------------------------------------

*/

#define NW_MSEC_PER_WML_TICK 100

/*

**-------------------------------------------------------------------------

**  Internal Prototypes

**-------------------------------------------------------------------------

*/

/* display functions called by the WML Browser */

static TBrowserStatusCode NW_UI_CreateCard(void *wae);

static TBrowserStatusCode NW_UI_ShowCard(void *wae);

static TBrowserStatusCode NW_UI_DestroyCard(void *wae);

static TBrowserStatusCode NW_UI_AddElement(void *wae, NW_Wml_ElType_e elemType,

                                    NW_Int16 *elemId);

static TBrowserStatusCode NW_UI_CleanUp(void *wae);

static TBrowserStatusCode NW_UI_SetOptState(void *wae, NW_Uint16 elemId, NW_Bool st);

static TBrowserStatusCode NW_UI_GetOptState(void *wae, NW_Uint16 elemId, NW_Bool* st);

static TBrowserStatusCode NW_UI_Refresh(void *wae);

static TBrowserStatusCode NW_Wml1x_CreateTimer(void *usrAgent, NW_Uint32 period);

static TBrowserStatusCode NW_Wml1x_ReadTimer(void *usrAgent, NW_Uint32 *period);

static TBrowserStatusCode NW_Wml1x_DestroyTimer(void *usrAgent);

static TBrowserStatusCode NW_Wml1x_ResumeTimer(void *usrAgent);

static TBrowserStatusCode NW_Wml1x_StopTimer(void *usrAgent);

static TBrowserStatusCode NW_Wml1x_IsTimerRunning(void *usrAgent, NW_Bool *isRunning);

/*

**-------------------------------------------------------------------------

**  File Scoped Static Variables

**-------------------------------------------------------------------------

*/

/* WML Core Routines. */

static const NW_DisplayApi_t panel_api =

{

  NW_UI_CreateCard,

  NW_UI_ShowCard,

  NW_UI_DestroyCard,

  NW_UI_AddElement,

  NW_UI_CleanUp,

  NW_UI_GetOptState,

  NW_UI_SetOptState,

  NW_UI_Refresh,

};

/*Timer API wrappers for WML 1.x content handler*/

static const NW_TimerApi_t Wml1x_timer_api =

{

  NW_Wml1x_CreateTimer,

  NW_Wml1x_ReadTimer,

  NW_Wml1x_DestroyTimer,

  NW_Wml1x_ResumeTimer,

  NW_Wml1x_StopTimer,

  NW_Wml1x_IsTimerRunning

};

static const NW_WmlApi_t wml_api =

{

  &panel_api,

  &Wml1x_timer_api

};

/* Additional constants */

static const NW_Ucs2 monospace[] = {'m', 'o', 'n', 'o', 's', 'p', 'a', 'c', 'e', '\0'};

static const NW_Ucs2 spaceString[] = {NW_TEXT_UCS2_NBSP,'\0'};

/*

**-------------------------------------------------------------------------

**  Internal Functions

**-------------------------------------------------------------------------

*/

/*****************************************************************

  Name:         NW_UI_SetParagraphProperties()

  Description:  set wrap and alignment paragraph properties

  Parameters:   

    thisObj - In      - the content handler on behalf of which the work is being done

    elId    - In      - the element id of the <p> element being processed, used in the WML query service

    box     - In      - pointer to the box tree node representing the <p> element

    nowrap  - In/Out  - pointer to boolean in which to maintain current nowrap property value

  Algorithm:    wrap property is 'sticky' from previous paragraphs

                alignment is left unless attribute set otherwise

  Return Value: KBrsrOutOfMemory

                KBrsrSuccess

*****************************************************************/

static

TBrowserStatusCode

NW_UI_SetParagraphProperties (NW_Wml1x_ContentHandler_t *thisObj,

                              NW_Uint16                 elId,

                              NW_LMgr_Box_t             *box,

                              NW_Bool                   *nowrap,

                              NW_LMgr_Box_t             **deleteBox)

{

  NW_LMgr_ContainerBox_t  *container = NW_LMgr_ContainerBoxOf(box);

  NW_ADT_DynamicVector_t  *children = NW_LMgr_ContainerBoxOf(box)->children;

  NW_Ucs2                 *retString = NULL;

  NW_LMgr_PropertyValue_t value;

  NW_LMgr_Property_t      prop;

  NW_TRY (status) {

    /* We must ignore empty P elements, see [WAP WML] */

    if (NW_ADT_Vector_GetSize(children) == 0) {

      *deleteBox = box;

      NW_THROW_SUCCESS(status);

    }

    else if (NW_ADT_Vector_GetSize(children) == 1) {

      NW_LMgr_Box_t *child = NW_LMgr_ContainerBox_GetChild(container, 0);

      if (NW_Object_IsClass(child, &NW_LMgr_TextBox_Class)) {

        /* if the box tree were complete here, we could query the text box to see if it is blank

        but since the text box has not yet been visited by the ShowCard() process, such a query

        will always return blank!  Instead, query the wmlInterpreter for the STR_VALUE of the element */

        status = NW_LMgr_Box_GetPropertyValue(child, NW_CSS_Prop_elementId, NW_CSS_ValueType_Integer, &value);

        if (status == KBrsrSuccess) {

          NW_Uint16 childElId = 0;

          childElId = NW_UINT16_CAST(value.integer);

          status = NW_Wml_GetAttribute(&(thisObj->wmlInterpreter),

                                       childElId,

                                       STR_VALUE,

                                       &retString);

          NW_THROW_ON (status, KBrsrOutOfMemory);

          if (retString == NULL) {

            /* must delete the child of box here, before the ShowCard() box visitor accesses it. */

            status = NW_LMgr_ContainerBox_RemoveChild(container,

                                                      child);

            NW_Object_Delete(child);

            *deleteBox = box;

            NW_THROW_SUCCESS(status);

          }

          else {

            NW_Uint32 i;

            NW_Uint32 j;

            /* if all the characters are whitespace then throw(success)*/

            j = NW_Str_Strlen(retString);

            for (i = 0; i < j; i++) {

              if (!NW_Str_Isspace(retString[i])) {

                break;

              }

            }

            if (i == j) {

              NW_THROW_SUCCESS(status);

            }

            NW_Str_Delete(retString);

            retString = NULL;

          }

        }

      }

    }

    /* Get the wrap mode attribute */

    status = NW_Wml_GetAttribute(&(thisObj->wmlInterpreter), 

                                 elId, 

                                 MODE_ATTR, 

                                 &retString);

    NW_THROW_ON (status, KBrsrOutOfMemory);

    if (retString != NULL) {

      if (NW_Str_StricmpConst(retString,WAE_ASC_WRAP_STR)==0) {

        *nowrap = NW_FALSE;

      } else if (NW_Str_StricmpConst(retString,WAE_ASC_NOWRAP_STR)==0) {

        *nowrap = NW_TRUE;

      }

      NW_Str_Delete(retString);

      retString = NULL;

    }

    /* If no wrap mode is set, we inherit the wrap property of the

       previous paragraph */

    prop.type = NW_CSS_ValueType_Token;

    prop.value.token = (*nowrap) ? NW_CSS_PropValue_nowrap : NW_CSS_PropValue_normal;

    NW_LMgr_Box_SetProperty (box, NW_CSS_Prop_whitespace, &prop);   

    /* Get the alignment attribute */

    status = NW_Wml_GetAttribute(&(thisObj->wmlInterpreter),

                                 elId,

                                 ALIGN_ATTR,

                                 &retString);

    NW_THROW_ON (status, KBrsrOutOfMemory);

    if (retString != NULL) {

      if (NW_Str_StricmpConst(retString,WAE_ASC_CENTER_STR) == 0) {

        prop.value.token = NW_CSS_PropValue_center;

      }

      else if (NW_Str_StricmpConst(retString,WAE_ASC_RIGHT_STR) == 0) {

        prop.value.token = NW_CSS_PropValue_right;

      }

      else {

        prop.value.token = NW_CSS_PropValue_left;

      }

      NW_Str_Delete(retString);

    }

    else {

      prop.value.token = NW_CSS_PropValue_left;

    }

    NW_LMgr_Box_SetProperty (box, NW_CSS_Prop_textAlign, &prop);   

  }

  NW_CATCH (status) {

  }

  NW_FINALLY {

    return status;

  } NW_END_TRY

}

/*****************************************************************

  Name:         NW_UI_SetCellProperties()

  Description:  set cell border properties

  Parameters:   

    box     - In      - pointer to the box tree node representing the <td> element

  Algorithm:    

  Return Value: KBrsrSuccess

*****************************************************************/

static

TBrowserStatusCode

NW_UI_SetCellProperties (NW_LMgr_Box_t *box)

{

  NW_LMgr_Property_t  prop;

  NW_TRY (status) {

    prop.type = NW_CSS_ValueType_Token;

    prop.value.token = NW_CSS_PropValue_hidden;

    status = NW_LMgr_Box_SetProperty (box, NW_CSS_Prop_overflow, &prop);

    _NW_THROW_ON_ERROR (status);

  }

  NW_CATCH (status) {

  }

  NW_FINALLY {

    return status;

  }NW_END_TRY

}

/*****************************************************************

  Name:         NW_UI_NormalizeTable()

  Description:  perform WML table column width processing

  Parameters:   

    thisObj - In      - the content handler on behalf of which the work is being done

    elId    - In      - the element id of the element being processed, used in the WML query service

    box     - In      - pointer to the box tree node representing the element

  Algorithm:    

 * The behavior of WML Tables is not exactly like the behavior of CSS Tables.

 * Two issues in particular need to be addressed:

 * 1) Since the CSS Static Algorithm used in the Layout Manager

 *    calculates the dimensions of the table based on the head row, the table

 *    will contain only as many columns as there are in the first row.  In WML

 *    this information is passed in the "columns" attribute.  Here we pad the

 *    first row if it does not contain enough cells.

 * 2) in WML, any extra cells in a row are "aggregated" into the last cell.

  Return Value: KBrsrOutOfMemory

                KBrsrSuccess

                various other TBrowserStatusCode values 

*****************************************************************/

static

TBrowserStatusCode

NW_UI_NormalizeTable (NW_Wml1x_ContentHandler_t *thisObj,

                      NW_Uint16                 elId,

                      NW_LMgr_Box_t             *box)

{

  NW_LMgr_Box_t          *newBox = NULL;

  NW_LMgr_Box_t          *tmpBox = NULL;

  NW_Text_UCS2_t         *spaceText = NULL;

  NW_LMgr_ContainerBox_t *newCell = NULL;

  NW_TRY (status) {

  NW_Ucs2                *retString;

  NW_ADT_Vector_Metric_t cols = 1;

  NW_ADT_Vector_Metric_t numRows;

  NW_ADT_Vector_Metric_t numCells;

  NW_LMgr_ContainerBox_t *tableContainer = NW_LMgr_ContainerBoxOf(box);

  NW_LMgr_ContainerBox_t *cell = NULL;

  NW_LMgr_ContainerBox_t *lastCell = NULL;

  NW_LMgr_ContainerBox_t *rowContainer = NULL;

  NW_LMgr_Property_t     prop;

  NW_ADT_Vector_Metric_t i;

  NW_ADT_Vector_Metric_t j;

  /* WML table optimization */

  prop.type = NW_CSS_ValueType_Integer;

  prop.value.token = NW_CSS_PropValue_flags_wmlTable;

  NW_LMgr_Box_SetProperty (box, NW_CSS_Prop_flags, &prop);

  /* Set the margin for the table */

  prop.type = NW_CSS_ValueType_Px;

  prop.value.integer = 2;

  NW_LMgr_Box_SetProperty (box, NW_CSS_Prop_margin, &prop);

  /* Get the "columns" attribute */

  status = NW_Wml_GetAttribute(&(thisObj->wmlInterpreter),

                               elId,

                               COLUMNS_ATTR,

                               &retString);  

  if (status == KBrsrOutOfMemory) {

    return status;

  }

  if (retString != NULL) {

		if(NW_Str_StrIsValidLength(retString))

		{

			cols = (NW_ADT_Vector_Metric_t)NW_Str_Atoi (retString);

		}

    if (cols == 0) {

      /* If the attribute value is illegal, we will make the table one column wide */

      cols = 1;

    }

    NW_Str_Delete (retString);

  }

  numRows = NW_LMgr_ContainerBox_GetChildCount(tableContainer);

  for (i = 0; i < numRows; i++) {

    rowContainer = (NW_LMgr_ContainerBox_t*) NW_LMgr_ContainerBox_GetChild (tableContainer, i);

	if (rowContainer->children == NULL)

		NW_THROW_SUCCESS(status);

	numCells = NW_LMgr_ContainerBox_GetChildCount(rowContainer);

    if (numCells == cols) {

      continue;

    }

    /* If there is an insufficient number of cells in a row,

     * we must pad it with extra empty boxes */

    else if (numCells < cols) {

      for (j = numCells; j < cols; j++) {

        /* Create a new cell container and set its properties */

        newCell = (NW_LMgr_ContainerBox_t*)NW_LMgr_StaticTableCellBox_New(1);

          NW_THROW_OOM_ON_NULL (newCell, status);

        NW_UI_SetCellProperties (NW_LMgr_BoxOf(newCell));

        /* Create the text object with a single space */

        spaceText =

          NW_Text_UCS2_New((NW_Ucs2*) spaceString, 1, 0);

          NW_THROW_OOM_ON_NULL (spaceText, status);

        /* Create a text box to hold the space */

        newBox = (NW_LMgr_Box_t*)

          NW_LMgr_TextBox_New (1, NW_TextOf (spaceText));

          NW_THROW_OOM_ON_NULL (newBox, status);

        /* Add the empty box to the cell container */

        status = NW_LMgr_ContainerBox_AddChild (newCell, NW_LMgr_BoxOf(newBox));

          _NW_THROW_ON_ERROR(status);

        /* Add the cell to the row container */

        status = NW_LMgr_ContainerBox_AddChild (rowContainer, NW_LMgr_BoxOf(newCell));

        if (status != KBrsrSuccess) {

           (void)NW_LMgr_ContainerBox_RemoveChild (newCell, NW_LMgr_BoxOf(newBox));

             NW_THROW (status);

        }

      }

    }

    /* If there are extra cells in the row, we must aggregate them into

     * the last column

     */

    else if (numCells > cols) {

      /* Get the cell in the last column */

      lastCell = (NW_LMgr_ContainerBox_t*)NW_LMgr_ContainerBox_GetChild (rowContainer, 

                                            (NW_ADT_Vector_Metric_t)(cols-1));

      NW_ASSERT (NW_Object_IsInstanceOf(lastCell, &NW_LMgr_ContainerBox_Class));

      /* Aggregate the remaining cells */

      for (j = cols; j < numCells; j++) {

        /* Get the first extra cell */

        tmpBox = NW_LMgr_ContainerBox_GetChild (rowContainer, j);

        if (!NW_Object_IsInstanceOf(tmpBox, &NW_LMgr_StaticTableCellBox_Class))

        {

           status = NW_LMgr_ContainerBox_RemoveChild (rowContainer, NW_LMgr_BoxOf(tmpBox));

           _NW_THROW_ON_ERROR(status);

           j--;

           numCells--;

           NW_Object_Delete(tmpBox);

           continue;

        }

        cell = (NW_LMgr_ContainerBox_t*)tmpBox;

        /* Create the text object with a single space */

        spaceText =

          NW_Text_UCS2_New((NW_Ucs2*) spaceString, 1, 0);

          NW_THROW_OOM_ON_NULL (spaceText, status);

        newBox = (NW_LMgr_Box_t*)

          NW_LMgr_TextBox_New (1, NW_TextOf (spaceText));

          NW_THROW_OOM_ON_NULL (newBox, status);

        /* Add the empty box to the last legal cell */

        status = NW_LMgr_ContainerBox_AddChild (lastCell, NW_LMgr_BoxOf(newBox));

          _NW_THROW_ON_ERROR(status);

        /* Remove the extra box from the row */

        status = NW_LMgr_ContainerBox_RemoveChild (rowContainer, NW_LMgr_BoxOf(cell));

          _NW_THROW_ON_ERROR(status);

        j--;

        numCells--;

        /* Append the extra content */

        status = NW_LMgr_ContainerBox_AppendChildrenOf (lastCell, cell);

          _NW_THROW_ON_ERROR(status);

        /* We don't want to destroy the cell content, because we have copied it

         * to lastCell */

        status = NW_ADT_DynamicVector_Clear (

          (NW_ADT_DynamicVector_t*)NW_LMgr_ContainerBox_GetChildren(cell));

          _NW_THROW_ON_ERROR(status);

        /* Finally, delete the cell */

        NW_Object_Delete(tmpBox);

      }

    }

  }

  } NW_CATCH (status) {

  NW_Object_Delete(newBox);

  NW_Object_Delete(spaceText);

  NW_Object_Delete(newCell);

  } NW_FINALLY {

  return status;

  } NW_END_TRY