/*
* 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
 *
*/


#if !defined(__E32BASE_H__)
#include <e32base.h>
#endif

#include <AknBidiTextUtils.h>

#include "SVGTextAreaElementImpl.h"
#include "SVGRectElementImpl.h"
#include "SVGTextElementImpl.h"
#include "SVGElementImpl.h"
#include "SVGDocumentImpl.h"
#include "SVGSchemaData.h"
#include "SVGEngineImpl.h"
#include "GfxAffineTransform.h"

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
CSvgTextAreaElementImpl* CSvgTextAreaElementImpl::NewL(  const TUint8 aElemID,
												CSvgDocumentImpl* aDoc )
{
	CSvgTextAreaElementImpl*self    = new ( ELeave ) CSvgTextAreaElementImpl( aDoc );
	CleanupStack::PushL( self );
	self->ConstructL(  aElemID);
	CleanupStack::Pop();

	return self;
}

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
CSvgTextAreaElementImpl* CSvgTextAreaElementImpl::NewLC(  const TUint8 aElemID,
												 CSvgDocumentImpl* aDoc )
{
	CSvgTextAreaElementImpl*self    = new ( ELeave ) CSvgTextAreaElementImpl( aDoc );
	CleanupStack::PushL( self );
	self->ConstructL(  aElemID );

	return self;
}

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
CSvgTextAreaElementImpl::~CSvgTextAreaElementImpl()
{
    if ( iSvgStyleProperties )
		{
			iSvgStyleProperties->Close();
			delete iSvgStyleProperties;
			iSvgStyleProperties = NULL;
		}

		if ( iInnerRectangle )
		{
			this->RemoveChild(iInnerRectangle);
			delete iInnerRectangle;
			iInnerRectangle = NULL;
		}

		if ( iBorderRectangle )
		{
			this->RemoveChild(iBorderRectangle);
			delete iBorderRectangle;
			iBorderRectangle = NULL;
		}

		if (iTextElementsArray)
		{
			iTextElementsArray->Reset();
			iTextElementsArray->Close();
			delete iTextElementsArray;
			iTextElementsArray = NULL;
		}
	if (iAllText)
	{
		delete iAllText;
		iAllText = NULL;
	}

	((CSvgDocumentImpl*)OwnerDocument())->RemoveInternalMouseListener( this );

}

// *******************************************************
// From SVG DOM
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
TFloatFixPt CSvgTextAreaElementImpl::X()
{
	if (!iInitialized)
	{
		return 0;
	}

    return iBorderRectangle->X();
}

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
TFloatFixPt CSvgTextAreaElementImpl::Y()
{
	if (!iInitialized)
	{
		return 0;
	}

    return iBorderRectangle->Y();
}

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
TFloatFixPt CSvgTextAreaElementImpl::Width()
{
	if (!iInitialized)
	{
		return 0;
	}

    return iBorderRectangle->Width();
}

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
TFloatFixPt CSvgTextAreaElementImpl::Height()
{
	if (!iInitialized)
	{
		return 0;
	}

    return iBorderRectangle->Height();
}

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
TFloatFixPt CSvgTextAreaElementImpl::Rx()
{
	if (!iInitialized)
	{
		return 0;
	}

    return iBorderRectangle->Rx();
}

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
TFloatFixPt CSvgTextAreaElementImpl::Ry()
{
	if (!iInitialized)
	{
		return 0;
	}

    return iBorderRectangle->Ry();
}

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
TBool CSvgTextAreaElementImpl::IsEditable()
{
    return iEditable;
}


