/*

* Copyright (c) 2002-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:  Popup form for adding custom controls to popup dialog

*

*/

// INCLUDE FILES

#include <barsread.h>

#include <eikdpage.h>

#include <eikdpsel.h>

#include <eikcapc.h>

#include <eikspace.h>

#include <eikprogi.h>

#include <eikrted.h>

#include <w32std.h>

#include <aknappui.h>

#include <AknsDrawUtils.h>

#include <aknconsts.h>

#include <AknUtils.h>

#include <AknsBasicBackgroundControlContext.h>

#include <AknsFrameBackgroundControlContext.h>

#include <layoutmetadata.cdl.h>

#include <aknsoundsystem.h>

#include <AknBidiTextUtils.h>

#include <AknBitmapAnimation.h>

#include <AknPanic.h>

#include <AknPopupform.h>

#include <AknPictographInterface.h>

#include <AknPictographDrawerInterface.h>

#include <avkon.mbg>

#include <AknIconUtils.h>

#include <aknlayoutscalable_avkon.cdl.h>

#include <AknTasHook.h>

// CONSTANTS

const TInt KMaxNoOfEditorLines = 6;

NONSHARABLE_CLASS(CAknPopupFormExtension) :

    public CCoeControl,

    public MAknPictographAnimatorCallBack,

    public MEikScrollBarObserver

    {

    public:

        static CAknPopupFormExtension* NewL( CAknPopupForm& aOwner );

        ~CAknPopupFormExtension();

        void Draw( const TRect& aRect ) const;

    private: // From MAknPictographAnimatorCallBack

        void DrawPictographArea();

    protected: // From MEikScrollBarObserver

        virtual void HandleScrollEventL(CEikScrollBar* aScrollBar, TEikScrollEvent aEventType);

    private:

        CAknPopupFormExtension( CAknPopupForm& aOwner );

        void ConstructL();

    public:

        CAknPopupForm& iOwner;

        CAknPictographInterface* iPictoInterface;

        TInt iWaitAnimationResourceIndex;

        TBool iHasLabelBackground;

        TInt iCursorLine;

        TBool iToBold;

    };

CAknPopupFormExtension::CAknPopupFormExtension( CAknPopupForm& aOwner )

    : iOwner( aOwner ), iWaitAnimationResourceIndex ( -1 ), iHasLabelBackground( EFalse )

    {

    }

