myvtm/DevAdapter/gwi/ThermalPrint1.1/ThermalPrintDriverGWI.cpp

#include "ThermalPrintDriverGWI.h"
#include "ThermalPrintSP.h"
#include "GwiLogFile.h"
#include "ErrorDefine.h"
#include <time.h>
#include <pthread.h>
#include <vector>
#include <iostream>
#include <string>

using namespace std;
char textBuff[4096]={0};
static int textLen=0;
static int lpszPathAllNum=0;
static long waitTime0;
int devColseFlag=false;

static char gDllModuleHelper = 0;
CLogFile *m_plogFile = NULL;
CThermalPrintSP *m_pThermalPrintSP = NULL;

pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;

LPSTR lpszPath="/tmp/tmp.bmp";
LPSTR lpszFields="GraphicFiled=/tmp/tmp.bmp\0\0";
static const std::string base64_chars = 
	"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
	"abcdefghijklmnopqrstuvwxyz"
	"0123456789+/";

static inline bool is_base64(BYTE c) {
	return (isalnum(c) || (c == '+') || (c == '/'));
}

std::vector<BYTE> base64_decode(std::string const& encoded_string) {
	int in_len = encoded_string.size();
	int i = 0;
	int j = 0;
	int in_ = 0;
	BYTE char_array_4[4], char_array_3[3];
	std::vector<BYTE> ret;

	while (in_len-- && ( encoded_string[in_] != '=') && is_base64(encoded_string[in_])) {
		char_array_4[i++] = encoded_string[in_]; in_++;
		if (i ==4) {
			for (i = 0; i <4; i++)
				char_array_4[i] = base64_chars.find(char_array_4[i]);

			char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
			char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
			char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];

			for (i = 0; (i < 3); i++)
				ret.push_back(char_array_3[i]);
			i = 0;
		}
	}

	if (i) {
		for (j = i; j <4; j++)
			char_array_4[j] = 0;

		for (j = 0; j <4; j++)
			char_array_4[j] = base64_chars.find(char_array_4[j]);

		char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
		char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
		char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];

		for (j = 0; (j < i - 1); j++) ret.push_back(char_array_3[j]);
	}

	return ret;
}

void stdBytes2File(char *allPath,std::vector<BYTE> allBytes)
{
	FILE *fp;
	BYTE b;
	
	fp=fopen(allPath,"wb");
	for(std::vector<BYTE>::iterator iter=allBytes.begin();iter!=allBytes.end();iter++)
	{
		b=*iter;
		fwrite(&b,sizeof(BYTE),1,fp);
	}
	fclose(fp);
}

CThermalPrint::CThermalPrint()
{
	m_gwiErrorCode = -1;

	memset(&m_DevErrorInfo,0,sizeof(m_DevErrorInfo));
	ResetParam();
	if(NULL == m_plogFile)
	{
		m_plogFile = new CLogFile(LAYER);
		m_plogFile->init();

		LogARG(m_plogFile, Log_Infor, "CThermalPrint", "Init ThermalPrint LOG success!");
	}

	if(NULL == m_pThermalPrintSP)
	{
		m_pThermalPrintSP = new CThermalPrintSP(m_plogFile);
	}
}

CThermalPrint::~CThermalPrint()
{
	pthread_mutex_destroy(&mtx);
	if(NULL != m_pThermalPrintSP)
	{
		delete m_pThermalPrintSP;
		m_pThermalPrintSP = NULL;
	}
}

void CThermalPrint::ResetParam(void)
{
	m_RowSpace=0;//行间距 单位mm
	m_Align=0;//字符对齐模式 单位是"AlignStyle"的值
	m_Reverse=0;//颠倒打印（注意需要设置退出或者切纸才行，并在行首） 取值（0：正常打印 1：颠倒打印）
	m_LeftMargin=0;//左边距 单位mm
	m_PrintArea=80;//可打印区域 单位mm

	m_Font_UnderLine=0;//下划线 取值（0：否 1：是）
	m_Font_Bold=0;//粗体 取值（0：否 1：是）
	m_Font_Inverse=0;//反白 取值（0：否 1：是）
	m_Font_DoubleHeight=0;//纵翻倍放大 取值（0：否 1：是）FONT_UNDERLINE = 0,//下划线 取值（0：否 1：是）
	m_Font_DoubleWide=0;//横翻倍向放大 取值（0：否 1：是）
	m_Font_SizeH=0;//字体宽高自定义，取值（宽 {1..6} ,长 {1..6}）
	m_Font_SizeW=0;//字体宽高自定义，取值（宽 {1..6} ,长 {1..6}）
	m_Font_Rotate=0;//字体旋转 取值（0,90,180,270）
	m_Font_SpaceL=0;//字符左右边距设置 单位mm 取值（左边距 {0..36},右边距 {0..36}）
	m_Font_SpaceR=0;//字符左右边距设置 单位mm 取值（左边距 {0..36},右边距 {0..36}）
}

