T168_111\appl\Parser\Dpl 文件：最后3对文件

最新推荐文章于 2024-07-18 17:22:51 发布

qq_33772147

最新推荐文章于 2024-07-18 17:22:51 发布

阅读量869

点赞数 19

文章标签： c# 开发语言

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

版权

DplModule.c ///

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

#define DPLMODULE_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 <stdlib.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 "XCore.h"
#include "XLCD.h"
#include "XLED.h"
#include "XTimer.h"
#include "XFileSys.h"
#include "XGraphic.h"
#include "XDisplay.h"
#include "XFunction.h"
#include "..\ParserUtil.h"
#include "DplCtrlCode.h"
#include "DplConfig.h"
#include "DplType.h"
#include "DplUtil.h"
#include "DplModule.h"

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

#if defined(DPL)

#define MOD_FILE_TYPE_IMAGE               'G'
#define MOD_FILE_TYPE_LABEL_FORMAT       'L'
#define MOD_FILE_TYPE_BIT_MAP_FONT       'F'
#define MOD_FILE_TYPE_SCALABLE_FONT       'S'
#define MOD_FILE_TYPE_CONFIGURATION       'C'
#define MOD_FILE_TYPE_LANGUAGE           'X'
#define MOD_FILE_TYPE_PLUG_IN           'N'
#define MOD_FILE_TYPE_MISCELLANEOUS       'M'
#define MOD_FILE_TYPE_UNKNOWN           'u'

#define DIF_ID_CHAR 'D'

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

typedef struct
{
   CHAR   ID;
   CHAR   Flipped;
   WORD   Width;
   WORD   Height;
   WORD   Dummy;
} DIFHEADER;

typedef struct
{
   WORD   Dummy;
   WORD   IdentWord;
   DWORD   FileSize;
   WORD   Rev0;
   WORD   Rev1;
   DWORD    Offset;
   DWORD    Size;
   DWORD    Width;
   DWORD    Height;
   WORD   Planes;
   WORD   BitCount;
   DWORD   Compression;
   DWORD   SizeImage;
   DWORD   XPelsPerMeter;
   DWORD   YPelsPerMeter;
   DWORD   ClrUsed;
   DWORD   ClrImportant;
} BMPHEADER;

typedef struct
{
   BYTE   Manufacturer;
   BYTE   VersionNo;
   BYTE   Encoding;
   BYTE   BitsPerPixel;
   WORD   Xmin;
   WORD   Ymin;
   WORD   Xmax;
   WORD   Ymax;
   WORD   HResolution;
   WORD   VResolution;
   BYTE   Palette[48];
   BYTE   Reserved;
   BYTE   Planes;
   WORD   BytesPerLine;
   WORD   PaletteType;
   WORD   HScreenSize;
   WORD   VScreenSize;
   BYTE   Filler[54];
} PCXHEADER;

typedef struct
{
   WORD   Version;
   WORD   HeaderSize;
   WORD   Planes;
   WORD   PatternSize;
   WORD   PixelWidth;
   WORD   PixelHeight;
   WORD   ImgaeWidth;
   WORD   ImageHeight;
   WORD   Reversed;
} IMGHEADER;

/******************************************************************************
* *
* 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 *
* *
******************************************************************************/

STATIC CHAR *FileNameExtension(CHAR *Name, CHAR FileType)
{
STATIC CHAR FileName[32];

   strcpy(FileName, Name);
   switch (FileType)
   {
       case MOD_FILE_TYPE_IMAGE:           // G = Image file
           strcat(FileName, ".DIF");
           break;
       case MOD_FILE_TYPE_LABEL_FORMAT:   // L = Label format file
           strcat(FileName, ".LAB");
           break;
       case MOD_FILE_TYPE_BIT_MAP_FONT:   // F = Downloaded bit-mapped font file
           strcat(FileName, "DMX.BMF");
           break;
       case MOD_FILE_TYPE_SCALABLE_FONT:   // S = Downloaded scalable font file
           strcat(FileName, "DMX.TTF");
           break;
       case MOD_FILE_TYPE_CONFIGURATION:   // C = Configuration file
           strcat(FileName, ".CFG");
           break;
       case MOD_FILE_TYPE_LANGUAGE:       // X = Language file
           strcat(FileName, ".XXX");
           break;
       case MOD_FILE_TYPE_PLUG_IN:           // N = Plug-in file
           strcat(FileName, ".XXX");
           break;
       case MOD_FILE_TYPE_MISCELLANEOUS:   // M = Miscellaneous file type
           strcat(FileName, ".MCL");
           break;
       case MOD_FILE_TYPE_UNKNOWN:           // u = Unknown type
       default:
           break;
   }
   return FileName;
}

