/*

* Copyright (c) 2002-2007 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 <eikimage.h>

#include <eikcapc.h>

#include <eikon.hrh>

#include <touchfeedback.h>

#include "AknUtils.h"

#include "AknPanic.h"

#include "aknborders.h"

#include "aknappui.h"

#include "aknsoundsystem.h"

#include "aknnotedialog.h"

#include "aknnotecontrol.h"

#include "aknnoteattributes.h"

#include "AknDef.h"

#include <AknsFrameBackgroundControlContext.h>

#include "AknDebug.h"

#ifdef RD_UI_TRANSITION_EFFECTS_POPUPS

#include <gfxtranseffect/gfxtranseffect.h>

#include <akntransitionutils.h>

#include <akntranseffect.h>

#include <e32property.h>

#include <avkondomainpskeys.h>

#include <aknglobalpopupprioritycontroller.h>

#endif

#include <AknTasHook.h> // for testability hooks

const TInt EEikDialogFlagSleeping   =0x20000;

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

// Finds out if this control belongs to the window group that is in focus.

//

//

// @return ETrue if the window group is in focus, otherwise EFalse

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

//

    {

    // this code finds out if this control belongs to window group

    // that is in focus, there are some rare cases when the latest opened

    // popup goes behind another one (e.g. system lock query -> power key menu)

    // we don't want transition in that case

    RWsSession& wsSession = CEikonEnv::Static()->WsSession();

    if ( !node )

        {

        return EFalse;

        }

    TInt nodeWindowGroupId = node->WindowGroupId();

    TInt focusedWindowGroupId = wsSession.GetFocusWindowGroup();

    if ( nodeWindowGroupId == focusedWindowGroupId )

        {

        }

    TInt count = wsSession.NumWindowGroups( 0 );

    // because there is not leave here,so no need to use CleanupStack.

    CArrayFixFlat<TInt>* wgIds = new CArrayFixFlat<TInt>( count );

    if ( wgIds )

        {

        // Get list of window group ids from WServ

        wsSession.WindowGroupList( 0, wgIds );

        // Select the first in the list (which will always be the forground app)

        // and we assume that there always will be at least one window group with zero priority

        TInt wgId = (*wgIds)[0];

        delete wgIds;

        if ( focusedWindowGroupId == wgId )

            {

            return ETrue;

            }

        }

    return EFalse;

//////////////////////////////////////////////////////////////////////

// CAknNoteDialogExtension

//////////////////////////////////////////////////////////////////////

NONSHARABLE_CLASS(CAknNoteDialogExtension) : public CBase

#ifdef RD_UI_TRANSITION_EFFECTS_POPUPS

				                ,public MAknTransitionUtilsObserver

#endif											 

    {

    public:

        static CAknNoteDialogExtension* NewL( CAknNoteDialog& aOwner );

        ~CAknNoteDialogExtension();

#ifdef RD_UI_TRANSITION_EFFECTS_POPUPS

        // From MAknTransitionUtilsObserver

		TInt AknTransitionCallback(TInt aEvent, TInt aState = 0, 

                                   const TDesC8* aParams = NULL);

#endif

    private:

        CAknNoteDialogExtension( CAknNoteDialog& aOwner );

        void ConstructL();

    public:

        CAknNoteDialog& iOwner;

#ifdef RD_UI_TRANSITION_EFFECTS_POPUPS

    // NoteControl() is now protected in CAknNoteDialog, so we need this

    // to start the animation from the callback.

    public:

        CAknNoteControl* iControl;

#endif

    };

CAknNoteDialogExtension::CAknNoteDialogExtension( CAknNoteDialog& aOwner )

    : iOwner( aOwner ) 

    {

    }

CAknNoteDialogExtension* CAknNoteDialogExtension::NewL( CAknNoteDialog& aOwner )

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

void CAknNoteDialogExtension::ConstructL()

    {

    }

CAknNoteDialogExtension::~CAknNoteDialogExtension()

    {

#ifdef RD_UI_TRANSITION_EFFECTS_POPUPS

	CAknTransitionUtils::RemoveObserver( this, 

	    CAknTransitionUtils::EEventControlTransitionFinished );

#endif

    }

#ifdef RD_UI_TRANSITION_EFFECTS_POPUPS

TInt CAknNoteDialogExtension::AknTransitionCallback(TInt /*aEvent*/, 

                                                    TInt /*aState*/, 

                                                    const TDesC8* /*aParams*/)

	{

	TRAP_IGNORE(iControl->StartAnimationL());

	CAknTransitionUtils::RemoveObserver( this, 

	    CAknTransitionUtils::EEventControlTransitionFinished );

	return KErrNone;

	}

