/*

* Copyright (c) 2002 - 2008 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: 

*

*/

#include "AknPhedView.h"

#include "AknPhoneNumberEditor.h"

#include <AknsDrawUtils.h>

#include <gfxtranseffect/gfxtranseffect.h>

#include <akntransitionutils.h>

#include <avkondomainpskeys.h>

#include <e32property.h>

// Helper class that monitor redirection changes

class CRedirectionListener : public CBase, public MAknTransitionUtilsObserver

    {

private:

    TInt AknTransitionCallback( TInt aEvent, TInt aState,

                                const TDesC8* /*aParams*/ )

        {

        if ( aEvent == CAknTransitionUtils::EEventWsBufferRedirection )

            {

            iRedirected = aState;

            if ( iCursorEnabled )

                {

                if ( iRedirected )

                    {

                    if ( iWg && iCursorStatus )

                        {

                        iWg->CancelTextCursor();

                        }

                    iCursorStatus = EFalse;

                    }

                else

                    {

                    iOwner.EnableCursor();

                    }

                }

            }

        return 0;

        }

public:

    CRedirectionListener( CAknPhedView& aOwner ) : iOwner( aOwner )

        {

        iRedirected = 0;

        TInt serverrunning;

        TInt ret=RProperty::Get( KPSUidAvkonDomain, KAknTfxServerStatus,

                 serverrunning );

        if(KErrNone == ret && ETfxSrvRunning == serverrunning) 

	        {

	        RProperty::Get( KPSUidAvkonDomain, KAknTfxServerRedirectionStatus,

	                        iRedirected );

	        iRedirected &= ETfxScreenRedirected;

	        }

        }

    inline void EnableCursor()

        {

        iCursorEnabled = ETrue;

        }

    void DisableCursor()

        {

        if ( iWg && iCursorStatus )

            {

            iWg->CancelTextCursor();

            }

        iCursorEnabled = EFalse;

        iCursorStatus = EFalse;

        }

    void UpdateCursor( const TTextCursor& aCursor )

        {

        TInt redirected=0; // init the value

        //judge the server status, if server is not running, it is no need to get redirect value.

        TInt serverrunning;

        TInt ret=RProperty::Get( KPSUidAvkonDomain, KAknTfxServerStatus,

                 serverrunning );

        if(KErrNone == ret && ETfxSrvRunning == serverrunning) 

            {

            ret=RProperty::Get( KPSUidAvkonDomain, KAknTfxServerRedirectionStatus,

                        redirected );

            if( KErrNone != ret)

                redirected = 0;

            redirected &= ETfxScreenRedirected;

            if ( redirected != iRedirected && redirected )

                {

                AknTransitionCallback( CAknTransitionUtils::EEventWsBufferRedirection,

                                       1, NULL );

                return;

                }

            }

        iRedirected = redirected;

        if ( iCursorEnabled && iWg && iWindow && !iRedirected )

            {

            iWg->SetTextCursor( *iWindow,

                                iOwner.CursorPosition() + TPoint( -1, 0 ),

                                aCursor );

            iCursorStatus = ETrue;

            }

        }

    inline void SetWindows( RWindowGroup* aWg, RWindowBase* aWindow )

        {

        iWg = aWg;

        iWindow = aWindow;

        }

private:

    TBool iRedirected;

    TBool iCursorEnabled;

    TBool iCursorStatus;

    RWindowGroup* iWg;

    RWindowBase* iWindow;

    CAknPhedView& iOwner;

    };

enum TAknPhedViewPanic

    {

    EFormatNullLines,

    EFormatTooManyLines,

    EFormatTooFewLines,

    EEventNullLines,

    ELineNoCursor

    };

void PhedViewPanic( TAknPhedViewPanic aPanic )

    {

    _LIT( KAknPhedView,"AknPhedView" );

    User::Panic( KAknPhedView, aPanic );

    }

TAknPhedViewLine::TAknPhedViewLine()

    {

    Mem::FillZ( this, sizeof( *this ) );

    iCursor = CAknPhedView::KNoPos;

    SetRedrawRequired();

    }