ErrorCodeEnum CThermalPrint::GetDevCategory(DevCategoryInfo &devCategory)
{
	LogARG(m_plogFile, Log_Infor, "GetDevCategory", "Enter...");

	m_gwiErrorCode = GWI_Error_Succeed;

	long lResult = 0;
	int nstatus = 0;
	char DevFirmware[1024]={0};
	memset(DevFirmware,0x00,sizeof(DevFirmware));
	lResult = m_pThermalPrintSP->ThermalPrint_GetStatus(nstatus,DevFirmware);

	if(RET_SUCCESS != lResult)
	{
		LogARG(m_plogFile, Log_Error, "GetDevCategory", "ThermalPrint_GetStatus failed,nResult = <%d>",lResult);
		devCategory.eState = DEVICE_STATUS_FAULT;
	}
	else
	{
		devCategory.eState = DEVICE_STATUS_NORMAL;
	}

	sprintf(devCategory.szModel,"FWID=%s",DevFirmware);    
	strcpy(devCategory.szType,"PVER=GWI#MID=JUST E6020-K");
	strcpy(devCategory.szVendor,"GWI");

	devCategory.version.wMajor = 1;
	devCategory.version.wBuild = 1;
	devCategory.version.wMinor = 1;
	devCategory.version.wRevision = 1;

	if(nstatus == WFS_PTR_DEVBUSY)
	{
		m_gwiErrorCode = GWI_Error_Dev_Busy;
	}
	else if(nstatus == WFS_PTR_DEVOFFLINE)
	{
		m_gwiErrorCode = GWI_Error_Dev_Offline;
	}
	else if(nstatus != WFS_PTR_DEVONLINE)
	{
		m_gwiErrorCode = GWI_Error_Dev_Error;
	}


	LogARG(m_plogFile, Log_Infor, "GetDevCategory", "Exit, lResult = <%d>",lResult);
	return ErrParse(m_gwiErrorCode); 
}

ErrorCodeEnum CThermalPrint::Reset()
{
	LogARG(m_plogFile, Log_Infor, "Reset", "Enter...");
	long lResult = 0;

	m_gwiErrorCode = GWI_Error_Succeed;

	lResult = m_pThermalPrintSP->ThermalPrint_Reset();
	if(RET_SUCCESS != lResult)
	{
		LogARG(m_plogFile, Log_Error, "Reset", "Reset failed,nResult = <%d>",lResult);
		m_gwiErrorCode = GWI_Error_Dev_Reset;
	}

	LogARG(m_plogFile, Log_Infor, "Reset", "Exit,lResult = <%d>",lResult);
	return ErrParse(m_gwiErrorCode); 
}

unsigned long GetTickCount() 
{ 
    struct timespec ts; 
    clock_gettime(CLOCK_MONOTONIC, &ts); 
    return (ts.tv_sec * 1000 + ts.tv_nsec / 1000000); 
}

void * printProc( void *param )
{
	char threadTemp[4666] = {0} ;
	int threadStrLen = 0 ;
	LogARG(m_plogFile, Log_Infor, "printProc", "Enter...");
	while(1)
	{
		if(devColseFlag)break;//关闭设备退出线程

		if( (GetTickCount() - waitTime0) < 1000)
		{	
			usleep(100*1000);
			continue;//等待时间未到，上次数据发送之后，未空闲1秒
		}

		int err = pthread_mutex_trylock(&mtx);
		if(0 == err)//抢到锁
		{
			if( textLen>0 && textBuff[textLen-1] == 0x0a)
			{
					threadStrLen = textLen ;
					memcpy(threadTemp , textBuff , textLen );
					textLen = 0;
					memset(textBuff,0,sizeof(textBuff));
					LogARG(m_plogFile, Log_Infor, "printProc", "PrintRawData =[%d]%s" , threadStrLen , threadTemp);	
					int ret = m_pThermalPrintSP->ThermalPrint_PrintRawData((LPBYTE)threadTemp, threadStrLen);
					if(ret == -14)
					{
						usleep(1000*1000);
						LogARG(m_plogFile,Log_Infor,"printProc","reprint!!!");
						ret = m_pThermalPrintSP->ThermalPrint_PrintRawData((LPBYTE)textBuff,textLen);
					}
			}
			else
			{
				//LogARG(m_plogFile,Log_Infor,"printProc","textBuff have not 0x0a or len = <%d>", textLen);
			}
			
			pthread_mutex_unlock(&mtx);
			waitTime0 = GetTickCount();
			//LogARG(m_plogFile, Log_Infor, "GetTickCount", "waitTime0 = <%d>", waitTime0);
		}
		else//抢不到锁，说明数据正在被处理，等待对方打印完成
		{
			LogARG(m_plogFile,Log_Infor,"printProc","waiting!!!");
			usleep(5000*1000);
		}
	}
	LogARG(m_plogFile, Log_Infor, "printProc", "Exit...");
	return 0;
}

ErrorCodeEnum CThermalPrint::DevClose()
{
	LogARG(m_plogFile, Log_Infor, "DevClose", "Enter...");
	long lResult = 0;

	devColseFlag=true;
	m_gwiErrorCode = GWI_Error_Succeed;

	lResult = m_pThermalPrintSP->ThermalPrint_CloseDevice();
	if(RET_SUCCESS != lResult)
	{
		LogARG(m_plogFile, Log_Error, "DevClose", "Close failed,nResult = <%d>",lResult);
		m_gwiErrorCode = GWI_Error_Dev_Close;
	}

	LogARG(m_plogFile, Log_Infor, "DevClose", "Exitl,Result = <%d>",lResult);
	return ErrParse(m_gwiErrorCode); 
}

