/*

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

*

*/

// AknPopup.cpp

//

// Copyright (c) 1997-2001 Symbian Ltd.  All rights reserved.

//

#include <aknPopupHeadingPane.h>

#include <AknPanic.h>

#include <aknsfld.h>

#include <AknsFrameBackgroundControlContext.h>

#include <eikfrlbd.h>

#include <eikmop.h>

#include <aknlayoutscalable_avkon.cdl.h>

#include <skinlayout.cdl.h>

#include <aknglobalpopupprioritycontroller.h>

#include <touchfeedback.h>

#ifdef RD_UI_TRANSITION_EFFECTS_POPUPS

#include <gfxtranseffect/gfxtranseffect.h>

#include <akntransitionutils.h>

#endif

#include <AknTasHook.h>

#include "aknPopup.h"

#include "akntrace.h"

#include "aknitemactionmenuregister.h"

const TInt KSpaceBelowTitle=7;

const TInt KSoftkeyHeightUndefined = -1;

enum TPopUpListFlags

    {    

    EPopupHandlingPointerEvent    = 0x01,

    EPopupAcceptAfterPointerEvent = 0x02,

    //EFTG-7HWDP6.

    //When portrait is initial model, and 'Full screen QWERTY keyboard' is default input method,

    //the behavior that double tap edit's area quickly may be treated by different control.

    //Findpane deals with first tapping, the Fep will be invoked,Then the model will changed from portrait to landscape.

    //Popuplist deals with second tapping. It invoke AttemptExitL( Efalse ) because pointer is outside of the popuplist.

    //The result is 'Full Screen QWERTY Keyboard' colsed. So we must prevent popuplist's exit in this case.

    //EPopupFepStartEvent will prevent popuplist's exit.        

    //EPopupLayoutSwitchEvent is a flag that decide EPopupFepStartEvent is valid or not.

    EPopupFepStartEvent           = 0x04,   

    EPopupLayoutSwitchEvent       = 0x08,

    // Multiselect popup list should not close when delay highlight happen 

    EPopupDelayHighlight          = 0x10,

    EPopupCancelAfterPointerEvent = 0x20,

    // Popup application is single click enabled.

    EPopupSingleClickEnabled      = 0x40

    };

/**

* Calculates and returns softkey rectangle.

*/

static TRect SoftkeyRect()

    {

    TRect screen;

    AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EScreen, screen );

    TAknLayoutRect softkeyRect;

    softkeyRect.LayoutRect( screen, 

        AknLayoutScalable_Avkon::popup_sk_window( 0 ).LayoutLine() );

    return softkeyRect.Rect();

    }

NONSHARABLE_CLASS(CAknPopupListExtension): public CBase

    {

    public:

        CAknPopupListExtension();

        ~CAknPopupListExtension();

        /**

         * Returns ETrue if popup pointer event is accepted otherwise EFalse.

         * 

         * @param aListBox Popup list listbox.

         * @return ETrue if event is accepted.

         */

        TBool AcceptPointerEvent( CEikListBox* aListBox ) const;

        /**

         * Returns ETrue if list box event is accepted otherwise EFalse.

         * 

         * @param aListBox Popup list listbox.

         * @param aEventType List event type.

         * @return ETrue if event is accepted.

         */

        TBool AcceptListBoxEvent(

                CEikListBox* aListBox,

                MEikListBoxObserver::TListBoxEvent aEventType ) const;

    public:

        CAknSearchField* iSearchControl;    // owned

        CAknsFrameBackgroundControlContext* iBgContext;        

        TInt  iFlags;    

        TBool iItemDraggingActioned;  

    };

CAknPopupListExtension::CAknPopupListExtension()

    {

    if ( AknLayoutUtils::PenEnabled() )

        {

        iFlags = 0;

        }

    }

CAknPopupListExtension::~CAknPopupListExtension()

    {

    delete iBgContext;

    }

TBool CAknPopupListExtension::AcceptPointerEvent(

        CEikListBox* aListBox ) const

    {

    TBool accept( EFalse );

    if ( aListBox )

        {

        // Do not accept if multiselection

        // or flag does not allow accepting

        // or highlight is disabled (list is view only)

        accept = !aListBox->IsMultiselection()

            && ( iFlags & EPopupAcceptAfterPointerEvent

            || iFlags & EPopupCancelAfterPointerEvent )

            && !( aListBox->View()->ItemDrawer()->Flags()

                    & CListItemDrawer::EDisableHighlight );

        }

    return accept;

    }

