刚才又有人在我QQ里问到如何禁止用户该表自己单文档窗体的大小,修改标题等等问题,其实这些问题不难,那么我现在来讲一下这个东西的实现。

首先找到单文档程序中的PreCreateWindow(CREATESTRUCT& cs)这个函数,这个函数是用来设置我们窗体的一些特征的,现在,我们来仔细看一下这个函数,如下:

BOOL CMainFrame::PreCreateWindow(CREATESTRUCT& cs)
{
if( !CFrameWnd::PreCreateWindow(cs) )
   return FALSE;
// TODO: Modify the Window class or styles here by modifying
// the CREATESTRUCT cs

return TRUE;
}

首先来看这个参数CREATESTRUCT& cs,是一个CREATESTRUCT结构的引用,那好,我们再来查询下MSDN,看一下这个结构,如下:

typedef struct tagCREATESTRUCT { // cs
    LPVOID    lpCreateParams;
    HINSTANCE hInstance;
    HMENU     hMenu;
    HWND      hwndParent;
    int       cy;
    int       cx;
    int       y;
    int       x;
    LONG      style;
    LPCTSTR   lpszName;
    LPCTSTR   lpszClass;
    DWORD     dwExStyle;
} CREATESTRUCT;

我们来一个一个的看这些参数:

LPVOID    lpCreateParams:这个参数用来指向将被用于创建窗口的数据的指针。

HINSTANCE hInstance: 这个参数标识了拥有新窗口的模块的模块实例的句柄。

HMENU     hMenu:这个参数标识了要被用于新窗口的菜单。如果是子窗口,则包含整数ID。

HWND      hwndParent:这个参数标识了拥有新窗口的窗口。如果新窗口是一个顶层窗口,这个参数可以为NULL。

int       cy:这个参数指定了新窗口的高。

int       cx:这个参数指定了新窗口的宽。

int       y:这个参数这个参数指定了新窗口的左上角的Y轴坐标。如果新窗口是一个子窗口,则坐标是相对于父窗口的;否则坐标是相对于屏幕原点的。

int       x:这个参数定了新窗口的左上角的X轴坐标。如果新窗口是一个子窗口,则坐标是相对于父窗口的;否则坐标是相对于屏幕原点的。

LONG      style:这个参数指定了新窗口的风格。

LPCTSTR   lpszName:这个参数指向一个以null结尾的字符串,指定了新窗口的名字。

LPCTSTR   lpszClass:这个参数指向一个以null结尾的字符串,指定了新窗口的Windows类名(一个WNDCLASS结构;更多的信息参见Win32 SDK文档)。

DWORD     dwExStyle:这个参数指定了新窗口的扩展风格。

在这些参数里面我们一般经常用到的是cy、cx、y、x、style、lpszName这几个,需要特别注意。

好了,现在开始在PreCreateWindow(CREATESTRUCT& cs)
加上代码,实现禁止改变单文档窗口大小:

BOOL CMainFrame::PreCreateWindow(CREATESTRUCT& cs)
{
if( !CFrameWnd::PreCreateWindow(cs) )
   return FALSE;
// TODO: Modify the Window class or styles here by modifying
// the CREATESTRUCT cs
cs.hMenu = NULL;//去掉菜单
cs.style&=~WS_MAXIMIZEBOX; //禁用按动最大化按钮
cs.style&=~WS_THICKFRAME;//禁止用户改变窗口大小
cs.cx = 700;//窗口宽度
cs.cy = 500;//窗口高度

cs.style&=~FWS_ADDTOTITLE;//将FWS_ADDTOTITLE去掉

cs. lpszName = "标题"//改变标题,替换自己的标题
return TRUE;
}

这里我们要注意,给这些参数赋值的时候我们需要用&符号还有一个~符号,我来解释一个:

cs.style&=~WS_MAXIMIZEBOX; //禁用按动最大化按钮

这句的意思是将WS_MAXIMIZEBOX从style里去掉,是个反与的操作,其他的类同。

posted @ 2010-08-03 12:39 wrh 阅读(1565) | 评论 (2)编辑 收藏

一.常见问题
a.可以编译,不能执行的
AfxInitRichEdit();

b.升级默认的Riched版本(默认的有一些bug)
可在InitInstance中添加
LoadLibrary("RICHED20.DLL")
最后注意 FreeLibrary

如果是CRichEditView基类的可用
BOOL CXXXXXXView::PreCreateWindow(CREATESTRUCT& cs)
{
//装入rich edit version 2.0
    if (LoadLibraryA("RICHED20.DLL") == NULL)
    {
        AfxMessageBox(_T("Fail to load \"riched20.dll\"."),MB_OK | MB_ICONERROR);
        PostMessage(WM_QUIT,0,0);
        return FALSE;
    }

    m_strClass = RICHEDIT_CLASSA;//for 2.0 class

    return CRichEditView::PreCreateWindow(cs);
}

c.最后追加行
richeditctrl.SetSel(-1, -1);
richeditctrl.ReplaceSel( (LPCTSTR)str );

显示回车换行:

设属性:"Multi lines"选为True。

设属性:"want return "选为True。

d.字数限制
CRichEditCtrl::LimitText(long nChars)

e.换行切换
CRichEditView的OnInitialUpdate()函数中加入下面两句:
m_nWordWrap = WrapNone;
WrapChanged();
WrapChanged实际上也是调用
ctrl.SetTargetDevice(NULL, 1); //m_nWordWrap == WrapNone
ctrl.SetTargetDevice(NULL, 0); //m_nWordWrap == WrapToWindow
还有不常用的 m_nWordWrap == WrapToTargetDevice
ctrl.SetTargetDevice(m_dcTarget, GetPrintWidth());
如果是在Dialog中,可使用SetTargetDevice,注意在属性里面加上want return

f.有时候不希望带格式的数据粘贴,可通过PasteSpecial选择性粘贴
pmyRichEditCtrl->PasteSpecial(CF_TEXT);

g.随着输入随着自动滚动条滚动到最后一行
int nFirstVisible = pmyRichEditCtrl->GetFirstVisibleLine();
if (nFirstVisible > 0)
{
   pmyRichEditCtrl->LineScroll(-nFirstVisible, 0);
}

m_cRichEdit.PostMessage(WM_VSCROLL, SB_BOTTOM,0);


h.设置UNDO的次数(只能用在RICHED20以上,即默认不支持,必须升级)
SendMessage(EM_SETTEXTMODE,TM_MULTILEVELUNDO,0);
TM_MULTILEVELUNDO 支持多取消(默认值).可通过EM_SETUNDOLIMIT设置最大次数
SendMessage(EM_SETUNDOLIMIT,100,0);

i.响应OnChange
EM_SETEVENTMASK 设置 ENM_CHANGE
long lMask = GetEventMask();
lMask |= ENM_CHANGE;
lMask &= ~ENM_PROTECTED;
SetEventMask(lMask);

j.设置只读
CRichEditCtrl::SetReadOnly( BOOL bReadOnly = TRUE );
通过设置PROTECTED实现选中的文本只读,参见
http://www.codeguru.com/Cpp/controls/richedit/article.php/c2401/

 

二.函数应用
a.设置字体(主要是通过SetSelectionCharFormat)

CHARFORMAT cf;
ZeroMemory(&cf, sizeof(CHARFORMAT));
cf.cbSize = sizeof(CHARFORMAT);
cf.dwMask|=CFM_BOLD;
cf.dwEffects|=CFE_BOLD;//设置粗体,取消用cf.dwEffects&=~CFE_BOLD;
cf.dwMask|=CFM_ITALIC;
cf.dwEffects|=CFE_ITALIC;//设置斜体,取消用cf.dwEffects&=~CFE_ITALIC;
cf.dwMask|=CFM_UNDERLINE;
cf.dwEffects|=CFE_UNDERLINE;//设置斜体,取消用cf.dwEffects&=~CFE_UNDERLINE;
cf.dwMask|=CFM_COLOR;
cf.crTextColor = RGB(255,0,0);//设置颜色
cf.dwMask|=CFM_SIZE;
cf.yHeight =200;//设置高度
cf.dwMask|=CFM_FACE;
strcpy(cf.szFaceName ,_T("隶书"));//设置字体
rich.SetSelectionCharFormat(cf);

b.设置字体的行间距
要用richedit2.0以上
试试
PARAFORMAT2 pf;
pf.cbSize = sizeof(PARAFORMAT2);
pf.dwMask = PFM_NUMBERING | PFM_OFFSET;
pf.wNumbering = PFN_BULLET;//注意PFM_NUMBERING
pf.dxOffset = 10;
VERIFY(SetParaFormat(pf));
常用的dwMask有
PFM_NUMBERING 成员 wNumbering 才起作用,项目符号,默认用PFN_BULLET
2 使用阿拉伯数字 (1, 2, 3, ...). 
3 使用小写字母 (a, b, c, ...). 
4 使用大写字母 (A, B, C, ...). 
5 使用小写罗马数字 (i, ii, iii, ...). 
6 使用大写罗马数字 (I, II, III, ...). 
7 自定义,字符见成员 wNumberingStart. 
PFM_OFFSET 成员 dxOffset 才起作用,缩进,单位twips
PFM_STARTINDENT 成员 dxStartIndent 才起作用,首行缩进
PFM_SPACEAFTER 成员 dySpaceAfter 才起作用,段间距
PFM_LINESPACING 成员 dyLineSpacing 才起作用,行间距

c.设置CRichEditCtrl(2.0)背景透明
long style = ::GetWindowLong(GetSafeHwnd(), GWL_EXSTYLE);
style &= WS_EX_TRANSPARENT;
::SetWindowLong(GetSafeHwnd(), GWL_EXSTYLE, style);
或 CreateEx,然后把WS_EX_TRANSPARENT样式加上

