/*

* Copyright (c) 2005-2006 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:  Implementation for CFepLayoutEditAreaBase

*

*/

#include <peninputcmd.h>

#include <AknBidiTextUtils.h>

#include <AknsDrawUtils.h>

#include <avkon.hrh>

#include "peninputlayouteditareabase.h"

#include "peninputlayoutinsertionpoint.h"

#include "peninputlayout.h"

// CONSTANTS

const TInt KGapLeftOfEachLine = 2;//1;

const TInt KSelectionRectMarginY = 2;

const TInt KDefaultHeight = 10;

const TInt KCursorCorrectionX = -1 * ( KCursorWidth + KCursorPosCorrectionX );

const TInt KDefaultRightMargin = 3 * KCursorWidth;

const TInt KAddBufLen = 100;

const TInt KSecretUpdateTimer = 1000000; // 1s

const TInt KSecretInstantShowTimer = 100000; // 100ms

const TInt KParagraphSeperator = 0x2029;

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

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

// CFepLayoutEditAreaBase::CFepLayoutEditAreaBase

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

// might leave.

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

EXPORT_C CFepLayoutEditAreaBase::CFepLayoutEditAreaBase(TRect aRect,

                                      CFepUiLayout* aUiLayout,TInt aControlId):

    CFepUiBaseCtrl(aRect,aUiLayout,aControlId),

    iCorrectedRect(aRect),iFontOwnership(EFalse)

    {    

    SetControlType(ECtrlEditAreaBase);

    iCursorVisible = ETrue;

    iCursorSelVisible = ETrue;

#ifdef RD_TACTILE_FEEDBACK     

    //register the area for tactile feedback

    if(aUiLayout)

    	{

    	//Advanced Tactile feedback REQ417-47932

    	if(IsKindOfControl(ECtrlTactileFeedback))

    		{

    		SetTactileFeedbackType(ETouchFeedbackSensitiveInput);

    		aUiLayout->RegisterFeedbackArea(reinterpret_cast<TInt>(this),aRect,ETouchFeedbackSensitiveInput);

    		}

    	}

#endif //RD_TACTILE_FEEDBACK   

    }

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

// CFepLayoutEditAreaBase::ConstructL

// Symbian 2nd phase constructor can leave.

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

EXPORT_C void CFepLayoutEditAreaBase::BaseConstructL()

    {

    CFepUiBaseCtrl::BaseConstructL();

    // Initialize text color

    iTextColor = KRgbBlack;

    // Create the caret

    iInsertionPoint = CInsertionPoint::NewL(this,BitmapDevice(),BitGc(),KDefaultHeight);

    iSecretTextTimer = CPeriodic::NewL(CActive::EPriorityStandard);

    }

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

// CFepLayoutEditAreaBase::~CFepLayoutEditAreaBase

// Destructor

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

EXPORT_C CFepLayoutEditAreaBase::~CFepLayoutEditAreaBase()

    {

    delete iInsertionPoint;

    delete iBuffer;    

    delete iVisualBuffer;

    iSecretTextTimer->Cancel();

    delete iSecretTextTimer;

    if(iFontOwnership && iFont)

        {

        BitmapDevice()->ReleaseFont(iFont);

        }    

    iOverlappedCtrlList.Close();

    }

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

// CFepLayoutEditAreaBase::SetRect

// Sets the rectangle

// (other items were commented in a header).

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

//

EXPORT_C void CFepLayoutEditAreaBase::SetRect(TRect aRect)

    {

    CFepUiBaseCtrl::SetRect(aRect);

    iCorrectedRect = aRect;

    iCorrectedRect.iBr.iX += KCursorCorrectionX;

	// resize the background bitmap

    if( BackgroundBmp() && BackgroundBmp()->SizeInPixels() != Rect().Size() )

	    {

	    AknIconUtils::SetSize( BackgroundBmp(), 

	    					   Rect().Size(), 

	    					   EAspectRatioNotPreserved );	    

	    }

	if( BkMaskBmp() && BkMaskBmp()->SizeInPixels() != Rect().Size() )

		{

	    AknIconUtils::SetSize( BkMaskBmp(), 

	    					   Rect().Size(), 

	    					   EAspectRatioNotPreserved );			

		}

    if (iBuffer && iFont)

        {

        TRAP_IGNORE(CalculateDisplayTextL());

        iInsertionPoint->SetPosition(PositionOfInsertionPointOnWindow());

        Draw();

        UpdateArea(Rect(),EFalse);

        }

    }

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