#endif

//////////////////////////////////////////////////////////////////////

// Construction/Destruction

//////////////////////////////////////////////////////////////////////

EXPORT_C CAknNoteDialog::CAknNoteDialog() : CEikDialog(),

    iTimeoutInMicroseconds(ENoTimeout), iTone(ENoTone)

    {

    AKNTASHOOK_ADD( this, "CAknNoteDialog" );

    }

EXPORT_C CAknNoteDialog::CAknNoteDialog(const TTone& aTone, const TTimeout& aTimeout) :

    CEikDialog(), iTimeoutInMicroseconds(aTimeout), iTone(aTone)

    {

    AKNTASHOOK_ADD( this, "CAknNoteDialog" );

    }

EXPORT_C CAknNoteDialog::CAknNoteDialog(CEikDialog** aSelfPtr,const TTone& aTone, const TTimeout& aTimeout) :

    CEikDialog(), iTimeoutInMicroseconds(aTimeout), iSelfPtr(aSelfPtr), iTone(aTone)

     {

     AKNTASHOOK_ADD( this, "CAknNoteDialog" );

     }

EXPORT_C CAknNoteDialog::~CAknNoteDialog()

    {

    AKNTASHOOK_REMOVE();

// FIXME: Experimental heuristics for determining popup type

#ifdef RD_UI_TRANSITION_EFFECTS_POPUPS

    if ( GfxTransEffect::IsRegistered( this ) )

        {

        // abort component effects (possibly appear effect) 

        // if aknnote gets destroyed without user interaction or timers

        GfxTransEffect::NotifyExternalState( ENotifyGlobalAbort );

		GfxTransEffect::Deregister(this); //Always deregister in destructor.

        }

    CAknTransitionUtils::RemoveData( ( TInt )NoteControl() );

#endif    

    delete iTimer;

#if defined _DEBUG && defined __WINS__

    if (!(DialogFlags()&EEikDialogFlagWait))

        DbgCheckSelfPtr(iSelfPtr);

#endif

    if (iSelfPtr) 

        {

        *iSelfPtr = NULL;

        iSelfPtr = NULL;

        }

    delete iControlAttributes;

    delete iNoteExtension;

    }

EXPORT_C void CAknNoteDialog::SetTimeout(const TTimeout& aTimeout)

    {

    iTimeoutInMicroseconds = aTimeout;

    }

EXPORT_C void CAknNoteDialog::SetTone(const TTone& aTone)

    {

    iTone = aTone;

    }

EXPORT_C void CAknNoteDialog::SetTextWrapping(TBool aEnabled)

    {

    CAknNoteAttributes* attr = ControlAttributes();

    if ( !attr )

        {

        return; // Nothing else we can do

        }

    if (aEnabled)

        {

        attr->iClearFlags.Set(ENoteNoTextWrapping);

        }

    else

        {

        attr->iFlags.Set(ENoteNoTextWrapping);

        }

    LayoutAndDraw();

    }

EXPORT_C void CAknNoteDialog::SetTextProcessing(TBool aEnabled)

    {

    CAknNoteAttributes* attr = ControlAttributes();

    if ( !attr )

        {

        return; // Nothing else we can do

        }

    if (aEnabled)

        {

        attr->iClearFlags.Set(ENoteNoTextProcessing);

        }

    else

        {

        attr->iFlags.Set(ENoteNoTextProcessing);

        }

    LayoutAndDraw();    

    }

