/*

* Copyright (c) 2003-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:  Box class associated with the handling image maps

*

*/

// INCLUDE FILES

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

#include "nw_lmgr_imagemapboxi.h"

#include "nw_image_cannedimages.h"

#include "nw_image_epoc32cannedimage.h"

#include "nw_image_virtualimage.h"

#include "nw_lmgr_rootbox.h"

#include "nw_text_ucs2.h"

#include "nw_lmgr_activecontainerbox.h"

#include "nw_lmgr_areabox.h"

#include "nwx_settings.h"

#include "nw_evt_controlkeyevent.h"

#include "nw_evt_focusevent.h"

#include "nw_evt_scrollevent.h"

#include "nw_evt_activateevent.h"

#include "nw_hed_hedeventhandler.h"

#include "nw_lmgr_animatedimageboxi.h"

#include "nw_lmgr_simplepropertylist.h"

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

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

// NW_LMgr_ImageMapBox_InitializeBorder

// Method which initializes the border width, color, and style to set values.

//   This method is used by the DrawBorder method.

// Returns: TBrowserStatusCode

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

//

void

NW_LMgr_ImageMapBox_InitializeBorder(CGDIDeviceContext* aDeviceContext,

                                     NW_LMgr_FrameInfo_t& aBorderWidth,

                                     NW_LMgr_FrameInfo_t& aBorderColor,

                                     NW_LMgr_FrameInfo_t& aBorderStyle,

                                     NW_GDI_Color_t& aInitialBgColor,

                                     NW_GDI_Color_t& aColor)

{

  aBorderWidth.top    = (NW_GDI_Metric_t)NW_LMgr_Box_MediumBorderWidth;

  aBorderWidth.bottom = (NW_GDI_Metric_t)NW_LMgr_Box_MediumBorderWidth;

  aBorderWidth.left   = (NW_GDI_Metric_t)NW_LMgr_Box_MediumBorderWidth;

  aBorderWidth.right  = (NW_GDI_Metric_t)NW_LMgr_Box_MediumBorderWidth;

  aBorderColor.bottom = NW_GDI_Color_Blue;

  aBorderColor.left = NW_GDI_Color_Blue;

  aBorderColor.right = NW_GDI_Color_Blue;

  aBorderColor.top = NW_GDI_Color_Blue;

  aBorderStyle.bottom = NW_CSS_PropValue_solid;

  aBorderStyle.left = NW_CSS_PropValue_solid;

  aBorderStyle.right = NW_CSS_PropValue_solid;

  aBorderStyle.top = NW_CSS_PropValue_solid;

  aInitialBgColor = aDeviceContext->BackgroundColor();

  aColor = aBorderColor.bottom;

  aDeviceContext->SwitchAgainstBG (&aColor);

  aBorderColor.bottom = aColor;

  aColor = aBorderColor.left;

  aDeviceContext->SwitchAgainstBG (&aColor);

  aBorderColor.left = aColor;

  aColor = aBorderColor.right;

  aDeviceContext->SwitchAgainstBG (&aColor);

  aBorderColor.right = aColor;

  aColor = aBorderColor.top;

  aDeviceContext->SwitchAgainstBG (&aColor);

  aBorderColor.top = aColor;

}

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

// NW_LMgr_ImageMapBox_InitializeImageMapIcon

// This method creates a new image map icon if one does not exist already and

//   returns a pointer to the image.

// Returns: NW_Image_AbstractImage_t*

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

//

TBrowserStatusCode

NW_LMgr_ImageMapBox_InitializeImageMapIcon(NW_LMgr_ImageMapBox_t* thisObj)

  {

  NW_ASSERT(thisObj);

  NW_TRY (status)

    {

    NW_LMgr_RootBox_t* rootBox = NW_LMgr_Box_GetRootBox( thisObj );

    NW_Image_AbstractImage_t* abstractImageMap = (NW_Image_AbstractImage_t*)NW_Image_CannedImages_GetImage( 

     rootBox->cannedImages, NW_Image_ImageMap );

    NW_ASSERT(abstractImageMap);

    // this will be deleted in the destructor

    thisObj->iImageMapIcon = (NW_Image_AbstractImage_t*)NW_Image_Virtual_New( abstractImageMap );

    NW_THROW_OOM_ON_NULL(thisObj->iImageMapIcon, status);

    }

  NW_CATCH (status)

    {

    }

  NW_FINALLY

    {

    return status;

    }

  NW_END_TRY

  }