STATIC INT SaveDmxImg(CHAR Module, CHAR *Name)
{
   _eFileDevice Device;
   _FileHandle *Handle;
   DIFHEADER DIF;
   CHAR *FileName;
   CHAR LineBuf[256];
   CHAR DataBuf[512];
   CHAR Data;
   WORD LineNumber;
   WORD LineLength;
   WORD DataLength;
   WORD Repeat;
   INT state = _NULL;
   INT i;

Device = TransformFileDevice(Module);
FileName = FileNameExtension(Name, MOD_FILE_TYPE_IMAGE);

   Remove(Device, FileName);
   if ((Handle = Fopen(Device, FileName, "w")) == _NULL)
       return FALSE;

   // Write dummy head to file
   memset((VOID *)&DIF, 0xff, sizeof(DIF));
   if (Fwrite(&DIF, sizeof(DIFHEADER), 1, Handle) != 1)
       state = END_OF_FILE;

   DIF.ID = DIF_ID_CHAR;
   DIF.Flipped = 0;
   DIF.Width = 0;
   DIF.Height = 0;

   Repeat = 1;
   LineLength = 0;
   while (1)
   {
       LineNumber = 0;
       DataLength = 0;
       while (DataLength < 4)
       {
           Data = DmxNextByte();
           if (isxdigit(Data))
               DataBuf[DataLength++] = Data;
           if (DmxIsTerminate(Data))
               DataLength = 0;
       }

       // Terminate
       if (memcmp(DataBuf, "FFFF", 4) == 0)
           break;

       // Duplicate records
       else if (memcmp(DataBuf, "0000", 4) == 0)
       {
           DataLength = 0;
           while (DataLength < 4)
           {
               Data = DmxNextByte();
               if (isxdigit(Data))
                   DataBuf[DataLength++] = Data;
               if (DmxIsTerminate(Data))
                   break;
           }
           if (DataLength >= 4 && memcmp(DataBuf, "FF", 2) == 0)
           {
               Repeat = (TransformHex(DataBuf[2]) << 4) | TransformHex(DataBuf[3]);
               if (DatamaxModel.Display == DISPLAY_EQUIPPED)
                   LineNumber = Repeat;
           }
       }

       else if (memcmp(DataBuf, "80", 2) == 0)
       {
           DataLength = 0;
           LineLength = (TransformHex(DataBuf[2]) << 4) | TransformHex(DataBuf[3]);
           while (DataLength < LineLength * 2)
           {
               Data = DmxNextByte();
               if (isxdigit(Data) && DataLength < sizeof(DataBuf))
                   DataBuf[DataLength++] = Data;
               if (DmxIsTerminate(Data))
                   break;
           }
           for (i = 0; i < LineLength; i++)
               LineBuf[i] = (TransformHex(DataBuf[i * 2]) << 4) | TransformHex(DataBuf[i * 2 + 1]);

           if (DatamaxModel.Display == DISPLAY_EQUIPPED)
               Repeat = 1;
           LineNumber = Repeat;
           Repeat = 1;
       }

       while (LineNumber)
       {
           if (state != END_OF_FILE)
           {
               // write width bytes
               if (Fwrite(&LineLength, sizeof(WORD), 1, Handle) != 1)
                   state = END_OF_FILE;
           }
           if (state != END_OF_FILE)
           {
               // write data
               if (Fwrite(&LineBuf, sizeof(CHAR), LineLength, Handle) != LineLength)
                   state = END_OF_FILE;
           }
           DIF.Height += 1;
           LineNumber--;
       }
   }

   if (state != END_OF_FILE)
   {
       Fseek(Handle, 0, SEEK_SET);
       if (Fwrite(&DIF, sizeof(DIFHEADER), 1, Handle) != 1)
           state = END_OF_FILE;
   }

Fclose(Handle);

   if (state == END_OF_FILE)
   {
       Remove(Device, FileName);
       MemoryFailed();
   }

return TRUE;
}

STATIC INT SaveBMP(CHAR Module, CHAR *Name, INT Flipped)
{
   _eFileDevice Device;
   _FileHandle *Handle;
   BMPHEADER BMP;
   DIFHEADER DIF;
   BYTE Data;
   BYTE *pTemp;
   CHAR *FileName;
   CHAR LineBuf[256];
   INT ReadBytes;
   INT LineLength;
   INT Lines;
   INT state = _NULL;
   INT i;

if ((Data = DmxNextByte()) != LF_CHAR || CtrlCode.CR != CR_CHAR)
DmxBackByte(Data);

   // Get BMP Head
   pTemp = (BYTE *)&BMP;
   *(pTemp + 0) = 0x00;   // Dummy
   *(pTemp + 1) = 0x00;   // Dummy
   for (i = 2; i < sizeof(BMPHEADER); i++)
       *(pTemp + i) = DmxNextByte();

   BMP.IdentWord = le16_to_cpu(BMP.IdentWord);
   BMP.FileSize = le32_to_cpu(BMP.FileSize);
   BMP.Rev0 = le16_to_cpu(BMP.Rev0);
   BMP.Rev1 = le16_to_cpu(BMP.Rev1);
   BMP.Offset = le32_to_cpu(BMP.Offset);
   BMP.Size = le32_to_cpu(BMP.Size);
   BMP.Width = le32_to_cpu(BMP.Width);
   BMP.Height = le32_to_cpu(BMP.Height);
   BMP.Planes = le16_to_cpu(BMP.Planes);
   BMP.BitCount = le16_to_cpu(BMP.BitCount);
   BMP.Compression = le32_to_cpu(BMP.Compression);
   BMP.SizeImage = le32_to_cpu(BMP.SizeImage);
   BMP.XPelsPerMeter = le32_to_cpu(BMP.XPelsPerMeter);
   BMP.YPelsPerMeter = le32_to_cpu(BMP.YPelsPerMeter);
   BMP.ClrUsed = le32_to_cpu(BMP.ClrUsed);
   BMP.ClrImportant = le32_to_cpu(BMP.ClrImportant);

   // remove unuse byte
   for (i = 0; i < 8; i++)
       DmxNextByte();

if (BMP.IdentWord != 0x4d42)
return FALSE;

   DIF.ID = DIF_ID_CHAR;
   DIF.Flipped = !Flipped;
   DIF.Width = BMP.Width;
   DIF.Height = BMP.Height;

   ReadBytes = ((DIF.Width + 31) / 32) * 4;
   LineLength = (DIF.Width + 7) / 8;
   Lines = DIF.Height;

Device = TransformFileDevice(Module);
FileName = FileNameExtension(Name, MOD_FILE_TYPE_IMAGE);

   Remove(Device, FileName);
   if ((Handle = Fopen(Device, FileName, "w")) == _NULL)
       return FALSE;

   // write head to file
   if (Fwrite(&DIF, sizeof(DIFHEADER), 1, Handle) != 1)
       state = END_OF_FILE;

   while (Lines)
   {
       if (state == END_OF_FILE)
           break;

for (i = 0; i < ReadBytes; i++)
LineBuf[i] = ~DmxNextByte();

       if (state != END_OF_FILE)
       {
           if (Fwrite(&LineBuf, sizeof(CHAR), LineLength, Handle) != LineLength)
               state = END_OF_FILE;
       }
       Lines--;
   }
   Fclose(Handle);

   if (state == END_OF_FILE)
   {
       Remove(Device, FileName);
       MemoryFailed();
   }

return TRUE;
}

