//SHOWHZ.C
#include <graphics.h>
#include <string.h>
#include <stdio.h>
#include <conio.h>
#include <math.h>
#include <mem.h>
#include <alloc.h>
#include <dir.h>
#include <dos.h>
#include <stdlib.h>

#define baseSize 168
#define portion 100

int X0,Y0,xRange,yRange,curX,curY,contourNO;
int newX0,newY0,newxRange,newyRange;

static unsigned readCount_0=0,readCount_8=0;

unsigned char *wordCont_0=NULL,*wordCont_8=NULL;
unsigned bytesNum_0,bytesNum_8;
unsigned char myRead(int call_8_0);

void control(int *xx,int *yy,unsigned char controlWord,int nowxRange,int nowyRange,int nowX0,int nowY0,int call_8_0);
void showHanzi(char *fontfileName,int qw,int wm);
void b3_4(int *x,int *y,int col);
void b3_3(int *x,int *y,int col);

void main(void)
{
unsigned char qm,wm;
int i,a=DETECT,b=0;
char *hzstring="矢量汉字演示示例";
struct ffblk ff;

registerbgidriver(EGAVGA_driver);

initgraph(&a,&b,"");

X0=1;
Y0=75;

xRange=152;
yRange=152;

b=findfirst("*.ps",&ff,FA_ARCH);

while(!b)
{
for(i=a=0;i<strlen(hzstring);i+=2)
{
qm=hzstring[i]-160;
wm=hzstring[i+1]-160; // 分两个BYTE取ASC值(汉字在160之后,故-160)

showHanzi(ff.ff_name,qm,wm);

a++;

if(a==4 || a==8) // 逢4,8换行
{
X0=0;
Y0+=150;
}
}

getch();

X0=Y0=1;
cleardevice();

qm=16; // 16区之后是汉字
wm=1;

xRange=144;
yRange=144;

for(i=a=0;i<6000;i+=2)
{
showHanzi(ff.ff_name,qm,wm++);

a++;

if(wm==95) // 每区94个汉字
{
qm++;
wm=1;
}

if(a==4 || a==8) // 逢4,8换行
{
X0=1;
Y0+=yRange;
}
else if(a==12) // 逢12清屏
{
if(getch()=='0')
{
break; // 按0退出
}

X0=Y0=1;
cleardevice();
a=0;
}
}

getch();

X0=Y0=1;
cleardevice();

b=findnext(&ff);
}
closegraph();
}

