// EIKFRMUT.CPP
//
// Copyright (c) 1997-1999 Symbian Ltd.  All rights reserved.
//

#include <coemain.h>
#include <eikform.h>
#include <eikcapca.h>
#include <eikcapc.h>
#include <eiklabel.h>
#include <eikopbut.h>
#include <eikhopbt.h>
#include <eikedwin.h>
#include <eikrted.h>
#include <eikchlst.h>
#include <eikmfne.h>
#include <eikmfne.hrh>
#include <eikfpne.h>
#include <eikchkbx.h>
#include <eikseced.h>
#include <eikctrls.hrh>

EXPORT_C void CEikForm::AddAutoTextEditorL(const TDesC& aPrompt,TInt aId,TInt aFlags,TInt aWidthInChars,TInt aNoOfLines,TDes* aReturn)
	{
	CEikEdwin* edwin=(CEikEdwin*)CreateLineByTypeL(aPrompt,aId,EEikCtEdwin,aReturn);
	edwin->ConstructL(aFlags,aWidthInChars,aReturn->MaxLength(),aNoOfLines);
	edwin->SetTextL(aReturn);
	}

EXPORT_C void CEikForm::AddAutoGlobalTextEditorL(const TDesC& aPrompt,TInt aId,TInt aFlags,TInt aWidthInChars,TInt aNoOfLines,TInt aTextLimit,CGlobalText* aReturn,TInt aFontControlFlags,TInt aFontNameFlags)
	{
	CEikGlobalTextEditor* gtEditor=(CEikGlobalTextEditor*)CreateLineByTypeL(aPrompt,aId,EEikCtGlobalTextEditor,aReturn);
	gtEditor->ConstructL(this,aNoOfLines,aTextLimit,aFlags,aFontControlFlags,aFontNameFlags);
	gtEditor->CalculateWidth(aWidthInChars);
	CEikEdwin::TSetContent content=(aFlags&CEikEdwin::EUserSuppliedText? CEikEdwin::EUseText : CEikEdwin::ECopyText);
	gtEditor->SetDocumentContentL(*aReturn,content);
	}

EXPORT_C void CEikForm::AddAutoRichTextEditorL(const TDesC& aPrompt,TInt aId,TInt aFlags,TInt aWidthInChars,TInt aNoOfLines,TInt aTextLimit,CGlobalText* aReturn,TInt aFontControlFlags,TInt aFontNameFlags)
	{
	CEikRichTextEditor* rtEditor=(CEikRichTextEditor*)CreateLineByTypeL(aPrompt,aId,EEikCtRichTextEditor,aReturn);
	rtEditor->ConstructL(this,aNoOfLines,aTextLimit,aFlags,aFontControlFlags,aFontNameFlags);
	rtEditor->CalculateWidth(aWidthInChars);
	CEikEdwin::TSetContent content=(aFlags&CEikEdwin::EUserSuppliedText? CEikEdwin::EUseText : CEikEdwin::ECopyText);
	rtEditor->SetDocumentContentL(*aReturn,content);
	}

EXPORT_C void CEikForm::AddAutoChoiceListL(const TDesC& aPrompt,TInt aId,TInt aFlags,TInt aMaxChar,MDesCArray* aArray,TInt* aReturn)
	{
	CEikChoiceList* list = (CEikChoiceList*)CreateLineByTypeL(aPrompt,aId,EEikCtChoiceList,aReturn);
	list->ConstructL(this,aFlags,aMaxChar);
	list->SetArrayL(aArray);
	list->SetCurrentItem(*aReturn);
	}

EXPORT_C void CEikForm::AddAutoNumberEditorL(const TDesC& aPrompt,TInt aId,TInt aMin,TInt aMax,TInt* aReturn)
	{
	CEikNumberEditor* numEd=(CEikNumberEditor*)CreateLineByTypeL(aPrompt,aId,EEikCtNumberEditor,aReturn);
	numEd->ConstructL(aMin,aMax,*aReturn);
	}

EXPORT_C void CEikForm::AddAutoRangeEditorL(const TDesC& aPrompt,TInt aId,TInt aMin,TInt aMax,HBufC* aSeparatorText,SEikRange* aReturn)
	{
	CEikRangeEditor* rangeEd=(CEikRangeEditor*)CreateLineByTypeL(aPrompt,aId,EEikCtRangeEditor,aReturn);
	rangeEd->ConstructL(aMin,aMax,*aReturn, aSeparatorText);
	}

