/*

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

#include "nw_lmgr_textbox.h"

#include "nw_lmgr_splittextbox.h"

#include "nw_lmgr_marqueebox.h"

#include "nw_lmgr_activecontainerbox.h"

#include "nw_lmgr_statictablecellbox.h"

#include "nw_adt_resizablevector.h"

#include "nw_lmgr_breakbox.h"

#include "nwx_settings.h"

#include "nw_lmgr_simplepropertylist.h"

#include "nw_image_epoc32simpleimage.h"

#include "nw_image_virtualimage.h"

#include "nw_lmgr_imgcontainerbox.h"

#include <stddef.h>

#include "BrsrStatusCodes.h"

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

/*                    PRIVATE METHODS                                        */

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

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

/*                    BLINK IMPLEMENTATION                                   */

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

static

TBrowserStatusCode

NW_LMgr_RootBox_Blink(NW_LMgr_RootBox_t* thisObj) 

{

  NW_LMgr_BoxVisitor_t* visitor = NULL;

  NW_TRY (status) {

  NW_LMgr_PropertyValue_t textDecoration;

  NW_LMgr_Box_t *child;

  /* Change the state */

  if (thisObj->blinkState) {

    thisObj->blinkState = NW_FALSE;

  }

  else {

    thisObj->blinkState = NW_TRUE;

  }

  /* Refresh the tree */

    visitor =

      NW_LMgr_ContainerBox_GetBoxVisitor(thisObj);

    NW_THROW_OOM_ON_NULL (visitor, status);

  /* Iterate through all children */

  child = NW_LMgr_BoxVisitor_NextBox(visitor, NULL);

  while ((child = NW_LMgr_BoxVisitor_NextBox(visitor, NULL)) != NULL) {

    /* Refresh all text boxes */

    if (NW_Object_IsInstanceOf(child, &NW_LMgr_AbstractTextBox_Class)) {

      /* Does the box blink? */

      textDecoration.token = NW_CSS_PropValue_none;

      NW_LMgr_Box_GetPropertyValue(child, NW_CSS_Prop_textDecoration, 

                                   NW_CSS_ValueType_Token, &textDecoration);

      /* Refresh */

      if ((textDecoration.token == NW_CSS_PropValue_blink) || 

          (textDecoration.token == NW_CSS_PropValue_blinkUnderline))

      {

        status = NW_LMgr_Box_Refresh(child);

	      _NW_THROW_ON_ERROR(status);

      }

    }

  }

  } NW_CATCH (status) {

  } NW_FINALLY {

  NW_Object_Delete(visitor);

  return status;

  } NW_END_TRY

}

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

static

TBrowserStatusCode

NW_LMgr_RootBox_BlinkCallback (void *timerData)

{

  NW_TRY (status) {

  NW_LMgr_RootBox_t *thisObj;

  /* cast timerData to a box */

  thisObj = NW_LMgr_RootBoxOf (timerData);

  NW_ASSERT (thisObj);

  /* make sure it is a RootBox */

  NW_ASSERT (NW_Object_IsClass (thisObj, &NW_LMgr_RootBox_Class));

  /* If the display is suspended, do nothing */

  if (!thisObj->hasFocus) {

    return KBrsrSuccess;

  }

  /* i-mode HTML Elements CUIS 28.0 limits blinks to 16 */

  if (thisObj->blinkState == NW_FALSE) {

    thisObj->blinkCount--;

    if (thisObj->blinkCount == 0) {

      NW_Object_Delete (thisObj->blinkTimer);

      thisObj->blinkTimer = NULL;

      thisObj->isBlinking = NW_FALSE;

      return KBrsrSuccess;

    }

  }

  status = NW_LMgr_RootBox_Blink(thisObj);

    _NW_THROW_ON_ERROR (status);

} NW_CATCH (status) {

  } NW_FINALLY {

  return status;

  } NW_END_TRY

}

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

   static data

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

const

