/*

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

#include "loadgen_loadattributes.h"

#include "loadgen.hrh"

#include <loadgen.rsg>

#include <AknForm.h> 

#include <eikedwin.h> 

#include <eikmfne.h>

#include <AknPopupFieldText.h>

#include <AknQueryValueText.h>

#include <eikspane.h> 

#include <akntitle.h> 

#include <eikcapc.h>

#include <e32hal.h> 

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

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

CLoadGenLoadTypeEditorBase::CLoadGenLoadTypeEditorBase(TBool aEditingExisting):

    iEditingExisting(aEditingExisting)

    {

    }

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

void CLoadGenLoadTypeEditorBase::ConstructL(const TDesC& aTitleText)

    {

    CAknForm::ConstructL();

    // set title text

    CEikStatusPane* sp = iEikonEnv->AppUiFactory()->StatusPane();

    CAknTitlePane* tp = static_cast<CAknTitlePane*>( sp->ControlL( TUid::Uid( EEikStatusPaneUidTitle ) ) );

    tp->SetTextL( aTitleText );

    }

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

void CLoadGenLoadTypeEditorBase::PreLayoutDynInitL()

    {

    CAknForm::PreLayoutDynInitL();

    }

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

TBool CLoadGenLoadTypeEditorBase::OkToExitL(TInt /*aButtonId*/)

    {

    return ETrue;

    }

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

void CLoadGenLoadTypeEditorBase::HandleControlStateChangeL(TInt aControlId)

    {

    CAknForm::HandleControlStateChangeL(aControlId);

    }

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

TBool CLoadGenLoadTypeEditorBase::RunQueryLD()

    {

    User::Panic(_L("Unk.form"), 222);

    return ETrue;

    }

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

TBool CLoadGenLoadTypeEditorBase::DoRunQueryLD(TInt aResource)

    {

    return ExecuteLD(aResource);

    }

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

void CLoadGenLoadTypeEditorBase::InsertFieldAfterL(TInt aResourceId, TInt aControlId, TInt aPrevControlId)

    {

    CCoeControl* prevControl = Control(aPrevControlId);

    __ASSERT_DEBUG(prevControl, User::Panic(_L("Form.Ctrl.Null"), 111));

    TInt pos = FindLineIndex(*prevControl);

    pos = pos + 1;

    InsertLineL(pos, aResourceId);

    Line(aControlId)->ActivateL();

    }

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

void CLoadGenLoadTypeEditorBase::UpdateFormL()

    {

    UpdatePageL(ETrue);

    }

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

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

CLoadGenCPULoadEditor* CLoadGenCPULoadEditor::NewL(TCPULoadAttributes& aAttributes, TBool aEditingExisting)

    {

    CLoadGenCPULoadEditor* self = new(ELeave) CLoadGenCPULoadEditor(aAttributes, aEditingExisting);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;    

    }

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

CLoadGenCPULoadEditor::~CLoadGenCPULoadEditor()

    {

    delete iCpuQueryValText;

    delete iCpuTextArray;

    delete iCPUsArray;

    }

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

CLoadGenCPULoadEditor::CLoadGenCPULoadEditor(TCPULoadAttributes& aAttributes, TBool aEditingExisting) :

    CLoadGenLoadTypeEditorBase(aEditingExisting), iAttributes(aAttributes)

    {

    }

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

void CLoadGenCPULoadEditor::ConstructL()

    {

    CLoadGenLoadTypeEditorBase::ConstructL(_L("CPU load"));

    }

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

void CLoadGenCPULoadEditor::PreLayoutDynInitL()

    {

    CLoadGenLoadTypeEditorBase::PreLayoutDynInitL();

    // load values to static editors

    CAknPopupFieldText* edPriority = static_cast<CAknPopupFieldText*>(Control(ELoadGenCPULoadQueryPriority));

    CAknPopupFieldText* edMode = static_cast<CAknPopupFieldText*>(Control(ELoadGenCPULoadQueryMode));

    CAknPopupFieldText* edType = static_cast<CAknPopupFieldText*>(Control(ELoadGenCPULoadQueryType));

    edPriority->SetCurrentValueIndex(iAttributes.iPriority);

    edMode->SetCurrentValueIndex(iAttributes.iMode);

    edType->SetCurrentValueIndex(iAttributes.iType);

    LoadCPUsL();

    UpdateVisibilitiesOfFieldsL(ETrue);

    }

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