// Handle pointer down event

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

//

EXPORT_C CFepUiBaseCtrl* CFepLayoutEditAreaBase::HandlePointerDownEventL(const TPoint& aPt)

    {

    if (iDimmed || !(iCursorVisible||iCursorSelVisible))

        {

        return NULL;

        }

    CFepUiBaseCtrl::HandlePointerDownEventL(aPt);

    // get the index of the character in render buffer where down event occurred

    TInt caretPos = PositionInVisualText(aPt.iX);

    //cancel any selection

    if(iDisplayTextCurSel.Length() && (iCursorVisible||iCursorSelVisible))

        {

        TRect rect = DrawSelection();

        UpdateArea(rect,EFalse);

        iDisplayTextCurSel.SetSelection(0,0);   

        iSelectedCompositionText.SetSelection(0,0);             

        }

    // set the new cursor position

    TInt newPosition = PositionInDisplayText(aPt.iX);

    SetPositionOfInsertionPointInBuffer(newPosition);   

    iInsertionPoint->SetPosition(PositionOfInsertionPointOnWindow()); 

    SetFocus();

    iScrolling = EFalse;

    CFepUiBaseCtrl* temp = CapturePointer();

    if (temp != this)

        {

        iPreCaptureCtrl = temp;

        }

    return this;

    }

TInt CFepLayoutEditAreaBase::CursorDistance(TInt aX) const

    {

    TInt cursorDistance;

    if ( iTextDirection == TBidiText::ELeftToRight )

        {

        cursorDistance = aX - iCorrectedRect.iTl.iX - KGapLeftOfEachLine;

        }

    else

        {

        cursorDistance = iCorrectedRect.iBr.iX - aX - KGapLeftOfEachLine;

        }

    TInt maxWidth = iCorrectedRect.Width() - KGapLeftOfEachLine;

    if(cursorDistance < 0)

        {

        cursorDistance = 0;

        }

    else 

        {

        cursorDistance = cursorDistance > maxWidth ? maxWidth : cursorDistance;

        }

    return cursorDistance;

    }

TBidiText::TDirectionality CFepLayoutEditAreaBase::CharDirection( TChar aChar ) const

    {

    TBuf<1> buf;

    buf.Zero();

    buf.Append( aChar );

    return TBidiText::TextDirectionality( buf );

    }

void CFepLayoutEditAreaBase::AdjustPostionInVisualText( const TInt /*cursorDistance*/, TInt& /*retVal*/ )

    {

    switch ( iTextDirection )

        {

        case TBidiText::ERightToLeft:

            break;

        case TBidiText::ELeftToRight:

        default:

            break;

        }

    }

TInt CFepLayoutEditAreaBase::PositionInVisualText(TInt aX)

    {

    TInt retVal;

    if(!iBuffer || !iFont)

        {

        // Edit area was empty, position is zero

        retVal = 0;

        return retVal;

        }

    // get the distance of the cursor from the beginning of iCorrectedRect

    TInt cursorDistance = CursorDistance(aX);

    // get the index of the cursor

    retVal = iFont->TextCount(iVisualText, cursorDistance);

    AdjustPostionInVisualText( cursorDistance, retVal ); 

    return retVal;

    }

