# re: C++下Windows Forms + MFC + WTL + wxWidgets + Qt + GTK+ 非官方综合比较 2009-01-06 19:05 qtopia
Nokia 最近推了 Qt Creator，是较好的IDE环境  回复  更多评论
  

# re: C++下Windows Forms + MFC + WTL + wxWidgets + Qt + GTK+ 非官方综合比较 2009-01-06 19:05 t
博主还可以增加一栏“国际化支持”  回复  更多评论
  

# re: C++下Windows Forms + MFC + WTL + wxWidgets + Qt + GTK+ 非官方综合比较[未登录] 2009-01-08 12:48 kenlistian
我觉得wxwidget是不错的选择。  回复  更多评论
  

# re: C++下Windows Forms + MFC + WTL + wxWidgets + Qt + GTK+ 非官方综合比较 2009-01-11 20:25 www
wxwidget做简单的还可以, 做复杂的界面,嘿嘿,那就麻烦了. win下还是MFC最爽.  回复  更多评论
  

# re: C++下Windows Forms + MFC + WTL + wxWidgets + Qt + GTK+ 非官方综合比较 2009-01-19 00:49 ArenAK
有没有哪一个是作者比较喜欢用的呢，及其原因？  回复  更多评论
  

# re: C++下Windows Forms + MFC + WTL + wxWidgets + Qt + GTK+ 非官方综合比较[未登录] 2009-01-19 16:35 六水
写的好~  回复  更多评论
  

# re: C++下Windows Forms + MFC + WTL + wxWidgets + Qt + GTK+ 非官方综合比较 2009-02-05 11:08 空明流转
@六水
我就知道你是友情赞助的。。。  回复  更多评论
  

# re: C++下Windows Forms + MFC + WTL + wxWidgets + Qt + GTK+ 非官方综合比较[未登录] 2009-02-11 22:35 六水
这你也知道？  回复  更多评论
  

# re: C++下Windows Forms + MFC + WTL + wxWidgets + Qt + GTK+ 非官方综合比较 2009-02-25 10:19 aladdina
wxWidgets的代码质量不是很高，有一些比较初级的bug。我用过一段时间的wxWidgets，自己测试没问题，但是用户总会发回一些crash report。

另外，wxWidgets和Qt除了对于一些常见应用，比如窗口、DC的封装之外，还提供了很多系统接口的封装，比如clipboard, thread, socket等。

Qt有Qt Creator作为IDE，工程项目文件可以跨平台，另外，工程文件也可以用qmake转成平台无关的makefile。准备最近有空试试Qt，个人觉得商业代码质量还是要稍微好一些。

  回复  更多评论
  

# re: C++下Windows Forms + MFC + WTL + wxWidgets + Qt + GTK+ 非官方综合比较 2009-09-18 12:09 idol
gtk 哪有 signal-slot机制，用的明明是 callbacks  回复  更多评论

TTF
　　TTF是True Type Font的简称。在Windows\Fonts目录下面，我们可以看到许多后缀为ttf的文件，它就是接下来我们接下来所要谈到的。
　　TTF是一种矢量字库。我们经常可以听到矢量这个词，像是FLASH中的矢量图形，在100*100分辨率下制作的flash，就算它放大为全屏，显示出的画面也不会出现马赛克。所谓矢量，其实说白了就是用点和线来描述图形，这样，在图形需要放大的时候，只要把所有这个图形的点和线放大相应的倍数就可以了。而且，在网站上有很多的TTF字库可以下载，或者你可以去买一些专门的字库光盘。然后在你发行你精心制作的游戏时，可以顺便捎上这些后缀为.ttf 的文件就行了。包括Quake这样的惊世之作，也都是用的TTF字库。
　　这样，我们就可以解决点阵汉字的一些问题。通过TTF，我们在字体的质量和字库的数量上获得了暂时性的胜利。

字库的读取和显示
　　先前谈到点阵字库，只需要很简单的一些操作，就可以显示出想要的汉字。下面我给出一个读取hzk16的函数，它需要一个Surface以供显示用：
　　#include <io.h>
　　#include <stdio.h>
　　#include <conio.h>
　　
　　// 读取16x16
　　void DispHZ16(int x, int y, BYTE *Str, LPDIRECTDRAWSURFACE surf)
　　{
　　 const int Mask[] = { 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01 };
　　 FILE *HzkFp;
　　 WORD i, j, k=0, m;
　　 WORD HzNum;
　　 WORD QuHao;
　　 WORD WeiHao;
　　 long offset;
　　 BYTE dotBuffer[32];
　　
　　 HzkFp = fopen("HZK16", "rb");
　　
　　 HzNum = strlen((const char *)Str)/2;
　　
　　 DDSURFACEDESC ddsd;
　　 LPWORD lpSurface;
　　 HRESULT ddrval;
　　
　　 ddsd.dwSize = sizeof(ddsd);
　　
　　 while((ddrval=surf->Lock(NULL, &ddsd, 0, NULL))==DDERR_WASSTILLDRAWING);
　　 if(ddrval == DD_OK)
　　 lpSurface = (LPWORD)ddsd.lpSurface;
　　
　　 for(i = 0; i<HzNum; i++)
　　 {
　　 QuHao = Str[i*2]-160;
　　 WeiHao = Str[i*2+1]-160;
　　
　　 offset = ((QuHao - 1) * 94 + (WeiHao-1))*32;
　　
　　 fseek(HzkFp, offset, SEEK_SET);
　　 fread(dotBuffer, 32, 1, HzkFp);
　　
　　 for(j=0;j<16;j++)
　　 for(k=0;k<2;k++)
　　 for(m=0;m<8;m++)
　　 if(dotBuffer[j*2+k] & Mask[m])
　　 {
　　 lpSurface[ddsd.lPitch*(y+j+1) + x+k*8+m] = 0x000000;
　　 }
　　 x+=16;
　　 }
　　
　　 surf->Unlock(NULL);
　　
　　 fclose(HzkFp);
　　}
　　其实原理很简单：
1. 打开字库
2. 计算字符串长度（这个函数只支持中文），并且Lock Surface
3. 依次计算出每个汉字所对应的区码和位码（汉字的第1个字节是区码，第2个字节就是位码），然后通过公式计算出这个汉字在字库中的偏移量：
offset = ((QuHao - 1) * 94 + (WeiHao-1))*32;
4. 读出一个32个字节的点阵
5. 绘制到Surface上
　　以上只是16＊16点阵字库的显示方法，24＊24的读取方法与之类似，大家可以参照相关资料来书写出自己的代码。
　　
　　如何显示TTF字库呢，有很多种手段，下面我按从简单到复杂的的顺序依次介绍:
1. 使用Windows API，也就是大家所熟悉的TextOut。通过它，还需要一个HDC（设备句柄），我们就可以随意地在屏幕任何地方显示出文字了。
2. 在http://www.freetype.org，有一个FreeType的免费库，而且是OpenSource的。它目前有2个版本：1.0和 2.0。其区别在于，1.0只能读取TTF格式的，而2.0支持更多的文件格式，在使用它之前请详细阅读所要遵循的Licence，以下是摘自 FreeType2.0对字库的支持列表：
o TrueType fonts (and collections)
o Type 1 fonts
o CID-keyed Type 1 fonts
o CFF fonts
o OpenType fonts (both TrueType and CFF variants)
o SFNT-based bitmap fonts
o X11 PCF fonts
o Windows FNT fonts
3. 自己研究TTF的格式，然后自己来操作。
晕
....... ╮╮
　 　 \█/倒！
　　　 ●
虽然我们想要把每一件事情都做好，但是也不是每一件事情都要亲历亲为。如果你非要这样，也行^____^，但是过不了多久，你就会陷入泥沼，到时候你会发现自己的热情正在慢慢被磨灭，什么叫做抓狂，相信你很快就会知道^_^。