e.得到内容有三种
1)GetWindowText
2)使用EM_GETTEXTEX
GETTEXTEX gt;
gt.cb = 200;
gt.flags = GT_DEFAULT;
gt.codepage = CP_ACP ;
gt.lpDefaultChar = NULL; 
gt.lpUsedDefChar = NULL;
SendMessage(EM_GETTEXTEX,(WPARAM)>,(LPARAM)text);
3)StreamOut(主要用于RTF等格式输出)
static DWORD CALLBACK
    MyStreamOutCallback(DWORD dwCookie, LPBYTE pbBuff, LONG cb, LONG *pcb)
{
   CFile* pFile = (CFile*) dwCookie;

   pFile->Write(pbBuff, cb);
   *pcb = cb;

   return 0;
}


   CFile cFile(TEXT("myfile.rtf"), CFile::modeCreate|CFile::modeWrite);
   EDITSTREAM es;
   es.dwCookie = (DWORD) &cFile;//设置用例参数,以便回调函数调用
   es.pfnCallback = MyStreamOutCallback;
   pmyRichEditCtrl->StreamOut(SF_RTF, es);
读入可以此类推,SetWindowText,EM_SETTEXTEX,StreamIn

f.查找字符串
FINDTEXTEX ft;
ft.chrg.cpMin = 0;
ft.chrg.cpMax = -1;
ft.lpstrText = "|";
long lPos = FindText(0, &ft);

如果要继续查找,修改cpMin,如
int nCount = 0;
do
{
 long lPos = GetRichEditCtrl().FindText(0, &ft);
 if( -1 == lPos) break;
 ft.chrg.cpMin = lPos + strlen(ft.lpstrText);
 ++nCount;
}while(TRUE);

g.以Html格式保存
目前做法可先转为RTF格式,再通过RTF-to-HTML Converter
http://www.codeguru.com/Cpp/controls/richedit/conversions/article.php/c5377/

h.重载OnProtected函数得到对应的消息,如粘贴等
void CMYichEditorView::OnProtected(NMHDR* pNMHDR, LRESULT* pResult)
{
    ENPROTECTED* pEP = (ENPROTECTED*)pNMHDR;

    switch (pEP->msg)

    {
        case WM_KEYDOWN://按键,判断pEP->wParam
        case WM_PASTE://粘贴
        case WM_CUT://剪切
        case EM_SETCHARFORMAT:
        default:
            break;
    };
 
   *pResult = FALSE;
}

 

三.聊天常用 
a.LINK 链接功能
1.  LoadLibrary(_T("Riched20.dll"));


2. 创建RichEdit2.0控件
CreateEx(0, _T("RichEdit20A"), NULL, WS_CHILD|WS_VISIBLE|WS_VSCROLL|WS_TABSTOP
    |ES_READONLY|ES_WANTRETURN|ES_MULTILINE,  rect.left, rect.top, cx, cy,
    pParentWnd->m_hWnd, (HMENU)nID, NULL);


3. 设定选中的文字为链接显示
CHARFORMAT2 cf2;
ZeroMemory(&cf2, sizeof(CHARFORMAT2));//
cf2.cbSize = sizeof(CHARFORMAT2);
cf2.dwMask = CFM_LINK;
cf2.dwEffects |= CFE_LINK;
m_cRichEdit.SendMessage(EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&cf2);


4.支持链接的点击响应
m_cRichEdit.SetEventMask(ENM_LINK);


5.响应链接的点击EN_LINK

BEGIN_MESSAGE_MAP(CMyRichEdit, CRichEditCtrl)
ON_NOTIFY_REFLECT(EN_LINK,OnURL)
END_MESSAGE_MAP()
......

void CMyRichEdit::OnURLClick(NMHDR *pNmhdr, LRESULT *pResult)
{
    TCHAR LinkChar[512];
    ENLINK *pLink = (ENLINK *)pNmhdr;
    if (pLink->msg == WM_LBUTTONUP)
    {
        SetSel(penLink->chrg);//这是链接的文字范围
        long Res = GetSelText((char *)LinkChar);//这是链接文字
                  //后面是你的处理过程
                  ......
         }
    }

 

b.插入位图
http://www.codeguru.com/Cpp/controls/richedit/article.php/c2417/
http://www.codeguru.com/Cpp/controls/richedit/article.php/c5383/

自定义在RichEdit中插入对象的图标
http://www.blogcn.com/user3/jiangsheng/blog/1319738.html
方法基本同Knowledge Base文章Q220844 HOWTO: Insert a Bitmap Into an RTF Document Using the RichEdit Control
只是在最后插入之前调用一下IOleCache::SetData,用一个HGLOBAL作为参数,HGLOBAL里面的数据是一个METAFILEPICT结构,包含自己提供的图片