TPoint CFepLayoutEditAreaBase::PositionInVisualWindow(TInt aCharacterIndex) const //visual text position in ICF

    {

    TPoint position;

    if(iFont)

        position.iY = iCorrectedRect.iTl.iY + (iCorrectedRect.Height() - 

                                    iFont->HeightInPixels())/2;

    else

        position.iY = iCorrectedRect.iTl.iY + (iCorrectedRect.Height()/4);

    if ( iTextDirection ==TBidiText::ELeftToRight )

        {

        if(aCharacterIndex < 0)

            {

            // index too small, set the point to the beginning of iCorrectedRect

            position.iX = iCorrectedRect.iTl.iX;

            }

        else if (aCharacterIndex > iVisualText.Length())

            {

            // index too big, set the point to the end of iCorrectedRect

            position.iX = iCorrectedRect.iBr.iX;

            }

        else

            {

            // calculate the position of the character relative to parent window

            position.iX = KGapLeftOfEachLine + iCorrectedRect.iTl.iX;    

            if(iFont)

                {

                position.iX += iFont->TextWidthInPixels(iVisualText.Left(aCharacterIndex));

                }

            }

        }

    else

        {

        if(aCharacterIndex < 0)

            {

            position.iX = iCorrectedRect.iBr.iX;

            }

        else if (aCharacterIndex > iVisualText.Length())

            {

            position.iX = iCorrectedRect.iTl.iX;

            }

        else

            {

            position.iX = iCorrectedRect.iBr.iX - KGapLeftOfEachLine;    

            if(iFont)

                {

                position.iX -= iFont->TextWidthInPixels(iVisualText.Left(aCharacterIndex));

                }

            }

        }

    return position;

    }

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

// Handle pointer up event

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

//

EXPORT_C CFepUiBaseCtrl* CFepLayoutEditAreaBase::HandlePointerUpEventL(const TPoint& aPt)

    {

    if (iDimmed || !(iCursorVisible||iCursorSelVisible))

        {

        return NULL;

        }

    CFepUiBaseCtrl::HandlePointerUpEventL(aPt);

    iScrolling = EFalse;

    if(iPreCaptureCtrl)

        {

        iPreCaptureCtrl->CapturePointer();

        }

    else

        {

        CapturePointer(EFalse);   

        }

    CalculateDisplayTextL();

    iInsertionPoint->SetPosition(PositionOfInsertionPointOnWindow());

    Draw();

    UpdateArea(Rect(),EFalse);

    return this;    

    }

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

// Handle pointer move event

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

//

EXPORT_C CFepUiBaseCtrl* CFepLayoutEditAreaBase::HandlePointerMoveEventL(const TPoint& aPt)

    {

    if( !PointerDown() || iDimmed || !(iCursorVisible||iCursorSelVisible) ) 

        return this;

	TInt newPosition = PositionInDisplayText(aPt.iX);

    TInt anchorPos = iDisplayTextCurSel.iAnchorPos - iDisplayTextOffset;

    TInt cursorPos = iDisplayTextCurSel.iCursorPos - iDisplayTextOffset;

    if(Rect().Contains(aPt) && newPosition == cursorPos)

        {

        return this;

        }

    iInsertionPoint->DelayCursorWhileDraging();    

    if(aPt.iX < iCorrectedRect.iTl.iX)

        {

        // selection was dragged beyond the left edge of iCorrectedRect -> scroll left

        ScrollLeft();

        } 

    else if(aPt.iX > iCorrectedRect.iBr.iX)

        {

        // selection was dragged beyond the right edge of iCorrectedRect -> scroll right

        ScrollRight();

        }

    else

        {

        // selection was dragged inside visible buffer -> update selection      

        SetPositionOfInsertionPointInBuffer(newPosition, anchorPos);

        iInsertionPoint->SetPosition(PositionOfInsertionPointOnWindow());

        if(iScrolling)

            {

            // text was scrolled just before user dragged the pen back inside iCorrectedRect

            // invalidate entire rect to show the new selection correctly

            Draw();

            UpdateArea(Rect(),EFalse);

            iScrolling = EFalse;

            }

        else

            {         

            if(newPosition != cursorPos )

                {

                TPoint prevPos = PositionInWindow(cursorPos);

                TPoint newPos = PositionInWindow(newPosition);

                // invalidate only changed selection, to minimize flickering

                TRect invalidRect(Rect());

                invalidRect.iTl.iX = Min(prevPos.iX, newPos.iX);

                invalidRect.iBr.iX = Max(prevPos.iX, newPos.iX) + KCursorSelectionGap;

                invalidRect.iBr.iX = invalidRect.iBr.iX > Rect().iBr.iX ? Rect().iBr.iX : invalidRect.iBr.iX;

                Draw();

                UpdateArea(invalidRect,EFalse);

                }

            }

        }

    return this;

    }

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