void showHanzi(char *fontFileName,int qm,int wm)
{
long firstIndex,secondIndex,secondIndex8;
unsigned char indexValue[2][3];
long wordOffset,newOffset;
FILE *fp;
int xx[4],yy[4],controlWord,i,j,index2;
bytesNum_0=0;
readCount_0=0;
readCount_8=0;
if(wordCont_0)
{
free(wordCont_0);
wordCont_0=NULL;
}
if((fp=fopen(fontFileName,"rb"))==NULL)
{
printf("Cannot open %s file\n",fontFileName);
exit(0);
}
wordOffset=(71*94+94)*3;
fseek(fp,wordOffset,SEEK_SET);
fread(indexValue[0],3,1,fp);
secondIndex=(long)indexValue[0][2]*65536+(long)indexValue[0][1]*256+
(long)indexValue[0][0];
wordOffset=(((long)qm-16)*94+wm-1)*3;
fseek(fp,wordOffset,SEEK_SET);
fread(indexValue[0],3,1,fp);
fread(indexValue[1],3,1,fp);
firstIndex=(long)indexValue[0][2]*65536+(long)indexValue[0][1]*256+
(long)indexValue[0][0];
bytesNum_0=(long)indexValue[1][2]*65536+(long)indexValue[1][1]*256+
(long)indexValue[1][0]-firstIndex;
wordCont_0=(unsigned char *)malloc(bytesNum_0);
if(!wordCont_0)
{
/*puts("Out of memory!");*/
return;
}
fseek(fp,firstIndex,SEEK_SET);
fread(wordCont_0,1,bytesNum_0,fp);
while(1)
{
if(readCount_0>=(2*bytesNum_0))
{
break;
}
controlWord=myRead(0);
if(controlWord<0x08)
{
control(xx,yy,controlWord,xRange,yRange,X0,Y0,0);
}
else
{
bytesNum_8=0;
readCount_8=0;
if(wordCont_8)
{
free(wordCont_8);
wordCont_8=NULL;
}
switch(controlWord)
{
case 0x08:
contourNO=0;
index2=(int)myRead(0)*16+myRead(0)-8;
newX0=(int)X0+(myRead(0)*16+myRead(0))*xRange/baseSize;
newY0=(int)Y0+(myRead(0)*16+myRead(0))*yRange/baseSize;
newxRange=(int)xRange*(myRead(0)*16+myRead(0))/portion;
newyRange=(int)yRange*(myRead(0)*16+myRead(0))/portion;
break;
case 0x09:
contourNO=0;
newX0=(int)X0+(myRead(0)*16+myRead(0))*xRange/baseSize;
newY0=(int)Y0+(myRead(0)*16+myRead(0))*yRange/baseSize;
newxRange=(int)xRange*(myRead(0)*16+myRead(0))/portion;
newyRange=(int)yRange*(myRead(0)*16+myRead(0))/portion;
index2=(int)myRead(0)*16+myRead(0)+0xf6;
break;
case 0x0a:
contourNO=0;
newX0=(int)X0+(myRead(0)*16+myRead(0))*xRange/baseSize;
newY0=(int)Y0+(myRead(0)*16+myRead(0))*yRange/baseSize;
newxRange=(int)xRange*(myRead(0)*16+myRead(0))/portion;
newyRange=(int)yRange*(myRead(0)*16+myRead(0))/portion;
index2=(int)myRead(0)*16+myRead(0)+0x1f6;
break;
default:
/*printf("\n******** >0x0a ********");*/
return;
}
newOffset=secondIndex+index2*3;
fseek(fp,newOffset,SEEK_SET);
fread(indexValue[0],3,1,fp);
fread(indexValue[1],3,1,fp);
firstIndex=(long)indexValue[0][2]*65536+(long)indexValue[0][1]*256+
(long)indexValue[0][0];
bytesNum_8=(long)indexValue[1][2]*65536+(long)indexValue[1][1]*256+
(long)indexValue[1][0]-firstIndex;
secondIndex8=firstIndex+secondIndex;
wordCont_8=(unsigned char *)malloc(bytesNum_8);
if(!wordCont_8)
{
/*puts("Out of memory 8!\n");*/
return;
}
fseek(fp,secondIndex8,SEEK_SET);
fread(wordCont_8,1,bytesNum_8,fp);
while(1)
{
if(readCount_8>=(2*bytesNum_8))
{
break;
}
controlWord=myRead(8);
if(controlWord>=0x80)
{
/*printf("\nToo many funtion call!!");*/
return;
}
control(xx,yy,controlWord,newxRange,newyRange,newX0,newY0,8);
}
free(wordCont_8);
wordCont_8=NULL;
}
}
X0+=xRange; // 自动更新x轴坐标
free(wordCont_0);
wordCont_0=NULL;
fclose(fp);
return;
}

