T168_111\appl\Parser\Zpl2：第18~23

最新推荐文章于 2024-09-16 17:46:36 发布

qq_33772147

最新推荐文章于 2024-09-16 17:46:36 发布

阅读量770

点赞数 24

文章标签： c++ 算法 linux

本文链接：https://blog.csdn.net/qq_33772147/article/details/136968616

版权

Zpl2Report.c 、、、、、、、、、、、、、、、、、、、、

/******************************************************************************
* *
* M O D U L E D E F I N E *
* *
******************************************************************************/

#define ZPL2REPORT_C

/******************************************************************************
* *
* C O M P I L E R D E F I N E D I N C L U D E F I L E S *
* *
******************************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <ctype.h>

/******************************************************************************
* *
* U S E R D E F I N E D I N C L U D E F I L E S *
* *
******************************************************************************/

#include "Common.h"
#include "XComm.h"
#include "XFileSys.h"
#include "XText.h"
#include "XAppVer.h"
#include "XPrtEng.h"
#include "..\Parser.h"
#include "..\ParserUtil.h"
#include "Zpl2Control.h"
#include "Zpl2Report.h"

/******************************************************************************
* *
* L O C A L D E F I N E S *
* *
******************************************************************************/

#if defined(ZPL2)

#define REPORT_FONT "D.FNT"
#define REPORT_WIDTH 450

#if defined(TDP225) || defined(TTP225)
#define REPORT_X           0
#elif defined(LEFT_ALIGN)
#define REPORT_X           0
#elif defined(CENTER_ALIGN)
#define REPORT_X           ((TPH_WIDTH_DOT - REPORT_WIDTH) / 2)
#endif

#define REPORT_Y 10
#define REPORT_LINEH 18

/******************************************************************************
* *
* L O C A L T Y P E D E F S *
* *
******************************************************************************/

/******************************************************************************
* *
* L O C A L F U N C T I O N P R O T O T Y P E S *
* *
******************************************************************************/

/******************************************************************************
* *
* L O C A L I N I T I A L I Z E D D A T A D E F I N I T I O N S *
* *
******************************************************************************/

/******************************************************************************
* *
* L O C A L U N I T I A L I Z E D D A T A D E F I N I T I O N S *
* *
******************************************************************************/

/******************************************************************************
*
* Function:
*
*
* Description:
*
*
* Input:
*     None.
*
* Output:
*     None.
*
******************************************************************************/
STATIC VOID OutConfig(REPORT *report, CHAR *caption, CHAR *fmt, ...)
{
   va_list args;
   CHAR printbuf[64];

   va_start(args, fmt);
   vsprintf(printbuf, fmt, args);
   va_end(args);

WriteReport(report, " %-20s%-18s", printbuf, caption);
}

STATIC INT ToMediaFeed(CHAR MediaFeed)
{
   if (MediaFeed == 'F')
       return 0;
   if (MediaFeed == 'C')
       return 1;
   if (MediaFeed == 'L')
       return 2;
   return 3;
}

