/*

* 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 <e32def.h>  // First to avoid NULL redefine warning (no #ifndef NULL).

#include "nw_fbox_epoc32selectskini.h"

#include "nw_image_cannedimages.h"

#include "nw_fbox_selectboxi.h"

#include "nw_lmgr_rootbox.h"

#include "nwx_string.h"

#include "nw_fbox_epoc32formimages.h"

#include "nw_gdi_types.h"

#include "GDIDeviceContext.h"

#include "nw_adt_resizablevector.h"

#include "nw_fbox_formboxutils.h"

#include "KimonoLocalizationStrings.h"

#include "nwx_logger.h"

#include "nw_lmgr_statictablecellbox.h"

#include "nw_browser_browserimages.h"

#include "BrsrStatusCodes.h"

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

    private data typed

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

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

#define NW_FBox_Epoc32SelectSkin_Separator_len ((sizeof(_NW_FBox_Epoc32SelectSkin_Separator)\

                                             /sizeof(NW_Ucs2))-1)

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

   static data

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

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

    private methods

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

NW_Ucs2*

NW_FBox_Epoc32SelectSkin_GetNewUcs2Str(NW_FBox_Epoc32SelectSkin_t* skin,

                                     NW_Text_t* text)

{

  NW_REQUIRED_PARAM(skin);

  return

    NW_Text_GetUCS2Buffer (text, NW_Text_Flags_Aligned | NW_Text_Flags_Copy,

                           NULL, NULL);

}

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

static

TBrowserStatusCode

NW_FBox_Epoc32SelectSkin_GetArrowSize(NW_FBox_SelectBox_t* selectBox,

                                      NW_GDI_Dimension3D_t* imageSize)

{

  const NW_Image_AbstractImage_t* image;

  NW_LMgr_RootBox_t* rootBox;

  NW_ASSERT(imageSize!=NULL);

  NW_ASSERT(selectBox!=NULL);

  /* get the root box */

  rootBox = NW_LMgr_Box_GetRootBox(NW_LMgr_BoxOf(selectBox));

  NW_ASSERT(rootBox);

  /* get the image from the canned images dictionary */

  NW_ASSERT(rootBox->cannedImages!=NULL);

  image = NW_Image_CannedImages_GetImage( rootBox->cannedImages,

                                          NW_Image_SelectArrow );

  NW_ASSERT(image);

  return NW_Image_AbstractImage_GetSize (image, imageSize);

}

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

static

TBrowserStatusCode

NW_FBox_Epoc32SelectSkin_GetTextExtent(NW_FBox_Epoc32SelectSkin_t* selectSkin,

                                       NW_FBox_SelectBox_t* selectBox,

                                       CGDIDeviceContext* deviceContext,

                                       NW_GDI_Dimension2D_t* extent,

                                       NW_Text_t* text)

  {

  NW_REQUIRED_PARAM(selectSkin);

  CGDIFont *font;

  TBrowserStatusCode status;

  TGDIFontInfo fontInfo;

  extent->width = 0;

  extent->height = 0;

  /* Set the font to match the parent. */

  font = NW_LMgr_Box_GetFont (NW_LMgr_BoxOf(selectBox));

  NW_ASSERT(font != NULL);

  /* Get info */

  font->GetFontInfo ( &fontInfo);

  if (text == NULL)

    {

    return KBrsrSuccess;

    }

  status = deviceContext->GetTextExtent (text,

                                         font,

                                         0,

                                         NW_GDI_FlowDirection_LeftRight,

                                         extent);

  extent->height = fontInfo.height;

  return status;

  }

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

static

NW_Int32

NW_FBox_Epoc32SelectSkin_GetMaxTextWidth(NW_FBox_Epoc32SelectSkin_t* selectSkin,

                                         NW_FBox_SelectBox_t* selectBox)

  {

  NW_REQUIRED_PARAM(selectSkin);

  CGDIFont *font;

  CGDIDeviceContext* deviceContext;

  TGDIFontInfo fontInfo;

  NW_Int32 maxWidth = 0;

  NW_Text_t* text = NULL;

  NW_ADT_Vector_Metric_t index;

  NW_GDI_Dimension2D_t extent;

  NW_FBox_OptionBox_t* optionBox = NULL;

  /* we're going to need the deviceContext to do text extent calculations */

  deviceContext = NW_LMgr_RootBox_GetDeviceContext (NW_LMgr_Box_GetRootBox(selectBox));

  NW_ASSERT (deviceContext != NULL);

  /* Set the font to match the parent. */

  font = NW_LMgr_Box_GetFont(NW_LMgr_BoxOf(selectBox));

  NW_ASSERT(font != NULL);

  font->GetFontInfo( &fontInfo);

  NW_Int32 numItems = NW_ADT_Vector_GetSize(NW_ADT_VectorOf(selectBox->children));

  for(index = 0; index < numItems; index++)

    {

      optionBox = *(NW_FBox_OptionBox_t**)NW_ADT_Vector_ElementAt(selectBox->children, index);

      if (!NW_Object_IsInstanceOf(optionBox, &NW_FBox_OptionBox_Class))

        continue;

      text = NW_FBox_OptionBox_GetText(optionBox);

      if (text == NULL)

        continue;

      extent.width = 0;

      extent.height = 0;

      deviceContext->GetTextExtent (text, font, 0, NW_GDI_FlowDirection_LeftRight, &extent);

      if (maxWidth < extent.width)

        {

          maxWidth = extent.width;

        }

    }

  return maxWidth;

  }

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