NW_LMgr_RootBox_Class_t  NW_LMgr_RootBox_Class = {

  { /* NW_Object_Core          */

    /* super                   */ &NW_LMgr_BidiFlowBox_Class,

    /* queryInterface          */ _NW_Object_Base_QueryInterface

  },

  { /* NW_Object_Base          */

    /* interfaceList           */ NULL

  },

  { /* NW_Object_Dynamic       */

    /* instanceSize            */ sizeof (NW_LMgr_RootBox_t),

    /* construct               */ _NW_LMgr_RootBox_Construct,

    /* destruct                */ _NW_LMgr_RootBox_Destruct

  },

  { /* NW_LMgr_Box             */

    /* split                   */ _NW_LMgr_Box_Split,

    /* resize                  */ _NW_LMgr_Box_Resize,

  /* postResize                */ _NW_LMgr_Box_PostResize,

    /* getMinimumContentSize   */ _NW_LMgr_Box_GetMinimumContentSize,

    /* hasFixedContentSize     */ _NW_LMgr_Box_HasFixedContentSize,

    /* constrain               */ _NW_LMgr_Box_Constrain,

    /* draw                    */ _NW_LMgr_Box_Draw,

    /* render                  */ _NW_LMgr_RootBox_Render,

    /* getBaseline             */ _NW_LMgr_ContainerBox_GetBaseline,

    /* shift                   */ _NW_LMgr_ContainerBox_Shift,

    /* clone                   */ _NW_LMgr_ContainerBox_Clone

  },

  { /* NW_LMgr_ContainerBox    */

    /* unused                  */ NW_Object_Unused

  },

  { /* NW_LMgr_FormatBox       */

    /* applyFormatProps        */ _NW_LMgr_FlowBox_ApplyFormatProps

  },

  { /* NW_LMgr_FlowBox         */

    /* unused                  */ NW_Object_Unused

  },

  { /* NW_LMgr_BidiFlowBox       */

    /* unused                  */ NW_Object_Unused

  },

  { /* NW_LMgr_RootBox         */

    /* unused                  */ NW_Object_Unused

  }

};

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

   virtual methods

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

TBrowserStatusCode

_NW_LMgr_RootBox_Construct (NW_Object_Dynamic_t* dynamicObject,

                                 va_list* argp)

{

  NW_LMgr_RootBox_t* thisObj;

  /* for convenience */

  thisObj = NW_LMgr_RootBoxOf (dynamicObject);

  NW_TRY (status) {

    NW_HED_AppServices_t* appServices;

    /* invoke our superclass constructor */

    status = _NW_LMgr_ContainerBox_Construct (dynamicObject, argp);

      if (status != KBrsrSuccess) {

        return status;

      }

    appServices = va_arg (*argp, NW_HED_AppServices_t*);

    thisObj->appServices = appServices;

    /* We must generate the cache later */

    thisObj->renderFromCache = NW_FALSE;

    thisObj->renderingState = NW_LMgr_RootBox_RenderUninitialized;

    /* Allocate the float vectors */

    thisObj->placedFloats = (NW_ADT_DynamicVector_t*)

      NW_ADT_ResizableVector_New(sizeof (NW_LMgr_Box_t*), 10, 5 );

    NW_THROW_OOM_ON_NULL (thisObj->placedFloats, status);

    thisObj->pendingFloats = (NW_ADT_DynamicVector_t*)

      NW_ADT_ResizableVector_New(sizeof (NW_LMgr_Box_t*), 10, 5 );

    NW_THROW_OOM_ON_NULL (thisObj->pendingFloats, status);

    thisObj->positionedAbsObjects = (NW_ADT_DynamicVector_t*)

      NW_ADT_ResizableVector_New(sizeof (NW_LMgr_Box_t*), 10, 5 );

    NW_THROW_OOM_ON_NULL (thisObj->positionedAbsObjects, status);

    thisObj->iPositionedBoxesPlaced = NW_FALSE;

    // allocate the vector

    thisObj->iOutOfViewListeners = (NW_ADT_DynamicVector_t*)

      NW_ADT_ResizableVector_New(sizeof (NW_Image_Epoc32Simple_t*), 5, 2 );

    NW_THROW_OOM_ON_NULL (thisObj->iOutOfViewListeners, status);

    /* create canned images */

    thisObj->cannedImages = NW_Image_CannedImages_New();

    // 

    thisObj->outstandingImageOpenings = 0;

    thisObj->needsRelayout = NW_FALSE;

    thisObj->focusBox = NULL;

    // initiate cached settings

    thisObj->iSmallScreenOn = NW_Settings_GetVerticalLayoutEnabled();

    thisObj->iWrapEnabled = NW_Settings_GetTextWrapEnabled();

    // unset. initialize during the first IsPageRTL() call

    thisObj->iIsPageRTL = -1;

    thisObj->iYScrollChange = 0;

  } NW_CATCH (status) {

    NW_Object_Delete(thisObj->placedFloats);

    NW_Object_Delete(thisObj->pendingFloats);

    NW_Object_Delete(thisObj->positionedAbsObjects);

    NW_Object_Delete(thisObj->iOutOfViewListeners);

  } NW_FINALLY {

  return status;

  } NW_END_TRY

}

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

void

_NW_LMgr_RootBox_Destruct (NW_Object_Dynamic_t* dynamicObject)