void TAknPhedViewLine::SetFormat( const CFont* aFont, const TRect& aRect, TInt aBaseline )

    {

    iFont = aFont;

    iRect = aRect;

    SetTruncation( iTruncation );

    iBaseline = aBaseline;

    }

TRect TAknPhedViewLine::Rect() const

    {

    return iRect;

    }

void TAknPhedViewLine::SetLeftPos( TInt aPos )

    {

    SetRedrawRequired();

    iLeftPos = aPos;

    if ( InRange(aPos, iModel->Length(), 0 ) )

        {

        if( iLeftPos > 0 && iLeftPos < iModel->Length() && iModel->Language() )

            {

            if ( iModel->ReverseText( iLeftPos ).Length() == 

                 iModel->ReverseText( iLeftPos - 1 ).Length() && !iLeftLine ) 

                {

                iLeftPos++; 

                }

            else if ( iModel->ReverseText( iLeftPos ).Length() == 

                      iModel->ReverseText( iLeftPos - 1 ).Length() && iLeftLine ) 

                {

                iLeftPos--; 

                }

            }

        // count characters that will fit to the right of this new left position

        iRightPos = iLeftPos - CountChars( MaxText(), IsTruncatedLeft(), 

                    !iRightLine, iLeftPos );

        if( iRightPos > 0 && iRightPos < iModel->Length() && iModel->Language() )

            {

            if ( iModel->ReverseText( iRightPos ).Length() == 

                 iModel->ReverseText( iRightPos + 1 ).Length() ) 

                {

                iRightPos++; 

                }

            }

        }

    else

        {

        iRightPos = aPos;

        }

    // propogate change of left hand side to right hand neighbor

    if ( iRightLine )

        iRightLine->SetLeftPos( iRightPos );

    }

void TAknPhedViewLine::SetRightPos( TInt aPos )

    {

    SetRedrawRequired();

    TInt nLength = iModel->Length();

    iRightPos = aPos;

    if ( InRange( aPos, nLength, 0 ) )

        {

        if( iRightPos > 0 && iRightPos < iModel->Length() && iModel->Language() )

            {

            if ( iModel->ReverseText( iRightPos ).Length() == 

                 iModel->ReverseText( iRightPos +1 ).Length() ) 

                {

                iRightPos++; 

                }

            }

        // count characters that will fit to the left of this new right position

        iLeftPos = iRightPos + CountChars( MaxReverseText(), 

                                           IsTruncatedRight(), 

                                           !iLeftLine,

                                           iMirror.Mirror( iRightPos ) );

        if( iLeftPos > 0 && iLeftPos < iModel->Length() && iModel->Language() )

            {

            if ( iModel->ReverseText( iLeftPos ).Length() == 

                 iModel->ReverseText( iLeftPos - 1 ).Length() && !iLeftLine ) 

                {

                iLeftPos++; 

                }

            else if ( iModel->ReverseText( iLeftPos ).Length() == 

                      iModel->ReverseText( iLeftPos - 1 ).Length() && iLeftLine ) 

                {

                iLeftPos--; 

                }

            }

        }

    else

        {

        iLeftPos = aPos;

        }

    // propogate change of right hand side to left hand neighbor

    if ( iLeftLine )

        iLeftLine->SetRightPos( iLeftPos );

    }

