/////////////////////////////////////////////////////////////////
// __ ____ _______ ______ //
// /\ \ / / / /\ ____\ / _____\ //
// \ \ \ / / / \ \ \___/ /\ \____/ //
// \ \ \ / / / \ \ \_____ \ \ \________ //
// \ \ \ / / / \ \ ____\ \ \ _______ \ //
// \ \ \ / / / \ \ \___/ \/_______/\ \ V //
// \ \ \_/ / \ \ \______ ____\_\ \ E S //
// \ \___/ \ \_______\ /\_______/ V A E //
// \/__/ \/_______/ \_______/ S A //
///////////////////////////////////////////////////////////// //
/////// 分辨率----位数----色深--------页数-----显存需求量 // //
///////////////////////////////////////////////////////////// //
// 640*480*8Bit----256-Colors----5-Pages-----512K //
// 640*480*16Bit---64K-Colors----10-Pages----1M //
// 800*600*8Bit----256-Colors----8-Pages-----512K //
// 800*600*16Bit---64K-Colors----16-Pages----1M //
// 1024*768*8Bit---256-Colors----12-Pages----1M //
// 1024*768*16Bit--64K-Colors----24-Pages----2M //
//////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////
#include <stdio.h>
#include <stdlib.h>
#include <dos.h>
#include <string.h>
#include <conio.h>

#define FALSE 0
#define TRUE 1
#define SOLID_FILL 1 // fills area in solid fill color
#define S8X8 8 // 8*8 获取ASCII ROM字符集首地址
#define S14X8 14 // 14*8 获取ASCII ROM字符集首地址
#define S16X8 16 // 16*8 获取ASCII ROM字符集首地址
#define VBE800X600X256 0x103
#define VRAM_GRAPH_800X600X256(x,y) (((unsigned long)y<<9L)+((unsigned long)y<<8L)+((unsigned long)y<<5L)+((unsigned long)(x)))

#define DIALOG_TITLE_BK_COLOR LIGHTBLUE // 对话框标题条背景颜色
#define DIALOG_TITLE_TEXT_COLOR BLACK // 对话框标题条文本颜色
#define DIALOG_TEXT_BK_COLOR LIGHTGRAY // 对话框背景颜色
typedef unsigned int BOOL; // 布尔类型
typedef unsigned int XMS_HANDLE; // XMS句柄类型
//////////////////////////////////////////////////////////////////////////////
/////XMS规范使用扩充内存所用的数据结构
//////////////////////////////////////////////////////////////////////////////
typedef struct XMS
{
unsigned long length; // 需传输的数据字节数(32位)
XMS_HANDLE source_handle; // 源数据块句柄
unsigned long source_offset; // 源偏移量(32位)
XMS_HANDLE dest_handle; // 目标数据块句柄
unsigned long dest_offset; // 目标偏移量(32位)
};
//////////////////////////////////////////////////////////////////////////////
////窗口区域保存结构体
//////////////////////////////////////////////////////////////////////////////
struct GUI_STACK
{
unsigned int x1;
unsigned int y1;
unsigned int x2;
unsigned int y2;
XMS_HANDLE handle; // XMS句柄
};

typedef struct
{
// enum WINDOW_TYPE;
char no;
char *chinese_name;
int number;
char unit;
char *help_name;
union
{
struct
{
int min;
int max;
char dot;
}a;
struct
{
int MENU_min;
int MENU_max;
char *MENU_chinese_name;
}b;
}c;
}BOOT_KING,*BOOT_KING_PTR;

void far (*XMS_Function)(void) = 0L;// XMS服务程序入口地址
XMS_HANDLE xms_handle; // 伪指针
int g_cur_vbe_page = 0;
int GUI_SP = 0; // 弹出式堆栈指针
unsigned char far *ROM_ASCII;
int Back_Color,Fore_Color,Fill_Color;
struct XMS xms;
struct GUI_STACK GUI_Stack[10]; // 弹出式堆栈