{

  NW_LMgr_RootBox_t* thisObj;

  /* for convenience */

  thisObj = NW_LMgr_RootBoxOf (dynamicObject);

  /* Delete the float vectors */

  (void) NW_ADT_DynamicVector_Clear(thisObj->placedFloats);

  (void) NW_ADT_DynamicVector_Clear(thisObj->pendingFloats);

  (void) NW_ADT_DynamicVector_Clear(thisObj->positionedAbsObjects);

  (void) NW_ADT_DynamicVector_Clear(thisObj->iOutOfViewListeners);

  NW_Object_Delete(thisObj->placedFloats);

  NW_Object_Delete(thisObj->pendingFloats);

  NW_Object_Delete(thisObj->positionedAbsObjects);

  NW_Object_Delete(thisObj->iOutOfViewListeners);

  /* Just in case:  this will delete the cache vectors  */

  NW_LMgr_RootBox_InvalidateCache(thisObj);

  /* Destroy the blink timer */

  if (thisObj->blinkTimer != NULL) {

    NW_Object_Delete (thisObj->blinkTimer);

  }

  /* destroy canned images */

  if (thisObj->cannedImages) {

    NW_Object_Delete(thisObj->cannedImages);

  }

}  

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

TBrowserStatusCode

_NW_LMgr_RootBox_Render (NW_LMgr_Box_t* box,

                         CGDIDeviceContext* deviceContext,

                         NW_GDI_Rectangle_t* clipRect,

                         NW_LMgr_Box_t* currentBox,

                         NW_Uint8 flags, 

                         NW_Bool* hasFocus,

                         NW_Bool* skipChildren,

                         NW_LMgr_RootBox_t* rootBox )

{

  NW_LMgr_RootBox_t *thisObj = NW_LMgr_RootBoxOf(box);

  NW_ADT_Vector_Metric_t floatCount, index;

  NW_LMgr_Box_t *floatBox;

  NW_GDI_Rectangle_t oldClip;

  NW_Bool tempHasFocus;

  NW_REQUIRED_PARAM( hasFocus );

  NW_REQUIRED_PARAM( rootBox );

  NW_REQUIRED_PARAM( skipChildren );

  // Save the old clip rect 

  oldClip = deviceContext->ClipRect();

  NW_TRY (status) 

    {

    NW_REQUIRED_PARAM(flags);

    if( thisObj->renderFromCache ) 

      {

      NW_LMgr_Box_t *childBox = NULL;

      NW_GDI_Rectangle_t childClipRect;

      NW_ADT_Vector_Metric_t boxCount, boxIndex;

      NW_LMgr_EventHandler_t *eventHandler = NULL;

      // Special handling for active containers 

      if (NW_Object_IsInstanceOf(currentBox, &NW_LMgr_ActiveContainerBox_Class)) 

        {

        eventHandler = NW_LMgr_ActiveContainerBoxOf(currentBox)->eventHandler;

        }

      // Go through the cached boxes 

      boxCount = NW_ADT_Vector_GetSize(thisObj->renderedBoxes);

      NW_ADT_Vector_Metric_t clipsCount = NW_ADT_Vector_GetSize(thisObj->renderedClips);

      for (boxIndex = 0; boxIndex < boxCount; boxIndex++) 

        {

        NW_ASSERT(boxIndex < clipsCount);

        childBox =

          *(NW_LMgr_Box_t**) NW_ADT_Vector_ElementAt (thisObj->renderedBoxes, boxIndex);

          childClipRect =

            *(NW_GDI_Rectangle_t*) NW_ADT_Vector_ElementAt (thisObj->renderedClips, boxIndex);

        /* Special handling for active containers */

        if (NW_Object_IsInstanceOf(childBox, &NW_LMgr_ActiveContainerBox_Class)) 

          {

          if (NW_LMgr_ActiveContainerBoxOf(childBox)->eventHandler

              == eventHandler) 

            {

            currentBox = childBox;

            }

          }

        tempHasFocus = NW_FALSE;

        /* Are we in focus */

        // check if childbox is the current box

        tempHasFocus = ( childBox == currentBox );

        if( !tempHasFocus )

          {

          // Find out if the box or the parent is in focus 

          // if the currentBox is a container, then check its childern to see if 'childBox' is

          // one of them.

          if( currentBox && NW_Object_IsDerivedFrom( currentBox, &NW_LMgr_ContainerBox_Class) )

            {

            //

            NW_LMgr_BoxVisitor_t boxVisitor;

            NW_LMgr_Box_t* tempBox = NULL;

			      NW_LMgr_BoxVisitor_Initialize( &boxVisitor, (NW_LMgr_Box_t*)currentBox );

			      while( ( tempBox = NW_LMgr_BoxVisitor_NextBox( &boxVisitor, NULL ) ) != NULL ) 

              {

              //

              if( childBox == tempBox ) 

                {

                tempHasFocus = NW_TRUE;

                break;

                }

				      }

            }

          }

        // Now set the clip and draw 

        deviceContext->SetClipRect( &childClipRect);

        status = NW_LMgr_Box_Draw(childBox, deviceContext, tempHasFocus );

        NW_THROW_ON_ERROR(status);

        }

      }

    else 

      {

      // In the case of partial render first chunk, following render immediately 

      // gotoActiveBox will call render again and we should take advantage of 

      // render cache; after partial render complete, all the scrolling will call

      // render and should render from the cache

      if ( !thisObj->partialRender || 

         (thisObj->partialRender && thisObj->renderingState == NW_LMgr_RootBox_RenderFirstChunk ) )

        {

        // Allocate the render cache 

      thisObj->renderedBoxes = (NW_ADT_DynamicVector_t*)

        NW_ADT_ResizableVector_New(sizeof (NW_LMgr_Box_t*), 10, 5 );

      NW_THROW_OOM_ON_NULL (thisObj->renderedBoxes, status);

      thisObj->renderedClips = (NW_ADT_DynamicVector_t*)

        NW_ADT_ResizableVector_New(sizeof (NW_GDI_Rectangle_t), 10, 5 );

      NW_THROW_OOM_ON_NULL (thisObj->renderedClips, status);

        // We will generate the cache  

        thisObj->renderFromCache = NW_TRUE;

        } 

      else

        {

        thisObj->renderedBoxes = NULL;

        thisObj->renderedClips = NULL;

        thisObj->renderFromCache = NW_FALSE;

        }

      // Invoke the superclass to render the tree 

      // rootbox never has focus.

      status =

        BoxRender_Render (box, deviceContext, clipRect, currentBox, 0, NW_FALSE, thisObj);

      _NW_THROW_ON_ERROR (status);

      // Draw any floats 

      floatCount = NW_ADT_Vector_GetSize(thisObj->placedFloats);

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

        {  

        floatBox = *(NW_LMgr_Box_t**)

		    NW_ADT_Vector_ElementAt (thisObj->placedFloats, index);

        NW_ASSERT(floatBox != NULL);

        status = BoxRender_Render (floatBox, deviceContext, clipRect, currentBox,

                                     NW_LMgr_Box_Flags_DrawFloats, NW_FALSE, thisObj);

        _NW_THROW_ON_ERROR (status);

        }

      // Start the blink timer 

      if ((thisObj->blinkTimer == NULL) && thisObj->isBlinking) 

        {

          thisObj->blinkTimer = NW_System_Timer_New (NW_LMgr_RootBox_BlinkCallback,

                                                     thisObj, 500, NW_TRUE);

          NW_THROW_OOM_ON_NULL (thisObj->blinkTimer, status);

          thisObj->blinkCount = NW_ISA_BLINK_LIMIT;

        }

      }

    } 

  NW_CATCH (status) 

    {

    } 

  NW_FINALLY 

    {    

    // ReSet the new clip rect 

    deviceContext->SetClipRect( &oldClip);

    return status;

    } 

  NW_END_TRY

  }

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

   public/protected final methods

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