TBrowserStatusCode

NW_LMgr_ImageMapBox_DrawImageMapIcon(NW_LMgr_ImageMapBox_t* thisObj,

                                     CGDIDeviceContext* deviceContext)

  {

  NW_GDI_Point2D_t imagePos;

  NW_GDI_Dimension3D_t imageSize;

  NW_GDI_Rectangle_t innerRect;

  NW_TRY (status)

    {

    // draw the image map icon on top of the image map

    deviceContext->SetPaintMode (NW_GDI_PaintMode_Copy);

    // if we don't have an image map icon, create one

    if (!thisObj->iImageMapIcon)

      {

      status = NW_LMgr_ImageMapBox_InitializeImageMapIcon(thisObj);

      NW_THROW_ON_ERROR(status);

      }

    // get image size 

    status = NW_Image_AbstractImage_GetSize( thisObj->iImageMapIcon, &imageSize );

    NW_THROW_ON_ERROR(status);

    NW_LMgr_Box_GetInnerRectangle( NW_LMgr_BoxOf(thisObj), &innerRect );

    // do not stretch out image map icon

    if( innerRect.dimension.height < imageSize.height )

        {

        imageSize.height = innerRect.dimension.height;

        }

    if( innerRect.dimension.width < imageSize.width )

        {

        imageSize.width = innerRect.dimension.width;

        }

    imagePos.x = innerRect.point.x + NW_LMgr_Box_MediumBorderWidth;

    imagePos.y = innerRect.point.y + NW_LMgr_Box_MediumBorderWidth;

    status = NW_Image_AbstractImage_DrawScaled( thisObj->iImageMapIcon, 

                                                deviceContext,

                                                &imagePos, 

                                                &imageSize );

    NW_THROW_ON_ERROR(status);

    }

  NW_CATCH (status)

    {

    }

  NW_FINALLY

    {

    return status;

    }

  NW_END_TRY

  }

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

   static data

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

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

static

const

NW_LMgr_IEventListener_Class_t _NW_LMgr_ImageMapBox_IEventListener_Class = {

  { /* NW_Object_Core         */

    /* super                  */ &NW_LMgr_IEventListener_Class,

    /* queryInterface         */ _NW_Object_Interface_QueryInterface

  },

  { /* NW_Object_Interface    */

    /* offset                 */ offsetof (NW_LMgr_ImageMapBox_t, NW_LMgr_IEventListener)

  },

  { /* NW_LMgr_IEventListener */

    /* processEvent           */ _NW_LMgr_ImageMapBox_IEventListener_ProcessEvent

  }

};

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

static

const NW_Object_Class_t* const _NW_LMgr_ImageMapBox_InterfaceList[] = {

  &_NW_LMgr_ImageMapBox_IEventListener_Class,

  NULL

};

// ========================== INTERFACE FUNCTIONS ==============================

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

NW_Uint8

_NW_LMgr_ImageMapBox_IEventListener_ProcessEvent(NW_LMgr_IEventListener_t* eventListener,

                                                 NW_Evt_Event_t* event)

{

  NW_LMgr_ImageMapBox_t* thisObj;

  NW_Uint8 ret = 0;

  // parameter assertion block

  NW_ASSERT (NW_Object_IsInstanceOf (eventListener,

                                     &NW_LMgr_IEventListener_Class));

  NW_ASSERT (NW_Object_IsInstanceOf (event, &NW_Evt_Event_Class));

  // obtain the implementer 

  thisObj = static_cast<NW_LMgr_ImageMapBox_t*>(NW_Object_Interface_GetImplementer (eventListener));

  if (thisObj->eventHandler != NULL) 

  {

    ret = NW_LMgr_EventHandler_ProcessEvent (thisObj->eventHandler,

                                             NW_LMgr_BoxOf (thisObj), 

                                             event);

  }

  return ret;

}

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