void control(int *xx,int *yy,unsigned char controlWord,int nowxRange,
int nowyRange,int nowX0,int nowY0,int call_8_0)
{
int i;
switch(controlWord)
{
case 0:
contourNO++;
xx[0]=(int)myRead(call_8_0)*16+myRead(call_8_0);
yy[0]=(int)myRead(call_8_0)*16+myRead(call_8_0);
xx[0]=nowxRange*xx[0]/baseSize;
yy[0]=nowyRange*yy[0]/baseSize;
xx[0]+=nowX0;yy[0]+=nowY0;
moveto(xx[0],yy[0]);
curX=xx[0];curY=yy[0];
break;
case 1:
xx[0]=(int)myRead(call_8_0)*16+myRead(call_8_0);
xx[0]=nowxRange*xx[0]/baseSize;
xx[0]+=nowX0;
lineto(xx[0],curY);
curX=xx[0];
break;
case 2:
yy[0]=(int)myRead(call_8_0)*16+myRead(call_8_0);
yy[0]=nowyRange*yy[0]/baseSize;
yy[0]+=nowY0;
lineto(curX,yy[0]);
curY=yy[0];
break;
case 3:
xx[0]=(int)myRead(call_8_0)*16+myRead(call_8_0);
yy[0]=(int)myRead(call_8_0)*16+myRead(call_8_0);
xx[0]=nowxRange*xx[0]/baseSize;
yy[0]=nowyRange*yy[0]/baseSize;
xx[0]+=nowX0;yy[0]+=nowY0;
lineto(xx[0],yy[0]);
curX=xx[0];curY=yy[0];
break;
case 4:
xx[0]=curX;yy[0]=curY;
xx[1]=(int)myRead(call_8_0)*16+myRead(call_8_0);
yy[1]=(int)myRead(call_8_0)*16+myRead(call_8_0);
xx[2]=(int)myRead(call_8_0)*16+myRead(call_8_0);
yy[2]=(int)myRead(call_8_0)*16+myRead(call_8_0);
xx[1]=nowxRange*xx[1]/baseSize;
yy[1]=nowyRange*yy[1]/baseSize;
xx[2]=nowxRange*xx[2]/baseSize;
yy[2]=nowyRange*yy[2]/baseSize;
xx[1]+=nowX0;yy[1]+=nowY0;
xx[2]+=nowX0;yy[2]+=nowY0;
b3_3(xx,yy,15);
curX=xx[2];curY=yy[2];
moveto(curX,curY);
break;
case 5:
xx[0]=curX;yy[0]=curY;
xx[1]=(int)myRead(call_8_0)*16+myRead(call_8_0);
yy[1]=(int)myRead(call_8_0)*16+myRead(call_8_0);
xx[2]=(int)myRead(call_8_0)*16+myRead(call_8_0);
yy[2]=(int)myRead(call_8_0)*16+myRead(call_8_0);
xx[3]=(int)myRead(call_8_0)*16+myRead(call_8_0);
yy[3]=(int)myRead(call_8_0)*16+myRead(call_8_0);
xx[1]=nowxRange*xx[1]/baseSize;
yy[1]=nowyRange*yy[1]/baseSize;
xx[2]=nowxRange*xx[2]/baseSize;
yy[2]=nowyRange*yy[2]/baseSize;
xx[3]=nowxRange*xx[3]/baseSize;
yy[3]=nowyRange*yy[3]/baseSize;
for(i=1;i<4;i++)
{
xx[i]+=nowX0;yy[i]+=nowY0;
}
b3_4(xx,yy,15);
curX=xx[3];curY=yy[3];
moveto(curX,curY);
break;
case 6:
xx[0]=(int)myRead(call_8_0)*16+myRead(call_8_0);
yy[0]=(int)myRead(call_8_0)*16+myRead(call_8_0);
xx[1]=(int)myRead(call_8_0)*16+myRead(call_8_0);
yy[1]=(int)myRead(call_8_0)*16+myRead(call_8_0);
xx[0]=nowxRange*xx[0]/baseSize;
yy[0]=nowyRange*yy[0]/baseSize;
xx[1]=nowxRange*xx[1]/baseSize;
yy[1]=nowyRange*yy[1]/baseSize;
for(i=0;i<2;i++)
{
xx[i]+=nowX0;yy[i]+=nowY0;
}
rectangle(xx[0],yy[0],xx[1],yy[1]);
curX=xx[1];curY=yy[1];
moveto(curX,curY);
break;
case 7:
/*printf("case 7\n");*/
return;
default:
/*printf("\n******** Case>7 ********");*/
return;
}
}

unsigned char myRead(int call_8_0)
{
switch(call_8_0)
{
case 0:
return(0x0f&(wordCont_0[readCount_0/2]>>((1-((readCount_0++)%2))*4)));
case 8:
return(0x0f&(wordCont_8[readCount_8/2]>>((1-((readCount_8++)%2))*4)));
default:
/*printf("\n******** myRead is wrong! ********");*/
return 0x00;
}
}