CAknPopupFormExtension* CAknPopupFormExtension::NewL( CAknPopupForm& aOwner )

    {

    CAknPopupFormExtension* self = new( ELeave ) CAknPopupFormExtension( aOwner );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

void CAknPopupFormExtension::ConstructL()

    {

    }

CAknPopupFormExtension::~CAknPopupFormExtension()

    {

    delete iPictoInterface;

    }

void CAknPopupFormExtension::DrawPictographArea()

    {

    iOwner.RedrawHeading();

    }

void CAknPopupFormExtension::HandleScrollEventL(CEikScrollBar* aScrollBar, TEikScrollEvent aEventType)

    {

    if ( AknLayoutUtils::PenEnabled() )

        {

        CEikCaptionedControl* captionedControl = iOwner.GetControlByControlType( EEikCtRichTextEditor );

        CEikRichTextEditor* ed = NULL;

        if ( captionedControl )

            {

            CCoeControl* coe = captionedControl->iControl;

            ed = reinterpret_cast<CEikRichTextEditor*>( coe );

            }

        TInt lpp = KMaxNoOfEditorLines;

        if ( ed && iOwner.TextIsScrollable() )

            {

            if ( iOwner.iFlags.IsSet ( EPopupFormHasEditor ) )

                {

                if ( !iOwner.iFlags.IsSet( EPopupFormUsesPlainFont ) )

                    {

                    lpp--;

                    }

                if ( iOwner.iFlags.IsSet( EPopupFormHasProgbar )|| iOwner.iFlags.IsSet( EPopupFormHasWaitAnim ) )

                    {

                    lpp--;

                    }

                }   

            // Using ed->MoveDisplayL to scroll text will cause some display 

            // error, so use ed->MoveCursorL to instead of it.            

            switch (aEventType)

                {

                case EEikScrollUp:

                    if ( (iOwner.iCurrentLine-1) >= 1 )

                        {

                        iOwner.iCurrentLine--;

                        iOwner.UpdateScrollIndicatorL();

                        while( iCursorLine > iOwner.iCurrentLine )

                            {

                            ed->MoveCursorL( TCursorPosition::EFLineUp, EFalse );

                            iCursorLine--;

                            }                        

                        }

                break;

                case EEikScrollPageUp:

                    {

                   if ( iOwner.iCurrentLine - lpp >= 1)

                        {

                        iOwner.iCurrentLine = iOwner.iCurrentLine - lpp + 1;

                        }

                   else

                        {

                        iOwner.iCurrentLine=1;

                        }

                    iOwner.UpdateScrollIndicatorL();

                    while ( iCursorLine > iOwner.iCurrentLine )

                        {

                        ed->MoveCursorL( TCursorPosition::EFLineUp, EFalse );

                        iCursorLine--;

                        }

                    }

                break;

                case EEikScrollDown:

                    if ( (iOwner.iNoOfEditorLines - iOwner.iCurrentLine) >= lpp )

                        {

                        iOwner.iCurrentLine++;

                        iOwner.UpdateScrollIndicatorL();                                              

                        while ( iCursorLine < iOwner.iCurrentLine - 1 + lpp )

                            {

                            ed->MoveCursorL( TCursorPosition::EFLineDown, EFalse );

                            iCursorLine++;    

                            }

                        }               

                break;

                case EEikScrollPageDown:

                    {

                    if ( (iOwner.iNoOfEditorLines - iOwner.iCurrentLine - lpp) >= (lpp - 1))

                        {

                        iOwner.iCurrentLine = iOwner.iCurrentLine + lpp - 1;

                        }

                   else

                        {

                        iOwner.iCurrentLine = iOwner.iNoOfEditorLines - lpp + 1;

                        }                    

                    iOwner.UpdateScrollIndicatorL();

                    TInt bottomLine = iOwner.iCurrentLine - 1 + lpp;

                    TInt destLine = bottomLine > iOwner.iNoOfEditorLines ? 

                                iOwner.iNoOfEditorLines : bottomLine;

                    while ( iCursorLine < destLine )

                        {

                        ed->MoveCursorL( TCursorPosition::EFLineDown, EFalse );

                        iCursorLine++;                                                                

                        }                    

                    }

                break;

                case EEikScrollThumbDragVert:

                    {

                    TInt currentLine = aScrollBar->Model()->iThumbPosition + 1;

                    if ( ( currentLine >= 1 ) && ( currentLine <= iOwner.iNoOfEditorLines ) )

                        {

                        if (currentLine>iOwner.iCurrentLine)

                            {

                            iOwner.iCurrentLine = currentLine;

                            iOwner.UpdateScrollIndicatorL();

                            TInt bottomLine = currentLine - 1 + lpp;

                            TInt destLine = bottomLine > iOwner.iNoOfEditorLines ? 

                                iOwner.iNoOfEditorLines : bottomLine;

                            while ( iCursorLine < destLine )

                                {

                                ed->MoveCursorL( TCursorPosition::EFLineDown, EFalse );

                                iCursorLine++;                                                                

                                }

                            }

                        if (currentLine<iOwner.iCurrentLine)                        

                            {                            

                            iOwner.iCurrentLine = currentLine;

                            iOwner.UpdateScrollIndicatorL();

                            while( iCursorLine > currentLine )

                                {

                                ed->MoveCursorL( TCursorPosition::EFLineUp, EFalse );

                                iCursorLine--;

                                }                                                       

                            }                        

                        }

                    }

                    break;

            default:

                // Do nothing

                break;

                }

            }

        }

    }

void CAknPopupFormExtension::Draw( const TRect& /* aRect */ ) const

    {

    if ( iHasLabelBackground )

        {

        CWindowGc &gc = SystemGc();

        MAknsSkinInstance* skin = AknsUtils::SkinInstance();

        TAknLayoutRect headingArea;

        TAknLayoutRect headingBackground;

        TAknLayoutRect headingCenter;

        headingArea.LayoutRect( Parent()->Rect(), AknLayoutScalable_Avkon::heading_pane( 0 ).LayoutLine() );

        headingBackground.LayoutRect( headingArea.Rect(), AknLayoutScalable_Avkon::bg_popup_heading_pane(  0 ).LayoutLine() );

        headingCenter.LayoutRect( headingBackground.Rect(), AknLayoutScalable_Avkon::bg_popup_heading_pane_g1().LayoutLine() );

        AknsDrawUtils::DrawFrame( skin, gc, headingBackground.Rect(), headingCenter.Rect(),

                                         KAknsIIDQsnFrPopupHeading,

                                         KAknsIIDQsnFrPopupHeadingCenter);

        }

    }

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

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

// CAknPopupForm::CAknPopupForm

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

// might leave.

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

//

EXPORT_C CAknPopupForm::CAknPopupForm():

 iTimeoutInSeconds( 0 ), iTone( ENoTone ), iType( EAknNote )

    {

    }

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

// CAknPopupForm::CAknPopupForm

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

// might leave.

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

//

EXPORT_C CAknPopupForm::CAknPopupForm( const TTone& aTone, const TInt aTimeout,

                             const TPopupFormType& aType ) :

iTimeoutInSeconds( aTimeout ), iTone( aTone ), iType( aType )

    {

    }

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

// CAknPopupForm::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

EXPORT_C void CAknPopupForm::ConstructL()

    {

    iExtension = CAknPopupFormExtension::NewL( *this );

    }

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

// CAknPopupForm::NewLC

// Two-phased constructor.

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

//

EXPORT_C CAknPopupForm* CAknPopupForm::NewLC( const TTone& aTone,

                                              const TInt aTimeout,

                                              const TPopupFormType& aType )

    {

    CAknPopupForm* self = new ( ELeave ) CAknPopupForm( aTone, aTimeout, aType );

    CleanupStack::PushL( self );

    self->ConstructL();

    AKNTASHOOK_ADDL( self, "CAknPopupForm" );

    return self;

    }

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

// CAknPopupForm::NewL

// Two-phased constructor.

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

//

EXPORT_C CAknPopupForm* CAknPopupForm::NewL( const TTone& aTone,

                                             const TInt aTimeout,

                                             const TPopupFormType& aType )

    {

    CAknPopupForm* self = NewLC( aTone, aTimeout, aType );

    CleanupStack::Pop( self );

    return self;

    }

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

// CAknPopupForm::NewLC

// Two-phased constructor.

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

//

EXPORT_C CAknPopupForm* CAknPopupForm::NewLC()

    {

    CAknPopupForm* self = new ( ELeave ) CAknPopupForm();

    CleanupStack::PushL( self );

    self->ConstructL();

    AKNTASHOOK_ADDL( self, "CAknPopupForm" );

    return self;

    }

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

// CAknPopupForm::NewL

// Two-phased constructor.

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

//

EXPORT_C CAknPopupForm* CAknPopupForm::NewL()

    {

    CAknPopupForm* self = NewLC();

    CleanupStack::Pop( self );

    return self;

    }

// Destructor

EXPORT_C CAknPopupForm::~CAknPopupForm()

    {

    AKNTASHOOK_REMOVE();

    delete iTimer;

    delete iSBFrame;

    delete iBrushAndPenContext;

    delete iExtension;

    }

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

// CAknPopupForm::SetTimeout

//

//

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

//

EXPORT_C void CAknPopupForm::SetTimeout( const TInt aTimeoutInSeconds )

    {

    iTimeoutInSeconds = aTimeoutInSeconds;

    if ( IsVisible() )

        {

        TRAP_IGNORE( StartTimeoutTimerL() );

        }

    }

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

// CAknPopupForm::SetTone

//

//

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

//

EXPORT_C void CAknPopupForm::SetTone( const TTone aTone )

    {

    iTone = aTone;

    }

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

// CAknPopupForm::SetPopupFormType

//

//

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

//

EXPORT_C void CAknPopupForm::SetPopupFormType( const TPopupFormType aType )

    {

    iType = aType;

    }

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

// CAknPopupForm::SetTitleL

// Set the title text. If the given text is too long, truncate it.

//

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

//

EXPORT_C void CAknPopupForm::SetTitleL( const TDesC& aTitle )

    {

    CEikCaptionedControl* captionedControl = GetControlByControlType( EEikCtLabel );

    CEikLabel* head = NULL;

    if ( captionedControl )

        {

        CCoeControl* coe = captionedControl->iControl;

        head = reinterpret_cast<CEikLabel*>( coe );

        }

    if ( head )

        {

        HBufC* clippedString = HBufC::NewLC( aTitle.Length() + KAknBidiExtraSpacePerLine );

        *clippedString = aTitle;

        TPtr clippedStringPtr = clippedString->Des();

        // get the parent rect before it necessarily has been calculated in SetSizeAndPosition

        TRect parentRect = PopupWindowRect();

        TAknLayoutRect layRect;

        layRect.LayoutRect( parentRect, AknLayoutScalable_Avkon::heading_pane( 0 ) );

        TAknLayoutText txtLay;

        txtLay.LayoutText(layRect.Rect(), AknLayoutScalable_Avkon::heading_pane_t1( 0 ) );

        TInt width = txtLay.TextRect().Width();

        if ( clippedString->Length() > 0 )

            {

            _LIT( KCR, "\r" );

            _LIT( KLF, "\n" ); 

            _LIT( KLS, "\x2028" );

            _LIT( KLS1, "\u2028" );       

            TInt run = ETrue;

            while( run )

                {

                TInt lf = clippedStringPtr. Find( KLF );

                if ( lf != KErrNotFound )

                    {

                    clippedStringPtr.Replace( lf, 1, KNullDesC );

                    }

                TInt cr = clippedStringPtr.Find( KCR );

                if ( cr != KErrNotFound )

                    {

                    clippedStringPtr.Replace( cr, 1, KNullDesC );

                    }

                TInt ls = clippedStringPtr.Find( KLS );

                if ( ls != KErrNotFound )

                    {

                    clippedStringPtr.Replace( ls, 1, KNullDesC );

                    }

                else 

                    {

                    ls = clippedStringPtr.Find( KLS1 );

                    if ( ls != KErrNotFound )

                        {

                        clippedStringPtr.Replace( ls, 1, KNullDesC );

                        }                                            

                    }                

                if ( lf == KErrNotFound && cr == KErrNotFound &&

                     ls == KErrNotFound )

                    {

                    run = EFalse;

                    }

                }

            }

        AknBidiTextUtils::ConvertToVisualAndClipL(

            clippedStringPtr, *( head->Font() ), width, width );

        head->SetTextL( clippedStringPtr );

        head->UseLogicalToVisualConversion( EFalse );

        CleanupStack::PopAndDestroy(); // clippedString

        if ( aTitle.Length() == NULL )

            {

            UpdateFlags( EPopupFormHeading, EFalse );

            }

        else if ( !iFlags.IsSet( EPopupFormHasHeading ) )

            {

            UpdateFlags( EPopupFormHeading, ETrue );

            }

        if ( IsActivated() )

            {

            LayoutAndDraw();    

            }

        }

    }

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

// CAknPopupForm::SetTextL

// Set the text. Move the cursor to the start of the text.

//

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

//

EXPORT_C void CAknPopupForm::SetTextL( const TDesC* aText )

    {

    CEikCaptionedControl* captionedControl = GetControlByControlType( EEikCtRichTextEditor );

    if ( captionedControl )

        {

        CCoeControl* coe = captionedControl->iControl;

        CEikRichTextEditor* ed = reinterpret_cast<CEikRichTextEditor*>( coe );

        if ( ed )

            {

            TInt oldNoOfLines = iNoOfEditorLines;

            // In CTextView, only \f is a newline character,

            // so '\n', '\r' and '\u2028' have to be onverted to '\f'.

            HBufC* text = aText->AllocL();

            CleanupStack::PushL( text );            

            TPtr ptr = text->Des();            

            if ( ptr.Length() > 0 )

                {

                _LIT( KLF, "\n" );

                _LIT( KCR, "\r" );

                _LIT( KLS, "\u2028" ); 

                _LIT( KLS1, "\x2028" );

                _LIT( KLineBreak, "\f" );