/*

* Copyright (c) 2000 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: Manual tuning dialog for FMRadio

*

*/

// INCLUDE FILES

#include	<aknappui.h>

#include	<AknsFrameBackgroundControlContext.h>

#include    <aknbutton.h>

#include 	<AknLayoutDef.h>

#include 	<AknLayout2ScalableDef.h>

#include 	<aknlayoutscalable_avkon.cdl.h>

#include 	<avkon.mbg>

#include 	<avkon.rsg>

#include	<barsread.h>

#include	<eiklabel.h>

#include	<skinlayout.cdl.h>

#include	<AknsDrawUtils.h>

#include	<StringLoader.h>

#include 	<aknconsts.h>

#include	<fmradio.rsg>

#include    "fmradiofrequencyquerycontrol.h"

#include	"fmradiofrequencyeditor.h"

#include	"fmradio.hrh"

#include 	"debug.h"

// CONSTANTS

const TInt KFMRadioButtonLongPressDelay = 450; //microseconds after long press event is reported

const TInt KFMRadioButtonRepeatDelay = 500;  //microseconds after repeat event is reported

const TInt KFMRadioButtonRepeatInterval = 200; //microseconds after repeat event is repeated

const TInt KFMRadioButtonRepeatDelayMicroseconds(KFMRadioButtonRepeatDelay*1000);

const TInt KFMRadioButtonRepeatIntervalMicrosecondsAccelerated(KFMRadioButtonRepeatInterval*500);

const TInt KFMRadioButtonRepeatAccelerationDelay(2000000); //Two seconds until accelerate long press repeat

const TInt  KEditorFrameCustomLRMargins = 50;

const TInt  KEditorFrameCustomAdditionHeight = 30;

const TInt KFMRadioEditorCustomInnerFrameSize = 15;

const TInt KFMRadioEditorCustomButtonMarginToLeftFrame = 1;

const TInt KFMRadioEditorCustomButtonSize = 16;

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

// C++ default constructor can NOT contain any code, that

// might leave.

//

CFMRadioFrequencyQueryControl::CFMRadioFrequencyQueryControl() : CAknQueryControl()

    {

    }

// Destructor

CFMRadioFrequencyQueryControl::~CFMRadioFrequencyQueryControl()

    {

    if (iFreqEditor)

        AknsUtils::DeregisterControlPosition(iFreqEditor);

    delete iFreqEditor;

	delete iMyPrompt;

	delete iMyEditorIndicator;

	delete iEditorContext;

	if ( iLongPressAccelerationTimer )

	    {

    	iLongPressAccelerationTimer->Cancel();

    	delete iLongPressAccelerationTimer;

	    }

	if ( iLongPressTimer) 

	    {

	    iLongPressTimer->Cancel();

	    delete iLongPressTimer;

	    }

    }

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

// CFMRadioFrequencyQueryControl::StaticCreateCustomControl

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

//

SEikControlInfo CFMRadioFrequencyQueryControl::StaticCreateCustomControl(TInt aIdentifier)

{

	FTRACE( FPrint( _L(" *** FM Radio -- CFMRadioFrequencyQueryControl::StaticCreateCustomControl -- ENTER") ) );

	SEikControlInfo customInfo;

	Mem::FillZ(&customInfo, sizeof(SEikControlInfo)); // zero all variables

	if (aIdentifier == EFMRadioCtFrequencyQuery)

	{

		customInfo.iControl = new CFMRadioFrequencyQueryControl;

	}

	FTRACE( FPrint( _L(" *** FM Radio -- CFMRadioFrequencyQueryControl::StaticCreateCustomControl -- EXIT") ) );

	return customInfo;

}

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

// CFMRadioFrequencyQueryControl::ConstructQueryL

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

//