// ErrorCodeEnum CThermalPrint::GetLastErr(DevErrorInfo &devErrInfo)
// {
// 	LogARG(m_plogFile, Log_Infor, "GetLastErr", "Enter...");

// 	memset(&devErrInfo,0,sizeof(DevErrorInfo));
// 	memcpy(&devErrInfo,&m_DevErrorInfo,sizeof(DevErrorInfo));

// 	LogARG(m_plogFile, Log_Infor, "GetLastErr", "Exit...");
// 	return Error_Succeed;
// }

#if DEVICE_BASE_INTERFACE_FILE_VERSION == 2
ErrorCodeEnum CThermalPrint::DevOpen(int argNum, char* argArray)
#else
ErrorCodeEnum CThermalPrint::DevOpen(BYTE btPort,DWORD dwBaudRate)
{
	LogARG(m_plogFile, Log_Infor, "DevOpen", "Enter,dwPort = <%d> dwBaudRate = <%d>",btPort,dwBaudRate);
	long lResult = 0;
	m_gwiErrorCode = GWI_Error_Succeed;

	lResult = m_pThermalPrintSP->ThermalPrint_OpenDevice();
	if(RET_SUCCESS != lResult)
	{
		LogARG(m_plogFile, Log_Error, "DevOpen", "open failed,nResult = <%d>",lResult);
		if(Error_DevConnFailed == lResult)
		{
			m_gwiErrorCode = GWI_Error_Dev_Connect;
		}
		else
		{
			m_gwiErrorCode = GWI_Error_Dev_Open;
		}

	}

	textLen = 0;
	lpszPathAllNum = 0;
	devColseFlag = false;

	pthread_t Thread;
	pthread_create(&Thread, NULL, printProc, (void *)this);

	LogARG(m_plogFile, Log_Infor, "DevOpen", "Exitl,Result = <%d>",lResult);
	return ErrParse(m_gwiErrorCode); 
}
#endif




//	获取打印机实时状态
ErrorCodeEnum CThermalPrint::GetDevState(ThermalState &devState)
{
	int iStatus;
	int iPaperStatus;
	m_gwiErrorCode = GWI_Error_Succeed;

	LogARG(m_plogFile, Log_Infor, "GetDevState", "Enter...");
	long lResult = 0;
	char DevFirmware[1024]={0};
	memset(DevFirmware,0x00,sizeof(DevFirmware));
	lResult = m_pThermalPrintSP->ThermalPrint_GetStatus(iStatus,DevFirmware);
	if(RET_SUCCESS != lResult)
	{
		LogARG(m_plogFile, Log_Error, "GetDevState", "ThermalPrint_GetStatus failed,nResult = <%d>",lResult);
		devState.hardwareState = STATE_OTHER_ERROR;
		m_gwiErrorCode = GWI_Error_Dev_State;
	}
	else
	{
		if(iStatus==WFS_PTR_DEVONLINE ||iStatus==WFS_PTR_DEVBUSY)
			devState.hardwareState = STATE_OK;
		else
			devState.hardwareState = STATE_OTHER_ERROR;
		LogARG(m_plogFile,Log_Infor, "GetDevState","OutVaule: devState.hardwareState= %d",devState.hardwareState);
		
		usleep(100*1000);
		lResult = m_pThermalPrintSP->ThermalPrint_GetPaperStatus(iPaperStatus);

		LogARG(m_plogFile,Log_Infor, "GetDevState","ThermalPrint_GetPaperStatus failed lResult = %d",lResult);
		if(RET_SUCCESS != lResult)
		{
			LogARG(m_plogFile, Log_Error, "GetDevState", "ThermalPrint_GetStatus failed,nResult = <%d>",lResult);
			devState.hardwareState = STATE_OTHER_ERROR;
		}
		else
		{
			if(iPaperStatus==WFS_PTR_PAPERFULL)
				devState.paperState = PAPER_FULL;
			else if(iPaperStatus==WFS_PTR_PAPERLOW)
				devState.paperState = PAPER_LOW;
			else if(iPaperStatus==WFS_PTR_PAPERLOW)
				devState.paperState = PAPER_EMPTY;
			else if(iPaperStatus==WFS_PTR_PAPERLOW)
				devState.paperState = PAPER_JAMMED;
			else
				devState.paperState = PAPER_EMPTY;
		}
	}

	LogARG(m_plogFile,Log_Infor, "GetDevState","Exit: lResult = %d",lResult);
	return ErrParse(m_gwiErrorCode); 
}

//开始打印初始设置:paperWidth一般为80mm和57mm
ErrorCodeEnum CThermalPrint::BeginPrint(ThermalPaperType eType,int paperWidth)
{
	LogARG(m_plogFile,Log_Infor, "BeginPrint","Enter eType = %d, paperWidth = %d",eType,paperWidth);

	m_gwiErrorCode = WFS_SUCCESS;
	m_deviceStatus = DEVICE_STATUS_NORMAL;
	m_gwiErrorCode = GWI_Error_Succeed;

	ResetParam();

	m_PaperType = eType;
	m_PaperWidth = paperWidth;
	LogARG(m_plogFile,Log_Infor,"BeginPrint","Exit: m_gwiErrorCode = %d",m_gwiErrorCode);
	return ErrParse(m_gwiErrorCode);
}