int _Cdecl TOP_X1(void);
int _Cdecl TOP_X2(void);
int _Cdecl TOP_Y1(void);
int _Cdecl TOP_Y2(void);
int _Cdecl TOP_Handle(void);
int _Cdecl BOTTOM_X1(void);
int _Cdecl BOTTOM_X2(void);
int _Cdecl BOTTOM_Y1(void);
int _Cdecl BOTTOM_Y2(void);
BOOL _Cdecl Stack_Empty(void);
BOOL _Cdecl Stack_Full(void);
BOOL _Cdecl PUSH_Stack(int x1,int y1,int x2,int y2,XMS_HANDLE handle);
BOOL _Cdecl POP_Stack(void);
void _Cdecl setfillstyle(int __pattern,int color);
void _Cdecl setcolor(int color);
int _Cdecl getcolor(void);
void _Cdecl setbkcolor(int color);
int _Cdecl getbkcolor(void);
int _Cdecl getfillcolor(void);
BOOL _Cdecl XMS_Test(void);
unsigned int _Cdecl XMS_Version(void);
int _Cdecl XMS_Size(void);
BOOL _Cdecl XMS_Alloc(int size);
int _Cdecl XMS_ReAlloc(XMS_HANDLE handle,int resize);
BOOL _Cdecl XMS_Free(XMS_HANDLE handle);
BOOL _Cdecl XMS_Move(struct XMS *xms);
void _Cdecl Write_To_XMS(char *buf,unsigned int size,XMS_HANDLE handle,unsigned long offset);
void _Cdecl Read_From_XMS(char *buf,unsigned int size,XMS_HANDLE handle,unsigned long offset);
void _Cdecl ReadHzkXMS(char *Hzkname);
void _Cdecl HzkFree(void);
void _Cdecl ReadHzkBit(unsigned char *qw,unsigned char *buf);
unsigned char far *Get_ASCII_ROM(unsigned int BX);
unsigned char far *Current_ASCII_ROM(int ch);
void _Cdecl set_vbe_page(int page);
char _Cdecl GetPixel(int x, int y);
void _Cdecl Common_PutPixel(int x,int y,int color);
void _Cdecl PutPixel(int x,int y,int color);
void _Cdecl POPUP_PutPixel(int x,int y,int color);
void _Cdecl puthz(int x,int y,char *p,int color,int d);
void _Cdecl POPUP_puthz(int x,int y,char *p,int color,int d);
void _Cdecl Vline(int x, int y1, int y2);
void _Cdecl POPUP_Vline(int x, int y1, int y2);
void _Cdecl Hline(int x1, int y, int x2);
void _Cdecl POPUP_Hline(int x1, int y, int x2);
void _Cdecl Line(int x1,int y1,int x2,int y2);
void _Cdecl Rectangle(int x1,int y1,int x2,int y2);
void _Cdecl POPUP_Rectangle(int x1,int y1,int x2,int y2);
void _Cdecl Bar(int x1, int y1, int x2, int y2);
void _Cdecl POPUP_Bar(int x1, int y1, int x2, int y2);
void _Cdecl Circle(int c_x, int c_y, int r);
void _Cdecl CircleFill(int x0, int y0, int r);
void _Cdecl InitGraph(void);
void _Cdecl CloseGraph(void);
BOOL _Cdecl Save_Image_XMS(int x1,int y1,int x2,int y2);
void _Cdecl Restore_Image_XMS(void);
/////////////////////////////////////////////////////////////////////////////////////////////////
////测试堆栈是否为空
/////////////////////////////////////////////////////////////////////////////////////////////////
BOOL _Cdecl Stack_Empty(void)
{
if (GUI_SP == 0)
return (TRUE);
return (FALSE);
}

/////////////////////////////////////////////////////////////////////////////////////////////////
////测试堆栈是否溢出
/////////////////////////////////////////////////////////////////////////////////////////////////
BOOL _Cdecl Stack_Full(void)
{
if (GUI_SP == 3)
return (TRUE);
return (FALSE);
}

/////////////////////////////////////////////////////////////////////////////////////////////////
////窗口区域及窗口句柄入栈
/////////////////////////////////////////////////////////////////////////////////////////////////
BOOL _Cdecl PUSH_Stack(int x1,int y1,int x2,int y2,XMS_HANDLE handle)
{
if (!Stack_Full())
{
GUI_SP++;
GUI_Stack[GUI_SP].x1 = x1;
GUI_Stack[GUI_SP].y1 = y1;
GUI_Stack[GUI_SP].x2 = x2;
GUI_Stack[GUI_SP].y2 = y2;
GUI_Stack[GUI_SP].handle = handle;
return (TRUE);
}
return (FALSE);
}

/////////////////////////////////////////////////////////////////////////////////////////////////
////窗口区域及窗口句柄出栈
/////////////////////////////////////////////////////////////////////////////////////////////////
BOOL _Cdecl POP_Stack(void)
{
if (!Stack_Empty())
{
GUI_SP--;
return (TRUE);
}
return (FALSE);
}

/////////////////////////////////////////////////////////////////////////////////////////////////
////获取栈顶.x1
/////////////////////////////////////////////////////////////////////////////////////////////////
int _Cdecl TOP_X1(void)
{
return (GUI_Stack[GUI_SP].x1);
}

/////////////////////////////////////////////////////////////////////////////////////////////////
////获取栈顶.x2
/////////////////////////////////////////////////////////////////////////////////////////////////
int _Cdecl TOP_X2(void)
{
return (GUI_Stack[GUI_SP].x2);
}

/////////////////////////////////////////////////////////////////////////////////////////////////
////获取栈顶.y1
/////////////////////////////////////////////////////////////////////////////////////////////////
int _Cdecl TOP_Y1(void)
{
return (GUI_Stack[GUI_SP].y1);
}

/////////////////////////////////////////////////////////////////////////////////////////////////
////获取栈顶.y2
/////////////////////////////////////////////////////////////////////////////////////////////////
int _Cdecl TOP_Y2(void)
{
return (GUI_Stack[GUI_SP].y2);
}

/////////////////////////////////////////////////////////////////////////////////////////////////
////获取栈顶.handle
/////////////////////////////////////////////////////////////////////////////////////////////////
int _Cdecl TOP_Handle(void)
{
return (GUI_Stack[GUI_SP].handle);
}

/////////////////////////////////////////////////////////////////////////////////////////////////
////获取栈底.x1
/////////////////////////////////////////////////////////////////////////////////////////////////
int _Cdecl BOTTOM_X1(void)
{
return (GUI_Stack[1].x1);
}

/////////////////////////////////////////////////////////////////////////////////////////////////
////获取栈底.x2
/////////////////////////////////////////////////////////////////////////////////////////////////
int _Cdecl BOTTOM_X2(void)
{
return (GUI_Stack[1].x2);
}

