/*

* Copyright (c) 2002 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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 FILES

#include <Browser_Platform_Variant.hrh>

#include <eikmenub.h>

#include <eikdef.h>

#include <akninfrm.h>

#include <eikon.rsg>

#include <eikenv.h>

#include <txtglobl.h>

#include <gulfont.h>

#include <txtfrmat.h>

#include <eikgted.h>

#include <aknconsts.h>

#include <akneditstateindicator.h>

#include <AknsListBoxBackgroundControlContext.h>

#include <BrowserNG.rsg>

#include <Featmgr.h>

#include <fepbase.h>

#include <aknutils.h>

#include <BrowserUiSDKCRKeys.h>

#include <centralrepository.h>

#include <AknLayout2ScalableDef.h>

#include <AknFepInternalCRKeys.h>

#include <aknlayoutfont.h>

#include <PtiDefs.h>

#include <aknlayoutscalable_avkon.cdl.h>

#include "CommonConstants.h"

#include "BrowserGotoPane.h"

#include "BrowserAppUi.h"

#include "BrowserUtil.h"

#include "browser.hrh"

#include "FavouritesLimits.h"

#include "BrowserAdaptiveListPopup.h"

#include "BrowserContentView.h"

#include "eikon.hrh"

#include <StringLoader.h>

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

// CBrowserGotoPane::NewL

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

//

CBrowserGotoPane* CBrowserGotoPane::NewL(

        const CCoeControl* aParent, TInt aIconBitmapId, TInt aIconMaskId,

        TBool aPopupListStatus, CBrowserContentView* aContentView,

        TBool aFindKeywordMode )

    {

    CBrowserGotoPane* gotoPane = new(ELeave)

        CBrowserGotoPane( aContentView, aFindKeywordMode );

    CleanupStack::PushL( gotoPane );

    gotoPane->ConstructL( aParent, aIconBitmapId, aIconMaskId, aPopupListStatus );

    gotoPane->MakeVisibleL( EFalse );

    gotoPane->SetFocus( EFalse );

    CleanupStack::Pop();    // gotoPane

    return gotoPane;

    }

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

// CBrowserGotoPane::MakeVisibleL

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

//

void CBrowserGotoPane::MakeVisibleL( TBool aVisible )

    {

    if ( aVisible )

        {

        if ( iSearchEditor )

            {

            ConstructSearchPaneL();

            }

        HandleFindSizeChanged();

        if ( AUTOCOMP ) //ask the feature manager

        {

        //2.1 does not put http:// there

            SetTextL( KNullDesC );

        }

        else

        {

        //2.0 does put the http:// there

            SetTextL( KHttpString );

            }

        }

    else

        {

        // Clear the search text if goto is cancelled ( hidden ).

        if ( iSearchEditor )

            {

            SetSearchTextL( KNullDesC );

            }

        }

    if (AknLayoutUtils::PenEnabled() &&  ( !iSearchEditor )  )

        {

        SetPointerCapture(aVisible);

        if (aVisible)

            {

            ActivateVKB();

            }

        }

    CCoeControl::MakeVisible( aVisible );

    iGotoKeyHandled->Reset();

    iGotoKeyHandled->EnableL( aVisible );

    if ( iSearchEditor )

        {

        SetTextModeItalicL();

        }

    // To avoid Flickring Effect when SearchInputFrame is

    // re-created with new search provider icon.

    DrawNow( );

    }

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

// CBrowserGotoPane::MakeVisible

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

//

void CBrowserGotoPane::MakeVisible( TBool aVisible )

    {

    TRAP_IGNORE( MakeVisibleL( aVisible ) );

    }

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

// CBrowserGotoPane::~CBrowserGotoPane

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

//

CBrowserGotoPane::~CBrowserGotoPane()

    {

    if (iAvkonAppUi!=NULL)

        {

        iAvkonAppUi->RemoveFromStack( iGotoKeyHandled );

        }

    delete iSearchEditor;

    delete iSearchInputFrame;

    delete iGotoKeyHandled;

    delete iEditor;

    delete iInputFrame;

    delete iPrevKeyword;

    delete iBAdaptiveListPopup;

    delete iDefaultSearchText;

    iContentView = NULL;

    CCoeEnv::Static()->RemoveFepObserver(static_cast<MCoeFepObserver &>(*this));

    }

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

// CBrowserGotoPane::CBrowserGotoPane

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

//

CBrowserGotoPane::CBrowserGotoPane( CBrowserContentView* aContentView, TBool aFindKeywordMode )

:   iContentView( aContentView),

    iFindKeywordMode( aFindKeywordMode ),

    iHandleFEPFind( ETrue ),

    iBAdaptiveListPopup( NULL ),

    iGotoPaneActive( ETrue ),

    iSearchPaneActive( EFalse),

    iSearchIconId( 0 )

    {

    }

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

// CBrowserGotoPane::ConstructL

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

//

void CBrowserGotoPane::ConstructL ( const CCoeControl* aParent, TInt aIconBitmapId, TInt aIconMaskId,

            TBool

            aPopupListStatus

            )

    {

    CreateWindowL();

    // remove 'const' modifier and set parent control

    SetMopParent( CONST_CAST( CCoeControl*, aParent ) );

    iEditor = new (ELeave) CEikGlobalTextEditor;

    iInputFrame = CAknInputFrame::NewL(

        iEditor,

        EFalse,

        KAvkonBitmapFile,

        aIconBitmapId,

        aIconMaskId,

        CAknInputFrame::EPopupLayout );

    iInputFrame->SetContainerWindowL( *this );

    AknEditUtils::ConstructEditingL (   iEditor,

                                        KFavouritesMaxUrlGotoPaneDefine,

                                        1,

                                        EAknEditorCharactersLowerCase,

                                        EAknEditorAlignRight,

                                        EFalse,

                                        ETrue,

                                        EFalse );

    iEditor->SetContainerWindowL( *this );

    iEditor->SetObserver( this );

    iEditor->SetBorder( TGulBorder::ENone );

    iEditor->SetAknEditorCase( EAknEditorLowerCase );

    iEditor->SetAknEditorInputMode( EAknEditorTextInputMode );

    if (AVKONAPAC)

        {

        // Disallow chinese input.

        iEditor->SetAknEditorAllowedInputModes( EAknEditorTextInputMode |

                                            EAknEditorNumericInputMode );

        }

    TInt editorFlags =  ((iFindKeywordMode) ? EAknEditorFlagDefault : EAknEditorFlagLatinInputModesOnly) |EAknEditorFlagUseSCTNumericCharmap;

#ifdef RD_INTELLIGENT_TEXT_INPUT

    TInt physicalKeyboards = 0;

    CRepository* aknFepRepository = CRepository::NewL( KCRUidAknFep );

    User::LeaveIfNull( aknFepRepository );

    aknFepRepository->Get( KAknFepPhysicalKeyboards,  physicalKeyboards );

    delete aknFepRepository;

    if ( physicalKeyboards &&   EPtiKeyboardQwerty3x11 ) {

        editorFlags = (editorFlags | EAknEditorFlagNoT9);

    }

#endif

    iEditor->SetAknEditorFlags( editorFlags );

    iEditor->SetAknEditorPermittedCaseModes (   EAknEditorUpperCase |

                                                EAknEditorLowerCase );

    iGotoKeyHandled = new (ELeave) CBrowserKeyEventHandled( *this );

    iAvkonAppUi->AddToStackL( iGotoKeyHandled,

                                ECoeStackPriorityFep + 1,

                                ECoeStackFlagRefusesFocus );

    iEditor->SetEdwinObserver( iGotoKeyHandled );

    iEditor->SetSkinBackgroundControlContextL(NULL);

    TBool searchFeature = iContentView->ApiProvider().Preferences().SearchFeature();

    if (  searchFeature && !iFindKeywordMode )

        {

        iDefaultSearchText = StringLoader::LoadL( R_IS_WEB_SEARCH );

        ConstructSearchPaneL();

        }

      //adaptive popuplist

    if ( aPopupListStatus && AUTOCOMP )

        {

        iBAdaptiveListPopup =

            new (ELeave) CBrowserAdaptiveListPopup( iEditor, this, EGotoPane, searchFeature );

        iBAdaptiveListPopup->ConstructL();

        iEditor->SetObserver( iBAdaptiveListPopup );

        if (iContentView)

            {

            iBAdaptiveListPopup->SetUrlSuffixList(iContentView->ApiProvider().Preferences().URLSuffixList());

            iBAdaptiveListPopup->SetMaxRecentUrls(iContentView->ApiProvider().Preferences().MaxRecentUrls());

            }

        }

    CCoeEnv::Static()->AddFepObserverL(static_cast<MCoeFepObserver &>(*this));

    iPrevKeyword = KNullDesC().AllocL();

    }

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

// CBrowserGotoPane::SetOrdinalPosition

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

//

void CBrowserGotoPane::SetOrdinalPosition( TInt aPos )

    {

    Window().SetOrdinalPosition( aPos );

    if ( iBAdaptiveListPopup )

        {

        iBAdaptiveListPopup->SetOrdinalPosition( aPos );

        }

    }

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

// CBrowserGotoPane::HandleFindSizeChanged

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

//

void CBrowserGotoPane::HandleFindSizeChanged()

    {

    if ( !AknLayoutUtils::PenEnabled() )

        {

        if ( iSearchEditor && !iFindKeywordMode)

            {

            TRect clientRect = CBrowserAppUi::Static()->ClientRect();

            TAknWindowLineLayout findWindow = AknLayout::popup_find_window();

            TRect findWindowRect = AknLayoutUtils::RectFromCoords( clientRect,findWindow.il, findWindow.it,

                    findWindow.ir, findWindow.ib, findWindow.iW, findWindow.iH);

            // Now Increase the height of rect to make room for two editors (Goto + search)//

            findWindowRect.iTl.iY -= ( findWindow.iH  );

            SetRect( findWindowRect );

            }

        else

            {

            TRect parentrect = iAvkonAppUi->ApplicationRect();

            TAknLayoutRect lrect;

            lrect.LayoutRect( parentrect,

                        AknLayout::main_pane( CBrowserAppUi::Static()->ApplicationRect(), 0, 1, 1 )

                        );

            AknLayoutUtils::LayoutControl ( this,

                                        lrect.Rect(),

                                        AknLayout::popup_find_window() );

            }

        }

    else

        {

        // The ClientRect() will be the application rectangle minus any

        // toolbars/menu bars etc.

        AknLayoutUtils::LayoutControl ( this,

                                        CBrowserAppUi::Static()->ClientRect(),

                                        AknLayout::popup_find_window() );

        }

    }

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

// CBrowserGotoPane::EnableKeyEventHandler

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

//

void CBrowserGotoPane::EnableKeyEventHandlerL( TBool aEnable )

    {

    iGotoKeyHandled->EnableL( aEnable );

    }

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

// CBrowserGotoPane::HandleControlEventL

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

//

void CBrowserGotoPane::HandleControlEventL ( CCoeControl* /*aControl*/,

                                                        TCoeEvent aEventType )

    {

    if ( iFindKeywordMode )

        {

        if ( iEditor->AknEditorCurrentInputMode() == EAknEditorCalculatorNumberModeKeymap

            // When the user copies and paste's content to the find dialog, the editor

            // is in Text Input mode, The engine should still get the find keyword request

            || iEditor->AknEditorCurrentInputMode() == EAknEditorTextInputMode

            )

            {

            if ( aEventType == MCoeControlObserver::EEventStateChanged )

                {

                HBufC* newText = GetTextL();

                if (!newText)

                    {

                    newText = KNullDesC().AllocL();

                    }

                if ( iPrevKeyword->Compare( *newText ) )

                    {

                    delete iPrevKeyword;

                    iPrevKeyword = NULL;

                    iPrevKeyword = newText;

                    // Find the typed keyword.

                    iContentView->FindKeywordL( GetTextL() );

                    iHandleFEPFind = EFalse;

                    }

                else

                    {

                    delete newText;

                    }

                }

            }

        }

    switch (aEventType)

        {

        case EEventRequestFocus:

            {

            FocusChanged( EDrawNow );

            break;

            }

        default:

            break;

        }

    }

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