void b3_4(int *x,int *y,int col)
{
int n,*bx,*by,sign=1,j=0,k,i;
double a,b,c,d,dt,xx,f0_3,f_0,f_1,f_2;
n=xx=sqrt(((double)(x[1]-x[0]))*((double)(x[1]-x[0]))+
((double)(y[1]-y[0]))*((double)(y[1]-y[0])))+
sqrt(((double)(x[2]-x[1]))*((double)(x[2]-x[1]))+
((double)(y[2]-y[1]))*((double)(y[2]-y[1])))+
sqrt(((double)(x[3]-x[2]))*((double)(x[3]-x[2]))+
((double)(y[3]-y[2]))*((double)(y[3]-y[2])));
if(xx>n) n++;
n*=2;
if(n==0) n=20;
do
{
bx=(int *)malloc(n*sizeof(int));
by=(int *)malloc(n*sizeof(int));
if((!bx)||(!by))
{
/*printf("Memory Alloction Error!");*/
return;
}
dt=(double)1/(double)n;
a=((-1)*x[0]+3*x[1]-3*x[2]+x[3]);
b=3*(x[0]-2*x[1]+x[2]);
c=3*(x[1]-x[0]);
d=x[0];
f0_3=6*a*dt*dt*dt;
f_2=f0_3+2*b*dt*dt;
f_1=f0_3/6+b*dt*dt+c*dt;
f_0=d;
bx[0]=f_0+0.5;
for(i=0;i<n;i++)
{
f_0+=f_1;
bx[i]=f_0+0.5;
f_1+=f_2;
f_2+=f0_3;
}
a=((-1)*y[0]+3*y[1]-3*y[2]+y[3]);
b=3*(y[0]-2*y[1]+y[2]);
c=3*(y[1]-y[0]);
d=y[0];
f0_3=6*a*dt*dt*dt;
f_2=f0_3+2*b*dt*dt;
f_1=f0_3/6+b*dt*dt+c*dt;
f_0=d;
bx[0]=f_0+0.5;
for(i=0;i<n;i++)
{
f_0+=f_1;
by[i]=f_0+0.5;
f_1+=f_2;
f_2+=f0_3;
}
sign=1;j=0;k=n/100+1;
for(i=1;i<n;i++)
{
if((abs(bx[i]-bx[i-1])>1)||(abs(by[i]-by[i-1])>1))
{
j++;
}
if(j>k)
{
free(bx);
free(by);
if(n>3)
n=n+n/3;
else
n=6;
sign=0;
} break;
}
} while(sign==0);
for(i=1;i<n;i++)
{
if((bx[i]!=bx[i-1])||(by[i]!=by[i-1]))
{
putpixel(bx[i],by[i],col);
}
}
free(bx);
free(by);
}

void b3_3(int *x,int *y,int col)
{
int n,*bx,*by,sign=1,j=0,k,i;
double a,b,c,d,dt,xx,f0_3,f_0,f_1,f_2;
n=xx=sqrt(((double)(x[1]-x[0]))*((double)(x[1]-x[0]))+
((double)(y[1]-y[0]))*((double)(y[1]-y[0])))+
sqrt(((double)(x[2]-x[1]))*((double)(x[2]-x[1]))+
((double)(y[2]-y[1]))*((double)(y[2]-y[1])));
if(xx>n) n++;
n*=4;
if(n==0) n=20;
do
{
bx=(int *)malloc(n*sizeof(int));
by=(int *)malloc(n*sizeof(int));
if((!bx)||(!by))
{
/*printf("Memory Alloction Error!");*/
return;
}
dt=(double)1/(double)n;
b=x[0]-2*x[1]+x[2];
c=2*(x[1]-x[0]);
d=x[0];
f_2=2*b*dt*dt;
f_1=b*dt*dt+c*dt;
f_0=d;
bx[0]=f_0+0.5;
for(i=0;i<n;i++)
{
f_0+=f_1;
bx[i]=f_0+0.5;
f_1+=f_2;
}
b=y[0]-2*y[1]+y[2];
c=2*(y[1]-y[0]);
d=y[0];
f_2=2*b*dt*dt;
f_1=b*dt*dt+c*dt;
f_0=d;
by[0]=f_0+0.5;
for(i=0;i<n;i++)
{
f_0+=f_1;
by[i]=f_0+0.5;
f_1+=f_2;
}
sign=1;j=0;k=n/100+1;
for(i=1;i<n;i++)
{
if((abs(bx[i]-bx[i-1])>1)||(abs(by[i]-by[i-1])>1))
{
j++;
}
if(j>k)
{
free(bx);
free(by);
if(n>3)
n=n+n/3;
else
n=6;
sign=0;
} break;
}
} while(sign==0);
for(i=1;i<n;i++)
{
if((bx[i]!=bx[i-1])||(by[i]!=by[i-1]))
{
putpixel(bx[i],by[i],col);
}
}
free(bx);
free(by);
}

