/*

* 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:  Hold different CSS images that are applied to document

*

*/

// INCLUDE FILES

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

#include "BrsrStatusCodes.h"

#include "CSSImageList.h"

#include "nw_text_ucs2.h"

#include "nw_image_virtualimage.h"

#include "nwx_multipart_generator.h"

#include "nwx_string.h"

#include "nwx_http_defs.h"

#include "nw_css_processori.h"

#include "nwx_settings.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

const TInt KCSSImageListArrayGranularity = 2;

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

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

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

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

// CVirtualNodeImageEntry::CVirtualNodeImageEntry

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CVirtualNodeImageEntry::CVirtualNodeImageEntry( )

  {

  }

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

// CVirtualNodeImageEntry::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CVirtualNodeImageEntry::ConstructL( )

  {

  }

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

// CVirtualNodeImageEntry::NewL

// Two-phased constructor.

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

//

CVirtualNodeImageEntry* CVirtualNodeImageEntry::NewL()

  {

  CVirtualNodeImageEntry* self = new( ELeave )CVirtualNodeImageEntry();

  CleanupStack::PushL( self );

  self->ConstructL();

  CleanupStack::Pop();

  return self;

  }

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

// CVirtualNodeImageEntry::NewLC

// Two-phased constructor.

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

//

CVirtualNodeImageEntry* CVirtualNodeImageEntry::NewLC()

  {

  CVirtualNodeImageEntry* self = CVirtualNodeImageEntry::NewL();

  CleanupStack::PushL( self );

  return self;

  }

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

// CVirtualNodeImageEntry::~CVirtualNodeImageEntry

// destructor.

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

//

CVirtualNodeImageEntry::~CVirtualNodeImageEntry()

  {

  if( iImageOwnership )

    {

    // delete the image

    NW_Object_Delete( iVirtualImage );

    }

  }

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

// CCSSImageListEntry::CCSSImageListEntry

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CCSSImageListEntry::CCSSImageListEntry( NW_Text_t* aUrl, TBool aListItem )

  : iUrl( aUrl ), iListItem( aListItem )

  {

  }

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

// CCSSImageListEntry::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CCSSImageListEntry::ConstructL( )

  {

  // initialize the virtual node-image pair list

  iVirtualNodeImageList = new (ELeave) CVirtualNodeImageList( KCSSImageListArrayGranularity );

  }

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

// CCSSImageListEntry::NewL

// Two-phased constructor.

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

//

CCSSImageListEntry* CCSSImageListEntry::NewL( NW_Text_t* aUrl, TBool aListItem )

  {

  CCSSImageListEntry* self = new( ELeave ) CCSSImageListEntry( aUrl, aListItem );

  CleanupStack::PushL( self );

  self->ConstructL();

  CleanupStack::Pop();

  return self;

  }

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

// CCSSImageListEntry::NewLC

// Two-phased constructor.

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

//

CCSSImageListEntry* CCSSImageListEntry::NewLC( NW_Text_t* aUrl, TBool aListItem )

  {

  CCSSImageListEntry* self = CCSSImageListEntry::NewL( aUrl, aListItem );

  CleanupStack::PushL( self );

  return self;

  }

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

// CCSSImageListEntry::~CCSSImageListEntry

// Destructor.

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

CCSSImageListEntry::~CCSSImageListEntry()

  {

  NW_Object_Delete( iUrl );

  NW_Mem_Free( iContentTypeString );

  // free virtual images

  if(iVirtualNodeImageList)

    {

    iVirtualNodeImageList->ResetAndDestroy();

    }

  delete iVirtualNodeImageList;

  iVirtualNodeImageList = NULL;

  // it's important to release virtual images first

  // as they might be observing this image

  // we are not observing the "main image"

  NW_Object_Delete( iImage );

  }

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

// CCSSImageListEntry::SetAbstractImage

// Sets the image and its content type

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

//

