/*

* Copyright (c) 2000 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 <calslbs.h>            // for Latin.... font methods

#include "nwx_string.h"

#include "nw_fbox_formbox.h"

#include "nw_evt_ecmaevent.h"

#include "nw_fbox_epoc32inputskini.h"

#include "nw_wml1x_wml_1_3_tokens.h"

#include "nw_fbox_inputbox.h"

#include "nw_fbox_textareabox.h"

#include "nw_fbox_passwordbox.h"

#include "nw_fbox_passwordboxi.h"

#include "nw_lmgr_box.h"

#include "nw_lmgr_textbox.h"

#include "nw_lmgr_rootbox.h"

#include "LMgrBoxTreeListener.h"

#include "GDIDeviceContext.h"

#include "nw_fbox_formboxutils.h"

#include "BrsrStatusCodes.h"

#include "nw_lmgr_statictablecellbox.h"

const NW_GDI_Dimension2D_t extraPadding = {2,2};

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

   private methods

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

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

static

TBrowserStatusCode

NW_FBox_Epoc32InputSkin_GetMaxCharExtent(NW_FBox_InputBox_t* inputBox, 

                                         NW_GDI_Dimension2D_t* extent)

{

  CFont* epocCFont;

  CGDIFont* font;

  CGDIDeviceContext* deviceContext;

  NW_LMgr_RootBox_t* rootBox = NULL;

  /* parameter assertion block */

  NW_ASSERT(inputBox!=NULL);

  NW_ASSERT(NW_Object_IsInstanceOf(inputBox, &NW_FBox_InputBox_Class));

  NW_ASSERT(extent!=NULL);

  /* get device context */

  rootBox = NW_LMgr_Box_GetRootBox (NW_LMgr_BoxOf (inputBox));

  NW_ASSERT (rootBox != NULL);

  deviceContext = NW_LMgr_RootBox_GetDeviceContext (rootBox);

  NW_ASSERT (deviceContext != NULL);

  /* get the box font */

  font = NW_LMgr_Box_GetFont (NW_LMgr_BoxOf(inputBox));

  NW_ASSERT (font != NULL);

  epocCFont = (CFont*)

    deviceContext->GetScaledCFont(  font );

  /* get character extents */

  extent->width = (NW_GDI_Metric_t)epocCFont->MaxNormalCharWidthInPixels();

  extent->height = (NW_GDI_Metric_t)epocCFont->HeightInPixels();

  return KBrsrSuccess;

}

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

static

TBrowserStatusCode

