// Copyright (c) 2005-2009 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:

//

/**

 @file	

 @publishedAll

 @released

*/

#ifndef  ECAMADVSETTINGS_H

#define  ECAMADVSETTINGS_H

#include <e32base.h>

#include <ecam.h>

#include <ecamadvsettingsuids.hrh>

#include <gdi.h>

#include <s32strm.h>

#include <ecam/ecamconstants.h>

#include <ecamimageprocessing.h>

#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <ecamadvsettingsconst.h>

#include <ecamadvsettingsdef.h>

#endif

class MCameraPresets;

class MCameraAdvancedSettings;

class MCameraAdvancedSettings2;

class MCameraAdvancedSettings3;

class MCameraAdvancedSettings4;

class MCameraPresets2;

class MCameraContinuousZoom;

/* General purpose constants */

/**

	UID used to identify the CCamera Advanced Settings API.

	This API is used to control specific individual advanced settings of camera hardware.

	These settings directly relate to the image acquisition phase.

	@see CCamera::CCameraAdvancedSettings

*/

static const TUid KECamAdvancedSettingUid 	= {KECamAdvancedSettingUidValue};

/**

	UID used to identify the CCamera Presets API.

	This API is used to simplify user - camera interaction by allowing simultaneous 

	setting of various advanced camera hardware settings using a single predefined parameter. 

	@see CCamera::CCameraPresets

*/

static const TUid  KECamPresetsUid 			= {KECamPresetsUidValue};

/** All clients receive these events, irrespective of camera index.  */

/** Camera slots in for 8 cameras. */

/** Camera with index 0 Plugged-in */

static const TUid  KUidECamEventGlobalCamera00PluggedIn = {KUidECamEventGlobalCamera00PluggedInUidValue};

/** Camera with index 1 Plugged-in */

static const TUid  KUidECamEventGlobalCamera01PluggedIn = {KUidECamEventGlobalCamera01PluggedInUidValue};

/** Camera with index 2 Plugged-in */

static const TUid  KUidECamEventGlobalCamera02PluggedIn = {KUidECamEventGlobalCamera02PluggedInUidValue};

/** Camera with index 3 Plugged-in */

static const TUid  KUidECamEventGlobalCamera03PluggedIn = {KUidECamEventGlobalCamera03PluggedInUidValue};

/** Camera with index 4 Plugged-in */

static const TUid  KUidECamEventGlobalCamera04PluggedIn = {KUidECamEventGlobalCamera04PluggedInUidValue};

/** Camera with index 5 Plugged-in */

static const TUid  KUidECamEventGlobalCamera05PluggedIn = {KUidECamEventGlobalCamera05PluggedInUidValue};

/** Camera with index 6 Plugged-in */

static const TUid  KUidECamEventGlobalCamera06PluggedIn = {KUidECamEventGlobalCamera06PluggedInUidValue};

/** Camera with index 7 Plugged-in */

static const TUid  KUidECamEventGlobalCamera07PluggedIn = {KUidECamEventGlobalCamera07PluggedInUidValue};

/** Camera slots plugged out for 8 cameras. */

/** Camera with index 0 Plugged-out */

static const TUid  KUidECamEventGlobalCamera00PluggedOut = {KUidECamEventGlobalCamera00PluggedOutUidValue};

/** Camera with index 1 Plugged-out */

static const TUid  KUidECamEventGlobalCamera01PluggedOut = {KUidECamEventGlobalCamera01PluggedOutUidValue};

/** Camera with index 2 Plugged-out */

static const TUid  KUidECamEventGlobalCamera02PluggedOut = {KUidECamEventGlobalCamera02PluggedOutUidValue};

/** Camera with index 3 Plugged-out */

static const TUid  KUidECamEventGlobalCamera03PluggedOut = {KUidECamEventGlobalCamera03PluggedOutUidValue};

/** Camera with index 4 Plugged-out */