EXPORT_C void CEikForm::AddAutoTimeEditorL(const TDesC& aPrompt,TInt aId,const TTime& aMin,const TTime& aMax,TBool aNoSeconds,TTime* aReturn)
	{
	CEikTimeEditor* timeEd = (CEikTimeEditor*)CreateLineByTypeL(aPrompt,aId,EEikCtTimeEditor,aReturn);
	timeEd->ConstructL(aMin,aMax,*aReturn,aNoSeconds);
	}

EXPORT_C void CEikForm::AddAutoDateEditorL(const TDesC& aPrompt,TInt aId,const TTime& aMin,const TTime& aMax, TBool aNoPopout,TTime* aReturn)
	{
	CEikDateEditor* dateEd = (CEikDateEditor*)CreateLineByTypeL(aPrompt,aId,EEikCtDateEditor,aReturn);
	dateEd->ConstructL(aMin,aMax,*aReturn,aNoPopout);
	}

EXPORT_C void CEikForm::AddAutoTimeAndDateEditorL(const TDesC& aPrompt,TInt aId,const TTime& aMin,const TTime& aMax,TBool aNoSeconds,TBool aNoPopout,HBufC* aInterveningText,TTime* aReturn)
	{
	TUint32 flags=0;
	if(aNoSeconds)
		flags|=EEikTimeWithoutSecondsField;
	if(aNoPopout)
		flags|=EEikDateWithoutPopoutCalendar;
	CEikTimeAndDateEditor* timeAndDateEd = (CEikTimeAndDateEditor*)CreateLineByTypeL(aPrompt,aId,EEikCtTimeAndDateEditor,aReturn);
	timeAndDateEd->ConstructL(aMin,aMax,*aReturn,flags,aInterveningText);
	}

EXPORT_C void CEikForm::AddAutoDurationEditorL(const TDesC& aPrompt,TInt aId,const TTimeIntervalSeconds& aMin,const TTimeIntervalSeconds& aMax,TBool aNoSeconds,TTimeIntervalSeconds* aReturn)
	{
	CEikDurationEditor* durationEd = (CEikDurationEditor*)CreateLineByTypeL(aPrompt,aId,EEikCtDurationEditor,aReturn);
	durationEd->ConstructL(aMin,aMax,*aReturn,aNoSeconds);
	}

EXPORT_C void CEikForm::AddAutoTimeOffsetEditorL(const TDesC& aPrompt,TInt aId,const TTimeIntervalSeconds& aMin,const TTimeIntervalSeconds& aMax,TBool aNoSeconds,TTimeIntervalSeconds* aReturn)
	{
	CEikTimeOffsetEditor* timeOffsetEd = (CEikTimeOffsetEditor*)CreateLineByTypeL(aPrompt,aId,EEikCtTimeOffsetEditor,aReturn);
	timeOffsetEd->ConstructL(aMin,aMax,*aReturn,aNoSeconds);
	}

EXPORT_C void CEikForm::AddAutoLatitudeEditorL(const TDesC& aPrompt,TInt aId,HBufC* aDegreeSign,HBufC* aMinuteSign,
											   HBufC* aSecondSign,HBufC* aTextForNorth,TChar aKeyToMatchForNorth,
											   HBufC* aTextForSouth,TChar aKeyToMatchForSouth,
											   SEikDegreesMinutesDirection* aReturn,TInt aFlags)
	{
	CEikLatitudeEditor* latitudeEd = (CEikLatitudeEditor*)CreateLineByTypeL(aPrompt,aId,EEikCtLatitudeEditor,aReturn);
	latitudeEd->ConstructL(aDegreeSign,aMinuteSign,aSecondSign,aTextForNorth,aKeyToMatchForNorth,aTextForSouth,aKeyToMatchForSouth,*aReturn,aFlags);
	}

EXPORT_C void CEikForm::AddAutoLongitudeEditorL(const TDesC& aPrompt,TInt aId,HBufC* aDegreeSign,HBufC* aMinuteSign,
												HBufC* aSecondSign,HBufC* aTextForEast,TChar aKeyToMatchForEast,
												HBufC* aTextForWest,TChar aKeyToMatchForWest,
												SEikDegreesMinutesDirection* aReturn,TInt aFlags)
	{
	CEikLongitudeEditor* longitudeEd = (CEikLongitudeEditor*)CreateLineByTypeL(aPrompt,aId,EEikCtLongitudeEditor,aReturn);
	longitudeEd->ConstructL(aDegreeSign,aMinuteSign,aSecondSign,aTextForEast,aKeyToMatchForEast,aTextForWest,aKeyToMatchForWest,*aReturn,aFlags);
	}