NW_FBox_Epoc32InputSkin_TruncateText(NW_FBox_Epoc32InputSkin_t* thisObj, 

                                     NW_GDI_Metric_t wrapWidth,

                                     CGDIDeviceContext* deviceContext,

                                     NW_Text_t* text,

                                     CGDIFont* font,

                                     NW_GDI_FlowDirection_t dir)

  {

  NW_GDI_Dimension2D_t extent;

  NW_Text_Length_t valueLength = 0;

  NW_Text_Length_t displayLength = 0;

  NW_Ucs2* displayStorage = NULL;

  NW_Ucs2* valueStorage = NULL;

  NW_TRY(status)

    {

    status = deviceContext->GetTextExtent(text,

                                          font,

                                          0,

                                          dir,

                                          &extent);

    NW_THROW_ON_ERROR(status);

    /* Line fits in the space */

    if (extent.width - 1 <= wrapWidth)

      {

      NW_ADT_DynamicVector_InsertAt (thisObj->textList, &text, NW_ADT_Vector_AtEnd);     

      NW_THROW_SUCCESS(status);

      }

    /* Line does not fit - truncate it */

    valueStorage = NW_Text_GetUCS2Buffer(text, 0, &valueLength, NULL);

    NW_THROW_ON_NULL(valueStorage, status, KBrsrFailure);

    status = NW_FBox_FormBoxUtils_GetDisplayLength( deviceContext, 

                                                    text,

                                                    font,

                                                    valueLength, 

                                                    (NW_Uint16)wrapWidth,

                                                    &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;

    status = NW_Text_SetStorage(text, displayStorage, displayLength, NW_TRUE);

    NW_THROW_ON_ERROR (status);

    NW_ADT_DynamicVector_InsertAt (thisObj->textList, &text, NW_ADT_Vector_AtEnd);     

    }

  NW_CATCH(status)

    {

    if (displayStorage)

      {

      NW_Mem_Free(displayStorage);

      }

    }

  NW_FINALLY

    {

    return status;

    }

  NW_END_TRY

  }

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

// NW_FBox_Epoc32GetInnerRectangle

// param: NW_LMgr_Box_t* - pointer to input box

// param: NW_GDI_Rectangle_t* - returns x,y and height,width of inner rectangle

// returns: KBrsrSuccess 

// Very similar to LMgrBox.cpp / NW_LMgr_Box_GetInnerRectangle() this routine

// is different in that GetFormatBounds is used here, instead of GetDisplayBounds.

//

static

TBrowserStatusCode

NW_FBox_Epoc32GetInnerRectangle(NW_LMgr_Box_t* box,

                              NW_GDI_Rectangle_t* innerRectangle)

{

  NW_GDI_Rectangle_t bounds;

  NW_LMgr_FrameInfo_t padding;

  NW_LMgr_FrameInfo_t borderWidth;

  /* Get all margin, border and padding settings */

  bounds = (NW_LMgr_Box_GetFormatBounds(box));

  NW_LMgr_Box_GetPadding(box, &padding, ELMgrFrameAll );

  NW_LMgr_Box_GetBorderWidth(box, &borderWidth, ELMgrFrameAll );

  innerRectangle->point.x = 

    (NW_GDI_Metric_t)(bounds.point.x + borderWidth.left + padding.left);

  innerRectangle->point.y = 

    (NW_GDI_Metric_t)(bounds.point.y + borderWidth.top + padding.top);

  innerRectangle->dimension.height = (NW_GDI_Metric_t)(bounds.dimension.height - 

    (borderWidth.top + borderWidth.bottom + padding.top + padding.bottom));

  innerRectangle->dimension.width = (NW_GDI_Metric_t)(bounds.dimension.width - 

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

  return KBrsrSuccess;

}

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

static

TBrowserStatusCode

NW_FBox_Epoc32InputSkin_SplitText(NW_FBox_InputSkin_t* skin, 

                                  NW_FBox_InputBox_t* inputBox,

                                  NW_Text_t* text)

  {

  NW_FBox_Epoc32InputSkin_t* thisObj;

  NW_Text_t* splitText = NULL;

  CGDIFont *font = NULL;

  NW_Text_Length_t length;

  NW_LMgr_RootBox_t* rootBox;

  CGDIDeviceContext* deviceContext;

  NW_GDI_Metric_t wrapWidth;

  NW_GDI_Dimension2D_t maxCharExtent;

  NW_GDI_Rectangle_t innerRect;

  NW_ADT_Vector_Metric_t numTexts = 0;

  NW_ADT_Vector_Metric_t numSplits = 0;

  NW_LMgr_Property_t prop;

  NW_GDI_FlowDirection_t dir;

  NW_TRY(status)

    {

    prop.type = NW_CSS_ValueType_Token;

    prop.value.token = NW_CSS_PropValue_ltr;

    NW_LMgr_Box_GetProperty(NW_LMgr_BoxOf(inputBox), NW_CSS_Prop_textDirection, &prop);

    dir = (prop.value.token == NW_CSS_PropValue_ltr) ? NW_GDI_FlowDirection_LeftRight : NW_GDI_FlowDirection_RightLeft;

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

    rootBox = NW_LMgr_Box_GetRootBox(NW_LMgr_BoxOf(inputBox));

    NW_ASSERT (rootBox != NULL);

    deviceContext = NW_LMgr_RootBox_GetDeviceContext (rootBox);

    NW_ASSERT (deviceContext != NULL);

    status = NW_FBox_Epoc32InputSkin_GetMaxCharExtent(inputBox, &maxCharExtent);

    NW_THROW_ON_ERROR(status);

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

    font = NW_LMgr_Box_GetFont (NW_LMgr_BoxOf(inputBox));

    NW_ASSERT(font != NULL);

    thisObj = NW_FBox_Epoc32InputSkinOf(skin);

    /* Get the box info */

    NW_FBox_Epoc32GetInnerRectangle(NW_LMgr_BoxOf(inputBox), &innerRect);

    innerRect.dimension.height -= extraPadding.height;

    innerRect.dimension.width -= extraPadding.width;

    numTexts = NW_FBox_InputBox_GetHeight(inputBox);

    // one extra character reserved so that EdWin looks good when wrapping 

    wrapWidth = innerRect.dimension.width;

    /* Munch until we have consumed the whole text */

    while ((numSplits < numTexts) && (splitText != text))

      {

      if (numSplits == (numTexts - 1))

        {

        status = NW_FBox_Epoc32InputSkin_TruncateText( thisObj, 

                                                       wrapWidth, 

                                                       deviceContext, 

                                                       text,

                                                       font,

                                                       dir); 

        NW_THROW_ON_ERROR(status);

        break;        

        }

      /* try to split at the newline if newline char is within the width */

      status = deviceContext->SplitText (text, 

                                         font,

                                         wrapWidth, 0,

                                         dir,

                                         &length,

                                         NW_GDI_SplitMode_Newline);

      if(status == KBrsrLmgrNoSplit)

        { /* Failed */    

        /* try to split at space to fit within current line */

        status = deviceContext->SplitText ( text, 

                                            font,

                                            wrapWidth, 

                                            0,

                                            dir,

                                            &length,

                                            NW_GDI_SplitMode_WordWrap );

        if(status == KBrsrLmgrNoSplit)

          { /* Failed */

          status = deviceContext->SplitText ( text,

                                              font,

                                              wrapWidth, 

                                              0,

                                              dir,

                                              &length,

                                              NW_GDI_SplitMode_Clip );

          if(status == KBrsrLmgrNoSplit) 

            {

            return KBrsrFailure;

            }

          }

        }

      if (status == KBrsrOutOfMemory) 

        {

        return status;

        }

      if (length != NW_Text_GetCharCount(text)) 

        {

        splitText = NW_Text_Split(text, length);

        if (splitText == NULL) 

          {

          return KBrsrOutOfMemory;

          }

        }

      else 

        {

        splitText = text;

        }

      numSplits++;

      NW_ADT_DynamicVector_InsertAt (thisObj->textList, &splitText, NW_ADT_Vector_AtEnd);     

      }

    }

  NW_CATCH(status)

    {

    }

  NW_FINALLY

    {

    return KBrsrSuccess;

    }

  NW_END_TRY

  }

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

void

NW_FBox_Epoc32InputSkin_ClearTextList(NW_FBox_Epoc32InputSkin_t* thisObj)

{

  NW_ADT_Vector_Metric_t index;

  NW_ADT_Vector_Metric_t size;

  NW_Text_t* text;

  size = NW_ADT_Vector_GetSize(NW_ADT_VectorOf(thisObj->textList));

  /* release the dynamic objects pointed by the object array */

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

  {

    text = *(NW_Text_t**)

           NW_ADT_Vector_ElementAt(NW_ADT_VectorOf(thisObj->textList), 0);

    NW_ADT_DynamicVector_RemoveAt(thisObj->textList, 0);

    NW_ASSERT(text);

    NW_Object_Delete(text);

  }

  thisObj->textList->size = 0;

}

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

static

TBrowserStatusCode

NW_FBox_Epoc32InputSkin_RecreateTextList(NW_FBox_Epoc32InputSkin_t* thisObj)

{

  NW_FBox_InputBox_t* inputBox = NULL;  

  NW_FBox_InputSkin_t* inputSkin = NULL;  

  NW_Text_t* text = NULL;

  TBrowserStatusCode status;

  /* parameter assertion block */

  NW_ASSERT(NW_Object_IsInstanceOf(thisObj, &NW_FBox_InputSkin_Class));

  /* for convenience */

  inputSkin = NW_FBox_InputSkinOf(thisObj);

  /* get input box */

  inputBox = NW_FBox_InputSkin_GetInputBox(inputSkin);

  NW_ASSERT(inputBox!=NULL);

  /* clears the list of texts */

  NW_FBox_Epoc32InputSkin_ClearTextList(thisObj);

  /* Now we try to get the text to be displayed */

  /* In case of password box, the following code, converts inputbox value

     to * and stores it in InputSkin */

  if (NW_Object_IsClass(inputBox, &NW_FBox_PasswordBox_Class))

  {

    status = _NW_FBox_PasswordBox_SetObscureDisplayText(inputBox, NW_TRUE);

    if (status != KBrsrSuccess){

      return status;

    }

    if (inputSkin->displayText){

      text = NW_Text_Copy(inputSkin->displayText, NW_FALSE);

    }

  }

  else

  {

    if (inputBox->value){

      text = NW_Text_Copy(inputBox->value, NW_FALSE);

    }

  }

  if (text == NULL){

    return KBrsrSuccess;

  }

  /* input text does not fit within the space, input box is on new line,

   we need to split the text into multiple rows */

  status = NW_FBox_Epoc32InputSkin_SplitText(inputSkin, inputBox, text);  

  if (status != KBrsrSuccess){

    return status;

  }

  return KBrsrSuccess;

}

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

static

TBrowserStatusCode

NW_FBox_InputSkin_VKBCallback (void *timerData)

{

 NW_FBox_Epoc32InputSkin_t* thisObj = NW_FBox_Epoc32InputSkinOf(timerData);

  //retrieve the epoc32 input box

  if (thisObj && thisObj->cppEpoc32InputBox)

  {

    thisObj->cppEpoc32InputBox->ActivateVKB();

  }

  if (thisObj->vkbTimer != NULL) {

    NW_Object_Delete (thisObj->vkbTimer);

    thisObj->vkbTimer = NULL;

  }

  return KBrsrSuccess;

}

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

   global data

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

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

const

NW_FBox_Epoc32InputSkin_Class_t  NW_FBox_Epoc32InputSkin_Class = {

  { /* NW_Object_Core             */

    /* super                      */ &NW_FBox_InputSkin_Class,

    /* queryInterface             */ _NW_Object_Base_QueryInterface

  },

  { /* NW_Object_Base             */

    /* interfaceList              */ NULL

  },

  { /* NW_Object_Dynamic          */

    /* instanceSize               */ sizeof (NW_FBox_Epoc32InputSkin_t),

    /* construct                  */ _NW_FBox_Epoc32InputSkin_Construct,

    /* destruct                   */ _NW_FBox_Epoc32InputSkin_Destruct

  },

  { /* NW_FBox_Skin               */

    /* NW_FBox_Skin_Draw          */ _NW_FBox_InputSkin_Draw,

    /* NW_FBox_Skin_GetSize       */ _NW_FBox_Epoc32InputSkin_GetSize

  },

  { /* NW_FBox_InputSkin          */

    /* drawText                   */ _NW_FBox_Epoc32InputSkin_DrawText,

    /* moveCursorLeft             */ NULL,

    /* moveCursorRight            */ NULL,

    /* clearLastChar              */ NULL,

    /* setDisplayText             */ _NW_FBox_Epoc32InputSkin_SetDisplayText,

    /* setActive                  */ _NW_FBox_Epoc32InputSkin_SetActive,

    /* setFocus                   */ _NW_FBox_Epoc32InputSkin_SetFocus,

    /* detailsDialog              */ NULL,

    /* split                      */ _NW_FBox_Epoc32InputSkin_Split,

    /* vkb                        */_NW_FBox_Epoc32InputSkin_SetVKB 

  },

  { /* NW_FBox_Epoc32InputSkin */

    /* unused                     */ NW_Object_Unused

  }

};

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

   virtual methods

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

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

TBrowserStatusCode

_NW_FBox_Epoc32InputSkin_Construct (NW_Object_Dynamic_t* dynamicObject,

                                       va_list* argp)

{

  TBrowserStatusCode status;

  NW_FBox_Epoc32InputSkin_t* thisObj;

  /* avoid "unreferenced formal parameter" warnings */

  (void) argp;

  /* for convenience */

  thisObj = NW_FBox_Epoc32InputSkinOf (dynamicObject);

  /* invoke our superclass constructor */

  status = _NW_FBox_InputSkin_Construct (dynamicObject, argp);

  if (status != KBrsrSuccess) {

    return status;

  }

  /* create the TextBox and insert it into our parent */

  thisObj->textList = (NW_ADT_DynamicVector_t*)

                      NW_ADT_ResizableVector_New(sizeof(NW_Text_t*), 3,3);

  if (thisObj->textList == NULL){

    return KBrsrOutOfMemory;

  }

  thisObj->cppEpoc32InputBox = NULL;

  /* successful completion */

  return KBrsrSuccess;

}

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

void

_NW_FBox_Epoc32InputSkin_Destruct (NW_Object_Dynamic_t* dynamicObject)

{

  NW_FBox_Epoc32InputSkin_t* thisObj;

  /* for convenience */

  thisObj = NW_FBox_Epoc32InputSkinOf (dynamicObject);

  /* destroy edwin */

  delete thisObj->cppEpoc32InputBox;

  thisObj->cppEpoc32InputBox = NULL;

  if (thisObj->vkbTimer != NULL) {

    NW_Object_Delete (thisObj->vkbTimer);

    thisObj->vkbTimer = NULL;

  }

  NW_FBox_Epoc32InputSkin_ClearTextList(thisObj);

  if (thisObj->textList){

    NW_Object_Delete(thisObj->textList);

  }

}

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

TBrowserStatusCode

_NW_FBox_Epoc32InputSkin_GetSize(NW_FBox_Skin_t* skin,

                                 NW_LMgr_Box_t* box,

                                 NW_GDI_Dimension3D_t* size)

{

  NW_FBox_InputBox_t* inputBox;

  NW_GDI_Dimension2D_t charExtent;

  NW_LMgr_PropertyValue_t sizeVal;