void CCSSImageListEntry::SetAbstractImage( NW_Image_AbstractImage_t* aImage, NW_Http_ContentTypeString_t aContentType )

  {

  iImage = aImage;

  iContentTypeString = aContentType;

  }

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

// CCSSImageList::QueryEntry

// Gets CSS image for a given URL

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

//

TBool CCSSImageList::QueryEntryL (NW_Text_t* aUrl, CCSSImageListEntry*& aRetEntry )

{

  NW_Text_Length_t length;

  NW_Uint8 freeNeeded;

  TBool found( EFalse );

  /* convert the url to Unicode and get the storage */

  NW_Ucs2* storage = (NW_Ucs2*)NW_Text_GetUCS2Buffer (aUrl, 0, &length, &freeNeeded);

  User::LeaveIfNull( storage );

  TInt size = iImageList->Count();

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

  {

    CCSSImageListEntry* entry = iImageList->At( index );

    NW_Text_Length_t len = 0;

    NW_Text_t* imageUrl = entry->ImageUrl();

    const void* urlStorage = NW_Text_GetUCS2Buffer( imageUrl, 0, &len, NULL );

    if (!(NW_Mem_memcmp (urlStorage, storage, (length+1) *sizeof (NW_Ucs2))))

    {

      found = ETrue;

      aRetEntry = entry;

      break;

    }

  } /* end for */

  if (freeNeeded)

  {

    NW_Mem_Free ((NW_Ucs2*)storage);

  }

  return found;

}

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

// CCSSImageList::CCSSImageList

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CCSSImageList::CCSSImageList( NW_CSS_Processor_t& aProcessor ) : iProcessor( &aProcessor )

  {

  }

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

// CCSSImageList::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CCSSImageList::ConstructL()

  {

    // initialize the imageList

  iImageList = new( ELeave )CImageListArray( KCSSImageListArrayGranularity );

  }

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

// CCSSImageList::NewL

// Two-phased constructor.

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

//

CCSSImageList* CCSSImageList::NewL( NW_CSS_Processor_t& aProcessor )

  {

  CCSSImageList* self = new( ELeave )CCSSImageList( aProcessor );

  CleanupStack::PushL( self );

  self->ConstructL();

  CleanupStack::Pop();

  return self;

  }

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

// CCSSImageList::~CCSSImageList

// Destructor.

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

//

CCSSImageList::~CCSSImageList()

{

  // first remove observers

  TInt size = 0;  

  if(iImageList)

    {

    size = iImageList->Count();

    }

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

    {

    CCSSImageListEntry* entry = iImageList->At( index );

    // check the virtual images list

    CVirtualNodeImageList* virtualImageList = entry->VirtualNodeImageList();

    TInt virtualImageCount = virtualImageList->Count();

    for( TInt i = 0; i < virtualImageCount; i++ )

      {

      NW_Image_Virtual_t* virtualImage;

      CVirtualNodeImageEntry* virtualImageEntry = virtualImageList->At( i );

      if( virtualImageEntry && ( virtualImage = virtualImageEntry->VirtualImage() ) != NULL )

        {

        // remove observer

        (void) NW_Image_AbstractImage_RemoveImageObserver( (NW_Image_AbstractImage_t*) virtualImage,

          &iProcessor->NW_Image_IImageObserver );

        }

      }

    }

  // destroy image list

  if(iImageList)

    {

    iImageList->ResetAndDestroy();

    }

  delete iImageList;

}

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

// CCSSImageList::CreateImageEntryL

// Creates a new entry to the image list where the URL is the ID

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

//

void CCSSImageList::CreateImageEntryL( NW_Text_t* aUrl, NW_DOM_ElementNode_t* aImageNode, TBool aListItem )