void CLoadGenCPULoadEditor::LoadCPUsL()

    {

    // if we are running in SMP environment

    if (iAttributes.iCpuCount > 1)

        {

        // insert possibility to select which cpu the load is generated to

        InsertFieldAfterL(R_CPULOAD_DLG_LINE_CPU, ELoadGenCPULoadQueryCpu, ELoadGenCPULoadQueryType);

        iCPUsArray = new (ELeave) CDesCArrayFlat( 5 );

        // "Free scheduling" means that no specific cpu is selected. Scheduler desides

        // which CPUu runs load thread at which time.

        iCPUsArray->AppendL(_L("Free scheduling"));

        // add CPUs

        for (int i = 0; i < iAttributes.iCpuCount; i++) 

            {

            TBuf<10> cpu;

            _LIT(KCPU, "CPU%d");

            cpu.Format(KCPU, i);

            iCPUsArray->AppendL(cpu);

            }

        // "All CPUs" means that one thread is started for each CPU.

        iCPUsArray->AppendL(_L("All CPUs"));

        iCpuTextArray = CAknQueryValueTextArray::NewL();

        iCpuTextArray->SetArray( *iCPUsArray );  

        iCpuQueryValText = CAknQueryValueText::NewL();    

        iCpuQueryValText->SetArrayL( iCpuTextArray );

        // CPU is not defined, set "Free scheduling" as default selection in query list

        if (iAttributes.iCpu < 0)

            {

            iCpuQueryValText->SetCurrentValueIndex(0);

            }

        // "All CPUs" selected. It is last choise in the selection list.

        else if (iAttributes.iCpu == KCPUSelection_AllCPUs)

            {

            iCpuQueryValText->SetCurrentValueIndex(iCpuTextArray->MdcaCount()-1);

            }

        // CPU is defined, set the correct CPU as default selection in query list

        else

            {

            // iCpu starts from zero (i.e. CPU0 is first CPU), but index zero

            // in iCpuQueryValText is "Free scheduling", hence iCpu+1.

            iCpuQueryValText->SetCurrentValueIndex(iAttributes.iCpu+1);

            }

        CAknPopupField* popup = static_cast<CAknPopupField*>(Control( ELoadGenCPULoadQueryCpu)); 

        popup->SetQueryValueL( iCpuQueryValText );

        }

    }

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

TBool CLoadGenCPULoadEditor::OkToExitL(TInt aButtonId)

    {

    if (aButtonId == EAknSoftkeyOk)

        {

        // store values from editors

        CAknPopupFieldText* edPriority = static_cast<CAknPopupFieldText*>(Control(ELoadGenCPULoadQueryPriority));

        CAknPopupFieldText* edMode = static_cast<CAknPopupFieldText*>(Control(ELoadGenCPULoadQueryMode));

        CAknPopupFieldText* edType = static_cast<CAknPopupFieldText*>(Control(ELoadGenCPULoadQueryType));

        CEikNumberEditor* edPeak = static_cast<CEikNumberEditor*>(ControlOrNull(ELoadGenCPULoadQueryLength));

        CEikNumberEditor* edIdle = static_cast<CEikNumberEditor*>(ControlOrNull(ELoadGenCPULoadQueryIdle));

        CEikNumberEditor* edVariance = static_cast<CEikNumberEditor*>(ControlOrNull(ELoadGenCPULoadQueryVariance));

        // we are running in SMP environment

        if (iAttributes.iCpuCount > 1)

            {

            TInt currentValueIndex = iCpuQueryValText->CurrentValueIndex();

            // user selected a specific CPU in which the load thread should be run in.

            if (currentValueIndex == 0)

                {

                // User selected "Free scheduling"

                iAttributes.iCpu = KCPUSelection_FreeScheduling;

                }            

            else if( currentValueIndex == iCpuTextArray->MdcaCount()-1 )

                {

                // User selected "All CPUs", which is the last item in the selection list

                iAttributes.iCpu = KCPUSelection_AllCPUs;

                }

            else

                {                

                // iCpu should start from zero (CPU0 is the first cpu)

                // but zero in currentValueIndex means "Free scheduling". CPU0 in

                // currentValueIndex is at index 1, hence -1.

                iAttributes.iCpu = currentValueIndex - 1;

                }

            }

        iAttributes.iPriority = edPriority->CurrentValueIndex();

        iAttributes.iMode = edMode->CurrentValueIndex();

        iAttributes.iType = edType->CurrentValueIndex();

        if (edPeak) iAttributes.iLength = edPeak->Number();

        if (edIdle) iAttributes.iIdle = edIdle->Number();

        if (edVariance) iAttributes.iRandomVariance = edVariance->Number();

        }

    return ETrue;

    }       

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