EXPORT_C void CEikForm::AddAutoFloatEditorL(const TDesC& aPrompt,TInt aId,const TReal& aMin,const TReal& aMax,TReal* aReturn)
	{
	CEikFloatingPointEditor* flPtEd=(CEikFloatingPointEditor*)CreateLineByTypeL(aPrompt,aId,EEikCtFlPtEd,aReturn);
	flPtEd->ConstructL(aMin,aMax,18);
	flPtEd->SetValueL(aReturn);
	}

EXPORT_C void CEikForm::AddAutoTwipsEditorL(const TDesC& aPrompt,TInt aId,TInt aMin,TInt aMax,TInt* aReturn)
	{
	CEikTwipsEditor* twipsEd = (CEikTwipsEditor*)CreateLineByTypeL(aPrompt,aId,EEikCtTwipsEd,aReturn);
	twipsEd->ConstructL(aMin,aMax);
	twipsEd->SetValueL(aReturn);
	}

EXPORT_C void CEikForm::AddAutoFixedPointEditorL(const TDesC& aPrompt,TInt aId,TInt aMin,TInt aMax,TInt* aRetValue,TInt aDecimalPlaces)
	{
	CEikFixedPointEditor* fixedEd = (CEikFixedPointEditor*)CreateLineByTypeL(aPrompt,aId,EEikCtFxPtEd,aRetValue);
	fixedEd->ConstructL(aMin,aMax);
	fixedEd->SetDecimalPlaces(aDecimalPlaces);
	fixedEd->SetValueL(aRetValue);
	}

EXPORT_C void CEikForm::AddAutoCheckBoxL(const TDesC& aPrompt,TInt aId,CEikButtonBase::TState* aReturn)
	{
	CEikCheckBox* chkBox = (CEikCheckBox*)CreateLineByTypeL(aPrompt,aId,EEikCtCheckBox,aReturn);
	chkBox->SetState(*aReturn);
	}

EXPORT_C void CEikForm::AddAutoSecretEditorL(const TDesC& aPrompt,TInt aId,TDes* aReturn)
	{
	CEikSecretEditor* secEd = (CEikSecretEditor*)CreateLineByTypeL(aPrompt,aId,EEikCtSecretEd,aReturn);
	secEd->SetMaxLength(aReturn->MaxLength());
	}

EXPORT_C void CEikForm::AddAutoTelephoneNumberEditorL(const TDesC& aPrompt,TInt aId,
													CEikTelephoneNumberEditor::TTelephoneEditorMode aMode, 
													TInt aFlags, TPtrC* aPromptArray, TInt aWidth,TDes* aReturn)
	{
	CEikTelephoneNumberEditor* telEd=STATIC_CAST(CEikTelephoneNumberEditor*,CreateLineByTypeL(aPrompt,aId,EEikCtTelephoneNumberEditor,aReturn));
	telEd->ConstructL(aMode,aFlags,aPromptArray,aWidth);
	telEd->SetNumberL(*aReturn);
	}

// Can't set inter button spacing in 2nd phase construction
/*EXPORT_C void CEikForm::AddAutoHorOptionButtonListL(const TDesC& aPrompt,TInt aId,TInt aInterButtonSpacing,TBool aTextOnRight,TInt* aReturn)
	{
	CEikHorOptionButtonList* buttonList = (CEikHorOptionButtonList*)CreateLineByTypeL(aPrompt,aId,EEikCtHorOptionButList,aReturn);
	buttonList->SetButtonById(*aReturn);
	}*/

/////////////////

EXPORT_C void CEikForm::SetLabelL(TInt aControlId, const TDesC& aDes)
	{
	CEikLabel* label=(CEikLabel*)Control(aControlId);
	label->SetTextL(aDes);
	label->DrawNow();
	}

EXPORT_C void CEikForm::SetLabelL(TInt aControlId, TInt aResourceId)
	{
	TBuf<128> tmp;
	iCoeEnv->ReadResource(tmp,aResourceId);
	SetLabelL(aControlId,tmp);
	}

