#include "HGLibDeviceImpl.hpp"
#include "base/HGInc.h"
#include "base/HGInfo.h"
#include "base/HGImage.h"
#include "HGString.h"

struct DeviceParam
{
	DeviceParam()
	{
		valueType = 0;
		intValue = 0;
		doubleValue = 0;
		boolValue = false;

		rangeType = 0;
		intValueMin = 0;
		intValueMax = 0;
		doubleValueMin = 0;
		doubleValueMax = 0;
	}

	// ÅäÖÃÃû
	std::string title;

	int	valueType;
	std::string stringValue;
	int intValue;
	double doubleValue;
	bool boolValue;

	int rangeType;
	std::vector<std::string> stringValueList;
	std::vector<int> intValueList;
	std::vector<double> doubleValueList;
	int intValueMin;
	int intValueMax;
	double doubleValueMin;
	double doubleValueMax;
};

struct DeviceParamsGroup
{
	std::string groupName;
	std::vector<DeviceParam> devParams;
};

HGLibDeviceHotPlugEventFunc HGLibDeviceImpl::m_hotPlugEventFunc = NULL;
HGPointer HGLibDeviceImpl::m_hotPlugEventParam = NULL;
HGBool HGLibDeviceImpl::m_init = HGFALSE;
std::map<SANE_Handle, HGLibDeviceImpl*> HGLibDeviceImpl::m_deviceList;

HGLibDeviceImpl::HGLibDeviceImpl()
{
	m_devHandle = NULL;
	m_devName.clear();
	m_scanning = HGFALSE;
	m_scanEvent = NULL;
	m_eventFunc = NULL;
	m_eventParam = NULL;
	m_imageFunc = NULL;
	m_imageParam = NULL;
}

HGLibDeviceImpl::~HGLibDeviceImpl()
{

}

HGBool HGLibDeviceImpl::Init(HGLibDeviceHotPlugEventFunc func, HGPointer param)
{
	if (m_init)
	{
		return HGFALSE;
	}

	assert(NULL == m_hotPlugEventFunc);
	m_hotPlugEventFunc = func;
	m_hotPlugEventParam = param;

	SANE_Int version_code = 0;
	if (SANE_STATUS_GOOD != sane_init_ex(&version_code, sane_ex_callback, NULL))
	{
		m_hotPlugEventFunc = NULL;
		m_hotPlugEventParam = NULL;
		return HGFALSE;
	}

	m_init = HGTRUE;
	return HGTRUE;
}

HGBool HGLibDeviceImpl::Deinit()
{
	if (!m_init)
	{
		return HGFALSE;
	}

	if (!m_deviceList.empty())
	{
		return HGFALSE;
	}

	sane_exit();
	m_hotPlugEventFunc = NULL;
	m_hotPlugEventParam = NULL;
	m_init = HGFALSE;
	return HGTRUE;
}

HGChar** HGLibDeviceImpl::GetNameList()
{
	const SANE_Device **device = NULL;
	sane_get_devices(&device, SANE_TRUE);
	if (NULL == device)
	{
		return NULL;
	}

	std::vector<std::string> devNameList;

	const SANE_Device** p = device;
	while (NULL != *p)
	{
		devNameList.push_back((*p)->name);
		++p;
	}

	if (devNameList.empty())
	{
		return NULL;
	}

	HGChar** nameList = (HGChar **)malloc((devNameList.size() + 1) * sizeof(HGChar *));
	if (NULL != nameList)
	{
		nameList[devNameList.size()] = NULL;
		for (int i = 0; i < (int)devNameList.size(); ++i)
		{
			nameList[i] = (HGChar *)malloc(devNameList[i].size() + 1);
			if (NULL != nameList[i])
				strcpy(nameList[i], devNameList[i].c_str());
		}
	}

	return nameList;
}

HGBool HGLibDeviceImpl::ReleaseNameList(HGChar** deviceName)
{
	if (NULL == deviceName)
	{
		return HGFALSE;
	}

	HGChar** p = deviceName;
	while (0 != *p)
	{
		free(*p);
		++p;
	}

	free(deviceName);
	return HGTRUE;
}

HGLibDeviceImpl* HGLibDeviceImpl::Open(const HGChar* deviceName)
{
	SANE_Handle devHandle = NULL;
	sane_open(deviceName, &devHandle);
	if (NULL == devHandle)
	{
		return NULL;
	}

	HGLibDeviceImpl* deviceImpl = new HGLibDeviceImpl;
	deviceImpl->m_devHandle = devHandle;
	deviceImpl->m_devName = deviceName;
	m_deviceList[devHandle] = deviceImpl;
	return deviceImpl;
}

