1435 lines
48 KiB
C++
1435 lines
48 KiB
C++
#include "mainwindow.h"
|
|
#include "ui_mainwindow.h"
|
|
#include <QCloseEvent>
|
|
#include <QMessageBox>
|
|
#include <QDateTime>
|
|
#include <QFileInfo>
|
|
#include "base/HGTime.h"
|
|
#include "base/HGUtility.h"
|
|
#include "imgproc/HGImgProc.h"
|
|
#include "imgproc/HGOCR.h"
|
|
#include "dialog_scaninfo.h"
|
|
#include "form_saveparam.h"
|
|
#include "sqlite3.h"
|
|
#include "cJSON.h"
|
|
#include "HGString.h"
|
|
|
|
MainWindow::MainWindow(QWidget *parent)
|
|
: QMainWindow(parent)
|
|
, ui(new Ui::MainWindow)
|
|
, m_dlgAdd(nullptr)
|
|
, m_dlgScanInfo(nullptr)
|
|
, m_devHandle(nullptr)
|
|
, m_scanning(false)
|
|
, m_dpi(200)
|
|
, m_scanFileName("")
|
|
, m_scanImgFmtWriter(nullptr)
|
|
, m_ocrMsgPump(nullptr)
|
|
, m_ocrThread(nullptr)
|
|
{
|
|
ui->setupUi(this);
|
|
|
|
m_trayIcon = new QSystemTrayIcon(this);
|
|
m_trayIcon->setIcon(QIcon(":images/image_rsc/png/logo.png"));
|
|
m_trayIcon->show();
|
|
m_trayIcon->setToolTip(tr("Scan Tool"));
|
|
|
|
qRegisterMetaType<QSystemTrayIcon::ActivationReason>("QSystemTrayIcon::ActivationReason");
|
|
connect(m_trayIcon, &QSystemTrayIcon::activated, this, &MainWindow::on_trayActivated);
|
|
|
|
m_showAction = new QAction(tr("Show"), this);
|
|
connect(m_showAction, &QAction::triggered, this, &MainWindow::on_showMainWindowDlg);
|
|
m_quitAction = new QAction(tr("Exit"), this);
|
|
connect(m_quitAction, &QAction::triggered, this, &QCoreApplication::quit); //应用程序的退出
|
|
|
|
//创建菜单，添加菜单项
|
|
m_trayIconMenu = new QMenu(this);
|
|
m_trayIconMenu->addAction(m_showAction);
|
|
m_trayIconMenu->addSeparator(); //分割线
|
|
m_trayIconMenu->addAction(m_quitAction);
|
|
//给系统托盘添加右键菜单
|
|
m_trayIcon->setContextMenu(m_trayIconMenu);
|
|
|
|
ui->tableWidget->setColumnCount(4);
|
|
ui->tableWidget->setSelectionBehavior(QAbstractItemView::SelectRows);
|
|
ui->tableWidget->setStyleSheet("selection-background-color:rgb(0, 120, 215)");
|
|
ui->tableWidget->setSelectionMode(QAbstractItemView::SingleSelection);
|
|
ui->tableWidget->horizontalHeader()->setFixedHeight(40);
|
|
ui->tableWidget->horizontalHeader()->setStretchLastSection(true);
|
|
ui->tableWidget->setHorizontalHeaderItem(0, new QTableWidgetItem("Device Type"));
|
|
ui->tableWidget->setHorizontalHeaderItem(1, new QTableWidgetItem("Button Id"));
|
|
ui->tableWidget->setHorizontalHeaderItem(2, new QTableWidgetItem("Device Config"));
|
|
ui->tableWidget->setHorizontalHeaderItem(3, new QTableWidgetItem("Save Param"));
|
|
ui->tableWidget->horizontalHeader()->setSectionResizeMode(0, QHeaderView::Stretch);
|
|
ui->tableWidget->horizontalHeader()->setSectionResizeMode(1, QHeaderView::Stretch);
|
|
ui->tableWidget->horizontalHeader()->setSectionResizeMode(2, QHeaderView::Stretch);
|
|
ui->tableWidget->horizontalHeader()->setSectionResizeMode(3, QHeaderView::Stretch);
|
|
|
|
LoadCfg();
|
|
|
|
ui->tableWidget->setRowCount((int)m_vScanParams.size());
|
|
for (int index = 0; index < (int)m_vScanParams.size(); ++index)
|
|
{
|
|
ui->tableWidget->setRowHeight(index, 30);
|
|
|
|
ui->tableWidget->setItem(index, 0, new QTableWidgetItem(QString(m_vScanParams[index].deviceType.c_str())));
|
|
ui->tableWidget->item(index, 0)->setTextAlignment(Qt::AlignCenter);
|
|
ui->tableWidget->item(index, 0)->setFlags(ui->tableWidget->item(index, 0)->flags() & ~Qt::ItemIsEditable);
|
|
|
|
const char *btnTypeStr[] = {"Manual", "Button 1", "Button 2", "Button 3"};
|
|
ui->tableWidget->setItem(index, 1, new QTableWidgetItem(btnTypeStr[m_vScanParams[index].buttonId]));
|
|
ui->tableWidget->item(index, 1)->setTextAlignment(Qt::AlignCenter);
|
|
ui->tableWidget->item(index, 1)->setFlags(ui->tableWidget->item(index, 1)->flags() & ~Qt::ItemIsEditable);
|
|
|
|
ui->tableWidget->setItem(index, 2, new QTableWidgetItem(GetDesc(m_vScanParams[index].deviceConfigs)));
|
|
ui->tableWidget->item(index, 2)->setTextAlignment(Qt::AlignCenter);
|
|
ui->tableWidget->item(index, 2)->setFlags(ui->tableWidget->item(index, 2)->flags() & ~Qt::ItemIsEditable);
|
|
|
|
ui->tableWidget->setItem(index, 3, new QTableWidgetItem(GetDesc(m_vScanParams[index].saveParam)));
|
|
ui->tableWidget->item(index, 3)->setTextAlignment(Qt::AlignCenter);
|
|
ui->tableWidget->item(index, 3)->setFlags(ui->tableWidget->item(index, 3)->flags() & ~Qt::ItemIsEditable);
|
|
}
|
|
|
|
ui->tableWidget->selectRow(0);
|
|
|
|
m_dlgScanInfo = new Dialog_ScanInfo(this);
|
|
|
|
connect(this, SIGNAL(deviceArrive(QString)), this, SLOT(on_deviceArrive(QString)));
|
|
connect(this, SIGNAL(deviceRemove(QString)), this, SLOT(on_deviceRemove(QString)));
|
|
connect(this, SIGNAL(keyPress(unsigned int)), this, SLOT(on_keyPress(unsigned int)));
|
|
connect(this, SIGNAL(scanWorking()), this, SLOT(on_scanWorking()));
|
|
connect(this, SIGNAL(scanInfo(QString, bool)), this, SLOT(on_scanInfo(QString, bool)));
|
|
connect(this, SIGNAL(scanImage(unsigned int)), this, SLOT(on_scanImage(unsigned int)));
|
|
connect(this, SIGNAL(scanFinish()), this, SLOT(on_scanFinish()));
|
|
|
|
SANE_Int version_code = 0;
|
|
sane_init_ex(&version_code, sane_ex_callback, this);
|
|
}
|
|
|
|
MainWindow::~MainWindow()
|
|
{
|
|
assert(nullptr == m_dlgAdd);
|
|
if (NULL != m_devHandle)
|
|
{
|
|
StopScan();
|
|
sane_close(m_devHandle);
|
|
m_devHandle = NULL;
|
|
m_devName.clear();
|
|
}
|
|
|
|
sane_exit();
|
|
|
|
delete m_dlgScanInfo;
|
|
delete ui;
|
|
}
|
|
|
|
bool MainWindow::FindScanParam(const std::string &deviceType, unsigned int buttonId, int ignoreIndex)
|
|
{
|
|
for (int i = 0; i < (int)m_vScanParams.size(); ++i)
|
|
{
|
|
if (deviceType == m_vScanParams[i].deviceType && buttonId == m_vScanParams[i].buttonId)
|
|
{
|
|
if (-1 == ignoreIndex) // 表示均不忽略
|
|
{
|
|
return true;
|
|
}
|
|
else if (i != ignoreIndex)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void MainWindow::StopScan()
|
|
{
|
|
if (m_scanning)
|
|
{
|
|
assert(NULL != m_devHandle);
|
|
sane_cancel(m_devHandle);
|
|
m_scanning = false;
|
|
m_quitAction->setEnabled(true);
|
|
ui->pushButtonAdd->setEnabled(true);
|
|
ui->pushButtonModify->setEnabled(true);
|
|
ui->pushButtonRemove->setEnabled(true);
|
|
ui->comboBox->setEnabled(true);
|
|
ui->pushButtonScan->setEnabled(true);
|
|
m_dpi = 200;
|
|
}
|
|
}
|
|
|
|
std::vector<DeviceConfig> MainWindow::MakeDeviceConfigs(const std::string &str)
|
|
{
|
|
std::vector<DeviceConfig> deviceConfigs;
|
|
|
|
cJSON* json = cJSON_Parse(str.c_str());
|
|
if (NULL != json)
|
|
{
|
|
cJSON* p = json->child;
|
|
while (NULL != p)
|
|
{
|
|
if (0 != strcmp(p->string, "device_configs"))
|
|
{
|
|
p = p->next;
|
|
continue;
|
|
}
|
|
|
|
if (p->type != cJSON_Array)
|
|
{
|
|
break;
|
|
}
|
|
|
|
cJSON* pEx = p->child;
|
|
while (NULL != pEx)
|
|
{
|
|
if (pEx->type != cJSON_Object)
|
|
{
|
|
pEx = pEx->next;
|
|
continue;
|
|
}
|
|
|
|
std::string name;
|
|
int valueType = 0;
|
|
std::string stringValue;
|
|
int intValue = 0;
|
|
double doubleValue = 0;
|
|
bool boolValue = false;
|
|
|
|
cJSON* pEx2 = pEx->child;
|
|
while (NULL != pEx2)
|
|
{
|
|
if (0 == strcmp(pEx2->string, "name") && pEx2->type == cJSON_String)
|
|
{
|
|
name = pEx2->valuestring;
|
|
}
|
|
else if (0 == strcmp(pEx2->string, "value"))
|
|
{
|
|
if (pEx2->type == cJSON_String)
|
|
{
|
|
stringValue = pEx2->valuestring;
|
|
}
|
|
else if (pEx2->type == cJSON_Number)
|
|
{
|
|
intValue = pEx2->valueint;
|
|
doubleValue = pEx2->valuedouble;
|
|
}
|
|
else if (pEx2->type == cJSON_True)
|
|
{
|
|
boolValue = true;
|
|
}
|
|
else if (pEx2->type == cJSON_False)
|
|
{
|
|
boolValue = false;
|
|
}
|
|
}
|
|
else if (0 == strcmp(pEx2->string, "value_type") && pEx2->type == cJSON_Number)
|
|
{
|
|
valueType = pEx2->valueint;
|
|
}
|
|
|
|
pEx2 = pEx2->next;
|
|
}
|
|
|
|
DeviceConfig deviceConfig;
|
|
deviceConfig.name = name;
|
|
deviceConfig.valueType = valueType;
|
|
if (1 == deviceConfig.valueType)
|
|
deviceConfig.stringValue = stringValue;
|
|
else if (2 == deviceConfig.valueType)
|
|
deviceConfig.intValue = intValue;
|
|
else if (3 == deviceConfig.valueType)
|
|
deviceConfig.doubleValue = doubleValue;
|
|
else if (4 == deviceConfig.valueType)
|
|
deviceConfig.boolValue = boolValue;
|
|
|
|
deviceConfigs.push_back(deviceConfig);
|
|
pEx = pEx->next;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
cJSON_Delete(json);
|
|
}
|
|
|
|
return deviceConfigs;
|
|
}
|
|
|
|
std::string MainWindow::GetDeviceConfigsStr(const std::vector<DeviceConfig> &deviceConfigs)
|
|
{
|
|
std::string str;
|
|
|
|
cJSON* json = cJSON_CreateObject();
|
|
if (NULL != json)
|
|
{
|
|
cJSON* array = cJSON_CreateArray();
|
|
for (int i = 0; i < deviceConfigs.size(); ++i)
|
|
{
|
|
cJSON* obj = cJSON_CreateObject();
|
|
cJSON_AddItemToObject(obj, "name", cJSON_CreateString(deviceConfigs[i].name.c_str()));
|
|
cJSON_AddItemToObject(obj, "value_type", cJSON_CreateNumber(deviceConfigs[i].valueType));
|
|
|
|
if (1 == deviceConfigs[i].valueType)
|
|
{
|
|
cJSON_AddItemToObject(obj, "value", cJSON_CreateString(deviceConfigs[i].stringValue.c_str()));
|
|
}
|
|
else if (2 == deviceConfigs[i].valueType)
|
|
{
|
|
cJSON_AddItemToObject(obj, "value", cJSON_CreateNumber(deviceConfigs[i].intValue));
|
|
}
|
|
else if (3 == deviceConfigs[i].valueType)
|
|
{
|
|
cJSON_AddItemToObject(obj, "value", cJSON_CreateNumber(deviceConfigs[i].doubleValue));
|
|
}
|
|
else if (4 == deviceConfigs[i].valueType)
|
|
{
|
|
cJSON_AddItemToObject(obj, "value", deviceConfigs[i].boolValue ? cJSON_CreateTrue() : cJSON_CreateFalse());
|
|
}
|
|
|
|
cJSON_AddItemToArray(array, obj);
|
|
}
|
|
|
|
cJSON_AddItemToObject(json, "device_configs", array);
|
|
|
|
char* resp = cJSON_Print(json);
|
|
if (NULL != resp)
|
|
{
|
|
str = resp;
|
|
free(resp);
|
|
}
|
|
|
|
cJSON_Delete(json);
|
|
}
|
|
|
|
return str;
|
|
}
|
|
|
|
SaveParam MainWindow::MakeSaveParam(const std::string &str)
|
|
{
|
|
SaveParam saveParam = Form_SaveParam::GetDefSaveParam();
|
|
|
|
cJSON* json = cJSON_Parse(str.c_str());
|
|
if (NULL != json)
|
|
{
|
|
cJSON* p = json->child;
|
|
while (NULL != p)
|
|
{
|
|
if (0 != strcmp(p->string, "save_param"))
|
|
{
|
|
p = p->next;
|
|
continue;
|
|
}
|
|
|
|
if (p->type != cJSON_Object)
|
|
{
|
|
break;
|
|
}
|
|
|
|
cJSON* pEx = p->child;
|
|
while (NULL != pEx)
|
|
{
|
|
if (0 == strcmp(pEx->string, "save_path") && pEx->type == cJSON_String)
|
|
{
|
|
saveParam.savePath = Utf8ToStdString(pEx->valuestring);
|
|
}
|
|
else if (0 == strcmp(pEx->string, "use_subfolder_by_time") && pEx->type == cJSON_True)
|
|
{
|
|
saveParam.isUseSubfolderByTime = true;
|
|
}
|
|
else if (0 == strcmp(pEx->string, "use_subfolder_by_time") && pEx->type == cJSON_False)
|
|
{
|
|
saveParam.isUseSubfolderByTime = false;
|
|
}
|
|
else if (0 == strcmp(pEx->string, "use_subfolder_by_blank_pages") && pEx->type == cJSON_True)
|
|
{
|
|
saveParam.isUseSubfolderByBlankPages = true;
|
|
}
|
|
else if (0 == strcmp(pEx->string, "use_subfolder_by_blank_pages") && pEx->type == cJSON_False)
|
|
{
|
|
saveParam.isUseSubfolderByBlankPages = false;
|
|
}
|
|
else if (0 == strcmp(pEx->string, "use_subfolder_by_color") && pEx->type == cJSON_True)
|
|
{
|
|
saveParam.isUseSubfolderByColor = true;
|
|
}
|
|
else if (0 == strcmp(pEx->string, "use_subfolder_by_color") && pEx->type == cJSON_False)
|
|
{
|
|
saveParam.isUseSubfolderByColor = false;
|
|
}
|
|
else if (0 == strcmp(pEx->string, "jpeg_quality") && pEx->type == cJSON_Number)
|
|
{
|
|
saveParam.jpegQuality = pEx->valueint;
|
|
}
|
|
else if (0 == strcmp(pEx->string, "tiff_compression_bw") && pEx->type == cJSON_Number)
|
|
{
|
|
saveParam.tiffCompressionBW = pEx->valueint;
|
|
}
|
|
else if (0 == strcmp(pEx->string, "tiff_compression") && pEx->type == cJSON_Number)
|
|
{
|
|
saveParam.tiffCompression = pEx->valueint;
|
|
}
|
|
else if (0 == strcmp(pEx->string, "tiff_quality") && pEx->type == cJSON_Number)
|
|
{
|
|
saveParam.tiffQuality = pEx->valueint;
|
|
}
|
|
else if (0 == strcmp(pEx->string, "filename_prefix") && pEx->type == cJSON_String)
|
|
{
|
|
saveParam.fileNamePrefix = Utf8ToStdString(pEx->valuestring);
|
|
}
|
|
else if (0 == strcmp(pEx->string, "filename_start_index") && pEx->type == cJSON_Number)
|
|
{
|
|
saveParam.fileNameStartIndex = pEx->valueint;
|
|
}
|
|
else if (0 == strcmp(pEx->string, "filename_digits") && pEx->type == cJSON_Number)
|
|
{
|
|
saveParam.fileNameDigits = pEx->valueint;
|
|
}
|
|
else if (0 == strcmp(pEx->string, "filename_odd_even_type") && pEx->type == cJSON_Number)
|
|
{
|
|
saveParam.fileNameOddEvenType = pEx->valueint;
|
|
}
|
|
else if (0 == strcmp(pEx->string, "filename_ext") && pEx->type == cJSON_String)
|
|
{
|
|
saveParam.fileNameExt = Utf8ToStdString(pEx->valuestring);
|
|
}
|
|
else if (0 == strcmp(pEx->string, "ocr") && pEx->type == cJSON_True)
|
|
{
|
|
saveParam.isOcr = true;
|
|
}
|
|
else if (0 == strcmp(pEx->string, "ocr") && pEx->type == cJSON_False)
|
|
{
|
|
saveParam.isOcr = false;
|
|
}
|
|
else if (0 == strcmp(pEx->string, "save_as_multi_page") && pEx->type == cJSON_True)
|
|
{
|
|
saveParam.isSaveAsMultiPage = true;
|
|
}
|
|
else if (0 == strcmp(pEx->string, "save_as_multi_page") && pEx->type == cJSON_False)
|
|
{
|
|
saveParam.isSaveAsMultiPage = false;
|
|
}
|
|
else if (0 == strcmp(pEx->string, "multi_pages_type") && pEx->type == cJSON_Number)
|
|
{
|
|
saveParam.multiPagesType = pEx->valueint;
|
|
}
|
|
else if (0 == strcmp(pEx->string, "custom_multi_pages") && pEx->type == cJSON_Number)
|
|
{
|
|
saveParam.customMultiPages = pEx->valueint;
|
|
}
|
|
|
|
pEx = pEx->next;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
cJSON_Delete(json);
|
|
}
|
|
|
|
return saveParam;
|
|
}
|
|
|
|
std::string MainWindow::GetSaveParamStr(const SaveParam &saveParam)
|
|
{
|
|
std::string str;
|
|
|
|
cJSON* json = cJSON_CreateObject();
|
|
if (NULL != json)
|
|
{
|
|
cJSON* obj = cJSON_CreateObject();
|
|
cJSON_AddItemToObject(obj, "save_path", cJSON_CreateString(StdStringToUtf8(saveParam.savePath).c_str()));
|
|
cJSON_AddItemToObject(obj, "use_subfolder_by_time", saveParam.isUseSubfolderByTime ? cJSON_CreateTrue() : cJSON_CreateFalse());
|
|
cJSON_AddItemToObject(obj, "use_subfolder_by_blank_pages", saveParam.isUseSubfolderByBlankPages ? cJSON_CreateTrue() : cJSON_CreateFalse());
|
|
cJSON_AddItemToObject(obj, "use_subfolder_by_color", saveParam.isUseSubfolderByColor ? cJSON_CreateTrue() : cJSON_CreateFalse());
|
|
cJSON_AddItemToObject(obj, "jpeg_quality", cJSON_CreateNumber(saveParam.jpegQuality));
|
|
cJSON_AddItemToObject(obj, "tiff_compression_bw", cJSON_CreateNumber(saveParam.tiffCompressionBW));
|
|
cJSON_AddItemToObject(obj, "tiff_compression", cJSON_CreateNumber(saveParam.tiffCompression));
|
|
cJSON_AddItemToObject(obj, "tiff_quality", cJSON_CreateNumber(saveParam.tiffQuality));
|
|
cJSON_AddItemToObject(obj, "filename_prefix", cJSON_CreateString(StdStringToUtf8(saveParam.fileNamePrefix).c_str()));
|
|
cJSON_AddItemToObject(obj, "filename_start_index", cJSON_CreateNumber(saveParam.fileNameStartIndex));
|
|
cJSON_AddItemToObject(obj, "filename_digits", cJSON_CreateNumber(saveParam.fileNameDigits));
|
|
cJSON_AddItemToObject(obj, "filename_odd_even_type", cJSON_CreateNumber(saveParam.fileNameOddEvenType));
|
|
cJSON_AddItemToObject(obj, "filename_ext", cJSON_CreateString(StdStringToUtf8(saveParam.fileNameExt).c_str()));
|
|
cJSON_AddItemToObject(obj, "ocr", saveParam.isOcr ? cJSON_CreateTrue() : cJSON_CreateFalse());
|
|
cJSON_AddItemToObject(obj, "save_as_multi_page", saveParam.isSaveAsMultiPage ? cJSON_CreateTrue() : cJSON_CreateFalse());
|
|
cJSON_AddItemToObject(obj, "multi_pages_type", cJSON_CreateNumber(saveParam.multiPagesType));
|
|
cJSON_AddItemToObject(obj, "custom_multi_pages", cJSON_CreateNumber(saveParam.customMultiPages));
|
|
cJSON_AddItemToObject(json, "save_param", obj);
|
|
|
|
char* resp = cJSON_Print(json);
|
|
if (NULL != resp)
|
|
{
|
|
str = resp;
|
|
free(resp);
|
|
}
|
|
|
|
cJSON_Delete(json);
|
|
}
|
|
|
|
return str;
|
|
}
|
|
|
|
void MainWindow::LoadCfg()
|
|
{
|
|
m_vScanParams.clear();
|
|
|
|
HGChar cfgPath[256];
|
|
HGBase_GetConfigPath(cfgPath, 256);
|
|
char dbPath[256];
|
|
sprintf(dbPath, "%s%s", cfgPath, "config.db");
|
|
|
|
sqlite3 *sqlite = nullptr;
|
|
sqlite3_open_v2(dbPath, &sqlite, SQLITE_OPEN_READONLY | SQLITE_OPEN_NOMUTEX | SQLITE_OPEN_SHAREDCACHE, NULL);
|
|
if (NULL == sqlite)
|
|
{
|
|
return;
|
|
}
|
|
|
|
sqlite3_stmt* stmt = NULL;
|
|
char sql[256];
|
|
sprintf(sql, "select * from scan_params");
|
|
int ret = sqlite3_prepare(sqlite, sql, -1, &stmt, NULL);
|
|
if (0 != ret)
|
|
{
|
|
sqlite3_close(sqlite);
|
|
return;
|
|
}
|
|
|
|
ret = sqlite3_step(stmt);
|
|
while (SQLITE_ROW == ret)
|
|
{
|
|
int id = sqlite3_column_int(stmt, 0);
|
|
const char* deviceType = (const char*)sqlite3_column_text(stmt, 1);
|
|
int buttonId = sqlite3_column_int(stmt, 2);
|
|
const char* deviceConfigs = (const char*)sqlite3_column_text(stmt, 3);
|
|
const char* saveParam = (const char*)sqlite3_column_text(stmt, 4);
|
|
|
|
ScanParam scanParam;
|
|
scanParam.deviceType = deviceType;
|
|
scanParam.buttonId = buttonId;
|
|
scanParam.deviceConfigs = MakeDeviceConfigs(deviceConfigs);
|
|
scanParam.saveParam = MakeSaveParam(saveParam);
|
|
m_vScanParams.push_back(scanParam);
|
|
|
|
ret = sqlite3_step(stmt);
|
|
}
|
|
|
|
ret = sqlite3_finalize(stmt);
|
|
assert(0 == ret);
|
|
|
|
sqlite3_close(sqlite);
|
|
}
|
|
|
|
void MainWindow::SaveCfg()
|
|
{
|
|
HGChar cfgPath[256];
|
|
HGBase_GetConfigPath(cfgPath, 256);
|
|
HGBase_CreateDir(cfgPath);
|
|
char dbPath[256];
|
|
sprintf(dbPath, "%s%s", cfgPath, "config.db");
|
|
HGBase_DeleteFile(dbPath);
|
|
|
|
sqlite3 *sqlite = nullptr;
|
|
sqlite3_open_v2(dbPath, &sqlite, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_NOMUTEX | SQLITE_OPEN_SHAREDCACHE, NULL);
|
|
if (NULL == sqlite)
|
|
{
|
|
return;
|
|
}
|
|
|
|
int ret = sqlite3_exec(sqlite, "create table scan_params (id integer primary key autoincrement, device_type text, "
|
|
"button_id integer, device_configs text, save_param text)", NULL, NULL, NULL);
|
|
if (0 != ret)
|
|
{
|
|
sqlite3_close(sqlite);
|
|
return;
|
|
}
|
|
|
|
for (int i = 0; i < (int)m_vScanParams.size(); ++i)
|
|
{
|
|
std::string deviceConfigsStr = GetDeviceConfigsStr(m_vScanParams[i].deviceConfigs);
|
|
std::string saveParamStr = GetSaveParamStr(m_vScanParams[i].saveParam);
|
|
|
|
char *sql = new char [1024 + deviceConfigsStr.size() + saveParamStr.size()];
|
|
sprintf(sql, "insert into scan_params (device_type, button_id, device_configs, save_param) values ('%s', '%d', '%s', '%s')",
|
|
m_vScanParams[i].deviceType.c_str(), m_vScanParams[i].buttonId, deviceConfigsStr.c_str(), saveParamStr.c_str());
|
|
sqlite3_exec(sqlite, sql, NULL, NULL, NULL);
|
|
}
|
|
|
|
sqlite3_close(sqlite);
|
|
}
|
|
|
|
QString MainWindow::GetDesc(const std::vector<DeviceConfig> &deviceConfigs)
|
|
{
|
|
QString desc = "-";
|
|
|
|
return desc;
|
|
}
|
|
|
|
QString MainWindow::GetDesc(const SaveParam &saveParam)
|
|
{
|
|
QString desc = "-";
|
|
|
|
return desc;
|
|
}
|
|
|
|
void MainWindow::StartScan(unsigned int buttonId)
|
|
{
|
|
if (nullptr == m_devHandle)
|
|
{
|
|
QMessageBox::information(this, tr("Tips"), tr("Device is offline"));
|
|
return;
|
|
}
|
|
|
|
if (m_scanning || nullptr != m_dlgAdd)
|
|
{
|
|
return;
|
|
}
|
|
|
|
std::string deviceType = m_devName.toStdString();
|
|
char v[256] = {0};
|
|
SANE_Status status = sane_control_option(m_devHandle, (SANE_Int)0x886D, SANE_ACTION_GET_VALUE, v, NULL);
|
|
if (SANE_STATUS_GOOD == status)
|
|
{
|
|
deviceType = v;
|
|
}
|
|
|
|
ScanParam scanParam;
|
|
bool find = false;
|
|
for (int i = 0; i < (int)m_vScanParams.size(); ++i)
|
|
{
|
|
if (deviceType == m_vScanParams[i].deviceType && buttonId == m_vScanParams[i].buttonId)
|
|
{
|
|
scanParam = m_vScanParams[i];
|
|
find = true;
|
|
}
|
|
}
|
|
|
|
if (!find)
|
|
{
|
|
// 手动扫描一定能找到配置，按键扫描不能提示
|
|
return;
|
|
}
|
|
|
|
// 1.恢复默认
|
|
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* name = desp->name;
|
|
while (' ' == *name)
|
|
++name;
|
|
|
|
if (0 == strcmp(SANE_STD_OPT_NAME_RESTORE, name) && SANE_TYPE_BUTTON == desp->type)
|
|
{
|
|
sane_control_option(m_devHandle, i, SANE_ACTION_SET_VALUE, NULL, NULL);
|
|
break;
|
|
}
|
|
}
|
|
|
|
// 2.设置新的属性
|
|
for (int i = 0; i < (int)scanParam.deviceConfigs.size(); ++i)
|
|
{
|
|
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* name = desp->name;
|
|
while (' ' == *name)
|
|
++name;
|
|
|
|
if (0 == strcmp(scanParam.deviceConfigs[i].name.c_str(), name))
|
|
{
|
|
if (SANE_TYPE_STRING == desp->type)
|
|
{
|
|
sane_control_option(m_devHandle, j, SANE_ACTION_SET_VALUE, (void*)scanParam.deviceConfigs[i].stringValue.c_str(), NULL);
|
|
}
|
|
else if (SANE_TYPE_INT == desp->type)
|
|
{
|
|
SANE_Int value = scanParam.deviceConfigs[i].intValue;
|
|
sane_control_option(m_devHandle, j, SANE_ACTION_SET_VALUE, &value, NULL);
|
|
}
|
|
else if (SANE_TYPE_FIXED == desp->type)
|
|
{
|
|
SANE_Fixed value = SANE_FIX(scanParam.deviceConfigs[i].doubleValue);
|
|
sane_control_option(m_devHandle, j, SANE_ACTION_SET_VALUE, &value, NULL);
|
|
}
|
|
else if (SANE_TYPE_BOOL == desp->type)
|
|
{
|
|
SANE_Bool value = (SANE_Bool)scanParam.deviceConfigs[i].boolValue;
|
|
sane_control_option(m_devHandle, j, SANE_ACTION_SET_VALUE, &value, NULL);
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// 3. 获取DPI
|
|
for (int i = 1; i < num_dev_options; ++i)
|
|
{
|
|
const SANE_Option_Descriptor* desp = sane_get_option_descriptor(m_devHandle, i);
|
|
if (nullptr == desp)
|
|
continue;
|
|
|
|
if (SANE_TYPE_INT == desp->type)
|
|
{
|
|
SANE_Int value = 0;
|
|
sane_control_option(m_devHandle, i, SANE_ACTION_GET_VALUE, &value, nullptr);
|
|
if (0 == strcmp(desp->name, SANE_STD_OPT_NAME_RESOLUTION))
|
|
{
|
|
m_dpi = (HGUInt)value;
|
|
}
|
|
}
|
|
}
|
|
|
|
// 4.保存配置
|
|
assert(m_scanFileName.isEmpty());
|
|
assert(nullptr == m_scanImgFmtWriter);
|
|
m_aquireIntoSaveParam = scanParam.saveParam;
|
|
m_aquireIntoInBlank = true;
|
|
m_aquireIntoBatchStartIndex = 0;
|
|
m_aquireIntoPageIndex = 0;
|
|
m_aquireIntoMultiPageCount = 0;
|
|
|
|
QDateTime dateTime = QDateTime::currentDateTime();
|
|
if (m_aquireIntoSaveParam.isUseSubfolderByTime)
|
|
{
|
|
#ifdef HG_CMP_MSC
|
|
std::string newPath = m_aquireIntoSaveParam.savePath + dateTime.toString("yyyy-MM-dd").toStdString() + "\\";
|
|
#else
|
|
std::string newPath = m_aquireIntoSaveParam.savePath + dateTime.toString("yyyy-MM-dd").toStdString() + "/";
|
|
#endif
|
|
m_aquireIntoSaveParam.savePath = newPath;
|
|
}
|
|
|
|
if (m_aquireIntoSaveParam.isOcr)
|
|
{
|
|
HGBase_CreateMsgPump(&m_ocrMsgPump);
|
|
HGBase_OpenThread(ocrThreadFunc, this, &m_ocrThread);
|
|
}
|
|
|
|
m_scanning = true;
|
|
m_quitAction->setEnabled(false);
|
|
ui->pushButtonAdd->setEnabled(false);
|
|
ui->pushButtonModify->setEnabled(false);
|
|
ui->pushButtonRemove->setEnabled(false);
|
|
ui->comboBox->setEnabled(false);
|
|
ui->pushButtonScan->setEnabled(false);
|
|
status = sane_start(m_devHandle);
|
|
if (SANE_STATUS_GOOD != status)
|
|
{
|
|
if (NULL != m_ocrMsgPump)
|
|
{
|
|
HGBase_ExitMsgPump(m_ocrMsgPump);
|
|
HGBase_CloseThread(m_ocrThread);
|
|
m_ocrThread = NULL;
|
|
HGBase_DestroyMsgPump(m_ocrMsgPump);
|
|
m_ocrMsgPump = NULL;
|
|
}
|
|
|
|
m_scanning = false;
|
|
m_quitAction->setEnabled(true);
|
|
ui->pushButtonAdd->setEnabled(true);
|
|
ui->pushButtonModify->setEnabled(true);
|
|
ui->pushButtonRemove->setEnabled(true);
|
|
ui->comboBox->setEnabled(true);
|
|
ui->pushButtonScan->setEnabled(true);
|
|
m_dpi = 200;
|
|
|
|
emit scanWorking();
|
|
emit scanInfo((const char*)sane_strstatus(status), true);
|
|
emit scanFinish();
|
|
return;
|
|
}
|
|
}
|
|
|
|
void MainWindow::AddManualScanParam()
|
|
{
|
|
assert(NULL != m_devHandle);
|
|
|
|
std::string deviceType = m_devName.toStdString();
|
|
char v[256] = {0};
|
|
SANE_Status status = sane_control_option(m_devHandle, (SANE_Int)0x886D, SANE_ACTION_GET_VALUE, v, NULL);
|
|
if (SANE_STATUS_GOOD == status)
|
|
{
|
|
deviceType = v;
|
|
}
|
|
|
|
if (FindScanParam(deviceType, 0, -1))
|
|
{
|
|
return;
|
|
}
|
|
|
|
ScanParam scanParam;
|
|
scanParam.deviceType = deviceType;
|
|
scanParam.buttonId = 0;
|
|
scanParam.deviceConfigs.clear();
|
|
scanParam.saveParam = Form_SaveParam::GetDefSaveParam();
|
|
m_vScanParams.push_back(scanParam);
|
|
SaveCfg();
|
|
|
|
ui->tableWidget->setRowCount((int)m_vScanParams.size());
|
|
int index = (int)m_vScanParams.size() - 1;
|
|
|
|
ui->tableWidget->setRowHeight(index, 30);
|
|
|
|
ui->tableWidget->setItem(index, 0, new QTableWidgetItem(QString(m_vScanParams[index].deviceType.c_str())));
|
|
ui->tableWidget->item(index, 0)->setTextAlignment(Qt::AlignCenter);
|
|
ui->tableWidget->item(index, 0)->setFlags(ui->tableWidget->item(index, 0)->flags() & ~Qt::ItemIsEditable);
|
|
|
|
const char *btnTypeStr[] = {"Manual", "Button 1", "Button 2", "Button 3"};
|
|
ui->tableWidget->setItem(index, 1, new QTableWidgetItem(btnTypeStr[m_vScanParams[index].buttonId]));
|
|
ui->tableWidget->item(index, 1)->setTextAlignment(Qt::AlignCenter);
|
|
ui->tableWidget->item(index, 1)->setFlags(ui->tableWidget->item(index, 1)->flags() & ~Qt::ItemIsEditable);
|
|
|
|
ui->tableWidget->setItem(index, 2, new QTableWidgetItem(GetDesc(m_vScanParams[index].deviceConfigs)));
|
|
ui->tableWidget->item(index, 2)->setTextAlignment(Qt::AlignCenter);
|
|
ui->tableWidget->item(index, 2)->setFlags(ui->tableWidget->item(index, 2)->flags() & ~Qt::ItemIsEditable);
|
|
|
|
ui->tableWidget->setItem(index, 3, new QTableWidgetItem(GetDesc(m_vScanParams[index].saveParam)));
|
|
ui->tableWidget->item(index, 3)->setTextAlignment(Qt::AlignCenter);
|
|
ui->tableWidget->item(index, 3)->setFlags(ui->tableWidget->item(index, 3)->flags() & ~Qt::ItemIsEditable);
|
|
|
|
ui->tableWidget->selectRow(index);
|
|
}
|
|
|
|
void MainWindow::SaveImage(HGImage image)
|
|
{
|
|
if (m_aquireIntoSaveParam.isSaveAsMultiPage)
|
|
{
|
|
if (nullptr == m_scanImgFmtWriter)
|
|
{
|
|
assert(m_scanFileName.isEmpty());
|
|
HGBase_CreateDir(m_aquireIntoSaveParam.savePath.c_str());
|
|
|
|
QString scanFileName;
|
|
while (1)
|
|
{
|
|
scanFileName = QString::fromLocal8Bit(m_aquireIntoSaveParam.savePath.c_str()) + QString::fromLocal8Bit(m_aquireIntoSaveParam.fileNamePrefix.c_str())
|
|
+ QString("%1.%2").arg(m_aquireIntoSaveParam.fileNameStartIndex, m_aquireIntoSaveParam.fileNameDigits, 10, QLatin1Char('0'))
|
|
.arg(QString::fromLocal8Bit(m_aquireIntoSaveParam.fileNameExt.c_str()));
|
|
QFileInfo fileInfo(scanFileName);
|
|
if (fileInfo.isFile())
|
|
{
|
|
++m_aquireIntoSaveParam.fileNameStartIndex;
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
HGUInt fmtType = 0;
|
|
if (nullptr != m_ocrMsgPump)
|
|
{
|
|
fmtType = HGIMGFMT_TYPE_TIFF;
|
|
}
|
|
|
|
HGImgFmt_OpenImageWriter(scanFileName.toLocal8Bit().toStdString().c_str(), fmtType, &m_scanImgFmtWriter);
|
|
if (nullptr != m_scanImgFmtWriter)
|
|
{
|
|
m_scanFileName = scanFileName;
|
|
}
|
|
}
|
|
|
|
if (nullptr != m_scanImgFmtWriter)
|
|
{
|
|
HGImgFmtSaveInfo saveInfo;
|
|
saveInfo.jpegQuality = (HGUInt)m_aquireIntoSaveParam.jpegQuality;
|
|
saveInfo.tiffCompression = HGIMGFMT_TIFFCOMP_NONE;
|
|
saveInfo.tiffJpegQuality = (HGUInt)m_aquireIntoSaveParam.tiffQuality;
|
|
|
|
HGImageInfo imgInfo;
|
|
HGBase_GetImageInfo(image, &imgInfo);
|
|
if (HGBASE_IMGTYPE_BINARY == imgInfo.type)
|
|
{
|
|
if (1 == m_aquireIntoSaveParam.tiffCompressionBW)
|
|
saveInfo.tiffCompression = HGIMGFMT_TIFFCOMP_LZW;
|
|
else if (2 == m_aquireIntoSaveParam.tiffCompressionBW)
|
|
saveInfo.tiffCompression = HGIMGFMT_TIFFCOMP_CCITTFAX4;
|
|
}
|
|
else
|
|
{
|
|
if (1 == m_aquireIntoSaveParam.tiffCompression)
|
|
saveInfo.tiffCompression = HGIMGFMT_TIFFCOMP_LZW;
|
|
else if (2 == m_aquireIntoSaveParam.tiffCompression)
|
|
saveInfo.tiffCompression = HGIMGFMT_TIFFCOMP_JPEG;
|
|
}
|
|
|
|
if (nullptr != m_ocrMsgPump)
|
|
{
|
|
saveInfo.jpegQuality = 100;
|
|
saveInfo.tiffCompression = HGIMGFMT_TIFFCOMP_NONE;
|
|
saveInfo.tiffJpegQuality = 100;
|
|
}
|
|
|
|
if (HGBASE_ERR_OK == HGImgFmt_SaveImageToWriter(m_scanImgFmtWriter, image, &saveInfo))
|
|
{
|
|
++m_aquireIntoMultiPageCount;
|
|
if (1 == m_aquireIntoSaveParam.multiPagesType && m_aquireIntoMultiPageCount == m_aquireIntoSaveParam.customMultiPages)
|
|
{
|
|
HGImgFmt_CloseImageWriter(m_scanImgFmtWriter);
|
|
m_scanImgFmtWriter = nullptr;
|
|
|
|
if (nullptr != m_ocrMsgPump)
|
|
{
|
|
QString *filePath = new QString(m_scanFileName);
|
|
HGMsg msg;
|
|
msg.id = 1;
|
|
msg.data = filePath;
|
|
if (HGBASE_ERR_OK != HGBase_PostPumpMessage(m_ocrMsgPump, &msg))
|
|
{
|
|
delete filePath;
|
|
}
|
|
}
|
|
|
|
m_scanFileName.clear();
|
|
++m_aquireIntoSaveParam.fileNameStartIndex;
|
|
m_aquireIntoMultiPageCount = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
assert(nullptr == m_scanImgFmtWriter);
|
|
|
|
QString savePath = QString::fromLocal8Bit(m_aquireIntoSaveParam.savePath.c_str());
|
|
if (m_aquireIntoSaveParam.isUseSubfolderByBlankPages)
|
|
{
|
|
HGBool isBlank = HGFALSE;
|
|
HGImgProc_ImageBlankCheck(image, nullptr, &isBlank);
|
|
if (isBlank)
|
|
{
|
|
m_aquireIntoInBlank = true;
|
|
}
|
|
else
|
|
{
|
|
if (m_aquireIntoInBlank)
|
|
{
|
|
++m_aquireIntoBatchStartIndex;
|
|
}
|
|
|
|
m_aquireIntoInBlank = false;
|
|
}
|
|
|
|
char batchDir[20];
|
|
sprintf(batchDir, "batch%d", m_aquireIntoBatchStartIndex);
|
|
#ifdef HG_CMP_MSC
|
|
savePath = savePath + batchDir + "\\";
|
|
#else
|
|
savePath = savePath + batchDir + "/";
|
|
#endif
|
|
}
|
|
|
|
if (m_aquireIntoSaveParam.isUseSubfolderByColor)
|
|
{
|
|
QString colorModeName;
|
|
HGImageInfo imgInfo;
|
|
HGBase_GetImageInfo(image, &imgInfo);
|
|
if (HGBASE_IMGTYPE_BINARY == imgInfo.type)
|
|
colorModeName = tr("binary");
|
|
else if (HGBASE_IMGTYPE_GRAY == imgInfo.type)
|
|
colorModeName = tr("gray");
|
|
else
|
|
colorModeName = tr("rgb");
|
|
#ifdef HG_CMP_MSC
|
|
savePath = savePath + colorModeName + "\\";
|
|
#else
|
|
savePath = savePath + colorModeName + "/";
|
|
#endif
|
|
}
|
|
|
|
HGBase_CreateDir(savePath.toLocal8Bit().toStdString().c_str());
|
|
|
|
while (1)
|
|
{
|
|
m_scanFileName = savePath + QString::fromLocal8Bit(m_aquireIntoSaveParam.fileNamePrefix.c_str()) + QString("%1.%2")
|
|
.arg(m_aquireIntoSaveParam.fileNameStartIndex, m_aquireIntoSaveParam.fileNameDigits, 10, QLatin1Char('0'))
|
|
.arg(QString::fromLocal8Bit(m_aquireIntoSaveParam.fileNameExt.c_str()));
|
|
QFileInfo fileInfo(m_scanFileName);
|
|
if (fileInfo.isFile())
|
|
{
|
|
++m_aquireIntoSaveParam.fileNameStartIndex;
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
HGImgFmtSaveInfo saveInfo;
|
|
saveInfo.jpegQuality = (HGUInt)m_aquireIntoSaveParam.jpegQuality;
|
|
saveInfo.tiffCompression = HGIMGFMT_TIFFCOMP_NONE;
|
|
saveInfo.tiffJpegQuality = (HGUInt)m_aquireIntoSaveParam.tiffQuality;
|
|
|
|
HGImageInfo imgInfo;
|
|
HGBase_GetImageInfo(image, &imgInfo);
|
|
if (HGBASE_IMGTYPE_BINARY == imgInfo.type)
|
|
{
|
|
if (1 == m_aquireIntoSaveParam.tiffCompressionBW)
|
|
saveInfo.tiffCompression = HGIMGFMT_TIFFCOMP_LZW;
|
|
else if (2 == m_aquireIntoSaveParam.tiffCompressionBW)
|
|
saveInfo.tiffCompression = HGIMGFMT_TIFFCOMP_CCITTFAX4;
|
|
}
|
|
else
|
|
{
|
|
if (1 == m_aquireIntoSaveParam.tiffCompression)
|
|
saveInfo.tiffCompression = HGIMGFMT_TIFFCOMP_LZW;
|
|
else if (2 == m_aquireIntoSaveParam.tiffCompression)
|
|
saveInfo.tiffCompression = HGIMGFMT_TIFFCOMP_JPEG;
|
|
}
|
|
|
|
HGUInt fmtType = 0;
|
|
if (nullptr != m_ocrMsgPump)
|
|
{
|
|
fmtType = HGIMGFMT_TYPE_TIFF;
|
|
saveInfo.jpegQuality = 100;
|
|
saveInfo.tiffCompression = HGIMGFMT_TIFFCOMP_NONE;
|
|
saveInfo.tiffJpegQuality = 100;
|
|
}
|
|
|
|
if (HGBASE_ERR_OK == HGImgFmt_SaveImage(image, fmtType, &saveInfo, m_scanFileName.toLocal8Bit().toStdString().c_str()))
|
|
{
|
|
if (nullptr != m_ocrMsgPump)
|
|
{
|
|
QString *filePath = new QString(m_scanFileName);
|
|
HGMsg msg;
|
|
msg.id = 1;
|
|
msg.data = filePath;
|
|
if (HGBASE_ERR_OK != HGBase_PostPumpMessage(m_ocrMsgPump, &msg))
|
|
{
|
|
delete filePath;
|
|
}
|
|
}
|
|
|
|
++m_aquireIntoSaveParam.fileNameStartIndex;
|
|
}
|
|
|
|
m_scanFileName.clear();
|
|
}
|
|
}
|
|
|
|
int MainWindow::sane_ex_callback(SANE_Handle hdev, int code, void* data, unsigned int* len, void* param)
|
|
{
|
|
(void)hdev;
|
|
(void)len;
|
|
|
|
MainWindow* p = (MainWindow*)param;
|
|
switch (code)
|
|
{
|
|
case SANE_EVENT_DEVICE_ARRIVED:
|
|
{
|
|
SANE_Device* sane_dev = (SANE_Device*)data;
|
|
emit p->deviceArrive(sane_dev->name);
|
|
}
|
|
break;
|
|
case SANE_EVENT_DEVICE_LEFT:
|
|
{
|
|
SANE_Device* sane_dev = (SANE_Device*)data;
|
|
emit p->deviceRemove(sane_dev->name);
|
|
}
|
|
break;
|
|
case SANE_EVENT_WORKING:
|
|
{
|
|
emit p->scanWorking();
|
|
emit p->scanInfo((const char*)data, false);
|
|
}
|
|
break;
|
|
case SANE_EVENT_SCAN_FINISHED:
|
|
{
|
|
emit p->scanInfo((const char*)data, (0 != *len));
|
|
emit p->scanFinish();
|
|
}
|
|
break;
|
|
case SANE_EVENT_STATUS:
|
|
{
|
|
//emit p->scanInfo((const char*)data, false);
|
|
}
|
|
break;
|
|
case SANE_EVENT_ERROR:
|
|
{
|
|
//emit p->scanInfo((const char*)data, (0 != *len));
|
|
}
|
|
break;
|
|
case SANE_EVENT_DEV_KEY_PRESSED:
|
|
{
|
|
emit p->keyPress(*len);
|
|
}
|
|
break;
|
|
case SANE_EVENT_IMAGE_OK:
|
|
{
|
|
++p->m_aquireIntoPageIndex;
|
|
emit p->scanImage(p->m_aquireIntoPageIndex);
|
|
|
|
if ((1 == p->m_aquireIntoSaveParam.fileNameOddEvenType && 1 != p->m_aquireIntoPageIndex % 2)
|
|
|| (2 == p->m_aquireIntoSaveParam.fileNameOddEvenType && 0 != p->m_aquireIntoPageIndex % 2))
|
|
{
|
|
// 跳过
|
|
}
|
|
else
|
|
{
|
|
SANE_Image* sane_img = (SANE_Image*)data;
|
|
|
|
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)
|
|
{
|
|
HGBase_SetImageDpi(img, p->m_dpi, p->m_dpi);
|
|
p->SaveImage(img);
|
|
HGBase_DestroyImage(img);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void MainWindow::ocrThreadFunc(HGThread thread, HGPointer param)
|
|
{
|
|
MainWindow *p = (MainWindow*)param;
|
|
HGBase_RunMsgPump(p->m_ocrMsgPump, ocrMsgPumpFunc, param);
|
|
}
|
|
|
|
void MainWindow::ocrMsgPumpFunc(HGMsgPump msgPump, const HGMsg *msg, HGPointer param)
|
|
{
|
|
MainWindow *p = (MainWindow*)param;
|
|
if (msg->id == 1)
|
|
{
|
|
QString *filePath = (QString *)msg->data;
|
|
|
|
HGOCRMgr ocrMgr = NULL;
|
|
HGImgProc_CreateOCRMgr(HGIMGPROC_OCRALGO_DEFAULT, &ocrMgr);
|
|
if (NULL != ocrMgr)
|
|
{
|
|
HGImgFmtReader reader = NULL;
|
|
HGImgFmt_OpenImageReader(filePath->toLocal8Bit().toStdString().c_str(), 0, &reader);
|
|
if (NULL != reader)
|
|
{
|
|
HGUInt count = 0;
|
|
HGImgFmt_GetImagePageCount(reader, &count);
|
|
for (HGUInt i = 0; i < count; ++i)
|
|
{
|
|
HGImage image = NULL;
|
|
HGImgFmt_LoadImageFromReader(reader, i, NULL, 0, 0, &image);
|
|
if (NULL != image)
|
|
{
|
|
HGImgProc_AddToImageOCRList(ocrMgr, image);
|
|
HGBase_DestroyImage(image);
|
|
}
|
|
}
|
|
|
|
HGImgFmt_CloseImageReader(reader);
|
|
}
|
|
|
|
//HGBase_DeleteFile(filePath->toLocal8Bit().toStdString().c_str());
|
|
HGImgProc_ImageListOCRToFile(ocrMgr, 0, filePath->toLocal8Bit().toStdString().c_str(), NULL, NULL);
|
|
|
|
HGImgProc_DestroyOCRMgr(ocrMgr);
|
|
}
|
|
|
|
delete filePath;
|
|
}
|
|
}
|
|
|
|
void MainWindow::closeEvent(QCloseEvent *e)
|
|
{
|
|
if (m_trayIcon->isVisible()) //托盘是显示的
|
|
{
|
|
hide(); // 隐藏主窗口
|
|
e->ignore(); //忽略关闭事件，这样才不会关闭程序
|
|
}
|
|
}
|
|
|
|
void MainWindow::on_deviceArrive(QString devName)
|
|
{
|
|
ui->comboBox->addItem(devName);
|
|
}
|
|
|
|
void MainWindow::on_deviceRemove(QString devName)
|
|
{
|
|
if (devName == m_devName)
|
|
{
|
|
assert(nullptr != m_devHandle);
|
|
StopScan();
|
|
if (nullptr != m_dlgAdd)
|
|
m_dlgAdd->reject();
|
|
sane_close(m_devHandle);
|
|
m_devHandle = NULL;
|
|
m_devName.clear();
|
|
}
|
|
|
|
for (int i = 0; i < ui->comboBox->count(); ++i)
|
|
{
|
|
if (ui->comboBox->itemText(i) == devName)
|
|
{
|
|
ui->comboBox->removeItem(i);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void MainWindow::on_keyPress(unsigned int buttonId)
|
|
{
|
|
assert(nullptr != m_devHandle);
|
|
StartScan(buttonId);
|
|
}
|
|
|
|
void MainWindow::on_scanWorking()
|
|
{
|
|
m_dlgScanInfo->Start();
|
|
}
|
|
|
|
void MainWindow::on_scanInfo(QString info, bool error)
|
|
{
|
|
m_dlgScanInfo->SetScanInfo(info, error);
|
|
}
|
|
|
|
void MainWindow::on_scanImage(unsigned int count)
|
|
{
|
|
m_dlgScanInfo->SetScanCount(count);
|
|
}
|
|
|
|
void MainWindow::on_scanFinish()
|
|
{
|
|
if (nullptr != m_scanImgFmtWriter)
|
|
{
|
|
HGImgFmt_CloseImageWriter(m_scanImgFmtWriter);
|
|
m_scanImgFmtWriter = nullptr;
|
|
|
|
if (nullptr != m_ocrMsgPump)
|
|
{
|
|
QString *filePath = new QString(m_scanFileName);
|
|
HGMsg msg;
|
|
msg.id = 1;
|
|
msg.data = filePath;
|
|
if (HGBASE_ERR_OK != HGBase_PostPumpMessage(m_ocrMsgPump, &msg))
|
|
{
|
|
delete filePath;
|
|
}
|
|
}
|
|
|
|
m_scanFileName.clear();
|
|
++m_aquireIntoSaveParam.fileNameStartIndex;
|
|
m_aquireIntoMultiPageCount = 0;
|
|
}
|
|
|
|
if (NULL != m_ocrMsgPump)
|
|
{
|
|
HGBase_ExitMsgPump(m_ocrMsgPump);
|
|
HGBase_CloseThread(m_ocrThread);
|
|
m_ocrThread = NULL;
|
|
HGBase_DestroyMsgPump(m_ocrMsgPump);
|
|
m_ocrMsgPump = NULL;
|
|
}
|
|
|
|
StopScan();
|
|
m_dlgScanInfo->Finish();
|
|
}
|
|
|
|
void MainWindow::on_comboBox_currentIndexChanged(const QString &arg1)
|
|
{
|
|
if (NULL != m_devHandle)
|
|
{
|
|
StopScan();
|
|
if (nullptr != m_dlgAdd)
|
|
m_dlgAdd->reject();
|
|
sane_close(m_devHandle);
|
|
m_devHandle = NULL;
|
|
m_devName.clear();
|
|
}
|
|
|
|
SANE_Status status = sane_open(arg1.toStdString().c_str(), &m_devHandle);
|
|
if (SANE_STATUS_GOOD == status)
|
|
{
|
|
m_devName = arg1;
|
|
AddManualScanParam();
|
|
}
|
|
}
|
|
|
|
void MainWindow::on_pushButtonScan_clicked()
|
|
{
|
|
assert(!m_scanning && nullptr == m_dlgAdd);
|
|
StartScan(0);
|
|
}
|
|
|
|
void MainWindow::on_trayActivated(QSystemTrayIcon::ActivationReason reason)
|
|
{
|
|
if (QSystemTrayIcon::Trigger == reason)
|
|
{
|
|
|
|
}
|
|
else if (QSystemTrayIcon::DoubleClick == reason)
|
|
{
|
|
show();
|
|
raise();
|
|
}
|
|
else if (QSystemTrayIcon::MiddleClick == reason)
|
|
{
|
|
|
|
}
|
|
}
|
|
|
|
void MainWindow::on_showMainWindowDlg()
|
|
{
|
|
show();
|
|
raise();
|
|
}
|
|
|
|
void MainWindow::on_pushButtonAdd_clicked()
|
|
{
|
|
if (nullptr == m_devHandle)
|
|
{
|
|
QMessageBox::information(this, tr("Tips"), tr("Device is offline"));
|
|
return;
|
|
}
|
|
|
|
std::string deviceType = m_devName.toStdString();
|
|
char v[256] = {0};
|
|
SANE_Status status = sane_control_option(m_devHandle, (SANE_Int)0x886D, SANE_ACTION_GET_VALUE, v, NULL);
|
|
if (SANE_STATUS_GOOD == status)
|
|
{
|
|
deviceType = v;
|
|
}
|
|
|
|
assert(nullptr == m_dlgAdd);
|
|
m_dlgAdd = new Dialog_Add(m_devHandle, this, deviceType);
|
|
if (m_dlgAdd->exec())
|
|
{
|
|
ScanParam scanParam = m_dlgAdd->GetScanParam();
|
|
m_vScanParams.push_back(scanParam);
|
|
SaveCfg();
|
|
|
|
ui->tableWidget->setRowCount((int)m_vScanParams.size());
|
|
int index = (int)m_vScanParams.size() - 1;
|
|
|
|
ui->tableWidget->setRowHeight(index, 30);
|
|
|
|
ui->tableWidget->setItem(index, 0, new QTableWidgetItem(QString(m_vScanParams[index].deviceType.c_str())));
|
|
ui->tableWidget->item(index, 0)->setTextAlignment(Qt::AlignCenter);
|
|
ui->tableWidget->item(index, 0)->setFlags(ui->tableWidget->item(index, 0)->flags() & ~Qt::ItemIsEditable);
|
|
|
|
const char *btnTypeStr[] = {"Manual", "Button 1", "Button 2", "Button 3"};
|
|
ui->tableWidget->setItem(index, 1, new QTableWidgetItem(btnTypeStr[m_vScanParams[index].buttonId]));
|
|
ui->tableWidget->item(index, 1)->setTextAlignment(Qt::AlignCenter);
|
|
ui->tableWidget->item(index, 1)->setFlags(ui->tableWidget->item(index, 1)->flags() & ~Qt::ItemIsEditable);
|
|
|
|
ui->tableWidget->setItem(index, 2, new QTableWidgetItem(GetDesc(m_vScanParams[index].deviceConfigs)));
|
|
ui->tableWidget->item(index, 2)->setTextAlignment(Qt::AlignCenter);
|
|
ui->tableWidget->item(index, 2)->setFlags(ui->tableWidget->item(index, 2)->flags() & ~Qt::ItemIsEditable);
|
|
|
|
ui->tableWidget->setItem(index, 3, new QTableWidgetItem(GetDesc(m_vScanParams[index].saveParam)));
|
|
ui->tableWidget->item(index, 3)->setTextAlignment(Qt::AlignCenter);
|
|
ui->tableWidget->item(index, 3)->setFlags(ui->tableWidget->item(index, 3)->flags() & ~Qt::ItemIsEditable);
|
|
|
|
ui->tableWidget->selectRow(index);
|
|
}
|
|
|
|
delete m_dlgAdd;
|
|
m_dlgAdd = nullptr;
|
|
}
|
|
|
|
void MainWindow::on_pushButtonModify_clicked()
|
|
{
|
|
int index = ui->tableWidget->currentRow();
|
|
if (-1 == index)
|
|
{
|
|
QMessageBox::information(this, tr("Tips"), tr("No item selected"));
|
|
return;
|
|
}
|
|
|
|
if (nullptr == m_devHandle)
|
|
{
|
|
QMessageBox::information(this, tr("Tips"), tr("Device is offline"));
|
|
return;
|
|
}
|
|
|
|
std::string deviceType = m_devName.toStdString();
|
|
char v[256] = {0};
|
|
SANE_Status status = sane_control_option(m_devHandle, (SANE_Int)0x886D, SANE_ACTION_GET_VALUE, v, NULL);
|
|
if (SANE_STATUS_GOOD == status)
|
|
{
|
|
deviceType = v;
|
|
}
|
|
|
|
if (deviceType != m_vScanParams[index].deviceType)
|
|
{
|
|
QMessageBox::information(this, tr("Tips"), tr("Device type mismatch"));
|
|
return;
|
|
}
|
|
|
|
assert(nullptr == m_dlgAdd);
|
|
m_dlgAdd = new Dialog_Add(m_devHandle, this, m_vScanParams[index], index);
|
|
if (m_dlgAdd->exec())
|
|
{
|
|
ScanParam scanParam = m_dlgAdd->GetScanParam();
|
|
m_vScanParams[index] = scanParam;
|
|
SaveCfg();
|
|
|
|
ui->tableWidget->item(index, 0)->setText(QString::fromStdString(m_vScanParams[index].deviceType));
|
|
|
|
const char *btnTypeStr[] = {"Manual", "Button 1", "Button 2", "Button 3"};
|
|
ui->tableWidget->item(index, 1)->setText(QString::fromStdString(btnTypeStr[m_vScanParams[index].buttonId]));
|
|
|
|
ui->tableWidget->item(index, 2)->setText(GetDesc(m_vScanParams[index].deviceConfigs));
|
|
ui->tableWidget->item(index, 3)->setText(GetDesc(m_vScanParams[index].saveParam));
|
|
}
|
|
|
|
delete m_dlgAdd;
|
|
m_dlgAdd = nullptr;
|
|
}
|
|
|
|
void MainWindow::on_pushButtonRemove_clicked()
|
|
{
|
|
int index = ui->tableWidget->currentRow();
|
|
if (-1 == index)
|
|
{
|
|
QMessageBox::information(this, tr("Tips"), tr("No item selected"));
|
|
return;
|
|
}
|
|
|
|
if (0 == m_vScanParams[index].buttonId)
|
|
{
|
|
QMessageBox::information(this, tr("Tips"), tr("Manual configuration items cannot be deleted"));
|
|
return;
|
|
}
|
|
|
|
QMessageBox msg(QMessageBox::Question, tr("Question"),
|
|
tr("Are you sure you want to remove the item?"),
|
|
QMessageBox::Yes | QMessageBox::No, this);
|
|
msg.exec();
|
|
if (msg.clickedButton() != msg.button(QMessageBox::Yes))
|
|
{
|
|
return;
|
|
}
|
|
|
|
m_vScanParams.erase(m_vScanParams.begin() + index);
|
|
SaveCfg();
|
|
ui->tableWidget->removeRow(index);
|
|
}
|