嘿嘿，我也是在网上找到的。

技术类 　

开发ＡＵＴＯＣＡＤ的纵横汉字环境

常州技术师范学院计算机科学系

郑成增 陈志锋 尹长青

一、前言

　　目前，在市场上流行着各种各样的ＣＡＤ系统，但是在众多的产品中，ＡＵＴＯＣＡＤ使用最为普遍。为了促进纵横汉字在ＣＡＤ领域中的应用，同时也满足ＣＡＤ用户希望有一种能适用于任何ＡＵＴＯＣＡＤ环境的汉字系统，笔者进行了ＡＵＴＯＣＡＤ的纵横汉字环境（以下简称纵横环境）的开发。

二、开发纵横环境的基本构思

　　开发纵横环境，实现汉化ＡＵＴＯＣＡＤ，从而用户可以轻松地在ＡＵＴＯＣＡＤ下应用纵横汉字输入法进行汉字的标注、说明（在机械制图时，对标注、说明，大都要求实用仿宋字体），即实现了ＡＵＴＯＣＡＤ应用的本地化。

１、本环境主要完成下述基本功能：
（１）在ＡＵＴＯＣＡＤ图形屏幕某个区域(即汉字输入提示区) 用中文提示提供用户进行汉字输入的选择：
（２）截获键盘输入，采用纵横码、区位、西文等输入法实现汉字的输入；
（３）调用矢量汉字库（ＨＺＴＸＴ．ＳＨＸ）中的汉字标注到ＡＵＴＯＣＡＤ图形中；
２、开发纵横环境的程序模块：
（１）矢量汉字库（ＨＺＴＸＴ．ＳＨＸ）的制作；
（２）汉字在ＡＵＴＯＣＡＤ中的显示；
（３）纵横汉字输入法模块；
（４）区位汉字输入法模块；
（５）汉字在ＡＵＴＯＣＡＤ中的标注模块；
（６）其它辅助功能模块

　　如图一所示即为本系统功能模块。

图一 程序功能模块

三、各功能模块的实现

　　１、矢量汉字库（ＨＺＴＸＴ．ＳＨＸ）的制作

　　在ＡＵＴＯＣＡＤ中，形（ＳＨＡＰＥ）是特殊的实体，可以用线、弧、圆来定义。形状常见的是用于定义文本字体。形状是用专用格式文本存贮在磁盘中的文件（扩展名为．ＳＨＰ），将其编译后即可被ＡＵＴＯＣＡＤ所使用。在ＡＵＴＯＣＡＤ中，每个形状必须具有１到２５５之间的唯一的号码。文本字体（如字母、数字等ＡＳＣＩＩ字符）要求与ＡＳＣＩＩ码中的每个字符的值都对应；其它形状可以分配给任意的号码。

　　每个形状定义具有以下格式的标题行：
　　　　　shapenumber, defbytes, shapename

　　后面跟有用逗号分隔和以０（零）表示该形态技术的一行或多行形状说明字节。在形状文件中的所有数码，带有前导０意味着是十六进制数，否则为十进制数。

　　shapenumber 为形状代码，一般为１到２５５之间的唯一号码；
　　difbytes 用于说明所需数据字节的数量，包括结束码０。每个形状不超过10000个字节。
　　shapename 用于定义形状名，如果形状名中含有小写字母，则形状名字将不存贮。