HGBool HGLibDeviceImpl::Close()
{
	assert(NULL != m_devHandle);
	assert(!m_devName.empty());

	StopScan();
	sane_close(m_devHandle);
	m_devHandle = NULL;
	m_devName.clear();

	std::map<SANE_Handle, HGLibDeviceImpl*>::iterator iter;
	for (iter = m_deviceList.begin(); iter != m_deviceList.end(); ++iter)
	{
		if (iter->second == this)
		{
			m_deviceList.erase(iter);
			break;
		}
	}

	delete this;
	return HGTRUE;
}

HGBool HGLibDeviceImpl::SetParam(const HGLibDeviceSetParam* param, HGUInt count)
{
	assert(NULL != m_devHandle);
	if (NULL == param || 0 == count)
		return HGFALSE;

	HGBool ret = HGTRUE;
	for (HGUInt i = 0; i < count; ++i)
	{
		if (NULL == param[i].title)
		{
			ret = HGFALSE;
			continue;
		}

		bool find = false;
		SANE_Int num_dev_options = 0;
		sane_control_option(m_devHandle, 0, SANE_ACTION_GET_VALUE, &num_dev_options, NULL);
		for (int j = 1; j < num_dev_options; ++j)
		{
			const SANE_Option_Descriptor* desp = sane_get_option_descriptor(m_devHandle, j);
			if (NULL == desp)
				continue;

			const char* title = desp->title;
			while (' ' == *title)
				++title;

			if (0 == strcmp(param[i].title, title))
			{
				if (SANE_TYPE_STRING == desp->type)
				{
					SANE_Char* value = param[i].stringValue;
					if (param[i].type != HGLIB_DEVPARAM_TYPE_STRING
						|| SANE_STATUS_GOOD != sane_control_option(m_devHandle, j, SANE_ACTION_SET_VALUE, value, NULL))
						ret = HGFALSE;
				}
				else if (SANE_TYPE_INT == desp->type)
				{
					SANE_Int value = param[i].intValue;
					if (param[i].type != HGLIB_DEVPARAM_TYPE_INT
						|| SANE_STATUS_GOOD != sane_control_option(m_devHandle, j, SANE_ACTION_SET_VALUE, &value, NULL))
						ret = HGFALSE;
				}
				else if (SANE_TYPE_FIXED == desp->type)
				{
					SANE_Fixed value = SANE_FIX(param[i].doubleValue);
					if (param[i].type != HGLIB_DEVPARAM_TYPE_DOUBLE
						|| SANE_STATUS_GOOD != sane_control_option(m_devHandle, j, SANE_ACTION_SET_VALUE, &value, NULL))
						ret = HGFALSE;
				}
				else if (SANE_TYPE_BOOL == desp->type)
				{
					SANE_Bool value = (SANE_Bool)param[i].boolValue;
					if (param[i].type != HGLIB_DEVPARAM_TYPE_BOOL
						|| SANE_STATUS_GOOD != sane_control_option(m_devHandle, j, SANE_ACTION_SET_VALUE, &value, NULL))
						ret = HGFALSE;
				}

				find = true;
				break;
			}
		}

		if (!find)
			ret = HGFALSE;
	}

	return ret;
}

HGBool HGLibDeviceImpl::SetParamEx(const HGChar* option, const HGVoid* data)
{
	assert(NULL != m_devHandle);
	if (NULL == option || NULL == data)
		return HGFALSE;

	HGBool ret = HGFALSE;
	SANE_Int num_dev_options = 0;
	sane_control_option(m_devHandle, 0, SANE_ACTION_GET_VALUE, &num_dev_options, NULL);
	for (int i = 1; i < num_dev_options; ++i)
	{
		const SANE_Option_Descriptor* desp = sane_get_option_descriptor(m_devHandle, i);
		if (NULL == desp)
			continue;

		const char* title = desp->title;
		while (' ' == *title)
			++title;

		if (0 == strcmp(option, title))
		{
			if (SANE_TYPE_STRING == desp->type)
			{
				SANE_Char* value = (SANE_Char*)(HGChar*)data;
				if (SANE_STATUS_GOOD == sane_control_option(m_devHandle, i, SANE_ACTION_SET_VALUE, value, NULL))
					ret = HGTRUE;
			}
			else if (SANE_TYPE_INT == desp->type)
			{
				SANE_Int value = (SANE_Int)(*(HGInt*)data);
				if (SANE_STATUS_GOOD != sane_control_option(m_devHandle, i, SANE_ACTION_SET_VALUE, &value, NULL))
					ret = HGTRUE;
			}
			else if (SANE_TYPE_FIXED == desp->type)
			{
				SANE_Fixed value = SANE_FIX(*(HGDouble*)data);
				if (SANE_STATUS_GOOD != sane_control_option(m_devHandle, i, SANE_ACTION_SET_VALUE, &value, NULL))
					ret = HGTRUE;
			}
			else if (SANE_TYPE_BOOL == desp->type)
			{
				SANE_Bool value = (SANE_Bool)(*(HGBool*)data);
				if (SANE_STATUS_GOOD != sane_control_option(m_devHandle, i, SANE_ACTION_SET_VALUE, &value, NULL))
					ret = HGTRUE;
			}

			break;
		}
	}

	return ret;
}