VOID ConfigLabel(_OutputWay OutWay)
{
   CONST STATIC CHAR *Baud[] = { "0","1200","2400","4800","9600","19200","38400","57600","115200" };
   CONST STATIC CHAR *Parity[] = { "NONE","ODD","EVEN" };
   CONST STATIC CHAR *DataBits[] = { "7","8" };
   CONST STATIC CHAR *PrtMode[] = { "TEAR OFF","TEAR OFF","PEEL OFF","CUTTER" };
   CONST STATIC CHAR *MediaType[] = { "NON-CONTINUOUS","NON-CONTINUOUS","CONTINUOUS","CONTINUOUS","CONTINUOUS" };
   CONST STATIC CHAR *SensorType[] = { "WEB","MARK","CONTINUOUS","CONTINUOUS","CONTINUOUS" };
   CONST STATIC CHAR *MediaFeed[] = { "FEED","CALIBRATION","LENGTH","NO MOTION" };

   _PrintCfg Conf = *pPrintCfg;
   REPORT *Report = OpenReport(OutWay);
   INT Space = TotalSpace(CARD_DEVICE);

   ToPrintConfig(&Conf);
   Conf.Direction = 1;
   Conf.Mirror = 0;

if (OutWay == OUTPUT_RS232)
SendChar(0x02);

   if (OutWay == OUTPUT_LABEL)
   {
       OutConfig(Report, "GURATION", "%20s", "PRINTER CONFI");
       OutConfig(Report, "", "");
   //   OutConfig(Report, "", "TSC Technologies");
       OutConfig(Report, "", "%s-%ddpi ZPL", ModelName, (INT)TPH_DPI);
       OutConfig(Report, "", "");
   }

   OutConfig(Report, "DARKNESS", "%02d.0", PrintDarkness);
   OutConfig(Report, "PRINT SPEED", "%s IPS", ToSpeedString(Conf.Speed));
   OutConfig(Report, "TEAR OFF", "%+04d", AdjustPosition);
   OutConfig(Report, "PRINT MODE", "%s", PrtMode[Conf.PrintOutMode]);
   OutConfig(Report, "MEDIA TYPE", "%s", MediaType[Conf.SensorMode]);
   OutConfig(Report, "SENSOR TYPE", "%s", SensorType[Conf.SensorMode]);
   OutConfig(Report, "SENSOR SELECT", "%s", Whether(AutoDetectType) ? "AUTO SELECT" : "MANUAL");
   OutConfig(Report, "PRINT METHOD", "%s", Conf.RibbonFlag ? "THERMAL-TRANS." : "DIRECT-THERMAL");
   OutConfig(Report, "PRINT WIDTH", "%04d DOTS", LabelWidth);
   OutConfig(Report, "LABEL LENGTH", "%04d", LabelLength);
   OutConfig(Report, "MAXIMUM LENGTH", "AUTO");
//   OutConfig(Report, "USB COMM.", "NOT CONNECTED");
   OutConfig(Report, "PARALLEL COMM.", "UNIDIRECTIONAL");
   OutConfig(Report, "SERIAL COMM.", "RS232");
   OutConfig(Report, "BAUD", "%s", Baud[Conf.UartSetting.Baud]);
   OutConfig(Report, "DATA BITS", "%s BITS", DataBits[Conf.UartSetting.DataBits]);
   OutConfig(Report, "PARITY", "%s", Parity[Conf.UartSetting.Parity]);
   OutConfig(Report, "HOST HANDSHAKE", "DTR/DSR");
   OutConfig(Report, "PROTOCOL", "NONE");
   OutConfig(Report, "COMMUNICATIONS", "NORMAL MODE");
   OutConfig(Report, "CONTROL PREFIX", "<%c> %02XH", TildeChar, TildeChar);
   OutConfig(Report, "FORMAT PREFIX", "<%c> %02XH", CaretChar, CaretChar);
   OutConfig(Report, "DELIMITER CHAR", "<%c> %02XH", DelimiterChar, DelimiterChar);
   OutConfig(Report, "ZPL MODE", "ZPL II");
   OutConfig(Report, "MEDIA POWER UP", "%s", MediaFeed[ToMediaFeed(FeedPowerUp)]);
   OutConfig(Report, "HEAD CLOSE", "%s", MediaFeed[ToMediaFeed(FeedCloseHead)]);
   OutConfig(Report, "BACKFEED", "DEFAULT");
   OutConfig(Report, "LABEL TOP", "%+04d", LabelTop);
   OutConfig(Report, "LEFT POSITION", "%+05d", LabelShift);
   OutConfig(Report, "REPRINT MODE", "ENABLED");
//   OutConfig(Report, "WEB S.", "026");
//   OutConfig(Report, "MEDIA S.", "069");
//   OutConfig(Report, "RIBBON S.", "065");
//   OutConfig(Report, "TAKE LABEL", "029");
//   OutConfig(Report, "MEDIA LED", "030");
//   OutConfig(Report, "RIBBON LED", "156");
//   OutConfig(Report, "LCD ADJUST", "+10");
   OutConfig(Report, "MODES ENABLED", "DPSWFXM");
   OutConfig(Report, "MODES DISABLED", ".......");
   OutConfig(Report, "RESOLUTION", "%d %.1f/MM FULL", TPH_WIDTH_DOT, MM_DOT);
   OutConfig(Report, "FIRMWARE", "V%-12s<-", VerName);
   OutConfig(Report, "HARDWARE ID", "");
   OutConfig(Report, "CONFIGURATION", "CUSTOMIZED");
   OutConfig(Report, "RAM", "%04dk............%c:", TotalSpace(DRAM_DEVICE), MemoryAlias.R);
   OutConfig(Report, "MEMORY CARD", "%04d%c............%c:",
       (Space > 9999) ? (Space / 1024) : Space, (Space > 9999) ? 'm' : 'k', MemoryAlias.B);
   OutConfig(Report, "ONBOARD FLASH", "%04dk............%c:", TotalSpace(FLASH_DEVICE), MemoryAlias.E);
   OutConfig(Report, "FORMAT CONVERT", "NONE");
//   OutConfig(Report, "ZEBRA NET II", "NONE");
   OutConfig(Report, "NONRESET CNTR", "%d IN", (pPrintRec->DotMilage) / (INT)TPH_DPI);
   OutConfig(Report, "RESET CNTR1", "%d IN", (pPrintRec->DotMilage - AdvancedCounter1) / (INT)TPH_DPI);
   OutConfig(Report, "RESET CNTR2", "%d IN", (pPrintRec->DotMilage - AdvancedCounter2) / (INT)TPH_DPI);
   OutConfig(Report, "NONRESET CNTR", "%d CM", (pPrintRec->DotMilage) / (INT)(MM_DOT * 10));
   OutConfig(Report, "RESET CNTR1", "%d CM", (pPrintRec->DotMilage - AdvancedCounter1) / (INT)(MM_DOT * 10));
   OutConfig(Report, "RESET CNTR2", "%d CM", (pPrintRec->DotMilage - AdvancedCounter2) / (INT)(MM_DOT * 10));

if (OutWay == OUTPUT_RS232)
SendChar(0x03);

CloseReport(Report, &Conf, REPORT_X, REPORT_Y, REPORT_LINEH, REPORT_FONT, LANG_ZPL);
}

VOID DirectoryList(_ObjFile *pFile, _OutputWay OutWay)
{
CONST STATIC CHAR *DeviceName[] = { "","RAM","ONBOARD FLASH","MEMORY CARD" };

   REPORT *Report = OpenReport(OutWay);
   _eFileDevice device = ToFileDevice(pFile->Device);
   _PrintCfg Conf = *pPrintCfg;
   _FileList List;
   CHAR Device[4];
   CHAR OutBuf[64];
   INT Index;

   ToPrintConfig(&Conf);
   Conf.Direction = 1;
   Conf.Mirror = 0;

   Device[0] = ' ';
   Device[1] = MemoryAlias.R;
   Device[2] = MemoryAlias.E;
   Device[3] = MemoryAlias.B;

   if (OutWay == OUTPUT_RS232)
   {
       SendChar(0x02);
       WriteReport(Report, "");
       WriteReport(Report, "- DIR %c:%-12s", pFile->Device, pFile->Name);
   }
   if (OutWay == OUTPUT_LABEL)
   {
       WriteReport(Report, " DIRECTORY OF %c:%s", pFile->Device, pFile->Name);
       WriteReport(Report, "");
   }

   Index = sizeof(Device) - 1;
   do
   {
       if (pFile->Device == '*')
           device = ToFileDevice(Device[Index]);

       OpenList(&List, device);
       while (NextFile(&List, pFile->Name))
       {
           if (OutWay == OUTPUT_RS232)
           {
               sprintf(OutBuf, "* %c:%s%8d", Device[device], List.FileName, List.FileSize);
               WriteReport(Report, "%-42s", OutBuf);
           }
           if (OutWay == OUTPUT_LABEL)
               WriteReport(Report, " %c:%-16s%12d", Device[device], List.FileName, List.FileSize);
       }
       Index -= 1;
   }
   while (pFile->Device == '*' && Index);

if (OutWay == OUTPUT_LABEL)
WriteReport(Report, "");

   Index = sizeof(Device) - 2;
   do
   {
       if (pFile->Device == '*')
           device = ToFileDevice(Device[Index]);

       if (OutWay == OUTPUT_RS232)
       {
           WriteReport(Report, "");
           WriteReport(Report, "- %8d kbytes free %c: %s ", FreeSpace(device), Device[device], DeviceName[device]);
       }
       if (OutWay == OUTPUT_LABEL)
       {
           WriteReport(Report, " %c: %s", Device[device], DeviceName[device]);
           WriteReport(Report, " %8d KBYTES FREE", FreeSpace(device));
       }
       Index -= 1;
   }
   while (pFile->Device == '*' && Index);

if (OutWay == OUTPUT_RS232)
SendChar(0x03);

CloseReport(Report, &Conf, REPORT_X, REPORT_Y, REPORT_LINEH, REPORT_FONT, LANG_ZPL);
}