static const TUid  KUidECamEventGlobalCamera04PluggedOut = {KUidECamEventGlobalCamera04PluggedOutUidValue};

/** Camera with index 5 Plugged-out */

static const TUid  KUidECamEventGlobalCamera05PluggedOut = {KUidECamEventGlobalCamera05PluggedOutUidValue};

/** Camera with index 6 Plugged-out */

static const TUid  KUidECamEventGlobalCamera06PluggedOut = {KUidECamEventGlobalCamera06PluggedOutUidValue};

/** Camera with index 7 Plugged-out */

static const TUid  KUidECamEventGlobalCamera07PluggedOut = {KUidECamEventGlobalCamera07PluggedOutUidValue};

/** Camera slots available for 8 cameras. */

/** Signals a camera previously has been reserved and then released again. 

    In this way available clients may attempt to reserve the camera */

/** Camera with index 0 Available. */

static const TUid  KUidECamEventGlobalCamera00Available  = {KUidECamEventGlobalCamera00AvailableUidValue};

/** Camera with index 1 Available. */

static const TUid  KUidECamEventGlobalCamera01Available  = {KUidECamEventGlobalCamera01AvailableUidValue};

/** Camera with index 2 Available. */

static const TUid  KUidECamEventGlobalCamera02Available  = {KUidECamEventGlobalCamera02AvailableUidValue};

/** Camera with index 3 Available. */

static const TUid  KUidECamEventGlobalCamera03Available  = {KUidECamEventGlobalCamera03AvailableUidValue};

/** Camera with index 4 Available. */

static const TUid  KUidECamEventGlobalCamera04Available  = {KUidECamEventGlobalCamera04AvailableUidValue};

/** Camera with index 5 Available. */

static const TUid  KUidECamEventGlobalCamera05Available  = {KUidECamEventGlobalCamera05AvailableUidValue};

/** Camera with index 6 Available. */

static const TUid  KUidECamEventGlobalCamera06Available  = {KUidECamEventGlobalCamera06AvailableUidValue};

/** Camera with index 7 Available. */

static const TUid  KUidECamEventGlobalCamera07Available  = {KUidECamEventGlobalCamera07AvailableUidValue};

/** Individual camera events. These are used by the camera to signal its observers. */

/** Lens changed. */

static const TUid  KUidECamEventLensChanged 			= {KUidECamEventLensChangedUidValue};

/** Flash source added. */

static const TUid  KUidECamEventFlashSourceAdded 		= {KUidECamEventFlashSourceAddedUidValue};

/** Flash source removed. */

static const TUid  KUidECamEventFlashSourceRemoved		= {KUidECamEventFlashSourceRemovedUidValue};

/** Image resolution changed. */

static const TUid  KUidECamEventCameraSettingImageSize 	= {KUidECamEventCameraSettingImageSizeUidValue};

/** Image Format changed. */

static const TUid  KUidECamEventCameraSettingImageFormat 		= {KUidECamEventCameraSettingImageFormatUidValue};

/** Camera orientation changed. */

static const TUid  KUidECamEventCameraSettingCameraOrientation  = {KUidECamEventCameraSettingCameraOrientationUidValue};

/** Optimal focus */

static const TUid KUidECamEventCameraSettingsOptimalFocus 		= {KUidECamEventCameraSettingsOptimalFocusUidValue};

/** Advanced settings. */

/** Stabilization mode.  */

static const TUid  KUidECamEventCameraSettingStabilizationMode 	= {KUidECamEventCameraSettingStabilizationModeUidValue};

/** Focus mode. */

static const TUid  KUidECamEventCameraSettingFocusMode 			= {KUidECamEventCameraSettingFocusModeUidValue};