void CFMRadioFrequencyQueryControl::ConstructQueryL(TResourceReader& aRes)

	{

	iFreqEditor = new (ELeave) CFMRadioFrequencyEditor;

    iFreqEditor->SetContainerWindowL(*this);

    iFreqEditor->ConstructFromResourceL(aRes);

    iFreqEditor->SetObserver(this);

    iFreqEditor->SetSkinTextColorL( EAknsCIQsnTextColorsCG27 );//query text input field

	iMyPrompt = new (ELeave) CEikLabel;

	iMyPrompt->SetContainerWindowL( *this );

	HBufC* promptTxt = StringLoader::LoadLC( R_QTN_FMRADIO_MANUAL_TUNE_FREQ );

	iMyPrompt->SetTextL( *promptTxt );

	CleanupStack::PopAndDestroy( promptTxt );

	iMyEditorIndicator = CFMRadioManualTuningEditorIndicator::NewL( this );

	// Construct editor context

    iEditorContext = CAknsFrameBackgroundControlContext::NewL(

        KAknsIIDQsnFrInput, TRect(0,0,1,1), TRect(0,0,1,1), EFalse );

    if ( AknLayoutUtils::PenEnabled() )

        {

        // Buttons with correct icons

          iIncreaseValueButton = 

                 CAknButton::NewL(KAvkonBitmapFile,

                 EMbmAvkonQgn_indi_button_increase,

                 EMbmAvkonQgn_indi_button_increase_mask,

                 -1,

                 -1,

                 EMbmAvkonQgn_indi_button_increase_pressed,

                 EMbmAvkonQgn_indi_button_increase_pressed_mask,

                 -1,

                 -1,

                 KNullDesC,

                 KNullDesC,

                 KAknButtonNoFrame /*| KAknButtonKeyRepeat*/ | KAknButtonReportOnLongPress,

                 0,

                 KAknsIIDQgnIndiButtonIncrease,

                 KAknsIIDNone,

                 KAknsIIDQgnIndiButtonIncreasePressed,

                 KAknsIIDNone );         

        iIncreaseValueButton->SetContainerWindowL(*this);

        iIncreaseValueButton->SetParent(this);

        iIncreaseValueButton->SetObserver(this);

        iIncreaseValueButton->MakeVisible(ETrue);

        iIncreaseValueButton->SetFocusing(EFalse);

       	iIncreaseValueButton->SetKeyRepeatInterval( KFMRadioButtonRepeatDelay, KFMRadioButtonRepeatInterval );

	    iIncreaseValueButton->SetLongPressInterval( KFMRadioButtonLongPressDelay );        

        iDecreaseValueButton = 

                 CAknButton::NewL(KAvkonBitmapFile,

                 EMbmAvkonQgn_indi_button_decrease,

                 EMbmAvkonQgn_indi_button_decrease_mask,

                 -1,

                 -1,

                 EMbmAvkonQgn_indi_button_decrease_pressed,

                 EMbmAvkonQgn_indi_button_decrease_pressed_mask,

                 -1,

                 -1,

                 KNullDesC,

                 KNullDesC,

                 KAknButtonNoFrame /*| KAknButtonKeyRepeat*/ | KAknButtonReportOnLongPress,

                 0,

                 KAknsIIDQgnIndiButtonDecrease,

                 KAknsIIDNone,

                 KAknsIIDQgnIndiButtonDecreasePressed,

                 KAknsIIDNone );

        iDecreaseValueButton->SetContainerWindowL(*this);

        iDecreaseValueButton->SetParent(this);

        iDecreaseValueButton->SetObserver(this);

        iDecreaseValueButton->MakeVisible(ETrue);

        iDecreaseValueButton->SetFocusing(EFalse);

		iDecreaseValueButton->SetKeyRepeatInterval( KFMRadioButtonRepeatDelay, KFMRadioButtonRepeatInterval );

	    iDecreaseValueButton->SetLongPressInterval( KFMRadioButtonLongPressDelay );

        }   

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

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

  	}

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

// CFMRadioFrequencyQueryControl::ComponentControl

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

//

CCoeControl* CFMRadioFrequencyQueryControl::ComponentControl(TInt aIndex) const

	{

    /*lint -save -e1763*/

    CCoeControl* ccontrol = NULL;

	switch (aIndex)

		{

		case 0:

			{

			ccontrol = iMyPrompt;

			break;

			}

		case 1:

			{

			ccontrol = iMyEditorIndicator;

			break;

			}

		case 2:

			{

			ccontrol = iFreqEditor;

			break;

			}

		case 3:

			{

			if ( AknLayoutUtils::PenEnabled() )

				{

		    	ccontrol = iIncreaseValueButton;

		    	}

		   	break;

		   	}

		case 4:

			{

			if ( AknLayoutUtils::PenEnabled() )

				{

	    		ccontrol = iDecreaseValueButton;

	    		}

	    	break;

	    	}

		default:

			{

			ccontrol = NULL;

			break;

			}

		}

	return ccontrol;

    /*lint -restore*/

	}

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