EXPORT_C void CEikForm::SetLabelReserveLengthL(TInt aControlId, TInt aLength)
	{
	((CEikLabel*)Control(aControlId))->SetBufferReserveLengthL(aLength);
	}

EXPORT_C void CEikForm::GetLabelText(TDes& aDes, TInt aControlId) const
	{
	aDes.Copy(*(((CEikLabel*)Control(aControlId))->Text()));
	}

EXPORT_C void CEikForm::SetEdwinTextL(TInt aControlId, const TDesC* aDes)
	{
	CEikEdwin* edwin=(CEikEdwin*)Control(aControlId);
	edwin->SetTextL(aDes);
	edwin->DrawNow();
	}

EXPORT_C void CEikForm::GetEdwinText(TDes& aDes,TInt aControlId) const
	{
	((CEikEdwin*)Control(aControlId))->GetText(aDes);
	}

EXPORT_C void CEikForm::SetTextEditorTextL(TInt aControlId,const CGlobalText* aGlobalText)
	{
	CEikGlobalTextEditor* editor=(CEikGlobalTextEditor*)Control(aControlId);
	editor->SetDocumentContentL(*((CGlobalText*)aGlobalText));	//const cast due to edwin function
	editor->DrawNow();
	}

EXPORT_C void CEikForm::GetTextEditorText(CGlobalText*& aGlobalText,TInt aControlId)
	{
	aGlobalText=((CEikGlobalTextEditor*)Control(aControlId))->GlobalText();
	}

EXPORT_C void CEikForm::ResetSecretEditor(TInt aControlId)
	{
	((CEikSecretEditor*)Control(aControlId))->Reset();
	}

EXPORT_C void CEikForm::GetSecretEditorText(TDes& aDes,TInt aControlId) const
	{
	((CEikSecretEditor*)Control(aControlId))->GetText(aDes);
	}

EXPORT_C void CEikForm::SetCheckBoxState(TInt aControlId, CEikButtonBase::TState aState)
	{
	CEikCheckBox* checkBox=(CEikCheckBox*)Control(aControlId);
	checkBox->SetState(aState);
	checkBox->DrawNow();
	}

EXPORT_C CEikButtonBase::TState CEikForm::CheckBoxState(TInt aControlId) const
	{
	return ((CEikCheckBox*)Control(aControlId))->State();
	}

EXPORT_C void CEikForm::SetChoiceListCurrentItem(TInt aControlId, TInt aItem)
	{
	CEikChoiceList* choiceList=(CEikChoiceList*)Control(aControlId);
	choiceList->SetCurrentItem(aItem);
	choiceList->DrawNow();
	}

EXPORT_C TInt CEikForm::ChoiceListCurrentItem(TInt aControlId) const
	{
	return ((CEikChoiceList*)Control(aControlId))->CurrentItem();
	}

EXPORT_C void CEikForm::SetFloatingPointEditorValueL(TInt aControlId,const TReal* aValue)
	{
	CEikFloatingPointEditor* fltPtEd=(CEikFloatingPointEditor*)Control(aControlId);
	fltPtEd->SetValueL(aValue);
	fltPtEd->DrawNow();
	}

EXPORT_C TReal CEikForm::FloatingPointEditorValue(TInt aControlId) const
	{
	return ((CEikFloatingPointEditor*)Control(aControlId))->Value();
	}

EXPORT_C void CEikForm::SetFixedPointEditorValueL(TInt aControlId,TInt aValue)
	{
	CEikFixedPointEditor* fixPtEd=(CEikFixedPointEditor*)Control(aControlId);
	fixPtEd->SetValueL(&aValue);
	fixPtEd->DrawNow();
	}

EXPORT_C TInt CEikForm::FixedPointEditorValue(TInt aControlId) const
	{
	return ((CEikFixedPointEditor*)Control(aControlId))->Value();
	}

EXPORT_C void CEikForm::SetFixedPointEditorDecimal(TInt aControlId,TInt aDecimal)
	{
	((CEikFixedPointEditor*)Control(aControlId))->SetDecimalPlaces(aDecimal);
	}

EXPORT_C TInt CEikForm::FixedPointEditorDecimal(TInt aControlId) const
	{
	return STATIC_CAST(CEikFixedPointEditor*,Control(aControlId))->DecimalPlaces();
	}

