/*

* 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:    LandmarksUi Content File -

*           Methods for Landmark editor field array.

*

*/

// INCLUDE FILES

#include "CLmkEditorFieldArray.h"  // this class

#include "MLmkEditorUiBuilder.h"

#include "MLmkEditorField.h"

#include "LmkEditorFieldFactory.h"

#include "CLmkFields.h"

#include "landmarks.hrh"

#include "CLmkUiUtils.h"

#include <bldvariant.hrh>

#include <EPos_CPosLandmark.h>

// Code added

#include <e32math.h>

#include <e32des16.h>

// CONSTANTS

/// Unnamed namespace for local definitions

namespace {

const TInt KNumberOfFields( 5 );

}  // namespace

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

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

// CLmkEditorFieldArray::CLmkEditorFieldArray

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

//

CLmkEditorFieldArray::CLmkEditorFieldArray( CLmkFields& aLmkFields,

        MLmkEditorUiBuilder& aUiBuilder ) :

    iLmkFields( aLmkFields ),

    iUiBuilder( aUiBuilder ),

    iFieldArray(KNumberOfFields)

    {

    }

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

// CLmkEditorFieldArray::ConstructL

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

//

void CLmkEditorFieldArray::ConstructL()

    {

	    iCategoryFlag = EFalse; // Used for showing categories

    }

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

// CLmkEditorFieldArray::NewL

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

//

CLmkEditorFieldArray* CLmkEditorFieldArray::NewL

        ( CLmkFields& aLmkFields,

        MLmkEditorUiBuilder& aUiBuilder )

    {

	CLmkEditorFieldArray* dlg = new(ELeave) CLmkEditorFieldArray( aLmkFields,

                                                                  aUiBuilder );

    CleanupStack::PushL( dlg );

    dlg->ConstructL();

    CleanupStack::Pop();  // dlg

    return dlg;

    }

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

// CLmkEditorFieldArray::~CLmkEditorFieldArray

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

//

CLmkEditorFieldArray::~CLmkEditorFieldArray()

    {

    iFieldArray.ResetAndDestroy();

    }

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

// CLmkEditorFieldArray::UpdateFieldsL

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

//

void CLmkEditorFieldArray::UpdateFieldsL( const TUint16 aFieldType )

    {

    TInt count = iFieldArray.Count();

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

        {

        if ( ( iFieldArray[i]->LandmarkItemField().FieldType() ==

               aFieldType ) || ( aFieldType == EAllEditorItems ) )

            {

            iFieldArray[i]->UpdateL();

            }

        }

    }

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

// CLmkEditorFieldArray::CreateFieldsFromLmkL

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

//

void CLmkEditorFieldArray::CreateFieldsFromLmkL()

    {

    CArrayPtrFlat<MLmkFieldData>& fields = iLmkFields.Fields();

    TInt count = fields.Count();

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

        {

        MLmkFieldData& lmkItemField = *fields[i];

        TBool tight = ETrue;

        if(iUiBuilder.EditMode())

	        {

	        tight =  CheckIfFieldIsEmpty(lmkItemField);

	        }

	        MLmkEditorField* editorField = NULL;

	        if( tight && iCategoryFlag && lmkItemField.EditorType() == EListFieldEditor )

	        {	//if there are

		        editorField = LmkEditorFieldFactory::CreateFieldL(

	                                        lmkItemField, iUiBuilder,iCategoryName);

	            iCategoryFlag = EFalse; // Safty purpose....

	        }

	        else if(tight)

			{

	        	editorField = LmkEditorFieldFactory::CreateFieldL(

	                                        lmkItemField, iUiBuilder );

			}

        CleanupStack::PushL( editorField );

        if ( editorField )

            {

            iFieldArray.AppendL( editorField );

            }

        CleanupStack::Pop(); //editorField

        }

    }

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

// CLmkEditorFieldArray::AreAllFieldsEmptyL

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

//

