/*

* Copyright (c) 2003 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:  Handles scrolling operations of the view

*

*/

// INCLUDE FILES

#include <e32def.h>  // To avoid NULL redefine warning (no #ifndef NULL)

#include <nwx_settings.h>

#include "MVCScroll.h"

#include "MVCView.h"

#include "nw_evt_tabevent.h"

#include "nw_lmgr_activecontainerbox.h"

#include "nw_gdi_utils.h"

#include "nw_lmgr_slavepropertylist.h"

#include "nw_lmgr_simplepropertylist.h"

#include "nw_lmgr_rootbox.h"

#include "nwx_logger.h"

#include "nw_lmgr_areabox.h"

#include "nw_evt_scrollevent.h"

// CONSTANTS

#define SMALL_SCROLL 16

#define NORMAL_SCROLL 18

#define LARGE_SCROLL 21

// ============================= LOCAL FUNCTIONS ===============================

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------

// CMVCScroll::NewL

// Two-phased constructor.

// -----------------------------------------------------------------------------

//

CMVCScroll* 

CMVCScroll::NewL(CView* view)

{

	CMVCScroll* scroll = new (ELeave) CMVCScroll(view);

	CleanupStack::PushL(scroll);

	CleanupStack::Pop(); // scroll

	return scroll;

}

// -----------------------------------------------------------------------------

// CMVCScroll::CMVCScroll

// Symbian 2nd phase constructor can leave.

// -----------------------------------------------------------------------------

//

CMVCScroll::CMVCScroll(CView* view) : iView(view)

{

}

// -----------------------------------------------------------------------------

// CMVCScroll::~CMVCScroll

// Destructor.

// -----------------------------------------------------------------------------

//

CMVCScroll::~CMVCScroll()

{

}

// -----------------------------------------------------------------------------

// IsBoxVisibleInEither

// Description: Helper function to test if box is visible in either rectangles             

// Returns: TBool : NW_TRUE if the box is visible within the two bounds

//                  NW_FALSE if the box is NOT visible within the bounds

// -----------------------------------------------------------------------------

//

TBool

CMVCScroll::IsBoxVisibleInEither (const NW_LMgr_Box_t* box,

                                  NW_GDI_Rectangle_t* bounds1,

                                  NW_GDI_Rectangle_t* bounds2)

{

  NW_ASSERT(iView != NULL);

  NW_ASSERT(box != NULL);

  NW_ASSERT(bounds1 != NULL);

  NW_ASSERT(bounds2 != NULL);

  if ( iView->IsBoxVisible(box, bounds1) ||

       iView->IsBoxVisible(box, bounds2) ) 

  {

    return NW_TRUE;

  }

  else 

  {

    return NW_FALSE;

  }

}

// -----------------------------------------------------------------------------

// This only get range of the box, not considering sibling or master box's range

//

void 

CMVCScroll::GetBoxRangeRestrict (NW_LMgr_Box_t* box, 

                                 NW_GDI_Metric_t* referenceY, NW_GDI_Metric_t* refY2,

                                 NW_GDI_Metric_t* referenceX, NW_GDI_Metric_t* refX2 )

{

  NW_ASSERT(box != NULL);

  if (NW_Object_IsClass(box, &NW_LMgr_AreaBox_Class)) 

  {

    NW_GDI_Rectangle_t areaBoxBounds = NW_LMgr_AreaBox_GetBounds(box);

    *referenceY = areaBoxBounds.point.y;

    *refY2 = (NW_GDI_Metric_t)(areaBoxBounds.point.y + areaBoxBounds.dimension.height);

    *referenceX = areaBoxBounds.point.x;

    *refX2 = (NW_GDI_Metric_t)(areaBoxBounds.point.x + areaBoxBounds.dimension.width);

  }

  else

  {

    NW_GDI_Rectangle_t boxBounds = NW_LMgr_Box_GetDisplayBounds( box );   

    *referenceY = boxBounds.point.y;

    *refY2 = (NW_GDI_Metric_t)(boxBounds.point.y + boxBounds.dimension.height);

    *referenceX = boxBounds.point.x;

    *refX2 = (NW_GDI_Metric_t)(boxBounds.point.x + boxBounds.dimension.width);

  }

  return;

}

// -----------------------------------------------------------------------------

// In case of non-split, simply box's range will be returned

//

void 