// CFMRadioFrequencyQueryControl::CountComponentControls

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

//

TInt CFMRadioFrequencyQueryControl::CountComponentControls() const

	{

	if ( AknLayoutUtils::PenEnabled() )

		{

		return 5;

		}

	else

		{

		return 3;

		}

	}

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

// CFMRadioFrequencyQueryControl::FocusChanged

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

//

void CFMRadioFrequencyQueryControl::FocusChanged(TDrawNow aDrawNow)

	{

    if (iFreqEditor)

        {

        iFreqEditor->SetFocus(IsFocused(), aDrawNow);

        SizeChanged();

        }

	}

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

// CFMRadioFrequencyQueryControl::PrepareForFocusLossL

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

//

void CFMRadioFrequencyQueryControl::PrepareForFocusLossL()

	{

    if (iFreqEditor)

        {

        iFreqEditor->PrepareForFocusLossL(); 

        }

	}

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

// CFMRadioFrequencyQueryControl::SetAcceleratedLongPress

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

//

void CFMRadioFrequencyQueryControl::SetAcceleratedLongPress(TBool aAccelerated)

    {

    iLongPressAccelerationTimer->Cancel();

    iLongPressTimer->Cancel();

    if( aAccelerated)

        {

        //add more speed

        iLongPressTimer->Start(KFMRadioButtonRepeatIntervalMicrosecondsAccelerated,

                            KFMRadioButtonRepeatIntervalMicrosecondsAccelerated,

                            TCallBack(LongPressTimerCallBack, this));

        }

    }

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

// CFMRadioFrequencyQueryControl::LongPressAccelerateCallBack

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

//

TInt CFMRadioFrequencyQueryControl::LongPressAccelerateCallBack( TAny* aAny )

    {

    ((CFMRadioFrequencyQueryControl*)(aAny))->SetAcceleratedLongPress(ETrue);

    return KErrNone;

    }

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

// CFMRadioFrequencyQueryControl::LongPressTimerCallBack

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

//

TInt CFMRadioFrequencyQueryControl::LongPressTimerCallBack( TAny* aAny )

    {

    ((CFMRadioFrequencyQueryControl*)(aAny))->DoIncrementOrDecrement();

    return KErrNone;

    }

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

// CFMRadioFrequencyQueryControl::DoIncrementOrDecrement

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

//

void CFMRadioFrequencyQueryControl::DoIncrementOrDecrement()

    {

    if(iChangeDirectionIncrease)

        {

        iFreqEditor->IncrementCurrentField();

        }

    else

        {

        iFreqEditor->DecrementCurrentField();

        }

    iKeyPressReported = ETrue;

    }

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

// CFMRadioFrequencyQueryControl::StartKeypress

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

//

void CFMRadioFrequencyQueryControl::StartKeypress()

    {

    iKeyPressReported = EFalse;

    iLongPressAccelerationTimer->Cancel();

    iLongPressAccelerationTimer->Start(KFMRadioButtonRepeatAccelerationDelay, 0,

                                        TCallBack(LongPressAccelerateCallBack, this));

    iLongPressTimer->Start(KFMRadioButtonRepeatDelayMicroseconds,

                        KFMRadioButtonRepeatDelayMicroseconds,

                        TCallBack(LongPressTimerCallBack, this));

    iFreqEditor->SetEditorReportState( EFalse );

    }

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

// CFMRadioFrequencyQueryControl::OfferKeyEventL

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

//

TKeyResponse CFMRadioFrequencyQueryControl::OfferKeyEventL( const TKeyEvent& aKeyEvent, TEventCode aType )

    {

    if ( aType == EEventKeyDown &&

            (aKeyEvent.iScanCode == EStdKeyUpArrow || aKeyEvent.iScanCode == EStdKeyDownArrow) )

        {

        iChangeDirectionIncrease = (aKeyEvent.iScanCode == EStdKeyUpArrow);

        StartKeypress();

        return EKeyWasConsumed;

        }

    else if ( aType == EEventKeyUp &&

            (aKeyEvent.iScanCode == EStdKeyUpArrow || aKeyEvent.iScanCode == EStdKeyDownArrow) )

        {

        if(!iKeyPressReported)

            {

            //was not a long press

            DoIncrementOrDecrement();

            }

        SetAcceleratedLongPress(EFalse);

        iFreqEditor->SetEditorReportState( ETrue );

        iFreqEditor->DrawAndReportL( EFalse );

        return EKeyWasConsumed;

        }

    //eat all up and down events, this is for EEventKey

    if(aKeyEvent.iScanCode == EStdKeyUpArrow || aKeyEvent.iScanCode == EStdKeyDownArrow)

        {

        return EKeyWasConsumed;

        }

    return iFreqEditor->OfferKeyEventL(aKeyEvent, aType);

    }

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

