/*
* 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:  ?Description
*
*/


// INCLUDE FILES

#include "AknInlineText.h"

// LOCAL FUNCTIONS

GLDEF_C void Panic(TAknInlineTextFormattingPanic aPanic)
	{
    User::Panic(KAknInlineTextFormatting, aPanic);
	}

// MODULE TEMPLATES

// MODULE DATA STRUCTURES

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

////////////////////////////////////////////////////////////////////////////////
//
// CAknPositionedInlineText
//
////////////////////////////////////////////////////////////////////////////////

// -----------------------------------------------------------------------------
// 2 stage constructor
// -----------------------------------------------------------------------------

CAknPositionedInlineText* CAknPositionedInlineText::NewL( const TTmDocPos& aPosition, const TDesC& aInlineText )
    {
    CAknPositionedInlineText* self = 
        new (ELeave) CAknPositionedInlineText( aPosition ); // Only partially constructed at this point
    CleanupStack::PushL( self );
    self->ConstructL( aInlineText );
    CleanupStack::Pop();
    return self;
    }

CAknPositionedInlineText::~CAknPositionedInlineText()
    {
    delete iText;
    }

const TTmDocPos& CAknPositionedInlineText::DocPos() const
    {
    return iDocPos;
    }

const TDesC& CAknPositionedInlineText::InlineText() const
    {
    return *iText;
    }

CAknPositionedInlineText::CAknPositionedInlineText( const TTmDocPos& aPosition )
    : iDocPos(aPosition)
    {
    }

void CAknPositionedInlineText::ConstructL( const TDesC& aInlineText )
    {
    iText = aInlineText.AllocL();
    }
////////////////////////////////////////////////////////////////////////////////
//
// CAknInlineTextStore
//
////////////////////////////////////////////////////////////////////////////////

const TInt KAknInlineTextStoreGranularity(2);

CAknInlineTextStore* CAknInlineTextStore::NewL()
    {
    return new (ELeave) CAknInlineTextStore();
    }
       
CAknInlineTextStore::~CAknInlineTextStore()
    {
    ResetAndDestroy();
    }

void CAknInlineTextStore::Clear()
    {
    ResetAndDestroy();
    }

void CAknInlineTextStore::ClearRange( const TTmDocPos& aStart, const TTmDocPos& aEnd )
    {
    TInt nToDelete(0);
    TInt firstToDelete(0);
    for (TInt index = Count() - 1; index >=0 ; --index)
	    {
        CAknPositionedInlineText* inlineText = At(index);
        const TTmDocPos& docPos = inlineText->DocPos();
		if ( aStart <= docPos && docPos <= aEnd )
            {
            delete ( inlineText );
            firstToDelete = index; // running lowest index to delete
            nToDelete++;
            }
		}
    // Perform deletions from array in one go as this is an expensive operation
	if ( nToDelete > 0 )
        Delete( firstToDelete, nToDelete );
    }

void CAknInlineTextStore::InsertInlineTextL( CAknPositionedInlineText* aInlineText )
    {
    TInt insertPosition(0);
    for (TInt ii = Count()-1; ii >= 0; --ii)
		{
		if ( At(ii)->DocPos() <= aInlineText->DocPos() )
            {
            insertPosition = ii+1;
            break;
            }
		}

    InsertL( insertPosition, aInlineText );
    }

const TTmDocPos* CAknInlineTextStore::NextInlineTextDocPos( const TTmDocPos& aDocPos ) const
    {
    const TTmDocPos* retPtr = NULL;
    TInt index = NextIndexStartingAtDocPos( aDocPos );
    if ( index >=0 )
        retPtr = &(At( index )->DocPos());
    return retPtr;
    }