/** Focus range. 

@deprecated

Replaced by KUidECamEventCameraSettingFocusRange2

In the first release of this event, KUidECamEventCameraSettingFocusRange was incorrectly given an already existing uid. 

In order to preserve compatibility this event is marked as deprecated and has been replaced by KUidECamEventCameraSettingFocusRange2.

Camera servers predating this API change will continue to send the original event which is indistinguishable by value. 

Caching the old value and comparing it with the current value, will allow the client to determine that the value has changed.

Camera servers which have been updated should send both KUidECamEventCameraSettingFocusRange and KUidECamEventCameraSettingFocusRange2 on a focus range change. 

Camera clients should therefore process both events(old and new). 

@see KUidECamEventCameraSettingFocusRange2

*/

static const TUid  KUidECamEventCameraSettingFocusRange 		= {KUidECamEventCameraSettingFocusRangeUidValue};

/** Autofocus type.

@deprecated

Replaced by KUidECamEventCameraSettingAutoFocusType2

In the first release of this event, KUidECamEventCameraSettingAutoFocusType was incorrectly given an already existing uid. 

In order to preserve compatibility this event is marked as deprecated and has been replaced by KUidECamEventCameraSettingAutoFocusType2.

Camera servers predating this API change will continue to send the original event which is indistinguishable by value. 

Caching the old value and comparing it with the current value, will allow the client to determine that the value has changed.

Camera servers which have been updated should send both KUidECamEventCameraSettingAutoFocusType and KUidECamEventCameraSettingAutoFocusType2 on a focus range change. 

Camera clients should therefore process both events(old and new). 

@see KUidECamEventCameraSettingAutoFocusType2*/

static const TUid  KUidECamEventCameraSettingAutoFocusType 		= {KUidECamEventCameraSettingAutoFocusTypeUidValue};

/** Autofocus area. */

static const TUid  KUidECamEventCameraSettingAutoFocusArea 		= {KUidECamEventCameraSettingAutoFocusAreaUidValue};

/** Autofocus lock state.  */

static const TUid  KUidECamEventCameraSettingAutoFocusLock		= {KUidECamEventCameraSettingAutoFocusLockUidValue};

/** Focus distance */

static const TUid  KUidECamEventCameraSettingFocusDistance 		= {KUidECamEventCameraSettingFocusDistanceUidValue};

/** Sensitivity - ISO rate. */

static const TUid  KUidECamEventCameraSettingIsoRate 			= {KUidECamEventCameraSettingIsoRateUidValue};

/** Aperture. */

static const TUid  KUidECamEventCameraSettingAperture 			= {KUidECamEventCameraSettingApertureUidValue};

/** Aperture range. */

static const TUid  KUidECamEventCameraSettingApertureRange 		= {KUidECamEventCameraSettingApertureRangeUidValue};

/** Shutter speed. */

static const TUid  KUidECamEventCameraSettingShutterSpeed 		= {KUidECamEventCameraSettingShutterSpeedUidValue};

/** Shutter speed range.  */

static const TUid  KUidECamEventCameraSettingShutterSpeedRange 	= {KUidECamEventCameraSettingShutterSpeedRangeUidValue};

/**  Metering mode. */

static const TUid  KUidECamEventCameraSettingMeteringMode 		= {KUidECamEventCameraSettingMeteringModeUidValue};

/** Drive mode. */

static const TUid  KUidECamEventCameraSettingDriveMode 			= {KUidECamEventCameraSettingDriveModeUidValue};

/** Braket mode. */

static const TUid  KUidECamEventCameraSettingBracketMode 		= {KUidECamEventCameraSettingBracketModeUidValue};

/** Bracket step. */

static const TUid  KUidECamEventCameraSettingBracketStep 		= {KUidECamEventCameraSettingBracketStepUidValue};

/** Bracket parameter. */

static const TUid  KUidECamEventCameraSettingBracketParameter 	= {KUidECamEventCameraSettingBracketParameterUidValue};

/** Bracket merge. */

static const TUid  KUidECamEventBracketMerge					= {KUidECamEventBracketMergeUidValue};

/** Picture orientation.  */

static const TUid  KUidECamEventCameraSettingPictureOrientation = {KUidECamEventCameraSettingPictureOrientationUidValue};

/** Automatic size selection option */