// CBrowserGotoPane::OfferKeyEventL

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

//

TKeyResponse CBrowserGotoPane::OfferKeyEventL

( const TKeyEvent& aKeyEvent, TEventCode aType )

    {

    TKeyResponse resp = EKeyWasNotConsumed;

    if (    AknLayoutUtils::PenEnabled()

         && PopupList()

         && PopupList()->DrawableWindow()->OrdinalPosition() > 0 )

        {

        PopupList()->SetOrdinalPosition(0);

        }

    if ( aType == EEventKey && aKeyEvent.iCode == EKeyEscape )  // Escape key event handling

        {

        CCoeEnv::Static()->AppUi()->RemoveFromStack( this );

        if ( PopupList() )

            {

            PopupList()->SetDirectoryModeL( ETrue );

            PopupList()->HidePopupL();

            }

        MakeVisible( EFalse );                                  // Hide Goto pane

        SetFocus( EFalse );

        resp = EKeyWasConsumed;                                 // should set the focus of container to ETrue...how?

        }

    if ( iFindKeywordMode )

        {

        if ( iContentView->MenuBar()->MenuPane()->IsVisible() )

            {

            return iContentView->MenuBar()->MenuPane()->OfferKeyEventL(  aKeyEvent, aType );

            }

        else

            {

            if ( aType == EEventKey )                           // Handle up and down arow keys to search for

                {                                               //   next and previous keywords.

                if (    aKeyEvent.iCode == EKeyLeftUpArrow      // Northwest

                     || aKeyEvent.iCode == EStdKeyDevice10      //   : Extra KeyEvent supports diagonal event simulator wedge

                     || aKeyEvent.iCode == EKeyUpArrow          // North

                     || aKeyEvent.iCode == EKeyRightUpArrow     // Northeast

                     || aKeyEvent.iCode == EStdKeyDevice11 )    //   : Extra KeyEvent supports diagonal event simulator wedge

                    {                                           // Any of those? If so, then...

                    iContentView->FindKeywordL( NULL, EFalse ); // Find previous keyword

                    iHandleFEPFind = EFalse;                    //   :

                    return EKeyWasConsumed;                     // And that consumes the key

                    }

                if (    aKeyEvent.iCode == EKeyLeftDownArrow    // Southwest

                     || aKeyEvent.iCode == EStdKeyDevice13      //   : Extra KeyEvent supports diagonal event simulator wedge

                     || aKeyEvent.iCode == EKeyDownArrow        // South

                     || aKeyEvent.iCode == EKeyRightDownArrow   // Southeast

                     || aKeyEvent.iCode == EStdKeyDevice12 )    //   : Extra KeyEvent supports diagonal event simulator wedge

                    {                                           // Any of those? If so, then...

                    iContentView->FindKeywordL( NULL, ETrue );  // Find next keyword

                    iHandleFEPFind = EFalse;                    //   :

                    return EKeyWasConsumed;                     // And that consumes the key

                    }

                if ( aKeyEvent.iCode == EKeyDevice3 )           // Select key?

                    {                                           // If so, then...

                    return EKeyWasConsumed;                     // Ignore select key

                    }

                }

            return iEditor->OfferKeyEventL( aKeyEvent, aType );  // Otherwise, just pass the key on to the editor

            }

        }

    else                                                        // *NOT* iFindKeywordMode

        {

        if (    aKeyEvent.iCode == EKeyRightUpArrow             // Northeast

             || aKeyEvent.iCode == EStdKeyDevice11              //   : Extra KeyEvent supports diagonal event simulator wedge

             || aKeyEvent.iCode == EKeyRightDownArrow           // Southeast

             || aKeyEvent.iCode == EStdKeyDevice12              //   : Extra KeyEvent supports diagonal event simulator wedge

             || aKeyEvent.iCode == EKeyLeftDownArrow            // Southwest

             || aKeyEvent.iCode == EStdKeyDevice13              //   : Extra KeyEvent supports diagonal event simulator wedge

             || aKeyEvent.iCode == EKeyLeftUpArrow              // Northwest

             || aKeyEvent.iCode == EStdKeyDevice10 )            //   : Extra KeyEvent supports diagonal event simulator wedge

            {                                                   // Any of those? If so, then...

            return EKeyWasConsumed;                             // Ignore diagonal navigation events here

            }

        // For touch UI, handle enter key from VKB as a "GOTO"

        if (AknLayoutUtils::PenEnabled() && aKeyEvent.iCode == EKeyEnter)

            {

            CBrowserAppUi::Static()->ActiveView()->HandleCommandL(EWmlCmdGotoPaneGoTo);

            return EKeyWasConsumed;

            }

        else if ( ((aKeyEvent.iCode == EKeyOK ) || (aKeyEvent.iCode == EKeyEnter))

             && iGPObserver 

             && IsFocused() )

            {

            if ( CBrowserAppUi::Static()->ContentView()->MenuBar()->MenuPane()->IsVisible() )

                {

                return CBrowserAppUi::Static()->ContentView()->MenuBar()->MenuPane()->OfferKeyEventL( aKeyEvent, aType );

                }

            else

                {

                // If there is an observer and we have the focus, enter key is

                // consumed and observer is notified.

                iGPObserver->HandleGotoPaneEventL

                                ( this, MGotoPaneObserver::EEventEnterKeyPressed );

                return EKeyWasConsumed;

                }

            }