TBool TAknPhedViewLine::HandleTextChange( TInt aStart, TInt aEnd )

    {

    // If the text change happens somewhere to the right of my LHS, handle it.

    TBool handled = EFalse;

    if ( aStart == aEnd && !iLeftLine && aStart > iLeftPos)

        {

        iLeftPos = aStart;

        }

    if ( !iRightLine && iRightPos > aStart )

        {

        iRightPos = aStart;

        }

    TInt chars = CountChars( MaxReverseText(), 

                             IsTruncatedRight(), 

                             !iLeftLine, 

                             iMirror.Mirror( iRightPos ) );

    if( iLeftPos < chars )

        {

        iLeftPos = chars;   

        }

    if ( iLeftPos >= aStart || ( !iLeftLine && aStart > iLeftPos ) )

        {

        if( iRightLine )

            {

            iRightLine->SetLeftPos( Max( iRightPos - 1, iRightLine->LeftPos() ) );

            TAknPhedViewLine * firstLine = this;

            while ( firstLine->iRightLine )

                {

                firstLine = firstLine->iRightLine;

                }

            firstLine->SetRightPos( firstLine->RightPos() );

            }

        else

            {

            SetRightPos( iRightPos );

            }

        handled = ETrue;

        }

    else if ( !iLeftLine || iLeftLine->LineWidth() == 0 )

        {

        SetLeftPos( aEnd );        

        }

    return handled;

    }

TBool TAknPhedViewLine::HandleCursorChange( TInt aCursor )

    {

    // cursor rule: cursor goes on bottom most line that can contain it (order is

    // specified by loop order in CAknPhedView::CursorChangeFormat).

    if ( LineContains( aCursor ) )

        {

        iCursor = aCursor;

        return ETrue;

        }

    else

        {

        iCursor = CAknPhedView::KNoPos;

        return EFalse;

        }

    }

void TAknPhedViewLine::HandleSelectionChange( TInt aLeft, TInt aRight )

    {

    if (InRange( iLeftPos, aLeft, aRight ) || LineContains( aLeft ) || aLeft == aRight )

        {

        SetRedrawRequired();

        }

    }

TInt TAknPhedViewLine::CountChars( const TDesC& aDes, 

                                   TBool aStartTruncated, 

                                   TBool aAllowEndTruncation, 

                                   TInt aCharsToEnd) const

    {

    // reduce width for start truncation

    TInt width = iRect.Width();

    if ( aStartTruncated )

        {

        width -= TruncationWidth();

        }

    TInt chars = TextCountWithTranslation( aDes, width );

    if ( aAllowEndTruncation && chars < aCharsToEnd )

        {

        // reduce with for end truncation and recalculate number of chars that will fit

        width -= TruncationWidth();

        chars = TextCountWithTranslation( aDes, width );

        }

    return chars;

    }

void TAknPhedViewLine::SetTruncation( const TDesC& aTruncation )

    {

    SetRedrawRequired();

    iTruncation.Set( aTruncation );

    if ( iFont )

        iTruncationWidth = TextWidthInPixelsWithTranslation( iTruncation );

    }

TBool TAknPhedViewLine::HasSelection() const

    { 

    return SelectionStart() != CAknPhedView::KNoPos; 

    }

TInt TAknPhedViewLine::SelectionStart() const

    {

    TInt start = CAknPhedView::KNoPos;

    if ( iModel->SelectionExists() )

        {

        // This line has selection in it if there is a definite overlap between

        // the line and the selection

        TInt leftMark = iMirror.LeftMark();

        TInt rightMark = iMirror.RightMark();

        if ( InRange( iRightPos, leftMark-1, rightMark ) )

            start = iRightPos;

        else if ( InRange( rightMark, iLeftPos-1, iRightPos ) )

            start = rightMark;

        }

    return start;

    }

TInt TAknPhedViewLine::SelectionEnd() const

    {

    TInt end = CAknPhedView::KNoPos;

    if ( iModel->SelectionExists() )

        {

        // This line has selection in it if there is a definite overlap between

        // the line and the selection

        TInt leftMark = iMirror.LeftMark();

        TInt rightMark = iMirror.RightMark();

        if ( InRange(iLeftPos, leftMark, rightMark+1 ) )

            end = iLeftPos;

        else if ( InRange( leftMark, iLeftPos, iRightPos+1 ) )

            end = leftMark;

        }

    return end;

    }

TInt TAknPhedViewLine::CursorPosToXPos( TInt aCursorPos ) const

    {

    TInt xPos = iRect.iBr.iX;

    if ( IsTruncatedRight() )

        xPos -= TruncationWidth();

    xPos -= TextWidthInPixelsWithTranslation( ReverseText().Left( aCursorPos - iRightPos ) );

    return --xPos;

    }