TBool CAknPopupListExtension::AcceptListBoxEvent(

        CEikListBox* aListBox,

        MEikListBoxObserver::TListBoxEvent aEventType ) const

    {

    TBool accept( EFalse );

    if ( aListBox )

        {

        switch ( aEventType )

            {

            case ( MEikListBoxObserver::EEventItemClicked ):

            case ( MEikListBoxObserver::EEventItemSingleClicked ):

                {

                if ( iItemDraggingActioned

                        || aListBox->IsMultiselection()

                        || ( !( iFlags & EPopupSingleClickEnabled )

                                && !AknLayoutUtils::PenEnabled() ) )

                    {

                    break;

                    }

                } // Fall through

            case ( MEikListBoxObserver::EEventEnterKeyPressed ):

                {

                accept = ETrue;

                break;

                }

            default:

                {

                break;

                }

            }

        }

    return accept;

    }

/**

* Constructor

*

*/

EXPORT_C CAknPopupList::CAknPopupList()

    {

    SetMopParent(iEikonEnv->EikAppUi());

#ifdef RD_UI_TRANSITION_EFFECTS_POPUPS

    GfxTransEffect::Register( this, KGfxContextMenuControlUid );

#endif

    }

/**

* Destructor

*

*/

EXPORT_C CAknPopupList::~CAknPopupList()

    {

    _AKNTRACE_FUNC_ENTER;

    AKNTASHOOK_REMOVE();

    if ( iPopoutCba )

        {

        iPopoutCba->MakeVisible( EFalse );

        }

#ifdef RD_UI_TRANSITION_EFFECTS_POPUPS

    // prevent drawing when Deregistering

    MakeVisible( EFalse ); 

    GfxTransEffect::Deregister( this );

#endif

    if (iCoeEnv && iEikonEnv)

        {

        iEikonEnv->RemoveFromStack(this);

        if (iAppBroughtForwards)

            iEikonEnv->BringForwards(EFalse);

        }

    if (iReturn)

        {

        FadeBehindPopup(EFalse);

        }

    AknGlobalPopupPriorityController::RemovePopupPriority(*this);

    delete iTitle;

    delete iPopoutCba;

    delete iIdle;

    if (FindBox())

        {

        delete FindBox();

        }

    delete iPopupListExtension;

    // Only stop the scheduler if a return value has been set -

    // otherwise the construction failed before the scheduler started.

    // The iReturn value is a convienient value to use since it is the

    // last member ste before the actiave scheduler is started.

    // Reset action menu register

    AknItemActionMenuRegister::SetConstructingMenuBarOwnerL( NULL );

    _AKNTRACE_FUNC_EXIT;

    }

EXPORT_C void CAknPopupList::CloseState()

    {

    _AKNTRACE_FUNC_ENTER;

    CancelPopup();

    _AKNTRACE_FUNC_EXIT;

    }

EXPORT_C void CAknPopupList::SetMaximumHeight(TInt aItems)

    {

    _AKNTRACE("CAknPopupList::SetMaximumHeight aItems=%d", aItems);

    iLayout.iMaximumHeight = aItems;

    }

/**

* Creates the pop-up list

*

* @param        aListBox        Pre-existing listbox-derived class

* @param        aCbaResource        Softkey pane to display while pop-up is active

*/

EXPORT_C CAknPopupList* CAknPopupList::NewL(CEikListBox* aListBox, TInt aCbaResource, AknPopupLayouts::TAknPopupLayouts aType)

    {

    _AKNTRACE_FUNC_ENTER;

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

    CleanupStack::PushL(self);

    self->ConstructL(aListBox, aCbaResource, aType);

    CleanupStack::Pop();        // self

    AKNTASHOOK_ADDL( self, "CAknPopupList" );

    _AKNTRACE_FUNC_EXIT;

    return self;

    }

/**

* 2nd phase construction

*

*/