在有多种选择可以取舍的情况下，我们需要考虑一下，对比一下各种解决方法的优劣。

　　在DirectDraw时代，我们都不自觉地喜欢上了GetDC，因为……多方便啊。可是现在已经到了DirectX8.1时代了（我要使劲地摇那些还沉醉于DirectX7中，为如何在使用alpha时提升那可怜的1、2个fps的朋友们：醒醒，该起床了！），HDC已经被M$列为禁用品。怎么办呢？是的，你可能已经想到了，我们还一直保存着窗口的hWnd呢，可以通过它来得到hdc，从而调用那些需要hdc的API，可是，这样做是更为愚蠢的，这样对你是没有一点好处的，不信，你就试试吧。有一句话，请牢记：要想你的游戏有更快的速度的话，请不要再去碰HDC了。
　　我们非常清楚hdc是一个超慢的解决办法，它无法在我们的高速游戏中满60分及格。下面来看看FreeType，它更像是一个Service。它的解决方法是，先通过一系列的初始化和设置，告诉FreeType字体的名字和大小等，然后它会动态地申请一个Graphic，再把我们要显示的字画到这个 Graphic上，你还可以把它保存为tga格式。不过我们最终所想要的不是这个，所以可能我们还需要从这个Graphic上逐点读取或者用 CopyRect，然后再画到我们的画面上。其实它已经是很方便的了，可是需要你去学习如何配置和使用它，这是很花时间的一件事情，而且它最大的优点是可以跨平台，我们需要它吗？如果有一个更为简单的办法，像是如果Textout不是那么慢的话，就好了……
　　在这里，顺便谈一下另2个字体显示类：ID3DXFont和CD3DFONT。可能早就有人会说怎么在上面的列表中没有它们？原因我会在下面慢慢地说明：
　　ID3DXFont，它存在于D3DX库中，一个现成的字体类，不过对于它的处理方法……我实在不敢恭维，就引用一位大师所说的话来表达我的看法吧: 在内部实现中， ID3DXFont::DrawText()函数确实做了我上面讨论的工作，先建立一张GDI兼容的位图，把文本绘制到位图上，而后把位图拷贝到纹理贴图上去，最后把纹理渲染到屏幕上。这样你就聚齐了所有的龟速的原始GDI函数，还包括了一大堆的额外开销 — 最终，这个函数比原来GDI的DrawTextEx()函数要慢上超过六倍……
　　CD3DFONT，是由M$在D3D的框架代码中提供。不过它只能显示英文，有很多朋友通过自己定制和修改这个类，来实现自己的中文显示。不过效果都不是很好。其实原理，跟ID3DXFont的方法差不多，不过处理方法要聪明了一点。

