//-----------------------------------------------------------------------------
#ifndef mvDriverBaseEnumsH
#if !defined(DOXYGEN_SHOULD_SKIP_THIS) && !defined(WRAP_ANY)
	#define mvDriverBaseEnumsH mvDriverBaseEnumsH
#endif // DOXYGEN_SHOULD_SKIP_THIS && WRAP_ANY
//-----------------------------------------------------------------------------

#if !defined(DOXYGEN_SHOULD_SKIP_THIS) && !defined(WRAP_ANY)
#	ifdef _WIN32
#		ifdef __BORLANDC__
#			pragma option push -b // force enums to the size of integer
#		endif // __BORLANDC__
#	endif // _WIN32
#endif // DOXYGEN_SHOULD_SKIP_THIS && WRAP_ANY

#ifdef BUILD_MVBLUECOUGAR_DOCUMENTATION
#	define IGNORE_MVBLUEFOX_SPECIFIC_DOCUMENTATION
#	define IGNORE_MVBLUELYNX_SPECIFIC_DOCUMENTATION
#	define IGNORE_MVGRABBER_SPECIFIC_DOCUMENTATION
#elif BUILD_MVBLUEFOX_DOCUMENTATION
#	define IGNORE_MVBLUECOUGAR_SPECIFIC_DOCUMENTATION
#	define IGNORE_MVBLUELYNX_SPECIFIC_DOCUMENTATION
#	define IGNORE_MVGRABBER_SPECIFIC_DOCUMENTATION
#elif BUILD_MVBLUELYNX_DOCUMENTATION
#	define IGNORE_MVBLUECOUGAR_SPECIFIC_DOCUMENTATION
#	define IGNORE_MVBLUEFOX_SPECIFIC_DOCUMENTATION
#	define IGNORE_MVGRABBER_SPECIFIC_DOCUMENTATION
#elif BUILD_MVGRABBER_DOCUMENTATION
#	define IGNORE_MVBLUECOUGAR_SPECIFIC_DOCUMENTATION
#	define IGNORE_MVBLUEFOX_SPECIFIC_DOCUMENTATION
#	define IGNORE_MVBLUELYNX_SPECIFIC_DOCUMENTATION
#endif // device specific documentation macros