HGLibDeviceGetParamGroup* HGLibDeviceImpl::GetParamGroupList(HGUInt* count)
{
	assert(NULL != m_devHandle);
	if (NULL == count)
		return NULL;

	std::vector<DeviceParamsGroup> devParams;

	SANE_Int num_dev_options = 0;
	sane_control_option(m_devHandle, 0, SANE_ACTION_GET_VALUE, &num_dev_options, NULL);
	for (int i = 1; i < num_dev_options; ++i)
	{
		const SANE_Option_Descriptor* desp = sane_get_option_descriptor(m_devHandle, i);
		if (NULL == desp)
			continue;

		const char* title = desp->title;
		while (' ' == *title)
			++title;

		if (SANE_TYPE_GROUP == desp->type)
		{
			DeviceParamsGroup group;
			group.groupName = title;
			devParams.push_back(group);
		}
		else if (SANE_TYPE_STRING == desp->type)
		{
			char value[256] = { 0 };
			sane_control_option(m_devHandle, i, SANE_ACTION_GET_VALUE, value, NULL);

			DeviceParam devParam;
			devParam.title = title;
			devParam.valueType = HGLIB_DEVPARAM_TYPE_STRING;
			devParam.stringValue = value;

			assert(SANE_CONSTRAINT_STRING_LIST == desp->constraint_type);

			devParam.rangeType = HGLIB_DEVPARAM_RANGETYPE_STRINGLIST;
			const SANE_String_Const* p = desp->constraint.string_list;
			while (NULL != *p)
			{
				devParam.stringValueList.push_back(*p);
				++p;
			}

			assert(!devParams.empty());
			devParams[devParams.size() - 1].devParams.push_back(devParam);
		}
		else if (SANE_TYPE_INT == desp->type)
		{
			SANE_Int value = 0;
			sane_control_option(m_devHandle, i, SANE_ACTION_GET_VALUE, &value, NULL);

			DeviceParam devParam;
			devParam.title = title;
			devParam.valueType = HGLIB_DEVPARAM_TYPE_INT;
			devParam.intValue = (int)value;

			if (SANE_CONSTRAINT_WORD_LIST == desp->constraint_type)
			{
				devParam.rangeType = HGLIB_DEVPARAM_RANGETYPE_INTLIST;
				const SANE_Word* p = desp->constraint.word_list;
				for (SANE_Int i = 0; i < p[0]; ++i)
				{
					devParam.intValueList.push_back(p[i + 1]);
				}
			}
			else if (SANE_CONSTRAINT_RANGE == desp->constraint_type)
			{
				devParam.rangeType = HGLIB_DEVPARAM_RANGETYPE_INTRANGE;
				devParam.intValueMin = desp->constraint.range->min;
				devParam.intValueMax = desp->constraint.range->max;
			}

			assert(!devParams.empty());
			devParams[devParams.size() - 1].devParams.push_back(devParam);
		}
		else if (SANE_TYPE_FIXED == desp->type)
		{
			SANE_Word value = 0;
			sane_control_option(m_devHandle, i, SANE_ACTION_GET_VALUE, &value, NULL);

			DeviceParam devParam;
			devParam.title = title;
			devParam.valueType = HGLIB_DEVPARAM_TYPE_DOUBLE;
			devParam.doubleValue = SANE_UNFIX(value);

			if (SANE_CONSTRAINT_WORD_LIST == desp->constraint_type)
			{
				devParam.rangeType = HGLIB_DEVPARAM_RANGETYPE_DOUBLELIST;
				const SANE_Word* p = desp->constraint.word_list;
				for (SANE_Int i = 0; i < p[0]; ++i)
				{
					devParam.doubleValueList.push_back(SANE_UNFIX(p[i + 1]));
				}
			}
			else if (SANE_CONSTRAINT_RANGE == desp->constraint_type)
			{
				devParam.rangeType = HGLIB_DEVPARAM_RANGETYPE_DOUBLERANGE;
				devParam.doubleValueMin = SANE_UNFIX(desp->constraint.range->min);
				devParam.doubleValueMax = SANE_UNFIX(desp->constraint.range->max);
			}

			assert(!devParams.empty());
			devParams[devParams.size() - 1].devParams.push_back(devParam);
		}
		else if (SANE_TYPE_BOOL == desp->type)
		{
			SANE_Bool value = 0;
			sane_control_option(m_devHandle, i, SANE_ACTION_GET_VALUE, &value, NULL);

			DeviceParam devParam;
			devParam.title = title;
			devParam.valueType = HGLIB_DEVPARAM_TYPE_BOOL;
			devParam.boolValue = (bool)value;

			devParam.rangeType = HGLIB_DEVPARAM_RANGETYPE_NULL;

			assert(!devParams.empty());
			devParams[devParams.size() - 1].devParams.push_back(devParam);
		}
	}

	*count = (HGUInt)devParams.size();
	HGLibDeviceGetParamGroup* paramGroup = (HGLibDeviceGetParamGroup*)malloc((*count) * sizeof(HGLibDeviceGetParamGroup));
	if (NULL != paramGroup)
	{
		for (int i = 0; i < (int)devParams.size(); ++i)
		{
			paramGroup[i].groupName = (HGChar *)malloc(devParams[i].groupName.size() + 1);
			if (NULL != paramGroup[i].groupName)
				strcpy(paramGroup[i].groupName, devParams[i].groupName.c_str());

			paramGroup[i].paramCount = (HGUInt)devParams[i].devParams.size();
			paramGroup[i].param = (HGLibDeviceGetParam*)malloc(paramGroup[i].paramCount * sizeof(HGLibDeviceGetParam));
			if (NULL != paramGroup[i].param)
			{
				for (int j = 0; j < (int)devParams[i].devParams.size(); ++j)
				{
					HGLibDeviceGetParam& dest = paramGroup[i].param[j];
					DeviceParam& src = devParams[i].devParams[j];

					dest.param.title = (HGChar *)malloc(src.title.size() + 1);
					if (NULL != dest.param.title)
						strcpy(dest.param.title, src.title.c_str());

					dest.param.type = src.valueType;
					if (HGLIB_DEVPARAM_TYPE_INT == dest.param.type)
						dest.param.intValue = src.intValue;
					else if (HGLIB_DEVPARAM_TYPE_DOUBLE == dest.param.type)
						dest.param.doubleValue = src.doubleValue;
					else if (HGLIB_DEVPARAM_TYPE_BOOL == dest.param.type)
						dest.param.boolValue = (HGBool)src.boolValue;
					else if (HGLIB_DEVPARAM_TYPE_STRING == dest.param.type)
					{
						dest.param.stringValue = (HGChar *)malloc(src.stringValue.size() + 1);
						if (NULL != dest.param.stringValue)
							strcpy(dest.param.stringValue, src.stringValue.c_str());
					}

					dest.rangeType = src.rangeType;
					if (HGLIB_DEVPARAM_RANGETYPE_INTLIST == dest.rangeType)
					{
						dest.intValueList.count = (HGUInt)src.intValueList.size();
						dest.intValueList.value = (HGInt *)malloc(dest.intValueList.count * sizeof(HGInt));
						if (NULL != dest.intValueList.value)
						{
							for (int k = 0; k < (int)src.intValueList.size(); ++k)
							{
								dest.intValueList.value[k] = src.intValueList[k];
							}
						}
					}
					else if (HGLIB_DEVPARAM_RANGETYPE_DOUBLELIST == dest.rangeType)
					{
						dest.doubleValueList.count = (HGUInt)src.doubleValueList.size();
						dest.doubleValueList.value = (HGDouble*)malloc(dest.doubleValueList.count * sizeof(HGDouble));
						if (NULL != dest.doubleValueList.value)
						{
							for (int k = 0; k < (int)src.doubleValueList.size(); ++k)
							{
								dest.doubleValueList.value[k] = src.doubleValueList[k];
							}
						}
					}
					else if (HGLIB_DEVPARAM_RANGETYPE_INTRANGE == dest.rangeType)
					{
						dest.intValueRange.minValue = src.intValueMin;
						dest.intValueRange.maxValue = src.intValueMax;
					}
					else if (HGLIB_DEVPARAM_RANGETYPE_DOUBLERANGE == dest.rangeType)
					{
						dest.doubleValueRange.minValue = src.doubleValueMin;
						dest.doubleValueRange.maxValue = src.doubleValueMax;
					}
					else if (HGLIB_DEVPARAM_RANGETYPE_STRINGLIST == dest.rangeType)
					{
						dest.stringValueList.count = (HGUInt)src.stringValueList.size();
						dest.stringValueList.value = (HGChar **)malloc(dest.stringValueList.count * sizeof(HGChar *));
						if (NULL != dest.stringValueList.value)
						{
							for (int k = 0; k < (int)src.stringValueList.size(); ++k)
							{
								dest.stringValueList.value[k] = (HGChar *)malloc(src.stringValueList[k].size() + 1);
								if (NULL != dest.stringValueList.value[k])
									strcpy(dest.stringValueList.value[k], src.stringValueList[k].c_str());
							}
						}
					}
				}
			}
		}
	}

	return paramGroup;
}