void CLoadGenCPULoadEditor::UpdateVisibilitiesOfFieldsL(TBool aFormInit)

    {

    // filter based on selected cpu load type

    CAknPopupFieldText* edType = static_cast<CAknPopupFieldText*>( Control( ELoadGenCPULoadQueryType ) );

    if ( !aFormInit && edType->CurrentValueIndex() == ECpuLoadTypeContinuous )

        {

        // save values before deleting the items

        CCoeControl* control = ControlOrNull( ELoadGenCPULoadQueryLength );

        if ( control )

            {

            CEikNumberEditor* edPeak = static_cast<CEikNumberEditor*>( control );

            iAttributes.iLength = edPeak->Number();

            DeleteLine( ELoadGenCPULoadQueryLength );

            control = NULL;

            }

        control = ControlOrNull( ELoadGenCPULoadQueryIdle );

        if ( control )

            {

            CEikNumberEditor* edIdle = static_cast<CEikNumberEditor*>( control );

            iAttributes.iIdle = edIdle->Number();

            DeleteLine( ELoadGenCPULoadQueryIdle );

            control = NULL;

            }

        control = ControlOrNull( ELoadGenCPULoadQueryVariance );

        if ( control )

            {

            CEikNumberEditor* edVariance = static_cast<CEikNumberEditor*>( control );

            iAttributes.iRandomVariance = edVariance->Number();

            DeleteLine( ELoadGenCPULoadQueryVariance );

            }

        }

    else if ( edType->CurrentValueIndex() == ECpuLoadTypePeriodic )

        {

        // insert new fields

        InsertFieldAfterL(R_CPULOAD_DLG_LINE_PERIODIC_LENGTH, ELoadGenCPULoadQueryLength, ELoadGenCPULoadQueryType);

        InsertFieldAfterL(R_CPULOAD_DLG_LINE_PERIODIC_IDLE, ELoadGenCPULoadQueryIdle, ELoadGenCPULoadQueryLength);

        InsertFieldAfterL(R_CPULOAD_DLG_LINE_PERIODIC_VARIANCE, ELoadGenCPULoadQueryVariance, ELoadGenCPULoadQueryIdle);

        // load values to just created editors

        CEikNumberEditor* edPeak = static_cast<CEikNumberEditor*>(Control(ELoadGenCPULoadQueryLength));

        CEikNumberEditor* edIdle = static_cast<CEikNumberEditor*>(Control(ELoadGenCPULoadQueryIdle));

        CEikNumberEditor* edVariance = static_cast<CEikNumberEditor*>(Control(ELoadGenCPULoadQueryVariance));

        edPeak->SetNumber(iAttributes.iLength);

        edIdle->SetNumber(iAttributes.iIdle);

        edVariance->SetNumber(iAttributes.iRandomVariance);

        }

    UpdateFormL();

    }

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

void CLoadGenCPULoadEditor::HandleControlStateChangeL(TInt aControlId)

    {

    CLoadGenLoadTypeEditorBase::HandleControlStateChangeL(aControlId);

    // update visibilities of fields    

    if (aControlId == ELoadGenCPULoadQueryType)

        {

        UpdateVisibilitiesOfFieldsL();

        }

    }

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

TBool CLoadGenCPULoadEditor::RunQueryLD()

    {

    return CLoadGenLoadTypeEditorBase::DoRunQueryLD(R_CPULOAD_FORM_DIALOG);

    }

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

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

CLoadGenMemoryEatEditor* CLoadGenMemoryEatEditor::NewL(TMemoryEatAttributes& aAttributes, TBool aEditingExisting)

    {

    CLoadGenMemoryEatEditor* self = new(ELeave) CLoadGenMemoryEatEditor(aAttributes, aEditingExisting);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;    

    }

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

CLoadGenMemoryEatEditor::~CLoadGenMemoryEatEditor()

    {

    }

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