// ---------------------------------------------------------------------------
// For JSR support
// ---------------------------------------------------------------------------
void CSvgTextAreaElementImpl::SetTextAreaDimensions(TFloatFixPt aX, TFloatFixPt aY, TFloatFixPt aWidth, TFloatFixPt aHeight)
{
	if (!iInitialized)
	{
		TRAPD(err, InitializeL());
    	if (err)
    	    {
		    #ifdef _DEBUG
            _LIT( KErrMsg, "CSvgTextAreaElementImpl::SetTextAreaDimensions Error in InitializeL()" );
            RDebug::Print(KErrMsg);
            #endif //_DEBUG
    	    }
	}

	TRAPD(err, iBorderRectangle->SetAttributeFloatL(KAtrX, aX));
	if (err)
	    {
	    #ifdef _DEBUG
        _LIT( KErrMsg, "CSvgTextAreaElementImpl::SetTextAreaDimensions Error in SetAttributeFloatL" );
        RDebug::Print(KErrMsg);
        #endif //_DEBUG
	    }

	TRAP(err, iBorderRectangle->SetAttributeFloatL(KAtrY, aY));
	if (err)
	    {
	    #ifdef _DEBUG
        _LIT( KErrMsg, "CSvgTextAreaElementImpl::SetTextAreaDimensions Error in SetAttributeFloatL" );
        RDebug::Print(KErrMsg);
        #endif //_DEBUG
	    }

	TRAP(err, iBorderRectangle->SetAttributeFloatL(KAtrWidth, aWidth));
	if (err)
	    {
	    #ifdef _DEBUG
        _LIT( KErrMsg, "CSvgTextAreaElementImpl::SetTextAreaDimensions Error in SetAttributeFloatL" );
        RDebug::Print(KErrMsg);
        #endif //_DEBUG
	    }

	TRAP(err, iBorderRectangle->SetAttributeFloatL(KAtrHeight, aHeight));
	if (err)
	    {
	    #ifdef _DEBUG
        _LIT( KErrMsg, "CSvgTextAreaElementImpl::SetTextAreaDimensions Error in SetAttributeFloatL" );
        RDebug::Print(KErrMsg);
        #endif //_DEBUG
	    }
}

// From MXmlElementOpt
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
TInt CSvgTextAreaElementImpl::GetAttributeFloat( const TInt aNameId,
                                             TFloatFixPt& aValue )
{
	if (!iInitialized)
	{
		TRAPD(err, InitializeL());
    	if (err)
    	    {
		    #ifdef _DEBUG
            _LIT( KErrMsg, "CSvgTextAreaElementImpl::GetAttributeFloat Error in InitializeL()" );
            RDebug::Print(KErrMsg);
            #endif //_DEBUG
    	    }
	}

    switch ( aNameId )
        {
        case KAtrX:
        case KAtrRefX:
        		aValue = X();
        break;
        case KAtrY:
        case KAtrRefY:
        		aValue = Y();
        break;
        case KAtrWidth:
        		aValue = Width();
        break;
        case KAtrHeight:
        		aValue = Height();
        break;
		// added as a part of get and Set api updation
		case KAtrRx:
				aValue = Rx();
		break;
		case KAtrRy:
				aValue = Ry();
		break;
        default:
        		return CSvgElementImpl::GetAttributeFloat( aNameId, aValue );
        }
    return KErrNone;
}

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
TInt CSvgTextAreaElementImpl::SetAttributeFloatL( const TInt aNameId,
                                              const TFloatFixPt aValue )
{
	if (!iInitialized)
	{
		InitializeL();
	}

    switch ( aNameId )
        {
        case KAtrX:
			iBorderRectangle->SetAttributeFloatL(aNameId, aValue);
			iInnerRectangle->SetAttributeFloatL(aNameId, aValue+TFloatFixPt(2));
		break;
        case KAtrY:
			iBorderRectangle->SetAttributeFloatL(aNameId, aValue);
			iInnerRectangle->SetAttributeFloatL(aNameId, aValue+TFloatFixPt(2));
		break;
		case KAtrRx:
			iBorderRectangle->SetAttributeFloatL(aNameId, aValue);
			//iInnerRectangle->SetAttributeFloatL(aNameId, aValue+TFloatFixPt(2));
		break;
		case KAtrRy:
			iBorderRectangle->SetAttributeFloatL(aNameId, aValue);
			//iInnerRectangle->SetAttributeFloatL(aNameId, aValue+TFloatFixPt(2));
		break;
        case KAtrWidth:
			if(iReqAttrFlag == KAtrSVGRec)
			{
				iReqAttrFlag = KAtrHeight;
			}
			else
			{
				iReqAttrFlag = 0;
			}

			iBorderRectangle->SetAttributeFloatL(aNameId, aValue);
			iInnerRectangle->SetAttributeFloatL(aNameId, aValue-TFloatFixPt(4));
		break;

        case KAtrHeight:
					if(iReqAttrFlag == KAtrSVGRec)
						{
						iReqAttrFlag = KAtrWidth;
						}
					else
						{
						iReqAttrFlag = 0;
						}
					iBorderRectangle->SetAttributeFloatL(aNameId, aValue);
			iInnerRectangle->SetAttributeFloatL(aNameId, aValue-TFloatFixPt(4));
			        break;
        default:
        return CSvgElementImpl::SetAttributeFloatL( aNameId, aValue );
        }
    return KErrNone;
}