// Drawa edit area

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

//

EXPORT_C void CFepLayoutEditAreaBase::Draw()

    {

    if(!AbleToDraw())

        return;

    CFbsBitGc* gc = static_cast<CFbsBitGc*>(BitGc());

    TRect rect = Rect();

	DrawOpaqueMaskBackground();

    // ----- draw bitmaps -----

	DrawBackground();

    DrawContent(gc,rect);

    }

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

// CFepLayoutEditAreaBase::DrawSelection()

// Draws the text selection

// (other items were commented in a header).

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

//

TRect CFepLayoutEditAreaBase::DrawSelection()

    {

    CFbsBitGc* gc = static_cast<CFbsBitGc*>(BitGc());

    gc->SetClippingRegion(&ValidClipRegion());

    TRect rect = Rect();

    if (!iFont || iInDragging)

        {

        return TRect(rect.iTl, TSize(0,0));

        }

    TInt baseLine = iFont->AscentInPixels() + (rect.Height() - 

                                                iFont->HeightInPixels())/2;    

    TRect selRect(rect);

    TInt startIndex = iDisplayTextCurSel.LowerPos() - iDisplayTextOffset;

    TInt endIndex = iDisplayTextCurSel.HigherPos() - iDisplayTextOffset;

    if(startIndex < 0)

        {

        // set startIndex to the beginning of the buffer.

        startIndex = 0;

        }

    if(endIndex> iDisplayText.Length())

        {

        // set endIndex to the end of the buffer

        endIndex = iDisplayText.Length();

        }

    TInt pos1 = PositionInWindow(startIndex).iX;

    TInt pos2 = PositionInWindow(endIndex).iX;

    selRect.iTl.iX = Min( pos1, pos2 );

    selRect.iBr.iX = Max( pos1, pos2 );

    if(selRect.iBr.iX > rect.iBr.iX)

        {

        selRect.iBr.iX = rect.iBr.iX;

        }

    selRect.iTl.iY += ((baseLine - iFont->AscentInPixels()) - 

                                                    KSelectionRectMarginY);

    selRect.iBr.iY -= ((rect.Height()-(baseLine + iFont->DescentInPixels()))

                                             - KSelectionRectMarginY);

    selRect.Intersection( rect );

    // draw selection by inverting colors in the selected text rectancle

    gc->SetBrushStyle(CGraphicsContext::ESolidBrush);

    gc->SetBrushColor(KRgbBlack);

    gc->SetDrawMode(CGraphicsContext::EDrawModeNOTSCREEN);

    gc->SetPenSize(PenSize());

    gc->SetPenColor(PenColor());

    gc->DrawRect(selRect);

    // restore normal draw mode

    gc->SetDrawMode(CGraphicsContext::EDrawModePEN);

    gc->SetBrushStyle(CGraphicsContext::ENullBrush);                

    gc->CancelClipping();        

    return selRect;

    }

TInt CFepLayoutEditAreaBase::UpdateSecretText( TAny* aEditArea )

    {

    CFepLayoutEditAreaBase* editArea = static_cast<CFepLayoutEditAreaBase*>(aEditArea);

    if ( !editArea->iTextIsSecret )

        {

        editArea->iSecretTextTimer->Cancel();

        return KErrNone;

        }

    TPtr ptr = editArea->iBuffer->Des();

    TInt startPos = ptr.LocateReverse( '*' ) + 1;

    TBuf<1> buf;

    buf.Append( '*' );

    if ( startPos < ptr.Length() )

        {

        ptr.Replace( startPos, 1, buf );

        if ( startPos == ptr.Length() -1 )

            {

            editArea->iSecretTextTimer->Cancel();

            }

        }

    TRAP_IGNORE(editArea->CalculateDisplayTextL());

    editArea->Draw();

    editArea->UpdateArea(editArea->Rect(),EFalse);

    return KErrNone;

    }

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

// CFepLayoutEditAreaBase::DrawContent

// Draws the text into the given graphic context

// (other items were commented in a header).

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

//