/*
* 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 "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:  SVG Implementation source file
 *
*/


#include "SVGFontHashMap.h"
#include "SVGDocumentImpl.h"

//SVG Font storage 

// ==========================================================================
// Need method description
// ==========================================================================
CSvgFontHashMap* CSvgFontHashMap::NewL()
    {
    CSvgFontHashMap*   self    = new ( ELeave ) CSvgFontHashMap;
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop();

    return self;
    }

// ==========================================================================
// Need method description
// ==========================================================================
CSvgFontHashMap* CSvgFontHashMap::NewLC()
    {
    CSvgFontHashMap*   self    = new ( ELeave ) CSvgFontHashMap;
    CleanupStack::PushL( self );
    self->ConstructL();

    return self;
    }

// ==========================================================================
// Need method description
// ==========================================================================
void CSvgFontHashMap::ConstructL()
    {
    }

// ==========================================================================
// Need method description
// ==========================================================================
CSvgFontHashMap::CSvgFontHashMap()

    {
    }

// ==========================================================================
// Need method description
// ==========================================================================
CSvgFontHashMap::~CSvgFontHashMap()
    {	
    	iSvgFontMapItems.ResetAndDestroy();
    	iSvgFontMapItems.Close();
    	
    	iFontDocumentPointers.ResetAndDestroy();
    	iFontDocumentPointers.Close();
    }

// ==========================================================================
// CSvgFontHashMap::AddFontL( CSvgFontElementImpl* aFontPtr,
//                                 const TDesC& aFontFamilyName )
// return ETrue if Font added
// return EFalse if Font was already in map
// ==========================================================================
TBool CSvgFontHashMap::AddFontL( CSvgFontElementImpl* aFontPtr,
                                 const TDesC& aFontFamilyName )
{
	CSvgFontMapItem* lFontMapItem = GetFontMapItem( aFontFamilyName );
    	
    	if (lFontMapItem)
    	{
    		//already a reference to this font in the font map
    		AddReferenceToFontL( aFontFamilyName);
    		return EFalse;
    	}
    	else
    	{
    		//didnt find that font in the font map...add it
			CSvgFontMapItem* lNewSvgFontMapItem = CSvgFontMapItem::NewL( );
		
			lNewSvgFontMapItem->SetFontPtr( aFontPtr );
       		lNewSvgFontMapItem->CopyFontFamilyName( aFontFamilyName );
       		lNewSvgFontMapItem->IncrementReferenceCount();
       		
			iSvgFontMapItems.Append(lNewSvgFontMapItem);
			
			return ETrue;
		}
}

// --------------------------------------------------------------------------
// void CSvgFontHashMap::AddReferenceToFontL( CFbsBitmap* aFont,
// return ETrue if reference successfully added
// return EFalse if already in map so just incremented reference
// ---------------------------------------------------------------------------
TBool CSvgFontHashMap::AddReferenceToFontL( const TDesC& aFontFamilyName )
    {	
    	CSvgFontMapItem* lFontMapItem = GetFontMapItem( aFontFamilyName );
    	
    	if (lFontMapItem)
    	{
    		//already a reference to this Font in the Font map
    		lFontMapItem->IncrementReferenceCount();
    		return ETrue;
    	}
    	else
    	{
    		return EFalse;
		}
        
    }

// --------------------------------------------------------------------------
// TBool CSvgFontHashMap::HasFontName( const TDesC& aFontName
// ---------------------------------------------------------------------------
TBool CSvgFontHashMap::HasFontFamilyName( const TDesC& aFontFamilyName )
    {
        TBool lHaveFont = EFalse;
		
		TInt svgFontMapItemsCnt = iSvgFontMapItems.Count();
        for (TInt i=0; i < svgFontMapItemsCnt; i++)
        {
            if ( aFontFamilyName == ((CSvgFontMapItem*)iSvgFontMapItems[i])->GetFontFamilyName() )
            {
                lHaveFont = ETrue;
            }
        }

        return lHaveFont;

    }