/////////////////////////////////////////////////////////////////////////////////////////////////
////获取栈底.y1
/////////////////////////////////////////////////////////////////////////////////////////////////
int _Cdecl BOTTOM_Y1(void)
{
return (GUI_Stack[1].y1);
}

/////////////////////////////////////////////////////////////////////////////////////////////////
////获取栈底.y2
/////////////////////////////////////////////////////////////////////////////////////////////////
int _Cdecl BOTTOM_Y2(void)
{
return (GUI_Stack[1].y2);
}

/////////////////////////////////////////////////////////////////////////////////////////////////
// 设置 bar 填充颜色(同 Turbo C)
/////////////////////////////////////////////////////////////////////////////////////////////////
void _Cdecl setfillstyle(int __pattern,int color)
{
__pattern++; // no use
Fill_Color = color;
}

/////////////////////////////////////////////////////////////////////////////////////////////////
// 设置前景色(同 Turbo C)
/////////////////////////////////////////////////////////////////////////////////////////////////
void _Cdecl setcolor(int color)
{
Fore_Color = color;
}

/////////////////////////////////////////////////////////////////////////////////////////////////
// 获取前景色(同 Turbo C)
/////////////////////////////////////////////////////////////////////////////////////////////////
int _Cdecl getcolor(void)
{
return (Fore_Color);
}

/////////////////////////////////////////////////////////////////////////////////////////////////
// 设置背景色(同 Turbo C)
/////////////////////////////////////////////////////////////////////////////////////////////////
void _Cdecl setbkcolor(int color)
{
Back_Color = color;
}

/////////////////////////////////////////////////////////////////////////////////////////////////
// 获取背景色(同 Turbo C)
/////////////////////////////////////////////////////////////////////////////////////////////////
int _Cdecl getbkcolor(void)
{
return (Back_Color);
}

/////////////////////////////////////////////////////////////////////////////////////////////////
// 获取填充色
/////////////////////////////////////////////////////////////////////////////////////////////////
int _Cdecl getfillcolor(void)
{
return (Fill_Color);
}

/////////////////////////////////////////////////////////////////////////////////////////////////
//检测XMS是否安装
// INT 2F - XMS 驱动程序安装检测
// 输入参数:AX = 4300h
// 返回值: AL = 80h XMS 驱动程序已安装
// AL <> 80h 未发现XMS 驱动程序
// 注: XMS 使你可以访问扩充内存以及其它的高于640K的非EMS内存,
// 其它程序不得使用与之相同的安装检测方式
/////////////////////////////////////////////////////////////////////////////////////////////////
BOOL _Cdecl XMS_Test(void)
{
_AX = 0x4300;
__int__(0x2F);
if (_AL == 0x80) // 检查XMS驱动程序是否已经安装
{
_AX = 0x4310;
__int__(0x2F); // 取得XMS功能调用的地址
XMS_Function=(void far *)MK_FP(_ES,_BX); // 返回值:ES:BX -> 驱动程序入口地址
return (TRUE);
}
return (FALSE);
}

/////////////////////////////////////////////////////////////////////////////////////////////////
// 说明： 获取XMS驱动器版本号
// 参数： 返回参数: XMS驱动器版本号
/////////////////////////////////////////////////////////////////////////////////////////////////
unsigned int _Cdecl XMS_Version(void)
{
_AH = 0x00;
(XMS_Function)();
return (_AX);
}

/////////////////////////////////////////////////////////////////////////////////////////////////
//查询空闲的扩充内存空间(不包括HMA)
//输入参数:AH = 08h
//返回值:AX = 最大的扩充内存块的大小(单位:K)
//DX = 总的扩充内存块的大小(单位:K)
//AX = 最大的扩充内存块的大小(单位:K)
//BL = 错误代码
/////////////////////////////////////////////////////////////////////////////////////////////////
int _Cdecl XMS_Size(void)
{
_AH = 0x08;
XMS_Function();
return (_DX);
}

/////////////////////////////////////////////////////////////////////////////////////////////////
//分配扩充内存
//输入参数:AH = 09h
// DX = 要求分配的内存块大小(单位:K)
//返回值:
// AX = 0001h 成功
// DX = 内存块的句柄
// AX = 0000h 失败
// BL = 错误代码
/////////////////////////////////////////////////////////////////////////////////////////////////
BOOL _Cdecl XMS_Alloc(int size)
{
_DX = size; // 扩充内存块大小,单位为K字节
_AH = 0x09;
XMS_Function();
if(_AX == 1)
return (_DX);
return (FALSE);
}

/////////////////////////////////////////////////////////////////////////////////////////////////
// 为句柄重新分配内存
// 输入参数:AH = 0Fh
// DX = 句柄
// BX = 新的块的容量(单位:K)
// 返回值:
// AX = 0001h 成功
// = 0000h 失败
// BL = 错误代码
/////////////////////////////////////////////////////////////////////////////////////////////////
int _Cdecl XMS_ReAlloc(XMS_HANDLE handle,int resize)
{
_AH = 0x0F;
_DX = handle;
_BX = resize;
(XMS_Function)();
if (_AX)
{
XMS_Size();
return (handle);
}
return (-1);
}