static const TUid  KUidECamEventCameraSettingAutomaticSizeSelection = {KUidECamEventCameraSettingAutomaticSizeSelectionUidValue};

/** Flash setting. */

static const TUid  KUidECamEventCameraSettingFlashMode 			= {KUidECamEventCameraSettingFlashModeUidValue};

/** Flash compensation step. */

static const TUid  KUidECamEventCameraSettingFlashCompensationStep 		= {KUidECamEventCameraSettingFlashCompensationStepUidValue};

/** Flash compensation. */

static const TUid  KUidECamEventCameraSettingFlashCompensation 	= {KUidECamEventCameraSettingFlashCompensationUidValue};

/** Manual flash power. */

static const TUid  KUidECamEventCameraSettingFlashManualPower 	= {KUidECamEventCameraSettingFlashManualPowerUidValue};

/** Red eye reduce mode. */

static const TUid  KUidECamEventCameraSettingFlashRedEyeReduce 	= {KUidECamEventCameraSettingFlashRedEyeReduceUidValue};

/** Exposure mode setting. */

static const TUid  KUidECamEventCameraSettingExposureMode 		= {KUidECamEventCameraSettingExposureModeUidValue};

/** Exposure compensation step. */

static const TUid  KUidECamEventCameraSettingExposureCompensationStep 	= {KUidECamEventCameraSettingExposureCompensationStepUidValue};

/** Exposure compensation. */

static const TUid  KUidECamEventCameraSettingExposureCompensation 		= {KUidECamEventCameraSettingExposureCompensationUidValue};

/** Exposure lock state. */

static const TUid  KUidECamEventCameraSettingExposureLock 		= {KUidECamEventCameraSettingExposureLockUidValue};

/** AE lock option. */

static const TUid  KUidECamEventAELock 							= {KUidECamEventAELockUidValue};

/** White balance.  */

static const TUid  KUidECamEventCameraSettingWhiteBalanceMode 	= {KUidECamEventCameraSettingWhiteBalanceModeUidValue};

/** Timer changed. */

static const TUid  KUidECamEventCameraSettingTimerInterval 		= {KUidECamEventCameraSettingTimerIntervalUidValue};

/** Timer lapse period.  */

static const TUid  KUidECamEventCameraSettingTimeLapse			= {KUidECamEventCameraSettingTimeLapseUidValue};

/** Optical zoom. */

static const TUid  KUidECamEventCameraSettingOpticalZoom 		= {KUidECamEventCameraSettingOpticalZoomUidValue};

/** Optical zoom range.  */

static const TUid  KUidECamEventCameraSettingOpticalZoomRange 	= {KUidECamEventCameraSettingOpticalZoomRangeUidValue};

/** Digital zoom. */

static const TUid  KUidECamEventCameraSettingDigitalZoom 		= {KUidECamEventCameraSettingDigitalZoomUidValue};

/** Digital zoom range.  */

static const TUid  KUidECamEventCameraSettingDigitalZoomRange 	= {KUidECamEventCameraSettingDigitalZoomRangeUidValue};

/** Clicking sound state.  */

static const TUid  KUidECamEventSoundClick 						= {KUidECamEventSoundClickUidValue};

/** Pixel aspect ratio. */

static const TUid  KUidECamEventPixelAspectRatio 				= {KUidECamEventPixelAspectRatioUidValue};

/** Yuv range. */

static const TUid  KUidECamEventYuvRange 						= {KUidECamEventYuvRangeUidValue};

/** Burst images. */

static const TUid  KUidECamEventBurstImages						= {KUidECamEventBurstImagesUidValue};

/** Stabilization effect - magnitude of stabilization */

static const TUid KUidECamEventCameraSettingsStabilizationEffect 		= {KUidECamEventCameraSettingsStabilizationEffectUidValue};

/** Stabilization algorithm */

static const TUid KUidECamEventSettingsStabilizationAlgorithmComplexity = {KUidECamEventSettingsStabilizationAlgorithmComplexityUidValue};