　 形状说明字节包括两部分：矢量长量，方向代码。高４位是矢量长度，低四位是方向代码。方向与方向代码如图二所示：

图二

　　除上述基本的形状说明字节外，还定义几个专用码（十进制）。

　　０ 形状定义结束
　　１ 进入绘图方式
　　２ 退出绘图方式
　　３ 用下一个字节除矢量长度
　　４ 用下一个字节乘矢量长度
　　５ 将当前位置压入堆栈
　　６ 从堆栈中弹出当前位置
　　７ 绘制由下一个字节给出的子形状号
　　８ 由下两个字节给出的Ｘ－Ｙ相对偏移量
　　９ 由（０，０）结束多个Ｘ－Ｙ相对偏移量
　　10 由下两个字节定义的八分圆弧
　　11 由下五个字节定义的小段
　　12 根据Ｘ－Ｙ位移量和凸度定义的弧
　　13 多个指定凸度的弧
　　14 只明是垂直文本字体时才处理下一条命令

　　文本字体是在上述形状文件的基础上，采用形状来定义的，形状编号对应于每个字符的ＡＳＣＩＩ。
　　文本字体文件必须包含一个特殊的形状编号，存贮有关字体自身的信息。格式如下：
　　＊０，４，字体名
　　ａｂｏｖｅ，ｂｅｌｏｗ，ｍｏｄｅｓ，０
　　ａｂｏｖｅ规定大写字母超过基线向量长度的大小，ｂｅｌｏｗ规定小写字母在基线下向量的大小，定义了基本字符尺寸和高度的比例因子。
　　ｍｏｄｅｓ通常为０；当为双向（水平或垂直）字体，ｍｏｄｅｓ为２。只有ｍｏｄｅｓ为２时，专用码１４才起作用。

　　为了使ＡＵＴＯＣＡＤ的通用性更好，ＡＵＴＯＣＡＤ提供了一种称为大字体文体文件的形状定义文件来满足汉字等多种文字的使用。

　　一个大字体形状的第一行必须为：

　　*BIGFONT nchars, nranges, b1, e1, b2, e2 ...

　　nchars 是在这个集合中所定义的字符数的近似值，如果实际值超过其１０％则出错。