//打印控制指令函数:主要是打印，切纸和控制打印光标指令函数
//第三个参数是预留参数 暂时无用到
ErrorCodeEnum CThermalPrint::ControlAction(PrintAction eAction,DWORD dwValue1,DWORD dwValue2)
{	
	LogARG(m_plogFile,Log_Infor,"ControlAction","Enter eAction = %d, dwValue1 = %d, dwValue2 = %d",eAction,dwValue1,dwValue2);

	long ret=0;
	int iAction;
	int iRightMove = 0;
	char newLine[32]={0};
	char moveInLine[32]={0};
	m_gwiErrorCode = GWI_Error_Succeed;
	m_deviceStatus = DEVICE_STATUS_NORMAL;
	/*chr20180503修改  解决右移问题*/
	if(eAction == ACTION_MOVE_TO_POSITION_RELATIVE)
	{
		iRightMove = dwValue1;
	}
	/*end*/
	sprintf(newLine,"0|0|%d|%d|%d|%d|%d|111000000|\x0a",m_LeftMargin,m_PrintArea,m_RowSpace,m_Font_SpaceL,m_Font_SpaceR);
	//sprintf(moveInLine,"0|0|%d|%d|%d|%d|%d|111000000| ",m_LeftMargin,m_PrintArea,m_RowSpace,0,0);/*chr20180503�޸�  �����������*/
	sprintf(moveInLine,"%d|0|%d|%d|%d|%d|%d|111000000|\x0a",iRightMove,m_LeftMargin,m_PrintArea,m_RowSpace,0,0);
	
	switch(eAction)
	{
	case ACTION_PRINT_ONE_LINE://打印走纸一行
	case ACTION_PRINT_MOVEFORWRAD_LINES://打印并走纸n行（单位:字符行）//TODO
		iAction = 0x0010;
		break;
	
	case ACTION_PRINT_MOVEBACKWRAD_LINES://回纸n行（单位:字符行）
		iAction = 0x0001;
		break;

	case ACTION_CUT_ALL://全切纸
		pthread_mutex_lock(&mtx);
		if(textLen>0)
		{
			//if(logFile) logFile->Log_Infor(myName, __FILE__, __LINE__, __FUNCDNAME__,"PrintRawData =[%d]%s",textLen,textBuff);
			printf("=======textBuff=[%s],textLen=[%d]===========\n",textBuff,textLen);
			ret = m_pThermalPrintSP->ThermalPrint_PrintRawData((LPBYTE)textBuff,textLen);
			if(ret == -14)
			{
				usleep(1000*1000);
				LogARG(m_plogFile,Log_Infor,"ControlAction","reprint!!!");
				ret = m_pThermalPrintSP->ThermalPrint_PrintRawData((LPBYTE)textBuff,textLen);
			}
			textLen = 0;
			//lpszPathAllNum=0;	//切纸不值0， 避免文件重复
			memset(textBuff,0,sizeof(textBuff));
		}
		pthread_mutex_unlock(&mtx);
		if(ret != 0)
		{
			LogARG(m_plogFile,Log_Infor,"ControlAction","XFS_PrintRawData ret=%d",ret);
			goto exit;
		}

		iAction = 0x0004;
		break;
	case ACTION_CUT_HALF://半切纸
		pthread_mutex_lock(&mtx);
		if(textLen>0)
		{
			ret = m_pThermalPrintSP->ThermalPrint_PrintRawData((LPBYTE)textBuff,textLen);
			textLen = 0;
			//lpszPathAllNum=0; //切纸不值0
			memset(textBuff,0,sizeof(textBuff));
		}
		pthread_mutex_unlock(&mtx);
		iAction = 0x0080;
		break;

	//case ACTION_MOVE_TO_POSITION_RELATIVE://把打印光标移动相对当前位置一段距离（横向），单位mm
	//case ACTION_MOVE_TO_FORWRAD_LENGTH://移动向前走纸一段距离（距离包括本行高度在内） 单位:mm
	case ACTION_MOVE_TO_BLACKMARK://移动到黑标位置，把打印位置设置在行首（标记纸有效）
		iAction = 0x0008;
		break;
	//case ACTION_PRINT_MOVEBACK_TO_LINE://设置起始位置在行首，取值（0：打印内容返回行首，1：清空要打印的内容返回行首）
	default :
		iAction = 0x0010;
		break;
	}

	LogARG(m_plogFile,Log_Infor,"ControlAction","eAction = %d, iAction = %d",eAction,iAction);
	//���ƽ��ʶ���
	if(eAction == ACTION_PRINT_ONE_LINE)
	{
		if(textLen>0)
		{
			textBuff[textLen]= '&';
			textLen++;
		}
		memcpy(&textBuff[textLen],newLine,strlen(newLine));
		textLen += strlen(newLine);
		waitTime0 = GetTickCount();
		//LogARG(m_plogFile, Log_Infor, "GetTickCount", "waitTime0 = <%d>", waitTime0);
	}
	else if(eAction == ACTION_PRINT_MOVEFORWRAD_LINES)
	{
		for(int i=0;i<dwValue1;i++)
		{
			if(textLen>0)
			{
				textBuff[textLen]= '&';
				textLen++;
			}
			memcpy(&textBuff[textLen],newLine,strlen(newLine));
			textLen += strlen(newLine);
		}
		waitTime0 = GetTickCount();
		//LogARG(m_plogFile, Log_Infor, "GetTickCount", "waitTime0 = <%d>", waitTime0);
	}
	
	else if(eAction == ACTION_MOVE_TO_POSITION_RELATIVE)
	{
	/*chr20180503修改  解决右移问题
		for(int i=0;i<dwValue1/2;i++)
		{
			strcat(moveInLine," ");
			if(i>=80)break;
		}
	*/	
		LogARG(m_plogFile, Log_Infor, "ControlAction", "moveInLine = <%s>", moveInLine);
		if(textLen>0)
		{
			textBuff[textLen]= '&';
			textLen++;
		}
		memcpy(&textBuff[textLen],moveInLine,strlen(moveInLine));
		textLen += strlen(moveInLine);
		waitTime0 = GetTickCount();
		//LogARG(m_plogFile, Log_Infor, "GetTickCount", "waitTime0 = <%d>", waitTime0);
	}
	
	else 
	{
		ret = m_pThermalPrintSP->ThermalPrint_ControlMedia(iAction);
	}

exit:
	LogARG(m_plogFile,Log_Infor,"ControlAction","ret = %d",ret);

	if(ret !=0)
	{
		m_deviceStatus = DEVICE_STATUS_FAULT;
		m_gwiErrorCode = GWI_Error_Dev_State;
	}

	LogARG(m_plogFile,Log_Infor,"ControlAction","textBuff=[%s]textLen = %d",textBuff, textLen);

	LogARG(m_plogFile,Log_Infor,"ControlAction","Exit: m_gwiErrorCode = %d",m_gwiErrorCode);
	return ErrParse(m_gwiErrorCode);
}