EXPORT_C void CAknNoteDialog::SetImageL(CEikImage* aImage)

    {

    CAknNoteAttributes* attr = ControlAttributes();

    if ( !attr )

        {

        User::Leave(KErrNoMemory);

        }

    attr->SetImageL(aImage);

    if (attr->IsLayoutNeeded())

        {

        LayoutAndDraw();

        }   

    }

EXPORT_C void CAknNoteDialog::SetIconL(CEikImage* aIcon)

    {

    CAknNoteAttributes* attr = ControlAttributes();

    if ( !attr )

        {

        User::Leave(KErrNoMemory);

        }

    attr->SetIconL(aIcon);

    if (attr->IsLayoutNeeded())

        {

        LayoutAndDraw();

        }   

    }

EXPORT_C void CAknNoteDialog::SetTextNumberL(TInt aNumber)

    {

    CAknNoteAttributes* attr = ControlAttributes();

    if ( !attr )

        {

        User::Leave(KErrNoMemory);

        }

    attr->SetTextNumberL(aNumber);

    if (attr->IsLayoutNeeded())

        {

        LayoutAndDraw();

        }   

    }

EXPORT_C void CAknNoteDialog::SetTextPluralityL(const TBool aIsPlural)

    {

    CAknNoteAttributes* attr = ControlAttributes();

    if ( !attr )

        {

        User::Leave(KErrNoMemory);

        }

    attr->SetTextPluralityL(aIsPlural);

    if (attr->IsLayoutNeeded())

        {

        LayoutAndDraw();

        }   

    }

EXPORT_C void CAknNoteDialog::SetTextL(const TDesC& aLabel)

    {

    CAknNoteAttributes* attr = ControlAttributes();

    if ( !attr )

        {

        User::Leave(KErrNoMemory);

        }

    if (attr->Text().Compare( aLabel ) )

        {

        attr->SetTextL(aLabel);

        if (attr->IsLayoutNeeded())

            {

            LayoutAndDraw();

            }   

        }

    }

/**

 * @deprecated - use SetTextL

 */

EXPORT_C void CAknNoteDialog::SetCurrentLabelL(TInt /*aControlId*/,const TDesC& aLabel)

    {

    SetTextL(aLabel);

    }

EXPORT_C TKeyResponse CAknNoteDialog::OfferKeyEventL(const TKeyEvent& aKeyEvent,TEventCode aType)

    {

    /// Only interested in standard key events

    if (aType != EEventKey ||

        (aType == EEventKey && aKeyEvent.iCode == EKeyEscape)

        ) // must pass escape event to dialog.

        {

        return CEikDialog::OfferKeyEventL(aKeyEvent,aType);

        }

    /// All short keypresses dismisses the note

    if ( !aKeyEvent.iRepeats )

        {

        StaticDeleteL(this);

        }

    return EKeyWasConsumed;

    }

EXPORT_C void CAknNoteDialog::LayoutAndDraw()

    {

    if (IsActivated())

        {

        TRect screenRect = iAvkonAppUi->ApplicationRect();

        SetSizeAndPosition(PreferredSize( screenRect.Size()/*TSize(AKN_LAYOUT_WINDOW_screen.iW,AKN_LAYOUT_WINDOW_screen.iH)*/));

        DrawNow();

        // Tell the attributes that the note has been fully drawn.

        // Optimized text drawing is allowed only after this.

        CAknNoteAttributes* attr = ControlAttributes();

        if ( attr )

            {

            attr->AllowOptimizedDrawing();

            }

        }

    }

