/*

* 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 "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 <aknenv.h>

#include <eikdef.h>

#include <aknsfld.h>

#include <akninfrm.h>   

#include <avkon.mbg>

#include <aknappui.h>

#include <eikon.rsg>        

#include <eikenv.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <uikon/eikenvinterface.h>

#endif

#include <txtglobl.h>

#include <gulfont.h>

#include <txtfrmat.h>

#include <eikedwin.h>

#include <uikon.hrh>

#include <aknconsts.h>

#include <aknEditStateIndicator.h>

#include <featmgr.h>                

#include <AknsListBoxBackgroundControlContext.h>

#include <AknsFrameBackgroundControlContext.h>

#include <AknsUtils.h>

#include "AknAdaptiveSearch.h"

#include <StringLoader.h>

#include <centralrepository.h>      // CenRep for AS

#include <AvkonInternalCRKeys.h>    // CenRep for AS

#include <AknTasHook.h>

#include <touchfeedback.h>

#include "aknSfldIndicatorFactory.h"

#include "aknsfldIndicator.h"

#include <eikbtgpc.h>

#include <eiklbx.h>

#include <skinlayout.cdl.h>

#include "akntrace.h"  // trace

using namespace SkinLayout;

// CONSTANTS

const TInt EUseSkinContext = 0x01;

const TInt EParentAbsolute = 0x02;

const TInt ETileIIDNone    = 0x04;

NONSHARABLE_CLASS(CHwKbSubscriber) : public CActive

    {

public:

    CHwKbSubscriber( TAny* aPtr, RProperty& aProperty );

    ~CHwKbSubscriber();

public: // New functions

    void SubscribeL();

    void StopSubscribe();

    static TInt HandlePropertyChaned( TAny* aPtr );

private: // from CActive

    void RunL();

    void DoCancel();

private:

    TCallBack  iCallBack;

    RProperty&  iProperty;

    };

CHwKbSubscriber::CHwKbSubscriber( TAny* aPtr, RProperty& aProperty )

    :CActive(EPriorityNormal), iCallBack( TCallBack( HandlePropertyChaned, aPtr)), 

     iProperty(aProperty)

    {

    CActiveScheduler::Add(this);

    }

CHwKbSubscriber::~CHwKbSubscriber()

    {

    Cancel();

    }

void CHwKbSubscriber::SubscribeL()

    {

    if (!IsActive())

        {

        iProperty.Subscribe(iStatus);

        SetActive();

        }

    }

void CHwKbSubscriber::StopSubscribe()

    {

    Cancel();

    }

TInt CHwKbSubscriber::HandlePropertyChaned( TAny* aPtr )

    {

    if ( aPtr )

        {

        TRAPD(err, 

              static_cast<CAknSearchField*>(aPtr)->HandleHWKeyboardModeChangeL());

        return err;

        }

    else

        {

        return KErrArgument;

        }

    }

void CHwKbSubscriber::RunL()

    {

    if (iStatus.Int() == KErrNone)

        {

        iCallBack.CallBack();

        SubscribeL();

        }

    }

void CHwKbSubscriber::DoCancel()

    {

    iProperty.Cancel();

    }

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

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

// CAknSearchField::CAknSearchField

// C++ default constructor.

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

//

CAknSearchField::CAknSearchField()

    {

    }

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

// CAknSearchField::~CAknSearchField

// Destructor.

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

//

EXPORT_C CAknSearchField::~CAknSearchField()

    {

    AKNTASHOOK_REMOVE();

    if ( iCBAObserverUpdated && iCba )

        {

        iCba->RemoveCommandObserver( 2 );

        if ( iBackedAppUi && !iBackedAppUi->IsAppClosing() )

            {

            iCba->RemoveCommandFromStack( 2, EAknSoftkeyCancel );

            }

        }

    delete iEditor;

    delete iAdaptiveSearch;    

    delete iInputFrame;    

    delete iSkinContext;

    delete iInputContext; 

    delete iIndicator;

    delete iHwKbSub;

    iHwKeyboardPro.Close();

    }  

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

// CAknSearchField::NewL

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

//

EXPORT_C CAknSearchField* CAknSearchField::NewL( const CCoeControl& aParent, 

                                                 TSearchFieldStyle aFieldStyle, 

                                                 CGulIcon* aIcon, 

                                                 TInt aTextLimit )

    { 

    _AKNTRACE_FUNC_ENTER;

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

    CleanupStack::PushL( self );

    _AKNTRACE( "[%s][%s] aSearchFieldStyle: %d", 

                            "CAknSearchField", __FUNCTION__, aFieldStyle );

    self->ConstructL( aParent, aFieldStyle, aIcon, aTextLimit );

    CleanupStack::Pop(); 

    AKNTASHOOK_ADDL( self, "CAknSearchField" );

    _AKNTRACE_FUNC_EXIT;

    return self;

    }   

NONSHARABLE_CLASS( CSearchFieldEditor ) : public CEikEdwin

    {

public:

    IMPORT_C TCoeInputCapabilities InputCapabilities() const;

    };

EXPORT_C TCoeInputCapabilities CSearchFieldEditor::InputCapabilities() const

    {

    TCoeInputCapabilities c( TCoeInputCapabilities::EAllText 

                | TCoeInputCapabilities::EWesternAlphabetic );

    c.MergeWith( CEikEdwin::InputCapabilities() );    

    return c;

    }

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

// CAknSearchField::ConstructL

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

//

void CAknSearchField::ConstructL( const CCoeControl& aParent,

                                  TSearchFieldStyle aFieldStyle,

                                  CGulIcon* aIcon, TInt aTextLimit )

    {

    SetMopParent( const_cast<CCoeControl*>(&aParent) );    

    iBackedAppUi = iAvkonAppUi;

    TFileName path(KAvkonBitmapFile);

    TInt bitmapId;

    TInt bitmapMaskId;    

    iIsPopup = EFalse; 

    TUint32 flags = NULL;

    iEditor = new ( ELeave ) CSearchFieldEditor;

    TBool isShowIndicator = EFalse;

    TBool ASEnabled = EFalse;

    if( AknLayoutUtils::PenEnabled())

        {

        ASEnabled = GetASStatusAndSubKbLayoutL( isShowIndicator );

        }

    else

        {

        isShowIndicator = ETrue;

        }         

    // Adaptive search is not allowed in popups anymore

    if ( aFieldStyle == EPopupAdaptiveSearch )

        {

        aFieldStyle = EPopup;

        }

    else if ( aFieldStyle == EPopupAdaptiveSearchWindow )

        {

        aFieldStyle = EPopupWindow;

        }

    switch ( aFieldStyle )

        {

        case EFixed:

            bitmapId = EMbmAvkonQgn_indi_find_glass;

            bitmapMaskId = EMbmAvkonQgn_indi_find_glass_mask;

            CreateWindowL( &aParent ); // This is now non-window owning control

            break;

        case ESearchWithoutLine:

            flags |= CAknInputFrame::EFixedFindWithoutLine;

        // FALL THROUGH/ no break here.

        case ESearch:

            bitmapId = EMbmAvkonQgn_indi_find_glass;

            bitmapMaskId = EMbmAvkonQgn_indi_find_glass_mask;

            SetContainerWindowL( aParent ); // This is now non-window owning control

            break;

        case EPopup:

            bitmapId = EMbmAvkonQgn_indi_find_glass;

            bitmapMaskId = EMbmAvkonQgn_indi_find_glass_mask;

            flags |= CAknInputFrame::EPopupLayout;

            CreateWindowL(); 

            iIsPopup = ETrue;

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

                {

                Window().SetRequiredDisplayMode( EColor16MA );

                TInt err = Window().SetTransparencyAlphaChannel();

                if ( err == KErrNone )                    

                    Window().SetBackgroundColor(~0);                    

                }            

            break;

        case EPinb:

            bitmapId = EMbmAvkonQgn_indi_find_glass_pinb;

            bitmapMaskId = EMbmAvkonQgn_indi_find_glass_pinb_mask;

            flags |= CAknInputFrame::EPinbLayout;

            SetContainerWindowL( aParent ); // This is now non-window owning control

            break;

        case EClockApp:

            bitmapId = EMbmAvkonQgn_indi_find_glass;

            bitmapMaskId = EMbmAvkonQgn_indi_find_glass_mask;

            flags |= CAknInputFrame::EClockAppLayout;

            SetContainerWindowL( aParent ); // This is now non-window owning control

            break;

        case EPopupWindow:

            bitmapId = EMbmAvkonQgn_indi_find_glass;

            bitmapMaskId = EMbmAvkonQgn_indi_find_glass_mask;

            if ( AknLayoutUtils::PenEnabled() )

                {

                flags |= CAknInputFrame::EPopupWindowEmbeddedSoftkeys;

                }

            flags |= CAknInputFrame::EPopupWindowLayout;

            flags |= CAknInputFrame::EFixedFindWithoutLine;

            SetContainerWindowL( aParent ); // This is now non-window owning control

            break;

        case EAdaptiveSearch:

            bitmapId = EMbmAvkonQgn_indi_find_glass;

            bitmapMaskId = EMbmAvkonQgn_indi_find_glass_mask;

            SetContainerWindowL( aParent );  

            iColumnFlag = 0xFFFFFFFF;     

            if( AknLayoutUtils::PenEnabled() )

                {

                iAdaptiveSearch = CAknAdaptiveSearch::NewL( aTextLimit, aFieldStyle );       

                iAdaptiveSearch->SetSearchField( this );         

                if ( ASEnabled )

                    {

                    iEditor->AddFlagToUserFlags( CEikEdwin::EAvkonDisableVKB );

                    }

                TInt edwinFlag( iEditor->AknEdwinFlags() );

                iEditor->SetAknEditorFlags( edwinFlag | 

                        EAknEditorFlagAdaptiveSearch );

                }                    

            break; 

        case EAdaptive:

            bitmapId = EMbmAvkonQgn_indi_find_glass;

            bitmapMaskId = EMbmAvkonQgn_indi_find_glass_mask;

            CreateWindowL( &aParent ); 

            iColumnFlag = 0xFFFFFFFF; 

            if( AknLayoutUtils::PenEnabled() )

                {

                iAdaptiveSearch = CAknAdaptiveSearch::NewL( aTextLimit, aFieldStyle );       

                iAdaptiveSearch->SetSearchField( this ); 

                if ( ASEnabled )

                    {

                    iEditor->AddFlagToUserFlags( CEikEdwin::EAvkonDisableVKB );

                    }

                TInt edwinFlag( iEditor->AknEdwinFlags() );

                iEditor->SetAknEditorFlags( edwinFlag | 

                        EAknEditorFlagAdaptiveSearch );

                }                      

            break;

        case EPopupAdaptiveSearch:

            bitmapId = EMbmAvkonQgn_indi_find_glass;

            bitmapMaskId = EMbmAvkonQgn_indi_find_glass_mask;

            flags |= CAknInputFrame::EPopupLayout;

            CreateWindowL(); 

            iColumnFlag = 0xFFFFFFFF; 

            iIsPopup = ETrue;

            if( AknLayoutUtils::PenEnabled() )

                {

                iAdaptiveSearch = CAknAdaptiveSearch::NewL( aTextLimit, aFieldStyle );       

                iAdaptiveSearch->SetSearchField( this );  

                if ( ASEnabled )

                    {

                    iEditor->AddFlagToUserFlags( CEikEdwin::EAvkonDisableVKB );

                    }

                TInt edwinFlag( iEditor->AknEdwinFlags() );

                iEditor->SetAknEditorFlags( edwinFlag | 

                        EAknEditorFlagAdaptiveSearch );

                }          

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

                {

                Window().SetRequiredDisplayMode( EColor16MA );

                TInt err = Window().SetTransparencyAlphaChannel();

                if ( err == KErrNone )                    

                    Window().SetBackgroundColor(~0);                    

                }                    

            break;

        case EPopupAdaptiveSearchWindow:

            bitmapId = EMbmAvkonQgn_indi_find_glass;

            bitmapMaskId = EMbmAvkonQgn_indi_find_glass_mask;

            if ( AknLayoutUtils::PenEnabled() )

                {

                flags |= CAknInputFrame::EPopupWindowEmbeddedSoftkeys;

                }

            flags |= CAknInputFrame::EPopupWindowLayout;

            flags |= CAknInputFrame::EFixedFindWithoutLine;

            SetContainerWindowL( aParent ); 

            iColumnFlag = 0xFFFFFFFF;   

            if( AknLayoutUtils::PenEnabled() )

                {

                iAdaptiveSearch = CAknAdaptiveSearch::NewL( aTextLimit, aFieldStyle );       

                iAdaptiveSearch->SetSearchField( this );  

                if ( ASEnabled )

                    {

                    iEditor->AddFlagToUserFlags( CEikEdwin::EAvkonDisableVKB );

                    }

                TInt edwinFlag( iEditor->AknEdwinFlags() );

                iEditor->SetAknEditorFlags( edwinFlag | 

                        EAknEditorFlagAdaptiveSearch );

                }             

            break;

/*     case EInput:

            bitmapId = EMbmAvkonInput;

            bitmapMaskId = EMbmAvkonInputm;

            SetFocus( ETrue );

            break;

        case EUrl:

            bitmapId = EMbmAvkonUrlm;

            bitmapMaskId = EMbmAvkonUrl;

            break;

*/

        default:

            bitmapId = 0;

            bitmapMaskId = 0;

            path = KNullDesC;

            SetContainerWindowL( aParent ); 

            break;

        }

    if ( !aIcon )

        {

        iInputFrame = CAknInputFrame::NewL( iEditor, EFalse, path, bitmapId, bitmapMaskId, 

                                            isShowIndicator ? 

                                            flags | CAknInputFrame::EShowIndicators :

                                            flags );

        }

    else

        {

        iInputFrame = CAknInputFrame::NewL( iEditor, EFalse, NULL, 

                                            flags | CAknInputFrame::EShowIndicators);

        }

    TAknLayoutId layout;

    iAvkonEnv->GetCurrentLayoutId( layout );

    if (layout == EAknLayoutIdAPAC && !AknLayoutUtils::PenEnabled()

        || FeatureManager::FeatureSupported( KFeatureIdChinese ) )

        {

        if ( aFieldStyle != EClockApp )

            {

            iIndicator = AknSearchFieldIndicatorFactory::CreateIndicatorL();

            if ( iIndicator ) // iIndicator is NULL if KFeatureIdAvkonApac is not supported.

                {

                iIndicator->SetContainerWindowL( *this );

                iIndicator->SetSearchFieldStyle( aFieldStyle );                

                if ( !isShowIndicator )

                    {

                    iIndicator->MakeVisible( EFalse );

                    }

                }

            }

        }

    iInputFrame->SetContainerWindowL( *this );

    iEditor->SetContainerWindowL( *this );

    AknEditUtils::ConstructEditingL( iEditor,

                                     aTextLimit,

                                     1,

                                     EAknEditorCharactersLowerCase,

                                     EAknEditorAlignLeft,

                                     EFalse,

                                     ETrue,

                                     EFalse );

    iEditor->SetObserver( this );

    iEditor->SetBorder( TGulBorder::ENone );

    iEditor->SetAknEditorInputMode( EAknEditorTextInputMode );

    iEditor->SetAknEditorAllowedInputModes( EAknEditorTextInputMode |

                                            EAknEditorNumericInputMode ); 

    if ( FeatureManager::FeatureSupported(KFeatureIdJapanese) )

        {

        iEditor->SetAknEditorPermittedCaseModes(EAknEditorCharactersLowerCase);

        }

    TInt editorFlags = iEditor->AknEdwinFlags() |

                       EAknEditorFlagNoT9 | 

                       EAknEditorFlagNoLRNavigation |

                       EAknEditorFlagForceTransparentFepModes |

                       EAknEditorFlagNoEditIndicators |

                       EAknEditorFlagFindPane;

    iEditor->SetAknEditorFlags( editorFlags );

    iEditor->CreateTextViewL();      

    if ( aFieldStyle == EPopup || 

         aFieldStyle == EFixed ||

         aFieldStyle == EPopupAdaptiveSearch || 

         aFieldStyle == EAdaptive )

        {

        iFlags |= EParentAbsolute;

        }

    if( aFieldStyle == ESearchWithoutLine )        

        iFlags |= ETileIIDNone;          

    SetupSkinContextL();    

    if ( aIcon )        

        iInputFrame->SetIcon( aIcon ); // May not leave after this    

    if ( aFieldStyle == EPopup || aFieldStyle == EPopupAdaptiveSearch )

        {

        iEditor->SetFocus( EFalse );

        }

    else 

        {      

        iEditor->SetFocus( ETrue );

        }  

    if ( AknsUtils::AvkonSkinEnabled() )        

        iFlags |= EUseSkinContext;    

    iStyle = aFieldStyle;      

    ActivateL();

    }

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

// CAknSearchField::SetLinePos

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

//

EXPORT_C void CAknSearchField::SetLinePos( TInt aLinePos )

    {

    iLinePos = aLinePos;

    TAknsItemID tileIID = KAknsIIDQsnBgColumnA;

    if ( iLinePos == 1 || iLinePos == 0 )

        {

        tileIID = KAknsIIDNone;

        }

    if ( iLinePos == 3 )

        {

        tileIID = KAknsIIDQsnBgColumnAB;

        }

    iSkinContext->SetTiledBitmap( tileIID );

    TAknWindowLineLayout tile = Column_background_and_list_slice_skin_placing_Line_2();

    if ( iLinePos == 1 )

        {

        tile = Column_background_and_list_slice_skin_placing_Line_1();

        }    

    if ( iLinePos == 3 )

        {

        tile = Column_background_and_list_slice_skin_placing_Line_3();

        }

    TRect main_pane;

    AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EMainPane, main_pane );     

    TRect clientRect( TRect(TPoint(0,0), main_pane.Size() ) );

    TAknLayoutRect tileRect;