//打印参数指令函数：
//第三个参数是预留参数 暂时无用到
ErrorCodeEnum CThermalPrint::SetParam(CommandType eType,DWORD dwValue1,DWORD dwValue2)
{
	LogARG(m_plogFile,Log_Infor,"SetParam","Enter eType = %d, dwValue1 = %d, dwValue2 = %d",eType,dwValue1,dwValue2);
	m_gwiErrorCode = GWI_Error_Succeed;

	switch(eType)
	{
	case COMMON_ROW_SPACE://行间距 单位mm
		m_RowSpace = dwValue1;
		break;
	case COMMON_ALIGN:	//字符对齐模式 单位是"AlignStyle"的值
		m_Align = dwValue1;
		break;
	case COMMON_REVERSE://颠倒打印（注意需要设置退出或者切纸才行，并在行首） 取值（0：正常打印 1：颠倒打印）
		m_Reverse = dwValue1;
		break;
	case COMMON_LEFT_MARGIN://左边距 单位mm
		m_LeftMargin = dwValue1;
		break;
	case COMMON_PRINTABLE_AREA://可打印区域 单位mm
		m_PrintArea = dwValue1;
		break;
	default:
		break;
	}
	LogARG(m_plogFile,Log_Infor,"SetParam","Exit: m_gwiErrorCode = %d",m_gwiErrorCode);
	return ErrParse(m_gwiErrorCode);
}

//打印字体指令函数：主要是字体相关饿指令函数
//第三个参数是预留参数 设置FONT_CUSTOM_SIZE用到，dwValue1表示宽，dwValue2表示长
//					设置FONT_LEFT_RIGHT_SPACE用到 dwValue1表示左边距 dwValue2表示右边距
ErrorCodeEnum CThermalPrint::SetFont(FontStyle eType,DWORD dwValue1,DWORD dwValue2)
{
	LogARG(m_plogFile,Log_Infor,"SetFont","Enter");
	LogARG(m_plogFile,Log_Infor,"SetFont","eType=%d,dwValue1=%d,dwValue2=%d",eType,dwValue1,dwValue2);
	m_gwiErrorCode = GWI_Error_Succeed;

	switch(eType)
	{
		case FONT_UNDERLINE://粗体 取值（0：否 1：是）
			m_Font_UnderLine = dwValue1;
			break;
		case FONT_BOLD://粗体 取值（0：否 1：是）
			m_Font_Bold = dwValue1;
			break;
		case FONT_INVERSE:	//反白 取值（0：否 1：是）
			m_Font_Inverse = dwValue1;
			break;
		case FONT_DOUBLEHEIGHT://纵翻倍放大 取值（0：否 1：是）
			m_Font_DoubleHeight = dwValue1;
			m_Font_SizeH=0;
			break;
		case FONT_DOUBLEWIDE://横翻倍向放大 取值（0：否 1：是）
			m_Font_DoubleWide = dwValue1;
			m_Font_SizeW=0;
			break;
		case FONT_CUSTOM_SIZE://字体宽高自定义，取值（宽 {1..6} ,长 {1..6}）
			m_Font_SizeH = dwValue2;
			m_Font_SizeW = dwValue1;
			break;
		case FONT_ROTATE://字体旋转 取值（0,90,180,270）
			m_Font_Rotate = dwValue1;
			break;
		case FONT_LEFT_RIGHT_SPACE://字符左右边距设置 单位mm 取值（左边距 {0..36},右边距 {0..36}）
			m_Font_SpaceL = dwValue1;
			m_Font_SpaceR = dwValue2;
			break;
		default:
			break;
	}
	LogARG(m_plogFile,Log_Infor,"SetFont","Exit: m_gwiErrorCode = %d",m_gwiErrorCode);
	return Error_Succeed;
}

