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

#include "devprinterstr.h"
#include <QThread>

bool little_than(const myprinterPara& s1, myprinterPara& s2)
{
    return (s1.line <= s2.line);
}

devprinterstr::devprinterstr()
{
}

int devprinterstr::InitStr()
{
    memset(m_printerPort,0,sizeof(m_printerPort));

    m_printType = PRINTTYPE_OTHER;
    m_SerBaud = 9600;
    m_nPrnVer = 1;

    m_MaxCol =0;
    m_MaxLine =0;
    m_HeigthAdj =12;

    m_JsonAnalyStr.InitStr();
    InitPrinterCutPara(&m_CutPaperPara);

    m_SerialPort.InitStr();
    m_lpt.InitStr();
    return 0;
}

int devprinterstr::PRN_CreatePrinter(int nPrnVer, char* sPrintPort,
    int nColMax, int nLineMax, int nHeightAdj,
    char* sPortAddr, char* sFormat, char *sCutPaper)
{
    int iRet;

    InitStr();

    iRet = strlen(sPrintPort);
    if ((iRet >60) || (iRet <4))
    {
         //Write_Log("sPrintPort 长度错误");
         return -1;
    }

    iRet = strlen(sFormat);
    if ((iRet >240) || (iRet <18))
    {
        return -2;
    }

    iRet = strlen(sCutPaper);
    if ((iRet >100) || (iRet <26))
    {
        return -3;
    }

    strcpy(m_printerPort,sPrintPort);
    charToUpper(m_printerPort);

    iRet = GetPrinterType();
    if(iRet <0)
    {
        return -4;
    }

  /*  if(PRINTTYPE_COM != m_printType)
    {
        return -100;
    }
*/
    if(m_MaxCol >200)
    {
        return -100;
    }

    if(m_MaxLine >500)
    {
        return -101;
    }

    if(m_HeigthAdj >255)
    {
        return -102;
    }
    m_MaxCol = nColMax;
    m_MaxLine = nLineMax;

    m_HeigthAdj = nHeightAdj;
    m_nPrnVer = nPrnVer;

    if(PRINTTYPE_LPT == m_printType)
    {
        int iPort = GetStatePort(sPortAddr);
        if(iPort <0)
        {
            return -5;
        }

        iPort++;
        m_lpt.SetStatesPort(iPort);
    }

    iRet = m_JsonAnalyStr.GetPrinterPara(m_PrnParalist,sFormat,m_MaxLine);
    if(iRet <0)
    {
        m_PrnParalist.clear();

        return -7;
    }

    if(m_PrnParalist.size() >=2)
    {
        std::sort(m_PrnParalist.begin(), m_PrnParalist.end(), little_than);
    }

    iRet = m_JsonAnalyStr.GetCutPaperPara(&m_CutPaperPara,sCutPaper);
    if(iRet <0)
    {
        m_PrnParalist.clear();
        return -8;
    }

    if(PRINTTYPE_COM == m_printType)
    {
        iRet = m_SerialPort.OpenPort(m_printerPort,m_SerBaud);
        if(iRet <0)
        {
            m_PrnParalist.clear();
            return -9;
        }
        return 0;
    }
    else if(PRINTTYPE_LPT == m_printType)
    {
        iRet = m_lpt.OpenPort(m_printerPort);
        if(iRet <0)
        {
            m_PrnParalist.clear();
            return -9;
        }
        return 0;
    }
    else
    {

    }

    return 0;
}

int devprinterstr::GetPrinterType()
{
    int iRet;
    char * ptr = NULL;
    int iFlag = 0;
    int iFind = 0;

    if (strstr(m_printerPort, "LPT"))
    {
        iFlag = 1;
    }
    else if (strstr(m_printerPort, "COM"))
    {
        iFlag = 2;
    }
    else if (strstr(m_printerPort, "USB"))
    {
        m_printType = PRINTTYPE_USBLPT;
        return 0;
    }
    else
    {
        return -1;
    }

    if (1 == iFlag)
    {
        iRet = isLptPort(m_printerPort);
        if (0 == iRet)
        {
            m_printType = PRINTTYPE_LPT;
            return 0;
        }
        else
        {
            return -2;
        }

        return -2;
    }
    else if(2== iFlag)
    {
        iRet = strlen(m_printerPort);
        for (int i = 0; i < iRet; i++)
        {
            if (':' == m_printerPort[i])
            {
                iFind = 1;
                m_printerPort[i] = 0;
                ptr = m_printerPort + i + 1;
                break;
            }
        }

        iRet = isComPort(m_printerPort);
        if (iRet<0)
        {
            return -3;
        }

        if (1 == iFind)
        {
            iRet = GetBaud(ptr);
            if (iRet < 0)
            {
                return -4;
            }
            m_SerBaud = iRet;
        }

        m_printType = PRINTTYPE_COM;
        return 0;
    }
    else
    {
        return -5;
    }

    return -6;
}