EXPORT_C TInt CAknNoteDialog::RunLD()

    {

    PlayTone();

    ReportUserActivity();

// FIXME: Experimental heuristics for finding out popup context from image/animation

#ifdef RD_UI_TRANSITION_EFFECTS_POPUPS    

    TInt uid = ( TInt )CAknTransitionUtils::GetData( ( TInt )NoteControl() );

    // only change registration, if not registered, don't register

    if ( uid != 0 &&  GfxTransEffect::IsRegistered( this ) ) 

        {

        GfxTransEffect::Register( this, TUid::Uid( uid ) );

        CAknTransitionUtils::RemoveData( ( TInt )NoteControl() );

        }

#endif

    return CEikDialog::RunLD();

    }

EXPORT_C TInt CAknNoteDialog::StaticDeleteL(TAny *aThis)

    {

    CAknNoteDialog* self = REINTERPRET_CAST(CAknNoteDialog*,aThis);

#ifdef RD_UI_TRANSITION_EFFECTS_POPUPS           

    if ( self->IsVisible() && GfxTransEffect::IsRegistered( self ) &&

		{

        TBool rsWasEnabled( EFalse );

        if( !CAknEnv::Static()->TransparencyEnabled() && self->DrawableWindow() && self->Window().IsRedrawStoreEnabled() )

            {

            rsWasEnabled = ETrue;

            // disable redrawstore during transition to avoid

            // drawing problems behind control

            self->Window().EnableRedrawStore( EFalse );

            }

        GfxTransEffect::NotifyExternalState( ENotifyGlobalAbort ); 

		//If still visible, do a transition to invisible state.

		CAknTransitionUtils::SetAllParents(self);

		GfxTransEffect::Begin(self, KGfxControlDisappearAction);

		GfxTransEffect::NotifyExternalState(ECaptureComponentsBegin, (const TDesC8*)self);

		TRect demarcation;

		CAknTransitionUtils::GetDemarcation(CAknTransitionUtils::EPopup, 

		                                    demarcation);

		GfxTransEffect::SetDemarcation(self, demarcation);

		self->MakeVisible(EFalse);

		GfxTransEffect::NotifyExternalState(ECaptureComponentsEnd, (const TDesC8*)self);

		GfxTransEffect::End(self);

		if( !CAknEnv::Static()->TransparencyEnabled() && rsWasEnabled )

            {

            // if redrawstore was on before transition,

            // enable it again

            self->Window().EnableRedrawStore( ETrue );

            }

		}

#endif // RD_UI_TRANSITION_EFFECTS_POPUPS        

    // Only actual delete the note if it's not a sleeping note

    // Deleting a sleeping note is really bad!

    if (!(self->DialogFlags()&EEikDialogFlagSleeping))

        {

        delete self; 

        }

    else

        {

        // Tell subclasses that the dialog is going to sleep

        if (self->iTimer)

            self->iTimer->Cancel();

        self->OkToExitL(KErrCancel);

        self->ExitSleepingDialog();

        self->NoteControl()->Reset();

        }

    return EFalse;

    }

EXPORT_C void CAknNoteDialog::SetSizeAndPosition( const TSize& aSize )

    {

    SetBorder( TGulBorder::ENone );

    CAknNoteControl* note = NoteControl();

    if (note)

        {

        if (!ControlAttributes()->IsLayoutNeeded()) // if we have a note control, there must be attributes also

            return;

        if ( AknLayoutUtils::PenEnabled() )

            {

            CEikDialog::SetSizeAndPosition( aSize );

            }

        else

            {

            TRect mainPane;

            AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EPopupParent,

                mainPane );

            TAknWindowLineLayout dialogLay;

            note->WindowLayout( dialogLay );

            AknLayoutUtils::LayoutControl(this, mainPane, dialogLay);

            }

        ControlAttributes()->SetLayoutDone();                

        }

    }

EXPORT_C void CAknNoteDialog::PreLayoutDynInitL()

    {

    TransferControlAttributes();

    if ( AknLayoutUtils::PenEnabled() )

        {

        // set to capture globally, if dialog have to be closed when tapped to screen

        if ( DialogFlags()&EEikDialogFlagCloseDialogWhenTapped ) 

            {

            SetGloballyCapturing(ETrue);        

            }

        SetPointerCapture(ETrue);

        }