分析与思考
　　那么我们应该怎么办呢？通常我们会幻想，如果可以像处理英文那样，把所有的汉字都保存在一张位图里，该有多好。这样，显示的速度就不是问题了，直接可以CopyRect上去。可是，这样可能吗？首先，必须每一种字体都要生成这样的一个巨型位图。而且据说在GB2312中，一共有6000多个汉字，就算是用16*16，oh my god，这个位图该有多大啊（据说会有2.5M^__^）！！！而且在DirectX8.1中，对于Texture（显示的最小单位，就好象是原来 DirectSurface的概念一样。说过多少遍了，不要再用DirectX8以前的东西了。不要试着去回忆那些美好的过去，我很明白，要你一下子放弃原来多年所获得的成就，是一件很痛苦的事情，但是包袱太重，是会影响进步的。就像是我们的国家……扯远了），不同的显卡，支持的最大容量也是不同的。比方说早期的Voodoo，只支持256*256大小的Texture。而在我的显卡（Geforce2 MX 200）上测试，支持最大2048*2048大小的Texture。对于这样的硬件不确定性，我们只能取其最小值，也就是256*256。
　　汉字虽然很多，但是常用的汉字，其实也就只有那么几百个。像这样的字：鬯、鞴，你一辈子会看到多少次呢？如果可以做一个类似于Cache的东西，保存着常用的那些个汉字，在需要显示的的时候，先在Cache中查找，如果有的话，就马上画上去；如果没有，就从字库中提取到Cache中。这样的话，在使用 Texture来保存汉字的位图信息的同时，对于每个汉字，我们还要定义一个结构，然后用一个东西把它串起来，综合它们2个，也就实现了我们所要的 Cache了。刚开始，我所定义的结构是这样的：
　　struct Char{
　　 char hz[3]; // 保存汉字
　　 int frequency;// 使用频率
　　 RECT rect; // 这个字对应位图的区域
　　 Bool isUsing; // 是否使用
　　}
　　对于汉字和英文，我在这里大概地讲一下原理：汉字是由2个字节保存，而英文只需要1个。而判断一个字是否是汉字，只需判断第1个byte是否>128（在原来的GB2312中，汉字的2个字节都是>128的。而新的GBK字库，汉字的第2个字节不一定>128，我想这是扩大了字库容量的原因。我的意思是说，如果给一个字符串你，随机给其中一个位置，然后我问你这个位置是什么？你的回答只能是：1 英文 2 汉字的首字节 3 汉字的尾字节。而这个问题的解法，为了稳妥起见，你必须从字符串的开始判断起）。也就是说在char[3]中，如果保存的是汉字，则char[0]保存汉字第1个字节，char[1]保存汉字第2个字节，第3个存放’\0’；如果是英文的话，则只用到char[0]，其它的全部为’\0’。
　　接下来，对于使用char[3]来保存汉字，是否真的很合适呢？因为如果把它当作一个字符串来看的话，在查找时就需要使用 strcmp 来比较字符串了，这样一定是会影响速度的。如果不把它看作字符串（字符串的最后一个字节需要以’\0’结尾），只用char[2]的话，我们可以只是简单地调用宏MAKEWORD，把2个byte压成1个WORD。当把文字作为一个WORD来看的时候，这样查找比较时可以用WORD内建的==操作，这样要比调用strcmp函数要快得多。
　　int frequency用来标志每个WORD的使用频率。设想，如果一个字已经存在于Cache中，以后每对它调用一次，就让frequency++。这样做还有一个用意是，是否可以在一个合适的时候，以frequency为参照来对这整个Cache排个序，把常用的字放在前面。那么在显示时，可以先在 Cache中查找所要显示的字是否已经存在于Cache中，如果有则直接显示，没有的话才需要采取某种手段将字加入到Cache中。一些常用的字（像：我、的、着、了、过……），使得显示的速度将会大大提高。
　　其实上面说了半天的Cache，它具体是什么呢？其实就是指的最小绘制单位，在DirectX7里是Surface，而在DirectX8中就是 Texture。使用它来存放显示过的汉字，这样，就不用每次都从字库中读取或是调用如TextOut这类GDI超慢的函数了。因为每次在绘制一个文字之前，都会先在这个Cache中找，有的话就直接画上去，没有才会调用TextOut操作。而这样做的原因，我们先设想一下：游戏一般会控制为30fps或是60fps的速度不停地刷新，如果在GameLoop中有任何的代码是龟速级的话，这样就会导致fps的最大数的降低，也就意味着在保证30fps或 60fps的同时，能绘制到屏幕上的物体的数量减少了。这就是我们为什么要使用Texture来作为Cache的实现的原因。再一个，文字在屏幕上显示时一般会保持一段时间，这个时间可能是1秒-3秒，我们的游戏也就会相应地更新60fps或180fps，这是因为人们需要阅读它们。或者是一些如标题这样的文字，它们总是不会更新的，或是更新得很慢。我们完全可以在第一时间，比方说我们的画面有60fps，在第1个fps时，我们得知要显示文字”唐”，然后先在Cache中找，结果很糟：没有找到！这时马上用TextOut写到Texture上（现在还是属于第1个fps的时间范围内），而接下来的59个 fps（甚至更多），都不用再调TextOut了，而是直接从我们的Cache：Texture上Copy到屏幕上，速度得到了保障。谈到GDI的函数，为了实现设备无关性，它们的速度都很慢。其实它们也不像说得那么慢，如果不是每一帧都要调用它们，也算是蛮快的^_^。那么这个RECT rect，就代表着这个文字所对应在Texture上的区域位置。
　　使用什么东西来把这n个Char串起来呢，一般会想到的是链表，原因无非有2个：1 随时有新的字加进来，而内存是不连续的 2 它几乎没有容量的限制（除非是内存用完了）。不过链表的访问速度是很慢的，如果使用像数组这样的东西就好了。仔细想想，在这里，我们用来存储的 Cache，最大也就是256*256（理由上面说了），所以大小应该会是固定的。我们只需要在数组中的给每一个汉字加上一个标志，说明这个位置的使用情况。那么就使用数组吧，这样的话，访问的速度要更快一些，直接首地址+偏移量就够了，不必像链表，在查找时需要逐node访问。当然，我绝不会想到用 new Char来申请这个数组。因为这样做实在没有必要，请不要过于迷信自己的能力，在STL中已经有vector了，为什么还要自己写呢？^_^最后的一个 bool成员变量isUsing，也就是上面所说，用来标志使用情况的。