// --------------------------------------------------------------------------
// CSvgFontMapItem* CSvgFontHashMap::GetFontMapItem( const TDesC& aFontName
// ---------------------------------------------------------------------------
CSvgFontMapItem* CSvgFontHashMap::GetFontMapItem( const TDesC& aFontFamilyName )
{
	TInt svgFontMapItemsCnt = iSvgFontMapItems.Count();
	for ( TInt i = 0; i < svgFontMapItemsCnt; i++ )
            {
            CSvgFontMapItem* lFontMap = (CSvgFontMapItem*)iSvgFontMapItems[i];

			TInt result = aFontFamilyName.Compare( lFontMap->GetFontFamilyName() );
			
            if ( result == 0 )
                {
					return lFontMap;
				}
			}
	
	return NULL;
}

// --------------------------------------------------------------------------
// TBool CSvgDocumentImpl::RemoveReferenceFromFontL( const TDesC& aFontName )
// returns True if there aren't any left
// returns False if there are references to that Font left
// ---------------------------------------------------------------------------
TBool CSvgFontHashMap::RemoveReferenceFromFontL( const TDesC& aFontFamilyName )
    {

		CSvgFontMapItem* lFontMapItem = GetFontMapItem( aFontFamilyName );
		
		if (lFontMapItem != NULL)
		{
			//we have this lFontMapElement
			TInt aReferenceCount = lFontMapItem->DecrementReferenceCount();
			
			if (aReferenceCount <= 0)
			{
				//no more references to this Font remove it from the map
				iSvgFontMapItems.Remove(iSvgFontMapItems.Find(lFontMapItem));
				delete lFontMapItem;
				return ETrue;
			}
		}
		
		return EFalse;
    }

// --------------------------------------------------------------------------
// START OF EXTERNAL SVG FONT DOCUMENT METHODS
// --------------------------------------------------------------------------
// TBool CSvgFontHashMap::AddFontDocument(CSvgDocumentImpl* newFontDocument, const TDesC& aFontFamily)
// ---------------------------------------------------------------------------
TBool CSvgFontHashMap::AddFontDocument(CSvgDocumentImpl* aFontDocument, const TDesC& aFontFamily)
{
    if (aFontDocument == NULL)
    {
        //no document passed in
        return EFalse;
    }

    CSvgElementImpl* myFontElement = (CSvgElementImpl*)GetFontPtr(aFontFamily);

    if (myFontElement == NULL)
    {
        //no font in of this name in map so we can't add its document handle
        return EFalse;
    }

    if ( !HasFontDocument(aFontDocument) )
    {
            //then add it to the list of font documents
            iFontDocumentPointers.Append(aFontDocument);

            //and add it to the current document's font map
            TInt errorcode = KErrNone;
            TRAP(errorcode, AddFontL((CSvgFontElementImpl*)myFontElement, aFontFamily));

            return ETrue;
    }

    return EFalse;
}

// --------------------------------------------------------------------------
// void CSvgFontHashMap::DeleteFontDocument(const TDesC& aFontFamily)
// ---------------------------------------------------------------------------
void CSvgFontHashMap::DeleteFontDocument(const TDesC& aFontFamily)
{
    CSvgElementImpl* myFontElement = NULL;

	TInt fontDocPointersCnt = iFontDocumentPointers.Count();
    for (TInt i=0; i < fontDocPointersCnt; i++)
    {
        CSvgDocumentImpl* myDoc = (CSvgDocumentImpl*)iFontDocumentPointers[i];

        myFontElement = (CSvgElementImpl*)GetFontPtr(aFontFamily);

        if (myFontElement != NULL)
        {
            iFontDocumentPointers.Remove(i);
            TInt error = KErrNone;
            TRAP(error,RemoveReferenceFromFontL(aFontFamily));
            if (myDoc)
            {
                delete myDoc;
                myDoc = NULL;
            }
        }
    }
}

// --------------------------------------------------------------------------
// TBool CSvgFontHashMap::HasFontDocument(CSvgDocumentImpl* myDoc)
// ---------------------------------------------------------------------------
TBool CSvgFontHashMap::HasFontDocument(CSvgDocumentImpl* myDoc)
{
    //check to see if we have this document pointer already
    TBool hasFontPointer = EFalse;

	TInt fontDocPointersCnt = iFontDocumentPointers.Count();
    for (TInt i=0; i < fontDocPointersCnt; i++)
    {
        if ((CSvgDocumentImpl*)iFontDocumentPointers[i] == myDoc)
        {
            hasFontPointer = ETrue;
        }
    }

    return hasFontPointer;
}