const

NW_LMgr_ImageMapBox_Class_t  NW_LMgr_ImageMapBox_Class = {

  { /* NW_Object_Core            */

    /* super                     */ &NW_LMgr_AnimatedImageBox_Class,

    /* queryInterface            */ _NW_Object_Base_QueryInterface

  },

  { /* NW_Object_Base            */

    /* interfaceList             */ _NW_LMgr_ImageMapBox_InterfaceList

  },

  { /* NW_Object_Dynamic         */

    /* instanceSize              */ sizeof (NW_LMgr_ImageMapBox_t),

    /* construct                 */ _NW_LMgr_ImageMapBox_Construct,

    /* destruct                  */ _NW_LMgr_ImageMapBox_Destruct

  },

  { /* NW_LMgr_Box               */

    /* split                     */ _NW_LMgr_ImgContainerBox_Split,

    /* resize                    */ _NW_LMgr_Box_Resize,

    /* postResize                */ _NW_LMgr_Box_PostResize,

    /* getMinimumContentSize     */ _NW_LMgr_ImageMapBox_GetMinimumContentSize,

    /* hasFixedContentSize       */ _NW_LMgr_MediaBox_HasFixedContentSize,

    /* constrain                 */ _NW_LMgr_Box_Constrain,

    /* draw                      */ _NW_LMgr_AnimatedImageBox_Draw,

    /* render                    */ _NW_LMgr_Box_Render,

    /* getBaseline               */ _NW_LMgr_Box_GetBaseline,

    /* shift                     */ _NW_LMgr_Box_Shift,

    /* clone                     */ _NW_LMgr_Box_Clone

  },

  { /* NW_LMgr_MediaBox          */

    /* unused                    */ NW_Object_Unused

  },

  { /* NW_LMgr_ImgContainerBox   */

    /* unused                    */ NW_Object_Unused

  },

  { /* NW_LMgr_AnimatedImageBox  */

    /* unused                    */ NW_Object_Unused

  },

  { /* NW_LMgr_ImageMapBox       */

    /* unused                    */ NW_Object_Unused

  }

};

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

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

// _NW_LMgr_ImageMapBox_Construct

// Description:  The constructor.  

// Returns: TBrowserStatusCode

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

//

TBrowserStatusCode

_NW_LMgr_ImageMapBox_Construct (NW_Object_Dynamic_t* dynamicObject,

                                va_list* argp)

{

  NW_TRY (status) 

  {

    NW_LMgr_ImageMapBox_t* imageBox;

    NW_ASSERT(dynamicObject != NULL);

    // invoke our superclass constructor

    status = _NW_LMgr_AnimatedImageBox_Construct (dynamicObject, argp);

    NW_THROW_ON_ERROR(status);

    // for convenience

    imageBox = NW_LMgr_ImageMapBoxOf( dynamicObject );

    // initialize the member variables

    imageBox->eventHandler = va_arg (*argp, NW_LMgr_EventHandler_t*);

    imageBox->iUrl = va_arg (*argp, NW_Text_t*);

    imageBox->iAreaBoxArrayList = NULL;

    imageBox->iImageMapIcon = NULL;

  } 

  NW_CATCH (status) 

  {

  } 

  NW_FINALLY 

  {

    return status;

  } 

  NW_END_TRY

}

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

// _NW_LMgr_ImageMapBox_Destruct

// Description:  The destructor.  

// Returns: void

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

//

void