实际的操作
　　上面考虑了那么多，我认为都是实际操作之前所应该有的。先谈谈如何显示吧，因为在DirectX8.1中已经将DirectDraw和 Direct3D融合为DirectGraphics了。所以无法像原来那样了…………哦，实在有太多东西要讲了，我还是推荐几篇文章给你吧^_^：
　　http://vip.6to23.com/mays/develop/directx/200201/Geczy3Din2D.htm
　　http://vip.6to23.com/mays/develop/directx/200201/GESurface.htm
　　http://vip.6to23.com/mays/develop/directx/200112/2DGtoDX8.htm
　　http://vip.6to23.com/mays/develop/directx/200201/DX8adv2D.htm
　　接下来，我会假设你已经具备了在DirectX8.1中绘图的基本概念了，所以在你继续往下阅读之前，请务必先仔细阅读以上推荐的文章。
　　前面提到，需要一个vector来对应Texture上各个位置文字的信息，上面已经创建了一个结构Char，则这个vector的定义为：
　　 vector <Char> _vBuf; // 记录缓冲中现有的文字情况
　　首先，由于可以利用硬件的放大缩小机能，所以字体的大小精度要求不是很高，只需要支持16*16和24*24大小的字体就可以了。我们需要一个这样的初始化函数：
　　bool CFont::
　　/*-------------------------------------------------------------
　　LPDIRECT3DDEVICE8 pd3dDevice --- D3DDevice设备
　　char szFontName[] --- 字体名(如: 宋体)
　　int nSize --- 字体大小, 只支持16和24
　　int nLevel --- 纹理的大小级别
　　-------------------------------------------------------------*/
　　Init( LPDIRECT3DDEVICE8 pd3dDevice, char szFontName[], int nSize, int nLevel )。
　　
　　在DirectX8.1中，由SetTexture(…)所贴的图的大小，也就是Texture的大小，是有大小限制的，长和宽都必须是2^n，而且位图越大，所花费的显存越大，这样留给其他显示用的显存就少了。所以，必须根据需求的不同，来自定Texture(也就是Cache)的大小。因为汉字点阵大小的原因，所以从实用角度而言（比方说只是显示fps或是短小的标题），开辟一个64*64大小的Texture，才能满足最低情况下的需要（这时如果选择16点阵的话可以存放16个汉字，24点阵可以存放7个，依次类推……）。
　　根据设置，创建Texture：
　　 _TextureSize = 32 << nLevel; // 纹理大小
　　 _TextSize = nSize; // 文字大小
　　 _TextureSize = 32 << nLevel; // 纹理大小
　　
　　 _RowNum = _TextureSize / _TextSize; // 计算一行可以容纳多少个文字
　　 _Max = _RowNum * _RowNum; // 计算缓冲最大值
　　
　　创建字体，还是需要使用Win32 API。也就是先创建一个HDC：
　　 _hDc = CreateCompatibleDC(NULL);
　　
　　然后创建一个BITMAP和一个FONT，将它们与HDC关联起来。
　　 LOGFONT LogFont;
　　 ZeroMemory( &LogFont, sizeof(LogFont) );
　　 LogFont.lfHeight = -_TextSize;
　　 LogFont.lfWidth = 0;
　　 LogFont.lfEscapement = 0;
　　 LogFont.lfOrientation = 0;
　　 LogFont.lfWeight = FW_BOLD;
　　 LogFont.lfItalic = FALSE;
　　 LogFont.lfUnderline = FALSE;
　　 LogFont.lfStrikeOut = FALSE;
　　 LogFont.lfCharSet = DEFAULT_CHARSET;
　　 LogFont.lfOutPrecision = OUT_DEFAULT_PRECIS;
　　 LogFont.lfClipPrecision = CLIP_DEFAULT_PRECIS;
　　 LogFont.lfQuality = DEFAULT_QUALITY;
　　 LogFont.lfPitchAndFamily = DEFAULT_PITCH;
　　 lstrcpy( LogFont.lfFaceName, szFontName );
　　
　　 _hFont = CreateFontIndirect( &LogFont );
　　 if ( NULL == _hFont )
　　 {
　　 DeleteDC( _hDc );
　　 return false;
　　 }
　　
　　（只需要创建一个字体大小的BITMAP即可）
　　 BITMAPINFO bmi;
　　 ZeroMemory(&bmi.bmiHeader, sizeof(BITMAPINFOHEADER));
　　 bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
　　 bmi.bmiHeader.biWidth = _TextSize;
　　 bmi.bmiHeader.biHeight = -_TextSize;
　　 bmi.bmiHeader.biPlanes = 1;
　　 bmi.bmiHeader.biBitCount = 32;
　　 bmi.bmiHeader.biCompression = BI_RGB;
　　
　　（这里需要定义一个指针指向位图的数据：
　　 DWORD * _pBits; // 位图的数据指针）
　　
　　 _hBmp = CreateDIBSection( _hDc, &bmi, DIB_RGB_COLORS,
　　 (void **) &_pBits, NULL, 0 );
　　 if ( NULL == _hBmp || NULL == _pBits )
　　 {
　　 DeleteObject( _hFont );
　　 DeleteDC( _hDc );
　　 return false;
　　 }
　　
　　 // 将hBmp和hFont加入到hDc
　　 SelectObject( _hDc, _hBmp );
　　 SelectObject( _hDc, _hFont );
　　
　　接着设置背景色和文字色：
　　 SetTextColor( _hDc, RGB(255,255,255) );
　　 SetBkColor( _hDc, 0 );
　　
　　设置文字为上对齐：
　　 SetTextAlign( _hDc, TA_TOP );
　　
　　创建Texture所需要的顶点缓冲：
　　 if ( FAILED( _pd3dDevice->CreateVertexBuffer( _Max * 6 * sizeof(FONT2DVERTEX),
　　 D3DUSAGE_WRITEONLY | D3DUSAGE_DYNAMIC, 0,
　　 D3DPOOL_DEFAULT, &_pVB ) ) )
　　 {
　　 DeleteObject( _hFont );
　　 DeleteObject( _hBmp );
　　 DeleteDC( _hDc );
　　 return false;
　　 }
　　
　　创建Texture
　　 if ( FAILED( _pd3dDevice->CreateTexture( _TextureSize, _TextureSize, 1, 0,
　　 D3DFMT_A4R4G4B4, D3DPOOL_MANAGED, &_pTexture ) ) )
　　 {
　　 DeleteObject( _hFont );
　　 DeleteObject( _hBmp );
　　 DeleteDC( _hDc );
　　 SAFE_RELEASE(_pVB);
　　 return false;
　　 }
　　
　　设置渲染设备的渲染属性：
　　 _pd3dDevice->SetRenderState( D3DRS_ALPHABLENDENABLE, TRUE );
　　 _pd3dDevice->SetRenderState( D3DRS_SRCBLEND, D3DBLEND_SRCALPHA );
　　 _pd3dDevice->SetRenderState( D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA );
　　 _pd3dDevice->SetRenderState( D3DRS_ALPHATESTENABLE, TRUE );
　　 _pd3dDevice->SetRenderState( D3DRS_ALPHAREF, 0x08 );
　　 _pd3dDevice->SetRenderState( D3DRS_ALPHAFUNC, D3DCMP_GREATEREQUAL );
　　 _pd3dDevice->SetTextureStageState( 0, D3DTSS_ALPHAOP, D3DTOP_MODULATE );
　　
　　 _pd3dDevice->SetTexture( 0, _pTexture );
　　 _pd3dDevice->SetVertexShader( D3DFVF_FONT2DVERTEX );
　　 _pd3dDevice->SetStreamSource( 0, _pVB, sizeof(FONT2DVERTEX) );
　　
　　设置缓冲的最大容量
　　 _vBuf.resize( _Max );
　　
　　这样，初始化完成了。接下来是如何把一个汉字写到Texture中，以及如何进行管理。定义函数：
　　// 得到文字在纹理中的位置
　　void CFont::
　　/*-------------------------------------------------------------
　　char c1 --- 文字的第1个字节
　　char c2 --- 文字的第2个字节
　　int & tX --- 写入纹理中的坐标x
　　int & tY --- 写入纹理中的坐标y
　　-------------------------------------------------------------*/
　　Char2Texture( char c1, char c2, int & tX, int & tY )
　　{
　　 WORD w = MAKEWORD(c1, c2); // 把此字变为WORD
　　 vector<Char>::iterator it = find( _vBuf.begin(), _vBuf.end(), w );
　　 if ( it == _vBuf.end() ) // 如果没找到
　　 {
　　 it = find( _vBuf.begin(), _vBuf.end(), 0 ); // 查找空闲位置
　　 if ( it == _vBuf.end() ) // 缓冲已满
　　 {
　　 for(; it!=_vBuf.begin(); it-- )
　　 {
　　 it->hz = 0;
　　 }
　　// Log.Output( "字体缓冲已满, 清空!" );
　　 }
　　
　　 // 计算当前空闲的Char在缓冲中是第几个
　　 int at = it-_vBuf.begin();
　　
　　 // 得到空闲位置的坐标
　　 tX = (at % _RowNum) * _TextSize;
　　 tY = (at / _RowNum) * _TextSize;
　　
　　 // 设置这个Char为使用中
　　 (*it).hz = w;
　　
　　 RECT rect = {0, 0, _TextSize, _TextSize};
　　 char sz[3] = {c1, c2, '\0'};
　　 // 填充背景为黑色(透明色)
　　 FillRect( _hDc, &rect, (HBRUSH)GetStockObject(BLACK_BRUSH) );
　　 // 往hBitmap上写字
　　 ::TextOut( _hDc, 0, 0, sz, c1 & 0x80 ? 2 : 1 );
　　
　　 // 锁定表面, 把汉字写入纹理, 白色的是字(可见), 黑色为背景(透明)
　　 D3DLOCKED_RECT d3dlr;
　　 _pTexture->LockRect(0, &d3dlr, NULL, D3DLOCK_NOSYSLOCK);
　　 BYTE * pDstRow = (BYTE*)( (WORD *)d3dlr.pBits + tY * _TextureSize + tX );
　　
　　 for (DWORD y=0; y<_TextSize; y++)
　　 {
　　 WORD * pDst16 = (WORD*)pDstRow;
　　 for (DWORD x=0; x<_TextSize; x++)
　　 {
　　 BYTE bAlpha = (BYTE)((_pBits[_TextSize * y + x] & 0xff) >> 4);
　　 if (bAlpha > 0)
　　 *pDst16++ = (bAlpha << 12) | 0x0fff;
　　 else
　　 *pDst16++ = 0x0000;
　　 }
　　 pDstRow += d3dlr.Pitch;
　　 }
　　 _pTexture->UnlockRect( NULL );
　　 }
　　 else
　　 {
　　 // 计算当前空闲的Char在缓冲中是第几个
　　 int at = it-_vBuf.begin();
　　
　　 // 得到这个字的坐标
　　 tX = (at % _RowNum) * _TextSize;
　　 tY = (at / _RowNum) * _TextSize;
　　 }
　　}
　　以上代码中的注释已经很清楚了，相信无须我多言。这里唯一需要声明的是：原来所定义的Char结构是这样的
　　struct Char{
　　 char hz[3]; // 保存汉字
　　 int frequency;// 使用频率
　　 RECT rect; // 这个字对应位图的区域
　　 Bool isUsing; // 是否使用
　　}
　　后来因为将char hz[3]合成为WORD，所以改为WORD hz。然后对于int frequency，这个词频应该如何表现，我一直没有想到很好的方法。frequency应该在何时++呢？是在每次被使用的时候吗？但是这样的话，上面说过，游戏是以60fps的速度在刷新，如果停上1分钟的话，变量很快就会溢出了。就算是使用像是DWORD或__int64这样的巨型变量保存，也是不安全的。除非能在某个合适的时候将frequency清零，但是这个“时候”是什么时候呢？或者设置一个最大值，如65535，但是这样也基本上没什么用途，很快，所有在vector中的Char中的frequency都会++成65535的。回忆一下最初，是因为想把常用字放到vector的前面，以便每次find操作可以最快返回结果的。而经过我的测试，即使不做这样的优化操作，速度也是很快的，毕竟Cache不是很大，加上vector是连续内存空间。所以可以放弃使用int frequency。
　　然后对于RECT rect，因为没有了int frequency，意味着一旦将汉字写入到Texture，其位置就不会变动了。所以，很容易根据find函数操作后的iterator，直接计算出这个汉字所在Texture的位置。这样，RECT rect也不再必须。
　　而bool isUsing，它本身就是个鸡肋，要也可以，这样结构更加清晰。不过，直接通过观察WORD hz为0或非0，即可实现isUsing的作用了。
　　为什么要对结构Char这么精雕细琢呢？
1. 既然没有必要的东西，就应该删除
2. Char结构的大小越大，vector所要求的内存越大
3. 小的结构，find可以更快地查找出所结果
　　为什么find会正常工作呢？这里我要大概地讲一下find是如何查找出所需的位置的：它只是简单地使用while从vector的begin一直遍历到end，逐个判断，直到找到为止。find要求必须实现自己的operator ==()，进一步跟踪到find的源码中，发现也是这样。于是前面的结构Char变成了现在这样：
　　 struct Char{
　　 WORD hz; // 文字
　　
　　 Char() : hz(0) {}
　　
　　 // 用作查找文字
　　 inline bool operator == ( WORD h ) const
　　 {
　　 return hz==h ? true : false;
　　 }
　　 };
　　是不是很简单？^___^
　　
　　终于到了显示的函数了：
　　// 得到文字在纹理中的位置
　　bool CFont::
　　/*-------------------------------------------------------------
　　char szText[] --- 显示的字符串
　　int x --- 屏幕坐标x
　　int y --- 屏幕坐标y
　　D3DCOLOR --- 颜色及alpha值
　　int nLen --- 字符串长度
　　float fScale --- 放大比例
　　-------------------------------------------------------------*/
　　TextOut( char szText[], int x, int y, D3DCOLOR color, int nLen, float fScale )
　　{
　　 Assert( szText!=NULL );
　　
　　 float sx = x, sy = y,
　　 offset=0, w=0, h=0, tx1=0, ty1=0, tx2=0, ty2=0;
　　 w = h = (float)_TextSize * fScale;
　　
　　 char ch[3] = {0,0,0};
　　 FONT2DVERTEX * pVertices = NULL;
　　 UINT wNumTriangles = 0;
　　 _pVB->Lock(0, 0, (BYTE**)&pVertices, D3DLOCK_DISCARD);
　　
　　 if ( -1 == nLen || // 默认值-1
　　 nLen > lstrlen( szText ) ) // 如果nLen大于字符串实际长度, 则nLen=实际长度
　　 nLen = lstrlen( szText );
　　 for (int n=0; n<nLen; n++ )
　　 {
　　 ch[0] = szText[n];
　　
　　 if ( ch[0]=='\n' )
　　 {
　　 sy+=h;
　　 sx=x;
　　 continue;
　　 }
　　
　　 if ( ch[0] & 0x80 )
　　 {
　　 n++;
　　 ch[1] = szText[n];
　　 offset = w;
　　 }
　　 else
　　 {
　　 ch[1] = '\0';
　　 offset = w / 2 ;
　　 }
　　
　　 int a, b;
　　 Char2Texture( ch[0], ch[1], a, b );
　　
　　 // 计算纹理左上角 0.0-1.0
　　 tx1 = (float)(a) / _TextureSize;
　　 ty1 = (float)(b) / _TextureSize;
　　 // 计算纹理右上角 0.0-1.0
　　 tx2 = tx1 + (float)_TextSize / _TextureSize;
　　 ty2 = ty1 + (float)_TextSize / _TextureSize;
　　
　　 // 填充顶点缓冲区
　　 *pVertices++ = FONT2DVERTEX(sx, sy + h, 0.9f, color, tx1, ty2);
　　 *pVertices++ = FONT2DVERTEX(sx, sy, 0.9f, color, tx1, ty1);
　　 *pVertices++ = FONT2DVERTEX(sx + w, sy + h, 0.9f, color, tx2, ty2);
　　 *pVertices++ = FONT2DVERTEX(sx + w, sy, 0.9f, color, tx2, ty1);
　　 *pVertices++ = FONT2DVERTEX(sx + w, sy + h, 0.9f, color, tx2, ty2);
　　 *pVertices++ = FONT2DVERTEX(sx, sy, 0.9f, color, tx1, ty1);
　　
　　 wNumTriangles+=2;
　　
　　 sx+=offset; // 坐标x增量
　　 }
　　 _pVB->Unlock();
　　 _pd3dDevice->DrawPrimitive( D3DPT_TRIANGLELIST, 0, wNumTriangles );
　　
　　 return true;
　　}