TBool CLmkEditorFieldArray::AreAllFieldsEmptyL() const

   {

   TBool result = ETrue;

   TReal localVar;

   const TInt fieldCount = iFieldArray.Count();

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

        {

        switch( iFieldArray[i]->LandmarkItemField().EditorType() )

            {

            //case ETextFieldEditor:

            case ETextGenericFieldEditor:

            case ETextPhoneNumberFieldEditor:

                {

                HBufC* fieldText = iFieldArray[i]->ControlTextL();

                if ( fieldText && fieldText->Length() > 0 )

                    {

					//Check if any active character or not

					TPtr16 ptr = fieldText->Des();

					ptr.Trim();

					if (ptr.Length() == 0)

						{

						result = ETrue;

						}

					else

						{

						result = EFalse;

						}

                    }

                delete fieldText;

                break;

                }

            case ETextUriFieldEditor:

                {

                HBufC* fieldText = iFieldArray[i]->ControlTextL();

                if( fieldText && fieldText->Length() > 0 )

                    {

                    //Check if any active character or not

					TPtr16 ptr = fieldText->Des();

					ptr.Trim();

					// Checking if the String present is only "http:\\"

					// If that is the case then the field is still

					// considered empty

					if(!CLmkUiUtils::FindIfWebAddrFieldIsEmpty(ptr))

					    {

					    result = EFalse;

					    }

                    }

                delete fieldText;

                break;

                }

            case EListFieldEditor:

                {

                if ( iFieldArray[i]->LandmarkItemField().Categories().Count() )

                    {

                    result = EFalse;

                    }

                break;

                }

           case ENumberFieldEditor:

   		        {

                localVar = iFieldArray[i]->FieldValue();

                if (!Math::IsNaN(localVar))

			        result = EFalse;

			    break;

		        }

           case ECoordinateFieldEditor:

   		        {

                localVar = iFieldArray[i]->FieldValue();

                if (!Math::IsNaN(localVar))

                    result = EFalse;

			    break;

		        }

            default:

                {

                break;

                }

            }

        if ( !result )

            {

            break;

            }

        }

    return result;

    }

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

// CLmkEditorFieldArray::FieldAt

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

//

const MLmkEditorField& CLmkEditorFieldArray::FieldAt

		( TInt aFieldIndex )

	{

    return *iFieldArray[aFieldIndex];

	}

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

// CLmkEditorFieldArray::Find

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

//

MLmkEditorField* CLmkEditorFieldArray::Find( TInt aControlId, TInt* aPos,

											 TInt* aPrevControlId ) const

    {

    MLmkEditorField* field = NULL;

	const TInt count = iFieldArray.Count();

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

        {

        MLmkEditorField* temp = iFieldArray.At(i);

        if (temp && temp->ControlId() == aControlId )

            {

            field = temp;

            if(aPos)

	            {

	            *aPos =i;

	            }

            break;

            }

        if( (temp && aPrevControlId) && temp->ControlId() < aControlId)

	        {

	        *aPrevControlId = temp->ControlId();

	        }

        }

    return field;

    }

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

// CLmkEditorFieldArray::SaveFieldsL

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

//

TBool CLmkEditorFieldArray::SaveFieldsL()

    {

	TBool result = EFalse;

    for ( TInt i(0); i < iFieldArray.Count(); ++i )

        {

        if ( iFieldArray[i]->SaveFieldL() )

			{

			result = ETrue;

			}

        }

    iLmkFields.SaveFieldsL();

    return result;

	}

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

// CLmkEditorFieldArray::SetCategoryName

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

//

void CLmkEditorFieldArray::SetCategoryName(const TDesC& aCategoryName)

{

	iCategoryName.Copy(aCategoryName);

	iCategoryFlag = ETrue;

}

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

// CLmkEditorFieldArray::SaveFieldsToBufferL

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

//

void CLmkEditorFieldArray::SaveFieldsToBufferL()

	{

    for ( TInt i(0); i < iFieldArray.Count(); ++i )

        {

        iFieldArray[i]->SaveFieldL();

        }

	}

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

// CLmkEditorFieldArray::GetFieldArray

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

//

CArrayPtrFlat<MLmkEditorField>& CLmkEditorFieldArray::GetFieldArray()

{

	return iFieldArray;

}

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

// CLmkEditorFieldArray::CheckIfFieldIsEmpty

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

//

TBool CLmkEditorFieldArray::CheckIfFieldIsEmpty(MLmkFieldData& a)

	{

	TBool result = EFalse;

	switch( a.EditorType() )

	    {

	    //case ETextFieldEditor:

	    case ETextGenericFieldEditor:

	    case ETextPhoneNumberFieldEditor:

	    case ETextUriFieldEditor:

	        {

	        TPtrC buf = a.TextData();

	        if ( buf.Length() > 0 )

	            {

	            result = ETrue;

	            }

	        break;

	        }

	    case EListFieldEditor:

	    	{

	    	RArray<TPosLmItemId>& t = a.Categories();

	    	if ( t.Count() > 0 )

	            {

	            result = ETrue;

	            }

	        break;

	        }

	    case ENumberFieldEditor:

	        {

	        TReal32 y = a.FloatData();

	        if(!Math::IsNaN(y))

	            {

	            result = ETrue;

	            }

	        break;

	        }

	    case ECoordinateFieldEditor:

	    	{

	    	TReal64 z = a.DoubleData();

	    	if(!Math::IsNaN(z))

	            {

	            result = ETrue;

	            }

	        break;

	        }

	    }

	  return result;

	}

// End of File