comlib/打印机代码/linux/DevPrinter/devprinterstr.cpp

#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;
}