结束语
　　记得有一句名言： Keep it simple and stupid.在实现功能的同时，保持代码简单、清晰是非常重要的一件事。相信在往后的日子里，在不论是别人阅读或是你自己回顾的时候，你都会发现一如既往地遵守这个守则，是多么得重要！
　　相信通过上面我那无数的废话，加上代码中还算足够的注释，聪明的你一定能够明白这其中的原理了吧。如果以上的内容还不足以让你完全搞清楚的话，你可以登录我的主页：
　　

炎龙工作室
　　上面不仅包括了上面所写的程序代码，还有一个用来演示效果的一个很简单的demo。
　　说明，以上所实现的CFont是包含在我的游戏引擎中的一个部件，而目前已经实现的部件包括有：
1. CGameFrame（游戏框架类） ----- 封装了窗口及D3D设备的建立，需要派生出自己的子类
2. CAudio和CSound（声音类） ----- 支持wav/mid/mp3的播放
3. CDirectInput（控制类） ----- 键盘、鼠标操作
4. CDirectShow（视频类） ----- 支持avi/mpg/mov等的播放
5. CSpriteX（精灵类） ----- 方便游戏中对精灵的控制
6. CFont（字体类） ----- 中英文字体的显示
7. CTimer（时间类） ----- 高精度时间的控制
8. FPS（fps 类） ----- fps的计算
9. LOG（日志类） ----- 游戏中的错误反应以及状态记录
　　最重要的是，这个Game Engine完全是开放源代码的。关于更新的情况、版本说明以及源码下载，请随时关注我的主页！
接下来，我将会继续完善这个Engine，可能加入的有：高效粒子系统、斜45度角地图……