{

  // create and empty image entry

  CCSSImageListEntry* newCSSImageEntry = CCSSImageListEntry::NewLC( aUrl, aListItem );

  // Virtual image list includes both the node and

  // the image itself

  CVirtualNodeImageEntry* newVirtualNodeImageListEntry = CVirtualNodeImageEntry::NewLC();

  newVirtualNodeImageListEntry->AddVirtualNode( aImageNode );

  // no image yet

  newVirtualNodeImageListEntry->AddVirtualImage( NULL );

  // no ownership

  newVirtualNodeImageListEntry->RemoveVirtualImageOwnership();

  // take image list onwership

  newCSSImageEntry->AddVirtualImageNodeEntryL( newVirtualNodeImageListEntry );

  CleanupStack::Pop(); // newVirtualNodeImageListEntry

  // and append to the list. take ownership

  iImageList->AppendL( newCSSImageEntry );

  CleanupStack::Pop(); // newCSSImageEntry

  }

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

// CCSSImageList::AddVirtualNodeToImageEntryL

// adds a new virtual node for a given URL to the image entry list

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

//

NW_Image_AbstractImage_t*

CCSSImageList::AddVirtualNodeToImageEntryL( NW_Text_t* aUrl, NW_DOM_ElementNode_t* aVirtualImageNode )

  {

  NW_Image_AbstractImage_t* image = NULL;

  CCSSImageListEntry *entry = NULL;

  if( QueryEntryL( aUrl, entry ) )

    {

    CVirtualNodeImageEntry* newVirtualNodeImageEntry = CVirtualNodeImageEntry::NewLC();

    // add the virtual node first

    newVirtualNodeImageEntry->AddVirtualNode( aVirtualImageNode );

    NW_Image_Virtual_t* virtualImage = NULL;

    // if the (main)image has not been loaded yet,

    // then entry->iImage is NULL.

    if( entry->AbstractImage() )

      {

      virtualImage = NW_Image_Virtual_New( entry->AbstractImage() );

      User::LeaveIfNull( virtualImage );

      // take the image ownership

      newVirtualNodeImageEntry->TakeVirtualImageOwnership();

      image = NW_Image_AbstractImageOf( virtualImage );

      // and set processor as observer

      (void) NW_Image_AbstractImage_SetImageObserver( image,

        &iProcessor->NW_Image_IImageObserver );

      }

    else

      {

      // create the virtual image entry when the abstract comes in

      // for the time being, add NULL pointer to the list

      // no ownership

      newVirtualNodeImageEntry->RemoveVirtualImageOwnership();

      }

    newVirtualNodeImageEntry->AddVirtualImage( virtualImage );

    // add to the list. take ownership

    entry->AddVirtualImageNodeEntryL( newVirtualNodeImageEntry );

    CleanupStack::Pop(); // newVirtualNodeImageEntry

    }

  return image;

  }

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

// CCSSImageList::SetImageL

// sets the image for a given URL. It also checks the virtual node list.

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

NW_Image_AbstractImage_t*