/////////////////////////////////////////////////////////////////////////////////////////////////
// 释放指定句柄所分配的扩充内存
// 输入参数:AH = 0Ah
// DX = 内存块的句柄
// 返回值:
// AX = 0001h 成功
// = 0000h 失败
// BL = 错误代码
/////////////////////////////////////////////////////////////////////////////////////////////////
BOOL _Cdecl XMS_Free(XMS_HANDLE handle)
{
_DX = handle;
_AH = 0x0A;
XMS_Function();
if(_AX)
return (TRUE);
return (FALSE);
}

/////////////////////////////////////////////////////////////////////////////////////////////////
//扩充内存和常规内存中的数据交换(移动扩充内存块)
// 移动扩充内存块
// 输入参数:
// AH = 0Bh
// DS:SI -> XMS 结构
// 返回值:
// AX = 0001h 成功
// = 0000h 失败
// BL = 错误代码
// 注: 如果结构中任一句柄为0000h, 那么其对应32位偏移量将被视为常规内存的绝对地址
/////////////////////////////////////////////////////////////////////////////////////////////////
BOOL _Cdecl XMS_Move(struct XMS *xms)
{
_DS = FP_SEG(xms);
_SI = FP_OFF(xms);
_AH = 0x0B;
XMS_Function();
if (_AX)
return (TRUE);
return (FALSE);
}

/////////////////////////////////////////////////////////////////////////////////////////////////
//将汉字库点阵字模从常规内存缓冲区buf装载到扩充内存
/////////////////////////////////////////////////////////////////////////////////////////////////
void _Cdecl Write_To_XMS(char *buf,unsigned int size,XMS_HANDLE handle,unsigned long offset)
{
xms.length = size;
xms.source_handle = 0;
xms.source_offset = FP_SEG((void far *)buf);
xms.source_offset <<= 16;
xms.source_offset += FP_OFF((void far *)buf);
xms.dest_handle = handle;
xms.dest_offset = offset;
XMS_Move(&xms);
}

/////////////////////////////////////////////////////////////////////////////////////////////////
//从扩充内存中读取汉字点阵字模到常规内存缓冲区buf
/////////////////////////////////////////////////////////////////////////////////////////////////
void _Cdecl Read_From_XMS(char *buf,unsigned int size,XMS_HANDLE handle,unsigned long offset)
{
xms.length = size;
xms.source_handle = handle;
xms.source_offset = offset;
xms.dest_handle = 0;
xms.dest_offset = FP_SEG((void far *)buf);
xms.dest_offset <<= 16;
xms.dest_offset += FP_OFF((void far *)buf);
XMS_Move(&xms);
}

/////////////////////////////////////////////////////////////////////////////////////////////////
//汉字库点阵装载到扩充内存
/////////////////////////////////////////////////////////////////////////////////////////////////
void _Cdecl ReadHzkXMS(char *Hzk16)
{
unsigned long hzksize;
unsigned int size;
unsigned long offset = 0;
char buf[32];
FILE *fp;

if (!XMS_Test())
{
puts("not found XMS");
exit(1);
}
if ((fp = fopen(Hzk16,"rb")) == NULL)
{
puts("Cannot Open HZK16 ...\n");
exit(1);
}
fseek(fp,0L,SEEK_END);
hzksize = ftell(fp);
fseek(fp,0L,SEEK_SET);
size = (int)(hzksize>>10) +1;
if (XMS_Size() < size)
{
puts("not enough XMS");
fclose(fp);
exit(-1);
}
if ((xms_handle = XMS_Alloc(size)) == 0)
{
puts("XMS handle Error...");
fclose(fp);
exit(-1);
}
while (!feof(fp))
{
size = fread(buf,sizeof(char),32,fp);
Write_To_XMS(buf,size,xms_handle,offset);
offset += size;
}
fclose(fp);
ROM_ASCII = Current_ASCII_ROM(S16X8);
}

/////////////////////////////////////////////////////////////////////////////////////////////////
// 释放XMS内存
/////////////////////////////////////////////////////////////////////////////////////////////////
void _Cdecl HzkFree(void)
{
XMS_Free(xms_handle);
}

/////////////////////////////////////////////////////////////////////////////////////////////////
// 汉字点阵字模从XMS读到缓冲区buf中
/////////////////////////////////////////////////////////////////////////////////////////////////
void _Cdecl ReadHzkBit(unsigned char *qw,unsigned char *buf)
{
unsigned short QM,WM;
long offset;

QM = *qw - 160;
WM = *(qw+1) - 160;
offset = ((QM-1)*94+WM-1)*32L;
Read_From_XMS(buf,32,xms_handle,offset);
}

/////////////////////////////////////////////////////////////////////////////////////////////////
//获得 ASCII ROM字符集首址
/////////////////////////////////////////////////////////////////////////////////////////////////
unsigned char far *Get_ASCII_ROM(unsigned int BX)
{
_AX = 0x1130;
_BX = BX;
__int__(0x10);
return (unsigned char far *)MK_FP(_ES,_BP);

}

/////////////////////////////////////////////////////////////////////////////////////////////////
//获得 8X8或14X8或16X8英文字模基地址
/////////////////////////////////////////////////////////////////////////////////////////////////
unsigned char far *Current_ASCII_ROM(int ch)
{
switch(ch)
{
case S8X8:
return (Get_ASCII_ROM(0x0300));
case S14X8:
return (Get_ASCII_ROM(0x0200));
case S16X8:
return (Get_ASCII_ROM(0x0600));
default:
return (Get_ASCII_ROM(0x0600));
}
}

