graph.c

C语言编写的监控中心终端程序。基于GPRS上传收发数据功能

}

void MapDrawRectangle(INT16 SX, INT16 SY, INT16 EX, INT16 EY)
{
    MapDrawLine(SX,	SY,	EX - 1,	SY);
    MapDrawLine(EX - 1,	SY,	EX - 1,	EY - 1);
    MapDrawLine(EX - 1,	EY - 1,	SX,	EY - 1);
    MapDrawLine(SX,	EY - 1,	SX,	SY);
}

void MapFillRectangle(INT16 SX, INT16 SY, INT16 EX, INT16 EY)
{
    INT16		H;
    INT16		i;

    if (SY > EY) {
	H = EX, EX = SX, SX = H;
	H = EY, EY = SY, SY = H;
    }
    H = (EY - SY);

    for (i = 0; i < H; i++) {
	MapDrawLine(SX, SY + i, EX, SY + i);
    }
}

void MapDrawTriangle(INT16 xStart, INT16 yStart, INT16 Size, BYTE Level, BYTE Dir)
{
    INT16		Height;

    if (Dir)						// Down
	Height =  (Size * 1732 / 2000 / Level);
    else						// Up
	Height = -(Size * 1732 / 2000 / Level);
    MapDrawLineWidth(xStart, yStart, xStart - Size / 2, yStart - Height);
    MapDrawLineWidth(xStart, yStart, xStart + Size / 2, yStart - Height);
    MapDrawLineWidth(xStart - Size / 2, yStart - Height,
		     xStart + Size / 2, yStart - Height);
}

void MapFillTriangle(INT16 xStart, INT16 yStart, INT16 Size, BYTE Level, BYTE Dir)
{
    INT16		i;
    INT16		Height;

    if (Dir)						// Down
	Height =  (Size * 1732 / 2000 / Level);
    else						// Up
	Height = -(Size * 1732 / 2000 / Level);
    for (i = 0; i < Size; i++) {
	MapDrawLineWidth(xStart, yStart,
			 xStart - Size / 2 + i, yStart - Height);
    }
}

void MapDrawString(INT16 xStart, INT16 yStart, BYTE *Str)
{
    BYTE	       *pFont;
    BYTE		FontIndex;
    UINT32		FontCount;
    UINT16		FontHigh, FontWidth;
    UINT32		BitMap;
    UINT32		FontMap;
    INT16		xPoint, yPoint;
    UINT16		i, j;
    BYTE		c, d;

    FontIndex = 0;
    if (MapFontSize == 24)
	FontHigh = 24;
    else
	FontHigh = 16;
    while ((c = ((BYTE *) Str)[FontIndex]) != '\0') {
	d = ((BYTE *) Str)[FontIndex + 1];
	if (c < 161 || d < 161) {		// ASCII char
	    if (MapFontSize == 24) {
		if (c < ' ') c = ' ';
		FontWidth = 12;
		FontCount = c - ' ';
		pFont = (BYTE *)(ASC24 + FontCount * FontHigh * (FontWidth + 4) / 8);
	    }
	    else {
		FontWidth = 8;
		FontCount = c;
		pFont = (BYTE *)(ASC16 + FontCount * FontHigh * FontWidth / 8);
	    }
	}
	else {
	    if (MapFontSize == 24) {
		FontWidth = 24;
		FontCount = (c - 160 - 16) * 94 + (d - 160 - 1);
		pFont = (BYTE *)(HZK24 + 72 * FontCount);
	    }
	    else {
		FontWidth = 16;
		FontCount = (c - 160 - 1) * 94 + (d - 160 - 1);
		pFont = (BYTE *)(HZK16 + 32 * FontCount);
	    }
	}

	for (i = 0; i < FontHigh; i++) {
	    if (c < 161 || d < 161) {		// ASCII char
		if (MapFontSize == 24) {
		    FontMap = (pFont[i * 2] << 8) | pFont[i * 2 + 1];
		    BitMap = 0x8000;
		}
		else {
		    FontMap = pFont[i];
		    BitMap = 0x80;
		}
	    }
	    else {
		if (MapFontSize == 24) {
		    FontMap = (pFont[i * 3] << 16) | (pFont[i * 3 + 1] << 8) |
			      (pFont[i * 3 + 2]);
		    BitMap = 0x800000;
		}
		else {
		    FontMap = (pFont[i * 2] << 8) | pFont[i * 2 + 1];
		    BitMap = 0x8000;
		}
	    }

	    for (j = 0; j < FontWidth; j++) {
		if (MapFontSize == 24)
		    xPoint = xStart + j + FontIndex * 12;
		else if (MapFontSize == 32)
		    xPoint = xStart + (j + FontIndex * 8) * 2;
		else
		    xPoint = xStart + j + FontIndex * 8;
		if (MapFontSize == 32)
		    yPoint = yStart + i * 2;
		else
		    yPoint = yStart + i;

		if (FontMap & BitMap) {
		    __plotXY(xPoint, yPoint);
		    if (MapFontSize == 32) {
			__plotXY(xPoint,     yPoint + 1);
			__plotXY(xPoint + 1, yPoint    );
			__plotXY(xPoint + 1, yPoint + 1);
		    }
		}
		BitMap >>= 1;
	    }
	}

	if (c < 161 || d < 161)			// ASCII char
	    FontIndex++;
	else
	    FontIndex += 2;
    }
}