EXPORT_C void CEikForm::SetTwipsEditorValueL(TInt aControlId, TInt* aValue)
	{
	CEikTwipsEditor* twipsEd=(CEikTwipsEditor*)Control(aControlId);
	twipsEd->SetValueL(aValue);
	twipsEd->DrawNow();
	}

EXPORT_C TInt CEikForm::TwipsEditorValue(TInt aControlId) const
	{
	CEikTwipsEditor* twipsEd=((CEikTwipsEditor*)Control(aControlId));
	return twipsEd->Value();
	}

EXPORT_C void CEikForm::SetNumberEditorMinAndMax(TInt aControlId, TInt aMinimumValue, TInt aMaximumValue)
	{
	CEikNumberEditor* numberEditor=(CEikNumberEditor*)Control(aControlId);
	numberEditor->SetMinimumAndMaximum(aMinimumValue, aMaximumValue);
	numberEditor->DrawNow();
	}

EXPORT_C void CEikForm::SetNumberEditorValue(TInt aControlId, TInt aNumber)
	{
	CEikNumberEditor* numberEditor=(CEikNumberEditor*)Control(aControlId);
	numberEditor->SetNumber(aNumber);
	numberEditor->DrawNow();
	}

EXPORT_C TInt CEikForm::NumberEditorValue(TInt aControlId) const
	{
	return ((CEikNumberEditor*)Control(aControlId))->Number();
	}

EXPORT_C void CEikForm::SetFloatEditorMinAndMax(TInt aControlId,TInt aMin,TInt aMax)
	{
	CEikFloatingPointEditor* floatEditor=(CEikFloatingPointEditor*)Control(aControlId);
	floatEditor->SetMinMax(aMin,aMax);
	floatEditor->DrawNow();
	}

EXPORT_C void CEikForm::SetFloatEditorValueL(TInt aControlId,TReal aFloat)
	{
	CEikFloatingPointEditor* floatEditor=(CEikFloatingPointEditor*)Control(aControlId);
	floatEditor->SetValueL(&aFloat);
	floatEditor->DrawNow();
	}

EXPORT_C TReal CEikForm::FloatEditorValue(TInt aControlId) const
	{
	return ((CEikFloatingPointEditor*)Control(aControlId))->Value();
	}

EXPORT_C void CEikForm::SetRangeEditorMinAndMax(TInt aControlId, TInt aMinimumValue, TInt aMaximumValue)
	{
	CEikRangeEditor* rangeEditor=(CEikRangeEditor*)Control(aControlId);
	rangeEditor->SetMinimumAndMaximum(aMinimumValue, aMaximumValue);
	rangeEditor->DrawNow();
	}

EXPORT_C void CEikForm::SetRangeEditorValue(TInt aControlId, const SEikRange& aRange)
	{
	CEikRangeEditor* rangeEditor=(CEikRangeEditor*)Control(aControlId);
	rangeEditor->SetRange(aRange);
	rangeEditor->DrawNow();
	}

EXPORT_C SEikRange CEikForm::RangeEditorValue(TInt aControlId) const
	{
	return ((CEikRangeEditor*)Control(aControlId))->Range();
	}

EXPORT_C void CEikForm::SetTTimeEditorMinAndMax(TInt aControlId, const TTime& aMinimumTime, const TTime& aMaximumTime)
	{
	CEikTTimeEditor* tTimeEditor=(CEikTTimeEditor*)Control(aControlId);
	tTimeEditor->SetMinimumAndMaximum(aMinimumTime, aMaximumTime);
	tTimeEditor->DrawNow();
	}

EXPORT_C void CEikForm::SetTTimeEditorValue(TInt aControlId, const TTime& aTime)
	{
	CEikTTimeEditor* tTimeEditor=(CEikTTimeEditor*)Control(aControlId);
	tTimeEditor->SetTTime(aTime);
	tTimeEditor->DrawNow();
	}

EXPORT_C TTime CEikForm::TTimeEditorValue(TInt aControlId) const
	{
	return ((CEikTTimeEditor*)Control(aControlId))->GetTTime();
	}

EXPORT_C void CEikForm::SetDurationEditorMinAndMax(TInt aControlId, const TTimeIntervalSeconds& aMinimumDuration, const TTimeIntervalSeconds& aMaximumDuration)
	{
	CEikDurationEditor* durationEditor=(CEikDurationEditor*)Control(aControlId);
	durationEditor->SetMinimumAndMaximum(aMinimumDuration, aMaximumDuration);
	durationEditor->DrawNow();
	}