/** Continuous Autofocus timeout */

static const TUid KUidECamEventCameraSettingsContinuousAutoFocusTimeout = {KUidECamEventCameraSettingsContinuousAutoFocusTimeoutUidValue};

/** White Balance manual setting */

static const TUid KUidECamEventCameraSettingsWBValue 					= {KUidECamEventCameraSettingsWBValueUidValue};	

/** Flash ready */

static const TUid KUidECamEventFlashReady 						= {KUidECamEventFlashReadyUidValue};	

/** Flash not ready */

static const TUid KUidECamEventFlashNotReady 					= {KUidECamEventFlashNotReadyUidValue};

/** Focus range. 

This is the new UID value to notify change on focus range and takes immediate effect as previous UID KUidECamEventCameraSettingFocusRange has been deprecated.

@see KUidECamEventCameraSettingFocusRange */

static const TUid  KUidECamEventCameraSettingFocusRange2 		= {KUidECamEventCameraSettingFocusRange2UidValue};

/** Autofocus type.

This is the new UID value to notify change on autofocus type and takes immediate effect as previous UID KUidECamEventCameraSettingAutoFocusType has been deprecated.

@see KUidECamEventCameraSettingAutoFocusType */

static const TUid  KUidECamEventCameraSettingAutoFocusType2 		= {KUidECamEventCameraSettingAutoFocusType2UidValue};

/** 

ISO Rate type. 

This TUid is available from the following methods only to the API clients using CCamera::New2L() or CCamera::NewDuplicate2L():

void CCamera::CCameraAdvancedSettings::GetSupportedSettingsL(RArray<TUid>& aSettings) const;

void CCamera::CCameraAdvancedSettings::GetActiveSettingsL(RArray<TUid>& aActiveSettings) const;

void CCamera::CCameraAdvancedSettings::GetDisabledSettingsL(RArray<TUid>& aDisabledSettings) const;

*/

static const TUid  KUidECamEventCameraSettingIsoRateType 		= {KUidECamEventCameraSettingIsoRateTypeUidValue};

/** 

Reference Screen setting. 

This TUid is available from the following methods only to the API clients using CCamera::New2L() or CCamera::NewDuplicate2L():

void CCamera::CCameraAdvancedSettings::GetSupportedSettingsL(RArray<TUid>& aSettings) const;

void CCamera::CCameraAdvancedSettings::GetActiveSettingsL(RArray<TUid>& aActiveSettings) const;

void CCamera::CCameraAdvancedSettings::GetDisabledSettingsL(RArray<TUid>& aDisabledSettings) const;

*/

static const TUid  KUidECamEventCameraSettingReferenceScreen    = {KUidECamEventCameraSettingReferenceScreenUidValue};

/** 

Pre Capture Warning indication.

This TUid is available from the following methods only to the API clients using CCamera::New2L() or CCamera::NewDuplicate2L():

void CCamera::CCameraAdvancedSettings::GetSupportedSettingsL(RArray<TUid>& aSettings) const;

void CCamera::CCameraAdvancedSettings::GetActiveSettingsL(RArray<TUid>& aActiveSettings) const;

void CCamera::CCameraAdvancedSettings::GetDisabledSettingsL(RArray<TUid>& aDisabledSettings) const;

*/

static const TUid  KUidECamEventCameraSettingAFAssistantLight	= {KUidECamEventCameraSettingAFAssistantLightUidValue};

class CCameraContinuousZoom;

/**	

A mixin class to be implemented by the client in order to use the Continuous Zoom API. The callbacks are invoked by the implementation

whenever the continuous zoom operations are ready to be notified.

@see CCameraContinuousZoom

@internalTechnology

@prototype

*/	