VOID HostFormat(_ObjFile *pFile)
{
   _FileHandle *Handle;
   CHAR Name[sizeof(pFile->Name)];
   INT i;

   if ((Handle = Fopen(ToFileDevice(pFile->Device), pFile->Name, "r")) != _NULL)
   {
       *strchr(strcpy(Name, pFile->Name), '.') = '\0';
       SendPrintf("%cXA%cDF%s%c", CaretChar, CaretChar, Name, DelimiterChar);

while ((i = Fgetc(Handle)) != END_OF_FILE)
SendChar((BYTE)i);

       SendPrintf("%cXZ\r\n", CaretChar);
       Fclose(Handle);
   }
}

VOID HostGraphics(_ObjFile *pFile)
{
   _FileHandle *Handle;
   CHAR Name[sizeof(pFile->Name)];
   SHORT Height, Width, ByteWidth;
   BYTE *pLineBuf;
   INT i, j;

   if (pFile->Device == _NULL)
   {
       // Device Default Value: search priority
       if ((Handle = Fopen(ToFileDevice(MemoryAlias.R), pFile->Name, "r")) == _NULL)
       if ((Handle = Fopen(ToFileDevice(MemoryAlias.E), pFile->Name, "r")) == _NULL)
       if ((Handle = Fopen(ToFileDevice(MemoryAlias.B), pFile->Name, "r")) == _NULL)
       if ((Handle = Fopen(ToFileDevice(MemoryAlias.A), pFile->Name, "r")) == _NULL)
           return;
   }
   else if ((Handle = Fopen(ToFileDevice(pFile->Device), pFile->Name, "r")) == _NULL)
       return;

   *strchr(strcpy(Name, pFile->Name), '.') = '\0';
   Fread(&Height, sizeof(SHORT), 1, Handle);
   Fread(&Width, sizeof(SHORT), 1, Handle);
   Height = le16_to_cpu(Height);
   Width = le16_to_cpu(Width);
   ByteWidth = (Width + 7) / 8;

SendPrintf("%cDG%s%c%d%c%d%c\r\n", TildeChar, Name, DelimiterChar,
Height * ByteWidth, DelimiterChar, ByteWidth, DelimiterChar);

   pLineBuf = malloc(ByteWidth);
   for (i = 0; i < Height; i++)
   {
       if (Fread(pLineBuf, sizeof(BYTE), ByteWidth, Handle) != ByteWidth)
           break;

       for (j = 0; j < ByteWidth; j++)
           if (*(pLineBuf + j) != 0x00)
               break;

       if (j != ByteWidth)
       {
           for (j = 0; j < ByteWidth; j++)
               SendPrintf("%02X", *(pLineBuf + j));
       }
       else
           SendChar(',');

       SendPrintf("\r\n");
   }
   free(pLineBuf);
   Fclose(Handle);
}

VOID HostIdentification(VOID)
{
SendPrintf("\x02%s,V%s,%.1f,%dKB\x03\r\n",
ModelName, VerName, MM_DOT, FreeSpace(FLASH_DEVICE));
}

VOID HostRamStatus(VOID)
{
SendPrintf("\x02%d,%d,%d\x03\r\n",
TotalSpace(DRAM_DEVICE), FreeSpace(DRAM_DEVICE), EmptySpace(DRAM_DEVICE));
}