STATIC INT SaveIMG(CHAR Module, CHAR *Name, INT Flipped)
{
   _eFileDevice Device;
   _FileHandle *Handle;
   IMGHEADER IMG;
   DIFHEADER DIF;
   BYTE Data;
   BYTE *pTemp;
   CHAR *FileName;
   CHAR PatternBuf[256];
   CHAR LineBuf[256];
   INT Lines, WidthBytes;
   INT RepeatLines, LineIndex;
   INT RepeatData;
   INT state = 0;
   INT i;

if ((Data = DmxNextByte()) != LF_CHAR || CtrlCode.CR != CR_CHAR)
DmxBackByte(Data);

   // Get IMG Head
   IMG.Version = (BYTE)DmxNextByte() * 256 + (BYTE)DmxNextByte();
   if (IMG.Version != 0x0001)
       return FALSE;
   IMG.HeaderSize = (BYTE)DmxNextByte() * 256 + (BYTE)DmxNextByte();
   if (IMG.HeaderSize != 8 && IMG.HeaderSize != 9)
       return FALSE;
   IMG.Planes = (BYTE)DmxNextByte() * 256 + (BYTE)DmxNextByte();
   IMG.PatternSize = (BYTE)DmxNextByte() * 256 + (BYTE)DmxNextByte();
   IMG.PixelWidth = (BYTE)DmxNextByte() * 256 + (BYTE)DmxNextByte();
   IMG.PixelHeight = (BYTE)DmxNextByte() * 256 + (BYTE)DmxNextByte();
   IMG.ImgaeWidth = (BYTE)DmxNextByte() * 256 + (BYTE)DmxNextByte();
   IMG.ImageHeight = (BYTE)DmxNextByte() * 256 + (BYTE)DmxNextByte();
   if (IMG.HeaderSize == 9)
       IMG.Reversed = (BYTE)DmxNextByte() * 256 + (BYTE)DmxNextByte();

   DIF.ID = DIF_ID_CHAR;
   DIF.Flipped = Flipped;
   DIF.Width = IMG.ImgaeWidth;
   DIF.Height = IMG.ImageHeight;

Device = TransformFileDevice(Module);
FileName = FileNameExtension(Name, MOD_FILE_TYPE_IMAGE);

   Remove(Device, FileName);
   if ((Handle = Fopen(Device, FileName, "w")) == _NULL)
       return FALSE;

   // write head to file
   if (Fwrite(&DIF, sizeof(DIF), 1, Handle) != 1)
       state = END_OF_FILE;

Lines = IMG.ImageHeight;
WidthBytes = (IMG.ImgaeWidth + 7) / 8;

RepeatLines = 0;
LineIndex = 0;

   while (Lines)
   {
       Data = DmxNextByte();
       if (Data == 0x00)
       {
           Data = DmxNextByte();
           if (Data == 0x00)
           {
               // Repeated rows
               Data = DmxNextByte();
               if (Data == 0xFF)
                   RepeatLines = DmxNextByte();
           }
           else
           {
               // Pattern
               RepeatData = Data;
               for (i = 0; i < IMG.PatternSize; i++)
                   PatternBuf[i] = DmxNextByte();
               for (i = 0; i < RepeatData; i++)
               {
                   memcpy(&LineBuf[LineIndex], PatternBuf, IMG.PatternSize);
                   LineIndex += IMG.PatternSize;
               }
           }
       }
       else if (Data == 0x80)
       {
           // Literal string
           RepeatData = DmxNextByte();
           for (i = 0; i < RepeatData; i++)
               LineBuf[LineIndex++] = DmxNextByte();
       }
       else
       {
           RepeatData = Data & 0x7F;
           if (Data & 0x80)
               memset(&LineBuf[LineIndex], 0xFF, RepeatData);
           else
               memset(&LineBuf[LineIndex], 0x00, RepeatData);

LineIndex += RepeatData;
}

       if (LineIndex >= WidthBytes)
       {
           if (RepeatLines)
           {
               for(i = 0; i < RepeatLines; i++)
               {
                   if (state != END_OF_FILE)
                   {
                       if (Fwrite(&LineBuf, sizeof(CHAR), WidthBytes, Handle) != WidthBytes)
                           state = END_OF_FILE;
                   }
               }
               Lines -= RepeatLines;
           }
           else
           {
               if (state != END_OF_FILE)
               {
                   if (Fwrite(&LineBuf, sizeof(CHAR), WidthBytes, Handle) != WidthBytes)
                       state = END_OF_FILE;
               }
               Lines--;
           }
           RepeatLines = 0;
           LineIndex = 0;
       }
   }
   Fclose(Handle);

   if (state == END_OF_FILE)
   {
       Remove(Device, FileName);
       MemoryFailed();
   }

return TRUE;
}