class MContinuousZoomObserver

	{	

public:

	/**

	This callback is sent when a new zoom factor is achieved. Client may not receive a callback for every new zoom factor as it is up

	to the implementation to choose the zoom factors for which it will issue this callback. Should an error occur, this implies that the

	continuous zoom operation has been stopped.

	@param  aContinuousZoomHandle

			Reference to CCameraContinuousZoom class object which was used to start the continuous zoom operation.

	@param  aZoomFactor

		    The new zoom factor value, multiplied by KECamFineResolutionFactor, which has been achieved.

	@param  aError

			Appropriate error code.

	*/

	virtual void ContinuousZoomProgress(CCamera::CCameraContinuousZoom& aContinuousZoomHandle, TInt aZoomFactor, TInt aError)=0;

	/**

	Implementation sends this callback when the Continuous Zoom operation has been completed. This callback will be sent when

	target zoom factor is achieved. This zoom factor may in some cases be less than the target zoom factor due to the complexity

	of the continuous zoom operation. Once this callback is received, client need not issue StopContinuousZoom() and can call

	StartContinuousZoom() again.

	@param  aContinuousZoomHandle

			Reference to CCameraContinuousZoom class object which was used to start the continuous zoom operation.

	@param  aFinalZoomFactor

			The final zoom factor value once the continuous zoom operation has completed. This zoom factor may in some cases be

			less than the target zoom factor due to the complexity of the continuous zoom operation.

	@param  aErrorCode

			Appropriate error code.

	*/

	virtual void ContinuousZoomCompleted(CCamera::CCameraContinuousZoom& aContinuousZoomHandle, TInt aFinalZoomFactor, TInt aError)=0;

	/**

	Gets a custom interface for future callbacks. This method will be called by the implementation to get a new interface

	which would support future callbacks.

	@param  aInterface

		    The Uid of the particular interface function required for callbacks.

	@param  aPtrInterface

		    The implementation has to type-cast the retrieved custom interface pointer to the appropriate type.	

	@return The error code.

	*/

	virtual TInt CustomInterface(TUid aInterface, TAny*& aPtrInterface)=0;

	};

/** 

CCamera advanced settings class exposes an API for controlling individually 

digital camera advanced settings. These settings directly relate to the 

image acquisition phase both for still images and video.

@note This class is not intended for sub-classing  and used to standardise existing

       varieties of implementations.

@note   If the class methods leave, the output type parameter value is not guaranteed to be valid.

@publishedAll

@released

*/

