/*

* Copyright (c) 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:             Avkon implementation of non-focusing popup menu to show word candidates.

*

*/

#include <eikenv.h>

#include <eikappui.h>

#include <badesca.h>

#include <coemain.h>

#include <aknPopupHeadingPane.h>

#include <aknsfld.h>

#include <AknsFrameBackgroundControlContext.h>

#include <aknlists.h>

#include <aknmessagequerycontrol.h> 

#include <skinlayout.cdl.h>

#include <AknLayout2ScalableDef.h>

#include <aknlayoutscalable_avkon.cdl.h>

#include <layoutmetadata.cdl.h>

#include <aknlayoutscalable_apps.cdl.h>

#include <AknFepInternalCRKeys.h>

#include <AvkonInternalCRKeys.h>

#include <AknFepGlobalEnums.h>

#include <avkon.hrh>

#include "AknFepAvkonCandidatePopup.h"

#include "AknPriv.hrh"

const TInt KChrKeyTimeout = 250000;

const TInt KChrKeyRepeatDelay = 1000000;

const TInt KScreenWidthQHDLandscape = 640;

const TInt KScreenHeightQHDLandscape = 360;

const TInt KOffsetWidthForCandidatePopup = 32;

/**

* Creates the pop-up list

*

*/

CAknFepAvkonCandidatePopup* CAknFepAvkonCandidatePopup::NewL( MAknFepCandidatePopupCallback& aOwner )

    {

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

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

/**

* C++ constructor

*

* @param    aOwner  The owner of the popup list. Provides the candidates and receives notification

*                   when candidate selected.

*

*/

CAknFepAvkonCandidatePopup::CAknFepAvkonCandidatePopup( MAknFepCandidatePopupCallback& aOwner )

    : CAknPopupList()

    , iOwner(aOwner)

    , iKeyboard(EPtiKeyboardNone)

    {

    }

/**

* 2nd phase construction

*

*/

void CAknFepAvkonCandidatePopup::ConstructL()

    {

    // Construct the inner listbox and the base class

   	iList = new( ELeave ) CAknSinglePopupMenuStyleListBox;

   	TInt primaryCandidate = 0;

    CRepository* aknFepRepository = NULL;

    aknFepRepository = CRepository::NewL(KCRUidAknFep);

    if(aknFepRepository)

    	{

       	aknFepRepository->Get(KAknFepPrimaryCandidateFlag, primaryCandidate);

        delete aknFepRepository;

        }

    TInt keyboardLayout = 0;

    RProperty::Get(KCRUidAvkon, KAknKeyBoardLayout, keyboardLayout);

    TPtiKeyboardType layout = (TPtiKeyboardType)keyboardLayout;

	// Not use embedded CBA, so new the CBA seperately

    TInt cbaResource = 0;

    if(primaryCandidate && layout != EPtiKeyboard12Key  )

    	{

    	CAknPopupList::ConstructL( iList,R_AKNFEP_SOFTKEYS_OK_CANCEL_SELECT,

    						   AknPopupLayouts::EMenuWindow );

		cbaResource = R_AKNFEP_SOFTKEYS_OK_CANCEL_SELECT;

    	}

    else

    	{

    	CAknPopupList::ConstructL( iList, R_AKNFEP_SOFTKEYS_SPELL_CANCEL_SELECT,

    						   AknPopupLayouts::EMenuWindow );  

	    cbaResource = R_AKNFEP_SOFTKEYS_SPELL_CANCEL_SELECT;

    	}

	// To add new CBA, here set its flag as the base class, 

	// but just not set Embedded flag.

	TUint flags = CEikButtonGroupContainer::EAddToStack;

    if ( AknLayoutUtils::PenEnabled() )

        {

        flags |= CEikButtonGroupContainer::EDelayActivation;

        }

	// Destroy the CBA constructed in base class, and new its own CBA

    delete iPopoutCba;

    iPopoutCba =  CEikButtonGroupContainer::NewL(

            CEikButtonGroupContainer::ECba,

            CEikButtonGroupContainer::EHorizontal,

            this, cbaResource, *this, flags );	

	iList->ConstructL( this, CEikListBox::ELeftDownInViewRect );

    iList->CreateScrollBarFrameL( ETrue );

    iList->ScrollBarFrame()->SetScrollBarVisibilityL( CEikScrollBarFrame::EOff,      //< horizontal

                                                      CEikScrollBarFrame::EAuto );   //< vertical

    iList->SetNonFocusing();

    // Construct the item array

    iCandidates = new (ELeave) CDesCArrayFlat( KPredictiveListCandidateMax ); 

    CTextListBoxModel* model = iList->Model();

    model->SetItemTextArray( iCandidates );

    model->SetOwnershipType( ELbmDoesNotOwnItemArray );

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

    SetNonFocusing();

    MakeVisible(EFalse); 

    }

MAknFepCandidatePopup::~MAknFepCandidatePopup()

{

}

/**

* Destructor

*

*/

CAknFepAvkonCandidatePopup::~CAknFepAvkonCandidatePopup()

    {

    delete iList;

    delete iCandidates;

    if( iChrKeypressMonitor )

        {

        iChrKeypressMonitor->Cancel();

        delete iChrKeypressMonitor;

        iChrKeypressMonitor = NULL;

        }

    }

TPtrC CAknFepAvkonCandidatePopup::ActiveWord() const

    {

    if ( iCandidates->Count()>*iSelectedIdx && *iSelectedIdx>0 )

        {

        return (*iCandidates)[*iSelectedIdx];    

        }

    else

        {

        return TPtrC( KNullDesC );

        }

    }

TPtrC CAknFepAvkonCandidatePopup::ExactWord() const

    {

    if ( iCandidates->Count() > 0 )

        {

        return (*iCandidates)[0];        

        }

    else

        {

        return TPtrC( KNullDesC );

        }

    }

/**

* Makes the pop-up selection list visible.

*

* @param        aInlineEditorRect   Tells the place of the inline editor. If possible, the popup is opened

*                                   so that it does not hide the inline editor.

*

* @param        aSelectedIdx        Input/output argument for the selected index. If legal index is given in,

*                                   it will be used as default selection. Otherwise the default selection will

*                                   be the currently active word. On succesful exit this variable contains

*                                   the index selected by the user.

*

* @param        aLastKeyEvent       The last key event received by the popup. On return this is the event

*                                   which closed the popup.

*               

* @return       The command id used to close the window. EAknFepSoftkeySpell, EAknSoftkeyCancel, or EAknSoftkeySelect

*/

TInt CAknFepAvkonCandidatePopup::ExecutePopupL( const TRect& aInlineEditorRect, TInt& aSelectedIdx,

												TKeyEvent& aLastKeyEvent, TBool aRightToLeftLanguage,

												TInt aKeyboard )

    {

    iSelectedIdx = &aSelectedIdx;

    iLastKeyEvent = &aLastKeyEvent;

    iKeyboard = (TPtiKeyboardType)aKeyboard;

    //This is the inline text rectangle, this is needed in the event of a layout change

    iInlineTextRect = aInlineEditorRect;

    TInt requestedSelection = *iSelectedIdx;

    iOwner.GetCandidatesL( *iCandidates, *iSelectedIdx );

    if ( requestedSelection >= 0 && requestedSelection < iCandidates->Count() )

        {

        *iSelectedIdx = requestedSelection;

        }

    iListBox->SetCurrentItemIndex( *iSelectedIdx );

    iRightToLeftCandidate = aRightToLeftLanguage;

    const TSize screenSize = iAvkonAppUi->ApplicationRect().Size(); //TSize(AKN_LAYOUT_WINDOW_screen.iW,AKN_LAYOUT_WINDOW_screen.iH);

    iPopoutCba->SetBoundingRect(TRect(screenSize));

    SetupWindowLayout(iWindowType);

    SetupWindowLocation( aInlineEditorRect );

    iListBox->SetListBoxObserver(this);        

    iEikonEnv->RemoveFromStack(this);

    iEikonEnv->EikAppUi()->AddToStackL(this,ECoeStackPriorityDialog/*ECoeStackPriorityFep*/);

    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();

    // The main rule is to make the first index (the exact match) visible. However, the active index should never

    // be hidden.

    iListBox->ScrollToMakeItemVisible( 0 );

    if ( iListBox->BottomItemIndex() < *iSelectedIdx )

        {

        iListBox->ScrollToMakeItemVisible( *iSelectedIdx );

        }

    // Ensure that the popup is on top. Without this the popup window is left in the background at least

    // in the dialogs of the Phonebook application.

    //Window().SetOrdinalPosition(0);

    //iPopoutCba->SetContainerWindowL( Window() ); this didn't help

    // Make the popup visible

    iPopoutCba->MakeVisible(ETrue);

    iListBox->MakeVisible(ETrue);    

    MakeVisible(ETrue);

    SetFocus(ETrue);

    FadeBehindPopup(EFalse);

    TInt returnValue;

    iReturn = &returnValue;

    iLastCommandId = EAknSoftkeySelect;

    iWait.Start();

    return returnValue;

    }

/**

* Called when the popup is closed. Unlike the base class, this class does not commit suicide on this situation.

*

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

*/

void CAknFepAvkonCandidatePopup::AttemptExitL(TBool aAccept)

    {

    *iSelectedIdx = iList->CurrentItemIndex();

    if (iCoeEnv && iEikonEnv)

        {

        iEikonEnv->RemoveFromStack(this);

        }

    SetFocus(EFalse);

    MakeVisible(EFalse);

    ListBox()->MakeVisible(EFalse);    

    iPopoutCba->MakeVisible(EFalse);

    if (iReturn) //Always not null unless ExecutePopupL leaves

        {

        if (!aAccept)

            {

            *iReturn = EAknSoftkeyCancel;

            }

        else

            {

            *iReturn = iLastCommandId;                        

            }

        }

	if(iWait.IsStarted())

    iWait.AsyncStop();

    }

void CAknFepAvkonCandidatePopup::HandleResourceChange(TInt aType)

    {

    CAknPopupList::HandleResourceChange(aType);

    //When there is a dynamic layout change, the candidate list position needs to be aligned with

    //the new position of the inline text.

    if(aType == KEikDynamicLayoutVariantSwitch)

        {

        // Move back candidate popup control priority.

        iEikonEnv->RemoveFromStack(this);        

        TRAP_IGNORE( iEikonEnv->EikAppUi()->AddToStackL(this, ECoeStackPriorityDialog )) ;       

        // Get candidate update position based on layout.

        TRAP_IGNORE(iOwner.GetUpdateCandidatePositionL(iInlineTextRect));

	// Ensure that the popup is on top.

	Window().SetOrdinalPosition(0); 

        SetupWindowLocation( iInlineTextRect);

        DrawNow();

        }

    else if(aType == KAknMessageFocusLost)

    	FadeBehindPopup(ETrue);

    }

void CAknFepAvkonCandidatePopup::UnFocus()

    {

    //Remove the candidate list from the control stack so that it does not receive any key event.

    if (iCoeEnv && iEikonEnv)

        {

        iEikonEnv->RemoveFromStack(this);

        }

    //Un-Focus the candidate list

    SetFocus(EFalse);

    }

void CAknFepAvkonCandidatePopup::ShowAtNewPosition(TRect aRect)

    {

    if (iCoeEnv && iEikonEnv)

        {

        TRAP_IGNORE( iEikonEnv->EikAppUi()->AddToStackL(this,ECoeStackPriorityDialog/*ECoeStackPriorityFep*/ ));

        }

    SetFocus(ETrue);

    iInlineTextRect = aRect;

    SetupWindowLocation( iInlineTextRect);

    DrawNow();

    }

void CAknFepAvkonCandidatePopup::SetFocusAddStackReducePriorityL()

    {

    if (iCoeEnv && iEikonEnv)

        {

        iEikonEnv->EikAppUi()->AddToStackL(this, ECoeStackPriorityDefault-1/*ECoeStackPriorityDialog-1*/ );

        }

    SetFocus(ETrue);

    }

TInt CAknFepAvkonCandidatePopup::HandleChrKeyMonitorCallback(TAny* aParam)

    {

    // the timer will be cancelled only when the key up event is received

    // the down arrow key event is simulated now

    TKeyEvent keyEvent;

    keyEvent.iCode = EKeyDownArrow;	

//    TEventCode type = EEventKey;

    TRAP_IGNORE( ((CAknFepAvkonCandidatePopup*)aParam)->ListBox()->OfferKeyEventL(keyEvent, EEventKey) );

    // Prevent the screen saver

    User::ResetInactivityTime();

    return 1;

    }

/**

* Modified from CAknPopupList::OfferKeyEventL().

*/

TKeyResponse CAknFepAvkonCandidatePopup::OfferKeyEventL(const TKeyEvent& aKeyEvent, 

														TEventCode aType)

    {

    *iLastKeyEvent = aKeyEvent;

    // Selection key is substituted with the space key. Thus, selecting a candidate with the selection

    // key auto-appends space character.

    if ( aKeyEvent.iScanCode == EStdKeyDevice3 )

        {

        //iLastKeyEvent->iScanCode = EStdKeySpace;

        iLastKeyEvent->iCode = EKeyOK;

        }

    // Asterisk is substituted with arrow down key to get same functionality in ITU-T keypads

    // Emulator sends key event with scancode EStdKeyNkpAsterisk and hardware an event

    // with code '*' so we check for both

    else if ( ( (aKeyEvent.iScanCode == EStdKeyNkpAsterisk || aKeyEvent.iCode == '*' ) 

            && iKeyboard == EPtiKeyboard12Key ) )

        {

        iLastKeyEvent->iCode = EKeyDownArrow;

        }

    else if( aKeyEvent.iScanCode == EStdKeyLeftFunc

            && iKeyboard == EPtiKeyboardHalfQwerty  ) 

    	{

    	if( aType == EEventKeyDown)

    		{

    		iLastKeyEvent->iCode = EKeyDownArrow;	

    		// start the timer

    		if(iChrKeypressMonitor->IsActive())

    		    {

    		    iChrKeypressMonitor->Cancel();

    		    }

            iChrKeypressMonitor->Start( KChrKeyRepeatDelay, KChrKeyTimeout, 

                TCallBack(HandleChrKeyMonitorCallback, this));

    		aType = EEventKey;

    		}    	

    	else

    		{

    		iChrKeypressMonitor->Cancel();

    		return EKeyWasNotConsumed;

    		}

    	}

    // this must be first check, since window will be faded when fast

    // swap window is visible

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

        {

        AttemptExitL(EFalse);

        return EKeyWasConsumed;

        }

    if ( Window().IsFaded() )

        {

        // this happens, when popuplist has a findbox, and user

        // presses shift to launch fep menu. Fep menu has priority menu

        // in control stack, but we have dialog priority. As result,

        // keyevents will get here first. If we return

        // EKeyWasNotConsumed, fep menu will catch those events

        // next.

        return EKeyWasNotConsumed;

        }

    TBool needRefresh = EFalse;

    TKeyResponse res = AknFind::HandleFindOfferKeyEventL(aKeyEvent, aType, this,

    													 ListBox(), FindBox(), EFalse, needRefresh);

    if (needRefresh && FindBox())

        {

        DrawNow();

        }

    if ( res == EKeyWasConsumed )

        {

        return res;

        }

    if (aType==EEventKey)

        {

        // Handle arrow keys based on iScancode

        TBool keyEventHandled = EFalse;

        switch (iLastKeyEvent->iScanCode)

            {

            case EStdKeyUpArrow: //fall through

            case EStdKeyDownArrow:

            			keyEventHandled = ETrue;

                 return iListBox->OfferKeyEventL(*iLastKeyEvent, aType);

            case EStdKeyLeftArrow:

                    if(iRightToLeftCandidate)

                        // These keys confirm the selection and are then handled by AknFepManager

                        AttemptExitL(ETrue);

                    else

                        // These keys cancel the selection and are then handled by AknFepManager

                        AttemptExitL(EFalse);

                    keyEventHandled = ETrue;

                    return EKeyWasConsumed;

            case EStdKeyRightArrow:  

                    if(iRightToLeftCandidate)

                            // These keys cancel the selection and are then handled by AknFepManager

                            AttemptExitL(EFalse);

                        else

                            // These keys confirm the selection and are then handled by AknFepManager

                            AttemptExitL(ETrue);

               			keyEventHandled = ETrue;

                    return EKeyWasConsumed;

            }

        if (!keyEventHandled)

        	{

        // Handle through iCode

	        switch (iLastKeyEvent->iCode)

	            {

	            case EKeyUpArrow: //fall through

	            case EKeyDownArrow:

	                 return iListBox->OfferKeyEventL(*iLastKeyEvent, aType);

	            case EKeyLeftArrow:

	                    if(iRightToLeftCandidate)

	                        // These keys confirm the selection and are then handled by AknFepManager

	                        AttemptExitL(ETrue);

	                    else

	                        // These keys cancel the selection and are then handled by AknFepManager

	                        AttemptExitL(EFalse);

	                    return EKeyWasConsumed;

	            case EKeyRightArrow:  

	                    if(iRightToLeftCandidate)

	                            // These keys cancel the selection and are then handled by AknFepManager

	                            AttemptExitL(EFalse);

	                        else

	                            // These keys confirm the selection and are then handled by AknFepManager