STATIC INT SavePCX(CHAR Module, CHAR *Name, INT Flipped)
{
   _eFileDevice Device;
   _FileHandle *Handle;
   PCXHEADER PCX;
   DIFHEADER DIF;
   BYTE Data;
   BYTE *pTemp;
   CHAR *FileName;
   CHAR LineBuf[256];
   INT Width, Height, WidthBytes;
   INT Count, Repeat;
   INT state = 0;
   INT i;

   // Get PCX Head
   pTemp = (BYTE *)&PCX;
   for (i = 0; i < sizeof(PCXHEADER); i++)
       *(pTemp + i) = DmxNextByte();

   PCX.Xmin = le16_to_cpu(PCX.Xmin);
   PCX.Ymin = le16_to_cpu(PCX.Ymin);
   PCX.Xmax = le16_to_cpu(PCX.Xmax);
   PCX.Ymax = le16_to_cpu(PCX.Ymax);
   PCX.HResolution = le16_to_cpu(PCX.HResolution);
   PCX.VResolution = le16_to_cpu(PCX.VResolution);
   PCX.BytesPerLine = le16_to_cpu(PCX.BytesPerLine);
   PCX.PaletteType = le16_to_cpu(PCX.PaletteType);
   PCX.HScreenSize = le16_to_cpu(PCX.HScreenSize);
   PCX.VScreenSize = le16_to_cpu(PCX.VScreenSize);

   // Check file type
   if (PCX.Manufacturer != 0x0A)
       return FALSE;
   // Check single color
   if ((PCX.BitsPerPixel != 1) || (PCX.Planes != 1))
       return FALSE;
   // Get width
   if ((Width = (INT)(PCX.Xmax - PCX.Xmin + 1)) <= 0)
       return FALSE;
   // Get height
   if ((Height = (INT)(PCX.Ymax - PCX.Ymin + 1)) <= 0)
       return FALSE;
   // Check bytes per line
   if (PCX.BytesPerLine == 0)
       return FALSE;

   DIF.ID = DIF_ID_CHAR;
   DIF.Flipped = Flipped;
   DIF.Width = Width;
   DIF.Height = Height;

WidthBytes = (Width + 7) / 8;

Device = TransformFileDevice(Module);
FileName = FileNameExtension(Name, MOD_FILE_TYPE_IMAGE);

   Remove(Device, FileName);
   if ((Handle = Fopen(Device, FileName, "w")) == _NULL)
       return FALSE;

   // write head to file
   if (Fwrite(&DIF, sizeof(DIFHEADER), 1, Handle) != 1)
       state = END_OF_FILE;

   while (Height)
   {
       Count = 0;
       pTemp = (BYTE *)LineBuf;
       while (Count < WidthBytes)
       {
           if ((Data = DmxNextByte()) >= 0xC0)
           {
               Repeat = Data & 0x3F;
               Count += Repeat;
               Data = ~DmxNextByte();
               for (i = 0 ; i < Repeat ; i++)
                   *pTemp++ = Data;
           }
           else
           {
               Count += 1;
               *pTemp++ = ~Data;
           }
       }
       while (Count < PCX.BytesPerLine)
       {
           if ((Data = DmxNextByte()) >= 0xC0)
           {
               Count += Data & 0x3F;
               DmxNextByte();
           }
           else
               Count += 1;
       }
       if (state != END_OF_FILE)
       {
           if (Fwrite(&LineBuf, sizeof(CHAR), WidthBytes, Handle) != WidthBytes)
               state = END_OF_FILE;
       }
       Height--;
   }
   Fclose(Handle);

   if (state == END_OF_FILE)
   {
       Remove(Device, FileName);
       MemoryFailed();
   }

return TRUE;
}

INT SaveImageFile(CHAR Module, CHAR *Name, CHAR FormatType)
{
INT status = FALSE;

#if defined(LCD_MODEL)
SetDisplayStatus(DIS_DOWNLOADING);
#endif

#if defined(MONO_LED)
StartPeriodFunc(FlashLED2);
#elif defined(POLY_LED)
StartPeriodFunc(FlashGreenLED);
#endif

   switch (FormatType)
   {
       case 'F':
           status = SaveDmxImg(Module, Name);
           break;
       case 'B':
           status = SaveBMP(Module, Name, 1);
           break;
       case 'b':
           status = SaveBMP(Module, Name, 0);
           break;
       case 'I':
           status = SaveIMG(Module, Name, 1);
           break;
       case 'i':
           status = SaveIMG(Module, Name, 0);
           break;
       case 'P':
           status = SavePCX(Module, Name, 1);
           break;
       case 'p':
           status = SavePCX(Module, Name, 0);
           break;
   }

#if defined(MONO_LED)
   CancelPeriodFunc(FlashLED2);
   ShowLED(HID_LED_IDLE, HID_LED_ON, HID_LED_IDLE);
#elif defined(POLY_LED)
   CancelPeriodFunc(FlashGreenLED);
   ShowLED(HID_LED_GREEN);
#endif

#if defined(LCD_MODEL)
ClrDisplayStatus(DIS_DOWNLOADING);
#endif

return status;
}

INT LoadImageFile(CHAR *Name, INT Column, INT Row, INT MultiW, INT MultiH, _ePutWay PutWay)
{
   _FileHandle *Handle;
   _ImgBuf   Image;
   DIFHEADER DIF;
   CHAR *FileName;
   BYTE LineBuf[TPH_WIDTH_BYTE];
   WORD WidthBytes;
   INT Width;
   INT Lines;
   INT X, Y;

FileName = FileNameExtension(Name, MOD_FILE_TYPE_IMAGE);

   if ((Handle = Fopen(DRAM_DEVICE, FileName, "r")) == _NULL)
       if ((Handle = Fopen(FLASH_DEVICE, FileName, "r")) == _NULL)
           if ((Handle = Fopen(CARD_DEVICE, FileName, "r")) == _NULL)
               return FALSE;

   Fread(&DIF, sizeof(DIFHEADER), 1, Handle);
   Width = DIF.Width;
   WidthBytes = (Width + 7) / 8;

   if (Image.pBuffer = malloc(TPH_WIDTH_BYTE * MultiH))
   {
       Image.iHeight = MultiH;
       Image.iWidth = Width * MultiW;
       Image.iByteWidth = (Image.iWidth + 7) / 8;
       X = Column - Image.iWidth;
       for (Lines = 0; Lines < DIF.Height; Lines++)
       {
           if (DIF.Width == 0)
           {
               Fread(&WidthBytes, sizeof(WidthBytes), 1, Handle);
               Width = WidthBytes * 8;
               Image.iWidth = Width * MultiW;
               Image.iByteWidth = (Image.iWidth + 7) / 8;
               X = Column - Image.iWidth;
           }
           if (WidthBytes <= TPH_WIDTH_BYTE)
           {
               Y = Row + Lines * MultiH;
               if (DIF.Flipped)
                   Y = Row + (DIF.Height - Lines) * MultiH;

               Fread(LineBuf, sizeof(CHAR), WidthBytes, Handle);
               LineMultiple(LineBuf, Image.pBuffer, Width, MultiW, MultiH, 0);
               PutImage(&sImageBuffer, &Image, X, Y, 180, PutWay);
           }
       }
       free(Image.pBuffer);
   }
   Fclose(Handle);
   return TRUE;
}