CLoadGenMemoryEatEditor::CLoadGenMemoryEatEditor(TMemoryEatAttributes& aAttributes, TBool aEditingExisting) :

    CLoadGenLoadTypeEditorBase(aEditingExisting), iAttributes(aAttributes)

    {

    }

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

void CLoadGenMemoryEatEditor::ConstructL()

    {

    CLoadGenLoadTypeEditorBase::ConstructL(_L("Memory eat"));

    // convert int64 vals to descs

    iAttributes.iAmountDes.Copy(KNullDesC);

    iAttributes.iRandomMinDes.Copy(KNullDesC);

    iAttributes.iRandomMaxDes.Copy(KNullDesC);

    iAttributes.iAmountDes.AppendNum(iAttributes.iAmount);

    iAttributes.iRandomMinDes.AppendNum(iAttributes.iRandomMin);

    iAttributes.iRandomMaxDes.AppendNum(iAttributes.iRandomMax);

    }

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

void CLoadGenMemoryEatEditor::PreLayoutDynInitL()

    {

    CLoadGenLoadTypeEditorBase::PreLayoutDynInitL();

    // load values to static editors

    CAknPopupFieldText* edPriority = static_cast<CAknPopupFieldText*>(Control(ELoadGenMemoryEatQueryPriority));

    CAknPopupFieldText* edSource = static_cast<CAknPopupFieldText*>(Control(ELoadGenMemoryEatQuerySource));

    CAknPopupFieldText* edType = static_cast<CAknPopupFieldText*>(Control(ELoadGenMemoryEatQueryType));

    CEikNumberEditor* edBuffer = static_cast<CEikNumberEditor*>(Control(ELoadGenMemoryEatQueryBuffer));

    CEikNumberEditor* edIdle = static_cast<CEikNumberEditor*>(Control(ELoadGenMemoryEatQueryIdle));

    CEikNumberEditor* edVariance = static_cast<CEikNumberEditor*>(Control(ELoadGenMemoryEatQueryVariance));

    edPriority->SetCurrentValueIndex(iAttributes.iPriority);

    edSource->SetCurrentValueIndex(iAttributes.iSource);

    edType->SetCurrentValueIndex(iAttributes.iType);

    edBuffer->SetNumber(iAttributes.iBuffer);

    edIdle->SetNumber(iAttributes.iIdle);

    edVariance->SetNumber(iAttributes.iRandomVariance);

    UpdateVisibilitiesOfFieldsL(ETrue);

    UpdateAvailableMemoryL();

    // set source as dimmed if editing existing item

    if (iEditingExisting)

        {

        SetLineDimmedNow(ELoadGenMemoryEatQuerySource, ETrue); 

        }

    }

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

TBool CLoadGenMemoryEatEditor::OkToExitL(TInt aButtonId)

    {

    if (aButtonId == EAknSoftkeyOk)

        {

        // store values from editors

        CAknPopupFieldText* edPriority = static_cast<CAknPopupFieldText*>(Control(ELoadGenMemoryEatQueryPriority));

        CAknPopupFieldText* edSource = static_cast<CAknPopupFieldText*>(Control(ELoadGenMemoryEatQuerySource));

        CAknPopupFieldText* edType = static_cast<CAknPopupFieldText*>(Control(ELoadGenMemoryEatQueryType));

        CEikNumberEditor* edBuffer = static_cast<CEikNumberEditor*>(Control(ELoadGenMemoryEatQueryBuffer));

        CEikNumberEditor* edIdle = static_cast<CEikNumberEditor*>(Control(ELoadGenMemoryEatQueryIdle));

        CEikNumberEditor* edVariance = static_cast<CEikNumberEditor*>(Control(ELoadGenMemoryEatQueryVariance));

        iAttributes.iPriority = edPriority->CurrentValueIndex();

        iAttributes.iSource = edSource->CurrentValueIndex();

        iAttributes.iType = edType->CurrentValueIndex();

        iAttributes.iBuffer = edBuffer->Number();

        iAttributes.iIdle = edIdle->Number();

        iAttributes.iRandomVariance = edVariance->Number();

        CEikEdwin* edAmount = static_cast<CEikEdwin*>(ControlOrNull(ELoadGenMemoryEatQueryAmount));

        CEikEdwin* edRandomMin = static_cast<CEikEdwin*>(ControlOrNull(ELoadGenMemoryEatQueryRandomMin));

        CEikEdwin* edRandomMax = static_cast<CEikEdwin*>(ControlOrNull(ELoadGenMemoryEatQueryRandomMax));

        // get desc values and convert to int64

        if (edAmount)

            {

            edAmount->GetText(iAttributes.iAmountDes);

            TLex converter;

            converter.Assign(iAttributes.iAmountDes);

            User::LeaveIfError(converter.Val(iAttributes.iAmount));

            }

        if (edRandomMin)

            {

            edRandomMin->GetText(iAttributes.iRandomMinDes);

            TLex converter;

            converter.Assign(iAttributes.iRandomMinDes);

            User::LeaveIfError(converter.Val(iAttributes.iRandomMin));

            }

        if (edRandomMax)

            {

            edRandomMax->GetText(iAttributes.iRandomMaxDes);

            TLex converter;

            converter.Assign(iAttributes.iRandomMaxDes);

            User::LeaveIfError(converter.Val(iAttributes.iRandomMax));

            // swap min max values if they in wrong order

            if (iAttributes.iRandomMin > iAttributes.iRandomMax)

                {

                TInt64 temp(iAttributes.iRandomMin);

                iAttributes.iRandomMin = iAttributes.iRandomMax;

                iAttributes.iRandomMax = temp; 

                }

            }                        

        }

    return ETrue;

    }       

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