方法如下（引用）：http://blog.csdn.net/kun1234567/archive/2008/04/11/2282761.aspx

CEGUI使用utf8编码格式。这就意味着我们可以很简单的就显示中文。

1、弄个包含中文的字体，在这里我借用大多数例子里的 “C：/windows/Font/simhei.ttf”文件。把这个文件拷贝到Datafiles文件夹的Font文件夹里。

2、随便照着一个 .Font文件，自己写一个simhei.font文件。可以用TXT写，然后保存，有的朋友说需要保存为utf8编码格式，实际上是不需要的。

3、同时注意修改你加载到程序里的scheme文件，将里面的字体文件设置成simhei.ttf。你也可以继续使用FirstWindow这个例子，这样的话直接修改源代码里的字体为simhei.tff。

4、现在在程序里进行字符编码转换，我拿代码说明问题：

std::wstring aa = L"123中文abcあいうえお";

char buff[128] = "";

WideCharToMultiByte( CP_UTF8, 0, aa.c_str(), aa.size(), buff, sizeof(buff), 0, 0);

button1->setText ( CEGUI::String ( CEGUI::utf8* )buff );

原理是这样的，对于utf8来说，英文字符和ansi编码在内存布局上没什么区别，都是一个UCHAR。但是对于非英文字符，则是UCHAR+UCHAR+UCHAR。如果我们手工进行编码格式转换，会比较烦琐。