CMVCScroll::GetMasterBoxRange (NW_LMgr_Box_t* box, 

                               NW_GDI_Metric_t* referenceY, NW_GDI_Metric_t* refY2,

                               NW_GDI_Metric_t* referenceX, NW_GDI_Metric_t* refX2 )

{

  NW_LMgr_Box_t *masterBox = NULL;

  NW_LMgr_PropertyList_t* propList;

  NW_ASSERT(box != NULL);

  propList = NW_LMgr_Box_PropListGet(box);

  if (NW_Object_IsInstanceOf(propList, &NW_LMgr_SlavePropertyList_Class))

  {

    masterBox = 

      NW_LMgr_SlavePropertyList_GetMasterBox(NW_LMgr_SlavePropertyListOf(propList));

  }

  else

  {

    masterBox = box;

  }

  NW_ASSERT(masterBox != NULL);

  GetBoxRangeRestrict( masterBox, referenceY, refY2, referenceX, refX2 );

  return;

}

// -----------------------------------------------------------------------------

// This method doesn't return the first sibling box with width and height as 0;

// instead, the sibling whose width and height are not 0 and is right next to the 

// first sibling box or the master box if no other sibling exists will be returned.

// In case of non-split, simply the box will be returned.

// Does not return NULL.

//

NW_LMgr_Box_t*

CMVCScroll::GetFirstSiblingBox (NW_LMgr_Box_t* box)

{

  NW_LMgr_Box_t *tempBox = NULL;

  NW_LMgr_Box_t *firstBox = NULL;

  NW_LMgr_PropertyList_t* propList;

  NW_LMgr_Property_t prop;

  NW_ASSERT(box != NULL);

  propList = NW_LMgr_Box_PropListGet(box);

  /* ensure box is a master box */

  if (NW_Object_IsInstanceOf(propList, &NW_LMgr_SlavePropertyList_Class))

  {

    box = 

      NW_LMgr_SlavePropertyList_GetMasterBox(NW_LMgr_SlavePropertyListOf(propList));

    propList = NW_LMgr_Box_PropListGet(box);

  }

  /* Get first box */

  do

  {

    prop.value.object = NULL;

    if( propList )

    {

      (void)NW_LMgr_PropertyList_Get(propList, NW_CSS_Prop_sibling, &prop);

      /* If we come back in a loop to the master box, then stop */

      if (prop.value.object == box)

      {

        /* This occurs when only one slave box exist and its width and height is 0 */

        if (firstBox == NULL)

        {

          firstBox = box;

        }

        break;

      }

      if(prop.value.object != NULL)

      {

        tempBox = NW_LMgr_BoxOf(prop.value.object);

        propList = NW_LMgr_Box_PropListGet(NW_LMgr_BoxOf(tempBox));

        NW_ASSERT (NW_Object_IsInstanceOf (propList, &NW_LMgr_PropertyList_Class));

        /* ignore the sibling box with width and height as 0 */

        NW_GDI_Rectangle_t boxBounds = NW_LMgr_Box_GetDisplayBounds( tempBox );   

        if( boxBounds.dimension.height != 0 && boxBounds.dimension.width != 0 )

        {

          firstBox = tempBox;

        }

      } else

      /* If it's null, it means non-split case */

      {

        firstBox = box;  // break out because prop.value.object == NULL

      }

    }

  }while(prop.value.object != NULL);

  if(firstBox == NULL)

  {

    firstBox = box;

  }

  return firstBox;

}

// -----------------------------------------------------------------------------

// In case of non-split, simply box's range will be returned;

//

void 

CMVCScroll::GetFirstSiblingBoxRange (NW_LMgr_Box_t* box, 

                                     NW_GDI_Metric_t* referenceY, NW_GDI_Metric_t* refY2,

                                     NW_GDI_Metric_t* referenceX, NW_GDI_Metric_t* refX2 )

{

  NW_LMgr_Box_t *firstBox = NULL;

  NW_ASSERT(box != NULL);

  firstBox = GetFirstSiblingBox(box);

  GetBoxRangeRestrict( firstBox, referenceY, refY2, referenceX, refX2 );

  return;

}

// -----------------------------------------------------------------------------

NW_Bool

CMVCScroll::HowBigIsBoxVisible ( const NW_LMgr_Box_t* box,

                                 NW_GDI_Rectangle_t* bounds,

                                 NW_GDI_Rectangle_t* overlap )