//打印文本数据函数
ErrorCodeEnum CThermalPrint::PrintText(BYTE *pData,DWORD dwDataLen)
{
	int ret=0;
	char formatBuff1[32]={0};
	char formatBuff2[32]={0};
	BYTE *buffer,*byData;
	int len,iDataLen;
	
	LogARG(m_plogFile,Log_Infor,"PrintText","Enter");
	LogARG(m_plogFile,Log_Infor,"PrintText","pData=[%s]dwDataLen=%d",pData,dwDataLen);

	byData=new BYTE[dwDataLen+256];
	buffer=new BYTE[dwDataLen+512];
	memset(buffer,0,dwDataLen+512);
	memset(byData,0,dwDataLen+256);

	memset(formatBuff1,0,sizeof(formatBuff1));
	memset(formatBuff2,0,sizeof(formatBuff2));
	
	sprintf(formatBuff1,"0|0|%d|%d|%d|%d|%d|",m_LeftMargin,m_PrintArea,m_RowSpace,m_Font_SpaceL,m_Font_SpaceR);

	if( m_Font_SizeH ==0 || m_Font_SizeH>6)
		sprintf(formatBuff2,"%d%d%d%d%d0%d%d%d|",m_Align+1,m_Font_DoubleWide+1,m_Font_DoubleHeight+1,m_Font_Bold,0,
					m_Font_UnderLine,m_Font_Inverse,m_Font_Rotate/90);
	else
		sprintf(formatBuff2,"%d%d%d%d%d0%d%d%d|",m_Align+1,m_Font_SizeW,m_Font_SizeH,m_Font_Bold,0,
					m_Font_UnderLine,m_Font_Inverse,m_Font_Rotate/90);

	
	strcat((char *)buffer,formatBuff1);
	strcat((char *)buffer,formatBuff2);
	
	len=strlen((char *)buffer);
/*chr20180329修改，增加对特殊字符判断*/
	int i=0;
	iDataLen = 0;
	for (i=0; i<dwDataLen;i++)
	{
		if(pData[i]=='&' || pData[i]=='/'||pData[i]=='|')
		{
			byData[iDataLen++]='/';
		}
		byData[iDataLen++]=pData[i];
	}
	memcpy(&buffer[len],byData,iDataLen);
	len +=iDataLen;
	//memcpy(&buffer[len],pData,dwDataLen);
	//len +=dwDataLen;

	m_gwiErrorCode = GWI_Error_Succeed;
	m_deviceStatus = DEVICE_STATUS_NORMAL;
	
	
	//��ӡ����
	LogARG(m_plogFile,Log_Infor,"PrintText","buffer=[%s],len=[%d]",buffer,len);
	//ret =XFS_PrintRawData(buffer,len);
	if(textLen==0)
	{
		memcpy(textBuff,buffer,len);
		textLen += len;
	}
	else 
	{
		textBuff[textLen]='&';
		textLen +=1;
		memcpy(&textBuff[textLen],buffer,len);
		textLen +=len;
	}
	waitTime0 = GetTickCount();
	//LogARG(m_plogFile, Log_Infor, "GetTickCount", "waitTime0 = <%d>", waitTime0);
	delete buffer;

	/*if(logFile) logFile->Log_Infor(myName, __FILE__, __LINE__, __FUNCDNAME__,"pData=[%s] dwDataLen=[%d]",pData,dwDataLen);
	ret =XFS_PrintRawData(pData,dwDataLen);*/

	LogARG(m_plogFile,Log_Infor,"PrintText","PrintRawData ret = %d",ret);

	if(ret !=0)
	{
		m_deviceStatus = DEVICE_STATUS_FAULT;
		m_gwiErrorCode = GWI_Error_Dev_State;
	}
	printf("=======textBuff=[%s],m_gwiErrorCode=[%d]===========\n",textBuff,m_gwiErrorCode);
	LogARG(m_plogFile,Log_Infor,"PrintText","Exit: m_gwiErrorCode = %d",m_gwiErrorCode);
	return ErrParse(m_gwiErrorCode);
}

//打印条形码函数
//dwUnitWidth 条形码基本模块宽度 取值{2..6} 默认2
//dwHeight 条形码高度 单位mm
//iHRIPosition hri字符打印位置 见枚举类型HriPosition
ErrorCodeEnum CThermalPrint::PrintBarCode(BarCodeType eType, BYTE *pData,DWORD dwDataLen,DWORD dwUnitWidth,DWORD dwHeight,HriPosition eHRIPosition)
{
	LogARG(m_plogFile,Log_Infor,"PrintBarCode","Enter");


	long lResult = 0;
	char szBarCode[512]={0};
	memset(szBarCode,0x00,sizeof(szBarCode));
	sprintf(szBarCode,"BarCode=%s\0",pData);

	lResult = m_pThermalPrintSP->ThermalPrint_Printform(0x0000,"TestReceiptForm","TestReceiptMedia",(LPSTR)szBarCode);

	m_gwiErrorCode = GWI_Error_Succeed;
	LogARG(m_plogFile,Log_Infor,"PrintBarCode","Exit: lResult = %d",lResult);
	return ErrParse(m_gwiErrorCode);
}