_NW_LMgr_ImageMapBox_Destruct (NW_Object_Dynamic_t* dynamicObject)

  {

  NW_LMgr_ImageMapBox_t* thisObj;

  // for convenience 

  thisObj = NW_LMgr_ImageMapBoxOf (dynamicObject);

  // destroy members

  if (thisObj->iAreaBoxArrayList != NULL)

    {

    //

    NW_ADT_Vector_Metric_t arrayIndex;

    NW_ADT_Vector_Metric_t elementSize = NW_ADT_Vector_GetSize( thisObj->iAreaBoxArrayList );

    for( arrayIndex = 0; arrayIndex < elementSize; arrayIndex++ ) 

      {

      NW_LMgr_AreaBox_t* areaBox = *(NW_LMgr_AreaBox_t**)NW_ADT_Vector_ElementAt( thisObj->iAreaBoxArrayList, arrayIndex );

      NW_Object_Delete( areaBox );

      }

    NW_Object_Delete (thisObj->iAreaBoxArrayList);

    thisObj->iAreaBoxArrayList = NULL;

    }

  if (thisObj->iImageMapIcon != NULL)

    {

    NW_Object_Delete( thisObj->iImageMapIcon );

    thisObj->iImageMapIcon = NULL;

    }

  if (thisObj->iUrl != NULL)

    {

    NW_Object_Delete( thisObj->iUrl );

    thisObj->iUrl = NULL;

    }

  if (thisObj->eventHandler != NULL)

    {

  	NW_Object_Delete( thisObj->eventHandler );

  	thisObj->eventHandler = NULL;

    }

  }

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

TBrowserStatusCode

_NW_LMgr_ImageMapBox_GetMinimumContentSize( NW_LMgr_Box_t* box,

                                            NW_GDI_Dimension2D_t* size )

  {

  NW_TRY (status) 

    {

    NW_GDI_Dimension3D_t imageSize;

    NW_LMgr_ImageMapBox_t* thisObj = NW_LMgr_ImageMapBoxOf( box );

    NW_LMgr_RootBox_t* rootBox = NW_LMgr_Box_GetRootBox( box );

    // call the parent's class implementation to get the size of the image map box

    status = _NW_LMgr_ImgContainerBox_GetMinimumContentSize (box, size);

    NW_THROW_ON_ERROR( status );

    // we only want to recalculate the size of the image map box if we are

    // in small screen mode

    if( NW_LMgr_RootBox_GetSmallScreenOn( rootBox ) )

      {

      // now we need to get the size of the icon we are using

      // if we don't have an image map icon, create one

      if (!thisObj->iImageMapIcon)

        {

        status = NW_LMgr_ImageMapBox_InitializeImageMapIcon(thisObj);

        NW_THROW_ON_ERROR(status);

        }

      status = NW_Image_AbstractImage_GetSize( thisObj->iImageMapIcon, &imageSize );

      NW_THROW_ON_ERROR(status);

      // we want to see if the image map box size is less that the icon size plus

      // the size of the borders (upper/lower)

      if (size->height < (imageSize.height + (NW_LMgr_Box_MediumBorderWidth * 2)))

        {

        size->height = (imageSize.height + (NW_LMgr_Box_MediumBorderWidth * 2));

        }

      } 

    }

  NW_CATCH (status) 

    {  

    } 

  NW_FINALLY 

    {

    return status;  

    } 

  NW_END_TRY

  }

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

NW_LMgr_ImageMapBox_t*

NW_LMgr_ImageMapBox_New (NW_ADT_Vector_Metric_t aNumProperties, 

                         NW_Image_AbstractImage_t* aVirtualImage, 

                         NW_Text_t* aAltText, 

                         NW_Bool aBrokenImage,

                         NW_LMgr_EventHandler_t* aEventHandler,

                         NW_Text_t* aUrl)

{

  return (NW_LMgr_ImageMapBox_t*)NW_Object_New (&NW_LMgr_ImageMapBox_Class, 

    aNumProperties, aVirtualImage, aAltText, aBrokenImage, aEventHandler, aUrl );

}

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

void

NW_LMgr_ImageMapBox_SetAreaBoxList (NW_LMgr_ImageMapBox_t* thisObj, 

                                    NW_ADT_DynamicVector_t* aAreaBoxArrayList)

{

  thisObj->iAreaBoxArrayList = aAreaBoxArrayList;

}

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

