T168_Backup\T168_111\appl\Graphic 文件：Line.c及PCX.c

最新推荐文章于 2024-07-20 19:39:28 发布

qq_33772147

最新推荐文章于 2024-07-20 19:39:28 发布

阅读量922

点赞数 18

文章标签： c语言开发语言

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

版权

Line.c 、、、、//

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

#define LINE_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>

/******************************************************************************
* *
* 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 "XGraphic.h"
#include "Line.h"

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

/* None */

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

typedef struct
{
   INT Width;
   INT Height;
   CONST BYTE *pPattern;
}_FillPattern;

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

/* None */

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

STATIC CONST BYTE PatternWhite[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
STATIC CONST BYTE PatternBlack[] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
STATIC CONST BYTE PatternBlack6[] = { 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
STATIC CONST BYTE PatternBlack12[] = { 0x03, 0x03, 0x00, 0x00, 0x30, 0x30, 0x00, 0x00 };
STATIC CONST BYTE PatternBlack25[] = { 0x03, 0x03, 0x30, 0x30, 0x03, 0x03, 0x30, 0x30 };
STATIC CONST BYTE PatternBlack38[] = { 0x03, 0x03, 0xCC, 0xCC, 0x30, 0x30, 0xCC, 0xCC };
STATIC CONST BYTE PatternBlack50[] = { 0x33, 0x33, 0xCC, 0xCC, 0x33, 0x33, 0xCC, 0xCC };
STATIC CONST BYTE PatternRight[] = { 0x3E, 0x7C, 0xF8, 0xF1, 0xE3, 0xC7, 0x8F, 0x1F };
STATIC CONST BYTE PatternLeft[] = { 0x1F, 0x8F, 0xC7, 0xE3, 0xF1, 0xF8, 0x7C, 0x3E };
STATIC CONST BYTE PatternGrid[] = { 0xFF, 0xFF, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03 };
STATIC CONST BYTE PatternDiamond[] = { 0x18, 0x3C, 0x7E, 0xFF, 0xFF, 0x7E, 0x3C, 0x18 };
STATIC CONST BYTE PatternCircle[] = { 0x07, 0x80, 0x1F, 0xE0, 0x3F, 0xF0, 0x7F, 0xF8,
0x7F, 0xF8, 0xFF, 0xFC, 0xFF, 0xFC, 0xFF, 0xFC,
0xFF, 0xFC, 0x7F, 0xF8, 0x7F, 0xF8, 0x3F, 0xF0,
0x1F, 0xE0, 0x07, 0x80, 0x00, 0x00, 0x00, 0x00 };

STATIC CONST _FillPattern sFillPattern[] =
{
   {1, 8, PatternWhite},
   {1, 8, PatternBlack},
   {1, 8, PatternBlack6},
   {1, 8, PatternBlack12},
   {1, 8, PatternBlack25},
   {1, 8, PatternBlack38},
   {1, 8, PatternBlack50},
   {1, 8, PatternDiamond},
   {2, 16, PatternCircle},
   {1, 8, PatternRight},
   {1, 8, PatternLeft},
   {1, 8, PatternGrid},
};

STATIC CONST LONG SinTab[1024] =
{
   0x00010000, 0x0000FFFF, 0x0000FFFF, 0x0000FFFF, 0x0000FFFF, 0x0000FFFF, 0x0000FFFE, 0x0000FFFE,
   0x0000FFFD, 0x0000FFFD, 0x0000FFFC, 0x0000FFFC, 0x0000FFFB, 0x0000FFFA, 0x0000FFF9, 0x0000FFF8,
   0x0000FFF7, 0x0000FFF6, 0x0000FFF5, 0x0000FFF4, 0x0000FFF3, 0x0000FFF2, 0x0000FFF0, 0x0000FFEF,
   0x0000FFED, 0x0000FFEC, 0x0000FFEA, 0x0000FFE9, 0x0000FFE7, 0x0000FFE5, 0x0000FFE3, 0x0000FFE1,
   0x0000FFDF, 0x0000FFDD, 0x0000FFDB, 0x0000FFD9, 0x0000FFD7, 0x0000FFD5, 0x0000FFD2, 0x0000FFD0,
   0x0000FFCD, 0x0000FFCB, 0x0000FFC8, 0x0000FFC6, 0x0000FFC3, 0x0000FFC0, 0x0000FFBD, 0x0000FFBA,
   0x0000FFB7, 0x0000FFB4, 0x0000FFB1, 0x0000FFAE, 0x0000FFAB, 0x0000FFA8, 0x0000FFA4, 0x0000FFA1,
   0x0000FF9D, 0x0000FF9A, 0x0000FF96, 0x0000FF93, 0x0000FF8F, 0x0000FF8B, 0x0000FF87, 0x0000FF83,
   0x0000FF7F, 0x0000FF7B, 0x0000FF77, 0x0000FF73, 0x0000FF6F, 0x0000FF6B, 0x0000FF66, 0x0000FF62,
   0x0000FF5D, 0x0000FF59, 0x0000FF54, 0x0000FF4F, 0x0000FF4B, 0x0000FF46, 0x0000FF41, 0x0000FF3C,
   0x0000FF37, 0x0000FF32, 0x0000FF2D, 0x0000FF28, 0x0000FF23, 0x0000FF1D, 0x0000FF18, 0x0000FF13,
   0x0000FF0D, 0x0000FF07, 0x0000FF02, 0x0000FEFC, 0x0000FEF6, 0x0000FEF1, 0x0000FEEB, 0x0000FEE5,
   0x0000FEDF, 0x0000FED9, 0x0000FED3, 0x0000FECC, 0x0000FEC6, 0x0000FEC0, 0x0000FEBA, 0x0000FEB3,
   0x0000FEAD, 0x0000FEA6, 0x0000FE9F, 0x0000FE99, 0x0000FE92, 0x0000FE8B, 0x0000FE84, 0x0000FE7D,
   0x0000FE76, 0x0000FE6F, 0x0000FE68, 0x0000FE61, 0x0000FE5A, 0x0000FE52, 0x0000FE4B, 0x0000FE43,
   0x0000FE3C, 0x0000FE34, 0x0000FE2D, 0x0000FE25, 0x0000FE1D, 0x0000FE15, 0x0000FE0D, 0x0000FE06,
   0x0000FDFD, 0x0000FDF5, 0x0000FDED, 0x0000FDE5, 0x0000FDDD, 0x0000FDD4, 0x0000FDCC, 0x0000FDC3,
   0x0000FDBB, 0x0000FDB2, 0x0000FDAA, 0x0000FDA1, 0x0000FD98, 0x0000FD8F, 0x0000FD86, 0x0000FD7D,
   0x0000FD74, 0x0000FD6B, 0x0000FD62, 0x0000FD59, 0x0000FD4F, 0x0000FD46, 0x0000FD3D, 0x0000FD33,
   0x0000FD29, 0x0000FD20, 0x0000FD16, 0x0000FD0C, 0x0000FD03, 0x0000FCF9, 0x0000FCEF, 0x0000FCE5,
   0x0000FCDB, 0x0000FCD0, 0x0000FCC6, 0x0000FCBC, 0x0000FCB2, 0x0000FCA7, 0x0000FC9D, 0x0000FC92,
   0x0000FC87, 0x0000FC7D, 0x0000FC72, 0x0000FC67, 0x0000FC5C, 0x0000FC51, 0x0000FC46, 0x0000FC3B,
   0x0000FC30, 0x0000FC25, 0x0000FC1A, 0x0000FC0E, 0x0000FC03, 0x0000FBF8, 0x0000FBEC, 0x0000FBE0,
   0x0000FBD5, 0x0000FBC9, 0x0000FBBD, 0x0000FBB1, 0x0000FBA6, 0x0000FB9A, 0x0000FB8D, 0x0000FB81,
   0x0000FB75, 0x0000FB69, 0x0000FB5D, 0x0000FB50, 0x0000FB44, 0x0000FB37, 0x0000FB2B, 0x0000FB1E,
   0x0000FB11, 0x0000FB05, 0x0000FAF8, 0x0000FAEB, 0x0000FADE, 0x0000FAD1, 0x0000FAC4, 0x0000FAB7,
   0x0000FAA9, 0x0000FA9C, 0x0000FA8F, 0x0000FA81, 0x0000FA74, 0x0000FA66, 0x0000FA58, 0x0000FA4B,
   0x0000FA3D, 0x0000FA2F, 0x0000FA21, 0x0000FA13, 0x0000FA05, 0x0000F9F7, 0x0000F9E9, 0x0000F9DB,
   0x0000F9CC, 0x0000F9BE, 0x0000F9AF, 0x0000F9A1, 0x0000F992, 0x0000F984, 0x0000F975, 0x0000F966,
   0x0000F957, 0x0000F948, 0x0000F939, 0x0000F92A, 0x0000F91B, 0x0000F90C, 0x0000F8FD, 0x0000F8ED,
   0x0000F8DE, 0x0000F8CF, 0x0000F8BF, 0x0000F8AF, 0x0000F8A0, 0x0000F890, 0x0000F880, 0x0000F870,
   0x0000F860, 0x0000F850, 0x0000F840, 0x0000F830, 0x0000F820, 0x0000F810, 0x0000F7FF, 0x0000F7EF,
   0x0000F7DE, 0x0000F7CE, 0x0000F7BD, 0x0000F7AD, 0x0000F79C, 0x0000F78B, 0x0000F77A, 0x0000F769,
   0x0000F758, 0x0000F747, 0x0000F736, 0x0000F725, 0x0000F713, 0x0000F702, 0x0000F6F0, 0x0000F6DF,
   0x0000F6CD, 0x0000F6BC, 0x0000F6AA, 0x0000F698, 0x0000F686, 0x0000F674, 0x0000F662, 0x0000F650,
   0x0000F63E, 0x0000F62C, 0x0000F619, 0x0000F607, 0x0000F5F5, 0x0000F5E2, 0x0000F5CF, 0x0000F5BD,
   0x0000F5AA, 0x0000F597, 0x0000F584, 0x0000F572, 0x0000F55F, 0x0000F54B, 0x0000F538, 0x0000F525,
   0x0000F512, 0x0000F4FE, 0x0000F4EB, 0x0000F4D7, 0x0000F4C4, 0x0000F4B0, 0x0000F49D, 0x0000F489,
   0x0000F475, 0x0000F461, 0x0000F44D, 0x0000F439, 0x0000F425, 0x0000F411, 0x0000F3FC, 0x0000F3E8,
   0x0000F3D3, 0x0000F3BF, 0x0000F3AA, 0x0000F396, 0x0000F381, 0x0000F36C, 0x0000F357, 0x0000F342,
   0x0000F32D, 0x0000F318, 0x0000F303, 0x0000F2EE, 0x0000F2D9, 0x0000F2C3, 0x0000F2AE, 0x0000F298,
   0x0000F283, 0x0000F26D, 0x0000F257, 0x0000F241, 0x0000F22B, 0x0000F215, 0x0000F1FF, 0x0000F1E9,
   0x0000F1D3, 0x0000F1BD, 0x0000F1A6, 0x0000F190, 0x0000F17A, 0x0000F163, 0x0000F14C, 0x0000F136,
   0x0000F11F, 0x0000F108, 0x0000F0F1, 0x0000F0DA, 0x0000F0C3, 0x0000F0AC, 0x0000F095, 0x0000F07D,
   0x0000F066, 0x0000F04E, 0x0000F037, 0x0000F01F, 0x0000F007, 0x0000EFF0, 0x0000EFD8, 0x0000EFC0,
   0x0000EFA8, 0x0000EF90, 0x0000EF78, 0x0000EF60, 0x0000EF47, 0x0000EF2F, 0x0000EF16, 0x0000EEFE,
   0x0000EEE5, 0x0000EECD, 0x0000EEB4, 0x0000EE9B, 0x0000EE82, 0x0000EE69, 0x0000EE50, 0x0000EE37,
   0x0000EE1E, 0x0000EE04, 0x0000EDEB, 0x0000EDD1, 0x0000EDB8, 0x0000ED9E, 0x0000ED85, 0x0000ED6B,
   0x0000ED51, 0x0000ED37, 0x0000ED1D, 0x0000ED03, 0x0000ECE9, 0x0000ECCF, 0x0000ECB4, 0x0000EC9A,
   0x0000EC7F, 0x0000EC65, 0x0000EC4A, 0x0000EC2F, 0x0000EC15, 0x0000EBFA, 0x0000EBDF, 0x0000EBC4,
   0x0000EBA9, 0x0000EB8D, 0x0000EB72, 0x0000EB57, 0x0000EB3B, 0x0000EB20, 0x0000EB04, 0x0000EAE9,
   0x0000EACD, 0x0000EAB1, 0x0000EA95, 0x0000EA79, 0x0000EA5D, 0x0000EA41, 0x0000EA25, 0x0000EA08,
   0x0000E9EC, 0x0000E9CF, 0x0000E9B3, 0x0000E996, 0x0000E979, 0x0000E95D, 0x0000E940, 0x0000E923,
   0x0000E906, 0x0000E8E8, 0x0000E8CB, 0x0000E8AE, 0x0000E890, 0x0000E873, 0x0000E855, 0x0000E838,
   0x0000E81A, 0x0000E7FC, 0x0000E7DE, 0x0000E7C0, 0x0000E7A2, 0x0000E784, 0x0000E766, 0x0000E747,
   0x0000E729, 0x0000E70B, 0x0000E6EC, 0x0000E6CD, 0x0000E6AF, 0x0000E690, 0x0000E671, 0x0000E652,
   0x0000E633, 0x0000E613, 0x0000E5F4, 0x0000E5D5, 0x0000E5B5, 0x0000E596, 0x0000E576, 0x0000E557,
   0x0000E537, 0x0000E517, 0x0000E4F7, 0x0000E4D7, 0x0000E4B7, 0x0000E497, 0x0000E476, 0x0000E456,
   0x0000E435, 0x0000E415, 0x0000E3F4, 0x0000E3D3, 0x0000E3B3, 0x0000E392, 0x0000E371, 0x0000E34F,
   0x0000E32E, 0x0000E30D, 0x0000E2EC, 0x0000E2CA, 0x0000E2A9, 0x0000E287, 0x0000E265, 0x0000E243,
   0x0000E221, 0x0000E1FF, 0x0000E1DD, 0x0000E1BB, 0x0000E199, 0x0000E177, 0x0000E154, 0x0000E132,
   0x0000E10F, 0x0000E0EC, 0x0000E0C9, 0x0000E0A6, 0x0000E083, 0x0000E060, 0x0000E03D, 0x0000E01A,
   0x0000DFF6, 0x0000DFD3, 0x0000DFAF, 0x0000DF8C, 0x0000DF68, 0x0000DF44, 0x0000DF20, 0x0000DEFC,
   0x0000DED8, 0x0000DEB4, 0x0000DE8F, 0x0000DE6B, 0x0000DE46, 0x0000DE22, 0x0000DDFD, 0x0000DDD8,
   0x0000DDB3, 0x0000DD8E, 0x0000DD69, 0x0000DD44, 0x0000DD1F, 0x0000DCF9, 0x0000DCD4, 0x0000DCAE,
   0x0000DC89, 0x0000DC63, 0x0000DC3D, 0x0000DC17, 0x0000DBF1, 0x0000DBCB, 0x0000DBA5, 0x0000DB7E,
   0x0000DB58, 0x0000DB31, 0x0000DB0A, 0x0000DAE4, 0x0000DABD, 0x0000DA96, 0x0000DA6F, 0x0000DA48,
   0x0000DA20, 0x0000D9F9, 0x0000D9D2, 0x0000D9AA, 0x0000D982, 0x0000D95B, 0x0000D933, 0x0000D90B,
   0x0000D8E3, 0x0000D8BA, 0x0000D892, 0x0000D86A, 0x0000D841, 0x0000D819, 0x0000D7F0, 0x0000D7C7,
   0x0000D79E, 0x0000D775, 0x0000D74C, 0x0000D723, 0x0000D6FA, 0x0000D6D0, 0x0000D6A7, 0x0000D67D,
   0x0000D653, 0x0000D629, 0x0000D5FF, 0x0000D5D5, 0x0000D5AB, 0x0000D581, 0x0000D556, 0x0000D52C,
   0x0000D501, 0x0000D4D7, 0x0000D4AC, 0x0000D481, 0x0000D456, 0x0000D42B, 0x0000D3FF, 0x0000D3D4,
   0x0000D3A8, 0x0000D37D, 0x0000D351, 0x0000D325, 0x0000D2F9, 0x0000D2CD, 0x0000D2A1, 0x0000D275,
   0x0000D249, 0x0000D21C, 0x0000D1EF, 0x0000D1C3, 0x0000D196, 0x0000D169, 0x0000D13C, 0x0000D10F,
   0x0000D0E1, 0x0000D0B4, 0x0000D087, 0x0000D059, 0x0000D02B, 0x0000CFFD, 0x0000CFCF, 0x0000CFA1,
   0x0000CF73, 0x0000CF45, 0x0000CF16, 0x0000CEE8, 0x0000CEB9, 0x0000CE8A, 0x0000CE5B, 0x0000CE2C,
   0x0000CDFD, 0x0000CDCE, 0x0000CD9E, 0x0000CD6F, 0x0000CD3F, 0x0000CD0F, 0x0000CCDF, 0x0000CCAF,
   0x0000CC7F, 0x0000CC4F, 0x0000CC1F, 0x0000CBEE, 0x0000CBBE, 0x0000CB8D, 0x0000CB5C, 0x0000CB2B,
   0x0000CAFA, 0x0000CAC9, 0x0000CA97, 0x0000CA66, 0x0000CA34, 0x0000CA02, 0x0000C9D0, 0x0000C99E,
   0x0000C96C, 0x0000C93A, 0x0000C908, 0x0000C8D5, 0x0000C8A2, 0x0000C870, 0x0000C83D, 0x0000C80A,
   0x0000C7D7, 0x0000C7A3, 0x0000C770, 0x0000C73C, 0x0000C709, 0x0000C6D5, 0x0000C6A1, 0x0000C66D,
   0x0000C638, 0x0000C604, 0x0000C5CF, 0x0000C59B, 0x0000C566, 0x0000C531, 0x0000C4FC, 0x0000C4C7,
   0x0000C492, 0x0000C45C, 0x0000C427, 0x0000C3F1, 0x0000C3BB, 0x0000C385, 0x0000C34F, 0x0000C318,
   0x0000C2E2, 0x0000C2AB, 0x0000C275, 0x0000C23E, 0x0000C207, 0x0000C1D0, 0x0000C198, 0x0000C161,
   0x0000C129, 0x0000C0F2, 0x0000C0BA, 0x0000C082, 0x0000C049, 0x0000C011, 0x0000BFD9, 0x0000BFA0,
   0x0000BF67, 0x0000BF2E, 0x0000BEF5, 0x0000BEBC, 0x0000BE83, 0x0000BE49, 0x0000BE0F, 0x0000BDD6,
   0x0000BD9C, 0x0000BD62, 0x0000BD27, 0x0000BCED, 0x0000BCB2, 0x0000BC77, 0x0000BC3D, 0x0000BC01,
   0x0000BBC6, 0x0000BB8B, 0x0000BB4F, 0x0000BB14, 0x0000BAD8, 0x0000BA9C, 0x0000BA60, 0x0000BA23,
   0x0000B9E7, 0x0000B9AA, 0x0000B96D, 0x0000B930, 0x0000B8F3, 0x0000B8B6, 0x0000B878, 0x0000B83B,
   0x0000B7FD, 0x0000B7BF, 0x0000B781, 0x0000B742, 0x0000B704, 0x0000B6C5, 0x0000B686, 0x0000B647,
   0x0000B608, 0x0000B5C9, 0x0000B589, 0x0000B549, 0x0000B509, 0x0000B4C9, 0x0000B489, 0x0000B449,
   0x0000B408, 0x0000B3C7, 0x0000B386, 0x0000B345, 0x0000B304, 0x0000B2C2, 0x0000B281, 0x0000B23F,
   0x0000B1FD, 0x0000B1BA, 0x0000B178, 0x0000B135, 0x0000B0F2, 0x0000B0AF, 0x0000B06C, 0x0000B029,
   0x0000AFE5, 0x0000AFA2, 0x0000AF5E, 0x0000AF19, 0x0000AED5, 0x0000AE91, 0x0000AE4C, 0x0000AE07,
   0x0000ADC2, 0x0000AD7C, 0x0000AD37, 0x0000ACF1, 0x0000ACAB, 0x0000AC65, 0x0000AC1F, 0x0000ABD8,
   0x0000AB91, 0x0000AB4A, 0x0000AB03, 0x0000AABC, 0x0000AA74, 0x0000AA2C, 0x0000A9E4, 0x0000A99C,
   0x0000A953, 0x0000A90B, 0x0000A8C2, 0x0000A879, 0x0000A82F, 0x0000A7E6, 0x0000A79C, 0x0000A752,
   0x0000A708, 0x0000A6BD, 0x0000A673, 0x0000A628, 0x0000A5DD, 0x0000A591, 0x0000A546, 0x0000A4FA,
   0x0000A4AE, 0x0000A462, 0x0000A415, 0x0000A3C8, 0x0000A37B, 0x0000A32E, 0x0000A2E1, 0x0000A293,
   0x0000A245, 0x0000A1F7, 0x0000A1A8, 0x0000A15A, 0x0000A10B, 0x0000A0BB, 0x0000A06C, 0x0000A01C,
   0x00009FCC, 0x00009F7C, 0x00009F2C, 0x00009EDB, 0x00009E8A, 0x00009E39, 0x00009DE7, 0x00009D95,
   0x00009D43, 0x00009CF1, 0x00009C9E, 0x00009C4B, 0x00009BF8, 0x00009BA5, 0x00009B51, 0x00009AFD,
   0x00009AA9, 0x00009A54, 0x000099FF, 0x000099AA, 0x00009955, 0x000098FF, 0x000098A9, 0x00009853,
   0x000097FC, 0x000097A5, 0x0000974E, 0x000096F7, 0x0000969F, 0x00009647, 0x000095EE, 0x00009595,
   0x0000953C, 0x000094E3, 0x00009489, 0x0000942F, 0x000093D5, 0x0000937A, 0x0000931F, 0x000092C4,
   0x00009269, 0x0000920D, 0x000091B0, 0x00009154, 0x000090F7, 0x00009099, 0x0000903C, 0x00008FDE,
   0x00008F7F, 0x00008F21, 0x00008EC1, 0x00008E62, 0x00008E02, 0x00008DA2, 0x00008D41, 0x00008CE1,
   0x00008C7F, 0x00008C1E, 0x00008BBC, 0x00008B59, 0x00008AF6, 0x00008A93, 0x00008A2F, 0x000089CB,
   0x00008967, 0x00008902, 0x0000889D, 0x00008837, 0x000087D1, 0x0000876B, 0x00008704, 0x0000869D,
   0x00008635, 0x000085CD, 0x00008564, 0x000084FB, 0x00008492, 0x00008428, 0x000083BD, 0x00008352,
   0x000082E7, 0x0000827B, 0x0000820F, 0x000081A2, 0x00008135, 0x000080C7, 0x00008059, 0x00007FEA,
   0x00007F7B, 0x00007F0C, 0x00007E9B, 0x00007E2B, 0x00007DB9, 0x00007D48, 0x00007CD5, 0x00007C62,
   0x00007BEF, 0x00007B7B, 0x00007B07, 0x00007A91, 0x00007A1C, 0x000079A6, 0x0000792F, 0x000078B7,
   0x0000783F, 0x000077C7, 0x0000774E, 0x000076D4, 0x00007659, 0x000075DE, 0x00007563, 0x000074E6,
   0x00007469, 0x000073EC, 0x0000736D, 0x000072EE, 0x0000726E, 0x000071EE, 0x0000716D, 0x000070EB,
   0x00007068, 0x00006FE5, 0x00006F61, 0x00006EDC, 0x00006E57, 0x00006DD0, 0x00006D49, 0x00006CC1,
   0x00006C38, 0x00006BAF, 0x00006B24, 0x00006A99, 0x00006A0D, 0x00006980, 0x000068F2, 0x00006863,
   0x000067D3, 0x00006742, 0x000066B1, 0x0000661E, 0x0000658B, 0x000064F6, 0x00006460, 0x000063CA,
   0x00006332, 0x00006299, 0x000061FF, 0x00006164, 0x000060C8, 0x0000602B, 0x00005F8C, 0x00005EED,
   0x00005E4C, 0x00005DA9, 0x00005D06, 0x00005C61, 0x00005BBB, 0x00005B14, 0x00005A6B, 0x000059C1,
   0x00005915, 0x00005868, 0x000057B9, 0x00005709, 0x00005657, 0x000055A4, 0x000054EF, 0x00005438,
   0x0000537F, 0x000052C5, 0x00005208, 0x0000514A, 0x0000508A, 0x00004FC8, 0x00004F04, 0x00004E3E,
   0x00004D75, 0x00004CAA, 0x00004BDD, 0x00004B0E, 0x00004A3C, 0x00004967, 0x00004890, 0x000047B6,
   0x000046DA, 0x000045FA, 0x00004517, 0x00004431, 0x00004348, 0x0000425B, 0x0000416B, 0x00004077,
   0x00003F7F, 0x00003E83, 0x00003D83, 0x00003C7E, 0x00003B74, 0x00003A66, 0x00003952, 0x00003838,
   0x00003719, 0x000035F3, 0x000034C7, 0x00003394, 0x00003259, 0x00003116, 0x00002FC9, 0x00002E74,
   0x00002D13, 0x00002BA8, 0x00002A2F, 0x000028A9, 0x00002713, 0x0000256C, 0x000023B0, 0x000021DD,
   0x00001FEF, 0x00001DE1, 0x00001BAC, 0x00001944, 0x0000169A, 0x00001394, 0x00000FFD, 0x00000B4F,
};

/******************************************************************************
* *
* 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.
*
******************************************************************************/
VOID DrawBar(_BarAttr *pBarAttr)
{
   _BarAttr sBarAttr = *pBarAttr;
   _ImgBuf *pImgBuf = sBarAttr.psImageBuffer;
   BYTE SetLeft, SetRight, SetData;
   BYTE ClrLeft, ClrRight, ClrData;
   BYTE *pImage, *pLine;
   INT BitLeft, BitRight;
   INT ImgWidthByte, BarWidth, BarWidthByte;
   INT i, j;

if (sBarAttr.sCoord.iX < 0 || sBarAttr.sCoord.iY < 0)
return;

//#if defined(TSPL_VER_1)
   if (sBarAttr.iWidth > pImgBuf->iWidth - sBarAttr.sCoord.iX)
       sBarAttr.iWidth = pImgBuf->iWidth - sBarAttr.sCoord.iX;
   if (sBarAttr.iHeight > pImgBuf->iHeight - sBarAttr.sCoord.iY)
       sBarAttr.iHeight = pImgBuf->iHeight - sBarAttr.sCoord.iY;
//#else
//   if ((sBarAttr.sCoord.iX + sBarAttr.iWidth > pImgBuf->iWidth) ||
//       (sBarAttr.sCoord.iY + sBarAttr.iHeight > pImgBuf->iHeight))
//       return;
//#endif

if (sBarAttr.iWidth <= 0 || sBarAttr.iHeight <= 0)
return;

if (sBarAttr.iType != DRAW_ERASE)
ModifyImgSection(sBarAttr.sCoord.iY, sBarAttr.iHeight, pImgBuf);

   pImage = pImgBuf->pBuffer;
   ImgWidthByte = pImgBuf->iWidth / 8;
   pImage += ImgWidthByte * sBarAttr.sCoord.iY + sBarAttr.sCoord.iX / 8;

BitLeft = 8 - (sBarAttr.sCoord.iX % 8);
BitRight = ((sBarAttr.sCoord.iX + sBarAttr.iWidth - 1) % 8) + 1;

BarWidth = sBarAttr.iWidth;
BarWidthByte = 0;

   if (BitLeft != 8)
   {
       if (BarWidth >= BitLeft)
       {
           BarWidth -= BitLeft;
           BarWidthByte++;
       }
   }
   if (BitRight != 8)
   {
       if (BarWidth >= BitRight)
       {
           BarWidth -= BitRight;
           BarWidthByte++;
       }
   }
   BarWidthByte += BarWidth / 8;

if (BarWidthByte == 0)
BarWidthByte = 1;

   SetLeft = 0xFF >> (8 - BitLeft);
   SetRight = 0xFF << (8 - BitRight);
   SetData = SetLeft & SetRight;

   ClrLeft = 0xFF << BitLeft;
   ClrRight = 0xFF >> BitRight;
   ClrData = ClrLeft | ClrRight;

   if (sBarAttr.iType == DRAW_BAR)
   {
       if (BarWidthByte == 1)
       {
           for (i = 0; i < sBarAttr.iHeight; i++)
           {
               *pImage |= SetData;
               pImage += ImgWidthByte;
           }
       }
       else
       {
           for (i = 0; i < sBarAttr.iHeight; i++)
           {
               pLine = pImage;
               *pLine++ |= SetLeft;
               for (j = 1; j < (BarWidthByte - 1); j++)
                   *pLine++ = 0xFF;
               *pLine++ |= SetRight;
               pImage += ImgWidthByte;
           }
   }
   }
   else if (sBarAttr.iType == DRAW_ERASE)
   {
       if (BarWidthByte == 1)
       {
           for (i = 0; i < sBarAttr.iHeight; i++)
           {
               *pImage &= ClrData;
               pImage += ImgWidthByte;
           }
       }
       else
       {
           for (i = 0; i < sBarAttr.iHeight; i++)
           {
               pLine = pImage;
               *pLine++ &= ClrLeft;
               for (j = 1; j < (BarWidthByte - 1); j++)
                   *pLine++ = 0x00;
               *pLine++ &= ClrRight;
               pImage += ImgWidthByte;
           }
       }
   }
   else if (sBarAttr.iType == DRAW_REVERSE)
   {
       if (BarWidthByte == 1)
       {
           for (i = 0; i < sBarAttr.iHeight; i++)
           {
               *pImage ^= SetData;
               pImage += ImgWidthByte;
           }
       }
       else
       {
           for (i = 0; i < sBarAttr.iHeight; i++)
           {
               pLine = pImage;
               *pLine++ ^= SetLeft;
               for (j = 1; j < (BarWidthByte - 1); j++)
                   *pLine++ ^= 0xFF;
               *pLine++ ^= SetRight;
               pImage += ImgWidthByte;
           }
       }
   }
   else if (sBarAttr.iType == DRAW_PATTERN)
   {
       CONST _FillPattern *pFill;
       CONST BYTE *pPattern;
       INT PatternSize, Column, Row;

       sBarAttr.iPattern %= sizeof(sFillPattern) / sizeof(_FillPattern);
       pFill = &sFillPattern[sBarAttr.iPattern];
       PatternSize = pFill->Width * pFill->Height;
       Column = (sBarAttr.sCoord.iX / 8) % pFill->Width;
       Row = (sBarAttr.sCoord.iY % pFill->Height) * pFill->Width;

       if (sBarAttr.PutWay == PUT_OR)
       {
           if (BarWidthByte == 1)
           {
               pPattern = pFill->pPattern + Column;
               for (i = 0; i < sBarAttr.iHeight; i++)
               {
                   *pImage |= *(pPattern + Row) & SetData;
                   pImage += ImgWidthByte;
                   Row += pFill->Width;
                   if (Row >= PatternSize)
                       Row = 0;
               }
           }
           else
           {
               for (i = 0; i < sBarAttr.iHeight; i++)
               {
                   pLine = pImage;
                   pPattern = pFill->pPattern + Row;
                   Column = (sBarAttr.sCoord.iX / 8) % pFill->Width;

                   *pLine++ |= *(pPattern + Column) & SetLeft;
                   if (++Column >= pFill->Width)
                       Column = 0;

                   for (j = 1; j < (BarWidthByte - 1); j++)
                   {
                       *pLine++ |= *(pPattern + Column);
                       if (++Column >= pFill->Width)
                           Column = 0;
                   }
                   *pLine++ |= *(pPattern + Column) & SetRight;

                   pImage += ImgWidthByte;
                   Row += pFill->Width;
                   if (Row >= PatternSize)
                       Row = 0;
               }
           }
       }
       else if (sBarAttr.PutWay == PUT_OW)
       {
           if (BarWidthByte == 1)
           {
               pPattern = pFill->pPattern + Column;
               for (i = 0; i < sBarAttr.iHeight; i++)
               {
                   *pImage &= ClrData;
                   *pImage |= *(pPattern + Row) & SetData;
                   pImage += ImgWidthByte;
                   Row += pFill->Width;
                   if (Row >= PatternSize)
                       Row = 0;
               }
           }
           else
           {
               for (i = 0; i < sBarAttr.iHeight; i++)
               {
                   pLine = pImage;
                   pPattern = pFill->pPattern + Row;
                   Column = (sBarAttr.sCoord.iX / 8) % pFill->Width;

                   *pLine &= ClrLeft;
                   *pLine++ |= *(pPattern + Column) & SetLeft;
                   if (++Column >= pFill->Width)
                       Column = 0;

                   for (j = 1; j < (BarWidthByte - 1); j++)
                   {
                       *pLine++ = *(pPattern + Column);
                       if (++Column >= pFill->Width)
                           Column = 0;
                   }
                   *pLine &= ClrRight;
                   *pLine++ |= *(pPattern + Column) & SetRight;

                   pImage += ImgWidthByte;
                   Row += pFill->Width;
                   if (Row >= PatternSize)
                       Row = 0;
               }
           }
       }
       else if (sBarAttr.PutWay == PUT_XOR)
       {
           if (BarWidthByte == 1)
           {
               pPattern = pFill->pPattern + Column;
               for (i = 0; i < sBarAttr.iHeight; i++)
               {
                   *pImage ^= *(pPattern + Row) & SetData;
                   pImage += ImgWidthByte;
                   Row += pFill->Width;
                   if (Row >= PatternSize)
                       Row = 0;
               }
           }
           else
           {
               for (i = 0; i < sBarAttr.iHeight; i++)
               {
                   pLine = pImage;
                   pPattern = pFill->pPattern + Row;
                   Column = (sBarAttr.sCoord.iX / 8) % pFill->Width;

                   *pLine++ ^= *(pPattern + Column) & SetLeft;
                   if (++Column >= pFill->Width)
                       Column = 0;

                   for (j = 1; j < (BarWidthByte - 1); j++)
                   {
                       *pLine++ ^= *(pPattern + Column);
                       if (++Column >= pFill->Width)
                           Column = 0;
                   }
                   *pLine++ ^= *(pPattern + Column) & SetRight;

                   pImage += ImgWidthByte;
                   Row += pFill->Width;
                   if (Row >= PatternSize)
                       Row = 0;
               }
           }
       }
   }
}

VOID DrawBox(_BarAttr *pBarAttr)
{
   _BarAttr sBarAttr = *pBarAttr;
   INT X = sBarAttr.sCoord.iX;
   INT Y = sBarAttr.sCoord.iY;
   INT Width = sBarAttr.iWidth;
   INT Height = sBarAttr.iHeight;
   INT Thin = sBarAttr.iThin;

   if (Height > Thin * 2 && Width > Thin * 2)
   {
       sBarAttr.iHeight = Thin;
       DrawBar(&sBarAttr);

sBarAttr.sCoord.iY = Y + Height - Thin;
DrawBar(&sBarAttr);

       sBarAttr.sCoord.iY = Y + Thin;
       sBarAttr.iHeight = Height - Thin * 2;
       sBarAttr.iWidth = Thin;
       DrawBar(&sBarAttr);

       sBarAttr.sCoord.iX = X + Width - Thin;
       DrawBar(&sBarAttr);
   }
   else
       DrawBar(&sBarAttr);
}

VOID DrawCircle(_CircleAttr *pCircleAttr)
{
   _BarAttr sBarAttr;
   INT InvRadiusH, InvRadiusL;
   INT AngleH, AngleL;
   INT DxH, DyH, DxL, DyL;
   INT RadiusH, RadiusL;
   INT LastDy;
   INT Thickness;
   INT i;

if (pCircleAttr->iRadius == 0 || pCircleAttr->iThickness == 0)
return;

   sBarAttr.psImageBuffer = pCircleAttr->psImageBuffer;
   sBarAttr.PutWay = pCircleAttr->PutWay;
   sBarAttr.iPattern = pCircleAttr->iPattern;
   sBarAttr.iType = pCircleAttr->iType;

   Thickness = pCircleAttr->iThickness;
   if (Thickness > pCircleAttr->iRadius)
       Thickness = pCircleAttr->iRadius;

RadiusH = pCircleAttr->iRadius;
RadiusL = pCircleAttr->iRadius - Thickness;

InvRadiusH = RadiusH ? (1 / (FLOAT)RadiusH * 0xFFFF) : 0;
InvRadiusL = RadiusL ? (1 / (FLOAT)RadiusL * 0xFFFF) : 0;

   sBarAttr.iHeight = 1;
   sBarAttr.iWidth = Thickness;
   AngleH = 0;   AngleL = 0;
   DyH = 0;
   DxH = RadiusH - 1;

   while (DyH <= DxH)
   {
       if (pCircleAttr->CirclePart & RIGHT_BOTTOM_CIRCLE)
       {
           sBarAttr.sCoord.iX = pCircleAttr->sCoord.iX + DxH - Thickness + 1;
           sBarAttr.sCoord.iY = pCircleAttr->sCoord.iY + DyH;
           if (sBarAttr.sCoord.iX >= 0 && sBarAttr.sCoord.iY >= 0)
               DrawBar(&sBarAttr);
       }

       if (pCircleAttr->CirclePart & RIGHT_TOP_CIRCLE)
       {
           sBarAttr.sCoord.iX = pCircleAttr->sCoord.iX + DxH - Thickness + 1;
           sBarAttr.sCoord.iY = pCircleAttr->sCoord.iY - DyH;
           if (sBarAttr.sCoord.iX >= 0 && sBarAttr.sCoord.iY >= 0 && DyH != 0)
               DrawBar(&sBarAttr);
       }

       if (pCircleAttr->CirclePart & LEFT_BOTTOM_CIRCLE)
       {
           sBarAttr.sCoord.iX = pCircleAttr->sCoord.iX - DxH;
           sBarAttr.sCoord.iY = pCircleAttr->sCoord.iY + DyH;
           if (sBarAttr.sCoord.iX >= 0 && sBarAttr.sCoord.iY >= 0)
               DrawBar(&sBarAttr);
       }

       if (pCircleAttr->CirclePart & LEFT_TOP_CIRCLE)
       {
           sBarAttr.sCoord.iX = pCircleAttr->sCoord.iX - DxH;
           sBarAttr.sCoord.iY = pCircleAttr->sCoord.iY - DyH;
           if (sBarAttr.sCoord.iX >= 0 && sBarAttr.sCoord.iY >= 0 && DyH != 0)
               DrawBar(&sBarAttr);
       }

       DyH += 1;
       AngleH += InvRadiusH;
       DxH = (INT)((RadiusH * SinTab[AngleH >> 6]) >> 16);

       if (Thickness != 1)
       {
           AngleL += InvRadiusL;
           DxL = (INT)((RadiusL * SinTab[AngleL >> 6]) >> 16);
           if ((DyH >= RadiusL) || (DxL < DyH))
               DxL = DyH - 1;
           Thickness = sBarAttr.iWidth = DxH - DxL;
       }
   }

LastDy = DyH;

   Thickness = pCircleAttr->iThickness;
   if (Thickness > pCircleAttr->iRadius)
       Thickness = pCircleAttr->iRadius;

sBarAttr.iWidth = 1;
sBarAttr.iHeight = Thickness;

   AngleH = 0;   AngleL = 0;
   DxH = 0;
   DyH = RadiusH - 1;

   while (DyH >= LastDy)
   {
       if (pCircleAttr->CirclePart & RIGHT_BOTTOM_CIRCLE)
       {
           sBarAttr.sCoord.iX = pCircleAttr->sCoord.iX + DxH;
           sBarAttr.sCoord.iY = pCircleAttr->sCoord.iY + DyH - Thickness + 1;
           if (sBarAttr.sCoord.iX >= 0 && sBarAttr.sCoord.iY >= 0 && DxH != 0)
               DrawBar(&sBarAttr);
       }

       if (pCircleAttr->CirclePart & RIGHT_TOP_CIRCLE)
       {
           sBarAttr.sCoord.iX = pCircleAttr->sCoord.iX + DxH;
           sBarAttr.sCoord.iY = pCircleAttr->sCoord.iY - DyH;
           if (sBarAttr.sCoord.iX >= 0 && sBarAttr.sCoord.iY >= 0 && DxH != 0)
               DrawBar(&sBarAttr);
       }

       if (pCircleAttr->CirclePart & LEFT_BOTTOM_CIRCLE)
       {
           sBarAttr.sCoord.iX = pCircleAttr->sCoord.iX - DxH;
           sBarAttr.sCoord.iY = pCircleAttr->sCoord.iY + DyH - Thickness + 1;
           if (sBarAttr.sCoord.iX >= 0 && sBarAttr.sCoord.iY >= 0)
               DrawBar(&sBarAttr);
       }

       DxH += 1;
       AngleH += InvRadiusH;
       DyH = (INT)((RadiusH * SinTab[AngleH >> 6]) >> 16);

       if (Thickness != 1)
       {
           AngleL += InvRadiusL;
           DyL = (INT)((RadiusL * SinTab[AngleL >> 6]) >> 16);
           if ((DxH >= RadiusL) || (DyL < DxH))
               DyL = DxH;
           Thickness = sBarAttr.iHeight = DyH - DyL;
       }
   }
}

VOID DrawFrame(_FrameAttr *pFrameAttr)
{
   INT Thickness;
   _CircleAttr sCircleAttr;
   _BarAttr sBarAttr;

   sBarAttr.psImageBuffer = pFrameAttr->psImageBuffer;
   sBarAttr.PutWay = pFrameAttr->PutWay;
   sBarAttr.iPattern = pFrameAttr->iPattern;
   sBarAttr.iType = pFrameAttr->iType;

   sCircleAttr.psImageBuffer = pFrameAttr->psImageBuffer;
   sCircleAttr.PutWay = pFrameAttr->PutWay;
   sCircleAttr.iPattern = pFrameAttr->iPattern;
   sCircleAttr.iType = pFrameAttr->iType;
   sCircleAttr.iRadius = pFrameAttr->iRadius;

   Thickness = pFrameAttr->iThickness;
   if (Thickness > pFrameAttr->iRadius)
       Thickness = pFrameAttr->iRadius;

   if (pFrameAttr->iRadius)
   {
       sCircleAttr.iThickness = Thickness;

       sCircleAttr.CirclePart = LEFT_TOP_CIRCLE;
       sCircleAttr.sCoord.iX = pFrameAttr->sCoord.iX + sCircleAttr.iRadius;
       sCircleAttr.sCoord.iY = pFrameAttr->sCoord.iY + sCircleAttr.iRadius;
       DrawCircle(&sCircleAttr);

       sCircleAttr.CirclePart = RIGHT_TOP_CIRCLE;
       sCircleAttr.sCoord.iX = pFrameAttr->sCoord.iX + pFrameAttr->iWidth - sCircleAttr.iRadius;
       sCircleAttr.sCoord.iY = pFrameAttr->sCoord.iY + sCircleAttr.iRadius;
       DrawCircle(&sCircleAttr);

       sCircleAttr.CirclePart = LEFT_BOTTOM_CIRCLE;
       sCircleAttr.sCoord.iX = pFrameAttr->sCoord.iX + sCircleAttr.iRadius;
       sCircleAttr.sCoord.iY = pFrameAttr->sCoord.iY + pFrameAttr->iHeight - sCircleAttr.iRadius;
       DrawCircle(&sCircleAttr);

       sCircleAttr.CirclePart = RIGHT_BOTTOM_CIRCLE;
       sCircleAttr.sCoord.iX = pFrameAttr->sCoord.iX + pFrameAttr->iWidth - sCircleAttr.iRadius;
       sCircleAttr.sCoord.iY = pFrameAttr->sCoord.iY + pFrameAttr->iHeight - sCircleAttr.iRadius;
       DrawCircle(&sCircleAttr);

       sBarAttr.sCoord.iX = pFrameAttr->sCoord.iX + sCircleAttr.iRadius + 1;
       sBarAttr.sCoord.iY = pFrameAttr->sCoord.iY;
       sBarAttr.iWidth = pFrameAttr->iWidth - 2 * sCircleAttr.iRadius;
       sBarAttr.iHeight = Thickness;
       DrawBar(&sBarAttr);

       sBarAttr.sCoord.iX = pFrameAttr->sCoord.iX + pFrameAttr->iWidth - Thickness;
       sBarAttr.sCoord.iY = pFrameAttr->sCoord.iY + sCircleAttr.iRadius;
       sBarAttr.iWidth = Thickness;
       sBarAttr.iHeight = pFrameAttr->iHeight - 2 * sCircleAttr.iRadius;
       DrawBar(&sBarAttr);

       sBarAttr.sCoord.iX = pFrameAttr->sCoord.iX + sCircleAttr.iRadius + 1;
       sBarAttr.sCoord.iY = pFrameAttr->sCoord.iY + pFrameAttr->iHeight - Thickness;
       sBarAttr.iWidth = pFrameAttr->iWidth - 2 * sCircleAttr.iRadius;
       sBarAttr.iHeight = Thickness;
       DrawBar(&sBarAttr);

       sBarAttr.sCoord.iX = pFrameAttr->sCoord.iX;
       sBarAttr.sCoord.iY = pFrameAttr->sCoord.iY + sCircleAttr.iRadius;
       sBarAttr.iWidth = Thickness;
       sBarAttr.iHeight = pFrameAttr->iHeight - 2 * sCircleAttr.iRadius;
       DrawBar(&sBarAttr);
   }

   if (pFrameAttr->iThickness > pFrameAttr->iRadius)
   {
       sBarAttr.sCoord.iX = pFrameAttr->sCoord.iX + pFrameAttr->iRadius;
       sBarAttr.sCoord.iY = pFrameAttr->sCoord.iY + pFrameAttr->iRadius;
       sBarAttr.iWidth = pFrameAttr->iWidth - 2 * pFrameAttr->iRadius;
       sBarAttr.iHeight = pFrameAttr->iHeight - 2 * pFrameAttr->iRadius;
       sBarAttr.iThin = pFrameAttr->iThickness - pFrameAttr->iRadius;
       DrawBox(&sBarAttr);
   }
}

VOID DrawDiagonal(_DiagonalAttr *pDiagonalAttr)
{
   _BarAttr sBarAttr;
   INT SourceX = pDiagonalAttr->sCoord1.iX;
   INT SourceY = pDiagonalAttr->sCoord1.iY;
   INT TargetX = pDiagonalAttr->sCoord2.iX;
   INT TargetY = pDiagonalAttr->sCoord2.iY;
   INT Slope;
   INT Dx = 0;
   INT Dy = 0;

   sBarAttr.psImageBuffer = pDiagonalAttr->psImageBuffer;
   sBarAttr.PutWay = pDiagonalAttr->PutWay;
   sBarAttr.iPattern = pDiagonalAttr->iPattern;
   sBarAttr.iType = pDiagonalAttr->iType;

   if (pDiagonalAttr->Direction == DIAGONAL_VERTICAL)
   {
       sBarAttr.iWidth = pDiagonalAttr->iThickness;
       sBarAttr.iHeight = 1;

       if (SourceY > TargetY)
       {
           SourceX = pDiagonalAttr->sCoord2.iX;
           SourceY = pDiagonalAttr->sCoord2.iY;
           TargetX = pDiagonalAttr->sCoord1.iX;
           TargetY = pDiagonalAttr->sCoord1.iY;
       }

Slope = ((TargetX - SourceX) << 8) / (TargetY - SourceY);

       while ((SourceY + Dy) <= TargetY)
       {
           sBarAttr.sCoord.iX = SourceX + Dx;
           sBarAttr.sCoord.iY = SourceY + Dy;
           if (sBarAttr.sCoord.iX >= 0 && sBarAttr.sCoord.iY >= 0)
               DrawBar(&sBarAttr);

           Dy += 1;
           Dx = (Dy * Slope) >> 8;
       }
   }
   else if (pDiagonalAttr->Direction == DIAGONAL_HORIZONTAL)
   {
       sBarAttr.iWidth = 1;
       sBarAttr.iHeight = pDiagonalAttr->iThickness;

       if (SourceX > TargetX)
       {
           SourceX = pDiagonalAttr->sCoord2.iX;
           SourceY = pDiagonalAttr->sCoord2.iY;
           TargetX = pDiagonalAttr->sCoord1.iX;
           TargetY = pDiagonalAttr->sCoord1.iY;
       }

Slope = ((TargetY - SourceY) << 8) / (TargetX - SourceX);

       while ((SourceX + Dx) <= TargetX)
       {
           sBarAttr.sCoord.iX = SourceX + Dx;
           sBarAttr.sCoord.iY = SourceY + Dy;
           if (sBarAttr.sCoord.iX >= 0 && sBarAttr.sCoord.iY >= 0)
               DrawBar(&sBarAttr);

           Dx += 1;
           Dy = (Dx * Slope) >> 8;
       }
   }
}

Line.h

#ifndef LINE_H

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

#define LINE_H

/* None */

#include "XImgMgr.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 DRAW_BAR               1
#define DRAW_ERASE               2
#define DRAW_REVERSE           3
#define DRAW_PATTERN           4

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

typedef enum
{
   RIGHT_TOP_CIRCLE = 0x01,
   RIGHT_BOTTOM_CIRCLE = 0x02,
   LEFT_BOTTOM_CIRCLE = 0x04,
   LEFT_TOP_CIRCLE = 0x08,
   FULL_CIRCLE = 0x0f,
}_eCirclePart;

typedef enum
{
DIAGONAL_VERTICAL,
DIAGONAL_HORIZONTAL,
}_eDiagDir;

typedef struct
{
   _ImgBuf *psImageBuffer;
   _Coord sCoord;
   _ePutWay PutWay;
   INT iPattern;
   INT iType;
   INT iWidth;
   INT iHeight;
   INT iThin;
}_BarAttr;

typedef struct
{
   _ImgBuf *psImageBuffer;
   _Coord sCoord;
   _eCirclePart CirclePart;
   _ePutWay PutWay;
   INT iPattern;
   INT iType;
   INT iRadius;
   INT iThickness;
}_CircleAttr;

typedef struct
{
   _ImgBuf *psImageBuffer;
   _Coord sCoord;
   _ePutWay PutWay;
   INT iPattern;
   INT iType;
   INT iWidth;
   INT iHeight;
   INT iThickness;
   INT iRadius;
}_FrameAttr;

typedef struct
{
   _ImgBuf *psImageBuffer;
   _Coord sCoord1;
   _Coord sCoord2;
   _eDiagDir Direction;
   _ePutWay PutWay;
   INT iPattern;
   INT iType;
   INT iThickness;
}_DiagonalAttr;

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

/* None */

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

/* None */

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

VOID DrawBar(_BarAttr *);
VOID DrawBox(_BarAttr *);
VOID DrawCircle(_CircleAttr *);
VOID DrawFrame(_FrameAttr *);
VOID DrawDiagonal(_DiagonalAttr *);

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

#endif

PCX.c /

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

#define PCX_C

/* None */

#include "Common.h"
#include "XCore.h"
#include "XFileSys.h"
#include "XGraphic.h"
#include "PCX.h"

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

#define PCX11 11
#define PCX14 14
#define PCX81 81
#define PCX83 83

#define MAXWIDTH (TPH_WIDTH_BYTE + 0x3F) /* 104 * 8 = 832 dot */

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

/******************02-08-99 10:44********************/
/*                                                   */
/* decode PCX                                       */
/*                                                   */
/* 1. 2 color                                       */
/* 2. 256 color change to 2 color                   */
/*                                                   */
/****************************************************/
typedef struct
{
   BYTE bManufacturer;
   BYTE bVersionNo;
   BYTE bEncoding;
   BYTE bBitsPerPixel;
   WORD wXmin;
   WORD wYmin;
   WORD wXmax;
   WORD wYmax;
   WORD wHResolution;
   WORD wVResolution;
   BYTE abPalette[48];
   BYTE bReserved;
   BYTE bPlanes;
   WORD wBytesPerLine;
   WORD wPaletteType;
   WORD wHScreenSize;
   WORD wVScreenSize;
   BYTE abFiller[54];
}_PCX_Header;

typedef struct
{
   INT iImageWidth;
   INT iImageHeight;
   INT iUseWidth;
   INT iUseHeight;
   INT iImageWidthByte;
   INT iUseWidthByte;
   INT iDataWidthByte;
   BYTE abPalette[256];
   BYTE bShiftBit;
   BYTE bShiftBit1;
   BYTE bShiftFlag;
    BYTE bShiftData;
    BYTE bRemoveBit;
    BYTE bRemoveMaskBit;
   BYTE bShiftMaskData;
   BYTE bRemoveMaskData;
} _PCX_Data;

INT PCXmain(_PCXAttr *sPCXattr);
VOID get_lineP1(BYTE *pbBuf, _PCX_Data *sPCX_Data);
VOID get_lineP8(BYTE *pbBuf, _PCX_Data *sPCX_Data);
INT decode_PCX11(_PCXAttr *sPCXAttr);
INT decode_PCX81(_PCXAttr *sPCXAttr);

/* None */

_FileHandle *FPCX;
_PCX_Header sPCX_Header;
BYTE abPCX_Buffer[1024], abPCXBuf[1024 + 0x3F];

iCount = 0;
bBit = 0x80;

*pbBuf = 0;
pbPalette = sPCX_Data->abPalette;

   while ( iCount < sPCX_Data->iUseWidth )
   {
       if ( ( bData = (BYTE)Fgetc(FPCX) ) >= 0xC0 )
       {
           iRepeat = bData & 0x3F;
           if ( *(pbPalette + (BYTE)Fgetc(FPCX)) == 1 )
           {
               for ( i = 0 ; i < iRepeat ; i++ )
               {
                   *pbBuf |= bBit;
                   bBit >>= 1;

                   if ( bBit == 0 )
                   {
                       bBit = 0x80;
                       pbBuf += 1;
                       *pbBuf = 0;
                   }
               }
           }
           else
           {
               for ( i = 0 ; i < iRepeat ; i++ )
               {
                   bBit >>= 1;

                   if ( bBit == 0 )
                   {
                       bBit = 0x80;
                       pbBuf += 1;
                       *pbBuf = 0;
                   }
               }
           }
           iCount += iRepeat;
       }
       else
       {
           if ( *(pbPalette + bData) == 1 )
               *pbBuf |= bBit;

           bBit >>= 1;

           if ( bBit == 0 )
           {
               bBit = 0x80;
               pbBuf += 1;
           *pbBuf = 0;
           }
           iCount += 1;
       }
   }

   while ( iCount < sPCX_Data->iImageWidthByte )
   {
       if ( ( bData = (BYTE)Fgetc(FPCX) ) >= 0xC0 )
       {
           iCount += bData & 0x3F;
           Fgetc(FPCX);
       }
       else
       {
           iCount += 1;
       }
   }
}

/*-----------------02-10-99 10:45-------------------
decode_PCX81()
--------------------------------------------------*/
INT decode_PCX81(_PCXAttr *sPCXAttr)
{
   BYTE *pbImagePtr, *pbTemp, *pbPalette, bData;
   INT i, j;
   DWORD dOffset;
   _PCX_Data sPCX_Data;

   if ( (sPCX_Data.iImageWidth = (INT)(sPCX_Header.wXmax - sPCX_Header.wXmin + 1)) <= 0 )
       return _ERROR;
   if ( (sPCX_Data.iImageHeight = (INT)(sPCX_Header.wYmax - sPCX_Header.wYmin + 1)) <= 0 )
       return _ERROR;
   if ( (sPCX_Data.iImageWidthByte = sPCX_Header.wBytesPerLine) <= 0 )
       return _ERROR;

   // Get Palette
   Fseek(FPCX, -768L, SEEK_END);
   if ( Fread(abPCX_Buffer, sizeof(BYTE), 768, FPCX) != 768 )
       return _ERROR;

   pbTemp = abPCX_Buffer;
   pbPalette = sPCX_Data.abPalette;
   for ( i = 0 ; i < 256 ; i++ )
   {
       if ( ((*pbTemp+0) + (*pbTemp+1) + (*pbTemp+2)) > 384 ) // 256 * 3 / 2 = 384
           *pbPalette = 0;
       else
           *pbPalette = 1;

       pbPalette += 1;
       pbTemp += 3;
   }

   Fseek(FPCX, sizeof(sPCX_Header), SEEK_SET);

   // UseWidth & UseWidthByte
   if ( (sPCXAttr->sCoord.iX + sPCX_Data.iImageWidth) > sPCXAttr->psImageBuffer->iWidth )
   {
       sPCX_Data.bShiftFlag = 1;
       sPCX_Data.iUseWidth = sPCXAttr->psImageBuffer->iWidth - sPCXAttr->sCoord.iX;
       if ( sPCX_Data.iUseWidth <= 0 )
           return _SUCCESS;

       if ( (sPCX_Data.iUseWidth % 8) > 0 )
           sPCX_Data.iUseWidthByte = sPCX_Data.iUseWidth / 8 + 1;
       else
           sPCX_Data.iUseWidthByte = sPCX_Data.iUseWidth / 8;
   }
   else
   {
       sPCX_Data.bShiftFlag = 0;
       sPCX_Data.iUseWidth = sPCX_Data.iImageWidth;

       if ( (sPCX_Data.iImageWidth % 8) > 0 )
           sPCX_Data.iUseWidthByte = sPCX_Data.iImageWidth / 8 + 1;
       else
           sPCX_Data.iUseWidthByte = sPCX_Data.iImageWidth / 8;
   }

   // Shift Bit
   sPCX_Data.bShiftBit = (BYTE)(sPCXAttr->sCoord.iX % 8);
   sPCX_Data.bShiftBit1 = 8 - sPCX_Data.bShiftBit;

   // UseHeight
   if ( (sPCXAttr->sCoord.iY + sPCX_Data.iImageHeight) > sPCXAttr->psImageBuffer->iHeight )
   {
       sPCX_Data.iUseHeight = sPCXAttr->psImageBuffer->iHeight - sPCXAttr->sCoord.iY;
       if ( sPCX_Data.iUseHeight <= 0 )
           return _SUCCESS;
   }
   else
   {
       sPCX_Data.iUseHeight = sPCX_Data.iImageHeight;
   }

   // The Last Line
   //if ( (i = sPCXAttr->sCoord.iY + sPCX_Data.iUseHeight) > sPCXAttr->psImageBuffer->iLastLine )
   //   sPCXAttr->psImageBuffer->iLastLine = i;
   ModifyImgSection(sPCXAttr->sCoord.iY, sPCX_Data.iUseHeight, sPCXAttr->psImageBuffer);

   // Image Offset
   dOffset = (DWORD)(sPCXAttr->psImageBuffer->iByteWidth * sPCXAttr->sCoord.iY +
                           sPCXAttr->sCoord.iX / 8);

   // Decode Data & Put Data
   sPCX_Data.bShiftData = 0;
   if ( sPCX_Data.bShiftBit == 0 )
   {
       for ( j = 0 ; j < sPCX_Data.iUseHeight ; j++ )
       {
           get_lineP8(abPCXBuf, &sPCX_Data);
           pbTemp = abPCXBuf;

           pbImagePtr = sPCXAttr->psImageBuffer->pBuffer + dOffset;
           for ( i = 0 ; i < sPCX_Data.iUseWidthByte ; i++ )
           {
               *pbImagePtr |= *pbTemp;
               pbImagePtr += 1;
               pbTemp += 1;
           }
           dOffset += sPCXAttr->psImageBuffer->iByteWidth;
       }
   }
   else
   {
       for ( j = 0 ; j < sPCX_Data.iUseHeight ; j++ )
       {
           get_lineP8(abPCXBuf, &sPCX_Data);
           pbTemp = abPCXBuf;

           pbImagePtr = sPCXAttr->psImageBuffer->pBuffer + dOffset;
           for ( i = 0 ; i < sPCX_Data.iUseWidthByte ; i++ )
           {
           bData = *pbTemp;
               *pbImagePtr |= ((bData >> sPCX_Data.bShiftBit) | sPCX_Data.bShiftData);
               sPCX_Data.bShiftData = bData << sPCX_Data.bShiftBit1;
               pbImagePtr += 1;
               pbTemp += 1;
           }

           if ( sPCX_Data.bShiftFlag == 0 )
               *pbImagePtr |= sPCX_Data.bShiftData;

           sPCX_Data.bShiftData = 0;
           dOffset += sPCXAttr->psImageBuffer->iByteWidth;
       }
   }
   return _SUCCESS;
}

/*-----------------02-10-99 10:46-------------------
get_line()
--------------------------------------------------*/
VOID get_lineP1(BYTE *pbBuf, _PCX_Data *sPCX_Data)
{
INT i, iCount, iRepeat;
BYTE bData;

iCount = 0;

   while ( iCount < sPCX_Data->iUseWidthByte )
   {
       if ( ( bData = (BYTE)Fgetc(FPCX) ) >= 0xC0 )
       {
           iRepeat = bData & 0x3F;
           bData = ~(BYTE)Fgetc(FPCX);

           for ( i = 0 ; i < iRepeat ; i++ )
           {
               *pbBuf = bData;
               pbBuf += 1;
           }
           iCount += iRepeat;
       }
       else
       {
           *pbBuf = ~bData;
           pbBuf += 1;
           iCount += 1;
       }
   }

/*-----------------02-10-99 10:45-------------------
decode_PCX11()
--------------------------------------------------*/
INT decode_PCX11(_PCXAttr *sPCXAttr)
{
   BYTE *pbImagePtr, *pbTemp, bData; //bTempData, bRemoveBit;
   INT i, j;
   DWORD dOffset;
   _PCX_Data sPCX_Data;

   if ( (sPCX_Data.iImageWidth = (INT)(sPCX_Header.wXmax - sPCX_Header.wXmin + 1)) <= 0 )
       return _ERROR;
   if ( (sPCX_Data.iImageHeight = (INT)(sPCX_Header.wYmax - sPCX_Header.wYmin + 1)) <= 0 )
       return _ERROR;
   if ( (sPCX_Data.iImageWidthByte = sPCX_Header.wBytesPerLine) <= 0 )
       return _ERROR;

   // Remove Bit
   if ( sPCX_Data.iImageWidth % 8 == 0 )
       sPCX_Data.bRemoveBit = 0xFF;
   else
       sPCX_Data.bRemoveBit = 0xFF << (8 - sPCX_Data.iImageWidth % 8);

   // UseWidth & UseWidthByte
   if ( (sPCXAttr->sCoord.iX + sPCX_Data.iImageWidth) > sPCXAttr->psImageBuffer->iWidth )
   {
       sPCX_Data.bShiftFlag = 1;
       sPCX_Data.iUseWidth = sPCXAttr->psImageBuffer->iWidth - sPCXAttr->sCoord.iX;
       if ( sPCX_Data.iUseWidth <= 0 )
           return _SUCCESS;

       sPCX_Data.iUseWidthByte = (sPCX_Data.iUseWidth + 7) / 8;
   }
   else
   {
       sPCX_Data.bShiftFlag = 0;
       sPCX_Data.iUseWidthByte = (sPCX_Data.iImageWidth + 7) / 8;
   }

   // Shift Bit
   sPCX_Data.bShiftBit = (BYTE)(sPCXAttr->sCoord.iX % 8);
   sPCX_Data.bShiftBit1 = 8 - sPCX_Data.bShiftBit;

   // UseHeight
   if ( (sPCXAttr->sCoord.iY + sPCX_Data.iImageHeight) > sPCXAttr->psImageBuffer->iHeight )
   {
       sPCX_Data.iUseHeight = sPCXAttr->psImageBuffer->iHeight - sPCXAttr->sCoord.iY;
       if ( sPCX_Data.iUseHeight <= 0 )
           return _SUCCESS;
   }
   else
   {
       sPCX_Data.iUseHeight = sPCX_Data.iImageHeight;
   }

   // The Last Line
   //if ( (i = sPCXAttr->sCoord.iY + sPCX_Data.iUseHeight) > sPCXAttr->psImageBuffer->iLastLine )
   //   sPCXAttr->psImageBuffer->iLastLine = i;
   ModifyImgSection(sPCXAttr->sCoord.iY, sPCX_Data.iUseHeight, sPCXAttr->psImageBuffer);

   // Image Offset
   dOffset = (DWORD)(sPCXAttr->psImageBuffer->iByteWidth * sPCXAttr->sCoord.iY
                           + sPCXAttr->sCoord.iX / 8);

#if defined(TSPL_VER_1)   // AND
   sPCX_Data.bRemoveMaskBit = ( sPCXAttr->sCoord.iX + sPCX_Data.iImageWidth ) % 8;
   if ( sPCX_Data.bRemoveMaskBit == 0 )
       sPCX_Data.bRemoveMaskData = 0;
   else
       sPCX_Data.bRemoveMaskData = 0xFF >> sPCX_Data.bRemoveMaskBit;
#endif

   // Decode Data & Put Data
   sPCX_Data.bShiftData = 0;

   if ( sPCX_Data.bShiftBit != 0 )
   {

#if defined(TSPL_VER_1) // AND
       sPCX_Data.bShiftMaskData = 0xFF << sPCX_Data.bShiftBit1;
       if ( (sPCX_Data.bShiftBit + sPCX_Data.iImageWidth) <= 8 )
           sPCX_Data.bRemoveMaskData |= sPCX_Data.bShiftMaskData;
#endif
       for ( j = 0 ; j < sPCX_Data.iUseHeight ; j++ )
       {
           get_lineP1(abPCXBuf, &sPCX_Data);
           pbTemp = abPCXBuf;
           pbImagePtr = sPCXAttr->psImageBuffer->pBuffer + dOffset;

#if defined(TSPL_VER_1)   // AND
           if ( sPCX_Data.iUseWidthByte != 1 )
           {
               bData = *pbTemp;
               *pbImagePtr &= sPCX_Data.bShiftMaskData;
               *pbImagePtr |= (bData >> sPCX_Data.bShiftBit);
               sPCX_Data.bShiftData = bData << sPCX_Data.bShiftBit1;
               pbImagePtr += 1;
               pbTemp += 1;

               for ( i = 1 ; i < sPCX_Data.iUseWidthByte - 1 ; i++ )
               {
                   bData = *pbTemp;
                   *pbImagePtr = ((bData >> sPCX_Data.bShiftBit) | sPCX_Data.bShiftData);
                   sPCX_Data.bShiftData = bData << sPCX_Data.bShiftBit1;
                   pbImagePtr += 1;
                   pbTemp += 1;
               }
           }
           else
               i = 0;

           i += 1;
           if ( i == ((sPCX_Data.iImageWidth + 7) / 8) )
           {
               bData = ((*pbTemp)) & sPCX_Data.bRemoveBit;
               if ( sPCX_Data.bShiftBit1 >= sPCX_Data.iImageWidth % 8 && sPCX_Data.iImageWidth % 8 )
               {
                   *pbImagePtr &= sPCX_Data.bRemoveMaskData;
                   *pbImagePtr |= ((bData >> sPCX_Data.bShiftBit) | sPCX_Data.bShiftData);
               }
               else
               {
                   if ( sPCX_Data.iUseWidthByte != 1 )
                       *pbImagePtr = ((bData >> sPCX_Data.bShiftBit) | sPCX_Data.bShiftData);
                   else
                   {
                       *pbImagePtr &= sPCX_Data.bShiftMaskData;
                       *pbImagePtr |= (bData >> sPCX_Data.bShiftBit);
                   }
                   sPCX_Data.bShiftData = bData << sPCX_Data.bShiftBit1;
                   pbImagePtr += 1;

                   if ( sPCX_Data.bShiftFlag == 0 )
                   {
                       *pbImagePtr &= sPCX_Data.bRemoveMaskData;
                       *pbImagePtr |= sPCX_Data.bShiftData;
                   }
               }
           }
           else
           {
               bData = (*pbTemp);
               *pbImagePtr &= ((bData >> sPCX_Data.bShiftBit) | sPCX_Data.bShiftData);
           }
#else
           for ( i = 0 ; i < sPCX_Data.iUseWidthByte - 1 ; i++ )
           {
               bData = *pbTemp;
               *pbImagePtr |= ((bData >> sPCX_Data.bShiftBit) | sPCX_Data.bShiftData);
               sPCX_Data.bShiftData = bData << sPCX_Data.bShiftBit1;
               pbImagePtr += 1;
               pbTemp += 1;
           }
           i += 1;
           if ( i == ((sPCX_Data.iImageWidth + 7) / 8) )
               bData = ((*pbTemp)) & sPCX_Data.bRemoveBit;
           else
               bData = (*pbTemp);

           *pbImagePtr |= ((bData >> sPCX_Data.bShiftBit) | sPCX_Data.bShiftData);
           sPCX_Data.bShiftData = bData << sPCX_Data.bShiftBit1;
           pbImagePtr += 1;

           if ( sPCX_Data.bShiftFlag == 0 )
               *pbImagePtr |= sPCX_Data.bShiftData;
#endif
           sPCX_Data.bShiftData = 0;
           dOffset += sPCXAttr->psImageBuffer->iByteWidth;
       }
   }
   else
   {
       for ( j = 0 ; j < sPCX_Data.iUseHeight ; j++ )
       {
           get_lineP1(abPCXBuf, &sPCX_Data);
           pbTemp = abPCXBuf;
           pbImagePtr = sPCXAttr->psImageBuffer->pBuffer + dOffset;

#if defined(TSPL_VER_1)   // AND
           for ( i = 0 ; i < sPCX_Data.iUseWidthByte - 1 ; i++ )
               *pbImagePtr++ = *pbTemp++;

           i += 1;
           if ( i == ((sPCX_Data.iImageWidth + 7) / 8) )
           {
               *pbImagePtr &= sPCX_Data.bRemoveMaskData;
               *pbImagePtr |= ((*pbTemp) & sPCX_Data.bRemoveBit);
           }
           else
               *pbImagePtr = *pbTemp;
#else
           for ( i = 0 ; i < sPCX_Data.iUseWidthByte - 1 ; i++ )
               *pbImagePtr++ |= *pbTemp++;

           i += 1;
           if ( i == ((sPCX_Data.iImageWidth + 7) / 8) )
               *pbImagePtr |= ((*pbTemp) & sPCX_Data.bRemoveBit);
           else
               *pbImagePtr |= *pbTemp;
#endif
           dOffset += sPCXAttr->psImageBuffer->iByteWidth;
       }
   }

return _SUCCESS;
}

/*-----------------02-10-99 10:43-------------------
PCXmain()
--------------------------------------------------*/
INT PCXmain(_PCXAttr *sPCXAttr)
{
WORD wPCX_Mode;

   while ( 1 )
   {
       if ( ( FPCX = Fopen(DRAM_DEVICE, (CHAR *)sPCXAttr->pbFileName, "r") ) != _NULL ){}
       else if ( ( FPCX = Fopen(FLASH_DEVICE, (CHAR *)sPCXAttr->pbFileName, "r") ) != _NULL ){}
       else if ( ( FPCX = Fopen(CARD_DEVICE, (CHAR *)sPCXAttr->pbFileName, "r") ) != _NULL ){}
       if ( FPCX == _NULL )
           break;

if ( Fread(&sPCX_Header, sizeof(sPCX_Header), 1, FPCX) != 1 )
break;

if ( sPCX_Header.bManufacturer != 0x0A )
break;

ModifyImgSection( sPCXAttr->sCoord.iY, sPCX_Header.wYmax - sPCX_Header.wYmin + 1, sPCXAttr->psImageBuffer);

wPCX_Mode = sPCX_Header.bBitsPerPixel * 10 + sPCX_Header.bPlanes;

       if ( wPCX_Mode == PCX11 )
       {
           if ( decode_PCX11(sPCXAttr) == _ERROR )
           {
               Fclose(FPCX);
               return _ERROR;
           }
       }
       else if ( wPCX_Mode == PCX81 )
       {
           if ( decode_PCX81(sPCXAttr) == _ERROR )
           {
               Fclose(FPCX);
               return _ERROR;
           }
       }
       else
       {
           Fclose(FPCX);
           return _ERROR;
       }
       Fclose(FPCX);
       return _SUCCESS;
   }
   Fclose(FPCX);
   return _ERROR;
}

INT PCX_Info(_PCXAttr *sPCXAttr)
{
BYTE *pbTemp;

   while ( 1 )
   {
       if ( ( FPCX = Fopen(DRAM_DEVICE, (CHAR *)sPCXAttr->pbFileName, "r") ) != _NULL ){}
       else if ( ( FPCX = Fopen(FLASH_DEVICE, (CHAR *)sPCXAttr->pbFileName, "r") ) != _NULL ){}
       else if ( ( FPCX = Fopen(CARD_DEVICE, (CHAR *)sPCXAttr->pbFileName, "r") ) != _NULL ){}
       if ( FPCX == _NULL )
   break;

       pbTemp = (BYTE *)&sPCX_Header;
       if ( Fread(&sPCX_Header, sizeof(sPCX_Header), 1, FPCX) != 1 )
           break;

#if defined(BIG_ENDIAN)
       sPCX_Header.wXmax = (sPCX_Header.wXmax >> 8) + (sPCX_Header.wXmax << 8);
       sPCX_Header.wXmin = (sPCX_Header.wXmin >> 8) + (sPCX_Header.wXmin << 8);
       sPCX_Header.wYmax = (sPCX_Header.wYmax >> 8) + (sPCX_Header.wYmax << 8);
       sPCX_Header.wYmin = (sPCX_Header.wYmin >> 8) + (sPCX_Header.wYmin << 8);
       sPCX_Header.wBytesPerLine = (sPCX_Header.wBytesPerLine >> 8) + (sPCX_Header.wBytesPerLine << 8);
#endif

       if ( sPCX_Header.bManufacturer != 0x0A )
           break;

       if ( (sPCXAttr->iTotalWidth = (INT)(sPCX_Header.wXmax - sPCX_Header.wXmin + 1)) <= 0 )
           break;
       if ( (sPCXAttr->iTotalHeight = (INT)(sPCX_Header.wYmax - sPCX_Header.wYmin + 1)) <= 0 )
           break;

       Fclose(FPCX);
       return _SUCCESS;
   }
   Fclose(FPCX);
   return _ERROR;
}

PCX.h ///

#ifndef PCX_H

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

#define PCX_H

/* None */

#include "XImgMgr.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 *
* *
******************************************************************************/

/* None */

typedef struct
{
   _ImgBuf       *psImageBuffer;
   _Coord sCoord;
INT iRotation;
INT           iTotalWidth;
INT           iTotalHeight;
BYTE *pbFileName;
}_PCXAttr;

/* None */