{

  NW_GDI_Rectangle_t boxBounds;

  /* parameter assertion block */

  NW_ASSERT (iView != NULL);

  NW_ASSERT (box != NULL);

  if (NW_Object_IsClass(box, &NW_LMgr_AreaBox_Class)) 

  {

    boxBounds = NW_LMgr_AreaBox_GetBounds( NW_LMgr_BoxOf( box ) );

  }

  else

  {

    boxBounds = NW_LMgr_Box_GetDisplayBounds( NW_LMgr_BoxOf( box ) );   

  }

  /* below check handles the case where the box is at least has sHVisibleAmt and sVVisibleAmt 

   * inside the display bounds

   */

  if (NW_GDI_Rectangle_Cross(&boxBounds, bounds, overlap)) 

  {

    if ((overlap->dimension.width >= iView->GetVisibleAmt().width) &&

        (overlap->dimension.height >= iView->GetVisibleAmt().height)) 

    {

      return NW_TRUE;

    }

    // If the box is smaller than visibleAmt, then we should go to that link

    else if ((overlap->dimension.width == boxBounds.dimension.width) &&

      (overlap->dimension.height == boxBounds.dimension.height))

    {

      return NW_TRUE;

    }

  }

  return NW_FALSE;

}

// -----------------------------------------------------------------------------

NW_Bool

CMVCScroll::GetScrollDownBounds ( CView* view,

                                  NW_GDI_Rectangle_t* scrolledBounds )

{

  const NW_GDI_Dimension2D_t* displaySize;

  NW_GDI_Dimension2D_t canvasSize;

  NW_Bool scroll;

  // get the display and cavas size

  displaySize =

    &(view->GetDeviceContext()->DisplayBounds()->dimension);

  TBrowserStatusCode status = NW_LMgr_RootBox_GetExtents (view->GetRootBox(), &canvasSize);

  NW_ASSERT (status == KBrsrSuccess);

  // can scroll 

  if (scrolledBounds->point.y + view->GetScrollAmt().height + displaySize->height 

      <= canvasSize.height) 

  {

    scrolledBounds->point.y = 

        (NW_GDI_Metric_t)(scrolledBounds->point.y + view->GetScrollAmt().height);

    scroll = NW_TRUE;

  } 

  else if (scrolledBounds->point.y + displaySize->height < canvasSize.height)

  {

    scrolledBounds->point.y = 

        (NW_GDI_Metric_t)(canvasSize.height - displaySize->height);

    scroll = NW_TRUE;

  } 

  else

  {

    scroll = NW_FALSE;

  }

  return scroll;

}

// -------------------------------------------------------------------------

NW_Bool

CMVCScroll::GetScrollUpBounds ( CView* view,

                                NW_GDI_Rectangle_t* scrolledBounds )

{

  NW_Bool scroll;

  // can scroll

  if (scrolledBounds->point.y - view->GetScrollAmt().height >= 0) 

  {

    scrolledBounds->point.y = 

        (NW_GDI_Metric_t)(scrolledBounds->point.y - view->GetScrollAmt().height);

    scroll = NW_TRUE;

  } 

  else if (scrolledBounds->point.y > 0) 

  {

    scrolledBounds->point.y = 0;

    scroll = NW_TRUE;

  } 

  else

  {

    scroll = NW_FALSE;

  }

  return scroll;

}

// -------------------------------------------------------------------------

NW_LMgr_Box_t*

CMVCScroll::GetTabIndex( const NW_LMgr_Box_t* oldBox, 

                         NW_Bool nextIndex, 

                         NW_Int32* currentTabIndex )

{

  NW_Bool found = NW_FALSE;

  NW_LMgr_Box_t* box = NULL;

  NW_ADT_Vector_t* tabListVector = NW_ADT_VectorOf( iView->GetTabList() );

  NW_Uint16 size = NW_ADT_Vector_GetSize( tabListVector );

  NW_ADT_Vector_Metric_t i;

  // if oldBox is NULL then return the first item in the list.

  if( oldBox == NULL )

  {

    i = 0;

    found = NW_TRUE;

  }

  else

  {

    // if the currentTabIndex is provided then get the next item in the list

    if( *currentTabIndex != -1 )

    {

      i = (NW_ADT_Vector_Metric_t)*currentTabIndex;

      // skip to the previous/next box

      i = (NW_ADT_Vector_Metric_t) (( nextIndex == NW_TRUE ) ? ( i + 1 ) : ( i - 1 ));

      found = NW_TRUE;

    }

    else

    {

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

      {

        box = (NW_LMgr_Box_t*)*NW_ADT_Vector_ElementAt( tabListVector, i );

        if( oldBox == box ) 

        {

          // skip to the previous/next box

          i = (NW_ADT_Vector_Metric_t) (( nextIndex == NW_TRUE ) ? ( i + 1 ) : ( i - 1 ));

          found = NW_TRUE;

          break;

        }

      }

    }

  }

  // if the box was found and index is valid

  if( found == NW_TRUE && i < size )

  {

    box = (NW_LMgr_Box_t*)*

      NW_ADT_Vector_ElementAt( tabListVector, i );

    *currentTabIndex = i;

  }

  else

  {

    box = NULL;

    *currentTabIndex = -1;

  }

  return box;

}