CGDIDeviceContext*

NW_LMgr_RootBox_GetDeviceContext (NW_LMgr_RootBox_t* thisObj)

{

  /* parameter assertion block */

  NW_ASSERT (NW_Object_IsInstanceOf (thisObj, &NW_LMgr_RootBox_Class));

  if (thisObj->boxTreeListener != NULL) {

    return thisObj->boxTreeListener->GetDeviceContext ();

  }

  return NULL;

}

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

NW_LMgr_Box_t*

NW_LMgr_RootBox_GetCurrentBox (NW_LMgr_RootBox_t* thisObj)

{

  /* parameter assertion block */

  NW_ASSERT (NW_Object_IsInstanceOf (thisObj, &NW_LMgr_RootBox_Class));

  if (thisObj->boxTreeListener != NULL) {

    return thisObj->boxTreeListener->GetCurrentBox ();

  }

  return NULL;

}

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

void

NW_LMgr_RootBox_BoxTreeDestroyed (NW_LMgr_RootBox_t* thisObj)

{

  /* parameter assertion block */

  NW_ASSERT (NW_Object_IsInstanceOf (thisObj, &NW_LMgr_RootBox_Class));

  /* Stop any blinking */

  thisObj->isBlinking = NW_FALSE;

  /* Destroy the blink timer */

  if (thisObj->blinkTimer != NULL) {

    NW_Object_Delete (thisObj->blinkTimer);

    thisObj->blinkTimer = NULL;

  }

  if (thisObj->boxTreeListener != NULL) {

    thisObj->boxTreeListener->BoxTreeDestroyed ();

  }

  thisObj->outstandingImageOpenings = 0;

  thisObj->needsRelayout = NW_FALSE;

  thisObj->renderingState = NW_LMgr_RootBox_RenderUninitialized;

  // clear RTL

  thisObj->iIsPageRTL = -1;

  thisObj->iHasGridModeTables = NW_FALSE;

  NW_LMgr_RootBox_InvalidateCache(thisObj);

}

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

TBrowserStatusCode