HGLibDeviceGetParam* HGLibDeviceImpl::GetParam(const HGChar* option)
{
	assert(NULL != m_devHandle);
	if (NULL == option)
		return NULL;

	HGLibDeviceGetParam* param = NULL;
	SANE_Int num_dev_options = 0;
	sane_control_option(m_devHandle, 0, SANE_ACTION_GET_VALUE, &num_dev_options, NULL);
	for (int i = 1; i < num_dev_options; ++i)
	{
		const SANE_Option_Descriptor* desp = sane_get_option_descriptor(m_devHandle, i);
		if (NULL == desp)
			continue;

		const char* title = desp->title;
		while (' ' == *title)
			++title;

		if (0 == strcmp(option, title))
		{
			DeviceParam devParam;
			devParam.title = title;

			if (SANE_TYPE_STRING == desp->type)
			{
				char value[256] = { 0 };
				sane_control_option(m_devHandle, i, SANE_ACTION_GET_VALUE, value, NULL);

				devParam.valueType = HGLIB_DEVPARAM_TYPE_STRING;
				devParam.stringValue = value;

				assert(SANE_CONSTRAINT_STRING_LIST == desp->constraint_type);

				devParam.rangeType = HGLIB_DEVPARAM_RANGETYPE_STRINGLIST;
				const SANE_String_Const* p = desp->constraint.string_list;
				while (NULL != *p)
				{
					devParam.stringValueList.push_back(*p);
					++p;
				}
			}
			else if (SANE_TYPE_INT == desp->type)
			{
				SANE_Int value = 0;
				sane_control_option(m_devHandle, i, SANE_ACTION_GET_VALUE, &value, NULL);

				devParam.valueType = HGLIB_DEVPARAM_TYPE_INT;
				devParam.intValue = (int)value;

				if (SANE_CONSTRAINT_WORD_LIST == desp->constraint_type)
				{
					devParam.rangeType = HGLIB_DEVPARAM_RANGETYPE_INTLIST;
					const SANE_Word* p = desp->constraint.word_list;
					for (SANE_Int i = 0; i < p[0]; ++i)
					{
						devParam.intValueList.push_back(p[i + 1]);
					}
				}
				else if (SANE_CONSTRAINT_RANGE == desp->constraint_type)
				{
					devParam.rangeType = HGLIB_DEVPARAM_RANGETYPE_INTRANGE;
					devParam.intValueMin = desp->constraint.range->min;
					devParam.intValueMax = desp->constraint.range->max;
				}
			}
			else if (SANE_TYPE_FIXED == desp->type)
			{
				SANE_Word value = 0;
				sane_control_option(m_devHandle, i, SANE_ACTION_GET_VALUE, &value, NULL);

				devParam.valueType = HGLIB_DEVPARAM_TYPE_DOUBLE;
				devParam.doubleValue = SANE_UNFIX(value);

				if (SANE_CONSTRAINT_WORD_LIST == desp->constraint_type)
				{
					devParam.rangeType = HGLIB_DEVPARAM_RANGETYPE_DOUBLELIST;
					const SANE_Word* p = desp->constraint.word_list;
					for (SANE_Int i = 0; i < p[0]; ++i)
					{
						devParam.doubleValueList.push_back(SANE_UNFIX(p[i + 1]));
					}
				}
				else if (SANE_CONSTRAINT_RANGE == desp->constraint_type)
				{
					devParam.rangeType = HGLIB_DEVPARAM_RANGETYPE_DOUBLERANGE;
					devParam.doubleValueMin = SANE_UNFIX(desp->constraint.range->min);
					devParam.doubleValueMax = SANE_UNFIX(desp->constraint.range->max);
				}
			}
			else if (SANE_TYPE_BOOL == desp->type)
			{
				SANE_Bool value = 0;
				sane_control_option(m_devHandle, i, SANE_ACTION_GET_VALUE, &value, NULL);

				devParam.valueType = HGLIB_DEVPARAM_TYPE_BOOL;
				devParam.boolValue = (bool)value;
				devParam.rangeType = HGLIB_DEVPARAM_RANGETYPE_NULL;
			}

			assert(0 != devParam.valueType);
			param = (HGLibDeviceGetParam*)malloc(sizeof(HGLibDeviceGetParam));
			if (NULL != param)
			{
				param->param.title = (HGChar*)malloc(devParam.title.size() + 1);
				if (NULL != param->param.title)
					strcpy(param->param.title, devParam.title.c_str());

				param->param.type = devParam.valueType;
				if (HGLIB_DEVPARAM_TYPE_INT == param->param.type)
					param->param.intValue = devParam.intValue;
				else if (HGLIB_DEVPARAM_TYPE_DOUBLE == param->param.type)
					param->param.doubleValue = devParam.doubleValue;
				else if (HGLIB_DEVPARAM_TYPE_BOOL == param->param.type)
					param->param.boolValue = (HGBool)devParam.boolValue;
				else if (HGLIB_DEVPARAM_TYPE_STRING == param->param.type)
				{
					param->param.stringValue = (HGChar*)malloc(devParam.stringValue.size() + 1);
					if (NULL != param->param.stringValue)
						strcpy(param->param.stringValue, devParam.stringValue.c_str());
				}

				param->rangeType = devParam.rangeType;
				if (HGLIB_DEVPARAM_RANGETYPE_INTLIST == param->rangeType)
				{
					param->intValueList.count = (HGUInt)devParam.intValueList.size();
					param->intValueList.value = (HGInt*)malloc(param->intValueList.count * sizeof(HGInt));
					if (NULL != param->intValueList.value)
					{
						for (int k = 0; k < (int)devParam.intValueList.size(); ++k)
						{
							param->intValueList.value[k] = devParam.intValueList[k];
						}
					}
				}
				else if (HGLIB_DEVPARAM_RANGETYPE_DOUBLELIST == param->rangeType)
				{
					param->doubleValueList.count = (HGUInt)devParam.doubleValueList.size();
					param->doubleValueList.value = (HGDouble*)malloc(param->doubleValueList.count * sizeof(HGDouble));
					if (NULL != param->doubleValueList.value)
					{
						for (int k = 0; k < (int)devParam.doubleValueList.size(); ++k)
						{
							param->doubleValueList.value[k] = devParam.doubleValueList[k];
						}
					}
				}
				else if (HGLIB_DEVPARAM_RANGETYPE_INTRANGE == param->rangeType)
				{
					param->intValueRange.minValue = devParam.intValueMin;
					param->intValueRange.maxValue = devParam.intValueMax;
				}
				else if (HGLIB_DEVPARAM_RANGETYPE_DOUBLERANGE == param->rangeType)
				{
					param->doubleValueRange.minValue = devParam.doubleValueMin;
					param->doubleValueRange.maxValue = devParam.doubleValueMax;
				}
				else if (HGLIB_DEVPARAM_RANGETYPE_STRINGLIST == param->rangeType)
				{
					param->stringValueList.count = (HGUInt)devParam.stringValueList.size();
					param->stringValueList.value = (HGChar**)malloc(param->stringValueList.count * sizeof(HGChar*));
					if (NULL != param->stringValueList.value)
					{
						for (int k = 0; k < (int)devParam.stringValueList.size(); ++k)
						{
							param->stringValueList.value[k] = (HGChar*)malloc(devParam.stringValueList[k].size() + 1);
							if (NULL != param->stringValueList.value[k])
								strcpy(param->stringValueList.value[k], devParam.stringValueList[k].c_str());
						}
					}
				}
			}

			break;
		}
	}

	return param;
}