VOID HostStatusReturn(VOID)
{
   INT a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y;
   _PrintCfg RepCfg = *pPrintCfg;
   _eJobMonitor JobMonitor = GetJobMonitor();
   WORD JobError = GetJobErrorState();
   BOOL JobLock = CheckJobLock();

ToPrintConfig(&RepCfg);

/*
* a = communication (interface) settings*
* a7 = Handshake (0 = Xon/Xoff, 1 = DTR)
* a6 = Parity Odd/Even (0 = Odd, 1 = Even)
* a5 = Disable/Enable (0 = Disable, 1 = Enable)
* a4 = Stop Bits (0 = 2 Bits, 1 = 1 Bit)
* a3 = Data Bits (0 = 7 Bits, 1 = 8 Bits)
* a8 a2 a1 a0 = Baud
* 0 0 0 0 = 110
* 0 0 0 1 = 300
* 0 0 1 0 = 600
* 0 0 1 1 = 1200
* 0 1 0 0 = 2400
* 0 1 0 1 = 4800
* 0 1 1 0 = 9600
* 0 1 1 1 = 19200
* 1 0 0 0 = 28800
* 1 0 0 1 = 38400
* 1 0 1 0 = 57600
* 1 0 1 1 = 14400
* b = paper out flag (1 = paper out)
* c = pause flag (1 = pause active)
* d = label length (value in number of dots)
* e = number of formats in receive buffer
* f = buffer full flag (1 = receive buffer full)
* g = communications diagnostic mode flag (1 = diagnostic mode active)
* h = partial format flag (1 = partial format in progress)
* i = unused (always 000)
* j = corrupt RAM flag (1 = configuration data lost)
* k = temperature range (1 = under temperature)
* l = temperature range (1 = over temperature)
*/
   a = 0;
   a |= (RepCfg.UartSetting.FlowControl != 0) ? 0x80 : 0;
   a |= (RepCfg.UartSetting.Parity == 2) ? 0x40 : 0;
   a |= (RepCfg.UartSetting.Parity != 0) ? 0x20 : 0;
   a |= (RepCfg.UartSetting.Stop == 0) ? 0x10 : 0;
   a |= (RepCfg.UartSetting.Baud == UART_BAUD_1200 ) ? 0x003 : 0;
   a |= (RepCfg.UartSetting.Baud == UART_BAUD_2400 ) ? 0x004 : 0;
   a |= (RepCfg.UartSetting.Baud == UART_BAUD_4800 ) ? 0x005 : 0;
   a |= (RepCfg.UartSetting.Baud == UART_BAUD_9600 ) ? 0x006 : 0;
   a |= (RepCfg.UartSetting.Baud == UART_BAUD_19200 ) ? 0x007 : 0;
   a |= (RepCfg.UartSetting.Baud == UART_BAUD_38400 ) ? 0x101 : 0;
   a |= (RepCfg.UartSetting.Baud == UART_BAUD_57600 ) ? 0x102 : 0;
   a |= (RepCfg.UartSetting.Baud == UART_BAUD_115200) ? 0x103 : 0;
   b = ((JobError & ERROR_PAPER_JAM) || (JobError & ERROR_PAPER_EMPTY)) ? 1 : 0;
   c = JobLock ? 1 : 0;
   d = LabelLength;
   e = 0;
   f = 0;
   g = 0;
   h = 0;
   i = 0;
   j = 0;
   k = 0;
   l = 0;

/*
* m = function settings*
* m7 = Media Type (0 = Die-Cut, 1 = Continuous)
* m6 = Sensor Profile (0 = Off, 1 = On)
* m5 = Communications Diagnostics (0 = Off, 1 = On)
* m4 = Unused
* m3 = Unused
* m2 = Unused
* m1 = Unused
* m0 = Print Mode (0 = Direct Thermal, 1 = Thermal Transfer)
* n = unused
* o = head up flag (1 = head in up position)
* p = ribbon out flag (1 = ribbon out)
* q = thermal transfer mode flag (1 = Thermal Transfer Mode selected)
* r = Print Mode
* 0 = Rewind
* 1 = Peel-Off
* 2 = Tear-Off
* 3 = Cutter
* 4 = Applicator
* s = print width mode
* t = label waiting flag (1 = label waiting in Peel-off Mode)
* u = labels remaining in batch
* v = format while printing flag (always 1)
* w = number of graphic images stored in memory
*/
   m = 0;
   m |= (RepCfg.SensorMode == CONTINUE_MODE_T) ? 0x80 : 0;
   m |= (RepCfg.RibbonFlag) ? 0x01 : 0;
   n = 0;
   o = 0;
#if defined(CARRIAGE_OPEN_MODEL)
   o = (IsCarriageOpen() && RepCfg.CarriageOpen) ? 1 : 0;
#endif
   p = ((JobError & ERROR_RIBBON_JAM) || (JobError & ERROR_RIBBON_EMPTY)) ? 1 : 0;
   q = (RepCfg.RibbonFlag) ? 1 : 0;
   r = 0;
   r = (PrintMode == 'R') ? 0 : r;   // R = Rewind
   r = (PrintMode == 'P') ? 1 : r;   // P = Peel-off
   r = (PrintMode == 'T') ? 2 : r;   // T = Tear-off
   r = (PrintMode == 'C') ? 3 : r;   // C = Cutter
   r = (PrintMode == 'D') ? 3 : r;   // D = Delayed cutter
   r = (PrintMode == 'A') ? 4 : r;   // A = Applicator
   s = 0;
   t = (JobMonitor == MONITOR_TAKE_LABEL) ? 1 : 0;
   u = GetPrintRemain();
   v = 1;
   w = GetFileTotal(FLASH_DEVICE, "*.GRF");
   w += GetFileTotal(CARD_DEVICE, "*.GRF");
   w += GetFileTotal(DRAM_DEVICE, "*.GRF");

/*
* x = password
* y = 0 (static RAM not installed)
* 1 (static RAM installed)
*/
x = 8888;
y = 0;

/* String 1 <STX>aaa,b,c,dddd,eee,f,g,h,iii,j,k,l<ETX><CR><LF>
* String 2 <STX>mmm,n,o,p,q,r,s,t,uuuuuuuu,v,www<ETX><CR><LF>
* String 3 <STX>xxxx,y<ETX><CR><LF>
*/
   SendPrintf("\x02%03d,%d,%d,%04d,%03d,%d,%d,%d,%03d,%d,%d,%d\x03\r\n",
       a, b, c, d, e, f, g, h, i, j, k, l);
   SendPrintf("\x02%03d,%d,%d,%d,%d,%d,%d,%d,%08d,%d,%03d\x03\r\n",
       m, n, o, p, q, r, s, t, u, v, w);
   SendPrintf("\x02%04d,%d\x03\r\n",
       x, y);
}

#endif

Zpl2Report.h 、、、、、、、、、、、、、、、、

#ifndef ZPL2REPORT_H

/******************************************************************************
* *
* M O D U L E D E F I N E *
* *
******************************************************************************/

#define ZPL2REPORT_H

/******************************************************************************
* *
* C O M P I L E R D E F I N E D I N C L U D E F I L E S *
* *
******************************************************************************/

/* None */

#include "Zpl2Type.h"

#ifdef __cplusplus
extern "C" { /* Assume C declarations for C++ */
#endif /* __cplusplus */

/******************************************************************************
* *
* G L O B A L D E F I N E S *
* *
******************************************************************************/

/******************************************************************************
* *
* S T R U C T U R E D E F I N I T I O N S *
* *
******************************************************************************/

/******************************************************************************
* *
* G L O B A L V A R I A B L E S - N O I N I T I A L I Z E R S *
* *
******************************************************************************/

#ifdef ZPL2REPORT_C
#define EXTERN
#else
#define EXTERN extern
#endif

/******************************************************************************
* *
* G L O B A L V A R I A B L E S - I N I T I A L I Z E R S *
* *
******************************************************************************/

/******************************************************************************
* *
* F U N C T I O N P R O T O T Y P E S *
* *
******************************************************************************/

#undef EXTERN

VOID ConfigLabel(_OutputWay);
VOID DirectoryList(_ObjFile *, _OutputWay);
VOID HostFormat(_ObjFile *);
VOID HostGraphics(_ObjFile *);
VOID HostIdentification(VOID);
VOID HostRamStatus(VOID);
VOID HostStatusReturn(VOID);

#ifdef __cplusplus
} /* End of extern "C" { */
#endif /* __cplusplus */

#endif

Zpl2Type.c 、、、、、、、、、、、、、、、、、、、、、、

/******************************************************************************
* *
* M O D U L E D E F I N E *
* *
******************************************************************************/