// *******************************************************
// From MXmlElement
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
TInt CSvgTextAreaElementImpl::SetAttributeL( const TDesC& aName,
                                         const TDesC& aValue )
{
	if (!iInitialized)
	{
		InitializeL();
	}

		CSvgElementImpl::SetAttributeL(aName,aValue);
    return KErrNone;
}

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
TInt CSvgTextAreaElementImpl::GetAttributeDes( const TInt aNameId, TPtrC16& aValue )
    {
    if (!iInitialized)
	{
		return KErrNone;
	}

    switch ( aNameId )
        {
        case KAtrCdata:
        aValue.Set(*iAllText);
        break;
        default:
        return CSvgElementImpl::GetAttributeDes( aNameId, aValue );
        }
    return KErrNone;
    }
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
TInt CSvgTextAreaElementImpl::SetAttributeDesL( const TInt aNameId,
                                            const TDesC& aValue )
    {
    switch ( aNameId )
        {
        case KAtrCdata:
        SetTextL( aValue );
        break;

        default:
        return CSvgElementImpl::SetAttributeDesL( aNameId, aValue );
        }
    return KErrNone;
    }


// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
void CSvgTextAreaElementImpl::SetEditable( const TDesC& aValue )
{
	if (aValue.FindF(_L("simple")) == KErrNotFound && aValue.FindF(_L("true")) == KErrNotFound)
	{
		iEditable = EFalse;
	}
	else
	{
		iEditable = ETrue;
	}
}

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
void CSvgTextAreaElementImpl::LocalizedArrangeTextL( CGfx2dGc* /* aGc */ )
    {
	if (!iInitialized)
	    {
		return;
	    }

	//every time we call arrange text we will clear the previous text elements
	//very expensive but easiest way to do this
	if (iTextElementsArray)
	    {
		TInt textEleArrayCnt = iTextElementsArray->Count();
		for (TInt i=0; i < textEleArrayCnt; i++)
		    {
			this->RemoveChild( iTextElementsArray->operator[](i) );
			delete iTextElementsArray->operator[](i);
		    }

		iTextElementsArray->Reset();
	    }
    // If there is some text in the text area, we need to do the following operations
    //      a. calculate number of lines that can fit in the inner rectangle of textArea 
    //          i. For this we need to get the dimension of Inner Rectangle
    //          ii. Then get the font corresponding to the current scale. This is obtained
    //              by creating a dummy text element and updating its CTM.
    //
	if (iAllText && iAllText->Length() > 0)
	    {
		TFloatFixPt lInnerRectWidthF, lInnerRectHeightF;
		iInnerRectangle->GetAttributeFloat( KAtrWidth, lInnerRectWidthF );
		iInnerRectangle->GetAttributeFloat( KAtrHeight, lInnerRectHeightF );
        
        // Create a dummy text element to obtain the font
      	CSvgTextElementImpl* lTextElement  = 
      	    (CSvgTextElementImpl*)iOwnerDocument->CreateElementL(KSvgTextElement);
      	CleanupStack::PushL(lTextElement);
        lTextElement->SetAttributeDesL(KAtrCdata,iAllText->Des());
        
        this->AppendChildL(lTextElement);
        CleanupStack::Pop(lTextElement);
        lTextElement->UpdateCTM();
        // Update the text element's font corresponding to the CTM.
        lTextElement->UpdateCurrentScaledFont();

        TFloatFixPt lScale = GetCurrentScale();
        
        //Taken the widest charactor to check against the dimensions of the text area.
        //There is no point in going futher, If the area of text area elelment 
        //is not big enough to fit the single char,
        TChar ch('W');
        if ( lScale == TFloatFixPt( 0 ) ||
             ((TReal32)( lInnerRectWidthF * lScale)) < lTextElement->Font()->CharWidthInPixels( ch ) ||
             ((TReal32)( lInnerRectHeightF * lScale)) < lTextElement->Font()->FontMaxHeight())
            {
            // Scale = 0 , means no drawing will take place.
            // Cleanup the text element
    		this->RemoveChild(lTextElement);
			delete lTextElement;
			lTextElement = NULL;
            return;
            }
        
        // Store the current font's ascent and descent
        TInt lTextAscent = lTextElement->Font()->FontMaxAscent();
        TInt lTextDescent = lTextElement->Font()->FontMaxDescent();

	TReal32 lTextHeight = lTextAscent + lTextDescent;

        if (lTextHeight == 0)
	        {
	    	//no text height so we need to not draw the text
    		this->RemoveChild(lTextElement);
			delete lTextElement;
			lTextElement = NULL;
	    	return;
            }
            
        // Calculate gap between two consecutive lines of text
        // CFont provides FontLineGap() which is Font Height + Line Gap
        
        TInt lLineGap = lTextElement->Font()->FontLineGap();
        // Number of lines of text
	    TInt lNumOflines = (TReal32)( lInnerRectHeightF * lScale)/( lLineGap ) ;

        if( lNumOflines < 1)
            {
        	//text is taller than the rectangle
    		this->RemoveChild(lTextElement);
			delete lTextElement;
			lTextElement = NULL;
            return;
            }
        // Create a list of line widths and line texts to use with ConvertToVisualAndWrapToArrayL
        CArrayFixFlat<TInt>* lLineWidthArray = new ( ELeave ) CArrayFixFlat<TInt>( lNumOflines );
        CleanupStack::PushL(lLineWidthArray);
        
        //one px offset is taken on Left & right ends w.r. to inner rect width.
        lLineWidthArray->AppendL((TInt)( lInnerRectWidthF * lScale ) - 2,lNumOflines);

        CArrayFixFlat< TPtrC >*   lWrappedArray = new ( ELeave ) CArrayFixFlat<TPtrC>( lLineWidthArray->Count() );

        CleanupStack::PushL(lWrappedArray);
        
        //ConvertToVisualAndWrapToArrayL requires KAknBidiExtraSpacePerLine. 
        //Refer the help of AknBidiTextUtils::ConvertToVisualAndWrapToArrayL
        HBufC *lBuf = HBufC::NewLC(iAllText->Length() + (lNumOflines) * KAknBidiExtraSpacePerLine);

        TPtr buf = lBuf->Des();
        buf.Copy(iAllText->Des());
        // Below API fills the lWrappedArray with the lines of text. If no space 
        // is available in textArea, then trailing ellipsis(...) will be displayed.
        AknBidiTextUtils::ConvertToVisualAndWrapToArrayL(buf, *lLineWidthArray, 
            *lTextElement->iBitmapFont, *lWrappedArray, ETrue);
        
        // Dummy text element is no longer required.
		this->RemoveChild(lTextElement);
		delete lTextElement;
		lTextElement = NULL;
		
		// Calculating the y offset for first line of text. 
		// Text is positioned wrt font baseline, hence the position =
		//      Inner Rectangle 's Y Coordinate + Unscaled Font Ascent
		// The scaling will be taken care of by UpdateCTM on the text elements.
        TInt lTextCurrentY = TReal32(iInnerRectangle->Y()) + (lTextAscent / (TReal32)lScale );
		TInt lWrappedArrayCnt = lWrappedArray->Count();
		
		// lWrappedArrayCnt is guaranteed to be less than lNumOfLines.
		// This loop creates Text  elements as many as elements in lWrapppedArray.
        // These elements are appended as child to the text area.
		for( TInt i=0; i < lWrappedArrayCnt ; i++)
		    {
		    lTextElement = (CSvgTextElementImpl*)iOwnerDocument->CreateElementL(KSvgTextElement);
            CleanupStack::PushL( lTextElement );
            iTextElementsArray->Append(lTextElement);
		    
		    TPtrC lineText = lWrappedArray->At(i);
		    lTextElement->SetAttributeDesL(KAtrCdata,lineText);
		    
		    //Text positioned from the inner rectangle's X- coordinate + 1 pixel gap 
	    	lTextElement->SetAttributeFloatL(KAtrX, TFloatFixPt(iInnerRectangle->X() + TFloatFixPt(1)));

            //need to set the next text element up to go down the height here too...
            lTextElement->SetAttributeFloatL(KAtrY, TFloatFixPt(lTextCurrentY));

			lTextElement->SetAttributeFloatL(KAtrWidth, TFloatFixPt(iInnerRectangle->Width() - TFloatFixPt(2)));
			lTextElement->SetAttributeFloatL(KAtrHeight, lTextHeight);

            this->AppendChildL(lTextElement);

            lTextElement->UpdateCTM();
            lTextElement->UpdateCurrentScaledFont();

            //The subsequent position calculated as lTextHeight( Ascent + descent ) / unscaled line gap
            lTextCurrentY +=  (TInt)(( lLineGap )/(TReal32)lScale);

            CleanupStack::Pop( lTextElement );
		    }

		 //delete lBuf;
		 CleanupStack::PopAndDestroy(lBuf);
		 CleanupStack::Pop(lWrappedArray);
		 delete lWrappedArray;
		 CleanupStack::Pop(lLineWidthArray);
		 delete lLineWidthArray;

	}
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
TInt CSvgTextAreaElementImpl::GetLength()
    {
        return iAllText->Length();
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
void CSvgTextAreaElementImpl::GetText( TDes& allText )
    {
    if ( iAllText )
        {
    	if ( allText.MaxLength() < iAllText->Length() )
    	    {
    	    allText = iAllText->Left( allText.MaxLength() );
    	    }
    	    else
    	        {
    	        allText = *iAllText;
    	        }
        }
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
void CSvgTextAreaElementImpl::SetTextL( const TDesC& aText )
    {

   	_LIT( KPreserve, "preserve" );
    _LIT( KDefault, "default");
    if ( iAllText )
        {
        delete iAllText;
        iAllText = NULL;
        }

    iAllText = aText.AllocL();
    TPtr textDes = iAllText->Des();
    TBool def = ETrue;
    
    // Get the xml:space value.
    TBuf<20> lXmlspace;    
   
    if(XMLSpace() == KPreserve)
    	{
    	lXmlspace=KPreserve;
    	def=EFalse;
    	}
    else if(XMLSpace() == KDefault)
    	{
    	lXmlspace=KDefault;
    	}
    // xml:space is inherited if not specified
    if ( lXmlspace!= KPreserve && lXmlspace != KDefault) 
        {
    	// Traverse to the nearest parent element which has the xml:space 
		// If no xml:space then render using xml:space="default"
	    CSvgElementImpl *lRoot=(CSvgElementImpl *)this->ParentNode();
	 	while(lRoot)
	 		{
	 		if ((lRoot->XMLSpace() == KPreserve))
	    		{
	    		def = EFalse;
	    		break;
	        	}
	        else if(lRoot->XMLSpace()==KDefault)
	        	{
	        	break;	
	        	}
	        lRoot=(CSvgElementImpl *)lRoot->ParentNode();
	 		}
        }
    
    _LIT(KSpace, " ");
    // default    
    if ( def && lXmlspace != KPreserve )
        {
        
        // Remove leading, trailing and contiguous spaces
        textDes.TrimAll();
        
        for (TInt i = textDes.Length() - 1; i >= 0; i--)
        	{
                	
        	// Remove new line character
        	if (textDes[i] == '\n') 
       			{
          		textDes.Delete(i,1);
       			}
          	
          	// Tab to be replaced with space.
          	if(textDes[i] == '\t')
          		{
          		textDes.Replace(i,1,KSpace);
          		}           	
        	}
        }
    // preserve
    else
        {
       
        for ( TInt i = 0; i < textDes.Length(); i++ )
            {
            // ms-dos carriage return contains two characters: 13, 10
           	const TInt KCarriageReturn1 = 13;
           	const TInt KCarriageReturn2 = 10;
           	
           	if ( i + 1 < textDes.Length() &&
           	 	(TInt)textDes[i] == KCarriageReturn1 && 
           	 	(TInt)textDes[i+1] == KCarriageReturn2 )
              	{
                textDes[i] = ' ';
                textDes.Delete( i+1, 1 );
       		    }
			
			// New line and tab should be replaced by space character.         
           	if (textDes[i] == '\n' ||textDes[i] == '\t')
              	{
                textDes.Replace(i,1, KSpace);
               	}
            }
        }
         
        iNeedTextRearrange = ETrue;

    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
void CSvgTextAreaElementImpl::InitializeL()
{
	if (!iBorderRectangle && !iInnerRectangle)
	{
		iBorderRectangle = CSvgRectElementImpl::NewL(KSvgRectElement, (CSvgDocumentImpl*)iOwnerDocument);
		this->AppendChildL(iBorderRectangle);
		iInnerRectangle = CSvgRectElementImpl::NewL(KSvgRectElement, (CSvgDocumentImpl*)iOwnerDocument);
		this->AppendChildL(iInnerRectangle);

		iInnerRectangle->SetAttributeFloatL(KAtrRx, 2);
		iInnerRectangle->SetAttributeFloatL(KAtrRy, 2);
		iInnerRectangle->SetPropertyL(KCSS_ATTR_FILL, _L("none"));
		iInnerRectangle->SetPropertyL(KCSS_ATTR_STROKEWIDTH, _L(".02"));
		iInnerRectangle->SetPropertyL(KCSS_ATTR_STROKE, _L("black"));

		iBorderRectangle->SetAttributeFloatL(KAtrRx, 2);
		iBorderRectangle->SetAttributeFloatL(KAtrRy, 2);
		iBorderRectangle->SetPropertyL(KCSS_ATTR_FILL, _L("none"));
		iBorderRectangle->SetPropertyL(KCSS_ATTR_STROKEWIDTH, _L(".1"));
		iBorderRectangle->SetPropertyL(KCSS_ATTR_STROKE, _L("black"));

		iInitialized = ETrue;
	}
}

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
TBool CSvgTextAreaElementImpl::DrawL( CGfx2dGc* aGc, CSvgElementImpl* aElement )
{
	if (iBorderRectangle->Width() <= TFloatFixPt(0) || iBorderRectangle->Height() <= TFloatFixPt(0))
		{
			return ETrue;
		}

    TFloatFixPt scale = GetCurrentScale();
    TFloatFixPt width = iInnerRectangle->Width() * scale;
    TFloatFixPt height = iInnerRectangle->Height() * scale;

    if ( width != iLastBBox.iWidth || height != iLastBBox.iHeight )
    {
        iNeedTextRearrange = ETrue;
        iLastBBox.iWidth = width;
        iLastBBox.iHeight = height;
    }

    DrawTextElements( aGc, aElement );

    return ETrue;
 }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
TBool CSvgTextAreaElementImpl::DrawTextElements( CGfx2dGc* aGc, CSvgElementImpl* /*aElement*/ )
{
	//draw text elements...readjust their positions according the width and height of the inner rectangle...
    if (iNeedTextRearrange)
    {
    	//TRAPD(err, ArrangeTextL(aGc));
    	TRAPD(err, LocalizedArrangeTextL(aGc));
    	if (err)
    	    {
		    #ifdef _DEBUG
            _LIT( KErrMsg, "CSvgTextAreaElementImpl::DrawTextElements Error in ArrangeTextL()" );
            RDebug::Print(KErrMsg);
            #endif //_DEBUG
    	    }

    	iNeedTextRearrange = EFalse;
    }

    //draw text until it reaches the inner border then start a new text element on the next line down
    /*if (iTextElementsArray)
    {
    	 for (int i=0; i < iTextElementsArray->Count(); i++)
    	{
			//draw text elements here...
			TRAPD(err, iTextElementsArray->operator[](i)->DrawL(aGc, aElement));
        	if (err)
        	    {
    		    #ifdef _DEBUG
                _LIT( KErrMsg, "CSvgTextAreaElementImpl::DrawTextElements Error in DrawL()" );
                RDebug::Print(KErrMsg);
                #endif //_DEBUG
        	    }

  		}
    }*/

  	return ETrue;
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
void CSvgTextAreaElementImpl::ConstructL(  const TUint8 aElemID )
{
		CSvgElementImpl::InitializeL( aElemID );

		iSvgStyleProperties = new(ELeave) RPointerArray<CCssValue>(KCSS_MAX_ATTR );

    	User::LeaveIfError( iSvgStyleProperties->Append( NULL ) );
    	iSvgStyleProperties->Remove( 0 );

		iTextElementsArray = new (ELeave)RPointerArray<CSvgTextElementImpl> (1);
		iTextElementsArray->Reset();

  		iSvgTransformable = CSvgTransformableImpl::NewL();

		iReqAttrFlag=KSVG_RECT_ELEMFLAG;

		iBorderRectangle = NULL;
		iInnerRectangle = NULL;

		iNeedTextRearrange = ETrue;
		iInitialized = EFalse;

		iAllText = HBufC::NewL( 2 );

  		iEditable = EFalse;

  	// Add this as internal event receiver
  	//((CSvgDocumentImpl*)iOwnerDocument)->AddToEventReceiverListL( this, KSvgEventMaskExternalUI);

	((CSvgDocumentImpl*)OwnerDocument())->AddInternalMouseListener( this );

}

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

CSvgTextAreaElementImpl::CSvgTextAreaElementImpl( CSvgDocumentImpl* aDoc )
{
		SetOwnerDocument(aDoc);
}

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
void CSvgTextAreaElementImpl::GetBBox( TGfxRectangle2D& aBbox )
{
	if (!iInitialized)
	{
		TGfxRectangle2D myRect(0,0,0,0);
		aBbox = myRect;
		return;
	}

    iBorderRectangle->GetBBox( aBbox );
}

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
void CSvgTextAreaElementImpl::GetUnscaledBBox( TGfxRectangle2D& aBbox )
{
	if (!iInitialized)
	{
		TGfxRectangle2D myRect(0,0,0,0);
		aBbox = myRect;
		return;
	}

    iBorderRectangle->GetUnscaledBBox(aBbox);
}

// ---------------------------------------------------------------------------
// perform a deep clone of this object
// ---------------------------------------------------------------------------
MXmlElement* CSvgTextAreaElementImpl::CloneL(MXmlElement* aParentElement)
{
    // create new text area
	CSvgTextAreaElementImpl* newElement = CSvgTextAreaElementImpl::NewL(  this->ElemID(), ((CSvgDocumentImpl*)iOwnerDocument) );

	newElement->iParentNode = aParentElement;
    // copy everything over
    this->CopyL(newElement);

    return newElement;
}

// ---------------------------------------------------------------------------
// perform a deep copy of this object
// ---------------------------------------------------------------------------
void CSvgTextAreaElementImpl::CopyL( CSvgTextAreaElementImpl* aDestElement )
{
    // copy stuff from superclass
    this->CSvgElementImpl::CopyL(aDestElement);

    // copy iRectangle items special to circle
    aDestElement->iBorderRectangle = (CSvgRectElementImpl*)iBorderRectangle->CloneL((MXmlElement*)iBorderRectangle);
    aDestElement->iInnerRectangle = (CSvgRectElementImpl*)iInnerRectangle->CloneL((MXmlElement*)iInnerRectangle);

    if (iTextElementsArray)
    {
    	TInt textEleArrayCnt = iTextElementsArray->Count();
   	 	for (int i=0; i < textEleArrayCnt; i++)
    	{
    		aDestElement->iTextElementsArray->Append((CSvgTextElementImpl*)iTextElementsArray->operator[](i)->CloneL((MXmlElement*)iTextElementsArray->operator[](i)));
    	}
    }

    // copy the reference to idoc (CSvgDocumentImpl)
    aDestElement->iOwnerDocument = this->iOwnerDocument;
}

/*** FROM MSvgMouseListener ***/
// ---------------------------------------------------------------------------
// mouse entered
// ---------------------------------------------------------------------------
TBool CSvgTextAreaElementImpl::MouseEntered( RPointerArray<CSvgElementImpl>& aElements,
                                    TInt /*aX*/, TInt /*aY*/ )
{
	CSvgEngineImpl* engine  = ( ( CSvgDocumentImpl* ) OwnerDocument() )->Engine();

	TInt eleCnt = aElements.Count();
	for (TInt i = 0; i < eleCnt; i++ )
	{
		if ( aElements[i] == this )
		{
			engine->NotifyTextAreaEntered(this);
			return ETrue;
		}
    }

	return EFalse;
}

// ---------------------------------------------------------------------------
// Notified when the mouse pointer exits a visible svg element.
// ---------------------------------------------------------------------------
TBool CSvgTextAreaElementImpl::MouseExited( RPointerArray<CSvgElementImpl>& aElements,
                                   TInt /*aX*/, TInt /*aY*/ )
{
	CSvgEngineImpl* lEngine  = ( ( CSvgDocumentImpl* ) OwnerDocument() )->Engine();

	TInt eleCnt = aElements.Count();
	for (TInt i = 0; i < eleCnt; i++ )
	{
		if ( aElements[i] == this )
		{
			lEngine->NotifyTextAreaExited(this);
			return ETrue;
		}
    }

	return EFalse;
}

// ---------------------------------------------------------------------------
// Notified when the mouse pointer is pressed down on visible svg element.
// ---------------------------------------------------------------------------
TBool CSvgTextAreaElementImpl::MouseMoved( RPointerArray<CSvgElementImpl>& /*aElements*/,
                                    TInt /*aX*/, TInt /*aY*/ )
{
    return EFalse;
}
// ---------------------------------------------------------------------------
// Notified when the mouse pointer is pressed down on visible svg element.
// ---------------------------------------------------------------------------
TBool CSvgTextAreaElementImpl::MousePressed( RPointerArray<CSvgElementImpl>& /*aElements*/,
                                    TInt /*aX*/, TInt /*aY*/ )
{
	return EFalse;
}

// ---------------------------------------------------------------------------
// Notified when the mouse pointer is released on on visible svg element.
// ---------------------------------------------------------------------------
TBool CSvgTextAreaElementImpl::MouseReleased( RPointerArray<CSvgElementImpl>& aElements,
                                    TInt /*aX*/, TInt /*aY*/ )
{
	CSvgEngineImpl* lEngine  = ( ( CSvgDocumentImpl* ) OwnerDocument() )->Engine();

	TInt eleCnt = aElements.Count();
	for (TInt i = 0; i < eleCnt; i++ )
	{
		if ( aElements[i] == this )
		{
			lEngine->NotifyTextAreaActivated(this);
			return ETrue;
		}
    }

    return EFalse;
}

// ---------------------------------------------------------------------------
// void CSvgTextAreaElementImpl::Print()
// ---------------------------------------------------------------------------
void CSvgTextAreaElementImpl::Print( TBool aIsEncodeOn )
{
	if (!aIsEncodeOn)
	{
		#ifdef _DEBUG
		RDebug::Printf("<textarea x=\"%d\" y=\"%d\" width=\"%d\" height=\"%d\" editable=\"%d\" >hmm</textarea>", (int)X(), (int)Y(), (int)Width(), (int)Height(), (int)iEditable/*, iAllText*/);
		#endif
	}
}