INT StoreLabelFormat(CHAR Module, CHAR *Name)
{
   _FileHandle *Handle;
   _eFileDevice Device;
   CHAR *FileName;
   INT state = _NULL;
   INT size;

#if defined(LCD_MODEL)
SetDisplayStatus(DIS_DOWNLOADING);
#endif

#if defined(MONO_LED)
StartPeriodFunc(FlashLED2);
#elif defined(POLY_LED)
StartPeriodFunc(FlashGreenLED);
#endif

Device = TransformFileDevice(Module);
FileName = FileNameExtension(Name, MOD_FILE_TYPE_LABEL_FORMAT);

   Remove(Device, FileName);
   if ((Handle = Fopen(Device, FileName, "w")) == _NULL)
       return FALSE;

   size = LabelStoreLen - (1 + 1 + strlen(Name) + 1);   // "s" + Module + Name + Terminate
   if (Fwrite(LabelStore, sizeof(CHAR), size, Handle) != size)
       state = END_OF_FILE;

Fclose(Handle);

   if (state == END_OF_FILE)
   {
       Remove(Device, FileName);
       MemoryFailed();
   }

#if defined(MONO_LED)
   CancelPeriodFunc(FlashLED2);
   ShowLED(HID_LED_IDLE, HID_LED_ON, HID_LED_IDLE);
#elif defined(POLY_LED)
   CancelPeriodFunc(FlashGreenLED);
   ShowLED(HID_LED_GREEN);
#endif

#if defined(LCD_MODEL)
ClrDisplayStatus(DIS_DOWNLOADING);
#endif

return TRUE;
}

INT RecallLabelFormat(CHAR *Name)
{
CHAR *FileName;

FileName = FileNameExtension(Name, MOD_FILE_TYPE_LABEL_FORMAT);

   if (RunFile(DRAM_DEVICE, FileName, 0, _NULL) == _NULL)
       if (RunFile(FLASH_DEVICE, FileName, 0, _NULL) == _NULL)
           if (RunFile(CARD_DEVICE, FileName, 0, _NULL) == _NULL)
               return FALSE;

return TRUE;
}

INT DownloadScalableFont(CHAR Module, CHAR *FontID, CHAR *Title, CHAR FontType)
{
   _eFileDevice Device;
   _FileHandle *Handle;
   CHAR Name[] = "--";
   CHAR *FileName;
   CHAR Data;
   INT FontSize;
   INT state = _NULL;
   INT i;

#if defined(LCD_MODEL)
SetDisplayStatus(DIS_DOWNLOADING);
#endif

#if defined(MONO_LED)
StartPeriodFunc(FlashLED2);
#elif defined(POLY_LED)
StartPeriodFunc(FlashGreenLED);
#endif

   memcpy(Name, FontID, 2);
   Device = TransformFileDevice(Module);
   FileName = FileNameExtension(Name, MOD_FILE_TYPE_SCALABLE_FONT);

   Remove(Device, FileName);
   if ((Handle = Fopen(Device, FileName, "w")) == _NULL)
       return FALSE;

   do   Data = DmxNextByte();
   while (DmxIsTerminate(Data));
   DmxBackByte(Data);

   FontSize = 0;
   for (i = 0; i < 8; i++)
   {
       Data = DmxNextByte();
       FontSize = (FontSize << 4) | TransformHex(Data);
   }
   for (i = 0; i < FontSize; i++)
   {
       Data = DmxNextByte();
       if (state != END_OF_FILE)
           state = Fputc((INT)Data, Handle);
   }

Fclose(Handle);

   if (state == END_OF_FILE)
   {
       Remove(Device, FileName);
       MemoryFailed();
   }

#if defined(MONO_LED)
   CancelPeriodFunc(FlashLED2);
   ShowLED(HID_LED_IDLE, HID_LED_ON, HID_LED_IDLE);
#elif defined(POLY_LED)
   CancelPeriodFunc(FlashGreenLED);
   ShowLED(HID_LED_GREEN);
#endif

#if defined(LCD_MODEL)
ClrDisplayStatus(DIS_DOWNLOADING);
#endif

return TRUE;
}

VOID DeleteModuleFile(CHAR Module, CHAR *Name, CHAR FileType)
{
_eFileDevice Device;
CHAR *FileName;

   Device = TransformFileDevice(Module);
   FileName = FileNameExtension(Name, FileType);
   ErasingFile(Device, FileName);
}

#endif

DplModule.h ///

#ifndef DPLMODULE_H

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

#define DPLMODULE_H

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

#include "XGraphic.h"

/******************************************************************************
* *
* 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 *
* *
******************************************************************************/

/******************************************************************************
* *
* 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 *
* *
******************************************************************************/

INT SaveImageFile(CHAR, CHAR *, CHAR);
INT LoadImageFile(CHAR *, INT, INT, INT, INT, _ePutWay);
INT StoreLabelFormat(CHAR , CHAR *);
INT RecallLabelFormat(CHAR *);
INT DownloadScalableFont(CHAR, CHAR *, CHAR *, CHAR);
VOID DeleteModuleFile(CHAR , CHAR *, CHAR);

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

#endif

DplType.c ///

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

#define DPLTYPE_C

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

#include "Common.h"
#include "XCore.h"
#include "..\ParserUtil.h"
#include "DplConfig.h"
#include "DplLabel.h"
#include "DplType.h"

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

#if defined(DPL)

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

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

LONG TransformDot(LONG Data, CHAR UnitMeasure)
{
   if (UnitMeasure == INCH_MODE)
       return (Data * TPH_DPI / 100);
   if (UnitMeasure == METRIC_MODE)
       return (Data * MM_DOT / 10);
   return 0;
}

INT TransformDegree(CHAR Rotation)
{
   if (Rotation == '1')
       return 180;
   if (Rotation == '2')
       return 270;
   if (Rotation == '3')
       return 0;
   if (Rotation == '4')
       return 90;
   return 180;
}