static

TBrowserStatusCode

NW_FBox_Epoc32SelectSkin_SetDisplayText(NW_FBox_Epoc32SelectSkin_t* thisObj)

  {

  CGDIDeviceContext* deviceContext = NULL;

  NW_FBox_SelectBox_t* selectBox = NULL;

  NW_GDI_Dimension2D_t extent;

  NW_GDI_Dimension2D_t charExtent;

  NW_GDI_Dimension3D_t imageSize;

  NW_Uint16 displayWidth = 0;

  NW_GDI_Rectangle_t innerRect;

  NW_Text_Length_t valueLength = 0;

  NW_Text_Length_t displayLength = 0;

  CGDIFont *font = NULL;

  NW_Ucs2* displayStorage = NULL;

  NW_Ucs2* valueStorage = NULL;

  NW_TRY(status)

    {

    selectBox = NW_FBox_SelectSkin_GetSelectBox(thisObj);

    NW_ASSERT (selectBox);

    /* we're going to need the deviceContext to do text extent calculations */

    deviceContext = NW_LMgr_RootBox_GetDeviceContext (NW_LMgr_Box_GetRootBox(selectBox));

    NW_ASSERT (deviceContext != NULL);

    /* Set the font to match the parent. TODO: this may not be the best policy */

    font = NW_LMgr_Box_GetFont (NW_LMgr_BoxOf(selectBox));

    NW_ASSERT(font != NULL);

    /* extract the image from our canned images */

    status = NW_FBox_Epoc32SelectSkin_GetArrowSize(selectBox, &imageSize);

    NW_THROW_ON_ERROR (status);

    status = NW_FBox_SelectSkin_GetMCharExtent(NW_FBox_SelectSkinOf(thisObj), &charExtent);

    NW_THROW_ON_ERROR (status);

    if (thisObj->value == NULL)

      {

      /* nothing to display */

      NW_THROW_SUCCESS(status);

      }

    /* Find out how much space is required to display the value */

    status = NW_FBox_Epoc32SelectSkin_GetTextExtent(thisObj, selectBox, 

                                                   deviceContext, &extent, NW_TextOf(thisObj->value));

    NW_THROW_ON_ERROR (status);

    displayWidth = (NW_Uint16)(extent.width + imageSize.width);

    NW_LMgr_Box_GetInnerRectangle(NW_LMgr_BoxOf(selectBox), &innerRect);

    valueStorage =

      NW_Text_GetUCS2Buffer(NW_TextOf(thisObj->value), 0, &valueLength, NULL);

    /* The text fits within the space */

    if (displayWidth <= innerRect.dimension.width)

      {

      /* Make a copy of the value */

      if (valueStorage)

        {

        displayStorage = NW_Str_Newcpy(valueStorage);

        NW_THROW_OOM_ON_NULL(displayStorage, status);

        }

      if (thisObj->displayText)

        {

        status = NW_Text_SetStorage(NW_TextOf(thisObj->displayText), displayStorage,

                           valueLength, NW_Text_Flags_TakeOwnership);

        NW_THROW_ON_ERROR (status);

        }

      else

        {

        thisObj->displayText = NW_Text_UCS2_New(displayStorage, valueLength, NW_Text_Flags_TakeOwnership);

        NW_THROW_OOM_ON_NULL(thisObj->displayText, status);

        }

      NW_THROW_SUCCESS(status);

      }

    /* The text does not fit the select box. We have to truncate it */

    status = NW_FBox_FormBoxUtils_GetDisplayLength(deviceContext,

                                                   (NW_Text_t*)thisObj->value,

                                                   font,

                                                   valueLength,

                                                   (NW_Uint16)(innerRect.dimension.width - imageSize.width),

                                                   &displayLength, NW_FALSE);

    NW_THROW_ON_ERROR (status);

    displayStorage = NW_Str_New(displayLength + NW_FBox_FormBoxUtils_Truncate_len);

    NW_THROW_OOM_ON_NULL(displayStorage, status);

    NW_Mem_memcpy(displayStorage, (valueStorage), displayLength*sizeof(NW_Ucs2));

    NW_Mem_memcpy(displayStorage + displayLength, NW_FBox_FormBoxUtils_Truncate,

                                   NW_FBox_FormBoxUtils_Truncate_len*sizeof(NW_Ucs2));

    displayLength += NW_FBox_FormBoxUtils_Truncate_len;

    if (thisObj->displayText == NULL)

      {

      thisObj->displayText =  NW_Text_UCS2_New(displayStorage, displayLength, NW_Text_Flags_TakeOwnership);

      if (thisObj->displayText == NULL)

        {

        NW_Mem_Free(displayStorage);

        status = KBrsrOutOfMemory;

        }

      }

    else

      {

      status = NW_Text_SetStorage(NW_TextOf(thisObj->displayText), displayStorage,

                                  displayLength, NW_TRUE);

      }

    }

  NW_CATCH (status)

    {

    }

  NW_FINALLY

    {

    return status;

    }

  NW_END_TRY

  }

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