HGBool HGLibDeviceImpl::ReleaseParamGroupList(HGLibDeviceGetParamGroup* paramGroup, HGUInt count)
{
	if (NULL == paramGroup || 0 == count)
	{
		return HGFALSE;
	}

	for (HGUInt i = 0; i < count; ++i)
	{
		for (HGUInt j = 0; j < paramGroup[i].paramCount; ++j)
		{
			free(paramGroup[i].param[j].param.title);
			if (HGLIB_DEVPARAM_TYPE_STRING == paramGroup[i].param[j].param.type)
				free(paramGroup[i].param[j].param.stringValue);

			if (HGLIB_DEVPARAM_RANGETYPE_INTLIST == paramGroup[i].param[j].rangeType)
				free(paramGroup[i].param[j].intValueList.value);
			else if (HGLIB_DEVPARAM_RANGETYPE_DOUBLELIST == paramGroup[i].param[j].rangeType)
				free(paramGroup[i].param[j].doubleValueList.value);
			else if (HGLIB_DEVPARAM_RANGETYPE_STRINGLIST == paramGroup[i].param[j].rangeType)
			{
				for (HGUInt k = 0; k < paramGroup[i].param[j].stringValueList.count; ++k)
					free(paramGroup[i].param[j].stringValueList.value[k]);
				free(paramGroup[i].param[j].stringValueList.value);
			}
		}

		free(paramGroup[i].groupName);
		free(paramGroup[i].param);
	}

	free(paramGroup);
	return HGTRUE;
}

