/*

* Copyright (c) 2006 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 "AknAdaptiveSearchGrid.h"

#include <AknsDrawUtils.h>

#include <layoutmetadata.cdl.h>

#include <aknlayoutscalable_apps.cdl.h>

#include <aknlayoutscalable_avkon.cdl.h>

#include <AknsListBoxBackgroundControlContext.h>

#include <AknsBasicBackgroundControlContext.h>

#include <AknsFrameBackgroundControlContext.h>

#include <numberconversion.h>  // For page indicator

#include <eikedwin.h>

#include <akninfrm.h>       // CAknInputFrame 

#include <avkon.mbg>        // Bitmaps for "dummy" find pane

#include <aknconsts.h>      // KAvkonBitmapFile

#include <featmgr.h>        // FeatureManager

#include <aknViewAppUi.h>   // CAknViewAppUi

#include <akntoolbar.h> 

#include "aknSfldIndicatorFactory.h"

#include "aknsfldIndicator.h"

#include <aknEditStateIndicator.h>

#include <eikbtgpc.h> 

#include <aknsfld.h> //for TSearchFieldStyle

#include <touchfeedback.h>

#include "akntrace.h"

// CONSTANTS

const TInt KPortraitMaxSize = 0;

const TInt KLandscapeMaxSize = 1;

const TInt KPortraitMultiPage = 0;

const TInt KLandscapeMultiPage = 1;

const TInt KPortraitSinglePage = 2;

const TInt KLandscapeSinglePage = 3;

const TInt KPortraitToolbarMaxSize = 18;

_LIT( KSlashOfPageIndicator, "/" );

_LIT( KSpaceCharacter, " " );

const TInt KCloseAndClearButtonCount = 2;  

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

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

// CAknAdaptiveSearchGrid::NewL()

// Two-phased constructor.

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

//

CAknAdaptiveSearchGrid* 

CAknAdaptiveSearchGrid::NewL( const TInt aTextLimit, TInt aFieldStyle )

    {

    CAknAdaptiveSearchGrid* self = CAknAdaptiveSearchGrid::NewLC( aTextLimit, 

                                                                  aFieldStyle );

    CleanupStack::Pop( self );

    return self;

    }

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

// CAknAdaptiveSearchGrid::NewLC()

// Two-phased constructor.

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

//

CAknAdaptiveSearchGrid* 

CAknAdaptiveSearchGrid::NewLC( const TInt aTextLimit, TInt aFieldStyle )

    {

    CAknAdaptiveSearchGrid* self = new ( ELeave ) CAknAdaptiveSearchGrid ( aTextLimit );

    CleanupStack::PushL( self );

    self->ConstructL( aFieldStyle );

    return self;

    }

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

// CAknAdaptiveSearchGrid::CAknAdaptiveSearchGrid()

// C++ default constructor.

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

//

CAknAdaptiveSearchGrid::CAknAdaptiveSearchGrid( const TInt aTextLimit )

    : iCloseButton( NULL ),     

      iDeleteButton( NULL ),

      iPrevButton( NULL ),

      iNextButton( NULL ),

      iLastFocusedButton( NULL ),

      iTextLimit( aTextLimit ),

      iShown( EFalse ),

      iNumOfPages( 1 ),

      iGridChars( NULL ),

      iAppUi( iAvkonAppUi ),     

      iAdaptiveSearchGridObserver( NULL ),

      iLayoutChanged(EFalse),

      iPopupFindpane(EFalse)

    {      

    __ASSERT_DEBUG( iAppUi, User::Invariant() );

    SetMopParent( iAppUi );

    }

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

// CAknAdaptiveSearchGrid::~CAknAdaptiveSearchGrid()

// Destructor.

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

//

CAknAdaptiveSearchGrid::~CAknAdaptiveSearchGrid()

    { 

    _AKNTRACE_FUNC_ENTER;

    CEikonEnv::Static()->EikAppUi()->RemoveFromStack( this );

    delete iBgContextOfFindPane;

    delete iBgContextOfControlPane;

    delete iSkinContextOfFindPane; 

    delete iInputFrame;

    // Clear current region of AS

    iCurrentRegion.Clear();    

    iButtonArray.ResetAndDestroy();

    if ( iEditor )

        {

        TRAP_IGNORE(iEditor->TextView()->SetCursorVisibilityL( 

            TCursor::EFCursorInvisible, TCursor::EFCursorInvisible ));

        delete iEditor;

        }   

    if( iGridChars )

        {

        delete iGridChars;

        iGridChars = NULL;

        }               

    if( iCloseButton )

        {

        delete iCloseButton;

        iCloseButton = NULL;

        }

    if( iDeleteButton )

        {

        delete iDeleteButton;

        iDeleteButton = NULL;

        }

    if( iPrevButton )

        {

        delete iPrevButton;

        iPrevButton = NULL;

        }

    if( iNextButton )

        {

        delete iNextButton;

        iNextButton = NULL;

        }

    if( iPageIndicator )

        {

        delete iPageIndicator;

        iPageIndicator = NULL;

        }

    CAknWsEventMonitor* eventMonitor = iAppUi->EventMonitor();    

    eventMonitor->Enable( EFalse ); 

    eventMonitor->RemoveObserver( this ); 

    _AKNTRACE_FUNC_EXIT;

    }

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

// CAknAdaptiveSearchGrid::ConstructL()

// Symbian 2nd phase constructor.

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

//

void CAknAdaptiveSearchGrid::ConstructL( TInt aFieldStyle )

    {   

    _AKNTRACE_FUNC_ENTER;

    _AKNTRACE( "[%s][%s] Search Field Style : %d", "CAknAdaptiveSearchGrid", __FUNCTION__, aFieldStyle );

    CreateWindowL();

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

        {

        Window().SetRequiredDisplayMode( EColor16MA );

        TInt err = Window().SetTransparencyAlphaChannel();

        if ( err == KErrNone )

            {

            Window().SetBackgroundColor(~0);

            }

        }        

    CAknWsEventMonitor* eventMonitor = iAppUi->EventMonitor();    

    eventMonitor->AddObserverL( this );

    eventMonitor->Enable();

    iSkinContextOfFindPane = CAknsListBoxBackgroundControlContext::NewL( KAknsIIDQsnBgAreaControlPopup, 

                                                                         TRect(0,0,0,0), 

                                                                         EFalse, 

                                                                         KAknsIIDNone, 

                                                                         TRect(0,0,0,0) );   

    iBgContextOfFindPane = CAknsFrameBackgroundControlContext::NewL( KAknsIIDQsnFrInput, 

                                                                     TRect(0,0,0,0), 

                                                                     TRect(0,0,0,0), 

                                                                     EFalse );    

    iBgContextOfControlPane = CAknsBasicBackgroundControlContext::NewL( KAknsIIDQgnGrafAdaptSearchPageBg, 

                                                                        TRect(0,0,0,0), EFalse );          

    // Init components

    InitControlsL( aFieldStyle );

    InitGrid();   

    _AKNTRACE_FUNC_EXIT;

    }   

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

// CAknAdaptiveSearchGrid::InitControls()

// Initiates find pane and page indicator. 

// Create control buttons: close, delete, next page, prev page 

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

//

void CAknAdaptiveSearchGrid::InitControlsL( TInt aFieldStyle )

    {    

    CGulIcon* gulIcon = NULL;

    gulIcon = GetColorIconL( 0 );   

    iCloseButton = CAknButton::NewL( gulIcon, NULL, NULL, NULL, KNullDesC, 

                                     KNullDesC, 0, 0 );   

    iCloseButton->SetBackgroundIds( KAknsIIDQsnFrFunctionButtonNormal,

            KAknsIIDQsnFrFunctionButtonPressed, KAknsIIDQsnFrFunctionButtonInactive,

            KAknsIIDQsnFrFunctionButtonPressed, KAknsIIDQsnFrFunctionButtonInactive );   

    iCloseButton->SetObserver( this );

    iCloseButton->SetContainerWindowL( *this );  

    gulIcon = GetColorIconL( 1 );   

    iDeleteButton = CAknButton::NewL( gulIcon, NULL, NULL, NULL, KNullDesC, 

                                      KNullDesC, KAknButtonKeyRepeat, 0 ); 

    iDeleteButton->SetBackgroundIds( KAknsIIDQsnFrFunctionButtonNormal,

            KAknsIIDQsnFrFunctionButtonPressed, KAknsIIDQsnFrFunctionButtonInactive,

            KAknsIIDQsnFrFunctionButtonPressed, KAknsIIDQsnFrFunctionButtonInactive );        

    iDeleteButton->SetObserver( this );

    iDeleteButton->SetContainerWindowL( *this );

    gulIcon = GetColorIconL( 2 );   

    iPrevButton = CAknButton::NewL( gulIcon, NULL, NULL, NULL, KNullDesC, 

                                    KNullDesC, KAknButtonKeyRepeat, 0 ); 

    iPrevButton->SetBackgroundIds( KAknsIIDQsnFrFunctionButtonNormal,

            KAknsIIDQsnFrFunctionButtonPressed, KAknsIIDQsnFrFunctionButtonInactive,

            KAknsIIDQsnFrFunctionButtonPressed, KAknsIIDQsnFrFunctionButtonInactive );   

    iPrevButton->SetObserver( this );

    iPrevButton->SetContainerWindowL( *this );    

    gulIcon = GetColorIconL( 3 );

    iNextButton = CAknButton::NewL( gulIcon, NULL, NULL, NULL, KNullDesC, 

                                    KNullDesC, KAknButtonKeyRepeat, 0 );     

    iNextButton->SetBackgroundIds( KAknsIIDQsnFrFunctionButtonNormal,

            KAknsIIDQsnFrFunctionButtonPressed, KAknsIIDQsnFrFunctionButtonInactive,

            KAknsIIDQsnFrFunctionButtonPressed, KAknsIIDQsnFrFunctionButtonInactive );                                   

    iNextButton->SetObserver( this ); 

    iNextButton->SetContainerWindowL( *this );

    TUint flags = 0;

    switch ( aFieldStyle )

        {

        case CAknSearchField::EPopupAdaptiveSearch:

            flags |= CAknInputFrame::EPopupLayout;

            iPopupFindpane = ETrue;

            break;

        case CAknSearchField::EPopupAdaptiveSearchWindow:

            flags |= CAknInputFrame::EPopupWindowLayout;

            flags |= CAknInputFrame::EFixedFindWithoutLine;

            break;

        }

    iEditor = new (ELeave) CEikEdwin;   

    iInputFrame = CAknInputFrame::NewL( iEditor, 

                                        EFalse, 

                                        KAvkonBitmapFile, 

                                        EMbmAvkonQgn_indi_find_glass, 

                                        EMbmAvkonQgn_indi_find_glass_mask, 

                                        flags );                     

    iEditor->SetContainerWindowL( *this );

    iInputFrame->SetContainerWindowL( *this );

    AknEditUtils::ConstructEditingL( iEditor,

                                     iTextLimit,

                                     1,

                                     EAknEditorCharactersLowerCase,

                                     EAknEditorAlignLeft,

                                     EFalse,

                                     ETrue,

                                     EFalse );

    iEditor->SetObserver( this );

    iEditor->SetBorder( TGulBorder::ENone );

    iEditor->SetAknEditorInputMode( EAknEditorTextInputMode );

    iEditor->SetAknEditorAllowedInputModes( EAknEditorTextInputMode |

                                            EAknEditorNumericInputMode ); 

    iEditor->AddFlagToUserFlags( CEikEdwin::EAvkonDisableVKB );

    if ( FeatureManager::FeatureSupported( KFeatureIdJapanese ) )

        {

        iEditor->SetAknEditorPermittedCaseModes( EAknEditorCharactersLowerCase );

        }

    TInt editorFlags = EAknEditorFlagNoT9 | 

                       EAknEditorFlagNoLRNavigation |

                       EAknEditorFlagForceTransparentFepModes |

                       EAknEditorFlagNoEditIndicators |

                       EAknEditorFlagFindPane;

    iEditor->SetAknEditorFlags( editorFlags );

    iEditor->CreateTextViewL(); 

    iInputFrame->SetInputContext( iBgContextOfFindPane );

    iEditor->SetSkinBackgroundControlContextL( iBgContextOfFindPane );

    TRgb textColor = KRgbBlack;

    TInt error = AknsUtils::GetCachedColor( AknsUtils::SkinInstance(), 

                                            textColor, 

                                            KAknsIIDQsnTextColors, 

                                            EAknsCIQsnTextColorsCG19);

    if( !error )

        {

        TRAP_IGNORE( AknLayoutUtils::OverrideControlColorL(*iEditor, EColorLabelText, textColor) );       

        }   

    // Create label for page indicator

    iPageIndicator = new (ELeave) CEikLabel;

    iPageIndicator->SetObserver( this );

    iPageIndicator->SetContainerWindowL( *this );

    iPageIndicator->SetTextL( KNullDesC );    

    }     

 CGulIcon* CAknAdaptiveSearchGrid::GetColorIconL( TInt aIndex )

    {    

    // order: Close, Backspace, Previous, Next    

     _AKNTRACE( "[%s][%s] color icon index : %d", "CAknAdaptiveSearchGrid", __FUNCTION__, aIndex );

    TAknsItemID skinIdArray[] = 

        {

        KAknsIIDQgnIndiSctClose,

        KAknsIIDQgnIndiAdaptSearchBackspace,

        KAknsIIDQgnIndiSctPagePrev,

        KAknsIIDQgnIndiSctPageNext,

        KAknsIIDQgnIndiKeypadSpace

        };

    TInt bitmapIds [] =

        {

        EMbmAvkonQgn_indi_sct_close,

        EMbmAvkonQgn_indi_adapt_search_backspace,

        EMbmAvkonQgn_indi_sct_page_prev,

        EMbmAvkonQgn_indi_sct_page_next,

        EMbmAvkonQgn_indi_keypad_space

        };

    TInt maskIds [] =

        {

        EMbmAvkonQgn_indi_sct_close_mask,

        EMbmAvkonQgn_indi_adapt_search_backspace_mask,

        EMbmAvkonQgn_indi_sct_page_prev_mask,

        EMbmAvkonQgn_indi_sct_page_next_mask,

        EMbmAvkonQgn_indi_keypad_space_mask

        };

    CFbsBitmap *icon = NULL;

    CFbsBitmap *mask = NULL;    

    TAknsItemID colorGroup = KAknsIIDQsnIconColors;

    TInt textColorIndex = EAknsCIQsnIconColorsCG30;    

    // space belong to another color group

    if( aIndex == 4 )

        {        

        colorGroup = KAknsIIDQsnTextColors; 

        textColorIndex = EAknsCIQsnTextColorsCG65;        

        }

    MAknsSkinInstance* skin = AknsUtils::SkinInstance();    

    if( aIndex == 0 )

        {        

        AknsUtils::CreateIconL( skin, skinIdArray[aIndex],                                           

                                icon, mask, KAvkonBitmapFile, 

                                bitmapIds[aIndex], maskIds[aIndex] );    

        }

    else

        {        

        AknsUtils::CreateColorIconL( skin, skinIdArray[aIndex],

                                           colorGroup,

                                           textColorIndex,

                                           icon, mask, 

                                           KAvkonBitmapFile, 

                                           bitmapIds[aIndex],

                                           maskIds[aIndex],

                                           KRgbBlack );    

        } 

    CGulIcon* gulIcon = CGulIcon::NewL( icon, mask );    

    return gulIcon;

    }

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

// CAknAdaptiveSearchGrid::UpdateLayoutVariant()

// Update layout variant. This should be done when 

// KEikDynamicLayoutVariantSwitch message recieved. 

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

// 

void CAknAdaptiveSearchGrid::UpdateLayoutVariant()

	{

    _AKNTRACE_FUNC_ENTER;

	InitGrid(); 

	UpdatePageAndRowCount();       	         

	if( IsShown() )

		{

		ControlsPositions();

		TRAP_IGNORE( UpdateVisibleButtonsL() );  

		ShowControls();           

		}

    _AKNTRACE_FUNC_EXIT;

	}

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

// CAknAdaptiveSearchGrid::UpdateSkinL()

// Update adaptive search grid skin. This should be done when 

// KAknsMessageSkinChange message recieved. 

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

//  

void CAknAdaptiveSearchGrid::UpdateSkinL()

	{

    CGulIcon* gulIcon = NULL;

    gulIcon = GetColorIconL( 0 );        

    iCloseButton->State()->SetIcon( gulIcon );

    CGulIcon* gulIcon1 = NULL;

    gulIcon1 = GetColorIconL( 1 );        

    iDeleteButton->State()->SetIcon( gulIcon1 );

    CGulIcon* gulIcon2 = NULL;

    gulIcon2 = GetColorIconL( 2 );        

	iPrevButton->State()->SetIcon( gulIcon2 );		

    CGulIcon* gulIcon3 = NULL;

    gulIcon3 = GetColorIconL( 3 );        

    iNextButton->State()->SetIcon( gulIcon3 );

   	UpdateVisibleButtonsL();	 	    		    

    if( iNumOfPages > 1 )

		{	

		// Page pane & page indicator	

    	TRect page_pane = RectFromLayout( Rect(), AknLayoutScalable_Apps::afind_page_pane( iLayoutOption) );	

    	if( AknsUtils::AvkonSkinEnabled() )

	        {	        

	        TRgb textColor = KRgbBlack; 

    	    TInt error = AknsUtils::GetCachedColor( AknsUtils::SkinInstance(), 

    	                                            textColor, 

    	                                            KAknsIIDQsnTextColors, 

    	                                            EAknsCIQsnTextColorsCG19);

    	    if( !error )        	        

    	        AknLayoutUtils::OverrideControlColorL(*iPageIndicator, EColorLabelText, textColor);         	                           

		    }			    

		iBgContextOfControlPane->SetRect( page_pane );     

		}

	}

// CAknAdaptiveSearchGrid::InitGridButtons()

// Initiates buttons array of the adaptive search grid.

// iTotalGridButtons should be calculated in advance by caling InitGrid() 

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

//

void CAknAdaptiveSearchGrid::InitGridButtons()

    { 

    iButtonArray.ResetAndDestroy();         

    //EKKG-7LZB4U. When SizeChanged() is invoked, maybe iLastFocusedButton keeps invaild point. 

    iLastFocusedButton = NULL;      

    for ( TInt i = 0; i < iTotalGridButtons; i++ )

        {

        TRAP_IGNORE( iButtonArray.Append( CreateButtonL() ) );

        }

    }   

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

// CAknAdaptiveSearchGrid::CreateButtonL

// Create a button from Text or Resource. 

// Set to button observer and container window

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

//

CAknButton* CAknAdaptiveSearchGrid::CreateButtonL()

    {   

    CAknButton* button = CAknButton::NewL( NULL, NULL, NULL, NULL,

        KNullDesC, KNullDesC , KAknButtonSizeFitText, 0 );        

    if ( button )

        {       

        button->SetObserver( this );        

        button->SetContainerWindowL( *this ); 

        button->SetBackground(this);

        button->SetTextColorIds( KAknsIIDQsnTextColors, EAknsCIQsnTextColorsCG65 );

        button->ActivateL();

        return button;

        }

    else

        {

        CleanupStack::PopAndDestroy( button );

        User::LeaveNoMemory(); 

        return NULL;

        }  

    }

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

// CAknAdaptiveSearchGrid::RectFromLayout

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

//

TRect CAknAdaptiveSearchGrid::RectFromLayout( const TRect& aParent,

        const TAknWindowComponentLayout& aComponentLayout ) const

    {

    TAknWindowLineLayout lineLayout = aComponentLayout.LayoutLine();

    TAknLayoutRect layoutRect;

    layoutRect.LayoutRect( aParent, lineLayout );

    return layoutRect.Rect();

    }

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

// CAknAdaptiveSearchGrid::InitGrid

// Calculate max grid size and total amount of buttons for initialisation

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

//

void CAknAdaptiveSearchGrid::InitGrid()

    {  

    TInt layout_option;