#define ZPL2TYPE_C

#include <ctype.h>
#include <string.h>

#include "Common.h"
#include "..\Parser.h"
#include "..\ParserUtil.h"
#include "Zpl2Util.h"
#include "Zpl2Format.h"
#include "Zpl2Field.h"
#include "Zpl2Control.h"
#include "Zpl2Type.h"

/******************************************************************************
* *
* L O C A L D E F I N E S *
* *
******************************************************************************/

#if defined(ZPL2)

/******************************************************************************
* *
* L O C A L T Y P E D E F S *
* *
******************************************************************************/

/******************************************************************************
*
* Function:
*
*
* Description:
*
*
* Input:
*     None.
*
* Output:
*     None.
*
******************************************************************************/
BOOL Whether(CHAR whether)
{
   if (whether == 'Y')
       return TRUE;

return FALSE;
}

INT ToHex(INT data)
{
return (isdigit(data) ? data - '0' : toupper(data) - 'A' + 10);
}

_eFileDevice ToFileDevice(CHAR device)
{
   if (device == MemoryAlias.R)   // DRAM
       return DRAM_DEVICE;
   if (device == MemoryAlias.E)   // Internal Flash Memory
       return FLASH_DEVICE;
   if (device == MemoryAlias.B)   // Flash Memory Card
       return CARD_DEVICE;
   if (device == MemoryAlias.A)   // Compact Flash Memory
       return CARD_DEVICE;

return NO_SELECT_DEVICE;
}

BOOL IsEnlargeFormat(CHAR DPM)
{
if (DPM == 'B')
return TRUE;

return FALSE;
}

BOOL IsScalableFont(CHAR *name)
{
if (strcmp(strchr(name, '.'), ".TTF") == 0)
return TRUE;

return FALSE;
}

BOOL SearchScalableFont(CHAR *name)
{
SHORT Width, Height;
CHAR buf[13];

   strcpy(strchr(strcpy(buf, name), '.'), ".TTF");
   if (GetFontSize(buf, LANG_ZPL, &Width, &Height))
       return TRUE;

return FALSE;
}

SHORT XAxis(SHORT X)
{
   if (ToDirection(LabelOrientation) ^ Whether(LabelMirror))
       X = X + LabelHome.X - LabelShift + pPrintCfg->ShiftDisX + ShiftXBase;
   else
       X = X + LabelHome.X + LabelShift - pPrintCfg->ShiftDisX - ShiftXBase;

if (X < 0)
X = 0;

X += ReferenceXBase;

#if defined(LEFT_ALIGN)
   if (ToDirection(LabelOrientation) ^ Whether(LabelMirror))
       X += (INT)(MM_DOT * 2.0);
   else
       X += (TPH_WIDTH_DOT - LabelWidth) - (INT)(MM_DOT * 2.0);
#else
   X += (TPH_WIDTH_DOT - LabelWidth) >> 1;

#endif

return X;
}

SHORT YAxis(SHORT Y)
{
Y += LabelHome.Y;

if (Y < 0)
Y = 0;

Y += ReferenceYBase;

return Y;
}

VOID ToPrintConfig(_PrintCfg *pPrtCfg)
{
pPrtCfg->PrintOutMode = ToPrintOut(PrintMode, Format.SuppressBack);
pPrtCfg->SuppressBack = BackfeedSequence == 'O' ? TRUE : FALSE;

pPrtCfg->ShiftDisY -= LabelTop;
pPrtCfg->OffsetDis += AdjustPosition + LabelTop;

   pPrtCfg->CutterPieces = Format.PauseCut ? Format.PauseCut : 1;
//   pPrtCfg->RibbonFlag = ToRibbon(MediaType);
   pPrtCfg->Direction = ToDirection(LabelOrientation);
   pPrtCfg->Mirror = Whether(LabelMirror);
   pPrtCfg->PrintKey = FALSE;
   pPrtCfg->fDensity = ToDensity(PrintDarkness + MediaDarkness);
   pPrtCfg->Speed = ToSpeed(PrintSpeed);
}

INT ToDegree(CHAR orientation)
{
   if (orientation == 'N')
       return 0;   // normal
   else if (orientation == 'R')
       return 90;   // rotated 90 degrees(clockwise)
   else if (orientation == 'I')
       return 180;   // inverted 180 degrees
   else if (orientation == 'B')
       return 270;   // read from bottom up, 270 degrees

return 0; // normal
}

_ePutWay ToPutWay(BOOL reverse)
{
if (Whether(LabelReverse) || reverse)
return PUT_XOR;

return PUT_OR;
}

BOOL ToDirection(CHAR orientation)
{
if (orientation == 'I')
return FALSE;

return TRUE;
}

_eSensorMode ToSensorMode(CHAR tracking)
{
   // continuous media
   if (tracking == 'N')
       return CONTINUE_MODE_T;
   // non-continuous media web sensing
   else if (tracking == 'Y' || tracking == 'W')
       return GAP_MODE;
   // non-continuous media mark sensing
   else if (tracking == 'M')
       return BLINE_MODE;

return CONTINUE_MODE_T;
}

CHAR ToMediaTracking(_eSensorMode mode)
{
   if (mode == CONTINUE_MODE_T)
       return 'N';
   else if (mode == GAP_MODE)
       return 'W';
   else if (mode == BLINE_MODE)
       return 'M';

return 'N';
}

FLOAT ToDensity(SHORT darkness)
{
   if (darkness > 30 ) darkness = 30;
   if (darkness < 0 ) darkness = 0;
   return (FLOAT)darkness / 30 * (DensityMax - DensityMin) + DensityMin;
}

SHORT ToSpeed(CHAR speed)
{
   if (speed == 'A')
       speed = 2;
   else if (speed == 'B')
       speed = 3;
   else if (speed == 'C')
       speed = 4;
   else if (speed == 'D')
       speed = 6;
   else if (speed == 'E')
       speed = 8;

speed += PrintRateBase;

return (SHORT)SpeedRange((FLOAT)speed);
}