HGBool HGLibDeviceImpl::ReleaseParam(HGLibDeviceGetParam* param)
{
	if (NULL == param)
	{
		return HGFALSE;
	}

	free(param->param.title);
	if (HGLIB_DEVPARAM_TYPE_STRING == param->param.type)
		free(param->param.stringValue);

	if (HGLIB_DEVPARAM_RANGETYPE_INTLIST == param->rangeType)
		free(param->intValueList.value);
	else if (HGLIB_DEVPARAM_RANGETYPE_DOUBLELIST == param->rangeType)
		free(param->doubleValueList.value);
	else if (HGLIB_DEVPARAM_RANGETYPE_STRINGLIST == param->rangeType)
	{
		for (HGUInt k = 0; k < param->stringValueList.count; ++k)
			free(param->stringValueList.value[k]);
		free(param->stringValueList.value);
	}

	free(param);
	return HGTRUE;
}

HGBool HGLibDeviceImpl::ResetParam()
{
	assert(NULL != m_devHandle);

	HGBool ret = HGFALSE;

	SANE_Int num_dev_options = 0;
	sane_control_option(m_devHandle, 0, SANE_ACTION_GET_VALUE, &num_dev_options, NULL);
	for (int i = 1; i < num_dev_options; ++i)
	{
		const SANE_Option_Descriptor* desp = sane_get_option_descriptor(m_devHandle, i);
		if (NULL == desp)
			continue;

		const char* title = desp->title;
		while (' ' == *title)
			++title;

		if (0 == strcmp(OPTION_TITLE_HFMRSZ, title) && SANE_TYPE_BUTTON == desp->type)
		{
			if (SANE_STATUS_GOOD == sane_control_option(m_devHandle, i, SANE_ACTION_SET_VALUE, NULL, NULL))
				ret = HGTRUE;
			break;
		}
	}

	return ret;
}