TInt CAknInlineTextStore::NextIndexStartingAtDocPos( const TTmDocPos& aDocPos ) const
    {

    TInt count = Count();
    if ( count == 0 )
        return -1;
      
    if ( At(count-1)->DocPos() < aDocPos  ) // even biggest is at lower docpos
        return -1;

    TInt index;
    for (index = 0; index < count ; ++index)
	    {
		if ( At(index)->DocPos() >= aDocPos  )
            {
            break;
            }
		}

    __ASSERT_DEBUG( index < count , Panic( EAknInlineTextFormattingStoreCorrupted) );

    return index;
    }

TInt CAknInlineTextStore::IndexFromDocPos( const TTmDocPos& aDocPos ) const
    {
    TInt matchedIndex = -1;
    TInt indexFound = NextIndexStartingAtDocPos( aDocPos );
    if (indexFound != -1 &&  At(indexFound)->DocPos() == aDocPos )
        matchedIndex = indexFound;
    return matchedIndex;
    }

CAknInlineTextStore::CAknInlineTextStore() : CArrayPtrFlat<CAknPositionedInlineText>( KAknInlineTextStoreGranularity )
    {}
 

////////////////////////////////////////////////////////////////////////////////
//
// CAknInlineTextSource
//
////////////////////////////////////////////////////////////////////////////////

CAknInlineTextSource::CAknInlineTextSource()
    {}

void CAknInlineTextSource::ConstructL()
    {
    iInlineTextStore = CAknInlineTextStore::NewL();
    }

CAknInlineTextSource::~CAknInlineTextSource()
    {
    delete iInlineTextStore;
    }

TInt CAknInlineTextSource::GetNextInlineTextPosition(
    const TTmDocPos& aFrom, 
    TInt aMaxLength, 
    TTmDocPos& aNext)
    {

    TInt errReturn = KErrNotFound; // Default is that there is nothing found

    const TTmDocPos* nextPos = iInlineTextStore->NextInlineTextDocPos( aFrom );
    // This returns NULL if nothing found   
    if ( nextPos )
        {

        if ( // pos must be strictly less than aFrom + aMaxLength, but may be 1 further if trailing
            (nextPos->iPos < (aFrom.iPos + aMaxLength) )
            || 
            (!nextPos->iLeadingEdge && (nextPos->iPos <= (aFrom.iPos + aMaxLength)) ) 
           )
            {
            aNext = *nextPos; // Copies the structure
            errReturn = KErrNone; // Report valid data
            }
        }
        
    return errReturn;
    }

TPtrC CAknInlineTextSource::GetInlineText(const TTmDocPos& aPos)
    {
    TInt index = iInlineTextStore->IndexFromDocPos( aPos );
    if ( index >= 0 )
        return iInlineTextStore->At( index )->InlineText();
    else
        {
        __ASSERT_DEBUG( EFalse, Panic(EAknInlineTextFormattingBadInlineTextFetch) );
        return KNullDesC();
        }
    }

TBool CAknInlineTextSource::HasInlineTextAt(const TTmDocPos& aPos, TPtrC& aPtrFound) const
    {
    TBool retVal( EFalse );
    TInt index = iInlineTextStore->IndexFromDocPos( aPos );
    if ( index != -1 )
        {
        retVal = ETrue;
        aPtrFound.Set(iInlineTextStore->At( index )->InlineText()) ;
        }
    return retVal;
    }

CAknInlineTextStore* CAknInlineTextSource::InlineTextStore() const
    {
    return iInlineTextStore;
    }

/**
* Empty implementation as all "when to format policy" is determined by sub-classes.  However, 
* this class implements so that sub-classes only have to implement what they need.
*/
void CAknInlineTextSource::CheckFormattingL(const TTmDocPos& /*aFrom*/, const TTmDocPos& /*aTo*/ )
    {}

/**
* Empty implementation as all upon-edit policy is determined by sub-classes.  However, 
* this class implements so that sub-classes only have to implement what they need.
*/
void CAknInlineTextSource::EditObserver( TInt /*aStart*/, TInt /*aExtent*/ ) 
    {}



//  End of File