NW_ADT_DynamicVector_t*

NW_LMgr_ImageMapBox_GetAreaBoxList (NW_LMgr_ImageMapBox_t* thisObj)

{

  return thisObj->iAreaBoxArrayList;

}

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

TBrowserStatusCode

NW_LMgr_ImageMapBox_DrawBorder(NW_LMgr_Box_t* box,

                               CGDIDeviceContext* deviceContext)

  {

  NW_LMgr_FrameInfo_t borderWidth;

  NW_LMgr_FrameInfo_t borderStyle;

  NW_LMgr_FrameInfo_t borderColor;

  NW_GDI_Color_t initialBgColor = 0;

  NW_GDI_Color_t color = 0;

  NW_LMgr_ImageMapBox_t* thisObj = NULL; 

  NW_ADT_Vector_Metric_t arrayIndex;

  NW_ADT_Vector_Metric_t elementSize;

  NW_LMgr_AreaBox_t* areaBox = NULL;

  NW_TRY(status)

    {  

    NW_ASSERT(box != NULL);

    thisObj = NW_LMgr_ImageMapBoxOf( box );

    NW_LMgr_RootBox_t* rootBox = NW_LMgr_Box_GetRootBox(box);

    NW_ASSERT(rootBox);

    NW_HED_AppServices_t* appServices = rootBox->appServices;

    NW_ASSERT(appServices);

    NW_LMgr_ImageMapBox_InitializeBorder(deviceContext,

                                         borderWidth,

                                         borderColor,

                                         borderStyle,

                                         initialBgColor,

                                         color);

    // if we are in vertical layout mode (small screen) then we want to "highlight" the

    // image box and display the image map icon if it has focus, otherwise we are in 

    // normal layout mode and we will want to highlight the area box that has focus

    if( NW_LMgr_RootBox_GetSmallScreenOn( rootBox ) )

      {

      if( NW_LMgr_Box_HasFocus ( NW_LMgr_BoxOf( thisObj ) ) )

        {

        // draw the border around the image map box

        status = NW_LMgr_Box_DrawBorder(NW_LMgr_Box_GetFormatBounds(box), 

                                         deviceContext, 

                                         &borderWidth, 

                                         &borderStyle, 

                                         &borderColor);

        NW_THROW_ON_ERROR(status);

        // draw the image map icon on the top left corner of the image

        status = NW_LMgr_ImageMapBox_DrawImageMapIcon(thisObj,

                                                      deviceContext);

        NW_THROW_ON_ERROR(status);

        }

      }

    else

      {

      // loop through area boxes and see if any are in focus

      NW_ADT_DynamicVector_t* areaBoxArray = NW_LMgr_ImageMapBox_GetAreaBoxList(thisObj);

      // It is possible to have an ImageMapBox with no AreaBoxArray

      // This happens when the usemap id is not present anywhere in the document

      if (areaBoxArray != NULL)

        {

        // find the index of the  node vector

        elementSize = NW_ADT_Vector_GetSize(areaBoxArray);

        for (arrayIndex = 0; arrayIndex < elementSize; arrayIndex++) 

          {

          areaBox = *(NW_LMgr_AreaBox_t**)NW_ADT_Vector_ElementAt (areaBoxArray, arrayIndex);

          if( NW_LMgr_Box_HasFocus( NW_LMgr_BoxOf( areaBox ) ) ) 

            {

            // draw the border around the area box

            status = NW_LMgr_Box_DrawBorder (NW_LMgr_AreaBox_GetBounds(NW_LMgr_BoxOf(areaBox)), 

                                             deviceContext, 

                                             &borderWidth, 

                                             &borderStyle, 

                                             &borderColor);

            NW_THROW_ON_ERROR(status);

            // if the image map box is broken, then we will need to display the alt text

            // of the area boxes if alt text is provided

            if( appServices->browserAppApi.IsImageMapView() && (NW_LMgr_ImgContainerBox_ImageIsBroken(box))) 

              {

              status = NW_LMgr_AreaBox_DisplayAltText( areaBox, deviceContext );