EXPORT_C void CEikForm::SetDurationEditorValue(TInt aControlId, const TTimeIntervalSeconds& aDuration)
	{
	CEikDurationEditor* durationEditor=(CEikDurationEditor*)Control(aControlId);
	durationEditor->SetDuration(aDuration);
	durationEditor->DrawNow();
	}

EXPORT_C TTimeIntervalSeconds CEikForm::DurationEditorValue(TInt aControlId) const
	{
	return ((CEikDurationEditor*)Control(aControlId))->Duration();
	}

EXPORT_C void CEikForm::SetTimeOffsetEditorMinAndMax(TInt aControlId, const TTimeIntervalSeconds& aMinimumTimeOffset, const TTimeIntervalSeconds& aMaximumTimeOffset)
	{
	CEikTimeOffsetEditor* timeOffsetEditor=(CEikTimeOffsetEditor*)Control(aControlId);
	timeOffsetEditor->SetMinimumAndMaximum(aMinimumTimeOffset, aMaximumTimeOffset);
	timeOffsetEditor->DrawNow();
	}

EXPORT_C void CEikForm::SetTimeOffsetEditorValue(TInt aControlId, const TTimeIntervalSeconds& aTimeOffset)
	{
	CEikTimeOffsetEditor* timeOffsetEditor=(CEikTimeOffsetEditor*)Control(aControlId);
	timeOffsetEditor->SetTimeOffset(aTimeOffset);
	timeOffsetEditor->DrawNow();
	}

EXPORT_C TTimeIntervalSeconds CEikForm::TimeOffsetEditorValue(TInt aControlId) const
	{
	return ((CEikTimeOffsetEditor*)Control(aControlId))->TimeOffset();
	}

EXPORT_C void CEikForm::SetLatitudeEditorValue(TInt aControlId, const SEikDegreesMinutesDirection& aLatitude)
	{
	CEikLatitudeEditor* latitudeEditor=(CEikLatitudeEditor*)Control(aControlId);
	latitudeEditor->SetLatitude(aLatitude);
	latitudeEditor->DrawNow();
	}

EXPORT_C SEikDegreesMinutesDirection CEikForm::LatitudeEditorValue(TInt aControlId) const
	{
	return ((CEikLatitudeEditor*)Control(aControlId))->Latitude();
	}

EXPORT_C void CEikForm::SetLongitudeEditorValue(TInt aControlId, const SEikDegreesMinutesDirection& aLongitude)
	{
	CEikLongitudeEditor* longitudeEditor=(CEikLongitudeEditor*)Control(aControlId);
	longitudeEditor->SetLongitude(aLongitude);
	longitudeEditor->DrawNow();
	}

EXPORT_C SEikDegreesMinutesDirection CEikForm::LongitudeEditorValue(TInt aControlId) const
	{
	return ((CEikLongitudeEditor*)Control(aControlId))->Longitude();
	}

EXPORT_C void CEikForm::SetOptionButtonState(TInt aControlId, CEikButtonBase::TState aState)
	{
	CEikOptionButton* opBut=STATIC_CAST(CEikOptionButton*,Control(aControlId));
	opBut->SetState(aState);
	opBut->DrawNow();
	}

EXPORT_C CEikButtonBase::TState CEikForm::OptionButtonState(TInt aControlId) const
	{
	return ((CEikOptionButton*)Control(aControlId))->State();
	}

EXPORT_C void CEikForm::SetHorOptionButListCurrentSet(TInt aControlId,TInt aSetButId)
	{
	CEikHorOptionButtonList* opButList=STATIC_CAST(CEikHorOptionButtonList*,Control(aControlId));
	opButList->SetButtonById(aSetButId);
	opButList->DrawNow();
	}

EXPORT_C TInt CEikForm::HorOptionButListCurrentSet(TInt aControlId) const
	{
	return ((CEikHorOptionButtonList*)Control(aControlId))->LabeledButtonId();
	}

EXPORT_C void CEikForm::SetTelephoneEditorMode(TInt aControlId,CEikTelephoneNumberEditor::TTelephoneEditorMode aMode)
	{
	CEikTelephoneNumberEditor* telEd=STATIC_CAST(CEikTelephoneNumberEditor*,Control(aControlId));
	telEd->SetModeL(aMode);
	telEd->DrawNow();
	}