使用CRichEditView::InsertFileAsObject就可以插入图像。VC++带有一个例子WordPad。
另外可以参考“Insert any HBITMAP (Bitmap) in your RichEdit Control”(http://www.codeguru.com/richedit/richeditrc.html)。

c.显示GIF动画
常用的是通过qq的imageole.dll(也有用Gif89.dll的)
http://www.xiaozhou.net/cooldog/blogview.asp?logID=82
http://www.codeproject.com/richedit/AnimatedEmoticon.asp

在richedit控件中插入动态GIF (Native C++版)
http://blog.joycode.com/jiangsheng/archive/2004/12/15/41209.aspx

d.IRichEditOleCallback的使用
http://61.186.252.131/Expert/topic/905/905844.xml?temp=.8379022

类似 MSN 信息发送框的制作(上)
http://www.vckbase.com/document/viewdoc/?id=1087
内容包含:实现右键菜单,图片插入,读取/写入RTF格式字符串

自定义 CRichEditCtrl 控件
http://www.vckbase.com/document/viewdoc/?id=328
内容包含:鼠标右键消息,消息映射,字体变换

PS.richedit控件升级到2.0后,先把字体设为楷体,输入汉字没有问题,但输入字母时,字母自动跳转为Arial字体,而1.0却没有这个文题,仍然是用楷体显示字母
是一个专门的设计 Dual-font, Smart font apply, 参见 http://61.186.252.131/Expert/topic/913/913807.xml?temp=.3753778

posted @ 2010-08-01 21:06 wrh 阅读(508) | 评论 (0)编辑 收藏


TrueType字体通常包含在单个TrueType字体文件中,其文件后缀为.TTF。OpenType字体是以类似   于TrueType字体的格式编码的POSTSCRIPT字体。OPENTYPE字体使用.OTF文件后缀。OPENTYPE还允许把多个OPENTYPE字体组合在一个文件中以利于数据共享。这些字体被称为TrueType字体集(TrueType   colleCTion),其文件后缀为.TTC。  
        TrueType字体用machintosh的轮廓字体资源的格式编码,有一个唯一的标记名"sfnt"。windows没有macintosh的位图字体资源格式,字体目录   包含了字体格式的版本号和几个表,每个表都有一个tableentry结构项,tableentry结构包含了资源标记、校验和、偏移量和每个表的大小。下面是TrueType字体目录的c语言定义:  
  typedef   sturct  
  {  
  char   tag[4];  
  ULONG   checkSum;  
  ULONG   offset;  
  ULONG   length;  
  }TableEntry;  
   
  typedef   struct  
  {  
  Fixed   sfntversion;   //0x10000   for   version   1.0  
  USHORT   numTables;  
  USHORT   searchRange;  
  USHORT   entrySelector;  
  USHORT   rangeShift;  
  TableEntry   entries[1];//variable   number   of   TableEntry  
  }TableDirectory;  
   
          TrueType   字体中的所有数据都使用big-endian编码,最高位字节在最前面(因为TrueType字体最初是由apple公司定义的,而apple公司的os运行在motorola的cpu上)。如果一人TrueType字体以00   01   00   00   ,00   17开头,我们就可以知道它的格式是轮廓字体资源("sfnt")版本1.0的格式,有23个表。  
   
          TableDirectory结构的最后一个字段是可变长度的tableentry结构的数组,安体中的每个表对应其中一项。TrueType字体中的每个表都保存了不同的逻辑信息-----如图元中数据、字符到图元的映射、字距调整信息等等。有表是必须的,有些是可选的。下表列出了TrueType字体中常见的表。  
     
  head           字体头                                           字体的全局信息  
  cmap           字符代码到图元的映射               把字符代码映射为图元索引  
  glyf           图元数据                                       图元轮廓定义以及网格调整指令  
  maxp           最大需求表                                   字体中所需内存分配情况的汇总数据  
  mmtx           水平规格                                       图元水平规格  
  loca           位置表索引                                   把元索引转换为图元的位置  
  name           命名表                                           版权说明、字体名、字体族名、风格名等等  
  hmtx           水平布局                                       字体水平布局星系:上高、下高、行间距、最大前进宽度、最小左支撑、最小右支撑  
  kerm           字距调整表                                   字距调整对的数组  
  post           PostScript信息                           所有图元的PostScript   FontInfo目录项和PostScript名  
  PCLT           PCL   5数据                                     HP   PCL   5Printer   Language   的字体信息:字体数、宽度、x高度、风格、记号集等等  
  OS/2           OS/2和Windows特有的规格         TrueType字体所需的规格集  
          在TableDirectory结构中,所有的TableEntry结构都必须根据它们的标记名排序。比如,cmap必须出现在head前,而head必须在glyf前。但是实际的表可以出现在TrueType字体文件中的任意位置。  
          Win32API   提供了一个应用程序可用于查询原始TrueType字体信息的函数:  
  DWORD   GetFontData(HDC   hDC,DWORD   dwTable   ,DWORD   dwOffset,   LPVOID   lpbBuffer   ,DWORD   cbData);  
          GetFontData函数可以用于查询设备上下文中当前逻辑字体所对应的TrueType字体,因此传递的不是逻辑字体句柄,而是设备上下文句柄。你可以查询整个TrueType文件基是文件中的一个表。要查询整个文件的话dwTable参数应该为0;否则,应该传递要查询的表的四字符标记的DWORD格式。参数dwOffset是要查询的表中的起始偏移,要查询整个表的话应该为0;参数;pvBuffer是缓冲区的地址,cbData是缓冲区的大小。如果最后个参数为NULL和0,GetFontData函数返回字体文件或表的大小;就会把到的数据拷贝到应用程序所提供的缓冲区中。  
  下面的例和查询整个TrueType字体的原始数据:  
    TableDirctory   *   GetTrueTypeFont   (HDC   hDC   ,DWORD   &nFontSize)  
  {  
  //query   font   size  
  nFontSize=GetFontData(hDC,0,0,NULL,0);  
   
  TableDirectory   *   pFont   =(TableDirectory   *)new   BYTE(nFontSize);  
  if   (pFont==NULL)  
  return     NULL;  
  GetFontData(hDC,0,0,pFont,nFontSize);  
   
  return   pFont;  
  }  
          GetFontData使得应用程序能够在自己的文档中内嵌TrueType字体,以确保这些文档能在没有相应字体的其他机器上显示。它的做法是允许应用程序查询字体数据,然后写入到文档中作为文档的一部分,在文档被打于时再安装该字体以确保文档能以创建时同样的方式显示。比如,Windows   NT/2000的假脱机程序在打印到远端服务器时会在假脱机文件中内嵌入TrueType字体以保证文档能在另一台机器上正确地打印。  
  一旦接受到TrueType字体的原始数据,它的头中的TableDirectory结构很容易分析。需要检查的只有版本号和表的数目,然后就可以检查单个的表。我们来看一些重要的和有趣的表。  
  1.字体头  
      字体头表(head表)中包含了TrueType字体的全局信息。下面是字体头表的结构。  
  typedef   sturct  
  {  
  Fixed   Table;//x00010000   ro   version   1.0  
  Fixed   fontRevision;//Set   by   font   manufacturer.  
  ULONG   checkSumAdjustment;  
  ULONG   magicNumer;   //Set   to   0x5f0f3cf5  
  USHORT   flags;  
  USHORT   unitsPerEm;   //Valid   range   is   from   16   to   16384  
  longDT   created;   //International   date   (8-byte   field).  
  longDT   modified;   //International   date   (8-byte   field).  
  FWord   xMin;   //For   all   glyph   bounding   boxes.  
  FWord   yMin;   //For   all   glyph   bounding   boxes.  
  FWord   xMax;   //For   all   glyph   bounding   boxes.  
  FWord   xMax;   //For   all   glyph   bounding   boxes.  
  USHORT   macStyle;  
  USHORT   lowestRecPPEM;   //Smallest   readable   size   in   pixels.  
  SHORT   fontDirctionHint;  
  SHORT   indexToLocFormat;   //0   for   short   offsets   ,1   for   long.  
  SHORT   glyphDataFormat;     //0   for   current   format.  
  }Table_head;  
   
          字体的历史记录在三个字段中:字全版本号、字体最初创建时间和字体最后修改时间。有8   个字节用于记录时间戳,记录的是从1904年1月1日午夜12:00开始的秒数,因此我们不用担心y2k问题,或是什么y2m问题。  
          字体设计时是针对一个参考网格设计的,该网格被称为em-square,字体中的图元用网格中的坐标表示。因此em-squrare的大小决定胃该字体的图元被缩放的方式,同时也反映胃该字体的质量。字体头中保存了每个em-square的格数和能   包含所有图元的边界框。Em-square的有效值是从16到16384,常见的值是2048、4096和8192。比如,Windings字体的em-square的格数是2048,图元的边界框是[0,-432,2783,1841]。  
          字体头表中的其他信息包括最小可读像素大小、字体方向、在位置表中图元索引的格式和图元数据格式等等。  
  最大需求表  
          TrueType字体是一种非常灵活的数据结构,它可以包含可变数目的图元,每个图元可以有不同数目的控制点,甚至还可以有数量可变的图元指令。最大需求表的目的是告知字体栅格器(rasterizer)对内存的需求,以便   在出来字体前分配合适大小的内存。因为性能对字体栅格器非常重要,像MFC的CAarray那样需要频繁进行数据拷贝操作的动态增长的数据结构不合要求。下面是maxp表的结构。  
  typedef   struct  
  {  
  Fixed   Version;//0x00010000   for   version   1.0.  
  USHORT   numGlypha;   //Number   of   glyphs   in   the   font   .  
  USHORT   maxPoints;   //Max   points   in   noncomposite   glyph   .  
  RSHORT   maxContours;   //Max   contours   in   noncomposite   glyph.  
  USHORT   maxCompositePoints;//Max   points   in   a   composite   glyph.  
  USHORT   maxCompositeContours;   //Max   contours   in   a   composite   glyph.  
  USHORT   maxZones;//   1   if   not   use   the   twilight   zone   [Z0],  
                                  //or   2   if   so   use   Z0;2   in   most   cases.  
  USHORT   max   TwilightPoints   ;/   Maximum   points   used   in   Z0.  
  USHORT   maxStorage;   //Number   of   storage   area   locations.  
  USHORT   maxFunctionDefs;   //Number   of   FDEFs.  
  USHORT   maxStackElements;   //Number   of   depth.  
  USHORT   maxSizeOfInstructions;   //Max   byte   count   for   glyph   inst.  
  USHORT   maxComponentElements;   //Max   number   top   components   refernced.  
  USHORT   maxComponentDepth;       //Max   levels   of   recursion.  
  }Table_maxp;  
   
          numGlyphs字段保存了字体中图元的总数,这决定了到位置表的图元索引的数量,可以用于严正图元索引的有效性。TrueType字体中的每个图元都可以是合成图元或简单图元。简单图元可以有一条或多大体上轮廓中国,条用一些控制点定义。合成图元用几个其他图元的组合来定义。maxPoints\maxCountors\maxCompositePoints   maxCompositeContours这几个字段说明了图元定义的复杂度。  
          除了图元的定义,TrueType字体还使用了图元指令用于提示字体扫描器如何对控制点进行调整以得到更均衡更漂亮的光栅化后的图元。图元指令也可以出现在字体程序表(fpgm表)以及控制值程序表(“prep”)的全局字体层中。TrueType图元指令是一个伪计算机字节指令,该机类似于Java的虚拟机,这些指令可以用堆栈计算机执行。MaxStackElements   maxSizeOfInstructions两个字段同志堆栈计算机这些指令的复杂度。  
          以Windings字体为例,该字体有226个图元,图元最多有47条轮廓线,简单图元最多有268个点,合成图元最多有141个点,合成图元最多有14条轮廓线,最坏情况下需要492层堆栈,最长的指令有1119个字节。  
  字符到图元索引的映射表(cmap表)定义了从不同代码页中的字符   代码到图元索引的映射关系,这是在TrueType字体中存取图元信息的关键。cmap表包含几个了表以支持不同的平台和不同的字符编码方案。  
   
  下面是cmap表的结构。  
   
    typedef   struct  
  {  
  USHORT   Platform;   //platform   ID  
  USHORT   EncodingID;   //encoding   ID  
  ULONG   TableOffset   ;//offset   to   encoding   table  

typedef   struct   {  
  WCHAR   wcLow;  
  USHORT   cGlyphs;  
  }  
   
  typedef   struct    
  {  
  DWORD   cbThis;     //sizeof   (GLYPHSET)+sizeof(WCRANGE)+(cRanges-1)  
  DWORD   flAccel;  
  DWORD   cGlyphsSupported;  
  DWORD   cRanges;  
  WCRANGE   ranges[1];   //ranges[cRanges]  
  }GLYPHSET;  
   
  DWORD   GetFontUnicodeRanges(HDC   hDC,LPGLYPHSET   lpgs);  
  DWORD   GetGlyphIndices(HDC   hDC,LPCTSTR   lpstr,int   c   ,LPWORD   pgi,DWORD   fl);  
   
          通常一种字体只提供UNICODE字符集中的字符的一个子集。这些字符可以被分组为多个区域,cmap映射表中就是这么做的。GetFontUnicodeRanges函数在一个GLYPHSET结构中返回支持的图元的数量、支持的UNICODE区域的数量以及设备上下文中字体的这些区域的详细信息。GLYPHSET是一个可变长的结构   ,其大小取决于所支持的UNICODE区域的数量。因此,和Win32   API中支持可变长结构一样,       GetFontUnicodeRanges函数通常需要调用两   次。第一次调用时得到以NULL指针作为最后一莜参数,GDI会返回所需窨的大小。调用者然后分配所需的内存,再次调用以得到真正的数据。这两   种情况下,GetFontUnicodeRanges函数都会返回保存整个结构所需的数据大小。MSDN文档可能还是错误地描述成了如果第二个参数是NULL,GetFontUnicodeRanges函数返回指向GLYPHSET结构的指针。  
  下面是用于查询上下文中当前字体GLYPHSET结构的一个简单函数。  
  GLYPHSET   *QueryUnicodeRanges(HDC   hDC)  
  {  
  //query   for   size  
  DWORD   size=GetFontUnicodeRanges(hDC,NULL);  
   
  if   (size==0)   return   NULL;  
  GLYPHSET   *pGlyphSet=(GLYPHSET   *)new   BYTE(size);  
   
  //get   real   data  
  pGlyphSet->cbThis=size;  
  size=GetFontUnicodeRanges(hDC,pGlyphSet);  
   
  return   pGlyphSet;  
  }  
   
   
          如果在一些Windows   TrueType字体上试着调用GetFontUnicodeRanges函数,你会发现这些字体通常支持1000个以上的图元,这些图元被分成几百个UNICODE区域。比如,“Times   New   Roman”有我143个图元,分布在145个区域中,和一个区域是0x20到0x7f,即可打印的7位ASCII代码区域。  
  GetFontUnicodeRanges函数只使用了TrueType字体“cmap”表的一部分部分信息,即从UNICODE到图元索引的映射域。GetGlyphIndices函数则能真正使用这些映射关系把一个字符串转换为一个图元索引的数组。它接收一个设备上下文句柄、一个字符串指针、字符串长度、一个WORD数组的指针和一个标志。生成的图元索引将保存在WORD数组中。如果标志为GGI_MASK_NONEXISTING_GLYPHS,找不到的字符的图元索引会被标注成0xFFFF。此函数得到的图元索引可以传给其他GDI函数,如ExtTextOut函数。  
   
  2.位置索引  
   
          TrueType字体中最有用的信息是glyf表中的图元数据。有了图元索引,要找到相应的图元,需要表(loca表)索引以把图元索引转换为图元数据表内的偏移量。  
  位置索引表中保存了n+1个图元数据表的索引,其中n是保存在最大需求表中的图元数量。最后一个额外   的偏移量并不指向一个新图元,而是指向最后一个图元的偏移量和当前图元的偏移量和当前图元的偏移量间的差值得到图元的长度。  
  位置索引表中的每一个索引以无符号短整数对齐的,如果使用了短整数格式,索引表实际存储的是WORD偏移量,而不是BYTE偏移量。这合得短整数格式的位置索引表能   支持128KB大小的图元数据表。  
   
  3.图元数据  
        图元数据(glyf表)是TrueType字体的核心信息,因此通常它是最大的表。因为的位置索引是一张单独的表,图元数据表就完全只是图元的序列而已,每个图元以图元头结构开始:  
  typedef   struct    
  {  
  WORD   numberOfContours;   //contor   number,negative   if   composite  
  FWord   xMin;       //Minimum   x   for   coordinate   data.  
  FWord   yMin;       //Minimum   y   for   coordinate   data.  
  FWord   xMax;       //Maximum   x   for   coordinate   data.  
  FWord   yMax;       //Maximum   y   for   coordinate   data.  
  }GlyphHeader;  
   
          对于简单图元,numberOfContours字段中保存的是当前图元的轮廓线的树木;对于合成图元,numberOfContours字段是一个负值。后者的轮廓线的总数必须基于组成该合成图元的所有图元的数据计算得到。GlyphHeader结构中后四个字段记录了图元的边界框。  
        对于简单图元,图元的描述紧跟在GlyphHeader结构之后。图元的描述由几部分信息组成:所有轮廓线结束点的索引、图元指令和一系列的控制点。每个控制点包括一个标志以x和y坐标。概念上而言,控制所需的信息和GDI函数PolyDraw函数所需的信息相同:一组标志和一组点的坐标。但TrueType字体中的控制点的编码要复杂得多。下面是图元描述信息的概述:  
  USHORT   endPtsOfContours[n];   //n=number   of   contours  
  USHORT   instructionlength;  
  BYTE   instruction[i];       //i   =   instruction   length  
  BYTE   flags[];                   //variable   size  
  BYTE   xCoordinates[];     //variable   size  
  BYTE   yCoordinates[];     //variable   size  
          图元可以包含一条或多条轮廓线。比如,字母"O"有两   条轮廓线,一条是内部的轮廓,另一条是外部的轮廓。对于每一条轮廓线,endPtsOfContours数组保存了其终点的索引,从该索引中可以计算出轮廓线中点的数量。比如,endPtsOfContours[0]是第一休轮廓线上点的数量,endPtsOfContours[1]-endPtsOfContours[0]是第二条轮廓线上点的数量。  
          终点数组后是图元指令通知度和图元指令数组。我们先跳过它们,先来讨论冬至点。图元的控制点保存在三个数组中:标志获得组、x坐标数组和y坐标数组。找到标志数组的起始点很简单,但是标志数组没有相应的长度字,也没有直接其他两个数组的方法,你必须先解码标志数组才能解释x和y坐标数组。  
          我们提到棕em-square被限制为最大为16384个网格,因此通常情况下需要各两个字节来表示x坐标和y坐标。为了节省空间,图元中保存的是相对坐标。第一个点的坐标是相对(0,0)记录的,所有随后的点记录者是和上一个点的坐标差值。有些差值可以用一个字节表示,有些差值为0,另外一些差值则无法用耽搁字节表示。标志数组保存了每个坐标的编码信息以及其他一些信息。下面是标志中各个位的含义的总结:  
   
  typedef   enum  
  {  
  G_ONCURVE       =   0x01,   //   on   curve   ,off   curve  
  G_REPEAT   =0x08,       //next   byte   is   flag   repeat   count    
  G_XMASK       =0x12,    
  G_XADDBYTE   =0x12,   //X   is   positive   byte  
  G_XSUBBYTE   =0x12,   //X   is   negative   byte    
  G_XSAME     =0x10,   //X   is   same  
  G_XADDINT   =0x00,   //X   is   signed   word    
   
  G_YMASK     =0x24,  
  G_YADDBYTE   =0x24,   //Y   is   positive   byte    
  G_YSUBBYTE   =0x04,   //Y   is   negative   byte  
  G_YSAME   =0x20   ,       //Y   is   same  
  G_YADDINT   =0x00,   //Y   is   signed   word  
  };  
   
          在第8章中我们讨论了直线和曲线,我们提到了一段三阶Bezier曲线有四个控制点定义:位于曲线上(on-curve)的起始点、两个不在曲线上(off-curve)的控制点和一个曲线上的结束点。TureType字体中的图元轮廓是用二阶Bezier曲线定义的,有三个点:一个曲线上的点,一个曲线外的点和另一个曲线上的点。多个连续的不在曲线上的点是允许的,但不是用来定义三阶或更高阶的Bezier曲线,而是为了减少控制点的数目。比如,对于on-off-off-on模式的四个点,会加入一个隐含的点使之成为on-off-on-off-on,因此定义的是两段二阶Bezier曲线。  
          如果设置了G_ONCURVE位,那么控制点在曲线上,否则不在曲线上。如果设置了G_REPEAT,标志数组中的下一字节表示重复次数,当前标志应该重复指定的次数。因此,标志数组中实际使用了某种类型的行程编码。标志中的其他位用于描述相应   的x坐标和y坐标的编码方式,它们可以表示当前相寻坐标是否和上一个相同、正的单字节值、负的单字节值或有符号两字节值。  
          解码图元的描述是一个两次扫描的起始点。然后再遍历图元定义中的每一个点把它转换为更容易管理的格式。程序清单14-2列出了解码TrueType图元的函数,它是KTrueType类的一个方法。  
   
  int   KTrueType::DecodeGlyph(int   index,   KCurve   &   curve,   XFORM   *   xm)   const  
  {  
  const   GlyphHeader   *   pHeader   =   GetGlyph(index);  
   
  if   (   pHeader==NULL   )  
  {  
  // assert(false);  
  return   0;  
  }  
   
  int nContour   =   (short)   reverse(pHeader->numberOfContours);  
   
  if   (   nContour<0   )  
  {  
  return   DecodeCompositeGlyph(pHeader+1,   curve);   //   after   the   header  
  }  
   
  if   (   nContour==0   )  
  return   0;  
   
  curve.SetBound(reverse((WORD)pHeader->xMin),   reverse((WORD)pHeader->yMin),    
                        reverse((WORD)pHeader->xMax),   reverse((WORD)pHeader->yMax));  
   
  const   USHORT   *   pEndPoint   =   (const   USHORT   *)   (pHeader+1);  
   
  int   nPoints   =   reverse(pEndPoint[nContour-1])   +   1;     //   endpoint   of   last   contour   +   1  
  int   nInst       =   reverse(pEndPoint[nContour]);       //   instructon   length  
   
  curve.m_glyphindex   =   index;  
  curve.m_glyphsize     =   (int)   GetGlyph(index+1)   -   (int)   GetGlyph(index);  
  curve.m_Ascender       =   m_Ascender;  
  curve.m_Descender     =   m_Descender;  
  curve.m_LineGap         =   m_LineGap;  
   
  GetMetrics(index,   curve.m_advancewidth,   curve.m_lsb);  
   
  if   (   curve.m_glyphsize==0   )  
  return   0;  
   
  curve.m_instrsize     =   nInst;  
   
  const   BYTE   *   pFlag   =   (const   BYTE   *)   &   pEndPoint[nContour]   +   2   +   nInst; //   first   byte   in   flag  
  const   BYTE   *   pX         =   pFlag;  
   
  int   xlen   =   0;  
   
  for   (int   i=0;   i<nPoints;   i++,   pX++)  
  {  
  int   unit   =   0;  
   
  switch   (   pX[0]   &   G_XMASK   )  
  {  
  case   G_XADDBYTE:  
  case   G_XSUBBYTE:  
  unit   =   1;  
  break;  
   
  case   G_XADDINT:  
  unit   =   2;  
  }  
   
  if   (   pX[0]   &   G_REPEAT   )  
  {  
  xlen   +=   unit   *   (pX[1]+1);    
   
  i   +=   pX[1];  
  pX   ++;  
  }  
  else  
  xlen   +=   unit;  
  }  
   
  const   BYTE   *   pY   =   pX   +   xlen;  
   
  int   x   =   0;  
KTrueType类处理TrueType字体的装入和解码,随书光盘中有它的完整源代码。DecodeGlyph给出图元索引和可选的变换矩阵,处理的是单个图元的解码。参数curve是KCurve类,用于把TrueType图元定义保存为32位的点的赎罪以及一个标志数组,以梗用GDI进行显示。这些代码可以作为简单TrueType字体编辑器的基础。  
          代码中调用了GetGlyph方法,该方法用位置表索引找到该图元的GlyphHeader结构。从中得到图元的轮廓线数目。注意必须反转该值的字节序,因为TrueType字体用的是Big-Endian字节序。如果该值为负值,说明这是一个合成图元,应该转而调用DecodeCompositeGlyph方法。接下支的代码定位了endPtsOfContours数组,找出点的总数,然后跳过指令找到标志数组的起始位置。  
          接下去需要长到的是x坐标数组的始位置和长度,这需要遍历标志数组一次。对于每一个控制点,它在x坐标数组中所占空间可能为0到2个字节,这取决于它的相对坐标是0、单个字节还是两个字节。  
          根据x坐标数组的地址和长度可以得到y坐标的地址。接下去的代码遍历所有的轮廓线,解码其中的控制点,把相对坐标转换为绝对坐标,然后把它加入到曲线对象中。如果需要的话,会对每个控制点做变换。  
  回想一下,TrueType使用的是二阶Bezier曲线,允许在两个曲线上的点之间有多个不在曲线上的点。为了简化曲线绘制算法,KCurve::Add方法在每两个不在曲线上的点之间加入一个额外的在曲线上的点。  
   
          处理了简单图元之后,我们来看看合成图元。合成图元用一个经变换的图元序列定义。每个经变换的图元的定义包括三个部分:一个标志、一个图元索引和一个变换矩阵。标志字段决定了变换矩阵的编码方式。编码的目的也是为了节省一些空间,加外还说明了是否已到达序列的终点。一个完整的2D   affine变换需要6个值。但如果只是平移的话,只需要两个值(dx,dy),这两个值可以保存为两个字节或两个字。如果x和y以相同的值缩放,加外还需要一个缩放值。取一般的情况下仍然需要6个值,但是很多时候可以节省几个字节。用于变换的值以2.14的有符号定点格式保存,dx和dy值除外,这两个值以整数形式保存。得到合成图元的过程实际上是变换和组合几个图元的过程。比如,如果字体中的一个图元是另一个图元的精确镜像,它只需定义为一个合成图元,可以通过对另一个图像做镜像变换即可。程序清单14-3列出了解码合成图元的代码。  
   
   
  int   KTrueType::DecodeCompositeGlyph(const   void   *   pGlyph,   KCurve   &   curve)   const  
  {  
  KDataStream   str(pGlyph);  
   
  unsigned   flags;  
   
  int   len   =   0;  
   
  do    
  {  
  flags             =   str.GetWord();  
   
  unsigned   glyphIndex   =   str.GetWord();  
   
  //   Argument1   and   argument2   can   be   either   x   and   y   offsets   to   be   added   to   the   glyph   or   two   point   numbers.    
  //   In   the   latter   case,   the   first   point   number   indicates   the   point   that   is   to   be   matched   to   the   new   glyph.    
  //   The   second   number   indicates   the   new   glyph's   "matched"   point.   Once   a   glyph   is   added,   its   point   numbers    
  //   begin   directly   after   the   last   glyphs   (endpoint   of   first   glyph   +   1).    
   
  //   When   arguments   1   and   2   are   an   x   and   a   y   offset   instead   of   points   and   the   bit   ROUND_XY_TO_GRID   is   set   to   1,    
  //   the   values   are   rounded   to   those   of   the   closest   grid   lines   before   they   are   added   to   the   glyph.    
  //   X   and   Y   offsets   are   described   in   FUnits.    
   
  signed   short   argument1;  
  signed   short   argument2;  
   
  if   (   flags   &   ARG_1_AND_2_ARE_WORDS   )  
  {  
  argument1   =   str.GetWord();   //   (SHORT   or   FWord)   argument1;  
  argument2   =   str.GetWord();   //   (SHORT   or   FWord)   argument2;  
  }    
  else    
  {  
  argument1   =   (signed   char)   str.GetByte();  
  argument2   =   (signed   char)   str.GetByte();  
  }  
   
  signed   short   xscale,   yscale,   scale01,   scale10;  
   
  xscale     =   1;  
  yscale     =   1;  
  scale01   =   0;  
  scale10   =   0;  
   
  if   (   flags   &   WE_HAVE_A_SCALE   )  
  {  
  xscale   =   str.GetWord();  
  yscale   =   xscale; //   Format   2.14    
  }    
  else   if   (   flags   &   WE_HAVE_AN_X_AND_Y_SCALE   )    
  {  
  xscale   =   str.GetWord();  
  yscale   =   str.GetWord();  
  }    
  else   if   (   flags   &   WE_HAVE_A_TWO_BY_TWO   )    
  {  
  xscale     =   str.GetWord();  
  scale01   =   str.GetWord();  
  scale10   =   str.GetWord();  
  yscale     =   str.GetWord();  
  }  
   
  if   (   flags   &   ARGS_ARE_XY_VALUES   )  
  {  
  XFORM   xm;  
   
  xm.eDx     =   (float)   argument1;  
  xm.eDy     =   (float)   argument2;  
  xm.eM11   =   xscale     /   (float)   16384.0;  
  xm.eM12   =   scale01   /   (float)   16384.0;  
  xm.eM21   =   scale10   /   (float)   16384.0;  
  xm.eM22   =   yscale     /   (float)   16384.0;  
   
  len   +=   DecodeGlyph(glyphIndex,   curve,   &   xm);  
  }  
  else  
  assert(false);  
  }    
  while   (   flags   &   MORE_COMPONENTS   );  
   
  if   (   flags   &   WE_HAVE_INSTRUCTIONS   )  
  {  
  unsigned   numInstr   =   str.GetWord();  
   
  for   (unsigned   i=0;   i<numInstr;   i++)  
  str.GetByte();  
  }  
   
  //   The   purpose   of   USE_MY_METRICS   is   to   force   the   lsb   and   rsb   to   take   on   a   desired   value.    
  //   For   example,   an   i-circumflex   (Unicode   00ef)   is   often   composed   of   the   circumflex   and   a   dotless-i.    
  //   In   order   to   force   the   composite   to   have   the   same   metrics   as   the   dotless-i,    
  //   set   USE_MY_METRICS   for   the   dotless-i   component   of   the   composite.   Without   this   bit,    
  //   the   rsb   and   lsb   would   be   calculated   from   the   HMTX   entry   for   the   composite   (or   would   need   to   be    
  //   explicitly   set   with   TrueType   instructions).    
   
  //   Note   that   the   behavior   of   the   USE_MY_METRICS   operation   is   undefined   for   rotated   composite   components.  
   
  return   len;  
  }  
   
   
   
          DecodeCompositeGlyph方法解码每个图元的标志、图元索引和变换矩阵,然后调用DecodeGlypgh方法进行解码。注意,对DecodeGlyph方法的调用包含一个有效的变换矩阵参数。当MORE_COMPONENTS标志结束时,该方法随之结束。随书光盘中有该方法完整的源代码。  
          解码后的TrueType字体的图元要用GDI绘制还有一个小问题需要处理。GDI只绘制三阶Bezier曲线,因此从图元表解码所得的二阶Bezier曲线的控制点需要转换为三阶Bezier曲线的控制点。通过对Bezier曲线原始数学定义的研究,可以得到如下用GDI绘制二阶Bezier曲线的简单例程。  
   
  //draw   a   2nd-degree   Bezier   curve   segment  
  BOOL   Bezier2(HDC   hDC,int   &   x0,int   &   y0,   int   x1,   int   y1,   int   x2   ,int   y2)  
  {  
  //   p0   p1   p2   -   >   p0   (p0   +   2p1)/3   (2p1+p2)/3,   p2  
   
  POINT   P[3]   =   {   {   (x0+2*x1)/3,(y0+2*y1)/3},  
                                {(2*x1+x2)/3,(2*y1+y2)/3},  
                                {x2,y2}   };  
  x0=x2;y0=y2;  
  return   PolyBezierTo(hDC,P,3);  
  }  
   
          对于用三个控制点(p0,p1,p2)定义的二阶Bezier曲线,相应的三阶Bezier曲线的控制点为(p0,(p0+2*p1)/3,(2*p1+p2)/3,p2)。  
   
   
  4.图元指令  
          程序清单14-2和14-3给人的印象是TrueType字体的栅格器可以通过扫描和转换图元的轮廓来轻松地实现,比如,用GDI和StrokeAndFillPath函数来填充图元轮廓绘制出来的路径。这种简单的字体栅格器的实现并不是很有用,除非它只用于高分辨诣的设备如打印机等。  
          简单栅格器得到的图像笔画粗细不一,有信息的遗漏,有字符特征的损失以及不对称等缺陷。当点阵变小是,情况不会更糟。总之,简单字体栅格器在小尺寸时会产生字迹模糊的结果。在大尺寸时会产生不好看的结果,只有在点阵增大时结果才会改善。  
          当在大的em-square(典型的是2048)中定义的图元轮廓缩小为小得多的网格时(如32*32),不可避免会损失精度并引入误差。  
   
          TrueType解决这个问题的方法是控制图元轮廓从em-square到栅格网格的缩放过程,使得到的结果看起来效果更好,和原始图元的设计尽量接近。这种技术被称为网格调整(grid   fitting),它想达到的目标有:  
          消除网格位置的可能影响,保证笔画的粗细和网格的相对位置无关。  
          控制图元中关键位置的尺寸  
          保持对称性和衬线等   重要的图元设计细节。  
       
            TrueType字体中网格调整的需求在两个地方中编码:控制值表(control   value   table)和每个图元的网格调整指令。  
          控制值表("cvt"表)用于保存一个数组,这些值被称为网格调整指令。比如,对于有衬线的字体,基线、衬线高度、大写字母笔划的宽度等值都或以是被控制的值。它们可以以字体设计者已知的次序保存在控制值表中,然后用它们的索引来引用。在字体光栅化过程中,控制值表中的值根据点阵的大小缩放。在网络调整指令中引用这些值   可以保证使用的值与网枸的位置无关。比如,如果水平线[14,0,25,200]可以用CVT表中的两个值定义为[14,0,14+CVT[stem_width],0+CVT[cap_height]],那     么该线的宽度和高度会和所在网格的相对位置无关,保持不变。  
          每一个图元的定义中附加有一个指令序列,该指令序列被称为图元指令,该背景令序列用于控制此图元的网格高速。图元指令线用控制值表中的值,以保证在索引图元中这些值相同。  
          图元指令是一种基于堆栈的伪计算机的指令。堆栈计算机常用于计算机语言的解释性实现。比如,Forth(用于嵌入式系统的一种强大而简洁的语言)、RPL(HP计算器使用的语言)和Java虚拟机都是堆栈计算机。  
          堆栈计算机通常没有寄存器,所有的计算都在堆栈上进行(有些堆栈计算机使用分开的控制堆栈和数据堆栈)。比如,压入指令把一个值压入堆栈,弹出指令从堆栈中弹出上面的值,二元加法指令弹出上面的两   个值   ,然后把它们的和压入堆栈。


本文来自CSDN博客,转载请标明出处:http://blog.csdn.net/clq271520093/archive/2008/01/17/2048257.aspx

posted @ 2010-07-30 13:59 wrh 阅读(1610) | 评论 (0)编辑 收藏
GB2312码是中华人民共和国国家汉字信息交换用编码,全称《信息交换用汉字编码字符集——基本集》,由国家标准总局发布,1981年5月1日实施,通行于大陆。新加坡等地也使用此编码。

  GB2312收录简化汉字及符号、字母、日文假名等共7445个图形字符,其中汉字占6763个。GB2312规定“对任意一个图形字符都采用两个字节表示,每个字节均采用七位编码表示”,习惯上称第一个字节为“高字节”,第二个字节为“低字节”。

  GB2312将代码表分为94个区,对应第一字节;每个区94个位,对应第二字节,两个字节的值分别为区号值和位号值加32(2OH),因此也称为区位码。01-09区为符号、数字区,16-87区为汉字区,10-15区、88-94区是有待进一步标准化的空白区。GB2312将收录的汉字分成两级:第一级是常用汉字计3755个,置于16-55区,按汉语拼音字母/笔形顺序排列;第二级汉字是次常用汉字计3008个,置于56-87区,按部首/笔画顺序排列。故而GB2312最多能表示6763个汉字。
posted @ 2010-07-30 13:42 wrh 阅读(659) | 评论 (0)编辑 收藏
为了使每一个汉字有一个全国统一的代码,1980年,我国颁布了第一个汉字编码的国家标准:GB2312-80《信息交换用汉字编码字符集》基本集,这个字符集是我国中文信息处理技术的发展基础,也是目前国内所有汉字系统的统一标准。到了后来又公布了国家标准GB18030-2000《信息交换用汉字编码字符集基本集的扩充》,简称GB18030。由于国标码是四位十六进制,为了便于交流,大家常用的是四位十进制的区位码。所有的国标汉字与符号组成一个94×94的矩阵。在此方阵中,每一行称为一个"区",每一列称为一个"位",因此,这个方阵实际上组成了一个有94个区(区号分别为0 1到94)、每个区内有94个位(位号分别为01到94)的汉字字符集。一个汉字所在的区号和位号简单地组合在一起就构成了该汉字的"区位码"。在汉字的区位码中,高两位为区号,低两位为位号。在区位码中,01-09区为682个特殊字符,16-87区为汉字区,包含6763个汉字 。其中16-55区为一级汉字(3755个最常用的汉字,按拼音字母的次序排列),56-87区为二级汉字(3008个汉字,按部首次序排列)。
    从汉字到区位码的转换。区位码是与汉字一一对应的编码,用四位数字表示, 前两位从01 到94称区码,后两位从01到94称位码。 一个汉字的前一半为“160+区码”的字符,后一半为“160+ 位码”的字符。例如:“刘”的区位码是 3385,其意为区码33位码85,它是由160+33=193和160+85=245的两个字节组成。即 0xC1F5,它就是汉字的 gb2312 编码。
下面程序将汉字 gb2312 转为相应的区位码:

#include <iostream>
#include <iomanip>
using namespace std;
int main()
{
   // temp[0] 为高字节,temp[1] 为低字节
   // 当输入单个 ascii 字符时,只存进 temp[0]
   // 当输入的不是中文或单个 ascii 字符时,程序退出
   unsigned char temp[2];
   cin >> temp;
   while(temp[1])
   {
      cout << setw(2) << setfill('0') << temp[0] - 160;  // 高 2 位
      cout << setw(2) << setfill('0') << temp[1] - 160 << endl; // 低 2 位
      // 输入下一个字符前,先将 temp[1] 清零
      temp[1] = 0;
      cin >> temp;
   }
   return 0;
}

字符编码简介
    Unicode是一种字符编码规范。先从ASCII说起。ASCII是用来表示英文字符的一种编码规范,每个ASCII字符占用1个字节(8bits)。因此,ASCII编码可以表示的最大字符数是256,其实英文字符并没有那么多,一般只用前128个(最高位为0),其中包括了控制字符、数字、大小写字母和其他一些符号 。而最高位为1的另128个字符被成为“扩展ASCII”,一般用来存放英文的制表符、部分音标字符等等的一些其他符号。这种字符编码规范显然用来处理英文没有什么问题。(实际上也可以用来处理法文、德文等一些其他的西欧字符,但是不能和英文通用),但是面对中文、阿拉伯文之类复杂的文字,255个字符显然不够用,于是,各个国家纷纷制定了自己的文字编码规范,其中中文的文字编码规范叫做“GB2312-80”,它是和ASCII兼容的一种编码规范,其实就是利用扩展ASCII没有真正标准化这一点,把一个中文字符用两个扩展ASCII字符来表示。但是这个方法有问题,最大的问题就是,中文文字没有真正属于自己的编码,因为扩展ASCII码虽然没有真正的标准化,但是PC里的ASCII码还是有一个事实标准的(存放着英文制表符),所以很多软件利用这些符号来画表格。这样的软件用到中文系统中,这些表格符就会被误认作中文字,破坏版面。而且,统计中英文混合字符串中的字数,也是比较复杂的,我们必须判断一个ASCII码是否扩展,以及它的下一个ASCII是否扩展,然后才“猜”那可能是一个中文字 。
    总之当时处理中文是很痛苦的。而更痛苦的是GB2312是国家标准,台湾当时有一个Big5编码标准,很多编码和GB是相同的,所以……,嘿嘿。这时候,我们就知道,要真正解决中文问题,不能从扩展ASCII的角度入手,也不能仅靠中国一家来解决。而必须有一个全新的编码系统,这个系统要可以将中文、英文、法文、德文……等等所有的文字统一起来考虑,为每个文字都分配一个单独的编码,这样才不会有上面那种现象出现。于是,Unicode诞生了。
    Unicode有两套标准,一套叫UCS-2(Unicode-16),用2个字节为字符编码,另一套叫UCS-4(Unicode-32),用4个字节为字符编码。以目前常用的UCS-2为例,它可以表示的字符数为2^16=65535,基本上可以容纳所有的欧美字符和绝大部分的亚洲字符 。UTF-8的问题后面会提到。在Unicode里,所有的字符被一视同仁。汉字不再使用“两个扩展ASCII”,而是使用“1个Unicode”,注意,现在的汉字是“一个字符”了,于是,拆字、统计字数这些问题也就自然而然的解决了。但是,这个世界不是理想的,不可能在一夜之间所有的系统都使用Unicode来处理字符,所以Unicode在诞生之日,就必须考虑一个严峻的问题:和ASCII字符集之间的不兼容问题。我们知道,ASCII字符是单个字节的,比如“A”的ASCII是65。而Unicode是双字节的,比如“A”的Unicode是0065,这就造成了一个非常大的问题:以前处理ASCII的那套机制不能被用来处理Unicode了。另一个更加严重的问题是,C语言使用'\0'作为字符串结尾,而Unicode里恰恰有很多字符都有一个字节为0,这样一来,C语言的字符串函数将无法正常处理Unicode,除非把世界上所有用C写的程序以及他们所用的函数库全部换掉。于是,比Unicode更伟大的东东诞生了,之所以说它更伟大是因为它让Unicode不再存在于纸上,而是真实的存在于我们大家的电脑中。那就是:UTF。UTF = UCS Transformation Format UCS转换格式。它是将Unicode编码规则和计算机的实际编码对应起来的一个规则。现在流行的UTF有2种:UTF-8和UTF-16。其中UTF-16和上面提到的Unicode本身的编码规范是一致的,这里不多说了。而UTF-8不同,它定义了一种“区间规则”,这种规则可以和ASCII编码保持最大程度的兼容。UTF-8有点类似于Haffman编码,它将Unicode编码为00000000-0000007F的字符,用单个字节来表示;00000080-000007FF的字符用两个字节表示00000800-0000FFFF的字符用3字节表示。因为目前为止Unicode-16规范没有指定FFFF以上的字符,所以UTF-8最多是使用3个字节来表示一个字符。但理论上来说,UTF-8最多需要用6字节表示一个字符。在UTF-8里,英文字符仍然跟ASCII编码一样,因此原先的函数库可以继续使用。而中文的编码范围是在0080-07FF之间,因此是2个字节表示(但这两个字节和GB编码的两个字节是不同的),用专门的Unicode处理类可以对UTF编码进行处理。
    下面说说中文的问题。由于历史的原因,在Unicode之前,一共存在过3套中文编码标准。GB2312-80,是中国大陆使用的国家标准,其中一共编码了6763个常用简体汉字。Big5,是台湾使用的编码标准,编码了台湾使用的繁体汉字,大概有8千多个。HKSCS,是中国香港使用的编码标准,字体也是繁体,但跟Big5有所不同。这3套编码标准都采用了两个扩展ASCII的方法,因此,几套编码互不兼容,而且编码区间也各有不同。因为其不兼容性,在同一个系统中同时显示GB和Big5基本上是不可能的。后来,由于各方面的原因,国际上又制定了针对中文的统一字符集GBK和GB18030,其中GBK已经在Windows、Linux等多种操作系统中被实现。GBK兼容GB2312,并增加了大量不常用汉字,还加入了几乎所有的Big5中的繁体汉字。但是GBK中的繁体汉字和Big5中的几乎不兼容。GB18030相当于是GBK的超集,比GBK包含的字符更多。
    谈谈Unicode编码,简要解释UCS、UTF、BMP、BOM等名词
    这是一篇程序员写给程序员的趣味读物。所谓趣味是指可以比较轻松地了解一些原来不清楚的概念,增进知识,类似于打RPG游戏的升级。整理这篇文章的动机是两个问题:
问题一:
    使用Windows记事本的“另存为”,可以在GBK、Unicode、Unicode big endian和UTF-8这几种编码方式间相互转换。同样是txt文件,Windows是怎样识别编码方式的呢?
    Unicode、Unicode big endian和UTF-8编码的txt文件的开头会多出几个字节,分别是FF、FE(Unicode),FE、FF(Unicode big endian),EF、BB、BF(UTF-8)。但这些标记是基于什么标准呢?
问题二:
    最近在网上看到一个ConvertUTF.c,实现了UTF-32、UTF-16和UTF-8这三种编码方式的相互转换。对于Unicode(UCS2)、GBK、UTF-8这些编码方式,我原来就了解。但这个程序让我有些糊涂,想不起来UTF-16和UCS2有什么关系。
    查了查相关资料,总算将这些问题弄清楚了,顺带也了解了一些Unicode的细节。写成一篇文章,送给有过类似疑问的朋友。本文在写作时尽量做到通俗易懂,但要求读者知道什么是字节,什么是十六进制。
 
0、big endian和little endian
    big endian和little endian是CPU处理多字节数的不同方式。例如“汉”字的Unicode编码是6C49。那么写到文件里时,究竟是将6C写在前面,还是将49写在前面?如果将6C写在前面,就是big endian。若是将49写在前面,就是little endian。
 
1、字符编码、内码,顺带介绍汉字编码
    字符必须编码后才能被计算机处理。计算机使用的缺省编码方式就是计算机的内码。早期的计算机使用7位的ASCII编码,为了处理汉字,程序员设计了用于简体中文的GB2312和用于繁体中文的big5。
    从ASCII、GB2312、GBK到GB18030,这些编码方法是向下兼容的,即同一个字符在这些方案中总是有相同的编码,后面的标准支持更多的字符。在这些编码中,英文和中文可以统一地处理。区分中文编码的方法是高字节的最高位不为0。按照程序员的称呼,GB2312、GBK到GB18030都属于双字节字符集 (DBCS)。
    有的中文Windows的缺省内码还是GBK,可以通过GB18030升级包升级到GB18030。不过GB18030相对GBK增加的字符,普通人是很难用到的,通常我们还是用GBK指代中文Windows内码。
    在DBCS中,GB内码的存储格式始终是big endian,即高位在前。GB2312的两个字节的最高位都是1。但符合这个条件的码位只有128*128=16384个。所以GBK和GB18030的低字节最高位都可能不是1。不过这不影响DBCS字符流的解析:在读取DBCS字符流时,只要遇到高位为1的字节,就可以将下两个字节作为一个双字节编码,而不用管低字节的高位是什么。
 
2、Unicode、UCS和UTF
    前面提到从ASCII、GB2312、GBK到GB18030的编码方法是向下兼容的。而Unicode只与ASCII兼容(更准确地说,是与ISO-8859-1兼容),与GB码不兼容。例如“汉”字的Unicode编码是6C49,而GB码是BABA。
    Unicode也是一种字符编码方法,不过它是由国际组织设计,可以容纳全世界所有语言文字的编码方案。Unicode的学名是"Universal Multiple-Octet Coded Character Set",简称为UCS。UCS可以看作是"Unicode Character Set"的缩写。UCS规定了怎么用多个字节表示各种文字。怎样传输这些编码,是由UTF(UCS Transformation Format)规范规定的,常见的UTF规范包括UTF-8、UTF-7、UTF-16。
 
3、UTF编码
    UTF-8就是以8位为单元对UCS进行编码。从UCS-2到UTF-8的编码方式如下:
    UCS-2编码(16进制) UTF-8 字节流(二进制)
    0000 - 007F 0xxxxxxx
    0080 - 07FF 110xxxxx 10xxxxxx
    0800 - FFFF 1110xxxx 10xxxxxx 10xxxxxx
    例如“汉”字的Unicode编码是6C49。6C49在0800-FFFF之间,所以肯定要用3字节模板了:1110xxxx 10xxxxxx 10xxxxxx。将6C49写成二进制是:0110 110001 001001, 用这个比特流依次代替模板中的x,得到:11100110 10110001 10001001,即E6 B1 89。
    UTF-16以16位为单元对UCS进行编码。对于小于0x10000的UCS码,UTF-16编码就等于UCS码对应的16位无符号整数。对于不小于0x10000的UCS码,定义了一个算法。不过由于实际使用的UCS2,或者UCS4的BMP必然小于0x10000,所以就目前而言,可以认为UTF-16和UCS-2基本相同。但UCS-2只是一个编码方案,UTF-16却要用于实际的传输,所以就不得不考虑字节序的问题。
 
4、UTF的字节序和BOM
    UTF-8以字节为编码单元,没有字节序的问题。UTF-16以两个字节为编码单元,在解释一个UTF-16文本前,首先要弄清楚每个编码单元的字节序。例如收到一个“奎”的Unicode编码是594E,“乙”的Unicode编码是4E59。如果我们收到UTF-16字节流“594E”,那么这是“奎”还是“乙”?Unicode规范中推荐的标记字节顺序的方法是BOM。是Byte Order Mark。BOM是一个有点小聪明的想法:在UCS编码中有一个叫做"ZERO WIDTH NO-BREAK SPACE"的字符,它的编码是FEFF。而FFFE在UCS中是不存在的字符,所以不应该出现在实际传输中。UCS规范建议我们在传输字节流前,先传输字符"ZERO WIDTH NO-BREAK SPACE"。这样如果接收者收到FEFF,就表明这个字节流是Big-Endian的;如果收到FFFE,就表明这个字节流是Little-Endian的。因此字符"ZERO WIDTH NO-BREAK SPACE"又被称作BOM。
    UTF-8不需要BOM来表明字节顺序,但可以用BOM来表明编码方式。字符"ZERO WIDTH NO-BREAK SPACE"的UTF-8编码是EF BB BF。所以如果接收者收到以EF BB BF开头的字节流,就知道这是UTF-8编码了。Windows就是使用BOM来标记文本文件的编码方式的。
posted @ 2010-07-30 09:18 wrh 阅读(994) | 评论 (0)编辑 收藏

在处理图形运算,特别是3D图形生成运算时,往往要定义一个Fixed数据类型,我称它为定点数,定点数其时就是一个整形数据类型,他的作用就是把所有数进行转换,从而得到相应类型的整型表达,然后使用定点数进行整行运算,取到最终值并将其转换回实际的基本数据类型。因此它是通过避免大量的浮点运算来加快图形处理的一个方式。

现在来定义下定点数的转换法则,定点数有8位单字节转换或16位双字节转换:区别只是一个要8移位,一个要做16移位

8位

typedef long FIXED;                                              // long型定点类型

#define itofx(i_x) ((i_x) << 8)                                  // 整转定点

#define ftofx(f_x) (long)((f_x) * 256)                           // 浮点转定点

#define dtofx(d_x) (long)((d_x) * 256)                           // 双精度转定点

#define fxtoi(fx_x) ((fx_x) >> 8)                                // 定点转整

#define fxtof(fx_x) ((float) (fx_x) / 256)                       // 定点转浮点

#define fxtod(fx_x) ((double)(fx_x) / 256)                       // 定点转双精度

#define Mulfx(fx_x,fx_y) (((fx_x) * (fx_y)) >> 8)                // 定点积得定点

#define Divfx(fx_x,fx_y) (((fx_x) << 8) / (fx_y))                // 定点除得定点

16位

typedef int FIXED;                                               // long型定点类型

#define itofx(i_x) ((i_x) << 16)                                 // 整转定点

#define ftofx(f_x) (long)((f_x) * 65536)                         // 浮点转定点

#define dtofx(d_x) (long)((d_x) * 65536)                         // 双精度转定点

#define fxtoi(fx_x) ((fx_x) >> 16)                               // 定点转整

#define fxtof(fx_x) ((float) (fx_x) / 65536)                     // 定点转浮点

#define fxtod(fx_x) ((double)(fx_x) / 65536)                     // 定点转双精度

#define Mulfx(fx_x,fx_y) (((fx_x) * (fx_y)) >> 16)               // 定点积得定点

#define Divfx(fx_x,fx_y) (((fx_x) << 16) / (fx_y))               // 定点除得定点

 

3D图形计算一般会用到16位的,2D图形计算一般会用到8位的,本着实用的原则定义定点数类型







Fixed是业界使用最广的一种类型,他并没有在标准C或者其他语言中定义,程序员可以灵活的使用Fixed类型,可以定义自己想要的Fixed类型。那么什么是Fixed类型呢?Fixed类型是用来取代浮点,使用4字节的高2个字节表示整数位,低2个字节表示浮点位。每个字节有8个bit位,4个字节32个bit位,因此,我们把这种Fixed称为16.16Fixed。当然,也有使用24.8的Fixed,这就要看需求和精确度了。比如Fixed中的数字1,就是65536,也就是(1<<16)。这里用了位移公式,就是将1左移16位,也就是2个字节,左移16等于剩以65536,只不过位移来的非常快,快过加法。(这里理解不了就算了)比如数字32.5,等于(32<<16)|32768,等于32*65536+32768。为什么要这么麻烦呢?有了Fixed,就好像操作整数一样,都是整数运算了。Fixed的四舍五入也很简单,比如我们将X四舍五入到整数类型,就是(X+32768)>>16。32768就是半个Fixed的1,也就是浮点的0.5。右移16位就是除以65536,为的是将高2字节移到正常的整数位上。我都说晕了,以后慢慢解释给大家,呵呵。

    Fixed类型说了一堆,究竟来做什么的?

    比如上例中,Y轴每次都要偏移0.4,而这个数是个浮点,严重影响了运算速度。比如,我们后台有一个数,用来计量Y轴本次的坐标,就叫做变量YY吧。X每次都加1,也就是XX++,Y每次加0.4,也就是YY+=0.4。为了提高速度,我们将YY升级到Fixed类型,YY每次加Fixed的0.4,也就是0.4*65536=26214,然后再四舍五入到整数类型,即YY+=26214,Y=(YY+32768)>>16。这样,就得到了每次的整数Y,并且都是整数的加减和位运算,速度非常快

posted @ 2010-07-29 14:35 wrh 阅读(3420) | 评论 (0)编辑 收藏
 

软件安装分为以下几个部分:

1、 Java环境安装:

这里使用的是jdk-1_5_0_05-windows-i586-p.exe,这个可以到sun公司的网站去下载:http://java.sun.com/。

下载完成后,即可安装J2SE-SDK到D:\jsk目录下(其他目录下也可以)。

配置环境变量如下:

JAVA_HOME = D:\jdk

PATH=%JAVA_HOME%\bin;%JAVA_HOME%\lib;%JAVA_HOME%\jre\lib;

CLASSPATH = %JAVA_HOME%\lib;%JAVA_HOME%\jre\lib;

 2、 Tomcat 安装与环境变量设置:

 Web Server选择流行的Apache Tomcat 5.0.28,到 http://tomcat.apache.org/ 处下载,建议使用非安装的压缩版,有一点需要注意,Apache Tomcat不支持EJB,因此如果要进行EJB开发,那么就不要选择Apache Tomcat。 安装tomcat到D:\Tomcat目录下。

运行Monitor Tomcat 然后打开http://localhost:8080/ ,出现 Tomcat页面则安装成功。

配置环境变量如下:

TOMCAT_HOME = D:\Tomcat

3.Eclipse 下载与安装

Eclipse Release 3.2 SDK 可从
http://www.eclipse.org/downloads/download.php?file=/eclipse/downloads/drops/R-3.2-200606291905/eclipse-SDK-3.2-win32.zip下载

下载完的解压包可以直接解压到D:\eclipse,就完成安装

 4.TomcatPlugin插件安装:

下载安装Sysdeo Tomcat插件,用来管理Tomcat服务器,提供断点调试功能,并且能自动建立Tomcat环境,修改其配置文件,是一个不错的Tomcat开发插件。

英文原版下载地址:http://www.sysdeo.com/sysdeo/eclipse/tomcatplugin

解压tomcatPluginV31.zip,

将解压目录下文件夹com.sysdeo.eclipse.tomcat_3.1复制到eclipse安装目录中的plugins目录中,即D:\eclipse\plugins。启动Eclipse,启动后你将看到你的菜单上多了一个下拉项Tomcat,点击 窗口->首选项,在左边树中点击tomcat,设置tomcat version为version 5.x,设置tomcat根目录为D:\tomcat,在左边树中点击tomcat->JVM setting,设置JRE为jdk(即jre所在目录)。

 5.MyEclipse 的安装与插入Eclipse

http://www.myeclipseide.com/ 下载MyEclipse_5.1.1后,安装,注意:安装时候要选择Eclipse的安装路径,其他选项保持默认。

安装完毕之后,将MyEclipse安装目录下的features和plugins文件里的全部文件复制到Eclipse下的features和plugins文件中。复制完后可以将MyEclipse卸载。

启动Eclipse,依次点击Window ----> Preferences ---->MyEclipse---->Subscription ----> Enter Subscription,输入注册名以及注册机生成的注册码(myeclipse5.0注册码License Name : yjhmily ,License Key  : lLR8ZC-444-55-4467865759095168)

 到此,一个JSP开发环境配置成功。

posted @ 2010-07-27 08:59 wrh 阅读(1534) | 评论 (0)编辑 收藏
rt.jar ,dt.jar ,tool.jar都是 做什么用的 ,分别什么时候需要设置到classpath里?
---------------------------------------------------------------

rt.jar是JAVA基础类库,dt.jar是关于运行环境的类库,tools.jar是工具类库

设置在classpath里是为了让你 import *
---------------------------------------------------------------

web系统都用到tool.jar

你用winrar看看里面是什么内容啦
---------------------------------------------------------------

1.
rt.jar 默认就在 根classloader的加载路径里面 放在claspath是多此一举
不信你可以去掉classpath里面的rt.jar

然后用 java -verbose XXXX 的方式运行一个简单的类 就知道 JVM的系统根Loader的路径里面

不光rt.jar jre\lib下面的大部分jar 都在这个路径里 

2.

tools.jar 是系统用来编译一个类的时候用到的 也就是javac的时候用到

javac XXX.java

实际上就是运行 

java -Calsspath=%JAVA_HOME%\lib\tools.jar  xx.xxx.Main  XXX.java 

javac就是对上面命令的封装 所以tools.jar 也不用加到classpath里面

3.
dt.jar是关于运行环境的类库,主要是swing的包   你要用到swing时最好加上
posted @ 2010-07-26 15:17 wrh 阅读(745) | 评论 (0)编辑 收藏

在这里只讲安装的过程,介于如何下载安装所需的软件非常简单,就不再嗷述,望见谅。这里主要以我的安装过成给大家分享

jsp 安装过程和先后顺序:
1 、jdk1.5   (需要设置环境变量)
2 、eclipse+多国语言包
3 、tomcat 5.5
4、 myeclipse 5.0    (注意路径的选择)
jsp安装的顺序和所要注意的问题及变量的设置具体方法如下:

一、先安装 JDK1.5

具体安装不说了,主要讲环境变量的设置。

安装完 jdk1.5.0 以后,设置环境变量:右击“我的电脑”→属性→高级→环境变量→在“系统变量”中设置JAVA_HOME、Path 和CLASSPATH,如果没有,请在“系统变量”点击“新建”。(比如JAVA_HOME没有,在点“新建”后,先在“变量名”中输入“JAVA_HOME”,再在“变量值”中输入“C:\Program Files\Java\jdk1.5.0_06
”),如果已经存在,就点“编辑”,在它的最前面或最后面加上“变量值”。

我的环境变量(没有请“新建”,有则点“编辑”):

1、名:JAVA_HOME(不分大小写,以下各步均相同),(没有请“新建”,有则点“编辑”)
值:C:\Program Files\Java\jdk1.5.0_06(C代表JDK安装在C盘,后面的 \Program Files\Java\ 是安装后JDK的路径,\jdk1.5.0_06是JDK的具体位置)

2、Path (没有请“新建”,有则“编辑”)
值:%JAVA_HOME%\bin;

3、CLASSPATH(没有请“新建”,有则“编辑”)
:.;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar; (要加点“.”表示当前路径)

4、键入命令“java -version”(这里先打“java”,空格键,然后才是 “-version”,注意是:java+空格键+ -version)出现图面,表示成功!!!

补充:配置环境变量
JAVA_HOME: D: \jdk1.5.0 (这里的JDK安装在D盘)
PATH: D:\jdk1.5.0\bin; (或者%JAVA_HOME%\bin;)
CLASSPATH: .;D:\jdk1.5.0\lib\tools.jar;D:\jdk1.5.0\jre\lib\rt.jar;
(或者:.;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar )
注意:在设置CLASSPATH时,一定要注意设置变量值时先输入点和分号“.;”以后才是后面的\jdk..........或%java-home...............
二、安装eclipse
其实“安装eclipse”这个词放在eclipse上,好像有些步正确,因为他并不需要安装,只要jdk安装好了,直接压缩就可以使用,但为了便于理解,还是叫他安装吧。下面:
直接解压eclipse-SDK-3.2-win32.zip到名为eclipse的文件夹,再解压NLpack1-eclipse-SDK-3.2-win32到文件夹,得到features和plugins两个文件夹,把features和plugins两个文件夹拷贝到eclipse里面(全部替换原有的features和plugins两个文件夹)
安装eclipse多国语言包插件:
在解压eclipse-SDK-3.2-win32.zip到名为eclipse的文件夹中新建一个文件夹links,在links里新建一个文本文件并重命名为language.links(扩展名随便),内容为:
path=path=E:\java\eclipse\language
注意路径要跟你的language目录一致。(且一定都是英文的目录才可以!!如果你是FAT32格式的话,那么可以是中文目录,如果你是NTFS的话,那就必须是全英文目录了,目前我测试都是这样)
总结:1.首先安装完语言包(下载页面:http://eclipse.cdpa.nsysu.edu.tw/downloads/drops/L-3.2_Language_Packs-200607121700/download.php?dropFile=NLpack1-eclipse-SDK-3.2-win32.zip)。
2.在桌面的快捷方式(在你解压缩后的那个文件夹里的月食图标“右击”→发送到桌面→快捷方式 来建立)路径后面加上参数即可:

英文-> -nl "en_US"

简体-> -nl "zh_CN"

繁体-> -nl "zh_TW"

其它语言按java标准类推.
在桌面上建立了它的快捷方式,直接点击它时,eclipse出现的界面是中文的了;当在路径后面加入参数 -nl "en_US",(即
E:\java\eclipse\eclipse.exe -nl "en_US")时,界面又成英文了

三、安装tomcat 5.5
安装Tomcat后,在我的电脑->属性->高级->环境变量->系统变量中添加以下环境变量(假定你的tomcat安装在c:\tomcat):
  
  CATALINA_HOME=c:\tomcat
  CATALINA_BASE=c:\tomcat
  
  然后修改环境变量中的classpath,把tomat安装目录下的common\lib下的(可以根据实际追加)servlet.jar追加到classpath中去,修改后的classpath如下:
  
  classpath=.;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar;%CATALINA_HOME%\common\lib\servlet.jar;
  
  接着可以启动tomcat,在IE中访问http://localhost:8080,如果看到tomcat的欢迎页面的话说明安装成功了。
四、安装myeclipse 5.0
在选择路径中,路径选择eclipse目录,即eclise的安装所在路径
安装完毕,启动eclipse,配置myeclipse update,必须注册

然后输入http://lochost:8080/出现tomcat,安装成功!!!

补充:
jdk环境变量,Eclipse详细配置
1. 下载jdk,安装完成后,右键点击“我的电脑”,选择“高级”,点“环境变量”,在下面的“系统变量”中,点击新建,
变量名 java_home
    变量值为你安装java的目录,如 C:\Java ,安装时如果修改安装路径,确保jdk,jre在同一目录Java下
    选择已经存在的path,在变量值最后加 ;C:\Java\jdk1.5.0\bin ,或者在最前写 C:\Java\jdk1.5.0\bin;
    新建classpath 变量值 C:\Java\jdk1.5.0    \lib\dt.jar;C:\Java\jdk1.5.0\lib\tools.jar
2. links方式安装插件 如语言包,解开后为NLpack1-eclipse-SDK-3.2-win32,下面有个eclipse,【复制】eclipse这个文件夹
    在eclipse安装目录下,如F:\eclipse 下新建文件夹命名为language ,再在links文件夹下新建文本文档,
里面写 path=language
    然后把文本文件改名为language.ini ,接下去把复制的eclipse文件夹放到language文件夹下,
也就是F:\eclipse\language下还有个        eclipse文件夹。路径是这样的F:\eclipse\language\eclipse 。
3. 运行eclipse,已经变成中文版的了
4. MyEclipse安装,下载对应的版本后,如myeclipse5.0以上的,对应eclipse3.2 ,直接点击安装,
路径选择eclipse目录
    安装完成后,在eclipse工作界面中栏目里多了MyEclipse,第1次运行会弹出注册界面,
输入网上找的注册码(网上搜索多的是)
    点击finish
tomcat安装,下载tomcat 5.0以上版本,安装完成后,同样在环境变量里新建tomcat_home ,输入变量值,F:\Tomcat 5.0
    在存在的classpath最后添加 F:\Tomcat 5.0\common\lib\servlet-api.jar,注意和前面的tools.jar用分号;隔开
    在eclipse工作界面中点窗口,首选项,MyEclipse - Application Server 选择Tomcat 5
    Tomcat home directory 设置enable 浏览选择Tomcat安装目录,在Tomcat目录下有个JDK,重新选择路径,
名称自己定义,如jdk1.5

posted @ 2010-07-26 14:50 wrh 阅读(835) | 评论 (0)编辑 收藏
http://access911.net/fixhtm/71FAB51E16DC.htm?tt=
posted @ 2010-07-20 16:11 wrh 阅读(334) | 评论 (0)编辑 收藏
仅列出标题
共25页: First 7 8 9 10 11 12 13 14 15 Last 

导航

<2024年3月>
252627282912
3456789
10111213141516
17181920212223
24252627282930
31123456

统计

常用链接

留言簿(19)

随笔档案

文章档案

收藏夹

搜索

最新评论

阅读排行榜

评论排行榜