//打印二维码QRCode函数
//dwUnitWidth 二维码基本元素宽度 取值{1..255} 默认3
ErrorCodeEnum CThermalPrint::PrintQRCode(BYTE *pData,DWORD dwDataLen,DWORD dwUnitWidth)
{	
	LogARG(m_plogFile,Log_Infor,"PrintQRCode","Enter");
	m_gwiErrorCode = GWI_Error_Succeed;

	long lResult = 0;
	char szQRCode[512]={0};
	memset(szQRCode,0x00,sizeof(szQRCode));
	sprintf(szQRCode,"BarCode=%s\0",pData);

	lResult = m_pThermalPrintSP->ThermalPrint_Printform(0x0000,"TestReceiptForm","TestReceiptMedia",(LPSTR)szQRCode);

	LogARG(m_plogFile,Log_Infor,"PrintQRCode","Exit: lResult = %d",lResult);
	return ErrParse(m_gwiErrorCode);
}

//打印二维码QRCode函数
//dwWidth 二维码长度 ，单位mm
ErrorCodeEnum CThermalPrint::PrintQRCodeByArea(BYTE *pData,DWORD dwDataLen,DWORD dwUnitWidth,DWORD dwWidth)
{
	LogARG(m_plogFile,Log_Infor,"PrintQRCodeByArea","Enter");
	m_gwiErrorCode = GWI_Error_Succeed;

	long lResult = 0;
	char szQRCode[512]={0};
	memset(szQRCode,0x00,sizeof(szQRCode));
	sprintf(szQRCode,"BarCode=%s\0",pData);

	lResult = m_pThermalPrintSP->ThermalPrint_Printform(0x0000,"TestReceiptForm","TestReceiptMedia",(LPSTR)szQRCode);

	LogARG(m_plogFile,Log_Infor,"PrintQRCodeByArea","Exit: lResult = %d",lResult);
	return ErrParse(m_gwiErrorCode);
}

//打印二维码PDF417函数
//errorLevel pdf417纠错级别 取值{0..8}
//dwUnitWidth  基本元素宽度 取值{3..90}
//dwUnitHeight 基本元素长度 取值{1..30}
//row  pdf417 行数 取值{1..7}
//lines pdf417 列数 取值{2..25}
ErrorCodeEnum CThermalPrint::PrintPDF417code(BYTE *pData,DWORD dwDataLen,int errorLevel,DWORD dwUnitWidth,DWORD dwUnitHeight,int rows,int lines)
{
	LogARG(m_plogFile,Log_Infor,"PrintPDF417code","Enter");
	m_gwiErrorCode = GWI_Error_Succeed;

	long lResult = 0;
	char szPDF417code[512]={0};
	memset(szPDF417code,0x00,sizeof(szPDF417code));
	sprintf(szPDF417code,"PDF417code=%s\0",szPDF417code);

	lResult = m_pThermalPrintSP->ThermalPrint_Printform(0x0000,"TestReceiptForm","TestReceiptMedia",(LPSTR)szPDF417code);

	LogARG(m_plogFile,Log_Infor,"PrintPDF417code","Exit: lResult = %d",lResult);
	return ErrParse(m_gwiErrorCode);
}

//打印二维码PDF417函数
//errorLevel pdf417纠错级别 取值{0..8}
//dwWidth  pdf417宽度 单位mm
//dwHeight pdf417长度 单位mm
ErrorCodeEnum CThermalPrint::PrintPDF417codeByArea(BYTE *pData,DWORD dwDataLen,int errorLevel,DWORD dwWidth,DWORD dwHeight)
{
	LogARG(m_plogFile,Log_Infor,"PrintPDF417codeByArea","Enter");
	m_gwiErrorCode = GWI_Error_Succeed;

	long lResult = 0;
	char szPDF417code[512]={0};
	memset(szPDF417code,0x00,sizeof(szPDF417code));
	sprintf(szPDF417code,"PDF417code=%s\0",szPDF417code);

	lResult = m_pThermalPrintSP->ThermalPrint_Printform(0x0000,"TestReceiptForm","TestReceiptMedia",(LPSTR)szPDF417code);

	LogARG(m_plogFile,Log_Infor,"PrintPDF417codeByArea","Exit: lResult = %d",lResult);
	return ErrParse(m_gwiErrorCode);
}

LPSTR lpszPathAll[26]={ "/tmp/tmp1.bmp","/tmp/tmp2.bmp","/tmp/tmp3.bmp","/tmp/tmp4.bmp","/tmp/tmp5.bmp",\
						"/tmp/tmp6.bmp","/tmp/tmp7.bmp","/tmp/tmp8.bmp","/tmp/tmp9.bmp","/tmp/tmp10.bmp",\
						"/tmp/tmp11.bmp","/tmp/tmp12.bmp","/tmp/tmp13.bmp","/tmp/tmp14.bmp","/tmp/tmp15.bmp",\
						"/tmp/tmp16.bmp","/tmp/tmp17.bmp","/tmp/tmp18.bmp","/tmp/tmp19.bmp","/tmp/tmp20.bmp",\
						"/tmp/tmp21.bmp","/tmp/tmp22.bmp","/tmp/tmp23.bmp","/tmp/tmp24.bmp","/tmp/tmp25.bmp",\
						};