static

NW_Bool

NW_FBox_Epoc32SelectSkin_OptionStateChanged(NW_FBox_Epoc32SelectSkin_t *skin,

                                        NW_Ucs2* data,

                                        NW_FBox_OptionBox_t* optionBox)

{

  NW_Ucs2* textStr;

  NW_Uint8 freeNeeded;

  NW_Text_Length_t length;

  NW_Text_Length_t dataLength;

  NW_Text_t* text;

  NW_Bool changed;

  NW_REQUIRED_PARAM(skin);

  dataLength = (NW_Text_Length_t)NW_Str_Strlen(data);

  changed = NW_FALSE;

  text = NW_FBox_OptionBox_GetText(optionBox);

  textStr = (NW_Ucs2*) NW_Text_GetUCS2Buffer (text, 0, &length, &freeNeeded);

  if (length == dataLength)

  {

    if (!NW_Mem_memcmp (data, textStr, length * sizeof (NW_Ucs2))) {

      NW_FBox_OptionBox_ChangeState(optionBox);

      changed = NW_TRUE;

    }

  }

  if (freeNeeded){

    NW_Mem_Free(textStr);

  }

  return changed;

}

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

static

NW_Bool

NW_FBox_Epoc32SelectSkin_OptGrpStateChanged(NW_FBox_Epoc32SelectSkin_t *skin,

                                        NW_Ucs2* data,

                                        NW_FBox_OptGrpBox_t* optGrpBox)

{

  NW_ADT_Vector_Metric_t numItems;

  NW_ADT_Vector_Metric_t index;

  numItems = NW_ADT_Vector_GetSize(NW_ADT_VectorOf(optGrpBox->children));

  for(index = 0; index < numItems; index++)

  {

    NW_FBox_FormBox_t* formBox;

    formBox = *(NW_FBox_FormBox_t**)

      NW_ADT_Vector_ElementAt(optGrpBox->children, index);

    if (NW_Object_IsInstanceOf(formBox, &NW_FBox_OptionBox_Class))

    {

      if (NW_FBox_Epoc32SelectSkin_OptionStateChanged(skin, data, NW_FBox_OptionBoxOf(formBox)))

        return NW_TRUE;

    }

    else if (NW_Object_IsInstanceOf(formBox, &NW_FBox_OptGrpBox_Class))

    {

      /* recurse here */

      if (NW_FBox_Epoc32SelectSkin_OptGrpStateChanged(skin, data, NW_FBox_OptGrpBoxOf(formBox)))

        return NW_TRUE;

    }

    else{

      NW_ASSERT(0);

    }

  }

  return NW_FALSE;

}

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

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

static

NW_Bool

NW_FBox_Epoc32SelectSkin_ChangeState(NW_FBox_Epoc32SelectSkin_t *skin,

                                  NW_Ucs2* data)