_ePrintOutMode ToPrintOut(CHAR mode, BOOL back)
{
   if (back)   // ^XB Operation is Rewind Mode
       return OFF_MODE;
   else if (mode == 'T')   // T = Tear-off
       return TEAR_MODE;
   else if (mode == 'P')   // P = Peel-off
       return PEEL_MODE;
   else if (mode == 'R')   // R = Rewind
       return OFF_MODE;
   else if (mode == 'A')   // A = Applicator
       return TEAR_MODE;
   else if (mode == 'C')   // C = Cutter
       return CUTTER_MODE;
   else if (mode == 'D')   // D = Delayed cutter
       return CUTTER_MODE;

return TEAR_MODE;
}

BOOL ToRibbon(CHAR type)
{
   if (type == 'T')       // thermal transfer media
       return TRUE;
   else if (type == 'D')   // direct thermal media
       return FALSE;

return FALSE;
}

#endif

Zpl2Type.h 、、、、、、、、、、、、、、、、、、、、、

#ifndef ZPL2TYPE_H

/******************************************************************************
* *
* M O D U L E D E F I N E *
* *
******************************************************************************/

#define ZPL2TYPE_H

/******************************************************************************
* *
* C O M P I L E R D E F I N E D I N C L U D E F I L E S *
* *
******************************************************************************/

/* None */

#include "XCore.h"

#ifdef ZLIB_COMPRESSION
#include "zlib\zlib.h"
#endif

#ifdef __cplusplus
extern "C" { /* Assume C declarations for C++ */
#endif /* __cplusplus */

/******************************************************************************
* *
* G L O B A L D E F I N E S *
* *
******************************************************************************/

#define MAX_CONTENT               3072
#define MAX_LABEL_LENGTH       HALF_IMAGE_LENGTH
#define MAX_LABEL_WIDTH           TPH_WIDTH_DOT

typedef struct
{
   CHAR               B;
   CHAR               E;
   CHAR               R;
   CHAR               A;
}_MemoryAlias;

typedef struct
{
CHAR Device;
CHAR Name[13];
}_ObjFile;

typedef struct
{
#ifdef ZLIB_COMPRESSION
   z_stream           strm;   // zlib decompression stream
#endif
   CHAR               data;
   CHAR               nibble;
   CHAR               type;
   CHAR               prefix[16];
   BOOL               preline;
   INT                   repeat;
   INT                   step;
   INT                   len;
}_ObjDecode;

typedef struct
{
SHORT X;
SHORT Y;
}_Axis;

typedef struct
{
   BOOL               Use;
   SHORT               Width;
   SHORT               Line;
   SHORT               Space;
   CHAR               Justification;
   SHORT               HangingIndent;
}_FieldBlock;

typedef struct
{
CHAR Direction;
SHORT CharacterGap;
}_FieldParameter;

typedef struct
{
   _ObjFile           File;
   CHAR               Orientation;
   SHORT               Height;
   SHORT               Width;
}_FieldFont;

typedef struct
{
   CHAR               Type;
   CHAR               Orientation;
   SHORT               Width;
   FLOAT               Ratio;
   SHORT               Height;
   CHAR               Interp;
   CHAR               Above;
   CHAR               Check;
   CHAR               Mode;
   CHAR               ParamChar1;
   CHAR               ParamChar2;
   SHORT               Columns;
   SHORT               Rows;
   SHORT               ParamNum1;
   SHORT               ParamNum2;
   CHAR               FieldID[25];
}_FieldBarcode;

typedef struct
{
   SHORT               Width;
   SHORT               Height;
   SHORT               RadiusX;
   SHORT               RadiusY;
   SHORT               Thickness;
   CHAR               Color;
   CHAR               Diagonal;
}_FieldGraphic;

typedef struct
{
   CHAR               Type;
   _ObjFile           File;
   SHORT               MultiX;
   SHORT               MultiY;
}_FieldImage;

typedef struct
{
   SHORT               Number;
   SHORT               Allocate;
   _Axis               Origin;
   _FieldBlock           Block;
   _FieldParameter       Parameter;
   BOOL               Typeset;
   BOOL               Reverse;
   BOOL               FontSet;
   CHAR               DataType;
   CHAR               Serialization;
   CHAR               Mask[65];
   CHAR               Increment[65];
   CHAR               LeadingZero;
   CHAR               HexIndicator;
   CHAR               ClockIndicator[3];
   CHAR               DrawType;
   struct
   {
       _FieldFont       Font;
       _FieldBarcode   Barcode;
       _FieldGraphic   Graphic;
       _FieldImage       Image;
   }Draw;
}_Field;

typedef struct
{
SHORT Length;
CHAR Content[MAX_CONTENT + 1];
}_FieldData;

typedef struct
{
   _Axis               Origin;
   SHORT               Width;
   SHORT               Height;
}_DrawArea;

typedef struct
{
   BOOL               Use;
   _Field               Field;
   _FieldData           Data;
   _DrawArea           Area;
}_Serialization;

typedef struct
{
   BOOL               Print;
   BOOL               SuppressBack;
   LONG               Quantity;
   LONG               PauseCut;
   LONG               Replicate;
   CHAR               Override;
   CHAR               SaveType;
   _ObjFile           ImageFile;
}_Format;

typedef struct
{
   CHAR               ID;
   SHORT               Height;
   SHORT               Width;
}_DefaultFont;

typedef struct
{
   SHORT               Width;
   FLOAT               Ratio;
   SHORT               Height;
}_DefaultBarcode;

typedef struct
{
   _DefaultFont       Font;
   _DefaultBarcode       Barcode;
   _ObjFile           FontFile;
   CHAR               Orientation;
}_FieldDefault;

#ifdef ZPL2TYPE_C
#define EXTERN
#else
#define EXTERN extern
#endif

EXTERN SHORT PrintRateBase;

BOOL Whether(CHAR);
INT ToHex(INT);
_eFileDevice ToFileDevice(CHAR);
BOOL IsEnlargeFormat(CHAR);
BOOL IsScalableFont(CHAR *);
BOOL SearchScalableFont(CHAR *);
SHORT XAxis(SHORT);
SHORT YAxis(SHORT);
VOID ToPrintConfig(_PrintCfg *);
INT ToDegree(CHAR);
_ePutWay ToPutWay(BOOL);
BOOL ToDirection(CHAR);
_eSensorMode ToSensorMode(CHAR);
CHAR ToMediaTracking(_eSensorMode);
FLOAT ToDensity(SHORT);
SHORT ToSpeed(CHAR);
_ePrintOutMode ToPrintOut(CHAR, BOOL);
BOOL ToRibbon(CHAR);

#undef EXTERN

#ifdef __cplusplus
} /* End of extern "C" { */
#endif /* __cplusplus */

