973 lines
27 KiB
C++
973 lines
27 KiB
C++
#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;
|
|
} |