TInt TAknPhedViewLine::XPosToCursorPos( TInt aXPos ) const

    {

    if ( IsTruncatedRight() )

        aXPos += TruncationWidth();

    TInt cursor = iRightPos + TextCountWithTranslation( ReverseText(), iRect.iBr.iX - aXPos );

    // cursor rule: Cursor can not be beyond the left end of the line

    if ( cursor > iLeftPos )

        cursor = iLeftPos;

    // cursor rule: Cursor should not be on the right end of a line, except the rightmost line

    if ( cursor == iRightPos && cursor < iLeftPos && iRightLine )

        cursor++;

    return cursor;

    }

void TAknPhedViewLine::Draw( CWindowGc& aGc, MAknsSkinInstance* aSkin,

    MAknsControlContext* aContext, const CCoeControl* aControl ) const

    {

    TBool useSkin = AknsDrawUtils::Background( aSkin, aContext, aControl, 

        aGc, iRect );

    // set up colors and styles 

    if( useSkin )

        {        

        aGc.SetBrushStyle( CGraphicsContext::ENullBrush );

        }

    else

        {

        aGc.SetBrushStyle( CGraphicsContext::ESolidBrush );

        }

    aGc.SetPenStyle( CGraphicsContext::ESolidPen );

    aGc.SetPenColor( KRgbBlack );

    aGc.SetBrushColor( KRgbWhite );

    // draw the text, including truncation

    TRect rect = iRect;

    TInt baseline =  Baseline() - iRect.iTl.iY;

    if ( IsTruncatedRight() )

        {

        DrawText( aGc, iTruncation, baseline, rect );

        }    

    if ( IsTruncatedLeft() )

        {

        TInt textWidth = iFont->TextWidthInPixels( Text() );

        TInt truncationWidth = iFont->TextWidthInPixels( iTruncation );

        if ( textWidth + truncationWidth > rect.Width() && Text().Length() >= 1 )    

            {        

            TPtrC text( Text() );

            DrawText(aGc, text.Right( text.Length() - 1 ), baseline, rect );            

            }

        else

            {

            DrawText( aGc, Text(), baseline, rect );

            }

        DrawText( aGc, iTruncation, baseline, rect );        

        }

    else

        {

        DrawText( aGc, Text(), baseline, rect );        

        }

    // blank the rest of the line

    if( !useSkin )

        {

        aGc.SetPenStyle( CGraphicsContext::ENullPen );

        aGc.DrawRect( rect );

        }

    // invert any selection by xoring with white

    if ( HasSelection() )

        {

        DrawHighlightText( aGc, useSkin );

        }

    iRedraw = EFalse;

    }

void TAknPhedViewLine::DrawText( CGraphicsContext& aGc, 

                                 const TDesC& aText, 

                                 TInt aBaseline, 

                                 TRect& aRect) const

    {

    TRgb color = KRgbBlack;

    AknsUtils::GetCachedColor( AknsUtils::SkinInstance(), color,

    aGc.SetPenColor( color );

    // This function shifts the RHS of aRect left by the width of the text drawn.

    // It temporarily limits the draw rectangle to the text width to prevent flicker.

    TPtr buf( TranslatedText( aText ) );

    TInt width = iFont->TextWidthInPixels( buf );

    TInt x = aRect.iTl.iX;

    aRect.iTl.iX = aRect.iBr.iX - width;

    aGc.DrawText( buf, aRect, aBaseline, CGraphicsContext::ERight );

    aRect.iBr.iX -= width;

    aRect.iTl.iX = x;

    }

void TAknPhedViewLine::DrawTextWithTranslation( CGraphicsContext& aGc, 

                                                const TDesC& aText, 

                                                TInt aBaseline, 

                                                TRect& aRect ) const

    {

    TRgb color;

    color = KRgbBlack;

    AknsUtils::GetCachedColor( AknsUtils::SkinInstance(), color,

    aGc.SetPenColor( color );

    TPtr buf( TranslatedText( aText ) );