INT TransformLabFmtAttrib(CHAR FmtAttrib)
{
   if (FmtAttrib == 'X')
       return LAB_FMT_ATTRIB_XOR;
   else if (FmtAttrib == 'O')
       return LAB_FMT_ATTRIB_OPAQUE;
   else if (FmtAttrib == 'T')
       return LAB_FMT_ATTRIB_TRANSPARENT;

return LAB_FMT_ATTRIB_XOR;
}

INT TransformBarType(SHORT LabFmtAttrib)
{
   if (LabFmtAttrib == LAB_FMT_ATTRIB_XOR)
       return DRAW_REVERSE;
   else if (LabFmtAttrib == LAB_FMT_ATTRIB_TRANSPARENT)
       return DRAW_BAR;
   else if (LabFmtAttrib == LAB_FMT_ATTRIB_OPAQUE)
       return DRAW_BAR;
   else if (LabFmtAttrib == LAB_FMT_ATTRIB_INVERSE)
       return DRAW_REVERSE;

return DRAW_BAR;
}

_ePutWay TransformPutType(SHORT LabFmtAttrib)
{
   if (LabFmtAttrib == LAB_FMT_ATTRIB_XOR)
       return PUT_XOR;
   else if (LabFmtAttrib == LAB_FMT_ATTRIB_TRANSPARENT)
       return PUT_OR;
   else if (LabFmtAttrib == LAB_FMT_ATTRIB_OPAQUE)
       return PUT_OW;
   else if (LabFmtAttrib == LAB_FMT_ATTRIB_INVERSE)
       return PUT_XOR;

return PUT_XOR;
}

_eFileDevice TransformFileDevice(CHAR Module)
{
if (Module == 'C')
Module = pDmxCfg->DefaultModule;

   switch (Module)
   {
       case 'A':
       case 'D':
           return DRAM_DEVICE;
       case 'B':
       case 'G':
       case 'X':
       case 'Y':
           return FLASH_DEVICE;
       case 'F':
       case 'H':
       case 'Z':
           return CARD_DEVICE;
   }
   return DRAM_DEVICE;
}

_ePrintOutMode TransformPrintOut(BOOL Cutter, BOOL PresentSensor)
{
   if (Cutter)
       return CUTTER_MODE;
   if (PresentSensor)
       return PEEL_MODE;

return TEAR_MODE;
}

_eSensorMode TransformSensorMode(CHAR SensorType)
{
   if (SensorType == EDGE_SENSOR_TYPE)
       return GAP_MODE;
   if (SensorType == CONTINUOUS_SENSOR_TYPE)
       return CONTINUE_MODE_T;
   if (SensorType == REFLECTIVE_SENSOR_TYPE)
       return BLINE_MODE;

return CONTINUE_MODE_T;
}

CHAR TransformSensorType(_eSensorMode SensorMode)
{
   if (SensorMode == GAP_MODE)
       return EDGE_SENSOR_TYPE;
   if (SensorMode == BLINE_MODE)
       return REFLECTIVE_SENSOR_TYPE;
   if (SensorMode == CONTINUE_MODE_T)
       return CONTINUOUS_SENSOR_TYPE;
   if (SensorMode == FEED_CONTINUE_MODE)
       return CONTINUOUS_SENSOR_TYPE;

return CONTINUOUS_SENSOR_TYPE;
}

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

return FALSE;
}

FLOAT TransformDensity(CHAR Heat)
{
   if (Heat < 0) Heat = 0;
   if (Heat > 30) Heat = 30;
   return (FLOAT)Heat / 30 * (DensityMax - DensityMin) + DensityMin;
}

INT TransformSpeed(CHAR Command)
{
FLOAT Speed = 3.0;

   if (Command == 'A') Speed = 1.0;
   if (Command == 'B') Speed = 1.5;
   if (Command == 'C') Speed = 2.0;
   if (Command == 'D') Speed = 2.5;
   if (Command == 'E') Speed = 3.0;
   if (Command == 'F') Speed = 3.5;
   if (Command == 'G') Speed = 4.0;
   if (Command == 'H') Speed = 4.5;
   if (Command == 'I') Speed = 5.0;
   if (Command == 'J') Speed = 5.5;
   if (Command == 'K') Speed = 6.0;
   if (Command == 'L') Speed = 6.5;
   if (Command == 'M') Speed = 7.0;
   if (Command == 'N') Speed = 7.5;
   if (Command == 'O') Speed = 8.0;
   if (Command == 'P') Speed = 8.5;
   if (Command == 'Q') Speed = 9.0;
   if (Command == 'R') Speed = 9.5;
   if (Command == 'S') Speed = 10.0;
   if (Command == 'T') Speed = 10.5;
   if (Command == 'U') Speed = 11.0;
   if (Command == 'V') Speed = 11.5;
   if (Command == 'W') Speed = 12.0;
   if (Command == 'X') Speed = 13.0;
   if (Command == 'Y') Speed = 14.0;
   if (Command == 'Z') Speed = 15.0;
   if (Command == 'a') Speed = 16.0;
   if (Command == 'b') Speed = 17.0;
   if (Command == 'c') Speed = 18.0;
   if (Command == 'd') Speed = 19.0;
   if (Command == 'e') Speed = 20.0;

return SpeedRange(Speed);
}

VOID TransformPrintConfig(_PrintCfg *pPrtCfg)
{
pPrtCfg->PrintOutMode = TransformPrintOut(CutterEquipped, PresentSensorEquipped);

// pPrtCfg->ShiftDisY = ;
// pPrtCfg->OffsetDis = ;

   pPrtCfg->CutterPieces = 1;
   pPrtCfg->Direction = 0;
   pPrtCfg->Mirror = 0;
   pPrtCfg->PrintKey = FALSE;
//   pPrtCfg->RibbonFlag = TransformRibbon(pDmxCfg->MediaType);
   pPrtCfg->Speed = TransformSpeed(pDmxCfg->PrintSpeed);
   pPrtCfg->fDensity = TransformDensity(pDmxCfg->Heat);
}

