2022-05-03 10:25:52 +00:00
|
|
|
|
#include "HGSaneImpl.hpp"
|
|
|
|
|
#include "../base/HGInc.h"
|
|
|
|
|
|
|
|
|
|
HGSaneManagerImpl::HGSaneManagerImpl()
|
|
|
|
|
{
|
2023-04-03 09:13:53 +00:00
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGSaneManagerImpl::~HGSaneManagerImpl()
|
|
|
|
|
{
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGResult HGSaneManagerImpl::Create()
|
|
|
|
|
{
|
2023-04-04 03:42:27 +00:00
|
|
|
|
std::string archName;
|
|
|
|
|
FILE *file = popen("arch", "r");
|
|
|
|
|
if (NULL != file)
|
|
|
|
|
{
|
|
|
|
|
char str[256] = {0};
|
|
|
|
|
if (NULL != fgets(str, 256, file))
|
|
|
|
|
{
|
|
|
|
|
char *p = str;
|
|
|
|
|
while (0 != *p && '\n' != *p)
|
|
|
|
|
{
|
|
|
|
|
archName.push_back(*p);
|
|
|
|
|
++p;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pclose(file);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (archName.empty())
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
2023-04-04 03:17:09 +00:00
|
|
|
|
char manuPath[] = "/etc/sane.d/dll.d";
|
|
|
|
|
|
|
|
|
|
DIR* dir = opendir(manuPath);
|
|
|
|
|
if (NULL != dir)
|
|
|
|
|
{
|
|
|
|
|
struct dirent* dire = NULL;
|
|
|
|
|
while (dire = readdir(dir))
|
|
|
|
|
{
|
|
|
|
|
if (0 == strcmp(dire->d_name, ".") || 0 == strcmp(dire->d_name, ".."))
|
|
|
|
|
{
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
char fileName[256];
|
|
|
|
|
sprintf(fileName, "%s/%s", manuPath, dire->d_name);
|
|
|
|
|
|
|
|
|
|
struct stat filebuf;
|
|
|
|
|
lstat(fileName, &filebuf);
|
|
|
|
|
if (S_ISDIR(filebuf.st_mode))
|
|
|
|
|
{
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
std::string manuName;
|
|
|
|
|
FILE *file = fopen(fileName, "r");
|
|
|
|
|
if (NULL != file)
|
|
|
|
|
{
|
|
|
|
|
char str[256] = {0};
|
|
|
|
|
while (NULL != fgets(str, 256, file))
|
|
|
|
|
{
|
|
|
|
|
if ('#' == str[0] || '\n' == str[0])
|
|
|
|
|
{
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
char *p = str;
|
|
|
|
|
while (0 != *p && '\n' != *p)
|
|
|
|
|
{
|
|
|
|
|
manuName.push_back(*p);
|
|
|
|
|
++p;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fclose(file);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (manuName.empty())
|
|
|
|
|
{
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
std::pair<std::string, std::string> pr;
|
|
|
|
|
pr.first = manuName;
|
|
|
|
|
|
|
|
|
|
char sanePath[256];
|
2023-04-04 03:42:27 +00:00
|
|
|
|
sprintf(sanePath, "/usr/lib/%s-linux-gnu/sane/libsane-%s.so.1", archName.c_str(), manuName.c_str());
|
2023-04-04 03:17:09 +00:00
|
|
|
|
pr.second = sanePath;
|
|
|
|
|
|
|
|
|
|
m_vSource.push_back(pr);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
closedir(dir);
|
|
|
|
|
}
|
|
|
|
|
|
2023-04-03 09:13:53 +00:00
|
|
|
|
return HGBASE_ERR_OK;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGResult HGSaneManagerImpl::Destroy()
|
|
|
|
|
{
|
|
|
|
|
if (!m_listSourceImpl.empty())
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return HGBASE_ERR_OK;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGResult HGSaneManagerImpl::GetSourceCount(HGUInt *count)
|
|
|
|
|
{
|
|
|
|
|
if (NULL == count)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
*count = (HGUInt)m_vSource.size();
|
|
|
|
|
return HGBASE_ERR_OK;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGResult HGSaneManagerImpl::GetSourceName(HGUInt index, HGChar* name, HGUInt maxLen)
|
|
|
|
|
{
|
|
|
|
|
if (index >= (HGUInt)m_vSource.size() || NULL == name || 0 == maxLen)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (maxLen < m_vSource[index].first.size() + 1)
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
strcpy(name, m_vSource[index].first.c_str());
|
|
|
|
|
return HGBASE_ERR_OK;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGResult HGSaneManagerImpl::OpenSource(HGUInt index, class HGSaneSourceImpl **sourceImpl)
|
|
|
|
|
{
|
|
|
|
|
if (index >= (HGUInt)m_vSource.size() || NULL == sourceImpl)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGSaneSourceImpl *newSourceImpl = new HGSaneSourceImpl(this);
|
|
|
|
|
HGResult ret = newSourceImpl->Open(m_vSource[index].first.c_str(), m_vSource[index].second.c_str());
|
|
|
|
|
if (HGBASE_ERR_OK != ret)
|
|
|
|
|
{
|
|
|
|
|
delete newSourceImpl;
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
m_listSourceImpl.push_back(newSourceImpl);
|
|
|
|
|
*sourceImpl = newSourceImpl;
|
|
|
|
|
return HGBASE_ERR_OK;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGResult HGSaneManagerImpl::OpenSelectedSource(HGWindow parent, class HGSaneSourceImpl **sourceImpl)
|
|
|
|
|
{
|
|
|
|
|
if (NULL == sourceImpl)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
}
|
|
|
|
|
|
2023-04-04 03:17:09 +00:00
|
|
|
|
const char **manuNames = new const char *[m_vSource.size() + 1];
|
|
|
|
|
const char **sanePaths = new const char *[m_vSource.size() + 1];
|
|
|
|
|
for (int i = 0; i < (int)m_vSource.size(); ++i)
|
|
|
|
|
{
|
|
|
|
|
manuNames[i] = m_vSource[i].first.c_str();
|
|
|
|
|
sanePaths[i] = m_vSource[i].second.c_str();
|
|
|
|
|
}
|
|
|
|
|
manuNames[m_vSource.size()] = NULL;
|
|
|
|
|
sanePaths[m_vSource.size()] = NULL;
|
|
|
|
|
|
2023-04-03 09:13:53 +00:00
|
|
|
|
HGDll dll = NULL;
|
|
|
|
|
SANEAPI saneAPI;
|
2023-04-03 09:38:29 +00:00
|
|
|
|
char manuName[256];
|
2023-04-04 03:17:09 +00:00
|
|
|
|
if (-2 == show_srclist_ui(manuNames, sanePaths, parent, &dll, &saneAPI, manuName, 256))
|
2023-04-03 09:13:53 +00:00
|
|
|
|
{
|
2023-04-04 03:17:09 +00:00
|
|
|
|
delete [] sanePaths;
|
|
|
|
|
delete [] manuNames;
|
2023-04-03 09:13:53 +00:00
|
|
|
|
return HGBASE_ERR_NOTSUPPORT;
|
|
|
|
|
}
|
|
|
|
|
|
2023-04-04 03:17:09 +00:00
|
|
|
|
delete [] sanePaths;
|
|
|
|
|
delete [] manuNames;
|
|
|
|
|
|
2023-04-03 09:13:53 +00:00
|
|
|
|
if (NULL == dll)
|
|
|
|
|
{
|
|
|
|
|
return HGSANE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGSaneSourceImpl* newSourceImpl = new HGSaneSourceImpl(this);
|
2023-04-04 03:17:09 +00:00
|
|
|
|
HGResult ret = newSourceImpl->Init(manuName, dll, &saneAPI);
|
2023-04-03 09:13:53 +00:00
|
|
|
|
if (HGBASE_ERR_OK != ret)
|
|
|
|
|
{
|
|
|
|
|
delete newSourceImpl;
|
|
|
|
|
HGBase_DestroyDll(dll);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
m_listSourceImpl.push_back(newSourceImpl);
|
|
|
|
|
*sourceImpl = newSourceImpl;
|
|
|
|
|
return HGBASE_ERR_OK;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void HGSaneManagerImpl::RemoveSource(class HGSaneSourceImpl* sourceImpl)
|
|
|
|
|
{
|
|
|
|
|
std::list<class HGSaneSourceImpl*>::iterator iter;
|
|
|
|
|
for (iter = m_listSourceImpl.begin(); iter != m_listSourceImpl.end(); ++iter)
|
|
|
|
|
{
|
|
|
|
|
if (*iter == sourceImpl)
|
|
|
|
|
{
|
|
|
|
|
m_listSourceImpl.erase(iter);
|
|
|
|
|
delete sourceImpl;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
HGSaneSourceImpl::HGSaneSourceImpl(HGSaneManagerImpl *managerImpl)
|
|
|
|
|
{
|
|
|
|
|
m_managerImpl = managerImpl;
|
|
|
|
|
m_manuName.clear();
|
2022-05-03 10:25:52 +00:00
|
|
|
|
m_dll = NULL;
|
2023-03-28 10:38:35 +00:00
|
|
|
|
memset(&m_saneApi, 0, sizeof(SANEAPI));
|
2022-05-03 10:25:52 +00:00
|
|
|
|
}
|
|
|
|
|
|
2023-04-03 09:13:53 +00:00
|
|
|
|
HGSaneSourceImpl::~HGSaneSourceImpl()
|
2022-05-03 10:25:52 +00:00
|
|
|
|
{
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
2023-04-04 03:17:09 +00:00
|
|
|
|
HGResult HGSaneSourceImpl::Init(const HGChar* saneManu, HGDll dll, const SANEAPI *saneAPI)
|
2023-04-03 09:13:53 +00:00
|
|
|
|
{
|
|
|
|
|
assert(NULL == m_dll);
|
|
|
|
|
|
2023-04-04 03:17:09 +00:00
|
|
|
|
if (NULL == saneManu || 0 == *saneManu || NULL == dll || NULL == saneAPI)
|
2023-04-03 09:13:53 +00:00
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (NULL == saneAPI->sane_open_api || NULL == saneAPI->sane_close_api
|
|
|
|
|
|| NULL == saneAPI->sane_start_api || NULL == saneAPI->sane_read_api
|
|
|
|
|
|| NULL == saneAPI->sane_cancel_api || NULL == saneAPI->sane_get_devices_api
|
|
|
|
|
|| NULL == saneAPI->sane_get_option_descriptor_api || NULL == saneAPI->sane_control_option_api
|
2023-04-04 03:17:09 +00:00
|
|
|
|
|| NULL == saneAPI->sane_get_parameters_api || NULL == saneAPI->sane_set_io_mode_api
|
2023-05-29 09:04:55 +00:00
|
|
|
|
|| NULL == saneAPI->sane_strstatus_api
|
2023-04-04 03:17:09 +00:00
|
|
|
|
|| NULL == saneAPI->sane_init_api || NULL == saneAPI->sane_exit_api)
|
2023-04-03 09:13:53 +00:00
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
}
|
|
|
|
|
|
2023-04-04 03:17:09 +00:00
|
|
|
|
if (SANE_STATUS_GOOD != saneAPI->sane_init_api(NULL, NULL))
|
2023-04-03 09:13:53 +00:00
|
|
|
|
{
|
|
|
|
|
return HGSANE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
m_manuName = saneManu;
|
|
|
|
|
m_dll = dll;
|
|
|
|
|
memcpy(&m_saneApi, saneAPI, sizeof(SANEAPI));
|
|
|
|
|
return HGBASE_ERR_OK;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGResult HGSaneSourceImpl::Open(const HGChar* saneManu, const HGChar* sanePath)
|
2022-05-03 10:25:52 +00:00
|
|
|
|
{
|
2023-03-27 03:17:11 +00:00
|
|
|
|
assert(NULL == m_dll);
|
2022-05-03 10:25:52 +00:00
|
|
|
|
|
2023-04-04 03:17:09 +00:00
|
|
|
|
if (NULL == saneManu || 0 == *saneManu || NULL == sanePath || 0 == *sanePath)
|
2023-04-03 09:13:53 +00:00
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
}
|
|
|
|
|
|
2023-04-04 03:17:09 +00:00
|
|
|
|
HGDll dll = NULL;
|
|
|
|
|
HGResult ret = HGBase_CreateDll(sanePath, &dll);
|
2022-05-03 10:25:52 +00:00
|
|
|
|
if (HGBASE_ERR_OK != ret)
|
|
|
|
|
{
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2023-04-04 03:17:09 +00:00
|
|
|
|
SANEAPI saneAPI;
|
|
|
|
|
ret = FindFunctions(dll, saneManu, &saneAPI);
|
2022-05-03 10:25:52 +00:00
|
|
|
|
if (HGBASE_ERR_OK != ret)
|
|
|
|
|
{
|
2023-04-04 03:17:09 +00:00
|
|
|
|
HGBase_DestroyDll(dll);
|
|
|
|
|
dll = NULL;
|
2022-05-03 10:25:52 +00:00
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2023-04-04 03:17:09 +00:00
|
|
|
|
if (SANE_STATUS_GOOD != saneAPI.sane_init_api(NULL, NULL))
|
2022-05-03 10:25:52 +00:00
|
|
|
|
{
|
|
|
|
|
HGBase_DestroyDll(m_dll);
|
|
|
|
|
m_dll = NULL;
|
2023-03-25 07:31:09 +00:00
|
|
|
|
return HGSANE_ERR_FAIL;
|
2022-05-03 10:25:52 +00:00
|
|
|
|
}
|
|
|
|
|
|
2023-04-03 09:13:53 +00:00
|
|
|
|
m_manuName = saneManu;
|
2023-04-04 03:17:09 +00:00
|
|
|
|
m_dll = dll;
|
|
|
|
|
memcpy(&m_saneApi, &saneAPI, sizeof(SANEAPI));
|
2022-05-03 10:25:52 +00:00
|
|
|
|
return HGBASE_ERR_OK;
|
|
|
|
|
}
|
|
|
|
|
|
2023-04-03 09:13:53 +00:00
|
|
|
|
HGResult HGSaneSourceImpl::Close()
|
2022-05-03 10:25:52 +00:00
|
|
|
|
{
|
2023-03-27 03:17:11 +00:00
|
|
|
|
assert(NULL != m_dll);
|
|
|
|
|
|
2023-03-25 07:31:09 +00:00
|
|
|
|
if (!m_listDeviceImpl.empty())
|
2022-05-03 10:25:52 +00:00
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
2023-04-04 03:17:09 +00:00
|
|
|
|
m_saneApi.sane_exit_api();
|
2023-03-27 03:17:11 +00:00
|
|
|
|
HGBase_DestroyDll(m_dll);
|
|
|
|
|
m_dll = NULL;
|
2023-04-03 09:13:53 +00:00
|
|
|
|
m_managerImpl->RemoveSource(this);
|
2022-05-03 10:25:52 +00:00
|
|
|
|
return HGBASE_ERR_OK;
|
|
|
|
|
}
|
|
|
|
|
|
2023-04-03 09:13:53 +00:00
|
|
|
|
HGResult HGSaneSourceImpl::GetName(HGChar* name, HGUInt maxLen)
|
|
|
|
|
{
|
|
|
|
|
if (NULL == name || 0 == maxLen)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (maxLen < m_manuName.size() + 1)
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
strcpy(name, m_manuName.c_str());
|
|
|
|
|
return HGBASE_ERR_OK;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGResult HGSaneSourceImpl::GetDeviceCount(HGUInt* count)
|
2022-05-03 10:25:52 +00:00
|
|
|
|
{
|
|
|
|
|
if (NULL == count)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
}
|
|
|
|
|
|
2023-03-25 07:31:09 +00:00
|
|
|
|
const SANE_Device** device_list;
|
2023-04-03 09:13:53 +00:00
|
|
|
|
if (SANE_STATUS_GOOD != m_saneApi.sane_get_devices_api(&device_list, SANE_TRUE))
|
2022-05-03 10:25:52 +00:00
|
|
|
|
{
|
2023-03-25 07:31:09 +00:00
|
|
|
|
return HGSANE_ERR_FAIL;
|
2022-05-03 10:25:52 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
*count = 0;
|
|
|
|
|
const SANE_Device** p;
|
|
|
|
|
for (p = device_list; *p != NULL; ++p)
|
|
|
|
|
++(*count);
|
|
|
|
|
|
|
|
|
|
return HGBASE_ERR_OK;
|
|
|
|
|
}
|
|
|
|
|
|
2023-04-03 09:13:53 +00:00
|
|
|
|
HGResult HGSaneSourceImpl::GetDeviceName(HGUInt index, HGChar* name, HGUInt maxLen)
|
2022-05-03 10:25:52 +00:00
|
|
|
|
{
|
|
|
|
|
if (NULL == name || 0 == maxLen)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const SANE_Device** device_list;
|
2023-04-03 09:13:53 +00:00
|
|
|
|
if (SANE_STATUS_GOOD != m_saneApi.sane_get_devices_api(&device_list, SANE_TRUE))
|
2022-05-03 10:25:52 +00:00
|
|
|
|
{
|
2023-03-25 07:31:09 +00:00
|
|
|
|
return HGSANE_ERR_FAIL;
|
2022-05-03 10:25:52 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGUInt count = 0;
|
|
|
|
|
const SANE_Device** p;
|
|
|
|
|
for (p = device_list; *p != NULL; ++p)
|
|
|
|
|
++count;
|
|
|
|
|
|
|
|
|
|
if (index >= count)
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
|
|
|
|
|
if (NULL == device_list[index]->name)
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
if (maxLen < strlen(device_list[index]->name) + 1)
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
strcpy(name, device_list[index]->name);
|
|
|
|
|
return HGBASE_ERR_OK;
|
|
|
|
|
}
|
|
|
|
|
|
2023-04-03 09:13:53 +00:00
|
|
|
|
HGResult HGSaneSourceImpl::OpenDevice(HGUInt index, HGSaneDeviceImpl** deviceImpl, HGChar* errInfo, HGUInt errInfoLen)
|
2022-05-03 10:25:52 +00:00
|
|
|
|
{
|
2023-03-25 07:31:09 +00:00
|
|
|
|
if (NULL == deviceImpl)
|
2022-05-03 10:25:52 +00:00
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const SANE_Device** device_list;
|
2023-04-03 09:13:53 +00:00
|
|
|
|
if (SANE_STATUS_GOOD != m_saneApi.sane_get_devices_api(&device_list, SANE_TRUE))
|
2022-05-03 10:25:52 +00:00
|
|
|
|
{
|
2023-03-25 07:31:09 +00:00
|
|
|
|
return HGSANE_ERR_FAIL;
|
2022-05-03 10:25:52 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGUInt count = 0;
|
|
|
|
|
const SANE_Device** p;
|
|
|
|
|
for (p = device_list; *p != NULL; ++p)
|
|
|
|
|
++count;
|
|
|
|
|
|
|
|
|
|
if (index >= count)
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
|
2023-03-25 07:31:09 +00:00
|
|
|
|
HGSaneDeviceImpl* newDeviceImpl = new HGSaneDeviceImpl(this);
|
|
|
|
|
HGResult ret = newDeviceImpl->Open(device_list[index]->name, errInfo, errInfoLen);
|
|
|
|
|
if (HGBASE_ERR_OK != ret)
|
2022-05-03 10:25:52 +00:00
|
|
|
|
{
|
2023-03-25 07:31:09 +00:00
|
|
|
|
delete newDeviceImpl;
|
|
|
|
|
return ret;
|
2022-05-03 10:25:52 +00:00
|
|
|
|
}
|
|
|
|
|
|
2023-03-25 07:31:09 +00:00
|
|
|
|
m_listDeviceImpl.push_back(newDeviceImpl);
|
|
|
|
|
*deviceImpl = newDeviceImpl;
|
2022-05-03 10:25:52 +00:00
|
|
|
|
return HGBASE_ERR_OK;
|
|
|
|
|
}
|
|
|
|
|
|
2023-04-03 09:13:53 +00:00
|
|
|
|
HGResult HGSaneSourceImpl::OpenSelectedDevice(HGWindow parent, class HGSaneDeviceImpl** deviceImpl)
|
2023-03-28 09:29:47 +00:00
|
|
|
|
{
|
|
|
|
|
if (NULL == deviceImpl)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
}
|
|
|
|
|
|
2023-03-29 08:16:19 +00:00
|
|
|
|
SANE_Handle handle = NULL;
|
|
|
|
|
char devName[256] = {0};
|
2023-04-12 05:29:52 +00:00
|
|
|
|
if (-2 == show_devlist_ui(&m_saneApi, NULL, parent, &handle, devName, 256))
|
2023-03-29 08:16:19 +00:00
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_NOTSUPPORT;
|
|
|
|
|
}
|
|
|
|
|
|
2023-03-28 09:29:47 +00:00
|
|
|
|
if (NULL == handle)
|
|
|
|
|
{
|
|
|
|
|
return HGSANE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGSaneDeviceImpl* newDeviceImpl = new HGSaneDeviceImpl(this);
|
2023-03-29 08:16:19 +00:00
|
|
|
|
HGResult ret = newDeviceImpl->Init(devName, handle);
|
2023-03-28 09:29:47 +00:00
|
|
|
|
if (HGBASE_ERR_OK != ret)
|
|
|
|
|
{
|
|
|
|
|
delete newDeviceImpl;
|
2023-04-03 09:13:53 +00:00
|
|
|
|
m_saneApi.sane_close_api(handle);
|
2023-03-28 09:29:47 +00:00
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
m_listDeviceImpl.push_back(newDeviceImpl);
|
|
|
|
|
*deviceImpl = newDeviceImpl;
|
|
|
|
|
return HGBASE_ERR_OK;
|
|
|
|
|
}
|
|
|
|
|
|
2023-04-04 03:17:09 +00:00
|
|
|
|
HGResult HGSaneSourceImpl::FindFunctions(HGDll dll, const HGChar* saneManu, SANEAPI *saneAPI)
|
2022-05-03 10:25:52 +00:00
|
|
|
|
{
|
2023-03-25 07:31:09 +00:00
|
|
|
|
HGResult ret = HGBASE_ERR_OK;
|
|
|
|
|
|
|
|
|
|
do
|
2022-05-03 10:25:52 +00:00
|
|
|
|
{
|
2023-04-03 09:13:53 +00:00
|
|
|
|
HGChar funcName[256];
|
|
|
|
|
|
|
|
|
|
sprintf(funcName, "sane_%s_init", saneManu);
|
2023-04-04 03:17:09 +00:00
|
|
|
|
ret = HGBase_GetDllProcAddress(dll, funcName, (HGPointer*)&saneAPI->sane_init_api);
|
2023-03-25 07:31:09 +00:00
|
|
|
|
if (HGBASE_ERR_OK != ret)
|
|
|
|
|
break;
|
|
|
|
|
|
2023-04-03 09:13:53 +00:00
|
|
|
|
sprintf(funcName, "sane_%s_exit", saneManu);
|
2023-04-04 03:17:09 +00:00
|
|
|
|
ret = HGBase_GetDllProcAddress(dll, funcName, (HGPointer*)&saneAPI->sane_exit_api);
|
2023-03-25 07:31:09 +00:00
|
|
|
|
if (HGBASE_ERR_OK != ret)
|
|
|
|
|
break;
|
|
|
|
|
|
2023-04-03 09:13:53 +00:00
|
|
|
|
sprintf(funcName, "sane_%s_get_devices", saneManu);
|
2023-04-04 03:17:09 +00:00
|
|
|
|
ret = HGBase_GetDllProcAddress(dll, funcName, (HGPointer*)&saneAPI->sane_get_devices_api);
|
2023-03-25 07:31:09 +00:00
|
|
|
|
if (HGBASE_ERR_OK != ret)
|
|
|
|
|
break;
|
|
|
|
|
|
2023-04-03 09:13:53 +00:00
|
|
|
|
sprintf(funcName, "sane_%s_open", saneManu);
|
2023-04-04 03:17:09 +00:00
|
|
|
|
ret = HGBase_GetDllProcAddress(dll, funcName, (HGPointer*)&saneAPI->sane_open_api);
|
2023-03-25 07:31:09 +00:00
|
|
|
|
if (HGBASE_ERR_OK != ret)
|
|
|
|
|
break;
|
|
|
|
|
|
2023-04-03 09:13:53 +00:00
|
|
|
|
sprintf(funcName, "sane_%s_close", saneManu);
|
2023-04-04 03:17:09 +00:00
|
|
|
|
ret = HGBase_GetDllProcAddress(dll, funcName, (HGPointer*)&saneAPI->sane_close_api);
|
2023-03-25 07:31:09 +00:00
|
|
|
|
if (HGBASE_ERR_OK != ret)
|
|
|
|
|
break;
|
|
|
|
|
|
2023-04-03 09:13:53 +00:00
|
|
|
|
sprintf(funcName, "sane_%s_start", saneManu);
|
2023-04-04 03:17:09 +00:00
|
|
|
|
ret = HGBase_GetDllProcAddress(dll, funcName, (HGPointer*)&saneAPI->sane_start_api);
|
2023-03-25 07:31:09 +00:00
|
|
|
|
if (HGBASE_ERR_OK != ret)
|
|
|
|
|
break;
|
2022-05-03 10:25:52 +00:00
|
|
|
|
|
2023-04-03 09:13:53 +00:00
|
|
|
|
sprintf(funcName, "sane_%s_read", saneManu);
|
2023-04-04 03:17:09 +00:00
|
|
|
|
ret = HGBase_GetDllProcAddress(dll, funcName, (HGPointer*)&saneAPI->sane_read_api);
|
2023-03-25 07:31:09 +00:00
|
|
|
|
if (HGBASE_ERR_OK != ret)
|
|
|
|
|
break;
|
|
|
|
|
|
2023-04-03 09:13:53 +00:00
|
|
|
|
sprintf(funcName, "sane_%s_cancel", saneManu);
|
2023-04-04 03:17:09 +00:00
|
|
|
|
ret = HGBase_GetDllProcAddress(dll, funcName, (HGPointer*)&saneAPI->sane_cancel_api);
|
2023-03-25 07:31:09 +00:00
|
|
|
|
if (HGBASE_ERR_OK != ret)
|
|
|
|
|
break;
|
|
|
|
|
|
2023-04-03 09:13:53 +00:00
|
|
|
|
sprintf(funcName, "sane_%s_set_io_mode", saneManu);
|
2023-04-04 03:17:09 +00:00
|
|
|
|
ret = HGBase_GetDllProcAddress(dll, funcName, (HGPointer*)&saneAPI->sane_set_io_mode_api);
|
2023-03-25 07:31:09 +00:00
|
|
|
|
if (HGBASE_ERR_OK != ret)
|
|
|
|
|
break;
|
|
|
|
|
|
2023-04-03 09:13:53 +00:00
|
|
|
|
sprintf(funcName, "sane_%s_strstatus", saneManu);
|
2023-04-04 03:17:09 +00:00
|
|
|
|
ret = HGBase_GetDllProcAddress(dll, funcName, (HGPointer*)&saneAPI->sane_strstatus_api);
|
2023-03-25 07:31:09 +00:00
|
|
|
|
if (HGBASE_ERR_OK != ret)
|
|
|
|
|
break;
|
|
|
|
|
|
2023-04-03 09:13:53 +00:00
|
|
|
|
sprintf(funcName, "sane_%s_get_parameters", saneManu);
|
2023-04-04 03:17:09 +00:00
|
|
|
|
ret = HGBase_GetDllProcAddress(dll, funcName, (HGPointer*)&saneAPI->sane_get_parameters_api);
|
2023-03-25 07:31:09 +00:00
|
|
|
|
if (HGBASE_ERR_OK != ret)
|
|
|
|
|
break;
|
|
|
|
|
|
2023-04-03 09:13:53 +00:00
|
|
|
|
sprintf(funcName, "sane_%s_get_option_descriptor", saneManu);
|
2023-04-04 03:17:09 +00:00
|
|
|
|
ret = HGBase_GetDllProcAddress(dll, funcName, (HGPointer*)&saneAPI->sane_get_option_descriptor_api);
|
2023-03-25 07:31:09 +00:00
|
|
|
|
if (HGBASE_ERR_OK != ret)
|
|
|
|
|
break;
|
|
|
|
|
|
2023-04-03 09:13:53 +00:00
|
|
|
|
sprintf(funcName, "sane_%s_control_option", saneManu);
|
2023-04-04 03:17:09 +00:00
|
|
|
|
ret = HGBase_GetDllProcAddress(dll, funcName, (HGPointer*)&saneAPI->sane_control_option_api);
|
2023-03-25 07:31:09 +00:00
|
|
|
|
if (HGBASE_ERR_OK != ret)
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
} while (0);
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2023-04-03 09:13:53 +00:00
|
|
|
|
void HGSaneSourceImpl::RemoveDevice(class HGSaneDeviceImpl* deviceImpl)
|
2023-03-25 07:31:09 +00:00
|
|
|
|
{
|
|
|
|
|
std::list<class HGSaneDeviceImpl*>::iterator iter;
|
|
|
|
|
for (iter = m_listDeviceImpl.begin(); iter != m_listDeviceImpl.end(); ++iter)
|
2022-05-03 10:25:52 +00:00
|
|
|
|
{
|
2023-03-25 07:31:09 +00:00
|
|
|
|
if (*iter == deviceImpl)
|
2022-05-03 10:25:52 +00:00
|
|
|
|
{
|
2023-03-25 07:31:09 +00:00
|
|
|
|
m_listDeviceImpl.erase(iter);
|
|
|
|
|
delete deviceImpl;
|
2022-05-03 10:25:52 +00:00
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
2023-03-25 07:31:09 +00:00
|
|
|
|
}
|
2022-05-03 10:25:52 +00:00
|
|
|
|
|
2023-03-25 07:31:09 +00:00
|
|
|
|
|
2023-04-03 09:13:53 +00:00
|
|
|
|
HGSaneDeviceImpl::HGSaneDeviceImpl(HGSaneSourceImpl* sourceImpl)
|
2023-03-25 07:31:09 +00:00
|
|
|
|
{
|
2023-04-03 09:13:53 +00:00
|
|
|
|
m_sourceImpl = sourceImpl;
|
2023-03-29 08:16:19 +00:00
|
|
|
|
m_devName.clear();
|
2023-03-25 07:31:09 +00:00
|
|
|
|
m_devHandle = NULL;
|
|
|
|
|
m_buffer = NULL;
|
|
|
|
|
m_bufferSize = 0;
|
|
|
|
|
m_dpi = 0;
|
|
|
|
|
m_eventFunc = NULL;
|
|
|
|
|
m_eventParam = NULL;
|
|
|
|
|
m_imageFunc = NULL;
|
|
|
|
|
m_imageParam = NULL;
|
2022-05-03 10:25:52 +00:00
|
|
|
|
}
|
|
|
|
|
|
2023-03-25 07:31:09 +00:00
|
|
|
|
HGSaneDeviceImpl::~HGSaneDeviceImpl()
|
2022-05-03 10:25:52 +00:00
|
|
|
|
{
|
2023-03-25 07:31:09 +00:00
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
2023-03-29 08:16:19 +00:00
|
|
|
|
HGResult HGSaneDeviceImpl::Init(const HGChar* devName, SANE_Handle handle)
|
2023-03-28 09:29:47 +00:00
|
|
|
|
{
|
|
|
|
|
assert(NULL == m_devHandle);
|
|
|
|
|
|
2023-03-29 08:16:19 +00:00
|
|
|
|
if (NULL == devName || NULL == handle)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
m_devName = devName;
|
2023-04-03 09:13:53 +00:00
|
|
|
|
m_sourceImpl->m_saneApi.sane_set_io_mode_api(handle, SANE_FALSE);
|
2023-03-28 09:29:47 +00:00
|
|
|
|
m_devHandle = handle;
|
|
|
|
|
return HGBASE_ERR_OK;
|
|
|
|
|
}
|
|
|
|
|
|
2023-03-25 07:31:09 +00:00
|
|
|
|
HGResult HGSaneDeviceImpl::Open(const HGChar* devName, HGChar* errInfo, HGUInt errInfoLen)
|
|
|
|
|
{
|
2023-03-27 03:17:11 +00:00
|
|
|
|
assert(NULL == m_devHandle);
|
2022-05-03 10:25:52 +00:00
|
|
|
|
|
2023-03-25 07:31:09 +00:00
|
|
|
|
if (NULL == devName)
|
2022-05-03 10:25:52 +00:00
|
|
|
|
{
|
2023-03-25 07:31:09 +00:00
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
2022-05-03 10:25:52 +00:00
|
|
|
|
}
|
|
|
|
|
|
2023-03-25 07:31:09 +00:00
|
|
|
|
SANE_Handle handle = NULL;
|
2023-04-03 09:13:53 +00:00
|
|
|
|
SANE_Status stat = m_sourceImpl->m_saneApi.sane_open_api(devName, &handle);
|
2023-03-25 07:31:09 +00:00
|
|
|
|
if (SANE_STATUS_GOOD != stat)
|
2022-05-03 10:25:52 +00:00
|
|
|
|
{
|
2023-03-25 07:31:09 +00:00
|
|
|
|
if (NULL != errInfo)
|
|
|
|
|
{
|
2023-04-03 09:13:53 +00:00
|
|
|
|
const char* err = m_sourceImpl->m_saneApi.sane_strstatus_api(stat);
|
2023-03-25 07:31:09 +00:00
|
|
|
|
if (NULL != err && errInfoLen >= strlen(err) + 1)
|
|
|
|
|
{
|
|
|
|
|
strcpy(errInfo, err);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return HGSANE_ERR_FAIL;
|
2022-05-03 10:25:52 +00:00
|
|
|
|
}
|
|
|
|
|
|
2023-03-29 08:16:19 +00:00
|
|
|
|
m_devName = devName;
|
2023-04-03 09:13:53 +00:00
|
|
|
|
m_sourceImpl->m_saneApi.sane_set_io_mode_api(handle, SANE_FALSE);
|
2023-03-25 07:31:09 +00:00
|
|
|
|
m_devHandle = handle;
|
2022-05-03 10:25:52 +00:00
|
|
|
|
return HGBASE_ERR_OK;
|
|
|
|
|
}
|
|
|
|
|
|
2023-03-25 07:31:09 +00:00
|
|
|
|
HGResult HGSaneDeviceImpl::Close()
|
2022-05-03 10:25:52 +00:00
|
|
|
|
{
|
2023-03-27 03:17:11 +00:00
|
|
|
|
assert(NULL != m_devHandle);
|
2022-05-03 10:25:52 +00:00
|
|
|
|
|
2023-04-03 09:13:53 +00:00
|
|
|
|
m_sourceImpl->m_saneApi.sane_close_api(m_devHandle);
|
2023-03-25 07:31:09 +00:00
|
|
|
|
m_devHandle = NULL;
|
2023-03-29 08:16:19 +00:00
|
|
|
|
m_devName.clear();
|
2023-04-03 09:13:53 +00:00
|
|
|
|
m_sourceImpl->RemoveDevice(this);
|
2022-05-03 10:25:52 +00:00
|
|
|
|
return HGBASE_ERR_OK;
|
|
|
|
|
}
|
|
|
|
|
|
2023-03-29 08:16:19 +00:00
|
|
|
|
HGResult HGSaneDeviceImpl::GetName(HGChar* name, HGUInt maxLen)
|
|
|
|
|
{
|
|
|
|
|
if (NULL == name || 0 == maxLen)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (maxLen < m_devName.size() + 1)
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
strcpy(name, m_devName.c_str());
|
|
|
|
|
return HGBASE_ERR_OK;
|
|
|
|
|
}
|
|
|
|
|
|
2023-05-16 02:22:33 +00:00
|
|
|
|
HGResult HGSaneDeviceImpl::GetCustomInfo(HGSaneDeviceCustomInfo *info)
|
2023-04-07 06:18:56 +00:00
|
|
|
|
{
|
2023-04-07 07:08:56 +00:00
|
|
|
|
if (NULL == info)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
}
|
|
|
|
|
|
2023-05-16 02:22:33 +00:00
|
|
|
|
memset(info, 0, sizeof(HGSaneDeviceCustomInfo));
|
|
|
|
|
|
|
|
|
|
GetValueInt32(0x8852, &info->vid);
|
|
|
|
|
GetValueInt32(0x8853, &info->pid);
|
2023-05-16 03:54:22 +00:00
|
|
|
|
GetValueStr256(0x8856, info->sn, 32);
|
2023-05-16 02:22:33 +00:00
|
|
|
|
GetValueStr256(0x8855, info->type, 32);
|
2023-05-16 03:54:22 +00:00
|
|
|
|
GetValueStr256(0x8857, info->fwVer, 32);
|
|
|
|
|
GetValueStr256(0x8858, info->ip, 32);
|
|
|
|
|
GetValueStr256(0x8859, info->mac, 32);
|
2023-05-16 02:22:33 +00:00
|
|
|
|
GetValueStr256(0x884A, info->driverVer, 32);
|
|
|
|
|
GetValueStr256(0x884B, info->vendor, 32);
|
|
|
|
|
GetValueStr256(0x884C, info->copyright, 32);
|
|
|
|
|
GetValueStr256(0x884D, info->comUrl, 128);
|
|
|
|
|
GetValueStr256(0x884E, info->comTel, 32);
|
|
|
|
|
GetValueStr256(0x884F, info->comAddr, 256);
|
|
|
|
|
GetValueStr256(0x8850, info->comGps, 256);
|
|
|
|
|
GetValueInt32(0x9902, &info->rollerCount);
|
|
|
|
|
GetValueInt32(0x8849, &info->totalCount);
|
2023-04-07 07:08:56 +00:00
|
|
|
|
|
|
|
|
|
return HGBASE_ERR_OK;
|
2023-04-07 06:18:56 +00:00
|
|
|
|
}
|
|
|
|
|
|
2023-05-16 02:22:33 +00:00
|
|
|
|
HGResult HGSaneDeviceImpl::Login(const HGChar *user, const HGChar *pwd)
|
|
|
|
|
{
|
|
|
|
|
if (NULL == user || strlen(user) >= 32
|
|
|
|
|
|| NULL == pwd || strlen(pwd) >= 32)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGChar value[256] = {0};
|
|
|
|
|
strcpy(value, user);
|
|
|
|
|
strcpy(value + 32, pwd);
|
|
|
|
|
return SetValueStr256(0x9900, value);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGResult HGSaneDeviceImpl::Logout()
|
|
|
|
|
{
|
|
|
|
|
HGChar value[256] = {0};
|
|
|
|
|
return SetValueStr256(0x9901, value);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGResult HGSaneDeviceImpl::ClearRollerCount()
|
|
|
|
|
{
|
|
|
|
|
return SetValueInt32(0x9902, 0);
|
|
|
|
|
}
|
|
|
|
|
|
2023-05-20 10:06:05 +00:00
|
|
|
|
HGResult HGSaneDeviceImpl::GetDriverLog(const HGChar *fileName)
|
2023-05-16 02:22:33 +00:00
|
|
|
|
{
|
2023-05-29 07:19:07 +00:00
|
|
|
|
if (NULL == fileName || strlen(fileName) >= 256)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
char v[256];
|
|
|
|
|
strcpy(v, fileName);
|
|
|
|
|
SANE_Status status = m_sourceImpl->m_saneApi.sane_control_option_api(m_devHandle, (SANE_Int)0x9903, SANE_ACTION_GET_VALUE, (void*)v, NULL);
|
|
|
|
|
return (SANE_STATUS_GOOD == status) ? HGBASE_ERR_OK : HGBASE_ERR_FAIL;
|
2023-05-16 02:22:33 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGResult HGSaneDeviceImpl::ClearDriverLog()
|
|
|
|
|
{
|
|
|
|
|
HGChar value[256] = {0};
|
|
|
|
|
return SetValueStr256(0x9903, value);
|
|
|
|
|
}
|
|
|
|
|
|
2023-05-20 10:06:05 +00:00
|
|
|
|
HGResult HGSaneDeviceImpl::GetDeviceLog(const HGChar *fileName)
|
2023-05-16 02:22:33 +00:00
|
|
|
|
{
|
2023-05-29 07:19:07 +00:00
|
|
|
|
if (NULL == fileName || strlen(fileName) >= 256)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
char v[256];
|
|
|
|
|
strcpy(v, fileName);
|
|
|
|
|
SANE_Status status = m_sourceImpl->m_saneApi.sane_control_option_api(m_devHandle, (SANE_Int)0x9904, SANE_ACTION_GET_VALUE, (void*)v, NULL);
|
|
|
|
|
return (SANE_STATUS_GOOD == status) ? HGBASE_ERR_OK : HGBASE_ERR_FAIL;
|
2023-05-16 02:22:33 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGResult HGSaneDeviceImpl::ClearDeviceLog()
|
|
|
|
|
{
|
|
|
|
|
HGChar value[256] = {0};
|
|
|
|
|
return SetValueStr256(0x9904, value);
|
|
|
|
|
}
|
|
|
|
|
|
2023-03-28 09:29:47 +00:00
|
|
|
|
HGResult HGSaneDeviceImpl::ShowSettingDlg(HGWindow parent)
|
2022-05-03 10:25:52 +00:00
|
|
|
|
{
|
2023-05-16 02:22:33 +00:00
|
|
|
|
if (-2 == show_setting_ui(&m_sourceImpl->m_saneApi, m_devHandle, m_devName.c_str(), parent))
|
2023-03-29 08:16:19 +00:00
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_NOTSUPPORT;
|
|
|
|
|
}
|
|
|
|
|
|
2023-03-25 07:31:09 +00:00
|
|
|
|
return HGBASE_ERR_OK;
|
2022-05-03 10:25:52 +00:00
|
|
|
|
}
|
|
|
|
|
|
2023-05-23 06:52:45 +00:00
|
|
|
|
HGResult HGSaneDeviceImpl::Start(HGWindow parent, HGSane_DeviceEventFunc eventFunc, HGPointer eventParam,
|
|
|
|
|
HGSane_DeviceImageFunc imageFunc, HGPointer imageParam)
|
2023-03-28 09:29:47 +00:00
|
|
|
|
{
|
2023-05-16 02:22:33 +00:00
|
|
|
|
HGResult ret = GetValueInt32(0x8818, &m_dpi);
|
|
|
|
|
if (HGBASE_ERR_OK != ret)
|
|
|
|
|
{
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2023-05-23 06:37:34 +00:00
|
|
|
|
m_eventFunc = eventFunc;
|
|
|
|
|
m_eventParam = eventParam;
|
2023-03-28 09:29:47 +00:00
|
|
|
|
m_imageFunc = imageFunc;
|
|
|
|
|
m_imageParam = imageParam;
|
2023-03-29 08:16:19 +00:00
|
|
|
|
|
2023-05-23 06:37:34 +00:00
|
|
|
|
if (-2 == show_scan_ui(&m_sourceImpl->m_saneApi, m_devHandle, m_devName.c_str(), parent,
|
|
|
|
|
show_scan_ui_event_func, this, show_scan_ui_image_func, this))
|
2023-03-29 08:16:19 +00:00
|
|
|
|
{
|
2023-05-16 02:22:33 +00:00
|
|
|
|
m_dpi = 0;
|
2023-03-29 08:16:19 +00:00
|
|
|
|
return HGBASE_ERR_NOTSUPPORT;
|
|
|
|
|
}
|
|
|
|
|
|
2023-03-28 09:29:47 +00:00
|
|
|
|
return HGBASE_ERR_OK;
|
|
|
|
|
}
|
|
|
|
|
|
2023-05-23 06:52:45 +00:00
|
|
|
|
HGResult HGSaneDeviceImpl::StartWithSingleScan(HGWindow parent, HGSane_DeviceEventFunc eventFunc, HGPointer eventParam,
|
|
|
|
|
HGSane_DeviceImageFunc imageFunc, HGPointer imageParam)
|
2023-03-25 07:31:09 +00:00
|
|
|
|
{
|
2023-05-16 02:22:33 +00:00
|
|
|
|
HGChar scanMode[256] = {0};
|
|
|
|
|
HGResult ret = GetValueStr256(0x882E, scanMode, 256);
|
|
|
|
|
if (HGBASE_ERR_OK != ret)
|
|
|
|
|
{
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
2022-05-03 10:25:52 +00:00
|
|
|
|
|
2023-05-16 02:22:33 +00:00
|
|
|
|
HGInt scanCount = 0;
|
|
|
|
|
ret = GetValueInt32(0x882F, &scanCount);
|
|
|
|
|
if (HGBASE_ERR_OK != ret)
|
|
|
|
|
{
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ret = GetValueInt32(0x8818, &m_dpi);
|
|
|
|
|
if (HGBASE_ERR_OK != ret)
|
|
|
|
|
{
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGChar newScanMode[256] = {0};
|
|
|
|
|
strcpy(newScanMode, OPTION_VALUE_SMZS_SMZDZS);
|
|
|
|
|
SetValueStr256(0x882E, newScanMode);
|
|
|
|
|
SetValueInt32(0x882F, 1);
|
|
|
|
|
|
2023-05-23 06:37:34 +00:00
|
|
|
|
m_eventFunc = eventFunc;
|
|
|
|
|
m_eventParam = eventParam;
|
2023-05-16 02:22:33 +00:00
|
|
|
|
m_imageFunc = imageFunc;
|
|
|
|
|
m_imageParam = imageParam;
|
|
|
|
|
|
2023-05-23 06:37:34 +00:00
|
|
|
|
if (-2 == show_scan_ui(&m_sourceImpl->m_saneApi, m_devHandle, m_devName.c_str(), parent,
|
|
|
|
|
show_scan_ui_event_func, this, show_scan_ui_image_func, this))
|
2023-05-16 02:22:33 +00:00
|
|
|
|
{
|
|
|
|
|
SetValueStr256(0x882E, scanMode);
|
|
|
|
|
SetValueInt32(0x882F, scanCount);
|
|
|
|
|
m_dpi = 0;
|
|
|
|
|
return HGBASE_ERR_NOTSUPPORT;
|
|
|
|
|
}
|
2022-05-03 10:25:52 +00:00
|
|
|
|
|
2023-05-16 02:22:33 +00:00
|
|
|
|
SetValueStr256(0x882E, scanMode);
|
|
|
|
|
SetValueInt32(0x882F, scanCount);
|
|
|
|
|
return HGBASE_ERR_OK;
|
2023-04-07 07:08:56 +00:00
|
|
|
|
}
|
|
|
|
|
|
2023-05-16 02:22:33 +00:00
|
|
|
|
HGResult HGSaneDeviceImpl::SetValueInt32(HGUInt optionId, HGInt value)
|
2023-04-07 07:08:56 +00:00
|
|
|
|
{
|
2023-05-16 02:22:33 +00:00
|
|
|
|
SANE_Int v = (SANE_Int)value;
|
|
|
|
|
SANE_Status status = m_sourceImpl->m_saneApi.sane_control_option_api(m_devHandle, (SANE_Int)optionId, SANE_ACTION_SET_VALUE, &v, NULL);
|
|
|
|
|
return (SANE_STATUS_GOOD == status) ? HGBASE_ERR_OK : HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
2023-04-07 07:08:56 +00:00
|
|
|
|
|
2023-05-16 02:22:33 +00:00
|
|
|
|
HGResult HGSaneDeviceImpl::GetValueInt32(HGUInt optionId, HGInt *value)
|
|
|
|
|
{
|
|
|
|
|
SANE_Int v = 0;
|
|
|
|
|
SANE_Status status = m_sourceImpl->m_saneApi.sane_control_option_api(m_devHandle, (SANE_Int)optionId, SANE_ACTION_GET_VALUE, &v, NULL);
|
|
|
|
|
if (SANE_STATUS_GOOD != status)
|
2023-04-07 07:08:56 +00:00
|
|
|
|
{
|
2023-05-16 02:22:33 +00:00
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
2023-04-07 07:08:56 +00:00
|
|
|
|
|
2023-05-16 02:22:33 +00:00
|
|
|
|
*value = (HGInt)v;
|
|
|
|
|
return HGBASE_ERR_OK;
|
|
|
|
|
}
|
2023-04-07 07:08:56 +00:00
|
|
|
|
|
2023-05-16 02:22:33 +00:00
|
|
|
|
HGResult HGSaneDeviceImpl::SetValueStr256(HGUInt optionId, const HGChar *value)
|
|
|
|
|
{
|
|
|
|
|
if (NULL == value || strlen(value) >= 256)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const char *v = value;
|
2023-05-20 10:06:05 +00:00
|
|
|
|
SANE_Status status = m_sourceImpl->m_saneApi.sane_control_option_api(m_devHandle, (SANE_Int)optionId, SANE_ACTION_SET_VALUE, (void*)v, NULL);
|
2023-05-16 02:22:33 +00:00
|
|
|
|
return (SANE_STATUS_GOOD == status) ? HGBASE_ERR_OK : HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGResult HGSaneDeviceImpl::GetValueStr256(HGUInt optionId, HGChar *value, HGUInt maxLen)
|
|
|
|
|
{
|
|
|
|
|
if (NULL == value || 0 == maxLen)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
char v[256] = {0};
|
|
|
|
|
SANE_Status status = m_sourceImpl->m_saneApi.sane_control_option_api(m_devHandle, (SANE_Int)optionId, SANE_ACTION_GET_VALUE, v, NULL);
|
|
|
|
|
if (SANE_STATUS_GOOD != status)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (maxLen <= strlen(v))
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
2023-04-07 07:08:56 +00:00
|
|
|
|
}
|
|
|
|
|
|
2023-05-16 02:22:33 +00:00
|
|
|
|
strcpy(value, v);
|
|
|
|
|
return HGBASE_ERR_OK;
|
2023-03-25 07:31:09 +00:00
|
|
|
|
}
|
2022-05-03 10:25:52 +00:00
|
|
|
|
|
2023-05-23 06:37:34 +00:00
|
|
|
|
void HGSaneDeviceImpl::show_scan_ui_event_func(HGUInt event, HGPointer param)
|
2023-03-28 09:29:47 +00:00
|
|
|
|
{
|
2023-05-23 06:37:34 +00:00
|
|
|
|
HGSaneDeviceImpl* p = (HGSaneDeviceImpl*)param;
|
|
|
|
|
if (NULL != p->m_eventFunc)
|
|
|
|
|
{
|
|
|
|
|
p->m_eventFunc((HGSaneDevice)p, event, p->m_eventParam);
|
|
|
|
|
}
|
|
|
|
|
}
|
2023-03-28 09:29:47 +00:00
|
|
|
|
|
2023-05-23 06:37:34 +00:00
|
|
|
|
void HGSaneDeviceImpl::show_scan_ui_image_func(HGImage image, HGPointer param)
|
|
|
|
|
{
|
|
|
|
|
HGSaneDeviceImpl* p = (HGSaneDeviceImpl*)param;
|
|
|
|
|
if (NULL != p->m_imageFunc)
|
|
|
|
|
{
|
|
|
|
|
HGBase_SetImageDpi(image, p->m_dpi, p->m_dpi);
|
|
|
|
|
p->m_imageFunc((HGSaneDevice)p, image, p->m_imageParam);
|
|
|
|
|
}
|
2023-03-30 07:36:19 +00:00
|
|
|
|
}
|