#ifdef __cplusplus
	extern "C" {
#endif // __cplusplus

#ifdef WRAP_DOTNET
	namespace mvIMPACT {
		namespace acquire {
#endif // WRAP_DOTNET

//-----------------------------------------------------------------------------
/// \brief Defines which field triggers the start of the acquisition.
enum TAcquisitionField
//-----------------------------------------------------------------------------
{
	/// \brief Controlled by the camera parameter.
	afAuto		= 0,
	/// \brief Only odd fields will be digitised.
	afOdd		= 1,
	/// \brief Only even fields will be digitised.
	afEven		= 2,
	/// \brief Odd and even fields will be digitised.
	afAny		= afOdd | afEven
};

#ifndef IGNORE_MVBLUEFOX_SPECIFIC_DOCUMENTATION
	//-----------------------------------------------------------------------------
	/// \brief Defines the footer mode of the <b>mvBlueFOX</b>.
	enum TAdvancedImageInfo
	//-----------------------------------------------------------------------------
	{
		/// \brief Advanced image information off.
		aiiOff			= 0,
		/// \brief Generate image average.
		aiiStats		= 1
	};
#endif // #ifndef IGNORE_MVBLUEFOX_SPECIFIC_DOCUMENTATION

//-----------------------------------------------------------------------------
/// \brief Defines valid white balance calibration modes.
enum TAoiMode
//-----------------------------------------------------------------------------
{
	/// \brief Use a small centred window for image processing.
	amCentered = 0,
	/// \brief Use the complete image for image processing.
	amFull,
	/// \brief Use an user defined Aoi window for image processing.
	amUseAoi
};

//-----------------------------------------------------------------------------
/// \brief Defines valid AutoControlSpeed modes.
///
/// Auto control speed modes define the time in which the controller tries to adapt it's parameters to
/// reach the desired result.
enum TAutoControlSpeed
//-----------------------------------------------------------------------------
{
	/// \brief The controller will converge slowly to the desired value.
	acsSlow = 0,
	/// \brief The controller will converge to the desired value at medium speed.
	acsMedium,
	/// \brief The controller will converge fast to the desired value.
	acsFast,
	/// \brief In this mode the user can control the behaviour of the closed loop(control circuit).
	acsUserDefined
};

//-----------------------------------------------------------------------------
/// \brief Defines valid AEC( <b>A</b>utomatic <b>E</b>xposure <b>C</b>ontrol ) modes
enum TAutoExposureControl
//-----------------------------------------------------------------------------
{
	/// \brief AEC is switched off.
	aecOff = 0,
	/// \brief AEC is switched on.
	aecOn
};

//-----------------------------------------------------------------------------
/// \brief Defines valid AGC( <b>A</b>utomatic <b>G</b>ain <b>C</b>ontrol ) modes.
enum TAutoGainControl
//-----------------------------------------------------------------------------
{
	/// \brief AGC is switched off.
	agcOff = 0,
	/// \brief AGC is switched on.
	agcOn
};

//-----------------------------------------------------------------------------
/// \brief Defines valid offset calibration modes.
enum TAutoOffsetCalibration
//-----------------------------------------------------------------------------
{
	/// \brief The automatic offset calibration is switched off.
	///
	/// In this mode the offset can be adjusted manually.
	aocOff = 0,
	/// \brief The automatic offset calibration is switched on.
	aocOn
};

//-----------------------------------------------------------------------------
/// \brief Defines valid bayer formats.
enum TBayerMosaicParity
//-----------------------------------------------------------------------------
{
	/// \brief The buffer or image starts with a green-red line starting with a green pixel.
	bmpGR,
	/// \brief The buffer or image starts with a green-red line starting with a red pixel.
	bmpRG,
	/// \brief The buffer or image starts with a green-blue line starting with a blue pixel.
	bmpBG,
	/// \brief The buffer or image starts with a green-blue line starting with a green pixel.
	bmpGB
};

//-----------------------------------------------------------------------------
/// \brief Defines valid results of a white balance calibration.
enum TBayerWhiteBalanceResult
//-----------------------------------------------------------------------------
{
	/// \brief No white balance calibration has been performed since start up.
	bwbrUnknown = 0,
	/// \brief The white balance calibration has been performed successfully for the
	/// selected setting.
	bwbrOK,
	/// \brief An unknown error occurred during the white balance calibration for the
	/// selected setting.
	bwbrErrorUnknown,
	/// \brief The previous white balance calibration failed because the reference image
	/// used for the calibration was too dark.
	bwbrErrorToDark,
	/// \brief The previous white balance calibration failed because the reference image
	/// used for the calibration was too bright.
	bwbrErrorToBright
};

#ifndef IGNORE_MVBLUEFOX_SPECIFIC_DOCUMENTATION
	//-----------------------------------------------------------------------------
	/// \brief Defines valid thresholds( in Volt ) for the digital inputs of the
	/// <b>mvBlueFOX</b> cameras.
	enum TBlueFOXDigitalInputThreshold
	//-----------------------------------------------------------------------------
	{
		/// \brief This input is assumed as logic '1' when the voltage applied to the
		/// input lies above about 2 Volts.
		bfdit2V	= 2,
		/// \brief This input is assumed as logic '1' when the voltage applied to the
		/// input lies above about 10 Volts.
		bfdit10V = 10
	};

	//-----------------------------------------------------------------------------
	/// \brief Defines the footer mode of the mvBlueFOX.
	enum TBlueFOXFooterMode
	//-----------------------------------------------------------------------------
	{
		/// \brief No footer.
		bffmOff			= 0,
		/// \brief A 64 Byte footer (standard).
		bffm64B			= 64,
		/// \brief A long 512 Byte footer.
		bffm512B		= 512
	};

	//-----------------------------------------------------------------------------
	/// \brief Defines the version of the kernel driver the mvBlueFOX is running with.
	enum TBlueFOXKernelDriver
	//-----------------------------------------------------------------------------
	{
		/// \brief The first version of the kernel driver.
		bfkdmvBlueFOX,
		/// \brief The second version of the kernel driver.
		///
		/// Under Windows&reg; this driver results in less CPU load, Under Linux
		/// this driver is currently not available, however the first version of the
		/// Linux kernel driver provides the same performance as the second version
		/// under Windows&reg;.
		bfkdmvBlueFOX2
	};

	//-----------------------------------------------------------------------------
	/// \brief Sensor timing options
	enum TBlueFOXSensorTiming
	//-----------------------------------------------------------------------------
	{
		/// \brief Standard Timing
		bfstStandard = 0,
		/// \brief Fast line skip timing
		///
		/// In this mode a faster line skip timing will be used. This will result in a higher 
		/// framerate in partial scan mode, but might affect the image quality.
		///
		/// \note
		/// This mode is not available for every mvBlueFOX camera.
		bfstFastLineSkip = 1
	};

	//-----------------------------------------------------------------------------
	/// \brief Defines the block size used for the USB transfer of the mvBlueFOX.
	enum TBlueFOXTransferSize
	//-----------------------------------------------------------------------------
	{
		/// \brief 16KB blocks.
		bfts16KB	= 16*1024,
		/// \brief 32KB blocks.
		bfts32KB	= 32*1024,
		/// \brief 64KB blocks.
		bfts64KB	= 64*1024,
		/// \brief 128KB blocks.
		bfts128KB	= 128*1024,
		/// \brief 256KB blocks.
		bfts256KB	= 256*1024,
		/// \brief 512KB blocks.
		bfts512KB	= 512*1024,
		/// \brief 1024KB blocks.
		bfts1024KB	= 1024*1024,
		/// \brief 2048KB blocks.
		bfts2048KB	= 2048*1024
	};
#endif // #ifndef IGNORE_MVBLUEFOX_SPECIFIC_DOCUMENTATION

#ifndef IGNORE_MVBLUELYNX_SPECIFIC_DOCUMENTATION
	//-----------------------------------------------------------------------------
	/// \brief Defines the pixel data clip mode on the <b>mvBlueLYNX</b> cameras.
	enum TBlueLYNXCameraDataClipMode
	//-----------------------------------------------------------------------------
	{
		/// \brief Disable the <i>data clip</i> mode.
		/// All pixel values <b>[0-255]</b> will be returned in the image.
		blcdcmOff	= 0,
		/// \brief Enable the <i>data clip</i> mode.
		/// The image pixel values will be clipped to <b>247</b>. The other values
		/// <b>[248-255]</b> can be used for color display.
		blcdcmOn	= 1
	};

	//-----------------------------------------------------------------------------
	/// \brief Defines the flash mode on the <b>mvBlueLYNX</b> cameras.
	enum TBlueLYNXCameraFlashMode
	//-----------------------------------------------------------------------------
	{
		/// \brief Disable the <i>flash</i>.
		blcfmOff		= 0,
		/// \brief Enable the <i>flash</i>.
		blcfmOn			= 1,
		/// \brief Enable the special mode: <i>software flash</i>.
		blcfmSoftware	= 2
	};

	//-----------------------------------------------------------------------------
	/// \brief Defines valid <b>mvBlueLYNX</b> camera pixel frequencies.
	/// \note The <i>fix</i> pixel frequency depends on the sensor type and sensor
	///       resolution.
	enum TBlueLYNXCameraPixelClock
	//-----------------------------------------------------------------------------
	{
		/// \brief Standard sensor clocking.
		blcpcStandard	= 0,
		/// \brief High speed sensor clocking.
		blcpcHighSpeed	= 1,
		/// \brief 12 MHz pixel clock.
		blcpc12000KHz	= 12000,
		/// \brief 13.5 MHz pixel clock.
		blcpc13500KHz	= 13500,
		/// \brief 20 MHz pixel clock.
		blcpc20000KHz	= 20000,
		/// \brief 24 MHz pixel clock.
		blcpc24000KHz	= 24000,
		/// \brief 27 MHz pixel clock.
		blcpc27000KHz	= 27000,
		/// \brief 40 MHz pixel clock.
		blcpc40000KHz	= 40000
	};

	//-----------------------------------------------------------------------------
	/// \brief Defines recognized <b>mvBlueLYNX</b> camera sensor expose modes.
	enum TBlueLYNXCameraExposeMode
	//-----------------------------------------------------------------------------
	{
		/// \brief Standard sequential mode.
		///
		/// In this mode the sensor first is exposed and then afterwards the image readout
		/// is performed.
		blcemStandard = 0,
		/// \brief Overlapped mode, expose during image readout.
		///
		/// This only affects the behaviour of the acquisition if <b>mvIMPACT::acquire::TCameraTriggerMode</b>
		/// is set to <b>mvIMPACT::acquire::TCameraTriggerMode::ctmContinuous</b> mode of CCD sensor.
		blcemOverlapped
	};

	//-----------------------------------------------------------------------------
	/// \brief Line scan sensor trigger modes.
	enum TBlueLYNXCameraLineTriggerMode
	//-----------------------------------------------------------------------------
	{
		/// \brief Disable the line trigger.
		blcltmOff = 0,
		/// \brief Start line expose when the line trigger input level rises above the trigger threshold.
		blcltmRisingEdge,
		/// \brief Start line expose when the line trigger input level falls below the trigger threshold.
		blcltmFallingEdge,
		/// \brief Start line expose when the line trigger input level rises above the trigger threshold and
		/// expose while line trigger input level above threshold.
		blcltmOnHighExpose,
		/// \brief Start line expose when the line trigger input level falls below the trigger threshold and
		/// expose while line trigger input level below threshold.
		blcltmOnLowExpose
	};

	//-----------------------------------------------------------------------------
	/// \todo document me
	enum TBlueLYNXVideoOutMode
	//-----------------------------------------------------------------------------
	{
		blvomOff = 0,
		blvom50Hz,
		blvom60Hz,
		blvomVGA_640_480_75Hz,
		blvomVGA_800_600_60Hz,
		blvomVGA_800_600_72Hz,
		blvomVGA_1024_768_60Hz
	};
#endif // IGNORE_MVBLUELYNX_SPECIFIC_DOCUMENTATION

//-----------------------------------------------------------------------------
/// \brief Defines the camera Aoi modes.
enum TCameraAoiMode
//-----------------------------------------------------------------------------
{
	/// \brief Use the complete Aoi window defined by the hardware ( sensor, camera ).
	camFull = 0,
	/// \brief Use an user defined AOI window.
	camUser
};

//-----------------------------------------------------------------------------
/// \brief Defines valid binning modes for the camera.
///
/// \note
/// Binning might be available for color sensors that do not support color
/// binning. This will result in incorrect color information when the data
/// is converted from a bayer sensor. However under some circumstances this feature
/// might be useful( e.g. when taking image in a very dark surrounding or at night
/// where almost no color information will be contained in the image anyway thus
/// resulting in useful images again). Therefore this feature has deliberately
/// left available.
enum TCameraBinningMode
//-----------------------------------------------------------------------------
{
	/// \brief No Binning.
	cbmOff = 0,
	/// \brief Horizontal Binning.
	cbmBinningH = 1,
	/// \brief Vertical Binning.
	cbmBinningV = 2,
	/// \brief Horizontal+Vertical Binning.
	cbmBinningHV = 3,
	/// \brief Horizontal Binning Bayer Mosaic Mode.
	cbmBinningHBayer = 4,
	/// \brief Vertical Binning Bayer Mosaic Mode.
	cbmBinningVBayer = 5,
	/// \brief Horizontal + Vertical Binning Bayer Mosaic Mode.
	cbmBinningHVBayer = 6
};

#ifndef IGNORE_MVGRABBER_SPECIFIC_DOCUMENTATION
	//-----------------------------------------------------------------------------
	/// \brief Defines the data format the camera is sending
	enum TCameraDataFormat
	//-----------------------------------------------------------------------------
	{
		/// \brief This is an unknown type.
		cdfUnknown = 0,
		/// \brief This is a 8 bit data format.
		cdfMono,
		/// \brief This is a Bayer format.
		cdfBayer,
		/// \brief This is a RGB format.
		cdfRGB
	};
#endif // #ifndef IGNORE_MVGRABBER_SPECIFIC_DOCUMENTATION

//-----------------------------------------------------------------------------
/// \brief Defines recognized camera sensor expose modes.
enum TCameraExposeMode
//-----------------------------------------------------------------------------
{
	/// \brief Standard sequential mode.
	///
	/// In this mode the sensor first is exposed and then afterwards the image readout
	/// is performed.
	cemStandard = 0,
	/// \brief Overlapped mode, expose during image readout.
	///
	/// This only affects the behaviour of the acquisition in <b>mvIMPACT::acquire::TCameraTriggerMode</b>
	/// is set to <b>mvIMPACT::acquire::TCameraTriggerMode::ctmContinuous</b>.
	cemOverlapped,
	/// \brief 'No shutter' mode, switch off exposure control.
	///
	/// This only affects the behaviour of the acquisition in <b>mvIMPACT::acquire::TCameraTriggerMode</b>
	/// is set to <b>mvIMPACT::acquire::TCameraTriggerMode::ctmContinuous</b>.
	cemNoShutter
};

#ifndef IGNORE_MVGRABBER_SPECIFIC_DOCUMENTATION
	//-----------------------------------------------------------------------------
	/// \brief Some grabbers are able to get the video signal and sync signals ( HD-IN, VD-IN ) on seperate lines.
	/// The user can select this for non standard cameras.
	enum TCameraExternalSyncEdge
	//-----------------------------------------------------------------------------
	{
		// \brief The sync signal is expected within the video signal.
		ceseNo = 0,
		// \brief The falling edge of external sync signal is used ( HD-IN,VD-IN )
		ceseFallingEdge = 1,
		// \brief The rising edge of external sync signal is used ( HD-IN,VD-IN )
		ceseRisingEdge = 2
	};

	//-----------------------------------------------------------------------------
	/// \brief Some grabbers are able to get the video signal and the sync signal on different input pins.
	/// The user can select this for non standard cameras.
	enum TCameraExternalSyncOutput
	//-----------------------------------------------------------------------------
	{
		// \brief The sync signal is expected on the selected video channel.
		// If RGB is used the sync signal is expected on the 'green' channel ( SyncOnGreen )
		cesoAuto = 0,
		// \brief The sync signal is expected on the first ('red') video channel ( mvTITAN-RGB only )
		cesoRed = 1,
		// \brief The sync signal is expected on the second ('green') video channel ( mvTITAN-RGB only )
		cesoGreen = 2,
		// \brief The sync signal is expected on the third ('blue') video channel ( mvTITAN-RGB only )
		cesoBlue = 3,
		// \brief The sync signal is expected on the fourth ('extern') video channel ( mvTITAN-RGB only )
		cesoExtern = 4
	};
#endif // #ifndef IGNORE_MVGRABBER_SPECIFIC_DOCUMENTATION

//-----------------------------------------------------------------------------
/// \brief Defines valid camera flash modes.
///
/// These enums may be 'ored' together.
enum TCameraFlashMode
//-----------------------------------------------------------------------------
{
	/// \brief Do not use the cameras flash output.
	cfmOff = 0,
	/// \brief Each time an image is exposed, that cameras output 0 will
	/// be set to high.
	cfmDigout0 = 1,
	/// \brief Each time an image is exposed, that cameras output 1 will
	/// be set to high.
	cfmDigout1 = 2
};

//-----------------------------------------------------------------------------
/// \brief Defines how the camera transmits it's video signal.
enum TCameraInterlacedType
//-----------------------------------------------------------------------------
{
	/// \brief The video signal is transmitted non interlaced, meaning that a complete
	/// image is transferred without interruption.
	citNone,
	/// \brief The video signal is transferred interlaced.
	///
	/// Here the camera transmits the video signal in two consecutive frames that form a complete
	/// image. The first frame contains all the even lines (0, 2, 4, ... ) of the image, while 
	/// the second frame contains all odd lines of the image.
	citInterlaced,
	/// \brief The video signal is transferred interlaced with the two frames in reversed order.
	///
	/// Here the camera transmits the video signal in two consecutive frames that form a complete
	/// image. The first frame contains all the odd lines (0, 2, 4, ... ) of the image, while 
	/// the second frame contains all even lines of the image.
	citInvertedInterlaced
};

#ifndef IGNORE_MVGRABBER_SPECIFIC_DOCUMENTATION
	//-----------------------------------------------------------------------------
	/// \brief Defines how the camera transmits the <b>DVAL</b> signal defined in the
	/// <b>CameraLink&reg; standard</b>.
	enum TCameraLinkDataValidMode
	//-----------------------------------------------------------------------------
	{
		/// \brief The camera transmits a data valid (<b>DVAL</b>) signal, that should
		/// be evaluated by the frame grabber.
		cldvmActive = 0,
		/// \brief The camera does not transmit a data valid (<b>DVAL</b>) signal, that should
		/// be evaluated by the frame grabber.
		cldvmInactive
	};

	//-----------------------------------------------------------------------------
	/// \brief Defines valid ways a camera can offer image data to a capture device.
	enum TCameraOutput
	//-----------------------------------------------------------------------------
	{
		/// \brief Specifies an undefined output.
		coUndefined = -1,
		/// \brief Auto mode. Here the capture device tries to guess how the data is transmitted. 
		coAuto = 0,
		/// \brief The camera will offer an analogue composite video signal.
		coComposite = 1,
		/// \brief The camera will offer <b>CameraLink&reg; Base</b> compliant image data.
		coBase = 2,
		/// \brief The camera will offer digital image data.
		coDigital = 3,
		/// \brief The camera will offer an analogue SVideo signal.
		coSVideo = 4,
		/// \brief The camera will offer <b>CameraLink&reg; Medium</b> compliant image data.
		coMedium = 5,
		/// \brief The camera will offer an analogue RGB signal.
		coRGB = 6,
		/// \brief Two cameras will offer two synchronous analogue signals.
		co2xComposite = 7,
		/// \brief Three cameras will offer three synchronous analogue signals.
		co3xComposite = 8,
		/// \brief Four cameras will offer four synchronous analogue signals.
		co4xComposite = 9
	};

#endif // #ifndef IGNORE_MVGRABBER_SPECIFIC_DOCUMENTATION

//-----------------------------------------------------------------------------
/// \brief Defines valid camera pixel frequencies.
enum TCameraPixelClock
//-----------------------------------------------------------------------------
{
	/// \brief 6 MHz pixel clock.
	cpc6000KHz	= 6000,
	/// \brief 8 MHz pixel clock.
	cpc8000KHz	= 8000,
	/// \brief 10 MHz pixel clock.
	cpc10000KHz	= 10000,
	/// \brief 12 MHz pixel clock.
	cpc12000KHz	= 12000,
	/// \brief 20 MHz pixel clock.
	cpc20000KHz	= 20000,
	/// \brief 24 MHz pixel clock.
	cpc24000KHz	= 24000,
	/// \brief 40 MHz pixel clock.
	cpc40000KHz	= 40000
};

#ifndef IGNORE_MVGRABBER_SPECIFIC_DOCUMENTATION
	//-----------------------------------------------------------------------------
	/// \brief Defines valid scan modes for the a camera.
	enum TCameraScanMode
	//-----------------------------------------------------------------------------
	{
		/// \brief The connected camera is an area scan camera.
		csmArea = 0,
		/// \brief The connected camera is an line scan camera.
		csmLine
	};

	//-----------------------------------------------------------------------------
	/// \brief Defines valid baud rates for serial port communication between
	/// frame grabber and camera.
	enum TCameraSerialPortBaudRate
	//-----------------------------------------------------------------------------
	{
		/// \brief 9600 baud
		cspbr9600 = 9600,
		/// \brief 19200 baud
		cspbr19200 = 19200,
		/// \brief 38400 baud
		cspbr38400 = 38400,
		/// \brief 57600 baud
		cspbr57600 = 57600,
		/// \brief 115200 baud
		cspbr115200 = 115200,
		/// \brief 230400 baud
		cspbr230400 = 230400,
		/// \brief 460800 baud
		cspbr460800 = 460800,
		/// \brief 921600 baud
		cspbr921600 = 921600
	};
#endif // #ifndef IGNORE_MVGRABBER_SPECIFIC_DOCUMENTATION

//-----------------------------------------------------------------------------
/// \brief Defines valid transmission modes for the camera.
enum TCameraTestMode
//-----------------------------------------------------------------------------
{
	/// \brief The 'normal' camera image will be transmitted.
	ctmOff = 0,
	/// \brief A grey gradient will be transmitted by the camera.
	ctmGreyRamp = 1,
	/// \brief A color test image with some moving components in it will be displayed.
	ctmMovingColor = 2,
	/// \brief A raw white bayer image will be transmitted.
	ctmWBTest = 3,
	/// \brief Images will be generated from a directory of bitmap files.
	ctmImageDirectory = 4
};

//-----------------------------------------------------------------------------
/// \brief Sensor trigger modes.
///
/// These triggermodes are currently only valid for <b>mvBlueFOX</b> devices.
enum TCameraTriggerMode
//-----------------------------------------------------------------------------
{
	/// \brief Don't wait for trigger. In this mode the camera continuously exposes images with
	/// the current settings.
	///
	/// However images are not transferred to the host system in this mode, so <b>NO</b> CPU load or
	/// whatsoever is produced in this mode.
	ctmContinuous = 0,
	/// \brief Start frame expose when the software asks for an image.
	ctmOnDemand,
	/// \brief Start frame expose when the trigger input level falls below the trigger threshold.
	ctmOnLowLevel,
	/// \brief Start frame expose when the trigger input level rises above the trigger threshold.
	ctmOnHighLevel,
	/// \brief Start frame expose when the trigger input level falls below the trigger threshold.
	ctmOnFallingEdge,
	/// \brief Start frame expose when the trigger input level rises above the trigger threshold.
	ctmOnRisingEdge,
	/// \brief Start frame expose when the trigger input level rises above the trigger threshold and
	/// expose while trigger input level above threshold.
	ctmOnHighExpose
};

//-----------------------------------------------------------------------------
/// \brief Sensor trigger source.
enum TCameraTriggerSource
//-----------------------------------------------------------------------------
{
	/// \brief Uses digital input 0 as the source for the trigger signal.
	ctsDigIn0 = 0,
	/// \brief Use digital input 1 as the source for the trigger signal.
	ctsDigIn1,
	/// \brief Use real time controller (RTCtrl) as the source for the trigger signal.
	ctsRTCtrl
};

#ifndef IGNORE_MVGRABBER_SPECIFIC_DOCUMENTATION
	//-----------------------------------------------------------------------------
	/// \brief Clamp signal means, that a AC coupled video signal is clamped on the porch
	///	to get a signal transfer with less noise and independent from the d.c. voltage portion.
	/// The clamp pulse width is always 0.5 µsec .
	enum TClampMode
	//-----------------------------------------------------------------------------
	{
		/// \brief Clamp pulse starts at 80 % of ActiveVideoAoi.X .
		ecmAuto, 
		/// \brief The user can set the clamp start time in µsec after the falling edge of the 
		/// video signals' vsync.
		ecmUser
	};
#endif // IGNORE_MVGRABBER_SPECIFIC_DOCUMENTATION

//-----------------------------------------------------------------------------
/// \brief Defines the color processing mode.
enum TColorProcessingMode
//-----------------------------------------------------------------------------
{
	/// \brief The driver decides (depending on the connected camera) what kind of
	/// color processing has to be applied.
	cpmAuto = 0,
	/// \brief No color processing will be performed.
	cpmRaw,
	/// \brief A Bayer color conversion will be applied before the image is transferred
	/// to the user.
	cpmBayer,
	/// \brief A Bayer to Mon conversion will be applied before the image is transferred
	/// to the user.
	cpmBayerToMono
};

//-----------------------------------------------------------------------------
/// \brief Defines the different test modes for continuous whitebalancecalibration.
enum TContinuousWhiteBalanceMode
//-----------------------------------------------------------------------------
{
	/// \brief Continuous WhiteBalance using ColorTemperature.
	cwbColorTemperature,
	/// \brief Continuous WhiteBalance using ColorDifferences.
	cwbColorDifferences,
	/// \brief Continuous WhiteBalance using Bright Regions.
	cwbBrightRegions
};

//-----------------------------------------------------------------------------
/// \brief Defines valid modes for the dark current filter.
enum TDarkCurrentFilterMode
//-----------------------------------------------------------------------------
{
	/// \brief This filter is switched off.
	dcfmOff = 0,
	/// \brief This filter is switched on.
	dcfmOn,
	/// \brief The next frame will be taken for dark current adjustment.
	dcfmCalibrateDarkCurrent
#ifndef DOXYGEN_SHOULD_SKIP_THIS
	// for internal use only
	, dcfmLastDarkCurrentFilterMode
#endif // #ifndef DOXYGEN_SHOULD_SKIP_THIS
};

//-----------------------------------------------------------------------------
/// \brief Defines valid modes for defective pixels filter.
enum TDefectivePixelsFilterMode
//-----------------------------------------------------------------------------
{
	/// \brief This filter is switched off.
	dpfmOff = 0,
	/// \brief The filter is active, detected defective pixels will be replaced with the average value from the left and right neighbour  pixel.
	dpfm3x1Average,
	/// \brief The filter is active, detected defective pixels will be replaced with the median value calculated from the nearest neighbours(3x3).
	dpfm3x3Median,
	/// \brief reset the calibration, delete all internal lists.
	dpfmResetCalibration,
	/// \brief Detect defective leaky pixels within the next frame captured.
	///
	/// These are pixels that produce a higher read out value than average when the sensor is not exposed.
	dpfmCalibrateLeakyPixel,
	/// \brief Detect defective cold pixels within the next frame captured.
	///
	/// These are pixels that produce a lower read out code than average when the sensor is exposed to light.
	dpfmCalibrateColdPixel
};

#ifndef IGNORE_MVGRABBER_SPECIFIC_DOCUMENTATION
	//-----------------------------------------------------------------------------
	/// \brief Defines grabber specific digital output modes.
	enum TDeviceDigitalOutputMode
	//-----------------------------------------------------------------------------
	{
		/// \brief The digital output can be switched manually.
		ddomManual = 0,
		/// \brief A single pulse will be generated on the digital output.
		ddomPulse,
		/// \brief A user defined signal will be generated on the digital output.
		ddomUser
	};

	//-----------------------------------------------------------------------------
	/// \brief Defines acquisition start event if using pulse sequences.
	enum TDeviceImageTrigger
	//-----------------------------------------------------------------------------
	{
		/// \brief Acquisition starts with trigger event as fast as possible.
		ditImmediately = 0,
		/// \brief Acquisition starts after all defined signals have been generated on the digital outputs.
		ditAfterDigOutSignals
	};
#endif // IGNORE_MVGRABBER_SPECIFIC_DOCUMENTATION

//-----------------------------------------------------------------------------
/// \brief Defines valid modes for the loading of settings during initialisation.
///
/// Whenever a <b>mvIMPACT::acquire::Device</b> is initialised this enum type defines the mode the
/// <b>mvIMPACT::acquire::Device</b> tries to restore settings from a previously stored session.
enum TDeviceLoadSettings
//-----------------------------------------------------------------------------
{
	/// \brief Tries to load settings automatically following an internal procedure.
	dlsAuto = 0,
	/// \brief No stored settings will be loaded at startup. The device will be
	/// initialized with the drivers default values.
	dlsNoLoad,
	//dlsFamily,
	//dlsProduct,
	//dlsCameraLocal
};

#ifndef IGNORE_MVBLUEFOX_SPECIFIC_DOCUMENTATION
	//-----------------------------------------------------------------------------
	/// \brief Defines the power mode for this device
	enum TDevicePowerMode
	//-----------------------------------------------------------------------------
	{
		/// \brief This device is switched on
		dpmOn,
		/// \brief This device is switched off.
		///
		/// This might save a considerable amount of energy if the device isn't
		/// needed for a certain amount of time.
		dpmOff
	};
#endif // #ifndef IGNORE_MVBLUEFOX_SPECIFIC_DOCUMENTATION

#ifndef IGNORE_MVGRABBER_SPECIFIC_DOCUMENTATION
	//-----------------------------------------------------------------------------
	/// \brief Scan rate mode
	enum TDeviceScanRateMode
	//-----------------------------------------------------------------------------
	{
		/// \brief Auto, scan rate of camera used.
		dsrmAuto,
		/// \brief User, scan rate must be set manually.
		dsrmUser
	};

	//-----------------------------------------------------------------------------
	/// \brief Defines valid moments to start the signal generation on the digital outputs.
	enum TDeviceSignalOutputStartEvent
	//-----------------------------------------------------------------------------
	{
		/// \brief The signal generation on the digital outputs starts with the next frame start signal ( e.g.: VSync ).
		dsoseFrame,
		/// \brief The signal generation on the digital outputs starts with the event defined in setting->camera->trigger.
		dsoseTrigger,
		/// \brief The signal generation on the digital outputs starts with next frame signal after the event defined in setting->camera->trigger.
		dsoseFrameAfterTrigger,
		/// \brief The signal generation on the digital outputs starts with the rising edge of SyncIn - signal. <b>CameraLink&reg;</b> only !!!
		dsoseSyncInRisingEdge,
		/// \brief The signal generation on the digital outputs starts with the falling edge of SyncIn - signal. <b>CameraLink&reg;</b> only !!!
		dsoseSyncInFallingEdge,
		/// \brief The SyncIn - signal is passed on selected digital output. <b>CameraLink&reg;</b> only !!!
		dsoseSyncInPassThrough,
		/// \brief The SyncIn - signal is inverted and passed on selected digital output. <b>CameraLink&reg;</b> only !!!
		dsoseSyncInPassThroughInv,
		/// \brief The signal generation on the digital outputs starts periodically. <b>CameraLink&reg;</b> only !!!
		dsosePeriodically
	};
#endif // IGNORE_MVGRABBER_SPECIFIC_DOCUMENTATION

//-----------------------------------------------------------------------------
/// \brief Defines valid <b>Device</b> states.
enum TDeviceState
//-----------------------------------------------------------------------------
{
	/// \brief The <b>mvIMPACT::acquire::Device</b> has been unplugged.
	///
	/// The <b>mvIMPACT::acquire::Device</b> has been since the <b>mvIMPACT::acquire::DeviceManager</b> has been initialised,
	/// but has been unplugged now.
	dsAbsent = 0,
	/// \brief The <b>mvIMPACT::acquire::Device</b> is currently connected and initialised.
	dsPresent,
	/// \brief The <b>mvIMPACT::acquire::Device</b> is connected and is currently initialising.
	dsInitializing,
	/// \brief This device is recognized, but can't be accessed currently.
	///
	/// This e.g. can be the case, if this is a device connected via a network and the device
	/// does not respond to one of the recognized network protocols.
	dsUnreachable,
	/// \brief This device is present, but currently switched into a low power consumption mode
	dsPowerDown
};

#ifndef IGNORE_MVGRABBER_SPECIFIC_DOCUMENTATION
	//-----------------------------------------------------------------------------
	/// \brief Valid syncout modes for grabbers ( mvTITAN-RGB only )
	enum TDeviceSyncOutMode
	//-----------------------------------------------------------------------------
	{
		/// \brief Sync signals off.
		dsomOff = 0,
		/// \brief A non interlaced HD_OUT/VD_OUT signal is generated.
		dsomNonInterlaced,
		/// \brief A interlaced HD_OUT/VD_OUT signal is generated.
		dsomInterlaced
	};

	//-----------------------------------------------------------------------------
	/// \brief Valid trigger modes for grabbers.
	enum TDeviceTriggerMode
	//-----------------------------------------------------------------------------
	{
		/// \brief Trigger off
		dtmOff = 0,
		/// \brief Trigger on
		dtmOn,
		/// \brief Trigger on falling edge of an external signal.
		dtmFallingEdge,
		/// \brief Trigger on rising edge of an external signal.
		dtmRisingEdge,
		/// \brief Timer is used to simulate trigger.
		dtmPeriodically,
		/// \brief SnapRequest simulates trigger.
		dtmOnDemand
	};
#endif // IGNORE_MVGRABBER_SPECIFIC_DOCUMENTATION

//-----------------------------------------------------------------------------
/// \brief Defines valid digital I/O states.
enum TDigIOState
//-----------------------------------------------------------------------------
{
	/// \brief Digital I/O is in 'logic 0' state.
	digioOff = 0,
	/// \brief Digital I/O is in 'logic 1' state.
	digioOn = 1,
	/// \brief Digital Input is in 'ignore' state.
	digioIgnore = 2,
	/// \brief Digital Output is kept in unchanged state.
	digioKeep = 3
};

#ifndef IGNORE_MVGRABBER_SPECIFIC_DOCUMENTATION
	//-----------------------------------------------------------------------------
	/// \brief Defines valid ways to create signals on a digital output.
	enum TDigitalOutputControlMode
	//-----------------------------------------------------------------------------
	{
		/// \brief The digital output signal is generated by the onboard processor.
		docmSoftware = 0,
		/// \brief The digital output signal is generated by a <b>R</b>eal <b>T</b>ime <b>C</b>ontroller
		/// that is part of the used hardware device.
		docmRTC
	};
#endif // #ifndef IGNORE_MVGRABBER_SPECIFIC_DOCUMENTATION

//-----------------------------------------------------------------------------
/// \brief Errors reported by the device manager.
///
/// These are errors which might occur in connection with the device manager
/// itself or while working with the single devices.
enum TDMR_ERROR // no_property_type
//-----------------------------------------------------------------------------
{
	/// \brief The function call was executed successfully.
	DMR_NO_ERROR = 0,
	/// \brief A dummy constant to mark the first valid error code for device and device
	/// manager related errors.
	DMR_FIRST_ERROR_CODE = -2100,
	/// \brief the specified device can't be found.
	///
	/// This error occurs either if an invalid device ID has been passed to the
	/// device manager or if the caller tried to close a device which currently
	/// isn't initialised.
	DMR_DEV_NOT_FOUND = DMR_FIRST_ERROR_CODE,
	/// \brief The device manager couldn't be initialised.
	///
	/// This is an internal error.
	DMR_INIT_FAILED = -2101,
	/// \brief The device is already in use.
	///
	/// This error will occur if this or another process has initialized this
	/// device already.
	DMR_DRV_ALREADY_IN_USE = -2102,
	/// \brief The specified device couldn't be initialised.
	DMR_DEV_CANNOT_OPEN = -2103,
	/// \brief The device manager hasn't been initialised.
	///
	/// This error occurs if the user tries to close the device manager without
	/// having previously initialised it.
	DMR_NOT_INITIALIZED = -2104,
	/// \brief A device could not be initialised.
	DMR_DRV_CANNOT_OPEN = -2105,
	/// \brief The devices request queue is empty.
	///
	/// This error occurs if the user wait for an image request to become available in a
	/// result queue without having send a image request to the device before.
	DMR_DEV_REQUEST_QUEUE_EMPTY = -2106,
	/// \brief A image request couldn't be created.
	///
	/// The creation of an image request failed. This might e.g. happen, if the system
	/// runs extremely low on memory.
	DMR_DEV_REQUEST_CREATION_FAILED = -2107,
	/// \brief An invalid parameter has been passed to a function.
	///
	/// This might e.g. happen if a function requiring a pointer to a structure has been passed
	/// an unassigned pointer or if a value has been passed, that is either too large or too small in
	/// that context.
	DMR_INVALID_PARAMETER = -2108,
	/// \brief One or more symbols needed in a detected driver library couldn't be resolved.
	///
	/// In most cases this is an error handled internally. So the user will not receive this error
	/// code as a result of a call to an API function. However when the user tries to get access
	/// to an <b>IMPACT</b> buffer type while the needed <b>IMPACT Base libraries</b> are not installed
	/// on the target system this error code also might be returned to the user.
	DMR_EXPORTED_SYMBOL_NOT_FOUND = -2109,
	/// \brief An unknown error occurred while processing a user called
	/// driver function.
	DEV_UNKNOWN_ERROR = -2110,
	/// \brief A driver function has been called with an invalid device handle.
	DEV_HANDLE_INVALID = -2111,
	/// \brief A driver function has been called but one or more of the input
	/// parameters are invalid.
	///
	/// Threre are several possible reasons for this error:
	/// - an unassigned pointer has been passed to a function, that requires a valid pointer
	/// - one or more of the passed parameters are of an incorrect type
	/// - one or more parameters contain an invalid value (e.g. a filename that points to a file that can't
	/// be found, a value, that is larger or smaller then the allowed values.
	DEV_INPUT_PARAM_INVALID = -2112,
	/// \brief A function has been called with an invalid number of input parameters.
	DEV_WRONG_INPUT_PARAM_COUNT = -2113,
	/// \brief The creation of a setting failed.
	///
	/// This can either happen, when a setting with the same name as the one the user
	/// tried to create already exists or if the system can't allocate memory for the
	/// new setting.
	DEV_CREATE_SETTING_FAILED = -2114,
	/// \brief The unlock for a <b>mvIMPACT::acquire::Request</b> object failed.
	///
	/// This might happen, if the <b>mvIMPACT::acquire::Request</b> is
	/// currently unlocked (has been unlocked before?) and therefore can't be unlocked.
	/// Another reason for this error might be that the request the user tries to
	/// unlock is currently processed by the device driver.
	DEV_REQUEST_CANT_UNLOCKED = -2115,
	/// \brief The number for the <b>mvIMPACT::acquire::Request</b> object is invalid.
	///
	/// The max. number for a <b>mvIMPACT::acquire::Request</b> object is
	/// the value of the property \a RequestCount in the <b>SystemBase</b> list - 1.
	DEV_INVALID_REQUEST_NUMBER = -2116,
	/// \brief A Request that hasn't been unlocked has been passed back to the driver.
	///
	/// This error might occur if the user requested an image from the driver but hasn't
	/// unlocked the <b>mvIMPACT::acquire::Request</b> that will be used for this new
	/// image.
	DEV_LOCKED_REQUEST_IN_QUEUE = -2117,
	/// \brief The user requested a new image, but no free <b>mvIMPACT::acquire::Request</b>
	/// object is available to process this request.
	DEV_NO_FREE_REQUEST_AVAILABLE = -2118,
	/// \brief The wait for a request failed.
	///
	/// This might have several reasons:
	///
	/// - the user waited for an image, but no image has been requested before.
	/// - the user waited for a requested image, but the image is still no ready(e.g. because of
	/// a short timeout and a long exposure time).
	/// - a triggered image has been requested but no trigger signal has been detected within the
	/// wait period.
	/// - a plug and play device(e.g. an USB device) has been unplugged an therefore can't deliver
	/// images anymore. In this case the \a 'state' property should be checked to find out if the
	/// device is still present or not.
	DEV_WAIT_FOR_REQUEST_FAILED = -2119,
	/// \brief The user tried to get/set a parameter, which is not supported by this device.
	DEV_UNSUPPORTED_PARAMETER = -2120,
	/// \brief The requested real time controller is not available for this device.
	DEV_INVALID_RTC_NUMBER = -2121,
	/// \brief Some kind of internal error occurred.
	///
	/// More information can be found in the *.log-file or the debug output.
	DMR_INTERNAL_ERROR = -2122,
	/// \brief The user allocated input buffer is to small to accommodate the result.
	DMR_INPUT_BUFFER_TOO_SMALL = -2123,
	/// \brief Some kind of internal error occurred in the device driver.
	///
	/// More information can be found in the *.log-file or the debug output.
	DEV_INTERNAL_ERROR = -2124,
	/// \brief One or more needed libraries are not installed on the system.
	DMR_LIBRARY_NOT_FOUND = -2125,
	/// \brief The called function is not available for this device.
	DMR_FUNCTION_NOT_IMPLEMENTED =  -2126,
	/// \brief The feature in question is not available for this device.
	DMR_FEATURE_NOT_AVAILABLE = -2127,
	/// \brief The user is not permitted to perform the requested operation.
	///
	/// This e.g. might happen if the user tried to delete user data without specifying the
	/// required password.
	DMR_EXECUTION_PROHIBITED = -2128,
	/// \brief The specified file can't be found.
	///
	/// This might e.g. happen if the current working directory doesn't contain the file specified.
	DMR_FILE_NOT_FOUND = -2129,
	/// \brief The licence doesn't match the device it has been assigned to.
	///
	/// When e.g. upgrading a device feature each licence file is bound to a certain device. If the
	/// device this file has been assigned to has a different serial number then the one used
	/// to create the licence this error will occur.
	DMR_INVALID_LICENCE = -2130,
	/// \brief There is no sensor found or the found sensor type is wrong or not supported.
	DEV_SENSOR_TYPE_ERROR = -2131,
	/// \brief A function call was associated with a camera description, that is invalid.
	///
	/// One possible reason might be, that the camera description has been deleted(driver closed?).
	DMR_CAMERA_DESCRIPTION_INVALID = -2132,
	/// \brief A suitable driver library to work with the device manager has been detected, but
	/// it is too old to work with this version of the mvDeviceManager library.
	///
	/// This might happen if two different drivers have been installed on the target system and
	/// one introduces a newer version of the device manager that is not compatible with the older
	/// driver installed on the system. In this case this error message will be written into the
	/// log-file together with the name of the library that is considered to be too old.
	///
	/// The latest drivers will always be available online under <b>www.matrix-vision.de</b>. There
	/// will always be an updated version of the library considered to be too old for download from
	/// here.
	DMR_NEWER_LIBRARY_REQUIRED = -2133,

	// If new error codes must be added this happens HERE!
	// When adding a new value here NEVER forget to update the internal string AND/OR exception table!

	/// \brief Needed for compile time checks for invalid error code values
	DMR_PSEUDO_LAST_ASSIGNED_ERROR_CODE,
	/// \brief A dummy constant to mark the last valid error code for device and device manager 
	/// related errors.
	DMR_LAST_ASSIGNED_ERROR_CODE = DMR_PSEUDO_LAST_ASSIGNED_ERROR_CODE - 2,
	/// \brief Defines the last valid error code value for device and device manager 
	/// related errors.
	DMR_LAST_VALID_ERROR_CODE = -2199
};

#ifndef IGNORE_MVGRABBER_SPECIFIC_DOCUMENTATION
	//-----------------------------------------------------------------------------
	/// \brief The fieldgate is used to detect the field ( odd or even ) for interlaced videosignals.
	enum TFieldGateMode
	//-----------------------------------------------------------------------------
	{ 
		/// \brief Fieldgate starts at 1/3 of a line and ends at 2/3 of a line.
		efmAuto,
		/// \brief FieldGateStart and FieldGateWidth can be set in pixels.
		efmUser
	};
#endif // IGNORE_MVGRABBER_SPECIFIC_DOCUMENTATION

//-----------------------------------------------------------------------------
/// \brief Defines a certain filter type. Currently unsupported.
enum TFilterType
//-----------------------------------------------------------------------------
{
	/// \brief Currently unsupported.
	ftBayer = 0
};

//-----------------------------------------------------------------------------
/// \brief Defines valid modes for the flat field filter.
enum TFlatFieldFilterMode
//-----------------------------------------------------------------------------
{
	/// \brief The filter is switched off.
	fffmOff = 0,
	/// \brief The filter is switched on.
	fffmOn,
	/// \brief The next frame will be taken as flat field.
	fffmCalibrateFlatField
};

//-----------------------------------------------------------------------------
/// \brief Defines valid <b>Device</b> HW update results.
///
/// This defines valid result e.g. of a user executed firmware update.
enum THWUpdateResult
//-----------------------------------------------------------------------------
{
	/// \brief No update has been performed for this <b>mvIMPACT::acquire::Device</b>.
	urNothing = 0,
	/// \brief The <b>mvIMPACT::acquire::Device</b> is currently updating firmware.
	urUpdateFW,
	/// \brief The <b>mvIMPACT::acquire::Device</b> indicates an error during updating firmware.
	urUpdateFWError,
	/// \brief The requested update couldn't be performed as the device is already in use.
	///
	/// If another (or even the same) process uses the device, this hardware update can't be performed.
	/// To perform the requested update this device needs to be closed.
	urDevAlreadyInUse,
	/// \brief The <b>mvIMPACT::acquire::Device</b> indicates that the firmware has been updated successfully.
	urUpdateFWOK,
	/// \brief The <b>mvIMPACT::acquire::Device</b> is currently setting device ID.
	urSetDevID,
	/// \brief The <b>mvIMPACT::acquire::Device</b> signalled an error when setting device ID.
	urSetDevIDError,
	/// \brief An invalid device ID has been specified.
	///
	/// Valid device ID lie within 0 and 250 including the upper and lower limit.
	urSetDevIDInvalidID,
	/// \brief The <b>mvIMPACT::acquire::Device</b> has successfully been assigned a new ID.
	urSetDevIDOK,
	/// \brief Size Error in writing User Data to <b>mvIMPACT::acquire::Device</b> .
	urSetUserDataSizeError,
	/// \brief Write Error in writing User Data to <b>mvIMPACT::acquire::Device</b> .
	urSetUserDataWriteError,
	/// \brief Writing user data to <b>mvIMPACT::acquire::Device</b> was successful.
	urSetUserDataWriteOK,
	/// \brief Reading user data from an <b>mvIMPACT::acquire::Device</b> failed.
	urGetUserDataReadError
};

//-----------------------------------------------------------------------------
/// \brief Valid image buffer pixel formats.
enum TImageBufferPixelFormat
//-----------------------------------------------------------------------------
{
	ibpfRaw = 0,
	/// \brief A single channel 8 bit per pixel format.
	ibpfMono8,
	/// \brief A single channel 16 bit per pixel format.
	ibpfMono16,
	/// \brief A three channel RGB image with 32 bit per pixel containing one fill byte per pixel.
	///
	/// This is an interleaved pixel format suitable for most display functions. The data
	/// is stored pixel-wise. When accessed 4-byte wise the data layout in memory can be
	/// interpreted like this (starting with the MSB):
	///
	/// 4 bytes   4 bytes   4 bytes  etc.
	/// B1G1R1X1  B2G2R2X2  B3G3R3X3
	///
	/// <b>ImageBuffer::vpData</b> will point to B1 when using a byte pointer. When working with a
	/// 32 bit size pointer, the LSB of the dereferenced pointer will contain the blue component of the
	/// pixel.
	ibpfRGBx888Packed,
	/// \brief This is a YUV422 image with 16 bit per pixel.
	///
	/// Two consecutive pixels (32 bit, 0xaabbccdd ) contain 8 bit luminance pixel 1(aa),
	/// 8 bit chrominance red pixel 1 and 2(bb),
	/// 8 bit luminance pixel 2(cc) and finally 8 bit chrominance blue(dd).
	ibpfYUV422Packed,
	/// \brief The image will be transferred as an RGB image in planar format.
	///
	/// This is a format best suitable for most image processing functions.
	/// The image will be converted into four planes(a plane for each color component and one
	/// alpha plane).
	///
	/// R1 R2 R3 R4 etc.
	/// ...........
	/// G1 G2 G3 G4 etc.
	/// ...........
	/// B1 B2 B3 B4 etc.
	/// ...........
	/// A1 A2 A3 A4 etc.
	/// while <b>ImageBuffer::vpData</b> will point to R1.
	ibpfRGBx888Planar,
	/// \brief A single channel 10 bit per pixel format.
	ibpfMono10,
	/// \brief A single channel 12 bit per pixel format.
	ibpfMono12,
	/// \brief A single channel 14 bit per pixel format.
	ibpfMono14,
	/// \brief The image will be transferred as an RGB image with 24 bit per pixel.
	///
	/// This is an interleaved pixel format suitable for most display and processing functions.
	/// The data is stored pixel-wise:
	///
	/// 3 bytes  3 bytes  3 bytes     etc.
	/// B1G1R1   B2G2R2   B3G3R3
	///
	/// <b>ImageBuffer::vpData</b> will point to B1 when using a byte pointer. When working with a
	/// 32 bit size pointer, the LSB of the dereferenced pointer will contain the blue component of the
	/// first pixel, the MSB will contain the blue component of the second pixel (0xB2R1G1B1).
	ibpfRGB888Packed,
	/// \brief currently unsupported.
	ibpfYUV444Planar,
	/// \brief A single channel 32 bit per pixel format.
	ibpfMono32
};

//-----------------------------------------------------------------------------
/// \brief Defines the pixel format of the result image.
enum TImageDestinationPixelFormat
//-----------------------------------------------------------------------------
{
	/// \brief The driver will decide which destination format has to be used.
	idpfAuto = 0,
	/// \brief The image will be transferred as an unprocessed block of data.
	idpfRaw,
	/// \brief The image will be transferred as a mono channel 8 bit per pixel image.
	idpfMono8,
	/// \brief The image will be transferred as an RGB image with 32 bit per pixel containing one fill byte per pixel.
	///
	/// This is an interleaved pixel format suitable for most display functions. The data
	/// is stored pixel-wise. When accessed 4-byte wise the data layout in memory can be
	/// interpreted like this (starting with the MSB):
	///
	/// 4 bytes   4 bytes   4 bytes  etc.
	/// B1G1R1X1  B2G2R2X2  B3G3R3X3
	///
	/// <b>ImageBuffer::vpData</b> will point to B1 when using a byte pointer. When working with a
	/// 32 bit size pointer, the LSB of the dereferenced pointer will contain the blue component of the
	/// pixel.
	idpfRGBx888Packed,
	/// \brief The image will be transferred as an YUV422 image with 16 bit per pixel.
	///
	/// Two consecutive pixels (32 bit, 0xaabbccdd ) contain 8 bit luminance pixel 1(aa),
	/// 8 bit chrominance red pixel 1 and 2(bb),
	/// 8 bit luminance pixel 2(cc) and finally 8 bit chrominance blue(dd).
	idpfYUV422Packed,
	/// \brief The image will be transferred as an RGB image in planar format.
	///
	/// This is a format best suitable for most image processing functions.
	/// The image will be converted into four planes(a plane for each color component and one
	/// alpha plane).
	///
	/// R1 R2 R3 R4 etc.
	/// ...........
	/// G1 G2 G3 G4 etc.
	/// ...........
	/// B1 B2 B3 B4 etc.
	/// ...........
	/// A1 A2 A3 A4 etc.
	/// while <b>ImageBuffer::vpData</b> will point to R1.
	idpfRGBx888Planar,
	/// \brief The image will be transferred as a mono channel 10 bit per pixel image.
	idpfMono10,
	/// \brief The image will be transferred as a mono channel 12 bit per pixel image.
	idpfMono12,
	/// \brief The image will be transferred as a mono channel 14 bit per pixel image.
	idpfMono14,
	/// \brief The image will be transferred as a mono channel 16 bit per pixel image.
	idpfMono16,
	/// \brief The image will be transferred as an RGB image with 24 bit per pixel.
	///
	/// This is an interleaved pixel format suitable for most display and processing functions.
	/// The data is stored pixel-wise:
	///
	/// 3 bytes  3 bytes  3 bytes     etc.
	/// B1G1R1   B2G2R2   B3G3R3
	///
	/// <b>ImageBuffer::vpData</b> will point to B1 when using a byte pointer. When working with a
	/// 32 bit size pointer, the LSB of the dereferenced pointer will contain the blue component of the
	/// first pixel, the MSB will contain the blue component of the second pixel (0xB2R1G1B1).
	idpfRGB888Packed
};

//-----------------------------------------------------------------------------
/// \brief Defines valid filters which can be applied to the captured image before it
/// is transferred to the user.
enum TImageProcessingFilter
//-----------------------------------------------------------------------------
{
	/// \brief No filter function will be applied to the image.
	ipfOff = 0,
	/// \brief A sharpen filter will be applied to the image.
	ipfSharpen
};

//-----------------------------------------------------------------------------
/// \brief Defines the behaviour of an <b>mvIMPACT::acquire::ImageRequestControl</b>.
enum TImageRequestControlMode
//-----------------------------------------------------------------------------
{
	/// \brief The standard mode for image requests.
	///
	/// In this mode one image will be captured from the hardware for each request 
	/// that is send to the device driver. The image will be taken with respect to the
	/// current parameters as defined in the setting selected in the corresponding
	/// image request control.
	ircmManual,
	/// \brief Reserved. Currently not implemented.
	ircmLive,
	/// \brief Reserved. Currently not implemented.
	ircmCounting,
	/// \brief In this mode no 'real' image will be captured, but the whole 
	/// processing chain will be traversed once.
	///
	/// This mode can be used either to find out what the image format and parameters
	/// after an image capture would be with the current settings or to prepare
	/// the hardware before starting the first image acquisiton to save time when 
	/// real image data is processed.
	///
	/// When requesting an image in this mode, the corresponding wait function will return 
	/// a complete request object with pixel format, dimensions and image buffer that contains
	/// some dummy data.
	ircmTrial
};

//-----------------------------------------------------------------------------
/// \brief Defines Image Result Configuration.
enum TImageResultConfiguration
//-----------------------------------------------------------------------------
{
	/// \brief Result is switched off.
	ircOff = 0,
	/// \brief Result is switched on.
	ircOn
};

//-----------------------------------------------------------------------------
/// \brief Defines the type of camera sensor.
enum TInfoSensorColorMode
//-----------------------------------------------------------------------------
{
	/// \brief This is an unknown type of sensor.
	iscmUnknown = 0,
	/// \brief This is a mono color sensor.
	iscmMono,
	/// \brief This is a Bayer color sensor.
	iscmBayer,
	/// \brief This is a color sensor.
	iscmColor
};

//-----------------------------------------------------------------------------
/// \brief Defines the bayer pattern of the sensor.
enum TInfoSensorColorPattern
//-----------------------------------------------------------------------------
{
	/// \brief This sensor starts to transmit a green pixel from a green and red line.
	///
	/// The raw image therefore is structured like this:
	///
	/// GRGRGRGRGRGRG etc.<br>
	/// BGBGBGBGBGBGB etc.<br>
	/// GRGRGRGRGRGRG etc.<br>
	/// etc.<br>
	iscpGreenRed,
	/// \brief This sensor starts to transmit a red pixel from a green and red line.
	///
	/// The raw image therefore is structured like this:
	///
	/// RGRGRGRGRGRGR etc.<br>
	/// GBGBGBGBGBGBG etc.<br>
	/// RGRGRGRGRGRGR etc.<br>
	/// etc.<br>
	iscpRedGreen,
	/// \brief This sensor starts to transmit a green pixel from a green and blue line.
	///
	/// The raw image therefore is structured like this:
	///
	/// GBGBGBGBGBGBG etc.<br>
	/// RGRGRGRGRGRGR etc.<br>
	/// GBGBGBGBGBGBG etc.<br>
	/// etc.<br>
	iscpBlueGreen,
	/// \brief This sensor starts to transmit a blue pixel from a green and blue line.
	///
	/// The raw image therefore is structured like this:
	///
	/// BGBGBGBGBGBGB etc.<br>
	/// GRGRGRGRGRGRG etc.<br>
	/// BGBGBGBGBGBGB etc.<br>
	/// etc.<br>
	iscpGreenBlue,
	/// \brief Nothing is known about the way the sensor transmits data.
	iscpUnknown
};

//-----------------------------------------------------------------------------
/// \brief Defines the type of camera sensor.
enum TInfoSensorType
//-----------------------------------------------------------------------------
{
	/// \brief This is an unknown type of sensor.
	istUnknown = 0,
	/// \brief This is a CCD sensor.
	istCCD = 0x1,
	/// \brief This is a CMOS sensor.
	istCMOS = 0x2,
	/// \brief This is a LINESCAN sensor.
	istLINESCAN = 0x4
};

//-----------------------------------------------------------------------------
/// \brief Defines how to handle interlaced image data.
///
///	Image data might be transmitted as fields. These later can either be combined
/// back into a full frame or can be handled individually.
enum TInterlacedMode
//-----------------------------------------------------------------------------
{
	/// \brief Enable the interlaced function.
	///
	/// The device will re-construct the interlaced data into a full frame.
	/// InvInterlaced/Interlaced is controlled by the camera parameter.
	imOn		= 0,
	/// \brief Disable the interlaced function.
	imOff		= 1
};

#ifndef IGNORE_MVGRABBER_SPECIFIC_DOCUMENTATION
	//-----------------------------------------------------------------------------
	/// \brief Currently available for mvTITAN/mvGAMMA-CL.
	///
	/// If <b>mvIMPACT::acquire::TLineCounter::lcOn</b> is used of 
	/// <b>mvIMPACT::acquire::RequestInfo</b> structure contains the line count
	/// of the first line of the <b>mvIMPACT::acquire::Request::lineCounter</b>.
	///
	/// <b>mvTITAN/mvGAMMA-CL</b>: The counter is implemented in the hardware. All incoming lines will be counted.
	/// A detected signal on the trigger input will reset the counter. In addition to the the result
	/// the line count will be encoded in bit 0 of the first 32 Words (2-byte) of every line (watermark).
	///
	/// To decode the line counter from a line of image data something like this is needed(pseudo-code):
	///
	///\code
	/// unsigned integer getWatermark( pointer pData )
	/// {
	///   unsigned integer result = 0
	///   do
	///   {
	///     result = result OR ( pData[i multiplied by 2] AND 0x1 ) shift_left_by(i)
	///     i + 1
	///   } while( i < 32 )
	///   return result
	/// }
	///\endcode
	enum TLineCounter
	//-----------------------------------------------------------------------------
	{
		/// \brief Disables line counter.
		lcOff		= 0,
		/// \brief Enables line counter.
		lcOn		= 1
	};
#endif // IGNORE_MVGRABBER_SPECIFIC_DOCUMENTATION

//-----------------------------------------------------------------------------
/// \brief Defines Mode of memory manager.
enum TMemManMode
//-----------------------------------------------------------------------------
{
	/// \brief MemMan in Automatic Mode
	mmAuto			= 0,
	/// \brief MemMan in Pool Mode
	mmPool			= 1
};

//-----------------------------------------------------------------------------
/// \brief Defines valid mirror modes.
enum TMirrorMode
//-----------------------------------------------------------------------------
{
	/// \brief No Mirroring.
	mmOff = 0,
	/// \brief The resulting image will be flipped around a horizontal axis.
	mmTopDown = 0x1,
	/// \brief The resulting image will be flipped around a vertical axis.
	mmLeftRight = 0x2,
	/// \brief The resulting image will be both around a horizontal and vertical axis.
	mmTopDownAndLeftRight = mmTopDown | mmLeftRight
};

//-----------------------------------------------------------------------------
/// \brief Defines valid network protocols.
enum TNetworkProtocol
//-----------------------------------------------------------------------------
{
	/// \brief This device is recognized as a supported device but doesn't respond
	/// to one of the recognized network protocols.
	npUnrecognized = 0,
	/// \brief This device will answer to the mvServer protocol.
	npmvServer = 1,
	/// \brief This device will answer to the GigE(TM) Vision protocol.
	npGigEVision = 2
};

#ifndef IGNORE_MVGRABBER_SPECIFIC_DOCUMENTATION
	//-----------------------------------------------------------------------------
	/// \brief Defines valid modes for the handling of the device' on board memory
	/// (if available)
	enum TOnBoardMemoryMode
	//-----------------------------------------------------------------------------
	{
		/// \brief The device will work with reasonable default values.
		///
		/// This option will be the right choice for most of the user. 
		obmmDefault,
		/// \brief The user can define how the on board memory of the device will
		/// be used.
		///
		/// This is for advanced user only and will not be necessary in most of
		/// the cases.
		obmmUser
	};
#endif // IGNORE_MVGRABBER_SPECIFIC_DOCUMENTATION

//-----------------------------------------------------------------------------
/// \brief Defines the pool mode of memory manager.
enum TPoolMode
//-----------------------------------------------------------------------------
{
	/// \brief Dont use Pool
	pmOff			= 0,
	/// \brief Use Pool in Manual Mode
	pmFixed			= 1,
	/// \brief Use Pool in Automatic Mode
	pmAuto			= 2
};

//-----------------------------------------------------------------------------
/// \brief Defines the current state of this <b>mvIMPACT::acquire::Request</b>.
enum TRequestState
//-----------------------------------------------------------------------------
{
	/// \brief This <b>mvIMPACT::acquire::Request</b> is currently unused.
	rsIdle,
	/// \brief This <b>mvIMPACT::acquire::Request</b> has been send into the drivers image request queue and
	/// currently wait to be processed.
	rsWaiting,
	/// \brief This <b>mvIMPACT::acquire::Request</b> is currently being processed.
	rsCapturing,
	/// \brief This <b>mvIMPACT::acquire::Request</b> has been processed.
	///
	/// The user is now responsible for this request. Before this <b>mvIMPACT::acquire::Request</b> is not unlocked
	/// again it can't be used by the driver. A <b>mvIMPACT::acquire::Request</b> in this state can safely be processed
	/// by the user. It's data will remain valid until either the <b>mvIMPACT::acquire::Request</b> is unlocked by
	/// the user or the device is closed.
	rsReady
};

//-----------------------------------------------------------------------------
/// \brief Defines valid result of an image request.
///
/// Whenever during the processing of the capture parameters but well before the actual
/// image capture and error is detected the MSB of this enum will be set to 1.
/// In this case almost everytime the current input parameters can't lead to a 
/// correct image and have to be changed.
enum TRequestResult
//-----------------------------------------------------------------------------
{
	/// \brief This image request has been processed successfully.
	rrOK = 0,
	/// \brief This image request resulted in a timeout. No image has been captured during
	/// the allowed period of time.
	rrTimeout = 1,
	/// \brief An error occurred during the processing of this request.
	rrError = 2,
	/// \brief SnapAborted, either internal buffers are missing or the user itself has aborted the snap .
	rrSnapAborted = 3,
	/// \brief An incomplete image was transferred.
	rrImageIncomplete = 4,
	/// \brief This request is not processible.
	///
	/// If this flag (the MSB) is set this either indicates that the current input parameters 
	/// can't be used to capture an image (in that case the result will not be the MSB alone)
	/// or that an internal error occurred during the process of this request.
	rrUnprocessibleRequest = 0x80000000,
	/// \brief No free buffer available to process this request.
	///
	/// To get more memory either some old requests should be unlocked or the size of the
	/// DMA memory (frame grabbers only) could be increased using the tools provided.
	rrNoBufferAvailable,
	/// \brief There is not enough memory available to the driver to process the current
	/// image request.
	///
	/// To get more memory either some old requests should be unlocked or the size of the
	/// DMA memory (frame grabbers only) could be increased using the tools provided.
	rrNotEnoughMemory,
	/// \brief ScanStandard not valid for this VideoStandard.
	rrScanStandardNotSupported,
	/// \brief ScanRate is not valid for this VideoStandard.
	rrScanRateInvalid,
	/// \brief The current camera description is not supported by the capture device.
	///
	/// This error code currently is relevant for frame grabbers only and might occur e.g.
	/// when selecting a <b>MEDIUM CameraLink&reg;</b> camera description for a grabber,
	/// that only supports <b>BASE</b> cameras.
	rrCameraNotSupported
};

//-----------------------------------------------------------------------------
/// \brief Defines valid RTCtrl Modes.
enum TRTCtrlModes
//-----------------------------------------------------------------------------
{
	/// \brief RTC switched off and editable.
	rtctrlModeStop,
	/// \brief RTC switched on and NOT editable.
	rtctrlModeRun
};

//-----------------------------------------------------------------------------
/// \brief Defines valid RTProg OpCodes.
enum TRTProgOpCodes
//-----------------------------------------------------------------------------
{
	/// \brief Do nothing.
	rtctrlProgNop,
	/// \brief Set digital outputs.
	rtctrlProgSetDigout,
	/// \brief Wait for digital inputs.
	rtctrlProgWaitDigin,
	/// \brief Wait for n clocks.
	rtctrlProgWaitClocks,
	/// \brief jump to location.
	rtctrlProgJumpLoc,
	/// \brief Set internal trigger signal to sensor controller.
	rtctrlProgTriggerSet,
	/// \brief Reset internal trigger signal to sensor controller.
	rtctrlProgTriggerReset,
	/// \brief Set internal expose signal to sensor controller.
	rtctrlProgExposeSet,
	/// \brief Reset internal expose signal to sensor controller.
	rtctrlProgExposeReset,
	/// \brief Reset internal sensor frame counter.
	rtctrlProgFrameNrReset
};

#ifndef IGNORE_MVGRABBER_SPECIFIC_DOCUMENTATION
	//-----------------------------------------------------------------------------
	/// \brief Analog grabbers generate its scan clock on different ways.
	enum TScanClock
	//-----------------------------------------------------------------------------
	{
		/// \brief The cameras clock signal is used.
		///
		/// If the property \a pixelClockOutput in the camera description is either set to
		///	<b>mvIMPACT::acquire::TCameraExternalSyncEdge::ceseFallingEdge</b> or
		/// <b>mvIMPACT::acquire::TCameraExternalSyncEdge::ceseRisingEdge</b>. 
		/// Otherwise <b>mvIMPACT::acquire::TScanClock::scAnalogue</b> is used for <b>mvTITAN-RGB</b>
		/// and <b>mvTITAN-G1</b> devices and <b>mvIMPACT::acquire::TScanClock::scDigital</b> for 
		/// <b>mvGAMMA-G</b> devices. Other devices currently do not support this feature.
		scAuto, 
		/// \brief The scan clock is generated by genlocking on horizontal sync.(HD) signal.
		///
		/// <b>ADVANTAGES:</b><br>
		/// - very small jitter (typically around some 100 pico seconds) -> suitable for high pixel clock (>20Mhz)
		/// - for matching HD freq. values (with respect to the signal send by the camera) this will produce 
		/// results almost as good as when working with an external clock signal(less scan artifacts)
		///
		/// <b>DISADVANTAGES:</b><br>
		/// - slow reaction time -> not suitable for fast channel switching
		/// - not suitable for signals with a pixel clock below 12 MHz
		scAnalogue, 
		/// \brief The scan clock is generated digitally.
		///
		/// <b>ADVANTAGE:</b><br>
		/// - locked after a single line, therefore this mode is very useful for fast channel switching
		///
		/// <b>DISADVANTAGE:</b><br>
		/// - bigger jitter as the analogue mode(<10ns), therefore not suitable for cameras with a pixel clock higher then about 20Mhz
		scDigital
	};

	//-----------------------------------------------------------------------------
	/// \brief There are different scan modes for standard cameras
	enum TScanStandard
	//-----------------------------------------------------------------------------
	{ 
		/// \brief 720 x 576 Pixels for 50 Hz standard cameras
		///		720 x 480 Pixels for 60 Hz standard cameras
		ssITU601,
		/// \brief 768 x 576 Pixels for 50 Hz standard cameras
		///		640 x 480 Pixels for 60 Hz standard cameras
		ssSquare,
		// \brief The user can define scanrate and camera AOI
		ssUser
	};
#endif // IGNORE_MVGRABBER_SPECIFIC_DOCUMENTATION

//-----------------------------------------------------------------------------
/// \brief Defines valid thread priorities.
enum TThreadPriority
//-----------------------------------------------------------------------------
{
    /// \brief Idle thread priority.
	tpIdle,
	/// \brief Lowest thread priority.
	tpLowest,
	/// \brief Below normal thread priority.
	tpBelowNormal,
	/// \brief Normal thread priority.
	tpNormal,
	/// \brief Above normal thread priority.
	tpAboveNormal,
	/// \brief Highest priority.
	tpHighest,
	/// \brief time critical thread priority.
	tpTimeCritical
};

//-----------------------------------------------------------------------------
/// \brief Defines valid flag for controlling the user access rights to the user
/// data that can be stored in the devices non-volatile memory.
enum TUserDataAccessRight
//-----------------------------------------------------------------------------
{
	/// \brief The user has read rights for this entry.
	udarRead = 0x1,
	/// \brief The user has principle write rights for this entry.
	///
	/// If <b>TUserDataAccessFlag::udarPassword</b> is not set for this entry or
	/// the corresponding password has been set correctly, the user can modify the
	/// corresponding entry.
	udarWrite = 0x2,
	/// \brief Just combines <b>TUserDataAccessFlag::udarRead</b> and <b>TUserDataAccessFlag::udarWrite</b>.
	udarRW = udarRead | udarWrite,
	/// \brief A password is needed to modify this entry.
	///
	/// Even if <b>TUserDataAccessFlag::udarWrite</b> is specified the user can only modify this entry
	/// if the correct password has been set.
	udarPassword = 0x4,
	/// \brief Combines all other flags.
	udarFull = udarRW | udarPassword
};

//-----------------------------------------------------------------------------
/// \brief There are different videostandards for cameras.
enum TVideoStandard
//-----------------------------------------------------------------------------
{ 
	/// \brief videosignal: grey, 50 fields per second, 625 lines
	vsCCIR,
	/// \brief videosignal: grey, 60 fields per second, 525 lines
	vsRS170,
	/// \brief videosignal: color, 50 fields per second, 625 lines
	vsPALBGH,
	/// \brief videosignal: color, 60 fields per second, 525 lines
	vsNTSCM
};

//-----------------------------------------------------------------------------
/// \brief Defines valid white balance calibration modes.
enum TWhiteBalanceCalibrationMode
//-----------------------------------------------------------------------------
{
	/// \brief Do not perform calibration, current values will be used.
	wbcmOff = 0,
	/// \brief Use the next image to perform the white balance calibration.
	///
	/// This is defined for bayer color sensors only.
	wbcmNextFrame,
	/// \brief Do a continuous white balance calibration.
	wbcmContinuous
};

//-----------------------------------------------------------------------------
/// \brief Defines valid parameter sets selectable via the \a WhiteBalance property.
enum TWhiteBalanceParameter
//-----------------------------------------------------------------------------
{
	/// \brief A set of constant parameters optimised for scenes illuminated by tungsten light sources.
	wbpTungsten = 0,
	/// \brief A set of constant parameters optimised for scenes illuminated by halogen light sources.
	wbpHalogen,
	/// \brief A set of constant parameters optimised for scenes illuminated by fluorescent light sources.
	wbpFluorescent,
	/// \brief A set of constant parameters optimised for scenes illuminated by day light.
	wbpDayLight,
	/// \brief A set of constant parameters optimised for scenes illuminated by photo flash light sources.
	wbpPhotoFlash,
	/// \brief A set of constant parameters optimised for scenes illuminated by day light and perfect weather.
	wbpBlueSky,
	/// \brief A parameter set which can be modified by the user.
	wbpUser1,
	/// \brief A parameter set which can be modified by the user.
	wbpUser2,
	/// \brief A parameter set which can be modified by the user.
	wbpUser3,
	/// \brief A parameter set which can be modified by the user.
	wbpUser4
};

#if !defined(DOXYGEN_SHOULD_SKIP_THIS) && !defined(WRAP_ANY)
	typedef enum TAcquisitionField TAcquisitionField;
	typedef enum TAdvancedImageInfo TAdvancedImageInfo;
	typedef enum TAoiMode TAoiMode;
	typedef enum TAutoControlSpeed TAutoControlSpeed;
	typedef enum TAutoExposureControl TAutoExposureControl;
	typedef enum TAutoGainControl TAutoGainControl;
	typedef enum TAutoOffsetCalibration TAutoOffsetCalibration;
	typedef enum TBayerMosaicParity TBayerMosaicParity;
	typedef enum TBayerWhiteBalanceResult TBayerWhiteBalanceResult;
	typedef enum TBlueFOXDigitalInputThreshold TBlueFOXDigitalInputThreshold;
	typedef enum TBlueFOXFooterMode TBlueFOXFooterMode;
	typedef enum TBlueFOXKernelDriver TBlueFOXKernelDriver;
	typedef enum TBlueFOXSensorTiming TBlueFOXSensorTiming;
	typedef enum TBlueFOXTransferSize TBlueFOXTransferSize;
	typedef enum TBlueLYNXCameraDataClipMode TBlueLYNXCameraDataClipMode;
	typedef enum TBlueLYNXCameraFlashMode TBlueLYNXCameraFlashMode;
	typedef enum TBlueLYNXCameraPixelClock TBlueLYNXCameraPixelClock;
	typedef enum TBlueLYNXCameraExposeMode TBlueLYNXCameraExposeMode;
	typedef enum TBlueLYNXCameraLineTriggerMode TBlueLYNXCameraLineTriggerMode;
	typedef enum TBlueLYNXVideoOutMode TBlueLYNXVideoOutMode;
	typedef enum TCameraAoiMode TCameraAoiMode;
	typedef enum TCameraBinningMode TCameraBinningMode;
	typedef enum TCameraDataFormat TCameraDataFormat;
	typedef enum TCameraExposeMode TCameraExposeMode;
	typedef enum TCameraExternalSyncEdge TCameraExternalSyncEdge;
	typedef enum TCameraExternalSyncOutput TCameraExternalSyncOutput;
	typedef enum TCameraFlashMode TCameraFlashMode;
	typedef enum TCameraInterlacedType TCameraInterlacedType;
	typedef enum TCameraLinkDataValidMode TCameraLinkDataValidMode;
	typedef enum TCameraOutput TCameraOutput;
	typedef enum TCameraPixelClock TCameraPixelClock;
	typedef enum TCameraScanMode TCameraScanMode;
	typedef enum TCameraSerialPortBaudRate TCameraSerialPortBaudRate;
	typedef enum TCameraTestMode TCameraTestMode;
	typedef enum TCameraTriggerMode TCameraTriggerMode;
	typedef enum TCameraTriggerSource TCameraTriggerSource;
	typedef enum TClampMode TClampMode;
	typedef enum TColorProcessingMode TColorProcessingMode;
	typedef enum TContinuousWhiteBalanceMode TContinuousWhiteBalanceMode;
	typedef enum TDarkCurrentFilterMode TDarkCurrentFilterMode;
	typedef enum TDefectivePixelsFilterMode TDefectivePixelsFilterMode;
	typedef enum TDeviceDigitalOutputMode TDeviceDigitalOutputMode;	
	typedef enum TDeviceImageTrigger TDeviceImageTrigger;
	typedef enum TDeviceLoadSettings TDeviceLoadSettings;
	typedef enum TDevicePowerMode TDevicePowerMode;
	typedef enum TDeviceScanRateMode TDeviceScanRateMode;
	typedef enum TDeviceSignalOutputStartEvent TDeviceSignalOutputStartEvent;
	typedef enum TDeviceState TDeviceState;
	typedef enum TDeviceSyncOutMode TDeviceSyncOutMode;
	typedef enum TDeviceTriggerMode TDeviceTriggerMode;
	typedef enum TDigIOState TDigIOState;
	typedef enum TDigitalOutputControlMode TDigitalOutputControlMode;
	typedef enum TDMR_ERROR TDMR_ERROR;
	typedef enum TFieldGateMode TFieldGateMode;
	typedef enum TFilterType TFilterType;
	typedef enum TFlatFieldFilterMode TFlatFieldFilterMode;
	typedef enum THWUpdateResult THWUpdateResult;
	typedef enum TImageBufferPixelFormat TImageBufferPixelFormat;
	typedef enum TImageDestinationPixelFormat TImageDestinationPixelFormat;
	typedef enum TImageProcessingFilter TImageProcessingFilter;
	typedef enum TImageRequestControlMode TImageRequestControlMode;
	typedef enum TImageResultConfiguration TImageResultConfiguration;
	typedef enum TInfoSensorColorMode TInfoSensorColorMode;
	typedef enum TInfoSensorColorPattern TInfoSensorColorPattern;
	typedef enum TInfoSensorType TInfoSensorType;
	typedef enum TInterlacedMode TInterlacedMode;
	typedef enum TLineCounter TLineCounter;
	typedef enum TMemManMode TMemManMode;
	typedef enum TMirrorMode TMirrorMode;
	typedef enum TNetworkProtocol TNetworkProtocol;
	typedef enum TOnBoardMemoryMode TOnBoardMemoryMode;
	typedef enum TPoolMode TPoolMode;
	typedef enum TRequestResult TRequestResult;
	typedef enum TRequestState TRequestState;
	typedef enum TRTCtrlModes TRTCtrlModes;
	typedef enum TRTProgOpCodes TRTProgOpCodes;
	typedef enum TScanClock TScanClock;
	typedef enum TScanStandard TScanStandard;
	typedef enum TThreadPriority TThreadPriority;
	typedef enum TUserDataAccessRight TUserDataAccessRight;
	typedef enum TVideoStandard TVideoStandard;
	typedef enum TWhiteBalanceCalibrationMode TWhiteBalanceCalibrationMode;
	typedef enum TWhiteBalanceParameter TWhiteBalanceParameter;
#endif // DOXYGEN_SHOULD_SKIP_THIS && WRAP_ANY

#ifdef WRAP_DOTNET
		} // namespace acquire
	} // namespace mvIMPACT
#endif // WRAP_DOTNET

#ifdef __cplusplus
	}
#endif // __cplusplus

// restore Borland compiler switch 'force enums to the size of integer'
#if !defined(DOXYGEN_SHOULD_SKIP_THIS) && !defined(WRAP_ANY)
#	ifdef _WIN32
#		ifdef __BORLANDC__
#			pragma option pop
#		endif // __BORLANDC__
#	endif // _WIN32
#endif // !defined(DOXYGEN_SHOULD_SKIP_THIS) && !defined(WRAP_ANY)

#endif // mvDriverBaseEnumsH