/////////////////////////////////////////////////////////////////////////////////////////////////
//显存换页函数
/////////////////////////////////////////////////////////////////////////////////////////////////
void _Cdecl set_vbe_page(int page)
{
if (g_cur_vbe_page != page)
{
_BX = 0;
_DX = g_cur_vbe_page = page;
_AX = 0x4F05;
__int__(0x10);
}
}

/////////////////////////////////////////////////////////////////////////////////////////////////
//读像素点函数
/////////////////////////////////////////////////////////////////////////////////////////////////
char _Cdecl GetPixel(int x, int y)
{
long addr;
int page;
char far *videoptr = (char far *)0xa0000000L;

addr = VRAM_GRAPH_800X600X256(x,y);
page = (int)(addr >> 16);
set_vbe_page(page);
return *(videoptr + (unsigned)(addr & 0xffff));
// return (peekb(0xa000, (unsigned)(addr & 0xFFFF) ));
}

/////////////////////////////////////////////////////////////////////////////////////////////////
//画点函数
/////////////////////////////////////////////////////////////////////////////////////////////////
void _Cdecl Common_PutPixel(int x,int y,int color)
{
int page;
long addr;
char far *videoptr = (char far *)0xa0000000L;

if (x < 800 && y < 600)
{
addr = VRAM_GRAPH_800X600X256(x,y);
page = (int)(addr >> 16);
set_vbe_page(page);
// pokeb(0xa000, (unsigned)(addr & 0xFFFF),color);
*(videoptr+(unsigned int)(addr&0xffff))= color;
}
}

/////////////////////////////////////////////////////////////////////////////////////////////////
//画点函数
/////////////////////////////////////////////////////////////////////////////////////////////////
void _Cdecl PutPixel(int x,int y,int color)
{
unsigned char put_mark = TRUE;
unsigned int i;

if (!Stack_Empty())
{
for (i = 1 ; i <= GUI_SP; i++)
{
if ((x >= GUI_Stack[i].x1 && x <= GUI_Stack[i].x2) &&
(y >= GUI_Stack[i].y1 && y <= GUI_Stack[i].y2))
put_mark = FALSE;
}
}
if (put_mark)
Common_PutPixel(x,y,color);
}

/////////////////////////////////////////////////////////////////////////////////////////////////
//画点函数(弹出式窗口专用)
/////////////////////////////////////////////////////////////////////////////////////////////////
void _Cdecl POPUP_PutPixel(int x,int y,int color)
{
Common_PutPixel(x,y,color);
}

/////////////////////////////////////////////////////////////////////////////////////////////////
////中英文混合输出函数
////unsigned char mat[16][2],
////for(j=0;j<16;j++)
//// for(i=0;i<2;i++)
//// for(k=0;k<8;k++)
//// if(mat[j][i]&(0x80>>k))　/*测试为1的位则显示*/
//// putpixel(i*8+k,j,WHITE);
/////////////////////////////////////////////////////////////////////////////////////////////////
void _Cdecl puthz(int x,int y,char *p,int color,int d)
{
unsigned int i,j;
unsigned char ch;
unsigned char matrix[32];

while((ch=*p++)!=0)
{
if(ch>160)
{
p--;
ReadHzkBit(p,matrix);
for(j = 0 ; j < 16 ; j++)
for(i = 0 ; i < 16 ; i++)
if(matrix[2*j+i/8] & (0x80>>i%8))
PutPixel(i+x,y+j,color);
else
PutPixel(i+x,y+j,Back_Color);
p++;
p++;
x+=16+d;
}
else
{
for(i=0;i<16;i++)
{
matrix[i*2]=*(ROM_ASCII+(ch)*16+i);
matrix[i*2+1]=0; // 字模右边8位补0
}
for(j=0;j<16;j++)
for(i=0;i<8;i++)
if (matrix[2*j+i/8] & (0x80>>i%8))
PutPixel(i+x,y+j,color);
else
PutPixel(i+x,y+j,Back_Color);
x+=8+d;
/*-----------------------------------------------------------------------------------------------*/
// 如果采用8X8点阵字模显示英文及数字,请采用如下代码
/*-----------------------------------------------------------------------------------------------*/
/* for(i=0;i<8;i++)
buf[i]=*(ROM_ASCII+(ch)*8+i);
for(j=0;j<8;j++)
for(i=0;i<8;i++)
if((0x80>>i%8)&buf[j+i/8])
POPUP_PutPixel(i+x,y+j+5,color);
else
POPUP_PutPixel(i+x,y+j+5,Back_Color);
x+=8+d;*/
}
}
}