{

  NW_ADT_Vector_Metric_t numItems;

  NW_ADT_Vector_Metric_t index;

  NW_FBox_SelectBox_t* selectBox;

  selectBox = (NW_FBox_SelectBox_t*)NW_FBox_Skin_GetFormBox(NW_FBox_SkinOf(skin));

  numItems = NW_ADT_Vector_GetSize(NW_ADT_VectorOf(selectBox->children));

  for(index = 0; index < numItems; index++)

  {

    NW_FBox_FormBox_t* formBox;

    formBox = *(NW_FBox_FormBox_t**)

      NW_ADT_Vector_ElementAt(selectBox->children, index);

    if (NW_Object_IsInstanceOf(formBox, &NW_FBox_OptionBox_Class))

    {

      if (NW_FBox_Epoc32SelectSkin_OptionStateChanged(skin, data, NW_FBox_OptionBoxOf(formBox)))

        return NW_TRUE;

    }

    else if (NW_Object_IsInstanceOf(formBox, &NW_FBox_OptGrpBox_Class))

    {

      if (NW_FBox_Epoc32SelectSkin_OptGrpStateChanged(skin, data, NW_FBox_OptGrpBoxOf(formBox)))

        return NW_TRUE;

    }

    else{

      NW_ASSERT(0);

    }

  }

  return NW_FALSE;

}

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

static

TBrowserStatusCode

NW_FBox_Epoc32SelectSkin_GetOptionValue(NW_FBox_OptionBox_t* optionBox,

                                     NW_Ucs2** val,

                                     NW_Bool* updated)

{

  NW_Ucs2* textStr = NULL;

  NW_Uint8 freeNeeded = NW_FALSE;

  NW_Text_Length_t length;

  NW_Text_t* text;

  NW_Bool state;

  TBrowserStatusCode status = KBrsrSuccess;

  if (updated == NULL)

  {

    return KBrsrFailure;

  }

  state = NW_FBox_CheckBox_GetState(NW_FBox_CheckBoxOf(optionBox));

  if (state == NW_FALSE)

  {

    *updated = NW_FALSE;

    goto cleanup;

  }

  text = NW_FBox_OptionBox_GetText(optionBox);

  textStr =

    NW_Text_GetUCS2Buffer (text, NW_Text_Flags_Aligned, &length, &freeNeeded);

  if (textStr == NULL)

  {

    *updated = NW_FALSE;

    status = KBrsrOutOfMemory;

    goto cleanup;

  }

  if (*val)

  {

    NW_Ucs2* str;

    NW_Uint16 newLength;

    newLength = (NW_Uint16)

      (NW_Str_Strlen (*val) + NW_FBox_Epoc32SelectSkin_Separator_len + length);

    str = NW_Str_New(newLength);

    if (str == NULL)

    {

      *updated = NW_FALSE;

      status = KBrsrOutOfMemory;

      goto cleanup;

    }

    NW_Mem_memset(str, 0, newLength);

    NW_Str_Strcpy(str, *val);

    NW_Str_Strcat(str, _NW_FBox_Epoc32SelectSkin_Separator);

    NW_Str_Strcat(str, textStr);

    NW_Str_Delete(*val);

    *val = str;

  }

  else{

    *val = NW_Str_Newcpy(textStr);

    if (*val == NULL)

    {

      *updated = NW_FALSE;

      status = KBrsrOutOfMemory;

      goto cleanup;

    }

  }

  *updated = NW_TRUE;

cleanup:

  if (freeNeeded){

    NW_Mem_Free(textStr);

  }

  return status;

}

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

static

TBrowserStatusCode

NW_FBox_Epoc32SelectSkin_GetChildrenValue(NW_FBox_Epoc32SelectSkin_t *skin,

                                       NW_FBox_FormBox_t*       parentFormBox,

                                       NW_ADT_Vector_Metric_t   numParentItems,

                                       NW_Bool                  multiple,

                                       NW_Ucs2**                newStr,

                                       NW_Bool*                 updated)

{

  NW_ADT_Vector_Metric_t index;

  NW_FBox_OptionBox_t* optionBox;

  TBrowserStatusCode status = KBrsrSuccess;

  *updated = NW_FALSE;

  for(index = 0; index < numParentItems; index++)

  {

    NW_FBox_FormBox_t* childFormBox;

    childFormBox = NULL;

    /* get the next child of the parent */

    if (NW_Object_IsInstanceOf(parentFormBox, &NW_FBox_SelectBox_Class))

    {

      childFormBox = *(NW_FBox_FormBox_t**)

        NW_ADT_Vector_ElementAt(NW_FBox_SelectBoxOf(parentFormBox)->children, index);

    }

    else if (NW_Object_IsInstanceOf(parentFormBox, &NW_FBox_OptGrpBox_Class))

    {

      childFormBox = *(NW_FBox_FormBox_t**)

        NW_ADT_Vector_ElementAt(NW_FBox_OptGrpBoxOf(parentFormBox)->children, index);

    }

    else

    {

      /* bad content - only <select> and <optgroup> are allowed as parent */

      NW_ASSERT((NW_Object_IsInstanceOf(parentFormBox, &NW_FBox_SelectBox_Class))

             || (NW_Object_IsInstanceOf(parentFormBox, &NW_FBox_OptGrpBox_Class)));