//获取打印失败后错误信息和错误状态
ErrorCodeEnum CThermalPrint::PrintImage(BYTE *pData,DWORD dwDataLen)
{
	LogARG(m_plogFile,Log_Infor,"PrintImage","Enter");
	m_gwiErrorCode = GWI_Error_Succeed;

	long lResult = 0;
	std::string base64_str;	
	std::vector<BYTE> decode_byte;
	
	base64_str.assign(pData,pData+dwDataLen);
	decode_byte = base64_decode(base64_str);
	
	//stdBytes2File(lpszPath,decode_byte);
	//XFS_Printform (0x0000,"TestReceiptForm","TestReceiptMedia",lpszFields);

	stdBytes2File(lpszPathAll[lpszPathAllNum],decode_byte);

	char imageLine[512]={0};
	memset(imageLine,0,sizeof(imageLine));
	sprintf(imageLine,"0|0|%d|%d|%d|%d|%d|111001000|",m_LeftMargin,m_PrintArea,0,0,0);
	strcat(imageLine,lpszPathAll[lpszPathAllNum++]);

	if(lpszPathAllNum>=24)lpszPathAllNum=0;

	int len=strlen(imageLine);
	if(textLen==0)
	{
		memcpy(textBuff,imageLine,len);
		textLen += len;
	}
	else 
	{
		textBuff[textLen]='&';
		textLen +=1;
		memcpy(&textBuff[textLen],imageLine,len);
		textLen +=len;
	}
	waitTime0 = GetTickCount();

	LogARG(m_plogFile,Log_Infor,"PrintImage","Exit: lResult = %d",lResult);
	return ErrParse(m_gwiErrorCode);
}

//获取打印失败后错误信息和错误状态
ErrorCodeEnum CThermalPrint::GetLastErrState(ThermalState &devState , DevErrorInfo &devErrInfo)
{
	LogARG(m_plogFile,Log_Infor,"GetLastErrState","Enter");
	m_gwiErrorCode = Error_Succeed;
	LogARG(m_plogFile,Log_Infor,"GetLastErrState","Exit: m_gwiErrorCode = %d",m_gwiErrorCode);
	return Error_Succeed;
}

// ErrorCodeEnum CThermalPrint::ErrParse(long lResult)
// {
// 	bool bFind = false;
// 	for(int n = 0; n < sizeof(m_DevErrArray)/sizeof(DevErrCode); n++)
// 	{
// 		if(lResult == m_DevErrArray[n].lErr)
// 		{
// 			bFind = true;
// 			ErrorCodeEnum ErrTmp = (ErrorCodeEnum)m_DevErrArray[n].lReturn;
// 			memset(m_DevErrorInfo.szErrMsg,0,sizeof(m_DevErrorInfo.szErrMsg));
// 			strcpy(m_DevErrorInfo.szErrMsg,m_DevErrArray[n].szErrDes);
// 			m_DevErrorInfo.dwErrMsgLen = (m_DevErrArray[n].lDevErr << 16) +strlen(m_DevErrArray[n].szErrDes);
// 			return ErrTmp;
// 		}
// 	}
// 	if(!bFind)
// 	{
// 		memset(m_DevErrorInfo.szErrMsg,0,sizeof(m_DevErrorInfo.szErrMsg));
// 		strcpy(m_DevErrorInfo.szErrMsg,"未定义错误");
// 		m_DevErrorInfo.dwErrMsgLen =strlen(m_DevErrorInfo.szErrMsg);
// 		return Error_Hardware;
// 	}
// 	return Error_Succeed;
// }

ErrorCodeEnum CThermalPrint::ErrParse(long gwiErrorCode)
{
	int i = 0;

	for(; gstErrorInfo[i].errorcode != Error_Succeed; ++i)
	{
		if(gwiErrorCode==gstErrorInfo[i].gwiErrorCode)
		{
			return gstErrorInfo[i].errorcode;
		}
	}
	return Error_Succeed;
}

//	Get last error the device issued.
//	Error message must include explanatory memorandum ,the original error 
//	code and anything in favour of location problem.
ErrorCodeEnum CThermalPrint::GetLastErr(DevErrorInfo &devErrInfo)
{
	int i = 0;
	memset(&devErrInfo, 0x00, sizeof(DevErrorInfo));

	//陈祖国 20190416 未初始化会越界，写法不规范
	for(; gstErrorInfo[i].errorcode != Error_Succeed && i < sizeof(gstErrorInfo)/sizeof(StErrorInfo); ++i)
	{
		if(m_gwiErrorCode==gstErrorInfo[i].gwiErrorCode)
		{
			devErrInfo.dwErrMsgLen = strlen(gstErrorInfo[i].description);
			memcpy(devErrInfo.szErrMsg, gstErrorInfo[i].description, devErrInfo.dwErrMsgLen);
			break;
		}
	}
	LogARG(m_plogFile,Log_Infor,"GetLastErr","Exit: m_gwiErrorCode = %d",m_gwiErrorCode);
	return Error_Succeed;
}