#endif

Zpl2Util.c 、、、、、、、、、、、、、、、、、、、、、、、

/******************************************************************************
* *
* M O D U L E D E F I N E *
* *
******************************************************************************/

#define ZPL2UTIL_C

#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>

#include "Common.h"
#include "..\Parser.h"
#include "..\ParserUtil.h"
#include "Zpl2Format.h"
#include "Zpl2Control.h"
#include "Zpl2Util.h"

/******************************************************************************
* *
* L O C A L D E F I N E S *
* *
******************************************************************************/

#if defined(ZPL2)

/******************************************************************************
* *
* L O C A L T Y P E D E F S *
* *
******************************************************************************/

VOID PrefixRule(CHAR *prefix)
{
   *prefix++ = CaretChar;
   *prefix++ = RS_CHAR;
   *prefix++ = TildeChar;
   *prefix++ = DLE_CHAR;
   *prefix++ = STX_CHAR;
   *prefix++ = ETX_CHAR;
   *prefix++ = SI_CHAR;
   *prefix = '\0';
}

CHAR ZebraNextByte(INT kind)
{
CHAR prefix[16];
CHAR data;

   do
   {
       data = NextByte();
       if (kind == NEXT_ANY || FormatStart == FALSE)
           return data;
       if (kind == NEXT_PARAMETER && (BYTE)data >= 0x20)
           return data;

       PrefixRule(prefix);
   }
   while (!CheckChar(data, prefix) && data != DelimiterChar);

return data;
}

INT CheckSeparate(CHAR data)
{
CHAR prefix[16];

   PrefixRule(prefix);
   if (CheckChar(data, prefix))
       return SEP_PREFIX;

if (data == DelimiterChar)
return SEP_DELIMITER;

if (CheckChar(data, "\r\n"))
return SEP_LINEFEED;

return SEP_NULL;
}

STATIC INT SeparateDelimit(INT kind)
{
INT sep;
CHAR data;

data = ZebraNextByte(kind);

   sep = CheckSeparate(data);
   if (sep == SEP_DELIMITER)
       return PARAM_NULL;

BackByte(data);

if (sep == SEP_PREFIX || sep == SEP_LINEFEED)
return PARAM_SUCCESS;

return PARAM_ERROR;
}

STATIC INT SeparateEnd(VOID)
{
INT sep;
CHAR data;

data = ZebraNextByte(NEXT_PARAMETER);
BackByte(data);

   sep = CheckSeparate(data);
   if (sep == SEP_PREFIX || sep == SEP_LINEFEED)
       return PARAM_SUCCESS;

return PARAM_NULL;
}

INT ParamEnd(VOID)
{
INT sep;
CHAR data;

   do
   {
       data = ZebraNextByte(NEXT_ANY);
       sep = CheckSeparate(data);
   }
   while (sep != SEP_LINEFEED && sep != SEP_PREFIX);

BackByte(data);

return PARAM_SUCCESS;
}

INT ParamFont(CHAR *font)
{
INT state;
CHAR data;

if (state = SeparateEnd())
return state;

data = ZebraNextByte(NEXT_PARAMETER);

   // Accepted Values: A through Z, 0 to 9, @
   if (isalnum(data) || data == '@')
       *font = toupper(data);

return SeparateEnd();
}

INT ParamDevice(CHAR *device)
{
   INT state;
   CHAR data;
   CHAR colon;

if (state = SeparateEnd())
return state;

data = ZebraNextByte(NEXT_PARAMETER);
colon = ZebraNextByte(NEXT_PARAMETER);

   if (colon != ':')
   {
       BackByte(colon);
       BackByte(data);
       return PARAM_NULL;
   }

data = toupper(data);

   // Accepted Values: R:, E:, B: and A:
   if (CheckChar(data, "REBA"))
       *device = data;

return SeparateEnd();
}

INT ParamChar(CHAR *character, CHAR *accept, BOOL upper)
{
INT state, kind = (upper ? NEXT_PARAMETER : NEXT_ANY);
CHAR data;

if ((state = SeparateDelimit(kind)) != PARAM_ERROR)
return state;

data = ZebraNextByte(kind);

if (upper)
data = toupper(data);

   // Accepted Values: accept
   if (CheckChar(data, accept) || *accept == '\0')
       *character = data;

   do   data = ZebraNextByte(NEXT_PARAMETER);
   while (CheckSeparate(data) == SEP_NULL);
   BackByte(data);

return SeparateDelimit(NEXT_PARAMETER);
}

INT ParamSpeed(CHAR *speed)
{
   INT state;
   LONG i;
   CHAR buf[16];
   CHAR data;

if ((state = SeparateDelimit(NEXT_PARAMETER)) != PARAM_ERROR)
return state;

do data = ZebraNextByte(NEXT_PARAMETER);
while (data == ' '); // remove space

   if (isdigit(data))
   {
       i = 0;
       do
       {
           if (isdigit(data) && i < 15)
               buf[i++] = data;
       }
       while (CheckSeparate(data = ZebraNextByte(NEXT_PARAMETER)) == SEP_NULL);

buf[i] = '\0';

BackByte(data);

i = atoi(buf);

       // Accepted Values: 2 to 12
       if (i >= 2 && i <= 12)
           *speed = i;
   }

   // Accepted Values: A, B, C, D and E
   else if (CheckChar(data, "ABCDE"))
       *speed = data;

return SeparateDelimit(NEXT_PARAMETER);
}

INT ParamData(_FieldData *data, CHAR *hex, CHAR *clock, BOOL end)
{
   INT state;
   INT sep;
   CHAR temp;

   data->Length = 0;
   while ((sep = CheckSeparate(temp = ZebraNextByte(NEXT_ANY))) != SEP_PREFIX)
   {
       if (end == FALSE && sep == SEP_DELIMITER)
           break;

if (sep == SEP_LINEFEED)
continue;

       if (*hex && temp == *hex)
           temp = (ToHex(ZebraNextByte(NEXT_ANY)) << 4) |
           ToHex(ZebraNextByte(NEXT_ANY));

//else if (temp == clock[0] || temp == clock[1] || temp == clock[2])
// rtc(ZebraNextByte(NEXT_ANY), buf, &len);

       if (data->Length < sizeof(data->Content) - 1)
           data->Content[data->Length++] = temp;
   }
   data->Content[data->Length] = '\0';

BackByte(temp);

return SeparateDelimit(NEXT_PARAMETER);
}