// -------------------------------------------------------------------------

NW_LMgr_Box_t*

CMVCScroll::GetNextEventListener (NW_LMgr_BoxVisitor_t* boxVisitor)

{

    NW_LMgr_Box_t* box = NULL;

    NW_GDI_Rectangle_t boxBounds;

    while ((box = NW_LMgr_BoxVisitor_NextBox (boxVisitor, NULL)) != NULL) {

      NW_LMgr_IEventListener_t* eventListener;

      /* we are only looking for boxes implementing the NW_LMgr_IEventListener

         interface */

      eventListener = (NW_LMgr_IEventListener_t*)NW_Object_QueryInterface (box, &NW_LMgr_IEventListener_Class);

      if (eventListener == NULL) {

        continue;

      }

      /* If activeContainerBox has zero length or zero width, we skip this

         activeContainerBox. This happens when activeContaninerBox only has

         one breakBox child */

      if (NW_Object_IsInstanceOf (box, &NW_LMgr_ActiveContainerBox_Class)) {

          boxBounds = NW_LMgr_Box_GetDisplayBounds(box);

          if (boxBounds.dimension.width == 0 || boxBounds.dimension.height == 0) {

              continue;

          }

      }

      return (box);

    }

    return (NULL);

}

// ------------------------------------------------------------------------- 

void

CMVCScroll::GetFirstVisible(NW_LMgr_Box_t* box, 

                         NW_LMgr_Box_t** firstVisible )

{

  NW_LMgr_PropertyList_t* propList;

  NW_LMgr_PropertyList_t* masterPropList;

  NW_LMgr_Box_t* masterBox = NULL;

  NW_LMgr_Box_t* tempBox = NULL;

  NW_LMgr_Property_t prop;

  NW_Bool found = NW_FALSE;

  NW_GDI_Rectangle_t viewBounds;

  NW_ASSERT( box != NULL );

  NW_ASSERT( iView != NULL );

  viewBounds = *(iView->GetDeviceContext()->DisplayBounds());

  viewBounds.point = *(iView->GetDeviceContext()->Origin());

  // let's check first if the box is visible

  if( iView->IsBoxVisible( box, &viewBounds ) )

  {

    // we've got the box

    tempBox = box;

    found = NW_TRUE;

  }

  else

  {

    propList = NW_LMgr_Box_PropListGet( box );

    if( propList != NULL )

    {

      // first check if we are on a master or a slave box

      if( NW_Object_IsInstanceOf( propList, &NW_LMgr_SlavePropertyList_Class ) )

      {

        // this is a slave

        // get the master's property list

        masterBox = NW_LMgr_SlavePropertyList_GetMasterBox( propList );

      }

      else

      {

        masterBox = box;

      }

      // we need the master property list to check if we've got a chain here

      masterPropList = NW_LMgr_Box_PropListGet( masterBox );

      propList = NULL;

      if( NW_LMgr_PropertyList_Get( masterPropList, NW_CSS_Prop_sibling, &prop ) == KBrsrSuccess )

      {

        // get the next to the master box

        if( prop.value.object != NULL )

        {

          tempBox = NW_LMgr_BoxOf( prop.value.object );

          if( tempBox != NULL )

          {

            // this must be a slave property list

            propList = NW_LMgr_Box_PropListGet( NW_LMgr_BoxOf( tempBox ) );

          }

        }

      }

      else

      {

        // this is not a chain

      }

      // let's go through the chain

      if( propList )

      {

        // at this point tempbox holds the box next to the master

        do

        {

          // check if this box is visible

          if( iView->IsBoxVisible( tempBox, &viewBounds ) )

          {

            // we've got the box