void MapFillString(INT16 xStart, INT16 yStart, BYTE *Str)
{
    BYTE	       *pFont;
    BYTE		FontIndex;
    UINT32		FontCount;
    UINT16		FontHigh, FontWidth;
    UINT32		BitMap;
    UINT32		FontMap;
    COLOR		TempColor;
    INT16		xPoint, yPoint;
    UINT16		i, j;
    BYTE		c, d;

    FontIndex = 0;
    if (MapFontSize == 24)
	FontHigh = 24;
    else
	FontHigh = 16;
    while ((c = ((BYTE *) Str)[FontIndex]) != '\0') {
	d = ((BYTE *) Str)[FontIndex + 1];
	if (c < 161 || d < 161) {		// ASCII char
	    if (MapFontSize == 24) {
		if (c < ' ') c = ' ';
		FontWidth = 12;
		FontCount = c - ' ';
		pFont = (BYTE *)(ASC24 + FontCount * FontHigh * (FontWidth + 4) / 8);
	    }
	    else {
		FontWidth = 8;
		FontCount = c;
		pFont = (BYTE *)(ASC16 + FontCount * FontHigh * FontWidth / 8);
	    }
	}
	else {
	    if (MapFontSize == 24) {
		FontWidth = 24;
		FontCount = (c - 160 - 16) * 94 + (d -160 - 1);
		pFont = (BYTE *)(HZK24 + 72 * FontCount);
	    }
	    else {
		FontWidth = 16;
		FontCount = (c - 160 - 1) * 94 + (d -160 - 1);
		pFont = (BYTE *)(HZK16 + 32 * FontCount);
	    }
	}

	for (i = 0; i < FontHigh; i++) {
	    if (c < 161 || d < 161) {		// ASCII char
		if (MapFontSize == 24) {
		    FontMap = (pFont[i * 2] << 8) | pFont[i * 2 + 1];
		    BitMap = 0x8000;
		}
		else {
		    FontMap = pFont[i];
		    BitMap = 0x80;
		}
	    }
	    else {
		if (MapFontSize == 24) {
		    FontMap = (pFont[i * 3] << 16) | (pFont[i * 3 + 1] << 8) |
			      (pFont[i * 3 + 2]);
		    BitMap = 0x800000;
		}
		else {
		    FontMap = (pFont[i * 2] << 8) | pFont[i * 2 + 1];
		    BitMap = 0x8000;
		}
	    }

	    for (j = 0; j < FontWidth; j++) {
		if (MapFontSize == 24)
		    xPoint = xStart + j + FontIndex * 12;
		else if (MapFontSize == 32)
		    xPoint = xStart + (j + FontIndex * 8) * 2;
		else
		    xPoint = xStart + j + FontIndex * 8;
		if (MapFontSize == 32)
		    yPoint = yStart + i * 2;
		else
		    yPoint = yStart + i;

		if (FontMap & BitMap) {
		    __plotXY(xPoint, yPoint);
		    if (MapFontSize == 32) {
			__plotXY(xPoint,     yPoint + 1);
			__plotXY(xPoint + 1, yPoint    );
			__plotXY(xPoint + 1, yPoint + 1);
		    }
		}
		else {
		    TempColor = MapColor;
		    MapColor = MapBackColor;
		    __plotXY(xPoint, yPoint);
		    if (MapFontSize == 32) {
			__plotXY(xPoint,     yPoint + 1);
			__plotXY(xPoint + 1, yPoint    );
			__plotXY(xPoint + 1, yPoint + 1);
		    }
		    MapColor = TempColor;
		}
		BitMap >>= 1;
	    }
	}

	if (c < 161 || d < 161)			// ASCII char
	    FontIndex++;
	else
	    FontIndex += 2;
    }
}