EXPORT_C void CAknPopupList::ConstructL(CEikListBox* aListBox, TInt aCbaResource, AknPopupLayouts::TAknPopupLayouts aType)

    {

    _AKNTRACE_FUNC_ENTER;

    CreateWindowL();

    Window().SetPointerGrab(ETrue);

    if( CAknEnv::Static()->TransparencyEnabled() )

        {

        Window().SetRequiredDisplayMode( EColor16MA );

        TInt err = Window().SetTransparencyAlphaChannel();

        if ( err == KErrNone )

            {

            Window().SetBackgroundColor(~0);

            }

        }

    iListBox = aListBox;

    iWindowType = aType;

    // Set a popout-type border

    iBorder.SetType(TGulBorder::ENone);

    iListBox->SetBorder(TGulBorder::ENone);

    // Create extension class

    if (!iPopupListExtension)

        iPopupListExtension = new (ELeave) CAknPopupListExtension(); 

    CAknAppUi* appUi = static_cast<CAknAppUi*>( iEikonEnv->EikAppUi() );

    if ( appUi && appUi->IsSingleClickCompatible() )

        {

        iPopupListExtension->iFlags |= EPopupSingleClickEnabled;

        }

    // If the system 'markable' CBA's are used, flag the listbox

    // as markable. (This allows it to update the CBA when the selected item

    // is changed).

    if (aCbaResource == R_AVKON_SOFTKEYS_MARK_BACK ||

        aCbaResource == R_AVKON_SOFTKEYS_UNMARK_BACK)

        iMarkable = ETrue;

    iCurrentResource = aCbaResource;

    // Create a CBA for use with the popup

    TUint flags = CEikButtonGroupContainer::EAddToStack;

    // Embedded CBA only in touch layout

    if ( AknLayoutUtils::PenEnabled() )

        {

        flags |= CEikButtonGroupContainer::EIsEmbedded;

        flags |= CEikButtonGroupContainer::EDelayActivation;

        }

    // Notify action menu register though popup list has no menubar.

    // This way item action menu and list is linked correctly and item

    // specific softkey state is changed according to list highlight.

    AknItemActionMenuRegister::SetConstructingMenuBarOwnerL( this );

    iPopoutCba = CEikButtonGroupContainer::NewL(

                CEikButtonGroupContainer::ECba,

                CEikButtonGroupContainer::EHorizontal,

                this, iCurrentResource, *this, flags );

    // non visible CBA's do not recieve keys

    iPopoutCba->MakeVisible(EFalse);

	AknGlobalPopupPriorityController::AddSubPopupL(*this, *iPopoutCba->ButtonGroup()->AsControl());

    iPopupListExtension->iBgContext = NULL;

    SetGloballyCapturing( ETrue );

    SetPointerCapture( ETrue );

    _AKNTRACE_FUNC_EXIT;

    }

/**

* Set the title for the selection list

*

* @param        aTitle        Title to be displayed

*/

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

    {

    _AKNTRACE("CAknPopupList::SetTitleL: aTitle=%S",&aTitle);

    if (!iTitle)

        {

        iTitle = new(ELeave)CAknPopupHeadingPane;

        iTitle->SetContainerWindowL(*this);

        iTitle->ConstructL(aTitle);

        } 

    else 

        {

        iTitle->SetTextL(aTitle);

        }

    }

/**

* Executes the pop-up selection list. Only returns when the user can accepted

* or cancelled the pop-up.

*

* @return        ETrue if the popup was accepted. EFalse if the popup was cancelled

*/