#endif

DplType.h //

#ifndef DPLTYPE_H

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

#define DPLTYPE_H

#include "XFileSys.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 SIGNAL_DISABLE               '0'
#define SIGNAL_STANDARD               '0'
#define SIGNAL_LOW_PULSE           '1'
#define SIGNAL_HIGH_PULSE           '2'
#define SIGNAL_ACTIVE_LOW           '3'
#define SIGNAL_ACTIVE_HIGH           '4'

#define MULTIPLE_LABEL 'M'
#define SINGLE_LABEL 'S'

#define EDGE_SENSOR_TYPE           'G'
#define CONTINUOUS_SENSOR_TYPE       'C'
#define REFLECTIVE_SENSOR_TYPE       'R'

#define METRIC_MODE 'M'
#define INCH_MODE 'I'

#define EQUIPPED_AUTO               'A'
#define EQUIPPED_ENABLE               'E'
#define EQUIPPED_DISABLE           'N'

#define DISPLAY_NOMINAL_ADJUST 64
#define NON_DISPLAY_NOMINAL_ADJUST 128

INT TransformHex(INT);
LONG TransformDot(LONG, CHAR);
INT TransformDegree(CHAR);
INT TransformLabFmtAttrib(CHAR);
INT TransformBarType(SHORT);
_ePutWay TransformPutType(SHORT);
_eFileDevice TransformFileDevice(CHAR);
_ePrintOutMode TransformPrintOut(BOOL, BOOL);
_eSensorMode TransformSensorMode(CHAR);
CHAR TransformSensorType(_eSensorMode);
BOOL TransformRibbon(CHAR);
FLOAT TransformDensity(CHAR);
INT TransformSpeed(CHAR);
VOID TransformPrintConfig(_PrintCfg *);

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

#endif

DplUtil.c

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

#define DPLUTIL_C

#include <ctype.h>

#include "Common.h"
#include "XCore.h"
#include "..\ParserUtil.h"
#include "DplCtrlCode.h"
#include "DplLabel.h"
#include "DplUtil.h"

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

#if defined(DPL)

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

VOID InitialDatamaxUtility(VOID)
{
EncodeDelimiter = '\0';
}

VOID ClearLabelStore(VOID)
{
LabelStoreLen = 0;
}

CHAR LabNextByte(VOID)
{
CHAR data;

data = DmxNextByte();

if (LabelStoreLen < LABEL_STORE_LENGTH)
LabelStore[LabelStoreLen++] = data;

return data;
}

VOID LabBackByte(CHAR data)
{
   if (LabelStoreLen)
       LabelStoreLen--;
   DmxBackByte(data);
}

BOOL LabIsTerminate(CHAR Terminate)
{
   if (Terminate == LabelParam.Terminate)
       return TRUE;
   if (Terminate == LF_CHAR && LabelParam.Terminate == CR_CHAR)
       return TRUE;

return FALSE;
}

VOID LabRemoveUntilTerm(VOID)
{
CHAR Data;

   while (1)
   {
       Data = LabNextByte();
       if (LabIsTerminate(Data))
           break;
   }
}

SHORT LabGetMul(VOID)
{
UCHAR Data;

Data = (UCHAR)LabNextByte();

   if (Data >= 'A' && Data <= 'O')
       Data = Data - 'A' + 10;
   else
       Data -= '0';

return (SHORT)Data;
}

BOOL LabGetHex(CHAR *pHex)
{
CHAR Data;
INT i;

   *pHex = 0;
   for (i = 0; i < 2; i++)
   {
       Data = toupper(LabNextByte());
       if (Data >= '0' && Data <= '9')
           *pHex = (*pHex << 4) + (Data - '0');
       else if (Data >= 'A' && Data <= 'F')
           *pHex = (*pHex << 4) + (Data - 'A') + 10;
       else
           return FALSE;
   }
   return TRUE;
}

BOOL LabGetNumTerm(LONG *pNum, INT Limit)
{
   LONG Number = 0;
   UINT Length = 0;
   CHAR Data;

   while (1)
   {
       Data = LabNextByte();
       if (LabIsTerminate(Data))
           break;
       if (!isdigit(Data) || ++Length > Limit)
       {
           LabBackByte(Data);
           return FALSE;
       }
       Number = Number * 10 + (Data - '0');
   }
   if (Length)
       *pNum = Number;
   return TRUE;
}

INT LabGetNumLen(LONG *pNum, INT Limit)
{
   LONG Number = 0;
   UINT Length = 0;
   CHAR Data;

   while (Length < Limit)
   {
       Data = LabNextByte();
       if (!isdigit(Data))
       {
           LabBackByte(Data);
           break;
       }
       Number = Number * 10 + (Data - '0');
       Length += 1;
   }
   *pNum = Number;
   return Length;
}

INT LabGetStrTerm(CHAR *pStr, INT Limit)
{
   BOOL Encode = FALSE;
   BOOL Half = FALSE;
   UINT Length = 0;
   CHAR Data;

   while (Length < Limit - 1)
   {
       Data = LabNextByte();
       if (LabIsTerminate(Data))
           break;
       if (Data == EncodeDelimiter && EncodeDelimiter)
       {
           Encode = !Encode;
           Half = FALSE;
       }
       else if (Encode)
       {
           if (Half)
           {
               *(pStr + Length) |= TransformHex(Data);
               Length += 1;
           }
           else
               *(pStr + Length) = (TransformHex(Data) << 4);
           Half = !Half;
       }
       else
       {
           *(pStr + Length) = Data;
           Length += 1;
       }
   }
   *(pStr + Length) = '\0';
   return Length;
}