int devprinterstr::GetStatePort(char* sPortAddr)
{
    char * pData;
    int iRet;
    int base;
    int iLen;
    QString qstr;
    bool ok;
    iRet =0;

    pData = sPortAddr;
    iLen = strlen(sPortAddr);
    if(iLen <=2)
    {
        iRet = isnumer(sPortAddr);
        if(iRet<0)
        {
            return -1;
        }

        iRet = QString(sPortAddr).toInt();
        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;
    }

    qstr = pData;
    qstr =  qstr.toUpper();

    iRet=qstr.toInt(&ok,base);
    if(ok)
    {
        return iRet;
    }

    return -3;
}



HRESULT devprinterstr::PRN_Close()
{
    if(PRINTTYPE_COM == m_printType)
    {
        m_SerialPort.ClosePort();
    }
    else if(PRINTTYPE_LPT == m_printType)
    {
        m_lpt.ClosePort();
    }
    else
    {

    }

    m_PrnParalist.clear();
    return 0;
}

HRESULT devprinterstr::PRN_CheckPrinter(INT32 &iStatus)
{
    if(PRINTTYPE_COM == m_printType)
    {
        return m_SerialPort.PRN_CheckPrinter(iStatus);
    }
    else if(PRINTTYPE_LPT == m_printType)
    {
        return m_lpt.PRN_CheckPrinter(iStatus);
    }
    else
    {

    }

    return -1;
}



HRESULT devprinterstr::PRN_Print(char *pInfo)
{
    QList<myprinterInfo>printerInfolist;
    QList<myprinterData>printerdatalist;
    int iRet;

    if(! pInfo)
    {
         return -1;
    }

    if(strlen(pInfo) <13)
    {
        return -2;
    }

    iRet = m_JsonAnalyStr.GetPrinterInfo(printerInfolist,pInfo);
    if(iRet<0)
    {
        return -1;
    }

    iRet = CreatePrinterData(printerdatalist,printerInfolist);
    if(iRet<0)
    {
        return -2;
    }

    if(PRINTTYPE_COM == m_printType)
    {
        iRet =m_SerialPort.PrinterData(m_MaxCol,m_MaxLine,m_HeigthAdj,&m_CutPaperPara,printerdatalist);
        if(iRet <0)
        {
            return -3;
        }
    }
    else if(PRINTTYPE_LPT == m_printType)
    {
        iRet =m_lpt.PrinterData(m_MaxCol,m_MaxLine,m_HeigthAdj,&m_CutPaperPara,printerdatalist);
        if(iRet <0)
        {
            return -3;
        }
    }
    else
    {

    }

    return 0;
}


int devprinterstr::CreatePrinterData(QList<myprinterData> & Datalist,QList<myprinterInfo> & Infolist)
{
    myprinterData  tmpData;
    myprinterPara  tmpPara;
    myprinterInfo  tmpinfo;
    tmpData.line = -1;
//    int iFlag =0;
    int iLen;
    int iRet;

    iLen = sizeof(tmpData.Data);
    for(int i=0; i<m_PrnParalist.size(); i++)
    {
         tmpPara = m_PrnParalist.at(i);
         if(tmpPara.line != tmpData.line)
         {
             if(0 != i)
             {
                 Datalist.append(tmpData);
             }
             tmpData.line = tmpPara.line;
             memset(tmpData.Data,0,iLen);
             for(int j =0; j<(iLen-1); j++)
             {
                 (tmpData.Data)[j] = ' ';
             }
         }

         for(int k =0; k<Infolist.size(); k++)
         {
              tmpinfo = Infolist.at(k);
              iRet = strcmp(tmpPara.Name,tmpinfo.Name);
              if(0 == iRet)
              {
                   int  itmpLen = strlen(tmpinfo.Value);
                   if( (itmpLen + tmpPara.col) >(iLen -1))
                   {
                        return -1;
                   }
                   memcpy(tmpData.Data+tmpPara.col,tmpinfo.Value,itmpLen);
                   break;
              }
         }
    }

    Datalist.append(tmpData);
    return 0;
}