class CCamera::CCameraAdvancedSettings : public CBase

	{

	/* so can use internal factory functions etc. */

	friend class CCamera;

public:

	/** Specifies camera type. */ 

	enum TCameraType

		{

		/** Unable to identify. */  

		ECameraUnknown 		= 0x00, 

		/** Camera is non-detachable from device. Camera is always present. */

		ECameraOnBoard	 	= 0x01,

		/** Camera is detachable from device. Camera is not always present. */

		ECameraPluggable 	= 0x02

		};

	/** Specifies stabilization mode of the camera. */

	enum TStabilizationMode

		{

		/** Not present or switched off, default */

		EStabilizationModeOff			= 0x00,

		/** Stabilization only in horizontal direction. */

		EStabilizationModeHorizontal	= 0x01,

		/** Stabilization only in vertical direction. */

		EStabilizationModeVertical		= 0x02,

		/** Rotational stabilization. */

		EStabilizationModeRotation		= 0x04,

		/** Automatic stabilization. */

		EStabilizationModeAuto			= 0x08,

		/** Manual stabilization. */

		EStabilizationModeManual		= 0x10   

		};

	/** Supported magnitudes of stabilization effect when in manual mode. */	

	enum TStabilizationEffect

		{

		/** Stabilization effect is off. */ 

		EStabilizationOff		= 0x00, 

		/** Stabilization effect is automatic, default. */

		EStabilizationAuto		= 0x01,

		/** Stabilization effect is very small in magnitude. */

		EStabilizationFine 		= 0x02,

		/** Stabilization effect is average in magnitude. */

		EStabilizationMedium	= 0x04,

		/** Stabilization effect is large in magnitude. */

		EStabilizationStrong	= 0x08

		};

	/** Supported stabilization algorithms, graded on complexity. */	

	enum TStabilizationAlgorithmComplexity

		{

		/** Stabilization algorithm selection is automatic, default. */ 

		EStabilizationComplexityAuto	= 0x00, 

		/** Stabilization algorithm is simple - less precise but fast. */

		EStabilizationComplexityLow		= 0x01,

		/** Stabilization algorithm is of medium complexity. */

		EStabilizationComplexityMedium	= 0x02,

		/** Stabilization algorithm is of high complexity. */

		EStabilizationComplexityHigh	= 0x04

		};

	/** Supported focus modes. */	

	enum TFocusMode

		{

		/** Focus mode is unknown. */ 

		EFocusModeUnknown	= 0x00, 

		/** Focus is automatic, default. */

		EFocusModeAuto		= 0x01,

		/** Focus is fixed. */

		EFocusModeFixed 	= 0x02,

		/** Focus is manually set. */

		EFocusModeManual	= 0x04

		};

	/** Supported focus ranges. */	

	enum TFocusRange

		{

		/** Auto. Default */

		EFocusRangeAuto 		= 0x00,

		/** Focus operates in close range (macro). */

		EFocusRangeMacro		= 0x01,

		/** Normal operation. */

		EFocusRangeNormal		= 0x02,

		/** Extended (tele) operation. */

		EFocusRangeTele			= 0x04,

		/** Focus at larger areas at short to medium distance. */

		EFocusRangePortrait		= 0x08,

		/** Optimised macro operation, 

		where depth of field is very shallow and observation area changes quickly. */

		EFocusRangeSuperMacro	= 0x10,

		/** 

		All objects at distances from half of the hyperfocal distance out to infinity will be in focus.

		This gives gives maximum depth of field.

		This enum value is available from the 'supported' or 'getter' methods only to the API clients using CCamera::New2L() or 

		CCamera::NewDuplicate2L().

		*/ 

		EFocusRangeHyperfocal 	= 0x20,

		/** 

		When there is a near obstacle or better focus wanted for far away objects.

		This enum value is available from the 'supported' or 'getter' methods only to the API clients using CCamera::New2L() or 

		CCamera::NewDuplicate2L().

		*/ 

		EFocusRangeInfinite		= 0x40

		};	

	/** Specifies the supported autofocus types. */

	enum TAutoFocusType

		{

		/** Autofocus is switched off. */

		EAutoFocusTypeOff	 		= 0x00,

		/** Operates on a single shot, consumes less power. */

		EAutoFocusTypeSingle	 	= 0x01,

		/** Continious autofocus, more precise but consumes more power. 

		    also known as AF Servo. */

		EAutoFocusTypeContinuous	= 0x02

		};

	/** Specifies the autofocus area. */

	enum TAutoFocusArea

		{

		/** Automatic. Default value */

		EAutoFocusTypeAuto				= 0x00,

		/** Single area, suitable for relatively flat surfaces and portrait. */

		EAutoFocusTypeSingleArea		= 0x01,

		/** Multiple points of an object, more weighting for centre points. */

		EAutoFocusTypeMultiAreaCentered	= 0x02

		};

	/** Specifies the Metering mode for the camera. 

	EMeteringModeAuto is the default value. */	

	enum TMeteringMode

		{

		/** Automatic mode, default. */	

		EMeteringModeAuto				= 0x0000, 

		/** Metering in which the center is given a weighted priority. */	

		EMeteringModeCenterWeighted		= 0x0001,

		/** Metering of a central area/spot only, also known as partial. */	

		EMeteringModeSpot				= 0x0002, 

		/** Metering is evaluated over a matrix(several spots) and calculated 

		    as a function of that. Usually best but with increased 

		    power consumption. Alternative name multi-metering mode. */	

		EMeteringModeEvaluative			= 0x0004

		};	

	/** Specifies the drive mode for the camera. This determines how and in what sucession are images