INT ParamName(CHAR *name, SHORT acc, ...)
{
   va_list args;
   INT state;
   INT i;
   CHAR buf[10];
   CHAR ext[4]   = "";
   CHAR data;
   CHAR **accext;
   BOOL valid = TRUE;

if ((state = SeparateDelimit(NEXT_PARAMETER)) != PARAM_ERROR)
return state;

   i = 0;
   while (CheckSeparate(data = ZebraNextByte(NEXT_PARAMETER)) == SEP_NULL)
   {
       if (data == '.')
           break;

if (!isgraph(data))
valid = FALSE;

       // Accepted Values: 1 to 8 printable (and not a space) characters
       if (valid && i < 8)
           buf[i++] =    toupper(data);
   }
   buf[i] = '\0';

   if (data == '.')
   {
       i = 0;
       while (CheckSeparate(data = ZebraNextByte(NEXT_PARAMETER)) == SEP_NULL)
       {
           // Accepted Values: 1 to 3 printable (and not a space) characters
           if (isgraph(data) && i < 3)
               ext[i++] =    toupper(data);
       }
       ext[i] = '\0';
   }
   BackByte(data);

   if (accext = malloc(acc * sizeof(CHAR *)))
   {
       va_start(args, acc);
       for (i = 0; i < acc; i++)
           *(accext + i) = va_arg(args, CHAR *);
       va_end(args);

       // compare fixed extension
       for (i = 0; i < acc; i++)
           if (strcmp(ext, *(accext + i)) == 0)
               break;

if (i == acc)
strcpy(ext, *accext); // Default Value

free(accext);
}

sprintf(name, "%s.%s", buf, ext);

return SeparateDelimit(NEXT_PARAMETER);
}

INT ParamNumber(VOID *num, INT type, DOUBLE lower, DOUBLE higher)
{
   INT state;
   INT i;
   DOUBLE d;
   CHAR buf[16];
   CHAR data;

if ((state = SeparateDelimit(NEXT_PARAMETER)) != PARAM_ERROR)
return state;

   i = 0;
   while (CheckSeparate(data = ZebraNextByte(NEXT_PARAMETER)) == SEP_NULL)
   {
       if ((isdigit(data) || data == '-' || data == '.') && i < 15)
           buf[i++] = data;
   }
   buf[i] = '\0';

BackByte(data);

d = atof(buf);

   // Accepted Values: lower to higher
   if (d >= lower && d <= higher)
   {
       if (type == PARAM_NUMBER_CHAR)
           *(CHAR *)num = d;
       else if (type == PARAM_NUMBER_SHORT)
           *(SHORT *)num = d;
       else if (type == PARAM_NUMBER_LONG)
           *(LONG *)num = d;
       else if (type == PARAM_NUMBER_FLOAT)
           *(FLOAT *)num = d;
       else if (type == PARAM_NUMBER_DOUBLE)
           *(DOUBLE *)num = d;
   }

return SeparateDelimit(NEXT_PARAMETER);
}

INT ParamUnit(SHORT *unit, SHORT lower, SHORT higher, BOOL overrange)
{
   INT state;
   INT i;
   DOUBLE d;
   CHAR buf[16];
   CHAR data;

if ((state = SeparateDelimit(NEXT_PARAMETER)) != PARAM_ERROR)
return state;

BackByte(data);

d = atof(buf);

if (lower >= 0) // absolute
d = (d < 0) ? (.0 - d) : d;

   if (MeasureUnit == 'I')
       d *= TPH_DPI;
   if (MeasureUnit == 'M')
       d *= MM_DOT;

i = (SHORT)(d + 0.5); // to round off

if (MeasureUnit == 'D')
i *= ConvertDPI;

   if (overrange)
   {
       if (i < lower)
           i = lower;
       if (i > higher)
           i = higher;
   }

   // Accepted Values: lower to higher
   if (i >= lower && i <= higher)
       *unit = i;

return SeparateDelimit(NEXT_PARAMETER);
}

#endif

Zpl2Util.h 、、、、、、、、、、、、、、、、、、、、、、、、、

#ifndef ZPL2UTIL_H

/******************************************************************************
* *
* M O D U L E D E F I N E *
* *
******************************************************************************/

#define ZPL2UTIL_H

#include <stdarg.h>

#include "Zpl2Type.h"

#ifdef __cplusplus
extern "C" { /* Assume C declarations for C++ */
#endif /* __cplusplus */

/******************************************************************************
* *
* G L O B A L D E F I N E S *
* *
******************************************************************************/

#define NEXT_ANY 0
#define NEXT_PARAMETER 1

#define SEP_NULL               0
#define SEP_PREFIX               1
#define SEP_DELIMITER           2
#define SEP_LINEFEED           3

#define PARAM_NULL               0
#define PARAM_SUCCESS           1
#define PARAM_ERROR               2

#define PARAM_NUMBER_CHAR       0
#define PARAM_NUMBER_SHORT       1
#define PARAM_NUMBER_LONG       2
#define PARAM_NUMBER_FLOAT       3
#define PARAM_NUMBER_DOUBLE       4

#ifdef ZPL2UTIL_C
#define EXTERN
#else
#define EXTERN extern
#endif

VOID PrefixRule(CHAR *);
CHAR ZebraNextByte(INT);
INT CheckSeparate(CHAR);
INT ParamEnd(VOID);
INT ParamFont(CHAR *);
INT ParamDevice(CHAR *);
INT ParamChar(CHAR *, CHAR *, BOOL);
INT ParamSpeed(CHAR *);
INT ParamData(_FieldData *, CHAR *, CHAR *, BOOL);
INT ParamName(CHAR *, SHORT, ...);
INT ParamNumber(VOID *, INT, DOUBLE, DOUBLE);
INT ParamUnit(SHORT *, SHORT, SHORT, BOOL);

#undef EXTERN

#ifdef __cplusplus
} /* End of extern "C" { */
#endif /* __cplusplus */

#endif