|
|
#include "devprinterstr.h"
|
|
|
#include <string.h>
|
|
|
#include <stdlib.h>
|
|
|
#include "global.h"
|
|
|
#include "cJSON.h"
|
|
|
#include <algorithm>
|
|
|
#include <fcntl.h>
|
|
|
#include <sys/ioctl.h>
|
|
|
#include <linux/lp.h>
|
|
|
#include <sys/io.h>
|
|
|
|
|
|
#include <unistd.h> /*Unix标准函数定义*/
|
|
|
#include <stdio.h>
|
|
|
bool little_than(const myprinterPara &s1, myprinterPara &s2)
|
|
|
{
|
|
|
return (s1.line < s2.line);
|
|
|
}
|
|
|
|
|
|
mySerialPort::mySerialPort()
|
|
|
{
|
|
|
m_DevStates = -1;
|
|
|
|
|
|
m_isAllowRead = 0;
|
|
|
}
|
|
|
|
|
|
int mySerialPort::PackagePro(unsigned char *Buf, int len)
|
|
|
{
|
|
|
int iRet;
|
|
|
m_mutex.Lock();
|
|
|
if (0 != m_isAllowRead)
|
|
|
{
|
|
|
m_isAllowRead = 0;
|
|
|
if (1 == len)
|
|
|
{
|
|
|
m_DevStates = GetComStates(Buf[0]);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
m_mutex.Unlock();
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
void mySerialPort::SetReadAllow(int iallow)
|
|
|
{
|
|
|
m_mutex.Lock();
|
|
|
m_isAllowRead = iallow;
|
|
|
m_mutex.Unlock();
|
|
|
}
|
|
|
|
|
|
INT32 mySerialPort::GetStates()
|
|
|
{
|
|
|
INT32 iRet;
|
|
|
m_mutex.Lock();
|
|
|
iRet = m_DevStates;
|
|
|
m_mutex.Unlock();
|
|
|
|
|
|
return iRet;
|
|
|
}
|
|
|
|
|
|
int mySerialPort::GetComStates(unsigned char cChar)
|
|
|
{
|
|
|
int iStates;
|
|
|
char btemp = cChar & 0x08;
|
|
|
if (0x0 == btemp)
|
|
|
{
|
|
|
iStates = 0;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
iStates = 1;
|
|
|
}
|
|
|
|
|
|
return iStates;
|
|
|
}
|
|
|
|
|
|
devprinterstr::devprinterstr()
|
|
|
{
|
|
|
}
|
|
|
|
|
|
int devprinterstr::InitStr()
|
|
|
{
|
|
|
memset(m_printerPort, 0, sizeof(m_printerPort));
|
|
|
|
|
|
m_StatePort = 0;
|
|
|
m_MaxCol = 0;
|
|
|
m_MaxLine = 0;
|
|
|
m_HeigthAdj = 0;
|
|
|
|
|
|
m_printType = PRINTTYPE_OTHER;
|
|
|
|
|
|
m_fd = -1;
|
|
|
m_nPrnVer = 1;
|
|
|
m_SerBaud =9600;
|
|
|
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
int devprinterstr::PRN_CreatePrinter(int nPrnVer, char *sPrintPort, int nColMax, int nLineMax,
|
|
|
int nHeigthAdj, char *sPortAddr, char *sFormat)
|
|
|
{
|
|
|
int iRet;
|
|
|
vector<myprinterPara>::iterator it;
|
|
|
|
|
|
InitStr();
|
|
|
if (!sPrintPort)
|
|
|
{
|
|
|
return -1;
|
|
|
}
|
|
|
|
|
|
if (iopl(3) < 0)
|
|
|
{
|
|
|
|
|
|
return -100;
|
|
|
}
|
|
|
|
|
|
/* if ((nHeigthAdj < 1) || (nHeigthAdj > 10))
|
|
|
{
|
|
|
return -101;
|
|
|
}
|
|
|
*/
|
|
|
iRet = strlen(sPrintPort);
|
|
|
if ((iRet > 30) || (iRet < 1))
|
|
|
{
|
|
|
return -2;
|
|
|
}
|
|
|
|
|
|
strcpy(m_printerPort, sPrintPort);
|
|
|
|
|
|
// charToUpper(m_printerPort);
|
|
|
iRet = GetPrinterType();
|
|
|
if (iRet < 0)
|
|
|
{
|
|
|
return -2;
|
|
|
}
|
|
|
|
|
|
// m_printType = PRINTTYPE_COM;
|
|
|
m_MaxCol = nColMax;
|
|
|
m_MaxLine = nLineMax;
|
|
|
m_HeigthAdj = nHeigthAdj;
|
|
|
m_nPrnVer = nPrnVer;
|
|
|
|
|
|
if (PRINTTYPE_LPT == m_printType)
|
|
|
{
|
|
|
m_StatePort = GetStatePort(sPortAddr);
|
|
|
if (m_StatePort < 0)
|
|
|
{
|
|
|
return -3;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
iRet = ParaJson(sFormat);
|
|
|
if (iRet < 0)
|
|
|
{
|
|
|
return -4;
|
|
|
}
|
|
|
|
|
|
iRet = m_printerPara.size();
|
|
|
if (iRet < 1)
|
|
|
{
|
|
|
return -100;
|
|
|
}
|
|
|
|
|
|
std::sort(m_printerPara.begin(), m_printerPara.end(), little_than);
|
|
|
it = m_printerPara.end() - 1;
|
|
|
if ((it->line) >= nLineMax)
|
|
|
{
|
|
|
return -101;
|
|
|
}
|
|
|
|
|
|
if (PRINTTYPE_COM == m_printType)
|
|
|
{
|
|
|
iRet = m_SerialPort.OpenPort(m_printerPort);
|
|
|
if (iRet < 0)
|
|
|
{
|
|
|
return -5;
|
|
|
}
|
|
|
// SetLineWidth();
|
|
|
return 0;
|
|
|
}
|
|
|
else if (PRINTTYPE_LPT == m_printType)
|
|
|
{
|
|
|
int iStates;
|
|
|
iRet = PRN_CheckLptPrinter(iStates);
|
|
|
if ((iRet < 0) || (0 != iStates))
|
|
|
{
|
|
|
return -6;
|
|
|
}
|
|
|
|
|
|
iRet = myOpenDev();
|
|
|
if (iRet < 0)
|
|
|
{
|
|
|
return -7;
|
|
|
}
|
|
|
|
|
|
/* iRet =SetLptLineWidth();
|
|
|
if(iRet <0)
|
|
|
{
|
|
|
return -4;
|
|
|
}
|
|
|
*/
|
|
|
return S_OK;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
return S_OK;
|
|
|
}
|
|
|
|
|
|
return S_OK;
|
|
|
}
|
|
|
|
|
|
int devprinterstr::GetPrinterType()
|
|
|
{
|
|
|
int iRet;
|
|
|
int iFlag = 0;
|
|
|
char *ptr = NULL;
|
|
|
int iFind = 0;
|
|
|
|
|
|
if (strstr(m_printerPort, "/dev/lp"))
|
|
|
{
|
|
|
m_printType = PRINTTYPE_LPT;
|
|
|
// return 0;
|
|
|
}
|
|
|
else if (strstr(m_printerPort, "/dev/tty"))
|
|
|
{
|
|
|
m_printType = PRINTTYPE_COM;
|
|
|
// return 0;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
return -1;
|
|
|
}
|
|
|
|
|
|
iRet = strlen(m_printerPort);
|
|
|
|
|
|
// if()
|
|
|
for (int i = 0; i < iRet; i++)
|
|
|
{
|
|
|
if (':' == m_printerPort[i])
|
|
|
{
|
|
|
iFind = 1;
|
|
|
m_printerPort[i] =0;
|
|
|
ptr = m_printerPort + i+1;
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if (1 == iFind)
|
|
|
{
|
|
|
iRet = GetBaud(ptr);
|
|
|
if (iRet < 0)
|
|
|
{
|
|
|
return -4;
|
|
|
}
|
|
|
m_SerBaud = iRet;
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
int devprinterstr::GetStatePort(char *sPortAddr)
|
|
|
{
|
|
|
char *pData;
|
|
|
char *pStopstr;
|
|
|
int iRet;
|
|
|
int base;
|
|
|
int iLen;
|
|
|
|
|
|
bool ok;
|
|
|
iRet = 0;
|
|
|
|
|
|
if (!sPortAddr)
|
|
|
{
|
|
|
return -1;
|
|
|
}
|
|
|
|
|
|
pData = sPortAddr;
|
|
|
iLen = strlen(sPortAddr);
|
|
|
|
|
|
if (iLen <= 2)
|
|
|
{
|
|
|
iRet = isnumer(sPortAddr);
|
|
|
if (iRet < 0)
|
|
|
{
|
|
|
return -1;
|
|
|
}
|
|
|
|
|
|
iRet = atoi(sPortAddr);
|
|
|
return iRet;
|
|
|
}
|
|
|
|
|
|
base = 10;
|
|
|
|
|
|
// 16 进制
|
|
|
if ('0' == sPortAddr[0])
|
|
|
{
|
|
|
if (('x' == sPortAddr[1]) || ('X' == sPortAddr[1]))
|
|
|
{
|
|
|
base = 16;
|
|
|
pData += 2;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
iRet = isnumer(pData, base);
|
|
|
if (iRet < 0)
|
|
|
{
|
|
|
return -2;
|
|
|
}
|
|
|
|
|
|
charToUpper(pData);
|
|
|
|
|
|
iRet = strtol(pData, &pStopstr, base);
|
|
|
if (0 == (pStopstr[0]))
|
|
|
{
|
|
|
return iRet;
|
|
|
}
|
|
|
|
|
|
return -3;
|
|
|
}
|
|
|
|
|
|
int devprinterstr::ParaJson(char *buf)
|
|
|
{
|
|
|
int iRet;
|
|
|
cJSON *root;
|
|
|
cJSON *object;
|
|
|
cJSON *item;
|
|
|
|
|
|
int size;
|
|
|
int iLen;
|
|
|
myprinterPara tmpPara;
|
|
|
|
|
|
if (!buf)
|
|
|
{
|
|
|
return -1;
|
|
|
}
|
|
|
|
|
|
iRet = strlen(buf);
|
|
|
if (iRet < 3)
|
|
|
{
|
|
|
return -2;
|
|
|
}
|
|
|
|
|
|
root = cJSON_Parse(buf);
|
|
|
if (!root)
|
|
|
{
|
|
|
return -3;
|
|
|
}
|
|
|
|
|
|
size = cJSON_GetArraySize(root);
|
|
|
if (0 == size)
|
|
|
{
|
|
|
cJSON_Delete(root);
|
|
|
return -4;
|
|
|
}
|
|
|
|
|
|
for (int i = 0; i < size; i++)
|
|
|
{
|
|
|
InitPrinterPara(&tmpPara);
|
|
|
|
|
|
object = cJSON_GetArrayItem(root, i);
|
|
|
if (!object)
|
|
|
{
|
|
|
cJSON_Delete(root);
|
|
|
return -5;
|
|
|
}
|
|
|
|
|
|
item = cJSON_GetObjectItem(object, PRINTERNANE);
|
|
|
if (!item)
|
|
|
{
|
|
|
cJSON_Delete(root);
|
|
|
return -6;
|
|
|
}
|
|
|
|
|
|
iLen = strlen(item->valuestring);
|
|
|
if (iLen >= 128)
|
|
|
{
|
|
|
cJSON_Delete(root);
|
|
|
return -7;
|
|
|
}
|
|
|
strcpy(tmpPara.Name, item->valuestring);
|
|
|
|
|
|
item = cJSON_GetObjectItem(object, PRINTERCOL);
|
|
|
if (item->valueint < 0)
|
|
|
{
|
|
|
cJSON_Delete(root);
|
|
|
return -7;
|
|
|
}
|
|
|
|
|
|
tmpPara.col = item->valueint;
|
|
|
|
|
|
item = cJSON_GetObjectItem(object, PRINTERLINE);
|
|
|
if (item->valueint < 0)
|
|
|
{
|
|
|
cJSON_Delete(root);
|
|
|
return -7;
|
|
|
}
|
|
|
|
|
|
tmpPara.line = item->valueint;
|
|
|
m_printerPara.push_back(tmpPara);
|
|
|
}
|
|
|
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
int devprinterstr::isPrtOk()
|
|
|
{
|
|
|
BYTE bTemp;
|
|
|
BYTE bFlag;
|
|
|
DWORD wData;
|
|
|
|
|
|
if(! GetPortVal)
|
|
|
{
|
|
|
return -1;
|
|
|
}
|
|
|
|
|
|
GetPortVal(m_StatePort, &wData, 1);
|
|
|
// wData = gfpInp32(m_StatePort);
|
|
|
bTemp = wData & 0xFF;
|
|
|
if( (0x0==bTemp) || (0xFF == bTemp))
|
|
|
{
|
|
|
return -2;
|
|
|
}
|
|
|
|
|
|
bFlag = bTemp & 0x10;
|
|
|
if(0x0 == bFlag)
|
|
|
{
|
|
|
|
|
|
return -3;
|
|
|
}
|
|
|
|
|
|
return 0;
|
|
|
}
|
|
|
*/
|
|
|
|
|
|
HRESULT devprinterstr::PRN_Print(char *pInfo)
|
|
|
{
|
|
|
int iRet;
|
|
|
vector<myprinterData> printerdatalist;
|
|
|
vector<myprinterInfo> printerInfolist;
|
|
|
|
|
|
if (!pInfo)
|
|
|
{
|
|
|
return -1;
|
|
|
}
|
|
|
|
|
|
iRet = strlen(pInfo);
|
|
|
if (iRet < 10)
|
|
|
{
|
|
|
return -2;
|
|
|
}
|
|
|
|
|
|
iRet = GetPrinterInfo(pInfo, printerInfolist);
|
|
|
if (iRet < 0)
|
|
|
{
|
|
|
return -3;
|
|
|
}
|
|
|
|
|
|
iRet = CreatePrinterData(printerdatalist, printerInfolist);
|
|
|
if (iRet < 0)
|
|
|
{
|
|
|
return -4;
|
|
|
}
|
|
|
|
|
|
if (PRINTTYPE_COM == m_printType)
|
|
|
{
|
|
|
iRet = StartPrintComData(printerdatalist);
|
|
|
if (iRet < 0)
|
|
|
{
|
|
|
return -5;
|
|
|
}
|
|
|
return 0;
|
|
|
}
|
|
|
else if (PRINTTYPE_LPT == m_printType)
|
|
|
{
|
|
|
iRet = StartPrintLptData(printerdatalist);
|
|
|
if (iRet < 0)
|
|
|
{
|
|
|
return -5;
|
|
|
}
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
//
|
|
|
int devprinterstr::GetPrinterInfo(char *pInfo, vector<myprinterInfo> &Infolist)
|
|
|
{
|
|
|
myprinterInfo tmpPara;
|
|
|
|
|
|
cJSON *root;
|
|
|
cJSON *object;
|
|
|
cJSON *item;
|
|
|
|
|
|
int size;
|
|
|
int iLen;
|
|
|
|
|
|
root = cJSON_Parse(pInfo);
|
|
|
if (!root)
|
|
|
{
|
|
|
return -1;
|
|
|
}
|
|
|
|
|
|
size = cJSON_GetArraySize(root);
|
|
|
if (0 == size)
|
|
|
{
|
|
|
cJSON_Delete(root);
|
|
|
return -2;
|
|
|
}
|
|
|
|
|
|
for (int i = 0; i < size; i++)
|
|
|
{
|
|
|
InitPrinterInfo(&tmpPara);
|
|
|
|
|
|
object = cJSON_GetArrayItem(root, i);
|
|
|
if (!object)
|
|
|
{
|
|
|
cJSON_Delete(root);
|
|
|
return -3;
|
|
|
}
|
|
|
|
|
|
item = cJSON_GetObjectItem(object, PRINTERNANE);
|
|
|
if (!item)
|
|
|
{
|
|
|
cJSON_Delete(root);
|
|
|
return -4;
|
|
|
}
|
|
|
|
|
|
iLen = strlen(item->valuestring);
|
|
|
if (iLen >= 128)
|
|
|
{
|
|
|
cJSON_Delete(root);
|
|
|
return -5;
|
|
|
}
|
|
|
strcpy(tmpPara.Name, item->valuestring);
|
|
|
|
|
|
item = cJSON_GetObjectItem(object, PRINTERVALUE);
|
|
|
if (!item)
|
|
|
{
|
|
|
cJSON_Delete(root);
|
|
|
return -6;
|
|
|
}
|
|
|
|
|
|
iLen = strlen(item->valuestring);
|
|
|
if (iLen >= 128)
|
|
|
{
|
|
|
cJSON_Delete(root);
|
|
|
return -7;
|
|
|
}
|
|
|
strcpy(tmpPara.Value, item->valuestring);
|
|
|
|
|
|
Infolist.push_back(tmpPara);
|
|
|
}
|
|
|
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
int devprinterstr::CreatePrinterData(vector<myprinterData> &Datalist,
|
|
|
vector<myprinterInfo> &Infolist)
|
|
|
{
|
|
|
int iLen;
|
|
|
int iRet;
|
|
|
int iFirst;
|
|
|
int issave;
|
|
|
|
|
|
myprinterData tmpData;
|
|
|
// myprinterPara tmpPara;
|
|
|
// myprinterInfo tmpinfo;
|
|
|
|
|
|
InitPrinterData(&tmpData);
|
|
|
|
|
|
iLen = sizeof(tmpData.Data);
|
|
|
|
|
|
vector<myprinterPara>::iterator itPara;
|
|
|
vector<myprinterInfo>::iterator itInfo;
|
|
|
iFirst = 0;
|
|
|
issave = 0;
|
|
|
for (itPara = m_printerPara.begin(); itPara != m_printerPara.end(); itPara++)
|
|
|
{
|
|
|
if ((itPara->line) != (tmpData.line))
|
|
|
{
|
|
|
if (0 == iFirst)
|
|
|
{
|
|
|
|
|
|
iFirst = 1;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
if (1 == issave)
|
|
|
{
|
|
|
Datalist.push_back(tmpData);
|
|
|
issave = 0;
|
|
|
}
|
|
|
}
|
|
|
tmpData.line = itPara->line;
|
|
|
memset(tmpData.Data, 0, iLen);
|
|
|
for (int j = 0; j < (iLen - 1); j++)
|
|
|
{
|
|
|
(tmpData.Data)[j] = ' ';
|
|
|
}
|
|
|
}
|
|
|
|
|
|
for (itInfo = Infolist.begin(); itInfo != Infolist.end(); itInfo++)
|
|
|
{
|
|
|
iRet = strcmp(itPara->Name, itInfo->Name);
|
|
|
if (0 == iRet)
|
|
|
{
|
|
|
int itmpLen = strlen(itInfo->Value);
|
|
|
if ((itmpLen + itPara->col) > (iLen - 1))
|
|
|
{
|
|
|
return -1;
|
|
|
}
|
|
|
memcpy(tmpData.Data + itPara->col, itInfo->Value, itmpLen);
|
|
|
issave = 1;
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if (1 == issave)
|
|
|
{
|
|
|
Datalist.push_back(tmpData);
|
|
|
issave = 0;
|
|
|
}
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
int devprinterstr::StartPrintComData(vector<myprinterData> &Datalist)
|
|
|
{
|
|
|
unsigned char FreeLenBuf[8];
|
|
|
int iLen;
|
|
|
char *pData;
|
|
|
vector<myprinterData>::iterator it;
|
|
|
char tempbuf[512];
|
|
|
unsigned char cWidth;
|
|
|
int iStates;
|
|
|
|
|
|
int iStartLen = 1;
|
|
|
strcpy((char *)FreeLenBuf, "\r\n");
|
|
|
|
|
|
SetComLineWidth(0x0C);
|
|
|
|
|
|
for (it = Datalist.begin(); it != Datalist.end(); it++)
|
|
|
{
|
|
|
|
|
|
if (iStartLen <= (it->line))
|
|
|
{
|
|
|
for (int j = iStartLen; j < it->line; j++)
|
|
|
{
|
|
|
//打印空行
|
|
|
m_SerialPort.WritePort(FreeLenBuf, 2);
|
|
|
}
|
|
|
|
|
|
iStartLen = it->line + 1;
|
|
|
iLen = strlen(it->Data);
|
|
|
pData = it->Data;
|
|
|
for (int j = (iLen - 1); j > 0; j--)
|
|
|
{
|
|
|
if (' ' == pData[j])
|
|
|
{
|
|
|
pData[j] = 0;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
iLen = strlen(pData);
|
|
|
if (iLen > m_MaxCol)
|
|
|
{
|
|
|
pData[m_MaxCol - 1] = 0;
|
|
|
}
|
|
|
|
|
|
memset(tempbuf, 0, sizeof(tempbuf));
|
|
|
strcpy(tempbuf, pData);
|
|
|
strcat(tempbuf, (const char *)FreeLenBuf);
|
|
|
|
|
|
m_SerialPort.WritePort((unsigned char *)tempbuf, strlen(tempbuf));
|
|
|
// m_SerialPort.WritePort(FreeLenBuf, strlen((char *)FreeLenBuf));
|
|
|
}
|
|
|
|
|
|
} // PrintFreeLine(tmpData.line - iStartLen);
|
|
|
|
|
|
for (int j = iStartLen; j < m_MaxLine; j++)
|
|
|
{
|
|
|
//打印空行
|
|
|
m_SerialPort.WritePort(FreeLenBuf, strlen((char *)FreeLenBuf));
|
|
|
}
|
|
|
|
|
|
//打印最后一行
|
|
|
cWidth = (unsigned char)(m_HeigthAdj & 0xFF);
|
|
|
SetComLineWidth(cWidth);
|
|
|
m_SerialPort.WritePort(FreeLenBuf, strlen((char *)FreeLenBuf));
|
|
|
|
|
|
//
|
|
|
SetComLineWidth(0x0C);
|
|
|
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
int devprinterstr::StartPrintLptData(vector<myprinterData> &Datalist)
|
|
|
{
|
|
|
char FreeLenBuf[8];
|
|
|
int iLen;
|
|
|
// int iRetLen;
|
|
|
char *pData;
|
|
|
vector<myprinterData>::iterator it;
|
|
|
// int fd;
|
|
|
int iRet;
|
|
|
char tempbuf[512];
|
|
|
unsigned char cWidth;
|
|
|
int iStates;
|
|
|
|
|
|
if (m_fd < 0)
|
|
|
{
|
|
|
return -1;
|
|
|
}
|
|
|
|
|
|
iRet = PRN_CheckLptPrinter(iStates);
|
|
|
if ((iRet < 0) || (0 != iStates))
|
|
|
{
|
|
|
return -100;
|
|
|
}
|
|
|
|
|
|
int iStartLen = 1;
|
|
|
strcpy(FreeLenBuf, "\r\n");
|
|
|
|
|
|
iRet = SetLptLineWidth(0x0C);
|
|
|
if (iRet < 0)
|
|
|
{
|
|
|
myCloseDev();
|
|
|
return -2;
|
|
|
}
|
|
|
// return 0;
|
|
|
|
|
|
for (it = Datalist.begin(); it != Datalist.end(); it++)
|
|
|
{
|
|
|
if (iStartLen <= (it->line))
|
|
|
{
|
|
|
for (int j = iStartLen; j < it->line; j++)
|
|
|
{
|
|
|
//打印空行
|
|
|
// m_SerialPort.WriteToPort(FreeLenBuf, 2);
|
|
|
iRet = myWrite(FreeLenBuf, 2);
|
|
|
if (iRet < 0)
|
|
|
{
|
|
|
myCloseDev();
|
|
|
return -3;
|
|
|
}
|
|
|
|
|
|
usleep(5000);
|
|
|
}
|
|
|
|
|
|
iStartLen = it->line + 1;
|
|
|
iLen = strlen(it->Data);
|
|
|
pData = it->Data;
|
|
|
for (int j = (iLen - 1); j > 0; j--)
|
|
|
{
|
|
|
if (' ' == pData[j])
|
|
|
{
|
|
|
pData[j] = 0;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
iLen = strlen(pData);
|
|
|
if (iLen > m_MaxCol)
|
|
|
{
|
|
|
pData[m_MaxCol - 1] = 0;
|
|
|
}
|
|
|
|
|
|
memset(tempbuf, 0, sizeof(tempbuf));
|
|
|
strcpy(tempbuf, pData);
|
|
|
strcat(tempbuf, FreeLenBuf);
|
|
|
|
|
|
iRet = myWrite(tempbuf, strlen(tempbuf));
|
|
|
if (iRet < 0)
|
|
|
{
|
|
|
myCloseDev();
|
|
|
return -4;
|
|
|
}
|
|
|
|
|
|
// usleep(2000);
|
|
|
}
|
|
|
|
|
|
} // PrintFreeLine(tmpData.line - iStartLen);
|
|
|
|
|
|
for (int j = iStartLen; j < m_MaxLine; j++)
|
|
|
{
|
|
|
//打印空行
|
|
|
iRet = myWrite(FreeLenBuf, 2);
|
|
|
if (iRet < 0)
|
|
|
{
|
|
|
myCloseDev();
|
|
|
return -6;
|
|
|
}
|
|
|
usleep(2000);
|
|
|
}
|
|
|
|
|
|
//打印最后一行
|
|
|
cWidth = (unsigned char)(m_HeigthAdj & 0xFF);
|
|
|
iRet = SetLptLineWidth(cWidth);
|
|
|
if (iRet < 0)
|
|
|
{
|
|
|
myCloseDev();
|
|
|
return -7;
|
|
|
}
|
|
|
|
|
|
iRet = myWrite(FreeLenBuf, 2);
|
|
|
if (iRet < 0)
|
|
|
{
|
|
|
myCloseDev();
|
|
|
return -8;
|
|
|
}
|
|
|
|
|
|
//
|
|
|
iRet = SetLptLineWidth(0x0C);
|
|
|
if (iRet < 0)
|
|
|
{
|
|
|
myCloseDev();
|
|
|
return -9;
|
|
|
}
|
|
|
|
|
|
// myCloseDev();
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
int devprinterstr::myWrite(char *buf, int iLen)
|
|
|
{
|
|
|
int iRet;
|
|
|
int iNum = 0;
|
|
|
int len = 0;
|
|
|
for (;;)
|
|
|
{
|
|
|
if (iNum > 10)
|
|
|
{
|
|
|
return -1;
|
|
|
}
|
|
|
|
|
|
iRet = write(m_fd, buf + len, iLen - len);
|
|
|
if (iRet < 0)
|
|
|
{
|
|
|
return -2;
|
|
|
}
|
|
|
|
|
|
if (0 == iRet)
|
|
|
{
|
|
|
iLen = 50000 + iLen * 1000;
|
|
|
if (iLen > 200000)
|
|
|
{
|
|
|
iLen = 2000000;
|
|
|
}
|
|
|
|
|
|
usleep(iLen);
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
len += iRet;
|
|
|
}
|
|
|
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
HRESULT devprinterstr::PRN_PaperCut()
|
|
|
{
|
|
|
if (PRINTTYPE_COM == m_printType)
|
|
|
{
|
|
|
unsigned char buf[8];
|
|
|
memset(buf, 0, sizeof(buf));
|
|
|
|
|
|
buf[0] = 0x1B;
|
|
|
buf[1] = 0x64;
|
|
|
buf[2] = 0x31;
|
|
|
|
|
|
m_SerialPort.WritePort(buf, 3);
|
|
|
}
|
|
|
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
HRESULT devprinterstr::PRN_Close()
|
|
|
{
|
|
|
if (PRINTTYPE_COM == m_printType)
|
|
|
{
|
|
|
m_SerialPort.ClosePort();
|
|
|
m_printerPara.resize(0);
|
|
|
}
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
int devprinterstr::PRN_CheckPrinter(INT32 &iStatus)
|
|
|
{
|
|
|
if (PRINTTYPE_LPT == m_printType)
|
|
|
{
|
|
|
// return -1;
|
|
|
return PRN_CheckLptPrinter(iStatus);
|
|
|
}
|
|
|
else if (PRINTTYPE_COM == m_printType)
|
|
|
{
|
|
|
return PRN_CheckComPrinter(iStatus);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
return -2;
|
|
|
}
|
|
|
|
|
|
return -3;
|
|
|
}
|
|
|
|
|
|
int devprinterstr::PRN_CheckComPrinter(INT32 &iStatus)
|
|
|
{
|
|
|
char unsigned buf[8];
|
|
|
int iLen;
|
|
|
memset(buf, 0, sizeof(buf));
|
|
|
buf[0] = 0x05;
|
|
|
|
|
|
m_SerialPort.SetReadAllow(1);
|
|
|
m_SerialPort.WritePort(buf, 1);
|
|
|
usleep(50000);
|
|
|
|
|
|
iStatus = m_SerialPort.GetStates();
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
int devprinterstr::PRN_CheckLptPrinter(INT32 &iStatus)
|
|
|
{
|
|
|
// int k;
|
|
|
// int iRet;
|
|
|
unsigned char bTemp;
|
|
|
|
|
|
/* if (m_fd < 0)
|
|
|
{
|
|
|
iRet = myOpenDev();
|
|
|
if (iRet < 0)
|
|
|
{
|
|
|
return -1;
|
|
|
}
|
|
|
}
|
|
|
*/
|
|
|
/* generate RESET pulse */
|
|
|
/* if (ioctl(m_fd, LPGETSTATUS, &k) < 0)
|
|
|
{
|
|
|
// fprintf(stderr, "getstatus ioctl failed\n");
|
|
|
myCloseDev();
|
|
|
return -2;
|
|
|
}
|
|
|
*/
|
|
|
|
|
|
// bTemp = (unsigned char)(k & 0xFF);
|
|
|
// bTemp = inb(m_StatePort);
|
|
|
bTemp = inb(0x1001);
|
|
|
iStatus = GetLptStates(bTemp);
|
|
|
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
int devprinterstr::SetComLineWidth(unsigned char cLen)
|
|
|
{
|
|
|
unsigned char buf[8];
|
|
|
memset(buf, 0, sizeof(buf));
|
|
|
|
|
|
buf[0] = 0x1B;
|
|
|
buf[1] = 0x41;
|
|
|
buf[2] = cLen;
|
|
|
|
|
|
m_SerialPort.WritePort(buf, 3);
|
|
|
|
|
|
memset(buf, 0, sizeof(buf));
|
|
|
buf[0] = 0x1B;
|
|
|
buf[1] = 0x32;
|
|
|
m_SerialPort.WritePort(buf, 2);
|
|
|
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
int devprinterstr::SetLptLineWidth(unsigned char cLen)
|
|
|
{
|
|
|
char buf[8];
|
|
|
int iRet;
|
|
|
|
|
|
buf[0] = 0x1B;
|
|
|
buf[1] = 0x41;
|
|
|
buf[2] = cLen;
|
|
|
|
|
|
iRet = myWrite(buf, 3);
|
|
|
if (iRet < 0)
|
|
|
{
|
|
|
// myCloseDev();
|
|
|
return -1;
|
|
|
}
|
|
|
|
|
|
usleep(1000);
|
|
|
|
|
|
memset(buf, 0, sizeof(buf));
|
|
|
buf[0] = 0x1B;
|
|
|
buf[1] = 0x32;
|
|
|
|
|
|
iRet = myWrite(buf, 2);
|
|
|
if (iRet < 0)
|
|
|
{
|
|
|
// myCloseDev();
|
|
|
return -1;
|
|
|
}
|
|
|
|
|
|
usleep(2000);
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
int devprinterstr::myOpenDev()
|
|
|
{
|
|
|
int fd;
|
|
|
int iRet;
|
|
|
|
|
|
//已打开
|
|
|
if (-1 != m_fd)
|
|
|
{
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
if ((fd = open(m_printerPort, O_WRONLY | O_NONBLOCK)) < 0)
|
|
|
{
|
|
|
// fprintf(stderr, "can not open %s\n", DEVICE);
|
|
|
return -1;
|
|
|
}
|
|
|
|
|
|
iRet = ioctl(fd, LPRESET);
|
|
|
if (0 != iRet)
|
|
|
{
|
|
|
close(fd);
|
|
|
return -2;
|
|
|
}
|
|
|
|
|
|
m_fd = fd;
|
|
|
return 0;
|
|
|
}
|
|
|
|
|
|
void devprinterstr::myCloseDev()
|
|
|
{
|
|
|
if (m_fd < 0)
|
|
|
{
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
close(m_fd);
|
|
|
m_fd = -1;
|
|
|
}
|
|
|
|
|
|
int devprinterstr::GetLptStates(unsigned char cchar)
|
|
|
{
|
|
|
// int iRet;
|
|
|
unsigned char ctemp;
|
|
|
unsigned char cbyte;
|
|
|
|
|
|
if ((0x00 == cchar) || (0xFF == cchar))
|
|
|
{
|
|
|
return -1;
|
|
|
}
|
|
|
|
|
|
ctemp = cchar & 0x80;
|
|
|
|
|
|
//<2F>ػ<EFBFBD><D8BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
|
|
if (0x00 != ctemp)
|
|
|
{
|
|
|
cbyte = cchar & 0x08;
|
|
|
if (0x00 == cbyte)
|
|
|
{
|
|
|
return -1;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
return 0;
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
cbyte = cchar & 0x20;
|
|
|
if (0x00 == cbyte)
|
|
|
{
|
|
|
return 2;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
return 1;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return -1;
|
|
|
}
|