比较偷懒的方法就是，我们先用WCHAR(unicode内存布局,UCHAR+UCHAR+UCHAR+UCHAR)来储存需要显示的字符串，然后调用Win32API来帮我们把宽字符转换成char(多字节字符集内存布局)。

这就是基本方法了，然后我们可以根据这个转换方针，利用Win32API随意的转换字符编码格式，从而满足程序中的各种需求。

       通过此方法可以显示中文，还没来得急高兴就发现了第二个问题：这种方法显示中文速度太慢（显示几十个字需要等上7、8秒左右）。难道没有高效的方法吗？

于是继续Google(我很懒，别人能做的事情从来不麻烦自己，懒得跟踪代码)，结果还真让我找到了两篇相关的文章：一份是千里马肝的《游戏中汉字显示的实现与技巧》，另一份是免费打工仔的《让OGRE支持中文》。从中找到了原因：

       原来在游戏中，是将点阵字库或tif字体里的文字写进纹理，根据需求贴到指定的位置。英文的显示非常简单，只有26个字母，就算再加一些标点、符号什么的，用一张位图，就可以足以显示所有的单词了。而中文要像处理英文那样，把所有的汉字都保存在一张位图里，那么每一种字体都要生成一个巨型位图。在 GB2312中，一共有6000多个汉字，就算是用16*16，据说会有2.5M！（马肝兄说的，我没算过）

    继续Google，也没有找到解决问题的直接办法，唉，再懒也得自己上阵了。

通过跟踪调试，发现了问题所在，原来罪魁祸首就是他：

const FontGlyph *Font::getGlyphData (utf32 codepoint)

{

     if (codepoint > d_maxCodepoint)

         return 0;

         if (d_glyphPageLoaded)

         {

              uint page = codepoint / GLYPHS_PER_PAGE;

              uint mask = 1 << (page & (BITS_PER_UINT - 1));

              if (!(d_glyphPageLoaded [page / BITS_PER_UINT] & mask))

              {

                   d_glyphPageLoaded [page / BITS_PER_UINT] |= mask;

                   rasterize (codepoint & ~(GLYPHS_PER_PAGE - 1),

                       codepoint | (GLYPHS_PER_PAGE - 1));

              }

         }

         CodepointMap::const_iterator pos = d_cp_map.find (codepoint);

         return (pos != d_cp_map.end()) ? &pos->second : 0;

}

原来CEGUI根据Unicode字符的编码顺序，为每256个字符分配一张纹理（例如编码0-255存放在纹理一，编码768-1023 存放在纹理四）。英文很容易搞定了，那么几个字符一张纹理就够了，可中文就得靠运气了，有时显示几个字就要生成几张纹理，还要将每张纹理用不需要的相邻字填满，劳民伤财！

发现了问题，我便按照千里马肝的思想对函数进行了改造，将使用的文字放入一张纹理中，因为纹理最大承载256个字，所以，当汉字超过256个时，则将不常用的去掉，将新的字符写入。

后来我发现汉字的引用没有太多的规律，常用的一千多汉字出现的概率没有那么悬殊（废话，要不怎么是常用呢!），没有办法很好地按照使用的频率将汉字限制在256个字以内，写进纹理，就索性一旦满了就将字全部释放掉，重新写入。（也需有我没找到，还请高手指教）

代码如下：

const FontGlyph *Font::getGlyphData (utf32 codepoint)

{

     if (codepoint > d_maxCodepoint)

         return 0;

     if(codepoint < 256)  //决定保留一张纹理放英文和字符

     {

         if (d_glyphPageLoaded)

         {

              uint page = codepoint / GLYPHS_PER_PAGE;

              uint mask = 1 << (page & (BITS_PER_UINT - 1));

              if (!(d_glyphPageLoaded [page / BITS_PER_UINT] & mask))

              {

                   d_glyphPageLoaded [page / BITS_PER_UINT] |= mask;

                   rasterize (codepoint & ~(GLYPHS_PER_PAGE - 1),

                       codepoint | (GLYPHS_PER_PAGE - 1));

              }

         }

         CodepointMap::const_iterator pos = d_cp_map.find (codepoint);

         return (pos != d_cp_map.end()) ? &pos->second : 0;

     }

     else //显示汉字啦

     {

         CodepointMap::const_iterator pos;

         pos = d_hz_map.find (codepoint);

         if(pos != d_hz_map.end())

         {

              return (pos != d_hz_map.end()) ? &pos->second : 0;

         }

         else

         {

              rasterizeHZ(codepoint);

              pos = d_hz_map.find (codepoint);

              return (pos != d_hz_map.end()) ? &pos->second : 0;

         }

     }

}