/////////////////////////////////////////////////////////////////////////////////////////////////
////中英文混合输出函数(弹出式窗口专用)
/////////////////////////////////////////////////////////////////////////////////////////////////
void _Cdecl POPUP_puthz(int x,int y,char *p,int color,int d)
{
unsigned int i,j;
unsigned char ch;
char buf[32];

while((ch=*p++)!=0)
{
if(ch>160)
{
p--;
ReadHzkBit(p,buf);
for (j=0;j<16;j++)
{
for (i=0;i<16;i++)
if ((0x80>>i%8)&buf[2*j+i/8])
POPUP_PutPixel(i+x,y+j,color);
else
POPUP_PutPixel(i+x,y+j,Back_Color);
POPUP_PutPixel(16+x,y+j,Back_Color);
}
p++;
p++;
x+=16+d;
}
else
{
for(i=0;i<16;i++)
{
buf[i*2]=*(ROM_ASCII+(ch)*16+i);
buf[i*2+1]=0; //字模右边8位补0

}
for(j=0;j<16;j++)
{
for(i=0;i<8;i++)
if ((0x80>>i%8)&buf[2*j+i/8])
POPUP_PutPixel(i+x,y+j,color);
else
POPUP_PutPixel(i+x,y+j,Back_Color);
POPUP_PutPixel(8+x,y+j,Back_Color);
}
x+=8+d;
/*-----------------------------------------------------------------------------------------------*/
// 如果采用8X8点阵字模显示英文及数字,请采用如下代码
/*-----------------------------------------------------------------------------------------------*/
/* ROM_ASCII = Current_ASCII_ROM(S8X8);
for(i=0;i<8;i++)
buf[i]=*(ROM_ASCII+(ch)*8+i);
for(j=0;j<8;j++)
for(i=0;i<8;i++)
if((0x80>>i%8)&buf[j+i/8])
POPUP_PutPixel(i+x,y+j+5,color);
else
POPUP_PutPixel(i+x,y+j+5,Back_Color);
x+=8+d;*/
}
}
}

/////////////////////////////////////////////////////////////////////////////////////////////////
////绘制一条垂直线函数
/////////////////////////////////////////////////////////////////////////////////////////////////
void _Cdecl Vline(int x, int y1, int y2)
{
int i,gcolor = getcolor();

for (i = y1; i <= y2; ++i)
PutPixel(x,i,gcolor);
}

/////////////////////////////////////////////////////////////////////////////////////////////////
////绘制一条垂直线函数(弹出式窗口专用)
/////////////////////////////////////////////////////////////////////////////////////////////////
void _Cdecl POPUP_Vline(int x, int y1, int y2)
{
int i,gcolor = getcolor();

for (i = y1; i <= y2; ++i)
POPUP_PutPixel(x,i,gcolor);
}

/////////////////////////////////////////////////////////////////////////////////////////////////
////绘制一条水平线函数
/////////////////////////////////////////////////////////////////////////////////////////////////
void _Cdecl Hline(int x1, int y, int x2)
{
int i,gcolor = getcolor();

for (i=x1;i<=x2;i++)
PutPixel(i,y,gcolor);
}

/////////////////////////////////////////////////////////////////////////////////////////////////
////绘制一条水平线函数(弹出式窗口专用)
/////////////////////////////////////////////////////////////////////////////////////////////////
void _Cdecl POPUP_Hline(int x1, int y, int x2)
{
int i,gcolor = getcolor();

for (i=x1;i<=x2;i++)
POPUP_PutPixel(i,y,gcolor);

}

/////////////////////////////////////////////////////////////////////////////////////////////////
////通用画线子程序
/////////////////////////////////////////////////////////////////////////////////////////////////
void _Cdecl Line(int x1,int y1,int x2,int y2)
{
register int t,d;
int xer=0,yer=0,deta_x,deta_y,incx,incy;
int gcolor = getcolor();

deta_x = x2 - x1;
deta_y = y2 - y1;
if (deta_x>0)
incx = 1;
else if(deta_x == 0)
incx = 0;
else
incx = -1;
if (deta_y>0)
incy = 1;
else if (deta_y == 0)
incy = 0;
else
incy = -1;

deta_x = abs(deta_x);
deta_y = abs(deta_y);

if (deta_x>deta_y)
d = deta_x;
else
d = deta_y;

for (t=0;t<=d+1;t++)
{
PutPixel(x1,y1,gcolor);
xer += deta_x;
yer += deta_y;
if (xer>d)
{
xer -= d;
x1 += incx;
}
if (yer>d)
{
yer -= d;
y1 += incy;
}
}
}

/////////////////////////////////////////////////////////////////////////////////////////////////
////画矩形
/////////////////////////////////////////////////////////////////////////////////////////////////
void _Cdecl Rectangle(int x1,int y1,int x2,int y2)
{
Hline(x1, y1, x2);
Hline(x1, y2, x2);
Vline(x1, y1, y2);
Vline(x2, y1, y2);

}

/////////////////////////////////////////////////////////////////////////////////////////////////
////画矩形(弹出式窗口专用)
/////////////////////////////////////////////////////////////////////////////////////////////////
void _Cdecl POPUP_Rectangle(int x1,int y1,int x2,int y2)
{
POPUP_Hline(x1, y1, x2);
POPUP_Hline(x1, y2, x2);
POPUP_Vline(x1, y1, y2);
POPUP_Vline(x2, y1, y2);

}

/////////////////////////////////////////////////////////////////////////////////////////////////
////填充矩形
/////////////////////////////////////////////////////////////////////////////////////////////////
void _Cdecl Bar(int x1, int y1, int x2, int y2)
{
int i,gcolor = getcolor();

setcolor(Fill_Color);
for (i = y1; i <= y2; ++i)
Hline(x1, i, x2);
setcolor(gcolor);
}

/////////////////////////////////////////////////////////////////////////////////////////////////
////填充矩形(弹出式窗口专用)
/////////////////////////////////////////////////////////////////////////////////////////////////
void _Cdecl POPUP_Bar(int x1, int y1, int x2, int y2)
{
int i,gcolor = getcolor();

setcolor(Fill_Color);
for (i = y1; i <= y2; ++i)
POPUP_Hline(x1,i,x2);
setcolor(gcolor);
}