void MapDrawFontMap(INT16 xStart, INT16 yStart, BYTE *pFont, BYTE Len)
{
    BYTE		FontIndex;
    UINT16		FontHigh, FontWidth;
    UINT32		BitMap;
    UINT32		FontMap;
    INT16		xPoint, yPoint;
    UINT16		i, j;

    FontIndex = 0;
    FontHigh = 24;
    FontWidth = 24;

    for (FontIndex = 0; FontIndex < Len; FontIndex++) {
	for (i = 0; i < FontHigh; i++) {
	    j = FontIndex * 72 + i * 3;
	    FontMap = (pFont[j] << 16) | (pFont[j + 1] << 8) | (pFont[j + 2]);
	    BitMap = 0x800000;

	    for (j = 0; j < FontWidth; j++) {
		xPoint = xStart + j + FontIndex * 24;
		yPoint = yStart + i;

		if (FontMap & BitMap) {
		    __plotXY(xPoint, yPoint);
		}
		BitMap >>= 1;
	    }
	}
    }
}

void MapDrawFontPart(INT16 xStart, INT16 yStart, BYTE *pChar, BYTE bStart, BYTE bLen)
{
    BYTE	       *pFont;
    UINT16		FontHigh, FontWidth;
    UINT32		BitMap;
    UINT32		FontMap;
    INT16		xPoint, yPoint;
    UINT16		i, j;
    BYTE		c, d;

    if (MapFontSize == 24)
	FontHigh = 24;
    else
	FontHigh = 16;

    if (MapFontSize == 32) {
	bLen >>= 1;
	bStart >>= 1;
    }

    c = *(pChar);
    d = *(pChar + 1);
    if (c < 161 || d < 161) {			// ASCII char
	if (MapFontSize == 24) {
	    if (c < ' ') c = ' ';
	    FontWidth = 12;
	    pFont = (BYTE *)(ASC24 + (c - ' ') * FontHigh * (FontWidth + 4) / 8);
	}
	else {
	    FontWidth = 8;
	    pFont = (BYTE *)(ASC16 + c * FontHigh * FontWidth / 8);
	}
    }
    else {
	if (MapFontSize == 24) {
	    FontWidth = 24;
	    pFont = (BYTE *)(HZK24 + 72 * ((c - 160 - 16) * 94 + (d -160 - 1)));
	}
	else {
	    FontWidth = 16;
	    pFont = (BYTE *)(HZK16 + 32 * ((c - 160 - 1) * 94 + (d -160 - 1)));
	}
    }

    for (i = 0; i < FontHigh; i++) {
	if (c < 161 || d < 161) {		// ASCII char
	    if (MapFontSize == 24) {
		FontMap = (pFont[i * 2] << 8) | pFont[i * 2 + 1];
		BitMap = 0x8000;
	    }
	    else {
		FontMap = pFont[i];
		BitMap = 0x80;
	    }
	}
	else {
	    if (MapFontSize == 24) {
		FontMap = (pFont[i * 3] << 16) | (pFont[i * 3 + 1] << 8) |
			  (pFont[i * 3 + 2]);
		BitMap = 0x800000;
	    }
	    else {
		FontMap = (pFont[i * 2] << 8) | pFont[i * 2 + 1];
		BitMap = 0x8000;
	    }
	}

	BitMap >>= bStart;
	for (j = 0; j < bLen; j++) {
	    if (MapFontSize == 32) {
		xPoint = xStart + (j << 1);
		yPoint = yStart + (i << 1);
	    }
	    else {
		xPoint = xStart + j;
		yPoint = yStart + i;
	    }

	    if (FontMap & BitMap) {
		__plotXY(xPoint, yPoint);
		if (MapFontSize == 32) {
		    __plotXY(xPoint,     yPoint + 1);
		    __plotXY(xPoint + 1, yPoint    );
		    __plotXY(xPoint + 1, yPoint + 1);
		}
	    }
	    BitMap >>= 1;
	}
    }
}