EXPORT_C void CEikForm::SetTelephoneEditorNumberL(TInt aControlId,const TDesC& aNumber)
	{
	CEikTelephoneNumberEditor* telEd=STATIC_CAST(CEikTelephoneNumberEditor*,Control(aControlId));
	telEd->SetNumberL(aNumber);
	telEd->DrawNow();
	}

EXPORT_C void CEikForm::SetTelephoneEditorNumberL(TInt aControlId,const TDesC& aCountry,const TDesC& aArea,const TDesC& aNumber)
	{
	CEikTelephoneNumberEditor* telEd=STATIC_CAST(CEikTelephoneNumberEditor*,Control(aControlId));
	telEd->SetNumberL(aCountry,aArea,aNumber);
	telEd->DrawNow();
	}

EXPORT_C void CEikForm::GetTelephoneEditorNumber(TInt aControlId,TDes& aNumber) const
	{
	STATIC_CAST(CEikTelephoneNumberEditor*,Control(aControlId))->GetNumber(aNumber);
	}

EXPORT_C void CEikForm::GetAutoValuesFromPage(CEikCapCArray* aLines)
	{
	const TInt count=aLines->Count();
	for (TInt ii=0; ii<count; ii++)
		{
       	CEikCaptionedControl* line=(*aLines)[ii];
		TAny* returnValue=line->iReturnValue;
		if (!returnValue)
			continue;
		CCoeControl* control=line->iControl;
		switch (line->iControlType)
			{
		case EEikCtEdwin:
			((CEikEdwin*)control)->GetText(*(TDes*)returnValue);
			break;
		case EEikCtSecretEd:
			((CEikSecretEditor*)control)->GetText(*(TDes*)returnValue);
			break;
		case EEikCtChoiceList:
			(*(TInt*)returnValue)=((CEikChoiceList*)control)->CurrentItem();
			break;
		case EEikCtFlPtEd:
			(*(TReal*)returnValue)=((CEikFloatingPointEditor*)control)->Value();
			break;
		case EEikCtFxPtEd:
			(*(TInt*)returnValue)=((CEikFixedPointEditor*)control)->Value();
			break;
		case EEikCtTwipsEd:
			(*(TInt*)returnValue)=((CEikTwipsEditor*)control)->Value();
			break;
		case EEikCtCheckBox:
			(*(CEikButtonBase::TState*)returnValue)=((CEikCheckBox*)control)->State();
			break;
		case EEikCtOptionButton:
			(*(CEikButtonBase::TState*)returnValue)=((CEikOptionButton*)control)->State();
			break;
		case EEikCtNumberEditor:
			(*(TInt*)returnValue)=((CEikNumberEditor*)control)->Number();
			break;
		case EEikCtRangeEditor:
			(*(SEikRange*)returnValue)=((CEikRangeEditor*)control)->Range();
			break;
		case EEikCtTimeEditor:
			(*(TTime*)returnValue)=((CEikTimeEditor*)control)->Time();
			break;
		case EEikCtDateEditor:
			(*(TTime*)returnValue)=((CEikDateEditor*)control)->Date();
			break;
		case EEikCtTimeAndDateEditor:
			(*(TTime*)returnValue)=((CEikTimeAndDateEditor*)control)->TimeAndDate();
			break;
		case EEikCtDurationEditor:
			(*(TTimeIntervalSeconds*)returnValue)=((CEikDurationEditor*)control)->Duration();
			break;
		case EEikCtTimeOffsetEditor:
			(*(TTimeIntervalSeconds*)returnValue)=((CEikTimeOffsetEditor*)control)->TimeOffset();
			break;
		case EEikCtLatitudeEditor:
			(*(SEikDegreesMinutesDirection*)returnValue)=((CEikLatitudeEditor*)control)->Latitude();
			break;
		case EEikCtLongitudeEditor:
			(*(SEikDegreesMinutesDirection*)returnValue)=((CEikLongitudeEditor*)control)->Longitude();
			break;
		case EEikCtHorOptionButList:
			(*(TInt*)returnValue)=((CEikHorOptionButtonList*)control)->LabeledButtonId();
			break;
		default:
			GetCustomAutoValue(returnValue,line->iControlType,control);
			break;
			}
		}
	}