CCSSImageList::SetImageL(NW_Text_t* aUrl, NW_Byte* aData, NW_Uint32 aLength,

                         NW_Http_ContentTypeString_t aContentTypeString)

    { 

    NW_Image_AbstractImage_t* image = NULL;

    CCSSImageListEntry *entry = NULL;

    if (QueryEntryL(aUrl, entry))

        {

        NW_GDI_Dimension3D_t size = {0, 0, 0};

        // Do we have an image content-type that Symbian won't recognize,

        // but the browser supports.

        TImageType imageType = GetRecognizedImageType((const char*)aContentTypeString);

        // make a copy of content type string as the caller

        // (_NW_CSS_Processor_ILoadRecipient_ProcessLoad) deletes it.

        TInt contentTypeLength = NW_Asc_strlen((char*)aContentTypeString);

        NW_Http_ContentTypeString_t contentTypeString =

                          (NW_Http_ContentTypeString_t)NW_Asc_New(contentTypeLength + 1);

        User::LeaveIfNull(contentTypeString);

        NW_Asc_strcpy((char*)contentTypeString, (char*)aContentTypeString);

        contentTypeString[contentTypeLength] = '\0';

        // create the abstract image

        image = (NW_Image_AbstractImage_t*)NW_Image_Epoc32Simple_New(size, NULL, NULL,

                                                                     NW_FALSE, NW_FALSE, imageType,

                                                                     aData, aLength,

                                                                     iProcessor->owner);

        User::LeaveIfNull(image);

        // set to the list

        entry->SetAbstractImage(image, contentTypeString);

        // check if there is a virtual image which is waiting for to be

        // updated. - create as many new virtual images out of entry->iImage as

        // virtual nodes we have

        // note: one virtual image must be created here for the main node

        // as the main box -which is not the virtual one- musn't own

        // simple image.

        // this "extra" virtual node is appended to the list at

        // CreateImageEntryL()

        CVirtualNodeImageList* virtualNodeImageList = entry->VirtualNodeImageList();

        TInt virtualImageCount = virtualNodeImageList->Count();

        for (TInt i = 0; i < virtualImageCount; i++)

            {

            CVirtualNodeImageEntry* virtualNodeImageEntry = virtualNodeImageList->At(i);

            if (!virtualNodeImageEntry->VirtualImage())

                {

                // create virtual image

                NW_Image_Virtual_t* virtualImage = NW_Image_Virtual_New(entry->AbstractImage());

                User::LeaveIfNull(virtualImage);

                // update the entry

                virtualNodeImageEntry->AddVirtualImage(virtualImage);

                virtualNodeImageEntry->TakeVirtualImageOwnership();

                // and set processor as observer

                (void)NW_Image_AbstractImage_SetImageObserver((NW_Image_AbstractImage_t*)virtualImage,

                                                              &iProcessor->NW_Image_IImageObserver);

                // and update the list

                virtualNodeImageList->At(i) = virtualNodeImageEntry;

                }

            }

#ifdef INCREMENTAL_IMAGE_ON

        NW_Image_Epoc32Simple_Initialize((NW_Image_Epoc32Simple_t*)image);

        // start opening the image

        ((CEpoc32ImageDecoder*)((NW_Image_Epoc32Simple_t*)image)->decoder)->Open();

#else 

        NW_Image_Epoc32Simple_Initialize((NW_Image_Epoc32Simple_t*)image);

#endif // INCREMENTAL_IMAGE_ON

        }   // end of if (QueryEntry...

    return image;

    }

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

// CCSSImageList::GetImageL

// gets the image for a given URL

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

//

NW_Image_AbstractImage_t*

CCSSImageList::GetImageL( NW_Text_t* aUrl, TBool& aFound )

{

  CCSSImageListEntry* entry = NULL;

  NW_Image_AbstractImage_t* image = NULL;

  aFound = QueryEntryL( aUrl, entry );

  if( aFound && entry != NULL )

    {

    image = entry->AbstractImage();

    }

  return image;

}

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

// CCSSImageList::EntryByVirtualImage

// gets both the image entry and the node for a given virtual image

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

//

CCSSImageListEntry* CCSSImageList::EntryByVirtualImage( NW_Image_AbstractImage_t* aVirtualImage,

                                                        NW_DOM_ElementNode_t** aImageNode )

  {

  TInt size = iImageList->Count();

  // lookup the virtual node-image list

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

    {

    CCSSImageListEntry* entry = iImageList->At( index );

    // check the virtual images list

    CVirtualNodeImageList* virtualNodeImageList = entry->VirtualNodeImageList();

    TInt virtualNodeImageCount = virtualNodeImageList->Count();

    for( TInt i = 0; i < virtualNodeImageCount; i++ )

      {

      NW_Image_Virtual_t* virtualImage;

      CVirtualNodeImageEntry* virtualNodeImageEntry = virtualNodeImageList->At( i );

      if( virtualNodeImageEntry && ( virtualImage = virtualNodeImageEntry->VirtualImage() ) != NULL )

        {

        if( NW_Image_AbstractImageOf( virtualImage ) == aVirtualImage )

          {

          // set image node. note that NULL can be passed if

          // the caller is not interested in the node value

          if( aImageNode != NULL )

            {

            *aImageNode = virtualNodeImageEntry->VirtulaNode();