HGBool HGLibDeviceImpl::StartScan(HGLibDeviceScanEventFunc eventFunc, HGPointer eventParam,
	HGLibDeviceScanImageFunc imageFunc, HGPointer imageParam)
{
	if (m_scanning)
	{
		return HGFALSE;
	}

	HGBase_CreateEvent(HGFALSE, HGFALSE, &m_scanEvent);
	assert(NULL != m_scanEvent);
	m_eventFunc = eventFunc;
	m_eventParam = eventParam;
	m_imageFunc = imageFunc;
	m_imageParam = imageParam;

	SANE_Status status = sane_start(m_devHandle);
	if (SANE_STATUS_GOOD != status)
	{
		m_eventFunc = NULL;
		m_eventParam = NULL;
		m_imageFunc = NULL;
		m_imageParam = NULL;
		HGBase_DestroyEvent(m_scanEvent);
		m_scanEvent = NULL;
		return HGFALSE;
	}

	m_scanning = HGTRUE;
	return HGTRUE;
}

HGBool HGLibDeviceImpl::StopScan()
{
	if (!m_scanning)
	{
		return HGFALSE;
	}

	sane_cancel(m_devHandle);

	assert(NULL != m_scanEvent);
	HGBase_WaitEvent(m_scanEvent);
	HGBase_DestroyEvent(m_scanEvent);
	m_scanEvent = NULL;

	m_eventFunc = NULL;
	m_eventParam = NULL;
	m_imageFunc = NULL;
	m_imageParam = NULL;

	m_scanning = HGFALSE;
	return HGTRUE;
}