/////////////////////////////////////////////////////////////////////////////////////////////////
////画圆函数，以(c_x, c_y)为中心画一半径为r的圆
/////////////////////////////////////////////////////////////////////////////////////////////////
void _Cdecl Circle(int c_x, int c_y, int r)
{
int x = 0, y = r, d0, d1, d2, direction;
int gcolor = getcolor();

d0 = (1-r) << 1;
while (y >= 0)
{
PutPixel(c_x + x, c_y + y, gcolor);
PutPixel(c_x - x, c_y - y, gcolor);
PutPixel(c_x + x, c_y - y, gcolor);
PutPixel(c_x - x, c_y + y, gcolor);
if (d0 < 0)
{
d1 = ((d0 + y) << 1) -1;
if (d1 <= 0) direction = 1;
else direction = 2;
}
else if (d0 > 0)
{
d2 = ((d0 - x) << 1) - 1;
if (d2 <= 0) direction = 2;
else direction = 3;
}
else direction = 2;

switch(direction)
{
case 1 : ++x;
d0 += (x<<1) + 1;
break;
case 2 : ++x;
--y;
d0+=(x-y+1)<<1;
break;
case 3 : --y;
d0 += -(y<<1) + 1;
break;
}
}
}

/////////////////////////////////////////////////////////////////////////////////////////////////
////填充的圆形,使用的是Midpoint算法
/////////////////////////////////////////////////////////////////////////////////////////////////
void _Cdecl CircleFill(int x0, int y0, int r)
{
int x,y;
int deltax,deltay;
int d,gcolor = getcolor();

x = 0;
y = r;
deltax = 3;
deltay = 2 - (r << 1);
d = 1 - r;

setcolor(getfillcolor());
while (x <= y)
{
Hline(x0-x, y0+y, x0+x) ;
Hline(x0-x, y0-y, x0+x);
Hline(x0-y, y0-x, x0+y);
Hline(x0-y, y0+x, x0+y);
Hline(x0-x, y0+y, x0+x);
if(d<0)
{
d += deltax;
deltax += 2;
x++;
}
else
{
d += deltax+deltay;
deltax += 2;
deltay += 2;
x++;
y--;
}
}
setcolor(gcolor);
}

/////////////////////////////////////////////////////////////////////////////////////////////////
////图形模式初始化子程序
/////////////////////////////////////////////////////////////////////////////////////////////////
void _Cdecl InitGraph(void)
{
_AX = 0x4F02;
_BX = VBE800X600X256;
__int__(0x10);
if (_AH != 0)
{
puts("Can't Initialize the graphics mode!");
exit(1);
}
}

//////////////////////////////////////////////////////////////////////////////
////关闭图形模式，回到文本模式子程序
//////////////////////////////////////////////////////////////////////////////
void _Cdecl CloseGraph(void)
{
_AX = 0x4F02;
_BX = 0x03;
__int__(0x10);
}

//////////////////////////////////////////////////////////////////////////////
////保存窗口映像
//////////////////////////////////////////////////////////////////////////////
BOOL _Cdecl Save_Image_XMS(int x1,int y1,int x2,int y2)
{
int i,j,size;
long long_size,offset = 0;
XMS_HANDLE handle;
char *ptr,buffer[800];

long_size = ((long)800L-(long)x1+1)*((long)y2-(long)y1+1);
long_size >>= 10;
size = long_size;
size++;
if (XMS_Size() > size)
{
if ((handle = XMS_Alloc(size)) != 0)
{
if (PUSH_Stack(x1,y1,x2,y2,handle))
{
size = 800 - TOP_X1();
for (i = TOP_Y1() ; i <= TOP_Y2() ; i++)
{
ptr = buffer;
for (j = TOP_X1() ; j < 800 ; j++)
*ptr++ = GetPixel(j,i);
Write_To_XMS(buffer,size,TOP_Handle(),offset);
offset += size;
}
return (TRUE);
}
}
}
return (FALSE);
}

//////////////////////////////////////////////////////////////////////////////
////恢复窗口映像
//////////////////////////////////////////////////////////////////////////////
void _Cdecl Restore_Image_XMS(void)
{
int i,j,size;
long offset = 0;
char *ptr,buffer[800];

for (i = TOP_Y1() ; i <= TOP_Y2() ; i++)
{
size = 800 - TOP_X1();
Read_From_XMS(buffer,size,TOP_Handle(),offset);
ptr = buffer;
for (j = TOP_X1() ; j < 800 ; j++)
POPUP_PutPixel(j,i,*ptr++);
offset += size;
}
}

//////////////////////////////////////////////////////////////////////////////
////弹出式列表当前位置以红色为底色，白色为字符色，显示亮条
////入口参数:
//// x1,y1 = 坐标(以像素为单位)
//// len = 亮条宽度
//// string = 显示字符串
//////////////////////////////////////////////////////////////////////////////
void _Cdecl POPUP_SET_Light_Bar(int x1,int y1,int len,char *string)
{
int bcolor = getbkcolor();

setfillstyle(SOLID_FILL,LIGHTRED);
setbkcolor(LIGHTRED);
POPUP_Bar(x1-2,y1-8,x1+len+2,y1+16+8);
POPUP_puthz(x1,y1,string,WHITE,0);
setbkcolor(bcolor);
}