EXPORT_C TBool CAknPopupList::ExecuteLD()

    {

    _AKNTRACE_FUNC_ENTER;

    __ASSERT_DEBUG(iListBox,Panic(EAknPanicListboxUndefined));

    iPopoutCba->SetBoundingRect(TRect(iAvkonAppUi->ApplicationRect().Size()));

    // Disable item specific menu just before the popup is about to be shown.

    // It can't be done earlier since CAknPopupList doesn't know whether the

    // embedded listbox is fully constructed when passed to its constructor or

    // not.

    iListBox->DisableItemSpecificMenu();

    // Technically it's wrong to disable findbox here, but doing so improves

    // compatibility with the old CAknEnv::ExecuteEmptyPopupListL implementation.

    // This code block can be removed to make the findbox permanently visible

    // (as is the case with main pane lists that use a fixed findbox).

    if ( FindBox() && iListBox->Model()->NumberOfItems() == 0 )

        {

        STATIC_CAST(CAknFilteredTextListBoxModel*,

                    ListBox()->Model())->Filter()->SetSearchField( NULL );

        FindBox()->Editor().SetFocus( EFalse );                    

        delete iPopupListExtension->iSearchControl;

        iPopupListExtension->iSearchControl = NULL;

        }

    if (FindBox())

        {

        SetupWindowLayout(AknPopupLayouts::TAknPopupLayouts(EAknPopupLayoutsFind + iWindowType));

        }        

    else

        {

        SetupWindowLayout(iWindowType);

        }

    iListBox->SetListBoxObserver(this);        

    iPopoutCba->MakeVisible(ETrue);

    AknGlobalPopupPriorityController::AddPopupToControlStackL(*this,ECoeStackPriorityDialog);

    AknGlobalPopupPriorityController::AddPopupToControlStackL(*iPopoutCba->ButtonGroup()->AsControl(),

        ECoeStackPriorityCba, ECoeStackFlagRefusesFocus );

    SetFocus(ETrue);

    if (iMarkable)

        {

        // If markable, set the popup to observe event change events.

        // Call HandleControlEvent to set the CBA appropriate to the 1st item

        iListBox->SetObserver(this);

        HandleControlEventL(iListBox, EEventStateChanged);

        }

    FadeBehindPopup( ETrue );

    #ifdef RD_UI_TRANSITION_EFFECTS_PHASE2	

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

    // this is done to find out if popuplist is shown behind another dialog

    // (this happens in wlan setup queries) If popuplist is not on foreground

    // the transition effect is skipped

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

	TInt focusGroup = wsSession.GetFocusWindowGroup();

    TInt count = wsSession.NumWindowGroups(0);

    TBool thisIsFocused( EFalse );

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

    CleanupStack::PushL(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)

    TInt wgId = (*wgIds)[0];

    if( focusGroup == wgId )

        thisIsFocused = ETrue;

    CleanupStack::PopAndDestroy();  // wgIds;

	#endif //RD_UI_TRANSITION_EFFECTS_PHASE2

#ifdef RD_UI_TRANSITION_EFFECTS_POPUPS

	if( GfxTransEffect::IsRegistered(this) && thisIsFocused )

		{

    MakeVisible( EFalse );

    CAknTransitionUtils::MakeVisibleSubComponents( this,

                                        CAknTransitionUtils::EForceInvisible );

		}

#endif

    ActivateL();

    iPopoutCba->ActivateL();

    // this is required here to make code like

    // iList->SetCurrentItemIndex( last item of the list );

    // iPopupList->ExecuteLD();

    // to work as it used to. Without this current item of the

    // list would be topmost item, and there would be unused empty

    // space below that.

    iListBox->UpdateScrollBarsL();

#ifdef RD_UI_TRANSITION_EFFECTS_POPUPS

    if(GfxTransEffect::IsRegistered(this) && thisIsFocused )

        {

        CAknTransitionUtils::SetAllParents(this);

#ifdef RD_UI_TRANSITION_EFFECTS_POPUPS

        // sequence support

        GfxTransEffect::NotifyExternalState(EInternalHandleSequence, (const TDesC8*)this);

#endif

        GfxTransEffect::Begin(this, KGfxControlAppearAction);

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

        TRect demarcation;

        CAknTransitionUtils::GetDemarcation(CAknTransitionUtils::EPopup, demarcation);

        GfxTransEffect::SetDemarcation(this, demarcation);

        MakeVisible(ETrue);

        CAknTransitionUtils::MakeVisibleSubComponents( this,

                                        CAknTransitionUtils::EForceVisible );

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

        GfxTransEffect::End(this);

        }

    else

        {

        MakeVisible(ETrue);

        }

#endif        

    if (!iAppBroughtForwards)

        {

        iEikonEnv->BringForwards(ETrue);

        iAppBroughtForwards = ETrue;

        AknGlobalPopupPriorityController::ShowPopup(*this, ETrue);

        }

    TBool returnValue;

    iReturn = &returnValue;

    iWait.Start();

    delete this;

    _AKNTRACE_FUNC_EXIT;

    return returnValue;

    }

EXPORT_C void CAknPopupList::FadeBehindPopup(TBool aFade)