void FreeTypeFont::rasterizeHZ (utf32 codepoint)

{

     int num;

     uint texsize = 512;

     if(d_hz_map.size() < 256)

     {

         float adv = d_fontFace->glyph->metrics.horiAdvance * float(FT_POS_COEF);

         d_hz_map[codepoint] = FontGlyph (adv);

     }

     else

     {

         d_hz_map.clear();

          ImagesetManager::getSingleton ().destroyImageset (hzImageset->getName ());

         hzImageset = ImagesetManager::getSingleton ().createImageset (

              d_name + "_auto_glyph_images_" ,

              System::getSingleton ().getRenderer ()->createTexture ());

         d_glyphImages.push_back (hzImageset);

         float adv = d_fontFace->glyph->metrics.horiAdvance * float(FT_POS_COEF);

         d_hz_map[codepoint] = FontGlyph (adv);

     }

     CodepointMap::const_iterator hzInter  = d_hz_map.find(codepoint);

     if (!hzInter->second.getImage())

     {

         // Render the glyph

         if (FT_Load_Char (d_fontFace, hzInter->first, FT_LOAD_RENDER | FT_LOAD_FORCE_AUTOHINT |

              (d_antiAliased ? FT_LOAD_TARGET_NORMAL : FT_LOAD_TARGET_MONO)))

         {

              std::stringstream err;

              err << "Font::loadFreetypeGlyph - Failed to load glyph for codepoint: ";

              err << static_cast<unsigned int> (hzInter->first);

              err << ".  Will use an empty image for this glyph!";

              Logger::getSingleton ().logEvent (err.str (), Errors);

              // Create a 'null' image for this glyph so we do not seg later

              Rect area(0, 0, 0, 0);

              Point offset(0, 0);

              String name;

              name += hzInter->first;

              hzImageset->defineImage(name, area, offset);

              ((FontGlyph &)hzInter->second).setImage(&hzImageset->getImage(name));

         }

         else

         {

              uint glyph_w = d_fontFace->glyph->bitmap.width + INTER_GLYPH_PAD_SPACE;

              uint glyph_h = d_fontFace->glyph->bitmap.rows + INTER_GLYPH_PAD_SPACE;

              // Check if glyph right margin does not exceed texture size

              uint x_next = m_nHZX + glyph_w;

              if (x_next > texsize)

              {

                  m_nHZX = INTER_GLYPH_PAD_SPACE;

                   x_next = m_nHZX + glyph_w;

                   m_nHZY = m_nHZYB;

              }

              // Check if glyph bottom margine does not exceed texture size

              uint y_bot = m_nHZY + glyph_h;

              // Copy rendered glyph to memory buffer in RGBA format

              drawGlyphToBuffer (hzmem_buffer + (m_nHZY * texsize) + m_nHZX, texsize);

              // Create a new image in the imageset

              Rect area(static_cast<float>(m_nHZX),

                   static_cast<float>(m_nHZY),

                   static_cast<float>(m_nHZX + glyph_w - INTER_GLYPH_PAD_SPACE),

                   static_cast<float>(m_nHZY + glyph_h - INTER_GLYPH_PAD_SPACE));

              Point offset(d_fontFace->glyph->metrics.horiBearingX * static_cast<float>(FT_POS_COEF),

                   -d_fontFace->glyph->metrics.horiBearingY * static_cast<float>(FT_POS_COEF));

              String name;

              name += hzInter->first;

              hzImageset->defineImage (name, area, offset);

              ((FontGlyph &)hzInter->second).setImage (&hzImageset->getImage (name));

              // Advance to next position

              m_nHZX = x_next;

              if (y_bot > m_nHZYB)

              {

                   m_nHZYB = y_bot;

              }

         }

     }

     // Copy our memory buffer into the texture and free it

     hzImageset->getTexture ()->loadFromMemory (hzmem_buffer, texsize, texsize, Texture::PF_RGBA);

}

     OK，问题搞定，打完收工。试试，效果还不错，可以洗洗睡了。特将自己的一点体会写出来，给新手提供个捷径，也希望高手批评指教。

        SOURCES +=main.cpp
        CONFIG +=qt

        ok 保存。

        打开命令行，切换目录到hello.cpp所在目录。生成Makefile文件；输入：

    qmake -o Makefile hello.pro ；

    接下来生成项目文件.vcproj文件。

    qmake -tp vc -o hello.vcproj hello.pro

   3，直接使用Qt Visual Studio Integration v1.2.2 for.VS.2003.2005插件(详见http://blog.csdn.net/znf19850924/archive/2008/01/16/2047373.aspx)

    需要配置如下：
         "Tools" -> "Options" -> "Qt" -> "Builds", 添加我们刚才编译的Qt代码,名字为"Qt 4.3.2", 路径为(yourqtinstallpath)

     启动一个新的工程.
         选择"Qt projects" -> "Qt Application"类型,输入工程名字,单击OK.

     双击工程文件里面的"test.ui",马上出现了所见及所得的窗体编辑器,在上面添加一个按钮.

     双击按钮,产生相应的消息响应函数.

     添加头文件:
         #include <QMessageBox>

         在函数void Test::on_pushButton_clicked()体内添加如下代码:
         QMessageBox box(this);
         box.setText("Haha, hit me.");
         box.exec();