int HGLibDeviceImpl::sane_ex_callback(SANE_Handle hdev, int code, void* data, unsigned int* len, void* param)
{
	switch (code)
	{
	case SANE_EVENT_DEVICE_ARRIVED:
	{
		SANE_Device* sane_dev = (SANE_Device*)data;
		HGBase_WriteInfo(HGBASE_INFOTYPE_DESC, "SANE_EVENT_DEVICE_ARRIVED, name=%s", Utf8ToStdString(sane_dev->name).c_str());

		if (NULL != m_hotPlugEventFunc)
			m_hotPlugEventFunc(HGLIB_DEVHOTPLUG_EVENT_ARRIVE, sane_dev->name, m_hotPlugEventParam);
	}
	break;
	case SANE_EVENT_DEVICE_LEFT:
	{
		SANE_Device* sane_dev = (SANE_Device*)data;
		HGBase_WriteInfo(HGBASE_INFOTYPE_DESC, "SANE_EVENT_DEVICE_LEFT, name=%s", Utf8ToStdString(sane_dev->name).c_str());

		if (NULL != m_hotPlugEventFunc)
			m_hotPlugEventFunc(HGLIB_DEVHOTPLUG_EVENT_REMOVE, sane_dev->name, m_hotPlugEventParam);
	}
	break;
	case SANE_EVENT_WORKING:
	{
		HGBase_WriteInfo(HGBASE_INFOTYPE_DESC, "SANE_EVENT_WORKING, msg=%s", Utf8ToStdString((char*)data).c_str());

		HGLibDeviceImpl* deviceImpl = m_deviceList[hdev];
		if (NULL != deviceImpl->m_eventFunc)
		{
			deviceImpl->m_eventFunc((HGLibDevice)deviceImpl, HGLIB_DEVSCAN_EVENT_BEGIN,
				HGFALSE, NULL, deviceImpl->m_eventParam);
			deviceImpl->m_eventFunc((HGLibDevice)deviceImpl, HGLIB_DEVSCAN_EVENT_INFO,
				HGFALSE, (const char*)data, deviceImpl->m_eventParam);
		}
	}
	break;
	case SANE_EVENT_SCAN_FINISHED:
	{
		HGBase_WriteInfo(HGBASE_INFOTYPE_DESC, "SANE_EVENT_SCAN_FINISHED, msg=%s", Utf8ToStdString((char*)data).c_str());

		HGLibDeviceImpl* deviceImpl = m_deviceList[hdev];
		if (NULL != deviceImpl->m_eventFunc)
		{
			deviceImpl->m_eventFunc((HGLibDevice)deviceImpl, HGLIB_DEVSCAN_EVENT_INFO, 
				(0 != *len), (const char*)data, deviceImpl->m_eventParam);
			deviceImpl->m_eventFunc((HGLibDevice)deviceImpl, HGLIB_DEVSCAN_EVENT_END,
				HGFALSE, NULL, deviceImpl->m_eventParam);
		}

		HGBase_SetEvent(deviceImpl->m_scanEvent);
	}
	break;
	case SANE_EVENT_STATUS:
	{
		HGBase_WriteInfo(HGBASE_INFOTYPE_DESC, "SANE_EVENT_STATUS, msg=%s", Utf8ToStdString((char*)data).c_str());	
	}
	break;
	case SANE_EVENT_ERROR:
	{
		HGBase_WriteInfo(HGBASE_INFOTYPE_DESC, "SANE_EVENT_ERROR, msg=%s", Utf8ToStdString((char*)data).c_str());	
	}
	break;
	case SANE_EVENT_IMAGE_OK:
	{
		HGBase_WriteInfo(HGBASE_INFOTYPE_DESC, "SANE_EVENT_IMAGE_OK");

		SANE_Image* sane_img = (SANE_Image*)data;

		HGLibDeviceImpl* deviceImpl = m_deviceList[hdev];
		if (NULL != deviceImpl->m_imageFunc)
		{
			HGUInt imgType = 0;
			if (sane_img->header.format == SANE_FRAME_GRAY)
			{
				if (1 == sane_img->header.depth)
					imgType = HGBASE_IMGTYPE_BINARY;
				else if (8 == sane_img->header.depth)
					imgType = HGBASE_IMGTYPE_GRAY;
			}
			else if (sane_img->header.format == SANE_FRAME_RGB)
				imgType = HGBASE_IMGTYPE_RGB;

			HGByte* data = sane_img->data;
			HGImageInfo imgInfo = { (HGUInt)sane_img->header.pixels_per_line, (HGUInt)sane_img->header.lines,
								   imgType, (HGUInt)sane_img->header.bytes_per_line, HGBASE_IMGORIGIN_TOP };

			HGImage img = NULL;
			HGBase_CreateImageFromData(data, &imgInfo, NULL, 0, HGBASE_IMGORIGIN_TOP, &img);
			if (NULL != img)
			{
				deviceImpl->m_imageFunc((HGLibDevice)deviceImpl, (HGLibImage)img, deviceImpl->m_imageParam);
				HGBase_DestroyImage(img);
			}
		}
	}
	break;
	}

	return 0;
}