// CFMRadioFrequencyQueryControl::HandleControlEventL

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

//

void CFMRadioFrequencyQueryControl::HandleControlEventL(CCoeControl* aControl, TCoeEvent aEventType)

	{

	if ( aEventType == CAknButton::ELongPressEndedEvent  )

		{

		SetAcceleratedLongPress(EFalse);

		iFreqEditor->SetEditorReportState( ETrue );

		iFreqEditor->DrawAndReportL( EFalse );

		}

	if ( (aControl == iIncreaseValueButton || aControl == iDecreaseValueButton )

	    && aEventType == CAknButton::ELongPressEvent )

        {

        iChangeDirectionIncrease = (aControl == iIncreaseValueButton);

        StartKeypress();

        return;

        }

	//single presses

	if ( aControl == iIncreaseValueButton && aEventType == EEventStateChanged )

        {

        iFreqEditor->IncrementCurrentField();

        return;

        }

	else if ( aControl == iDecreaseValueButton && aEventType == EEventStateChanged )

        {

        iFreqEditor->DecrementCurrentField();

        return;

        }

	//finally tune to the frequency

    if (iQueryControlObserver && aEventType == EEventStateChanged)

        {                

        if ( iFreqEditor->IsValidToReport() )

            {

			MAknQueryControlObserver::TQueryValidationStatus validity = MAknQueryControlObserver::EEditorValueValid;

			if ( !iFreqEditor->IsValid() )

				{

				validity = MAknQueryControlObserver::EEditorValueNotParsed; 

				}

            iQueryControlObserver->HandleQueryEditorStateEventL( this, MAknQueryControlObserver::EQueryControlEditorStateChanging, validity );

            }

		}	            

	}

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

// CFMRadioFrequencyQueryControl::SetFrequency

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

//

void CFMRadioFrequencyQueryControl::SetFrequency(const TUint32 aFreq)

	{

	if (iFreqEditor)

		{

		iFreqEditor->SetFrequency(aFreq);

		}

	}

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

// CFMRadioFrequencyQueryControl::Frequency

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

//		

TUint32 CFMRadioFrequencyQueryControl::Frequency() const

	{

    if (iFreqEditor)

        {

        return iFreqEditor->Frequency();

        }

    return 0; 

	}

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

// CFMRadioFrequencyQueryControl::ControlByLayoutOrNull

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

//

CCoeControl* CFMRadioFrequencyQueryControl::ControlByLayoutOrNull(TInt /*aLayout*/)

	{

    return iFreqEditor;

	}

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

// CFMRadioFrequencyQueryControl::EditorContentIsValidL

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

//

TBool CFMRadioFrequencyQueryControl::EditorContentIsValidL() const

	{

	TInt ret = EFalse;

    if (iFreqEditor) 

        {

        CEikMfne* editor = iFreqEditor;

        ret = editor->Field(editor->CurrentField())->IsValid();

        }

    return ret;

	}

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

// CFMRadioFrequencyQueryControl::SetAndUseFlags

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

//

void CFMRadioFrequencyQueryControl::SetAndUseFlags(TBitFlags16 aFlags)

	{

	iFlags = aFlags;

	iMyEditorIndicator->SetFlags(aFlags);

	}

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

// CFMRadioFrequencyQueryControl::LayoutEditor

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

//

void CFMRadioFrequencyQueryControl::LayoutEditor(const TLayoutMethod& aLayoutM)

	{

	TIndex LAFIndex(NbrOfPromptLines());

    iHasEditor = ETrue;

    LayoutEditorFrame(aLayoutM);

    LayoutEditorIndicator(aLayoutM);	

    CEikMfne* edwin = NULL;

    if ( iFreqEditor )

        {

        edwin = iFreqEditor;

        }        

    if ( edwin )

        {