// --------------------------------------------------------------------------
//END OF EXTERNAL SVG FONT DOCUMENT
// --------------------------------------------------------------------------

// --------------------------------------------------------------------------
// void CSvgFontHashMap::PrintFontHashMap( )
// ---------------------------------------------------------------------------
void CSvgFontHashMap::PrintFontHashMap()
{
	RDebug::Printf("----Font Hash Map----\n");
	TInt svgFontMapItemsCnt = iSvgFontMapItems.Count();
	for (TInt i=0; i< svgFontMapItemsCnt; i++)
	{
		CSvgFontMapItem* lFontMapItem = iSvgFontMapItems[i];
		
		if(lFontMapItem)
		{
			lFontMapItem->Print();	
		}	
	}
}

// --------------------------------------------------------------------------
// CFbsBitmap* CSvgDocumentImpl::GetFontPtr( const TDesC& aFontName )
// ---------------------------------------------------------------------------
CSvgFontElementImpl* CSvgFontHashMap::GetFontPtr( const TDesC& aFontFamilyName )
    {
    
    CSvgFontMapItem* lFontMapItem = GetFontMapItem( aFontFamilyName );
    
    if (lFontMapItem)
    	{
    	return (lFontMapItem->GetFontPtr());
    	}
    
    	return NULL;
 
    }

// ==========================================================================
// Need method description
// ==========================================================================
CSvgFontMapItem* CSvgFontMapItem::NewL()
    {
    CSvgFontMapItem*   self    = new ( ELeave ) CSvgFontMapItem;
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop();

    return self;
    }

// ==========================================================================
// Need method description
// ==========================================================================
CSvgFontMapItem* CSvgFontMapItem::NewLC()
    {
    CSvgFontMapItem*   self    = new ( ELeave ) CSvgFontMapItem;
    CleanupStack::PushL( self );
    self->ConstructL();

    return self;
    }

// ==========================================================================
// Need method description
// ==========================================================================
void CSvgFontMapItem::ConstructL()
    {
    }

// ==========================================================================
// Need method description
// ==========================================================================
CSvgFontMapItem::CSvgFontMapItem()
    {
    }

// ==========================================================================
// Need method description
// ==========================================================================
CSvgFontMapItem::~CSvgFontMapItem()
    {
    	if (iFontFamilyName)
    	{
    		delete iFontFamilyName;
    		iFontFamilyName = NULL;
    	}
    	/*if (iFontPtr)
    	{
    		delete iFontPtr;
    	}
    	if (iFontDocumentPtr)
    	{
    		delete iFontDocumentPtr;
    	}*/
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
CSvgFontElementImpl* CSvgFontMapItem::GetFontPtr()
    {
    return iFontPtr;
    }


// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
const TDesC& CSvgFontMapItem::GetFontFamilyName()
    {
    return ( const TDesC & ) *iFontFamilyName;
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
void CSvgFontMapItem::SetFontPtr( CSvgFontElementImpl* aFontPtr )
    {
    iFontPtr = aFontPtr;
    }


// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
void CSvgFontMapItem::CopyFontFamilyName( const TDesC& aFontFamilyName )
    {
    if (iFontFamilyName)
    {
    	delete iFontFamilyName;
    	iFontFamilyName = NULL;
    }
    
    iFontFamilyName = aFontFamilyName.Alloc();
    }

//-----------------------------------------------------------------------
//
//-----------------------------------------------------------------------
TInt CSvgFontMapItem::IncrementReferenceCount( )
	{
	iFontReferenceCount++;
	return iFontReferenceCount;
	}

//-----------------------------------------------------------------------
//
//-----------------------------------------------------------------------
TInt CSvgFontMapItem::DecrementReferenceCount()
	{
	iFontReferenceCount--;
	return iFontReferenceCount;
	}

//-----------------------------------------------------------------------
//
//-----------------------------------------------------------------------	
void CSvgFontMapItem::Print()
{
	RDebug::RawPrint(iFontFamilyName->Des());
	RDebug::Printf("ref_count = %d fontptr = %d fontdocptr = %d \n", iFontReferenceCount, iFontPtr, iFontDocumentPtr);	
}