static const UINT32	Color16Tbl[] = {
/* 0x00 */	0x000000,		// Blank
/* 0x01 */	GPS_BLOCK_COLOR_6,	// Earth Yellow
/* 0x02 */	GPS_BLOCK_COLOR_4,	// Pink
/* 0x03 */	0x808080,		// Grey
/* 0x04 */	MAP_COLOR_YELLOW,	// Yellow
/* 0x05 */	MAP_COLOR_WHITE,	// White
/* 0x06 */	MAP_COLOR_BLUE,		// Light Blue
/* 0x07 */	MAP_COLOR_BLACK,	// Black
/* 0x08 */	0x1090b0,		// Purple
/* 0x09 */	0x6060ff,
/* 0x0A */	MAP_COLOR_GREEN,	// Green
/* 0x0B */	0x00b0b0,
/* 0x0C */	0x868686,
/* 0x0D */	0xbcbcbc,
/* 0x0E */	0xb0b0ff,
/* 0x0F */	MAP_COLOR_RED,		// Red
};

void MapDrawIcon(INT16 xStart, INT16 yStart, BYTE *pFont)
{
    INT16		xPoint, yPoint;
    INT16		i, j;
    BYTE		FontData;

    for (i = 0; i < 24; i++) {
	for (j = 0; j < 12; j++) {
	    FontData = pFont[i * 12 + j];
	    xPoint = xStart + 2 * j;
	    yPoint = yStart + i;
	    if (FontData & 0xf0) {
		MapSetColor(Color16Tbl[(FontData >> 4) & 0x0f]);
		__plotXY(xPoint, yPoint);
	    }

	    if (FontData & 0x0f) {
		MapSetColor(Color16Tbl[(FontData >> 0) & 0x0f]);
		__plotXY(xPoint + 1, yPoint);
	    }
	}
    }
}

void MapDrawRound(INT16 xStart, INT16 yStart, INT16 R)
{
    INT16		i, j;

    for (i = xStart - R; i <= xStart + R; i++) {
    	for (j = yStart - R; j <= yStart + R; j++) {
	    if ((abs(i - xStart) * abs(i - xStart) +
		 abs(j - yStart) * abs(j - yStart)) < (R * R)) {
		if (MapPointInWindow(i, j)) {
		    __plotXY(i, j);
		}
	    }
	}
    }
}

static void MapDrawCirclePart(INT16 xCenter, INT16 yCenter, INT16 R, BYTE Area)
{
    INT16		AX, AY;
    INT16		DX, DY, DS;

    AX = 0;
    AY = R;
    DX = 3;
    DY = (1 - R) << 1;
    DS = (1 - R);

    while (AX < AY) {
	switch (Area) {
	case 1:
	    __plotXY(xCenter + AX, yCenter - AY);
	    __plotXY(xCenter + AY, yCenter - AX);
	    break;
	case 2:
	    __plotXY(xCenter + AX, yCenter + AY);
	    __plotXY(xCenter + AY, yCenter + AX);
	    break;
	case 3:
	    __plotXY(xCenter - AX, yCenter + AY);
	    __plotXY(xCenter - AY, yCenter + AX);
	    break;
	case 4:
	    __plotXY(xCenter - AX, yCenter - AY);
	    __plotXY(xCenter - AY, yCenter - AX);
	    break;
	}

	if (DS < 0) {
	    DS += DX;
	    DX += 2;
	    AX++;
	}
	else {
	    DS += DX + DY;
	    DX += 2;
	    DY += 2;
	    AX++;
	    AY--;
	}
    }
}

void MapDrawCircle(INT16 xCenter, INT16 yCenter, INT16 R)
{
    MapDrawCirclePart(xCenter, yCenter, R, 1);
    MapDrawCirclePart(xCenter, yCenter, R, 2);
    MapDrawCirclePart(xCenter, yCenter, R, 3);
    MapDrawCirclePart(xCenter, yCenter, R, 4);
}

void MapDrawCircleRect(INT16 SX, INT16 SY, INT16 DX, INT16 DY, INT16 R)
{
    MapDrawLine(SX + R,	     SY,	  SX + DX - 1 - R, SY);
    MapDrawLine(SX + R,	     SY + DY - 1, SX + DX - 1 - R, SY + DY - 1);
    MapDrawLine(SX,	     SY + R,      SX,		   SY + DY - 1 - R);
    MapDrawLine(SX + DX - 1, SY + R,      SX + DX - 1,     SY + DY - 1 - R);