　　nranges 表示需要使用连续的几个数码用作特殊字符(如汉字需用两个字节表示，则nranges为２）。

　　(b1,e1),(b2,e2),..., 等定义这样范围的起始码和中止码。

　　常见矢量汉字库文件是一个二进制文件，ＵＣＤＯＳ３.1的矢量汉字库由索引表头和字形数据两部分组成，字形数据部分的基本单元有４个字节，头两个字节为某一线段的起始偏移位置，后两个字节为该线段的终止偏移位置。根据ＵＣＤＯＳ的矢量字库生成形状文件，将该形状文件编译即可得到所需的矢量字库hztxt.shx。

　　２．汉字直接写屏技术在ＡＵＴＯＣＡＤ中的实现

　　汉字显示的基本方法是将要显示的汉字的字模数据从汉字库中读出，然后把整个汉字一个点一个点地画出来。

　　为了提高汉字显示的速度，可以采用直接写ＶＲＡＭ的方法。ＶＧＡ卡在640X480的１６色显示模式下，ＶＲＡＭ被分成４个独立的位平面，各位平面有相同的地址空间，其首地址为Ａ０００：００００Ｈ，可通过图形控制器等特殊硬件来实现对每个位平面的独立担保。其步骤为：

设制好ＶＲＡＭ的首地址为００１Ｃ：００００保护模式；
根据点的坐标计算该点的ＶＲＡＭ中的偏移地址，为简单化，该点的横坐标为８倍数，计算公式为：
Ｙ＊８０＋Ｘ／８

通过图形控制器索引０号功能，设置颜色；
通过图形控制器索引１号功能，设置屏蔽写允许；
通过图形控制器索引３号功能，设置画点方式（重写、与、或、异或）；一般为异或方式（ＸＯＲ）；
通过图形控制器索引８号功能，设置位屏蔽寄存器为一次画八个点；
输出数据，实现显示；
显示完成后，将上述图形控制器寄存器恢复到初值。
　　３、汉字输入模块的设计

　　汉字输入模块用于将用户从键盘上输入的信息转化成汉字内码。它由两部分组成：编码方案（即汉字输入法）和主控程序。

　　主控程序主要完成以下几个功能 :

接管键盘，根据用户输入的不同进行相应的处理；
在输入过程中，允许进行输入法的转换；
输入过程中若有错误，则可进行修改；
当输入无效时，应鸣叫示意
　　（１）纵横输入法的实现

　　本模块的功能将键盘的数字转换成相应的汉字内码，为简单起见，将给纵横码表按数字大小排序。具体过程如下：

　　1. 首先建立一个纵横码索引表，该表包含了每一组纵横码所对应的所有汉字；
　　2. 根据用户输入的数字在提示行中显示出来；
　　3. 将所有符合条件的汉字在提示行中显示出来；
　　4. 让用户从重码字选择所需的字；
　　5. 取得该字的内码。

　　（２）区位输入法程序

　　本模块的功能是把用户输入的区位码转换成对应的汉字内码。汉字的内码一般有两个字节组成，每个字节的最高位为１，由区位码到汉字内码的转换比较简单，公式如下：

　　　　　汉字内码高字节＝区码＋１６０

　　　　　汉字内码低字节＝区码＋１６０

　　假设区码用变量ＱＵ，位码用变量ＷＥＩ表示，字符串变量ＨＺＮＭ存贮转换后的汉字内码，则可以采用下述语句实现：

　　　　　sprintf(HZNM,"%c%c",Q+160,WEI+160);

　　４、汉字标注模块的设计

　　汉字标注是汉化ＡＵＴＯＣＡＤ的目的所在，本模块只需设置好汉字字形，然后调用ＡＵＴＯＣＡＤ的标准ＴＥＸＴ命令将用户从键盘输入的汉字字符串在图形中标注出来。

　　在标注汉字之前，首先要让ＡＵＴＯＣＡＤ准备好汉字的形状文件（ＨＺＴＸＴ．ＳＨＸ）和西文的形状文件（ＴＸＴ．ＳＨＸ），即定义字符ＳＴＹＬＥ。若字形名为ＨＺＣＡＤ，则定义过程如下：

　　Command: STYLE

　　Style name <STANDARD>: HZCAD

　　Text file <TXT>: TXT, HZTXT

　　... ... （以下各项采用缺省值即可）

　　在定义好定型后，即可调用ＴＥＸＴ命令来实现汉字在图形中的标注。首先要求用户输入标注方式等内容，然后将这些参数和从键盘上输入的汉字串一起传送到ＴＥＸＴ命令，ＴＥＸＴ命令会自动处理汉字及西文，从相应的ＳＨＸ文件中取出对应的字形数据，并标注图形中。

　　５、辅助模块的设计

　　（１）实时帮助系统　　

　　当用户键入Ｆ１，即调用汉字显示模块显示帮助信息，使用户能正确使用本软件，退出时采用ＡＵＴＯＣＡＤ的ＲＥＡＤＲＡＷ命令即可恢复原图。　　

　　（２）命令行的汉字提示

　　采用汉字显示模块，设计一个ＡＤＳ专用函数ＨＺ＿ＰＲＯ（），在提示行显示出汉字字符串，提示用户的输入。

四、结束语

　　本纵横环境实现了在586/122微机上，配合ＡＵＴＯＣＡＤ１２.０英文版，采用纵横输入法进行汉字的输入、标注，效果很好。

【主要参考文献】

　　［１］钱培德等，微机汉字操作系统实用开发技术，北京师范大学出版社，1992

　　［２］纵横汉字信息技术研究所，纵横汉字系统，清华大学出版社，1994

　　［３］郑成增等，金工实习技能操作培训计算机CAI-CAD系统，计算机科学技术应用，
1995.6

　　［４］王福军，AutoCAD R12/R13应用C程序设计，电子工业出版社，1995

返回论文集一目录