void CLoadGenMemoryEatEditor::UpdateVisibilitiesOfFieldsL(TBool aFormInit)

    {

    // filter based on selected memory eat type

    CAknPopupFieldText* edType = static_cast<CAknPopupFieldText*>(Control(ELoadGenMemoryEatQueryType));

    if (!aFormInit && (edType->CurrentValueIndex() == EMemoryEatTypeMemoryToEat || edType->CurrentValueIndex() == EMemoryEatTypeMemoryToBeLeft))

        {

        // no need for changes if amount field is already active

        CEikNumberEditor* edAmount = static_cast<CEikNumberEditor*>(ControlOrNull(ELoadGenMemoryEatQueryAmount));

        if (edAmount) return;

        // save values before deleting the items

        CEikEdwin* edRandomMin = static_cast<CEikEdwin*>(Control(ELoadGenMemoryEatQueryRandomMin));

        CEikEdwin* edRandomMax = static_cast<CEikEdwin*>(Control(ELoadGenMemoryEatQueryRandomMax));

        edRandomMin->GetText(iAttributes.iRandomMinDes);

        edRandomMax->GetText(iAttributes.iRandomMaxDes);

        DeleteLine(ELoadGenMemoryEatQueryRandomMin);

        DeleteLine(ELoadGenMemoryEatQueryRandomMax);

        }

    else if (!aFormInit && edType->CurrentValueIndex() == EMemoryEatTypeWavy)

        {

        // save values before deleting the items

        CEikEdwin* edAmount = static_cast<CEikEdwin*>(Control(ELoadGenMemoryEatQueryAmount));

        edAmount->GetText(iAttributes.iAmountDes);

        DeleteLine(ELoadGenMemoryEatQueryAmount);

        }

    if (edType->CurrentValueIndex() == EMemoryEatTypeMemoryToEat || edType->CurrentValueIndex() == EMemoryEatTypeMemoryToBeLeft)

        {

        // insert new fields

        InsertFieldAfterL(R_MEMORYEAT_DLG_LINE_AMOUNT, ELoadGenMemoryEatQueryAmount, ELoadGenMemoryEatQueryType);

        // load values to just created editors

        CEikEdwin* edAmount = static_cast<CEikEdwin*>(Control(ELoadGenMemoryEatQueryAmount));

        edAmount->SetTextL(&iAttributes.iAmountDes);

        }

    else if (edType->CurrentValueIndex() == EMemoryEatTypeWavy)

        {

        // insert new fields

        InsertFieldAfterL(R_MEMORYEAT_DLG_LINE_RANDOM_MIN, ELoadGenMemoryEatQueryRandomMin, ELoadGenMemoryEatQueryType);

        InsertFieldAfterL(R_MEMORYEAT_DLG_LINE_RANDOM_MAX, ELoadGenMemoryEatQueryRandomMax, ELoadGenMemoryEatQueryRandomMin);

        // load values to just created editors