//////////////////////////////////////////////////////////////////////////////
////弹出式列表恢复亮条
////入口参数:
//// x1,y1 = 坐标(以像素为单位)
//// len = 亮条宽度
//// string = 显示字符串
//////////////////////////////////////////////////////////////////////////////
void _Cdecl POPUP_RESTORE_Light_Bar(int x1,int y1,int len,char *string)
{
int bcolor = getbkcolor();

setfillstyle(SOLID_FILL,DIALOG_TEXT_BK_COLOR);
setbkcolor(DIALOG_TEXT_BK_COLOR);
POPUP_Bar(x1-2,y1-8,x1+len+2,y1+16+8);
POPUP_puthz(x1,y1,string,BLACK,0);
setbkcolor(bcolor);
}

//////////////////////////////////////////////////////////////////////////////
////画一个凹矩形
//////////////////////////////////////////////////////////////////////////////
void _Cdecl POPUP_GuiConCaveRectangle(int x1,int y1,int x2,int y2)
{
setcolor(DARKGRAY);
POPUP_Hline(x1,y1,x2);
POPUP_Vline(x1,y1,y2);
setcolor(WHITE);
POPUP_Hline(x1,y2,x2);
POPUP_Vline(x2,y1,y2);
}

//////////////////////////////////////////////////////////////////////////////
////画一个凸按钮(专门用于画对话框、列表框的外框)
//////////////////////////////////////////////////////////////////////////////
void _Cdecl POPUP_GuiConProtrudingBox(int x1,int y1,int x2,int y2)
{
setcolor(WHITE);
POPUP_Hline(x1,y1,x2);
POPUP_Vline(x1,y1,y2);
POPUP_Hline(x1-1,y1-1,x2+1);
POPUP_Vline(x1-1,y1-1,y2+1);
setcolor(DARKGRAY);
POPUP_Hline(x1,y2,x2);
POPUP_Vline(x2,y1,y2);
POPUP_Hline(x1-1,y2+1,x2+1);
POPUP_Vline(x2+1,y1-1,y2+1);
setfillstyle(SOLID_FILL,DIALOG_TEXT_BK_COLOR);
POPUP_Bar(x1+1,y1+1,x2-1,y2-1);
POPUP_GuiConCaveRectangle(x1+2,y1+2,x2-2,y1+28-2);
setfillstyle(SOLID_FILL,DIALOG_TITLE_BK_COLOR);
POPUP_Bar(x1+4,y1+4,x2-4,y1+28-4);
}

//////////////////////////////////////////////////////////////////////////////
// 画一条凹凸立体线
//////////////////////////////////////////////////////////////////////////////
void _Cdecl POPUP_Double_Line(int x1,int y1,int x2)
{
setcolor(DARKGRAY);
POPUP_Hline(x1,y1-1,x2);
setcolor(WHITE);
POPUP_Hline(x1,y1,x2);
}

////////////////////////////////////////////////////////////////////////////////////////////////
// 创建对话框子程序
// 入口参数:
// x1,y1,x2,y2 = 窗口区域
// 功能:
// 1.窗口区域(x1,y1,x2,y2)及窗口指针入栈
// 2.保存窗口区域屏幕到扩展内存
// 2.画对话框
////////////////////////////////////////////////////////////////////////////////////////////////
BOOL _Cdecl POPUP_Create_DialogBox(int x1,int y1,int x2,int y2)
{
if (Save_Image_XMS(x1,y1,x2,y2))
{
POPUP_GuiConProtrudingBox(TOP_X1()+1,TOP_Y1()+1,TOP_X2()-1,TOP_Y2()-1);
return (TRUE);
}
return (FALSE);
}

////////////////////////////////////////////////////////////////////////////////////////////////
// 关闭对话框子程序
////////////////////////////////////////////////////////////////////////////////////////////////
void _Cdecl POPUP_Close_DialogBox(void)
{
if (!Stack_Empty())
{
Restore_Image_XMS();
XMS_Free(TOP_Handle());
POP_Stack();
}
}

/////////////////////////////////////////////////////////////////////////////////////////////////
// 快速清除屏幕子程序(将缓冲屏幕中的数据直接复制到可见视频缓存区里面去)
// 由于分辨率为800*600*256色（8位深度），因此共需800*600/65535=8页=512K
/////////////////////////////////////////////////////////////////////////////////////////////////
void _Cdecl GuiQuickClsScreen(int color)
{
unsigned int i,j;
unsigned char VDCBuf[800];
unsigned int dest_off = 0;

memset(VDCBuf,color,800);
for (j = 0 ; j < 8 ; j++) // 页号(共需8页)
{
set_vbe_page(j); // 依次选择页号0－页号7
dest_off = 0; // 偏移
for (i = 0 ; i < 81 ; i++) // 由于显卡每页64K，因此先送64800个像素
{
movedata(FP_SEG(VDCBuf),FP_OFF(VDCBuf),0xa000,dest_off,800);
dest_off += 800; // 指向下一根扫描线
}
movedata(FP_SEG(VDCBuf),FP_OFF(VDCBuf),0xa000,dest_off,736);// 将每页余下的736个像素单独送
}
}

void main(void)
{
InitGraph();
GuiQuickClsScreen(BLUE);
POPUP_GuiConProtrudingBox(100,100,500,500);

getch();
getch();
}

风格和注释都不错，希望能坚持写下去，做个游戏引擎，呵呵

[此贴子已经被作者于2007-10-31 21:05:00编辑过]

qv5HbAxH.bmp (623.96 KB)

图片附件: 游客没有浏览图片的权限，请 登录 或 注册