INT LabGetStrLen(CHAR *pStr, INT Limit)
{
   BOOL Encode = FALSE;
   BOOL Half = FALSE;
   UINT Length = 0;
   CHAR Data;

   while (Length < Limit)
   {
       Data = LabNextByte();
       if (Data == EncodeDelimiter && EncodeDelimiter)
       {
           Encode = !Encode;
           Half = FALSE;
       }
       else if (Encode)
       {
           if (Half)
           {
               *(pStr + Length) |= TransformHex(Data);
               Length += 1;
           }
           else
               *(pStr + Length) = (TransformHex(Data) << 4);
           Half = !Half;
       }
       else
       {
           *(pStr + Length) = Data;
           Length += 1;
       }
   }
   *(pStr + Length) = '\0';
   return Length;
}

CHAR DmxNextByte(VOID)
{
return NextByte();
}

VOID DmxBackByte(CHAR data)
{
BackByte(data);
}

BOOL DmxIsTerminate(CHAR Terminate)
{
   if (Terminate == CtrlCode.CR)
       return TRUE;
   if (Terminate == LF_CHAR && CtrlCode.CR == CR_CHAR)
       return TRUE;

return FALSE;
}

VOID DmxRemoveInvalidByte(VOID)
{
CHAR getter[16];
CHAR Data;

AttentionGetter(getter);

   Data = DmxNextByte();
   while (!DmxIsTerminate(Data) && !CheckChar(Data, getter))
       Data = DmxNextByte();

if (CheckChar(Data, getter))
DmxBackByte(Data);
}

BOOL DmxGetCfgNum(LONG *pNum, INT Limit)
{
   BOOL Status = TRUE;
   LONG Number = 0;
   UINT Length = 0;
   CHAR Data;

   while (1)
   {
       Data = DmxNextByte();
       if (!isalnum(Data))
       {
           DmxBackByte(Data);
           break;
       }
       if (!isdigit(Data) || Length >= Limit)
           Status = FALSE;
       if (Status)
           Number = Number * 10 + (Data - '0');
       Length += 1;
   }
   *pNum = Number;
   return Status;
}

INT DmxGetCfgChr(CHAR *pBuf, INT Limit)
{
UINT Length = 0;
CHAR Data;

   while (1)
   {
       Data = DmxNextByte();
       if (!isalnum(Data))
       {
           DmxBackByte(Data);
           break;
       }
       if (Length < Limit)
           *(pBuf + Length) = Data;
       Length += 1;
   }
   return Length;
}

BOOL DmxGetNetAddr(ULONG *pAddr)
{
   UINT Length = 0;
   CHAR Address[16];
   CHAR Data;

*pAddr = 0;

   while (1)
   {
       Data = DmxNextByte();
       if (!isalnum(Data) && Data != '.')
       {
           DmxBackByte(Data);
           break;
       }
       if (Length < sizeof(Address) - 1)
           Address[Length] = Data;
       Length += 1;
   }
   if (Length >= sizeof(Address))
       return FALSE;

Address[Length] = '\0';

#if defined(NUTNET)
if ((*pAddr = inet_addr(Address)) == (ULONG)-1)
return FALSE;
#endif

return TRUE;
}

INT DmxGetNumber(LONG *pNum, INT Limit)
{
   LONG Number = 0;
   UINT Length = 0;
   CHAR Data;

   while (Length < Limit)
   {
       Data = DmxNextByte();
       if (!isdigit(Data))
       {
           DmxBackByte(Data);
           break;
       }
       Number = Number * 10 + (Data - '0');
       Length += 1;
   }
   *pNum = Number;
   return Length;
}

INT DmxGetString(CHAR *pStr, INT Limit)
{
   BOOL Encode = FALSE;
   BOOL Half = FALSE;
   UINT Length = 0;
   CHAR Data;

   while (Length < Limit - 1)
   {
       Data = DmxNextByte();
       if (DmxIsTerminate(Data))
           break;
       if (Data == EncodeDelimiter && EncodeDelimiter)
       {
           Encode = !Encode;
           Half = FALSE;
       }
       else if (Encode)
       {
           if (Half)
           {
               *(pStr + Length) |= TransformHex(Data);
               Length += 1;
           }
           else
               *(pStr + Length) = (TransformHex(Data) << 4);
           Half = !Half;
       }
       else
       {
           *(pStr + Length) = Data;
           Length += 1;
       }
   }
   *(pStr + Length) = '\0';
   return Length;
}

BOOL DmxGetAlpha(CHAR *pBuf, INT Length)
{
CHAR Data;

   while (Length--)
   {
       Data = DmxNextByte();
       if (!isalnum(Data))
       {
           DmxBackByte(Data);
           return FALSE;
       }
       *pBuf++ = Data;
   }
   return TRUE;
}

#endif

DplUtil.h //

#ifndef DPLUTIL_H

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

#define DPLUTIL_H

#include "DplType.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 LABEL_STORE_LENGTH 0x10000

#ifdef DPLUTIL_C
#define EXTERN
#else
#define EXTERN extern
#endif

EXTERN CHAR LabelStore[LABEL_STORE_LENGTH];
EXTERN INT LabelStoreLen;

EXTERN CHAR EncodeDelimiter;

VOID InitialDatamaxUtility(VOID);

VOID ClearLabelStore(VOID);
CHAR LabNextByte(VOID);
VOID LabBackByte(CHAR);
BOOL LabIsTerminate(CHAR);
VOID LabRemoveUntilTerm(VOID);

SHORT LabGetMul(VOID);
BOOL LabGetHex(CHAR *);
BOOL LabGetNumTerm(LONG *, INT);
INT LabGetNumLen(LONG *, INT);
INT LabGetStrTerm(CHAR *, INT);
INT LabGetStrLen(CHAR *, INT);

CHAR DmxNextByte(VOID);
VOID DmxBackByte(CHAR);
BOOL DmxIsTerminate(CHAR);
VOID DmxRemoveInvalidByte(VOID);

BOOL DmxGetCfgNum(LONG *, INT);
INT DmxGetCfgChr(CHAR *, INT);
BOOL DmxGetNetAddr(ULONG *);
INT DmxGetNumber(LONG *, INT);
INT DmxGetString(CHAR *, INT);
BOOL DmxGetAlpha(CHAR *, INT);

#undef EXTERN

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

#endif