- 在线时间
- 1916 小时
- 最后登录
- 2024-4-23
- 注册时间
- 2004-4-26
- 听众数
- 47
- 收听数
- 0
- 能力
- 60 分
- 体力
- 39894 点
- 威望
- 6 点
- 阅读权限
- 255
- 积分
- 15767
- 相册
- 0
- 日志
- 0
- 记录
- 0
- 帖子
- 4950
- 主题
- 2634
- 精华
- 5
- 分享
- 0
- 好友
- 137
TA的每日心情 | 奋斗 2024-4-23 06:17 |
---|
签到天数: 1011 天 [LV.10]以坛为家III
群组: 万里江山 群组: sas讨论小组 群组: 长盛证券理财有限公司 群组: C 语言讨论组 群组: Matlab讨论组 |
<>取得本地internet机器的名字及IP地址 </P><>一、下面的例子使用 Winsock API 取得本地主机的名字及地址
; v P) _8 A' ^( n' P# p2 Svoid __fastcall TForm1::Button1Click(TObject *Sender) ( I& W1 v- p7 f- Y
{ ' t1 [$ l2 a5 G' {
hostent *p;
: r; w6 ]6 h' X% ~+ r3 Dchar s[128]; ! Y) f% ^) }( t; h: Y7 I
char *p2; </P><>//Get the computer name
6 N4 l F3 _' N$ ~gethostname(s, 128);
8 m* Z v- u: p. ]) r) [8 rp = gethostbyname(s); H' m! @! H( A! A
Memo1->Lines->Add(p->h_name); </P><>//Get the IpAddress 7 f! n! U% U* `. n
p2 = inet_ntoa(*((in_addr *)p->h_addr)); ; p* M9 L3 r' D d
Memo1->Lines->Add(p2);
) G; b9 S; g% J( F; ^, ]} </P><>void __fastcall TForm1::FormCreate(TObject *Sender)
# |8 v% Y7 t( F+ q$ X{
7 E) @/ v+ m w5 ~6 NWORD wVersionRequested; 8 K3 a1 ^! Z3 u( p' x: ^
WSADATA wsaData; </P><>//Start up WinSock ) P s/ z* U1 o \. G
wVersionRequested = MAKEWORD(1, 1);
: ^7 o7 ?+ x4 EWSAStartup(wVersionRequested, &wsaData); . D& @* X) G. v- z* u
} </P><>void __fastcall TForm1::FormDestroy(TObject *Sender) 0 @- T, Q8 v x" u
{ 5 S0 s0 N) B" z4 @* ^
WSACleanup(); 7 F6 u! ?$ \4 H% |" i
} </P><>用C++Builder创建数字签名 </P><>6 p! V# \9 N- p# J$ |. C
如果你在网络上传递一份数据,但却存在着种种不安全的因素,使你对数据能否原封不动地到达目的地而心存疑惑,这时,你就可以给数据加上数字签名,从而使对方可以通过验证签名来检查你所传过去的数据是否已被他人修改。 </P><> 一、程序原理 </P><> 数字签名的工作原理还是比较简单的,它是根据你所提供的原始数据,经过复杂的算法,产生特定的数据签名,对方通过同样的过程也产生签名,如果数据已被修改,那么就不可能得到两份一模一样的签名,从而就可判断数据已被他人修改。编程人员利用Windows的CAPI接口,就可以实现数据的加密、解密和数字签名。 </P><> 二、程序清单 </P><> 下面用C++ Builder的语句来看一下它的具体实现过程。
) K( l, u7 P D. w% ^: [ 先来创建数字签名,假定其数据来自于一个文件。 9 J8 C3 f) M: B y6 n9 J0 S" H6 m
//变量声明: 4 ]2 S6 e7 R6 ]9 U# \$ ^3 B
HCRYPTPROV hProv;
) D' b1 P. u+ O // CSP的句柄 $ P! x; \( w; x
HCRYPTHASH hHash; , y: o6 J) F9 L! }9 k
// 散列的句柄 / m; Y1 e. c, D. l* G
const int BUFFER=4096;
2 x. a* ]; o' ~# } // 缓冲区大小常数 + k* c. _7 q9 |1 F
BYTE pBuffer[BUFFER]; 7 W4 r0 Y! W. m( A
// 存放读文件内容的缓冲区
Y* I) Y1 Y, C$ M3 p3 ^ BYTE pSignature[256];
/ M0 ^4 L# \2 d // 存放签名的缓冲区
. s, ~1 h9 |- Q8 @2 F DWORD dSignatureLen=256; " c# X0 G8 l/ o5 K. l3 f
// 签名的长度
# M% A/ O& i8 a h' z( r TFileStream *sourceFile; ' E( U5 }7 Z# }" U8 V$ g* `* V& }
// 一个文件流 3 D' w& R( {: @ D5 U- a3 a
if(!CryptAcquireContext(&hProv,NULL,NULL,PROV-RSA-FULL,0))
9 C4 ?: |! c& A // 连接默认的CSP,接受它的句柄放入hProv # L8 J* A: K' s6 y3 L3 E$ b; S0 \
{
5 W7 |% L, n, m; ^! G; w3 @0 r: K$ c // 错误处理 3 X [7 x7 _% p5 ?
} ; {6 h7 T& L! t4 i0 w
if(!CryptCreateHash(hProv,CALG-MD5,0,0,&hHash))
# P9 v$ h1 h9 M+ s5 G1 p; { // 创建一个散列对象,得到它的句柄放入hHash
. \3 a5 F. o* G0 C3 b1 ~1 T2 P {
5 G6 }: H6 C9 P4 G7 e8 ] // 错误处理 7 \% q2 f+ Q! R% w
} * f# I6 o/ _, l% V, T z6 ^
do + x1 B2 o6 L+ J8 p0 | R
{ ( p* _; c" e7 E e# p! @) J/ g
dReadLen=sourceFile->Read(pBuffer,BUFFER); 6 o# C, H; C" @6 Q' `0 A; e
if(!CryptHashData(hHash,pBuffer,dReadLen,0)) 4 J+ u; r' n2 N X
// 根据文件的内容计算散列值 3 a* P( n$ i+ h* _
{ m' u) w$ D$ z/ F* k
// 错误处理
8 z+ X& s% C7 E: j }
8 B v$ _& {- N# R }while(!(dReadLen<BUFFER));
8 y8 s+ `, _& P; X/ G2 E# e- g/ T if(!CryptSignHash(hHash,AT-SIGNATURE,NULL,0,pSignature,&dSignatureLen)) , X4 _! m! |! e
//使用私人密钥对散列值进行数字签名
8 t8 _" v. H; ?5 J //签名数据放入pSignature,长度放入dSignatureLen
" R0 o" P! ~8 f' m // 错误处理 % K/ c# r. @2 P; M0 o5 ^" j0 T
} 5 d$ Y1 g" q6 g: F0 a8 r; E" P
对基于文件的数据签名进行检验。
, F8 Y0 {4 T1 J8 u4 y //变量声明: & h+ O# }# p. p
HCRYPTPROV hProv;
3 @' [3 S& |7 g6 {$ O // CSP的句柄
$ Y5 Y3 J' u. l0 f HCRYPTHASH hHash; 2 R j# `. Z/ a0 n) Q7 U o
// 散列的句柄 8 C! H) Q7 q2 J" [* n! ?) E
HCRYPTKEY hPublicKey; , w3 B k; x5 }
// 公共密钥的句柄 0 m8 U( `' c- Q! ~5 U- ]* u* w- ^$ |
const int BUFFER=4096;
. t3 Y/ e2 o- G' h // 缓冲区大小常数 / N0 w! `2 b* `9 h9 Q- w! G& j
BYTE pBuffer[BUFFER]; " \* I3 {% A+ {0 b4 L8 M% i/ U+ f
// 存放读文件内容的缓冲区
: [! P% Y' B" ~' w ? TFileStream *sourceFile; // 一个文件流
( V/ f% {7 }2 v7 D) U+ U) O BYTE pSignature[256]; " D: b7 r* x# B- l
// 上一段得到的签名的缓冲区 : ?# e- p5 ?: o+ S4 @$ |
DWORD dSignatureLen; 6 r8 D& X+ v8 _+ P, \ b" E
// 上一段得到的签名的长度
' I" x( J, E, T- K1 P if(!CryptAcquireContext(&hProv,NULL,NULL,PROV-RSA-FULL,0))
7 s% m# f6 Y x4 X // 连接默认的CSP,接受它的句柄放入hProv
% W% h/ [ R: J( A) D( i$ Z {
/ q' x9 `- o( M! ^# `$ J4 ^ // 错误处理 2 i k$ J+ H, _
}
+ g M5 q. A4 r* ] if(!CryptGetUserKey(hProv,AT_SIGNATURE,&hPublicKey); // 得到公共密钥的句柄 7 c3 s7 r9 Z! l2 n6 J/ G' ]1 k
{
5 a1 G% I/ k' b2 q) h% y5 v$ _ // 错误处理 6 j! T" i+ p1 w2 V
}
3 z- f1 e" k+ } if(!CryptCreateHash(hProv,CALG-MD5,0,0,&hHash)) // 创建一个散列对象,得到它的句柄放入hHash ) g) l2 e& F% @. ]' U% t
{
" h! G3 v6 G5 b) P, t D // 错误处理 ) @( l: t$ B% f
} : ^2 p& [/ _& d l/ {( \; g
do
! a# j* ~ y! m6 G- M% X { * F4 _0 u9 F" ^+ |
dReadLen=sourceFile->Read(pBuffer,BUFFER); ! ?2 k$ `5 Z5 _( J9 s
if(!CryptHashData(hHash,pBuffer,dReadLen,0)) 7 Z/ t, C. H# d% U9 }, s
// 根据文件的内容计算散列值 ( j E- J0 e, t- k" \6 N
{ " U, o d( _2 C" X' u2 V
// 错误处理
/ f2 ~5 I% F$ w+ O* P1 v0 M( [ }
) i8 r$ q: N- @ }while(!(dReadLen<BUFFER)); 9 i1 ~' I, E8 X! h7 y/ N
if(!CryptVerifySignature(hHash,pSignature,dSignatureLen,hPublicKey,NULL,0))
0 H( J# p5 @% j" e+ h' } {
/ b2 k( V# |; i( m' _ H( u7 f if(GetLastError()==NTE-BAD-SIGNATURE) ShowMessage(″文件已被修改″); 8 [1 X3 ?, K; o9 X: P
}
6 Q2 N/ d; [+ O. i" o3 w# G3 `7 B else
5 C2 P6 I0 }' O+ ~% W: d: ~/ |" I2 W {
/ p+ r) y6 s! S) d ShowMessage(″文件没被修改″);
4 l" w0 H9 Q7 o1 @* c) p8 J } </P><> 以上是一个数字签名的简单实现,得到的签名数据可以单独保存,也可以分开保存。 </P><>用Enter 键 控 制 焦 点 切 换 的 方 法 </P><>在Windows 环 境 下, 要 使 一 个 控 件 取 得 焦 点, 可 在 该 控 件 上 用 鼠 标 单 击 一 下, 或 按Tab 键 将 焦 点 移 至 该 控 件 上。 这 种 控 制 焦 点 切 换 的 方 法 有 时 不 符 合 用 户 的 习 惯。 就 图 一 而 言, 用 户 就 希 望 用Enter 键, 控 制 焦 点 由Edit1 切 换 到 Edit2。 要 实 现 这 样 的 功 能 需 借 助WinAPI 函 数SendMessage 来 完 成。 方 法 是: 先 设Form1 的KeyPreview 属 性 为true, 然 后 在Form1 的OnKeyPress 事 件 中 加 入 如 下 的 代 码。 这 样, 用 户 就 可 以 通 过 按Enter, 键 控 制 焦 点 按 定 义 好 的Taborder 顺 序 来 移 动 了 ! 7 K$ c, t* t" s9 Y
void __fastcall TForm1::FormKeyPress(TObject *Sender, char &Key)
1 }3 P7 S* G0 i9 L1 t5 C{
3 b* K! q# r6 E( d4 c, Kif(Key==VK_RETURN) </P><>{
- X0 e. R' u2 I5 GSendMessage(this- >Handle,WM_NEXTDLGCTL,0,0); ' w0 ^5 S! ?6 R% `. P( h$ }: ~
Key=0;
3 P/ [2 B+ a3 N3 v9 o5 o} ) B q8 f: F6 {! Z+ T' E
} </P><>
3 r% B8 t. l+ a拦 截 Windows 消 息 </P><>
6 X, T7 Q' \ b v8 }# C4 R. Q3 X) P$ G7 D- --Borland C++ Builder的API后门 </P><>---- 引子 </P><>---- C++ Builder不愧为Borland公司的优秀产品,用它来开发Windows程序非常快捷高效,但在编程过程中你也会发现它的一些限制性,让你无法实现自己的想法。比如你无法在修改表单的系统菜单;比如使用跟踪栏时,你找不到StartTrack和EndTrack事件,而偏偏你的程序需要这两个事件。Windows API编程中,你就不会有这些麻烦,只需处理一下WM_SYSCOMMAND和WM_HSCROLL(或WM_VSCROLL)消息,就能实现上述功能。Windows API的缺点是编程十分麻烦,太多的时间要耗在细节上面,但它的功能却是最强大的。C++ Builder的VCL在功能上只是它的一个子集,因为VCL是在API的基础上封装的,封装时舍弃了一些不常用到的功能。但是程序员的想象力没有被封装,他们总怀着更大的热情去实现别出心裁的想法,修改系统菜单和给跟踪栏增加StartTrack和ndTrack事件只是其中的小把戏而已。可是VCL并没有这些功能,怎么办? </P><>---- 幸好,Borland公司没有把路堵死,而是留了个后门--允许程序员自己拦截并处理Windows消息,就象API编程一样。于是,办法有了... </P><>---- 方法 </P><>---- 拦截Windows消息需要以下几步:
7 o1 y$ u4 T. {- H/ O3 {---- 在表单头文件内(如Unit1.h)
2 h3 m* R9 J ?/ L5 A/ O3 Z+ x---- 1. 在类声明中建立消息映射表,把某条消息的处理权交给自定义的消息处理函数。 </P><>BEGIN_MESSAGE_MAP
B L, Y: p1 @9 zMESSAGE_HANDLER(Windows消息名,TMessage,消息处理函数名) ' v+ [0 M. S' j: K( L
MESSAGE_HANDLER(...)
" W! E% d0 b4 V& {END_MESSAGE_MAP(TForm) </P><>
- o6 a9 P" H- v* B. B6 }---- 2. 在类声明的private区内声明消息处理函数。 </P><>private: // User declarations ( P' ^$ s! P/ P2 `% E1 P7 L' w
void __fastcall 消息处理函数名(TMessage &Message); : n8 a3 b. B! U! e3 E& B' ?$ Z% u8 R
在表单文件内(如Unit1.cpp) </P><>. h0 [. n4 L* P! M! a n
---- 3. 写出消息处理函数,在这里实现你需要的功能。比如
1 T) R/ P2 ~8 S) `5 {void __fastcall MainForm::OnWMHScroll (TMessage &Message)
' {. r2 l) F) v{
: }7 B7 \1 a& j- }( A8 Z. N' M... // 在此加入你自己的代码
$ r j( N6 D2 V7 mTForm:ispatch(&Message); ; H! P5 W& }+ J& ]
} </P><>3 E4 U4 a. Z b# O( o; ]
---- 解释 </P><>---- 1. 关于TMessage </P><P>---- TMessage是VCL预定义的结构,定义如下: 9 `3 Z! Z+ Z% D! U
struct TMessage / H( a0 R8 [" b* N: V
{ 4 Z+ {& c9 ?/ b* q" J
unsigned int Msg; //消息
- v' B( m G, r" E/ Vint WParam; //字参数
$ t! D+ l3 q! o$ g- x! Iint LParam; //长字参数 . Q, n8 I" ], i) [0 k% y7 k. X
int Result; //消息结果 ' I6 _8 Q, E B; O7 F- R; E% G
}; </P><P>
" j. E7 H3 |, D6 @6 b+ H7 E5 {; _---- 2. 关于TForm:ispatch(&Message) </P><P>---- 自定义的消息处理函数末尾最好加一句TForm:ispatch(&Message),这一句的作用是让消息继续传递下去。如果没有这一句,消息将被完全拦截,VCL类可能由于得不到消息而无法实现正常功能。 </P><P>---- 实例一:修改系统菜单 </P><P>---- 有一些程序,主窗口很小,菜单也没有,如果想加入关于或设置对话框,最好的办法是拿系统菜单开刀。Windows API编程中,修改系统菜单与实现其他功能一样,不太容易,也不会太难。但在C++ Builder中,表单类(TForm)没有提供有关系统菜单的任何属性与方法,实现其他功能易如反掌,而修改系统菜单似乎难于上青天。 </P><P>---- 还好,Borland公司允许程序员自已处理Window消息,于是机会来了! </P><P>一、用Window API函数修改系统菜单 </P><P>假定表单名为MainForm,设置MainForm::OnCreate()函数: </P><P>1. 用GetSystemMenu(MainForm->Handle,false)取得系统菜单句柄; </P><P>2. 用AppendMenu,DeleteMenu,ModifyMenu函数修改系统菜单,把新的ID号赋于自定义的菜单项。
8 C2 S1 H$ |" I' J: `5 Z- E这时运行程序,可以看到系统菜单也被修改,但自定义的菜单项却不能被响应。 </P><P>二、拦截WM_SYSCOMMAND消息以响应自定义的菜单项 - [/ R, v/ U4 u* Y' g) ~, ]
在表单头文件内(如Unit1.h) </P><P>1. 在表单类定义末尾加入消息响应表,取得WM_SYSCOMMAND消息的处理权 1 ^/ B) j- B. `" G; [
BEGIN_MESSAGE_MAP
, {9 _# K. `3 G+ Q1 d# |: C$ |MESSAGE_HANDLER(WM_SYSCOMMAND,TMessage,OnWMSysCommand)
2 L0 ?2 T& g2 ]" M4 mEND_MESSAGE_MAP(TForm) </P><P>2. 在表单类定义的private区内加入消息处理函数声明
# _1 I# m, @! V/ m# Bprivate: // User declarations
* t2 ?3 z, ~7 ]1 _" E3 ivoid __fastcall OnWMSysCommand(TMessage& Message); </P><P>在表单文件内(如Unit1.h) </P><P>3. 写出消息响应函数
9 e# j3 d- C0 D3 J. _- rvoid __fastcall TForm1::OnWMSysCommand(TMessage& Message)
8 p# ]2 L& u$ s- j2 a{
4 r7 I/ R' Z" y: @if(Message.WParam==ID_SysMenu_MyItem) 3 m7 k K3 k, T8 }4 ^6 T1 p0 ~
{
% U4 G# i% f, X/ ?0 s5 X// Your Code Here, Do Something 0 v( @: u7 f3 W, y# u3 m' h: R+ r
} ( n# F% q( o# H* V0 R$ z9 w
TForm:ispatch(&Message);
4 \7 @5 X7 |) y$ D" u& A% t4 C} </P><P>3 v3 l# G0 M$ c1 ~
三、完整程序示例 </P><P>实例二:给跟踪栏增加OnStartTrack和OnEndTrack事件 </P><P>当跟踪栏用于进度控制时,OnStartTrack和OnEndTrack很可能是你需要的事件。比如在控制多媒体播放进度的场合,当用户移动滑块时,你需要OnStartTrack事件让播放停止,需要OnEndTrack事件定位新的播放位置。但Borland公司没有提供这两个事件,我等编程爱好者只好自力更生,打拦截Windows消息的主意了。 </P><P>一、拦截WM_HSCROLL消息,给跟踪栏增加OnStartTrack和OnEndTrack事件 </P><P>在表单头文件内(如Unit.h) </P><P>1. 在表单类定义末尾加入消息响应表,把WM_HSCROLL消息处理权交给OnWMHScroll函数。
+ R) I3 Q! J( ~) p$ JBEGIN_MESSAGE_MAP
8 {0 o! p( i, g5 i! n( rMESSAGE_HANDLER(WM_HSCROLL,TMessage,OnWMHScroll) 2 t# s! K$ S3 U7 o* m
END_MESSAGE_MAP(TForm) </P><P>2. 在表单类定义的private区内加入OnWMHScroll函数声明。 6 R: W1 a; d- X0 a
private: // User declarations
) v8 H- a, s0 c9 U0 S1 G. N3 vvoid __fastcall OnWMHScroll(TMessage &Message); </P><P>
G8 p( f& i* Y y" A3. 在表单类定义的private区内加入StartTrack和EndTrack函数声明。 / x U. f$ t2 t# P1 W
private: // User declarations : q- F0 N4 Z+ ^& h& y' k
void __fastcall TrackBar1StartTrack(TObject *Sender);
. N' `3 K- s1 \9 J# h7 _ {void __fastcall TrackBar1EndTrack(TObject *Sender); </P><P>在表单文件内(如Unit.cpp) </P><P>4. 写出OnWMHScroll函数,使它能根据消息参数调用StartTrack和EndTrack函数,在实际意义上产生OnStartTrack和OnEndTrack事件。 </P><P>5. 写出StartTrack和EndTrack函数。 </P><P>如果是垂直跟踪栏,把上面的WM_HSCROLL改为WM_VSCROLL即可。 </P><P>二、完整程序示例 </P><P>尾声 </P><P>Borland C++ Builder编程中,拦截Windows消息是一项高级编程技术,能让你尽量挖掘Windows的潜力,尤其让曾用API编程的程序员感到心慰。拦截Windows消息是API尽情发挥的舞台,当VCL不能为你做什么时,请想起底层的API。 </P><P>使用CommaText </P><P>有时需要一个方便的方法存放一个StringList,它只有简单的一行。例如,当你想使用一个INI文件,如何向一个INI文件中写入一行呢,使用CommaText 就能完成这个工作。 </P><P>这里有个例子,功能是创建一个blah.ini文件,并写入一个如下形式的值: </P><P>[My Section] + n' i" B4 W1 A1 b2 d+ U; `
Memo1=(你在Memo1中输入的文字) </P><P>1.在Form1上有两个按钮btnLoad and btnSave和一个Memo1 </P><P>2.还要加入: . p9 H: {; J2 s9 n3 y
#include <inifiles.hpp> </P><P>3.定义变量: " s9 s2 q# V j6 Q
const String iniFile="blah.ini",iniSection="My Section",iniValue="Memo1"; </P><P>4.保存按钮代码: / H: \) j8 m' c" v( ?
void __fastcall TForm1::btnSaveClick(TObject *Sender) 2 u; } V# @, `) ?% k
{ 4 l; d$ n U: g! U2 k
TIniFile *ini=new IniFile(ExtractFilePath(Application->ExeName)+iniFile); ) I+ Q( @5 d v2 L
ini->WriteString(iniSection,iniValue,Memo1->Lines->CommaText);
E0 m& w! e- s+ W! ddelete ini;
( Z3 k( {/ P$ T! J) O, ?3 ]} </P><P>5.装载按钮代码: ( B0 k# t+ o! U7 ?6 i0 L- f5 `
void __fastcall TForm1::btnLoadClick(TObject *Sender)
& l# N9 u/ F1 k7 G( H( c{ / D% y w, q* H8 ^: {0 B
TIniFile *ini=new TIniFile(ExtractFilePath(Application->ExeName)+iniFile); & m/ q$ m# j! D! O0 O
Memo1->Lines->CommaText=ini->ReadString(iniSection,iniValue,"");
5 x6 E2 ~ T( r4 ]; odelete ini; 9 c8 B; c3 n+ ]1 V+ C+ X) c$ {
} </P><P>6.以下代码支持加载后对内容进行排序,到实际存储不变: 6 o! Q: z; o! X c7 M
void __fastcall TForm1::btnSortLoadClick(TObject *Sender)
# P0 |5 ]; H; h6 e: R& P{ . ]7 W7 ~! k' T. C
TStringList *sl=new TStringList;
) s5 ?- f, i o9 j% fTIniFile *ini=new TIniFile(ExtractFilePath(Application->ExeName)+iniFile);
( {$ H/ A4 @3 k& n2 Osl->CommaText=ini->ReadString(iniSection,iniValue,""); / P$ a0 M1 e' R/ H
sl->Sort();
$ u, l6 v, n, xMemo1->Lines=sl;
( I3 w, i( k2 K8 K: M' odelete ini; & q- m1 R: Z6 J0 Z
delete sl;
8 r/ o! Y3 a7 ~! c7 \} </P><P>程序开始时先显示信息框 </P><P>一、软件进入主窗口前,先显示一个信息框,告诉用户一些有关该软件的信息,比如软件名称,版本号等。该信息框在显示1~2秒后自动消失。 % b$ c5 W* |, D6 @7 i. x. V. T
1.建立New Application,这时系统自动生成一个Form1,这作为主Form. </P><P>2.File->New Form 建立一个新Form为Form2,这个作为信息框。 </P><P>3.在Form2上添加组件TTimer(System控件条上),用于设定信息框的显示时间。
& T& G9 D8 R$ |7 U/ r! l4.TTimer的事件OnTimer中加入:Form2->Close(); </P><P>5.在WinMain()函数中加入:
$ ^% i' e, c. `- d4 M" vApplication->CreateForm(__classid(TForm2), &Form2);
' d# m3 G1 Z9 G9 J1 Z0 HForm2->ShowModal( ); //这句要自己加入
0 `7 R% {% ]' S6 C/ M2 rApplication->Run();
, v0 c! V# g2 R/ h+ U* @2 @并且要把Form2的头文件Unit2.h包括到WinMain()所在的Project1.cpp中。 </P><P>6.运行程序,将先显示Form2,显示时间由TTimer的Interval属性决定,1000是一秒。 </P><P>二、软 件 封 面 的 实 现 % ?0 N. H" g# \3 v* U- f {5 S
现 代 软 件 设 计 的 流 行 做 法 是, 在 程 序 运 行 完 成 初 始 化 之 前, 先 调 用 一 幅 画 面 做 为 封 面, 通 常 是1/4 屏 幕 大 小, 显 示 一 下 软 件 的 名 称、 作 者、 版 本 等 信 息。 要 用C++ Builder 实 现 这 样 的 功 能, 方 法 很 简 单: </P><P>① 自 定 义 一 窗 体 类 TSplashForm, 将 其 设 置 成" 透 明 窗 口", 即 BorderIcons 下 的 所 有 选 项 均 置 成false, BorderStyle=bsNone,FormStyle=fsStayOnTop, Position=poScreenCenter; </P><P>② 在TSplashForm 窗 体 上 放 置 一TPanel( 相 当 于 图 形 的 镜 框); </P><P>③ 在TPanel 上 放 置 一TImage 控 件, 调 入 所 需 要 的 图 形; </P><P>④ 对WinMain 函 数 稍 加 修 改, 加 入 如 下 所 示 代 码 即 可。 需 要 指 出 的 是, 这 段 代 码 通 过 函 数 FindWindow, 搜 索 内 存 中 是 否 有 窗 口 标 题 为 "Demo" 应 用 程 序 存 在, 若 存 在, 则 退 出 程 序 的 运 行。 该 功 能 可 防 止 程 序 的 再 次 运 行。 在 某 些 场 合 这 样 设 计 是 必 须 的。 </P><P>WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int) ) W# e7 d E% {3 T" \3 u, y
{ ) ]3 x' x0 B- e4 n6 d! d/ c
try + t# d* j: ?; D( |# m! n" y( u
{
9 U. I( ~7 H; B6 W K' I, H' Bif(FindWindow(NULL,"Demo")!=0)
. v# `: w, s: ^" l{ " D: y. \, a% N+ c" z! `1 b( t" R
Application- >MessageBox (" 程 序 已 经 运 行!"," 警
6 h; o6 @# ^) b. F0 @/ |告",MB_ICONSTOP);
8 G+ _! O' n% Sreturn 0; # W. p9 C$ L2 e" e' {) K
} </P><P>TSplashForm *splash=new TSplashForm(Application); </P><P>splash- >Show(); </P><P>splash- >Update(); </P><P>Application- >Initialize(); </P><P>Application- >CreateForm(__classid(TForm1), &Form1); </P><P>splash- >Close(); </P><P>delete splash; </P><P>Application- >Run(); </P><P>} </P><P>catch (Exception &exception) </P><P>{ </P><P>Application- >ShowException(&exception); </P><P>} </P><P>return 0; </P><P>} </P><P>怎样获取程序的命令行参数? </P><P>
) N, q& i/ \3 u你可以用下面的两种不同的技巧来解决这个问题。 </P><P>技巧1:首先,也许是最简单的方法是调用VCL ParaStr()函数。你可使用ParamCount()函数来确定到底有多少个命令行参数传递给了应用程序。 </P><P>ParamStr需要一个整数参数并且返回一个AnsiString对象。若参数为0,ParamStr 将返回可执行文件的全称路径。若参数为1,将返回程序名及第一个命令行参数。若参数为2,将返回第二个参数,等等。 </P><P>作为一个实践,开启一个新的项目,在主窗口上放置5个Label,将下面的代码添加到窗口的构造函数中: </P><P>Label1->Caption = ParamStr(0);
: i" k3 t+ `! h2 C+ pLabel2->Caption = ParamStr(1); % {% n8 v6 `2 i- K% R# n* r0 l
Label3->Caption = ParamStr(2); + n+ A) j; l' Z; s/ D$ t
Label4->Caption = ParamStr(3); }# U2 J. N% K3 Q' T- n) Y, _
Label5->Caption = ParamStr(4);
* g+ D$ V/ j# F- x再运行程序。一般应能看到类似字符串: </P><P>E:\CBUILDER\PROJECTS\PROJECT1.EXE , a; q2 J( i) s/ E( c6 o9 _' J* K
如果没传递参数到程序,那么Label2到Label5是空字符串。关闭程序,从C++Builder菜单中选择 Run | Parameters。输入几个参数(-debug -testing -param)再次运行程序。你将看到: </P><P>E:\CBUILDER\PROJECTS\PROJECT1.EXE $ R0 u/ D4 \$ g8 I
-debug
* f7 |7 U1 F: i" z-testing
2 A0 P0 `: d+ O& ?+ k( `' M- U-param * \0 h3 _- Z% u) e7 o; r, ~3 Y2 J
提示: ParamStr 对目录中的空格能智能判断。为证实这点,把生成的EXE文件拷贝到Program Files目录下再运行它,你将会看到ParamStr(0)返回全路径,并包含空格。 </P><P>技巧2:第二个方法就是调用GetCommandLine API函数。GetCommandLine不需要参数,并且返回一个C风格的char *,包含全部的命令行参数。你将不得不分解字符串以取得相关参数。 </P><P>Label5->Caption = AnsiString(GetCommandLine()); " H. b; X/ y! D- H% V
运行后,Label5将为: </P><P>"E:\CBuilder\Projects\Project1.exe" -debug -testing -param </P><P>5 X/ K5 Z5 @5 ~, P& v
如何监视剪贴板 </P><P>在Form1的.h的private加上: . X. e* C. o5 [, G) w, S1 G/ V8 n
void __fastcall ClipboardChanged(TMessage& Msg); </P><P>在Form1的.h的public加上: $ L. ], l+ \" Y1 m9 M
BEGIN_MESSAGE_MAP 9 k& A* g! i4 l
MESSAGE_HANDLER(WM_DRAWCLIPBOARD,TMessage,ClipboardChanged) 3 C7 E8 H3 O% U! a* U( n
END_MESSAGE_MAP(TForm) </P><P>在Form1的.cpp内加上: ; v ]8 y8 C2 E9 h& Z3 ?/ Q' J& g
void __fastcall TForm1::ClipboardChanged(TMessage& Msg) 5 P9 F9 j9 F7 j! v
{
' w8 p7 n; `8 _8 N+ X POINT MousePos; 8 l7 S2 t& a9 q& q) |
GetCursorPos(&MousePos); ) R- k& [3 H0 c( w- |
PopupMenu4->PopupComponent=Form1;
# q$ \# `# A" D" x( n PopupMenu4->Popup(MousePos.x,MousePos.y); //一有变化,就弹出一个菜单,复制,剪切或清除都能引发此函数 5 d3 f, \' P8 w( x1 X0 ?
} </P><P>在Form1的.cpp内有一个ToolButton
8 |* K: D( @" I1 Svoid __fastcall TForm1::ToolButton9Click(TObject *Sender) ' A8 G+ c' d7 U
{ ! b, t3 W2 d/ b( _( l0 h# u
static HWND LastHandle;
/ \6 E3 m9 ]; N/ d" C& [ static bool clip=false; & @1 I4 M% }: {
if(clip==true) 9 S4 K/ ?9 A8 u
{ 4 B! e& Q- z# W% Y7 m
ToolButton9->Down=false;
* d( T: {6 R$ v) d8 A1 Q ChangeClipboardChain(Form1->Handle,LastHandle); //结束监视
1 X. Q! {+ h) f1 L }
$ {4 f# n$ j3 T' M' a$ P6 v else
' _/ x( M1 P p" u# l! u {
7 M5 j; e, w1 k8 q' Q2 q ToolButton9->Down=true;
: M, t2 W9 @1 l, V: k. q3 F( I: H Clipboard()->Clear();
9 [ I4 O/ c- g Application->Minimize(); 7 y7 W P5 ?. M8 t
LastHandle=SetClipboardViewer(Form1->Handle); //启动监视 9 l- S' I! z) H" V$ `- a6 B1 r n
} " G& p; f/ I8 a4 y
clip=!clip;
- e" k( y( e* r6 h. i4 b: z9 `} </P><P>+ o$ [/ _. Q% B
如何使用OnIdle事件 </P><P>使用OnIdle事件随时监视剪贴板内容以改变弹出菜单的可执行项。 </P><P>在Form1的.h的private加上:
. T; x1 }' e7 l% Cvoid __fastcall OnIdle(TObject* Sender,bool& Done); </P><P>在Form1的.cpp内加上: : Y. K3 b. v8 Y- m& o6 [
void __fastcall TForm1::OnIdle(TObject* Sender,bool& Done) 2 T; @* S- [- ]/ V/ A% f
{ . ?3 N( J% G% `0 Y, b3 w
bool TextSelected=DBRichEdit1->SelLength>0;
" ^- ^: n$ }" M5 C$ I N17->Enabled=TextSelected;//剪切,复制,清除
* }/ N d( }4 ]0 f. i N18->Enabled=TextSelected; ! q6 }5 x" Z n" a
N20->Enabled=TextSelected;
1 L! k% I; ~. e6 Y; ] bool CBHasText=Clipboard()->HasFormat(CF_TEXT);// 需加入#include<Clipbrd.h>
6 C0 n+ y/ C9 g8 d" E N19->Enabled=CBHasText;//粘贴 . H, u% |7 V8 C( {/ u7 v# `
bool HasText=RichEdit1->Lines->Count>0;
3 J" h3 z, _# k. q: F/ Z9 W N21->Enabled=HasText;//全选 6 y* w9 G/ c. N s+ n
bool HasChanged=RichEdit1->Modified;
4 I1 s/ y* y& u" B3 d" e! o ToolButton2->Enabled=HasChanged; 5 A& \) S4 ^& R/ z8 U, T
ToolButton4->Enabled=HasChanged; % n3 ^. f0 L/ v
} </P><P>在Form1的OnCreate内加上: 5 X, W) u+ G7 n% S9 M
Application->OnIdle=OnIdle; </P><P>. q+ }' y+ H7 Y; P6 l
/ ?; H- L0 g5 K
用C++Builder4.0编写Win 95下的串行异步通信程序 </P><P> ·串口操纵的基本方法· </P><P>
1 ~& P D; M/ k1 w8 ~( e 在Win32下,对串口的操作就如同对文件一样打开或关闭,对串行数据的读写可在用户定义的读写缓冲区中进行。具体使用的函数为: </P><P> 首先用CreateFile( )打开通信串口,其中参数lpFileName指向串口逻辑名,如“COM1”或“COM2”等,参数dwDesiredAccess定义文件的读写权限,一般设为GENERIC-READ|GENERIC-WRITE;参数dwShareMode定义资源共享方式,此处必须设为0,为独占方式;lpSecurityAttributes定义安全属性,Win 95下为NULL;dwCreationDistribution定义文件创建方式;dwFlagsAndAttributes定义文件属性和标记,应设为FILE-FLAG-OVERLAPPED,表示异步通信方式;hTemplateFile 指向一个模板文件的句柄,在 Windows 95下为NULL。 </P><P> 然后用BuildCommDCB( )和SetCommState( )函数通过通信设备控制块DCB(Device Control Block)设置串口通信参数(如波特率、停止位、数据位、校验位等),其中BuildCommDCB( )中的字符串参数lpDef 定义同DOS命令中MODE的参数格式,关于DCB更具体的设置需要根据用户对数据流定义、握手信号及通信控制要求具体定义,参见有关Windows技术资料。用GetCommState()可以得到当前的DCB参数值。如果需要还可通过SetCommTimeouts()和GetCommTomeouts()重新设置读写的超时参数;读写缓冲区的设置使用SetupComm(),参数dwInQueue和 dwOutQueue分别定义为输入和输出缓冲区的大小。 </P><P> 在串口初始化完毕后,还要建立与通信有关的事件对象。一般使用CreateEvent()函数,它返回一事件句柄,其中参数lpEventAttributes指向安全属性结构地址,在Win 95(无安全属性)中为NULL;布尔参数bManualReset 定义事件重置方式,true 表示手工重置,false表示自动重置(相关函数为SetEvent()和ResetEvent());参数bInitialState定义事件初始状态,true表示发信号,否则为不发信号;lpName是为多进程设置的事件名,对于单进程定义为NULL。然后用SetCommMask()定义用户程序可监视的通信事件类别。 </P><P> 以上设置完成后,用户程序就可以等待通信事件的产生,一般调用函数WaitCommEvent()监视通信事件,其中参数lpEvtMask指向产生事件的掩码地址,用于判断事件产生的性质,lpOverlapped指向重叠结构地址,可简单定义为NULL。对于串口事件的响应一般有四种方式:查询、同步I/O、异步I/O和事件驱动I/O,需要根据用户不同控制要求而定。查询方式占用较长的计算机时间,同步I/O方式直到读取完指定的字节数或超时时才返回,容易造成线程阻塞,异步I/O用于后台处理,事件驱动是由系统通知用户程序发生的事件并进行串口操作。 比较而言事件驱动I/O方式较灵活。 </P><P> 当有通信事件产生时,就可用函数ReadFile()和WriteFile()直接对串口缓冲区进行读写操作了。其中lpBuffer 指向读写缓冲区,nNumberOfBytes为要读写的字节数,lpNumberOfBytes为实际读写的字节数,lpOverlapped指定同步或异步操作。通信结束后,调用函数CloseHandle()将串口关闭。 </P><P> ·应用实例说明· </P><P>
8 Z: F! n4 i# V 使用以上的API函数,笔者给出了简化后的串口初始化的实例。图1为使用C++ Builder 组件生成的串口通信基本参数设置的界面实例。 </P><P> HANDLE hcom; //定义句柄 </P><P> DCB dcb; </P><P> OVERLAPPED e; //定义重叠结构 </P><P> void -fastcall TForm1::OkBtnClick(TObject?Sender) </P><P> { hcom=CreateFile("COM2",GENERIC-READ|GENERIC-WRITE,0,NULL,OPEN-EXISTING,
5 y% e7 c2 [* h6 s% H. O1 W8 RFILE-ATTRIBUTE-NORMAL|FILE-FLAG-OVERLAPPED,NULL); //打开通讯口 </P><P> BuildCommDCB("9600,O,8,1",&dcb); </P><P>//第一个字符串参数实际使用时由图1选择后组合,这里仅简单说明其格式 </P><P> SetCommState(hcom,&dcb); </P><P> SetupComm(hcom,512,512);//设置读写缓冲区 </P><P> e.hEvent=CreateEvent(NULL,false,false,NULL); //设置事件 </P><P> SetCommMask(hcom,EV-RXCHAR| EV-TXEMPTY); //设置事件掩码 </P><P> OkBtn-〉Enabled=false;} </P><P>C++BUILDER非可视组件的消息处理技巧 </P><P> 一个非可视的组件必须对Windows操作系统或用户定义的消息作出响应。然而,由于一个非可视组件没有窗口,因此它也没有窗口句柄,自然它也不能接收到消息,为了解决这一问题,我们的思路是创建一个隐藏的窗口,使非可视组件能够接收到消息。 </P><P> 为了给你的非可视组件创建一个隐藏的窗口,需要有以下: </P><P> 1.一个私有变量型(Private Variable)的HWnd来取得窗口句柄。 </P><P> 2.一个用来捕捉窗口发送给组件的函数(a WndProc)。 </P><P> 3.对AllcolateHwnd的调用使之创建窗口句柄并设置WndProc。 </P><P> 为了清楚的解释上述思路和展示创建过程,下面我们将以一个具体的实例来说明。 </P><P> 首先我们先创建一个新的组件,在C++Builder中,选择FILE|NEW...双击组件图标显示一个新的组件对话框改变Ancestor Type为Tcomponent和Class name为TTest并设置完毕。 </P><P> 然后,切换到新组件的头文件,在类的私有部分(private section)加入以下声明: </P><P> HWnd FHandle; </P><P> void-fastcall WndProc </P><P>(TMessage& Msg); </P><P> 第一行声明了一个调用Fhandle的HWnd变量,这个变量将用于窗口创建后捕获窗口句柄。第二行声明了一个用于接收消息的WndProc函数。这个函数的声明必须加以标识,以便限定它是一个WndProc,然后在类声明Public(公有)部分构造以下声明: </P><P> Viod DoIt( ); </P><P> 这个公有函数将被我们用来测试组件,类声明应如下: </P><P> class PACKAGE TTest : public </P><P>TComponent </P><P> { </P><P> private: </P><P> HWnd FHandle; </P><P> void-fastcall WndProc </P><P>(TMessage& Msg); </P><P> protected: </P><P> public: </P><P> -fastcall TTest </P><P>(TComponent* Owner); </P><P> void DoIt( ); </P><P> -published: </P><P> }; </P><P> 现在切换到组件的代码单元,将下面一行加入到单元的顶部(在函数上也许是不错的地方) </P><P> #define MY-Message.WM_USER+1 </P><P> 这一行声明了一个在DoIt函数被调用时,组件将发送给它自己的用户自定义消息。此时我们必须为组件分配一个窗口句柄。这个句柄将提供一个隐藏的窗口使我们可以捕捉组件中的消息。找到组件构造代码,加入下面代码: </P><P> -fastcall Test::Test </P><P>(TComponent* Owner) </P><P>: TComponent(Owner) </P><P> { </P><P> FHandle=AllocateHWnd </P><P>(WndProc); </P><P> } </P><P> 好,重要的一步已完成,AllocateHWnd函数创建了一个隐藏窗口并且返回它的句柄,注意这里我们为了使Windows知道哪里发来了消息,传递WndProc的地址; </P><P> 现在我们来创建WndProc的函数部分。在源文件中加入: </P><P> void-fastcall TTest::WndProc </P><P>(TMessage& Msg) </P><P> { </P><P> if (Msg.Msg == MY_MESSAGE) </P><P> MessageBox(0, ″Got here!″, ″Message″, 0); </P><P> try { </P><P> Dispatch(&Msg); </P><P> } </P><P> catch (...) { </P><P> Application-〉HandleException(this); </P><P> } </P><P> } </P><P> 无论何时Windows发送消息给组件,Windows都会调用这个函数。这部分代码完成了两件事。首先,它检查被接收的消息是否是我们用户自定义的消息。如果是,一个消息框将被显示,你可以看到实际上我们接收到的消息。其次,这段代码传送了系统(或VCL)处理过程中的消息,try/catch块用来保证,如果异常出现,它将成为缺省风格下的句柄。 </P><P> 概括地说,WndProc函数在为缺省句柄传递所有其他消息,监控了所有客户消息。现在我们创建DoIt函数,完成我们的组件,加入我们创建DoIt函数,完成我们的组件,加入代码: </P><P> void TTest:oIt() </P><P> { </P><P> PostMessage(FHandle, </P><P>MY-MESSAGE, 0, 0); </P><P> } 这个函数发送一个消息组件的窗口句柄(记住,这个窗口句柄是以前存入到Fhandle数据成品中的)。现在我们已经完成了创建组件选择,用SelectFile|ColseAll来保存我们的工作测试组件。 </P><P> 下一步将测试组件。如果你使用BCB3,那么你必须把组件加入到“包”(Packege)中,然后用Componet|install(可以使用DCLSTD35 Packege来快速测试)。再选择你刚存的TestBCB.Cpp,一旦你安装完成组件后,它将出现在组件板上。双击按钮,为按钮的OnClick事件创建以下代码: </P><P> Test1-〉 DoIt( ); </P><P> 现在运行程序,当你点击按钮时,将看到一个消息框显示“Got here". </P><P> ListingA和B包含了头文件和源代码以下列出。 </P><P> 总结:一个可以响应Windows消息的非可视组件有许多用途。最显而易见的就是用来封装某些方面的WindowsAPI。例如:TAPI和WinSock发送消息给事件的指定用户。如果你写的组件封装了一个这样的API。你将需要捕捉Windows发送的消息。而在你的组件中加入隐藏窗口将很好的帮你做到这一点。 </P><P> 以上程序在C++ BUILDER 3.0中调试通过。 </P><P>用C++Builder 建立数据库VCL使用经验 </P><P> 随着数据库的广泛应用,数据库编程已经成为程序设计中发展迅猛的一支。C++ Builder在数据库开发方面具有的强大功能是无可比拟的,你甚至可以不写一行程序就生成漂亮的数据库程序。 </P><P> 下面对C++Builder中的几个数据库VCL的使用技巧做一下介绍: </P><P> 一、DBGrid控件 </P><P> 1.设置DBGrid的字段显示宽度属性 </P><P> 为了在DBGrid中建立较小的列,你必须建立一个显示标题,它等于或小于字段值。例如,你希望建立一个只有三个字符宽的列,你的列标题显示必须只有三个字符或更少。 </P><P> 2.改变DBGrid的显示字段及日期显示格式 </P><P> (1)双击DBGrid对应的Table1,进入字段编辑器。 </P><P> (2)点右键出现选单选“Add Fields…" ,出现添加字段对话框,选择要添加的字段(该字段将在运行时由DBGrid显示)然后点OK按钮。 </P><P> (3)假设添加了“日期”字段,点该字段,在属性表中的:DisplayLabel中填入你希望DBGrid显示的字段名。如果原来字段名是英文的,这里用中文名后DBGrid将显示中文名。在DisplayFormat中填入:yyyy-mm-dd,以后日期将按1999-05-28格式显示。 </P><P> 二、Tquery控件 </P><P> Tquery 控件是数据库编程中非常重要的一个控件,它负责通过BDE与数据库建立联系,通过SQL语句方便的建立查询。Query必须建立相应的SQL才能生效。 </P><P> Tquery的参数设置如下: </P><P> (1)在SQL属性中:Select * from 表名 where 字段名=:变量名 </P><P> 跟在“ : "后面的是变量。这样写后,在参数属性中就可以修改该变量的数据类型等。 </P><P> (2)对变量的赋值: </P><P> Query1-〉Active=false; </P><P> Query1-〉Params-〉Items[0]-〉AsString=Edit1-〉Text; </P><P> Query1-〉Active=true;//查找符合变量的记录 </P><P> (3)用DBGrid显示结果 </P><P> DBGrid的DataSource与DataSource1连接,而DataSource1的DataSet与Tquery1 连接。 </P><P> 三、应用示例 </P><P> 通过Query控件嵌入SQL语句建立的查询比Table更简单、更高效。 </P><P> 用一个简单的代码来说明如何建立查询程序: </P><P> 例如,要建立一个检索表1中书名为book1的程序则在表单上放置DBGrid,DataSource,Query三个控件加入以下代码: </P><P> DBGrid1-〉DataSource=DataSource1; </P><P> DataSource1-〉DataSet=Tqery1; </P><P> Query1-〉Close(); </P><P> Query1-〉SQL-〉Clear(); </P><P> Query1-〉SQL-〉Add(″Select * From 表 Where (书名=′book1′ ″); </P><P> Query1-〉ExecSQL(); </P><P> Query-〉Active=true; </P><P> 你就可以在生成的表格中看到所有名称为book1的记录。 </P><P>用C++ Builder创建基于Internet的点对点Chat </P><P>---- 创建基于Internet的应用程序,你也许会想到复杂的WinSock编程。不过,C++ Builder3提供了新的WebBroker的Internet套件,其中的TClientSocket和TServerSocket组件封装了Windows的有关API,大大简化了WinSock编程。要通过Internet传输数据,至少需要一对Socket,一个Socket在客户端,另一个Socket在服务器端。其实TClientSocket、TServerSocket组件并不是Socket对象,其属性Socket将返回各自的Socket对象。TClientSocket用来处理客户端到服务器端之间的socket连接,TServerSocket用来处理由客户端发来的socket连接,一旦客户端和服务器端都接通了socket,客户端和服务器端就可以相互通信了。 </P><P>---- 建立一新项目,创建应用程序的用户界面: </P><P>---- 1.将组件页切换到Internet页,放一个TServerSocket组件和一个TClientSocket组件到窗体上,这样应用程序既可以是TCP/IP服务器,也可以是TCP/IP客户。将Port属性都设为同一个值(如1000),确定Socket之间的连接类型为NonBlocking(非阻塞方式)。 </P><P>---- 2.放两个TMemo组件到窗体上,用来分别显示双方的谈话内容,将Memo2的ReadOnly属性设为True。 </P><P>---- 3.在窗体的顶部放上一个Panel组件,在其上放三个按钮:监听(btnlisten)、连接(btnconnect)、断开(btndisconnect),用来启动相应的操作。 </P><P>---- 4.在窗体底部放一个StatusBar组件,将其SimplePanel属性设为True,在相应的事件处理程序中改变状态条信息,让用户随时了解连接状态。 </P><P>---- 打开头文件,在窗体类的Private段添加两个私有成员: bool IsServer;String Server。双方通信时需同时运行Chat程序,IsServer用来确定哪个Chat程序处于服务器端,Server用来存放服务器的主机名。建立窗体类的构造器如下: </P><P>__fastcall TForm1::TForm1(TComponent* Owner) ( n" e1 a/ A M! B6 J0 W* y
: TForm(Owner) 6 Q! I& H0 m: v9 \) Z* G
{ ! \3 V4 V9 }0 w+ G0 j9 @
IsServer=false;
+ }3 r8 K) o9 ^4 ]: w# y6 yServer="localhost"; , ]) d! q l. i
} </P><P>2 Y8 G. n t) ^4 J8 E G, i" U
---- 这里Server被缺省设为localhost,这样程序可以在没有连入Internet的单机上进行调试。在Windows子目录下你可以找到hosts.sam文件中,在该文件中已经将本机IP地址127.0.0.1定义了主机名:localhost。
3 c a; N! ?, u* Y% D- \void __fastcall TForm1::FormCreate(TObject *Sender) ; D" T% X- P4 y, Y$ k J
{ . `* t# Y0 i# x8 K+ X$ r
btndisconnect- >Enabled=false;
: ?% e0 y" M9 c2 Q; u: }} </P><P>---- 程序运行后,如果用户按下"监听"钮,则将该程序设为服务器端,这时应将TServerSocket的Active属性设为True,使服务器自动进入监听状态。 9 t, v# w, S' {- Z& u7 j: ^
void __fastcall TForm1::btnlistenClick(TObject *Sender) 9 a/ S9 x2 s. r
{ 5 b* z: t3 f& X. U* C# Q& p* v
ClientSocket1- >Active=false; ( P" s6 J5 O) ?, T' s# |
ServerSocket1- >Active=true;
! q# x1 d5 z5 ]9 DStatusBar1- >SimpleText="正在监听...";
I- g7 x- Z+ y, g3 U j8 J2 e( Q. fbtnlisten- >Enabled=false;
9 V$ N" `' O& l3 U% O4 Hbtnconnect- >Enabled=false; ; Z1 @1 M5 e' c
} </P><P>---- 当用户按下"连接"钮后,程序会弹出一个询问框,要求用户输入要连接的服务器的主机名,然后建立连接。 9 M2 A% Y" [) s) X1 V$ B& X
void __fastcall TForm1::btnconnectClick(TObject *Sender) ) U3 J7 d# P( V6 m/ f; c
{ $ c) j! g, t. U2 ^
if(InputQuery("连接到服务器","输入服务器地址:",Server)){ 0 G: [. f9 D$ e; D9 c. W1 a
if(Server.Length() >0){
. f( f9 J- S3 B- wClientSocket1- >Host=Server; 8 P1 {4 a& ?' a1 ]" G. }1 Y- x
ClientSocket1- >Active=true; 0 H' F$ x$ ?; c* ^; V
btnlisten- >Enabled=false;
. R, F& b9 t1 n+ ~; B. wbtnconnect- >Enabled=false;
" {2 ?$ B9 ]5 r: D0 qbtndisconnect- >Enabled=true;
) j- ]( }& k3 T/ k}
9 C+ ?* X3 p% U9 b0 `% J; F7 w. E. s} 6 O( a1 Q: j, \; L! a
} </P><P>5 @$ `3 A+ n. b3 ~
---- 当用户提出连接请求后,客户端会触发OnCreate事件,程序先在状态条中显示连接信息,然后将显示对方谈话内容的Memo2清空,准备开始交谈。
5 N/ d* e/ f: `1 t% I7 _* lvoid __fastcall TForm1::ClientSocket1Connect(TObject *Sender, ( W" C& j* |/ p! Q& I$ S' k
TCustomWinSocket *Socket) 1 E; F" J/ ~9 V$ @8 N ?
{
5 i/ f; G# g% pStatusBar1- >SimpleText="连接到:"+Server;
; H# A6 K; E" z7 S. `) [Memo2- >Lines- >Clear();
0 C; b# [# F7 l; i% `- c L} </P><P>
# S6 C4 A2 t9 V) J# {---- 在服务器接受了客户的请求后会触发OnAccept事件,在这个事件处理程序中将标志服务器端的变量IsServer设为True,并准备开始交谈。
. v6 O1 z# M5 v, Evoid __fastcall TForm1::ServerSocket1Accept( 4 f, m2 @/ O; N$ @/ y: S
TObject *Sender,
) N, K7 ]$ x5 Q) ^ DTCustomWinSocket *Socket) $ z* e0 }, z, _/ A2 q# w
{
, i& w: N7 `3 O1 s' n/ o i& YMemo2- >Lines- >Clear(); . L4 c7 z9 P N6 l# d2 `5 q+ d
IsServer=true;
6 L6 s4 |- ~2 ^: TStatusBar1- >SimpleText="连接到:" 1 o7 p2 I9 p; r* ] c' X
+Socket- >RemoteAddress;
: M+ g8 b# t" G: E) g1 ?* I} </P><P>
# f. }* Y! }: L---- 在建立连接后,双方就可以在Memo1中输入谈话内容开始进行交谈了,按下Enter键后,将所在行的文本发送出去。服务器端的Socket的Connections属性返回一个数组,该数组由服务器当前活动的连接组成。 0 d5 X& G" g0 P9 e1 ? e
void __fastcall TForm1::Memo1KeyDown(
: G1 f# b$ k3 b' I- j: oTObject *Sender, WORD &Key, * P, H0 o, j3 p1 v; Z7 e
TShiftState Shift)
+ A4 o5 A+ { Y3 {% J( S{ : f1 }# T% H) Z2 S/ N
if(Key==VK_RETURN){ 2 `3 f. e1 r1 T0 ]2 @& w
if(IsServer) ( ~8 U# |! n; D* @/ R! R7 u* u
ServerSocket1- >Socket- >Connections[0]- >SendText( 4 L v" U6 i0 p: _9 u# [! c6 |2 Q
Memo1- >Lines- >Strings[Memo1- >Lines- >Count-1]);
8 r' w0 \' C0 i3 y& I1 p! S5 Telse
: E% O- B9 Z; t" YClientSocket1- >Socket- >SendText( * [& V; C; V% ]% e4 |! w
Memo1- >Lines- >Strings[Memo1- >Lines- >Count-1]); & Y i! @) R2 K! {
} & j- m- i( m( {
} </P><P> ) R- S( m$ j A
---- 在本例中我们采用非阻塞传输方式,当其中的一方进行写操作时,另一方会触发OnRead事件(客户端)或OnClientRead事件(服务器端),这两个事件的处理程序只是将接收到的内容添加到Memo2的后面。 ( I8 N4 Q) z$ i3 I
Memo2- >Lines- >Add(Socket- >ReceiveText()); </P><P>---- 如果在用户建立连接后单击"断开"钮,将断开客户端与服务器的连接,服务器端将触发OnClientDisconnect事件,而客户端则会触发OnDisconnect事件,这时服务器端应回到监听状态,等待用户的连接;而客户端将返回到连接前的状态,等待用户再次建立连接,如果有不止一个服务器的话,可以选择连接到其他的服务器上。
4 D1 {! S" P1 ?" c) [% Y2 M3 Lvoid __fastcall TForm1::btndisconnectClick(
! c+ w& t5 p& ^+ _; J9 BTObject *Sender) ; |: ^' n: b0 N S! O! J! V
{
f$ P0 Z: c2 [# S3 LClientSocket1- >Close(); ! |! Z' w4 b- W# P0 m
} & F/ O7 m- w4 V3 ]! U& V+ Z
void __fastcall TForm1::ServerSocket1ClientDisconnect( $ A/ [0 m S% |. Z% C
TObject *Sender, 7 ~! q9 i! u x$ ~/ o* r2 X5 y
TCustomWinSocket *Socket) % L5 d. e0 s+ N+ E/ ^4 E1 }# m% f: R
{ 6 ~5 b$ \: N+ T3 U: r& e4 U
StatusBar1- >SimpleText="正在监听...";
! D" K2 v* h% ?. E; }7 w7 i} . J ] \( |/ B
void __fastcall TForm1::ClientSocket1Disconnect(
7 h* q. _# a# E9 O0 ]1 L2 v9 WTObject *Sender, TCustomWinSocket *Socket) & |$ h1 X, R+ J" x3 |& u) P7 v Z
{
! q( ]& X) U2 R- ? z0 Xbtnlisten- >Enabled=true;
% R6 f$ B* W: mbtnconnect- >Enabled=true; 0 U8 b- e& l( X4 i2 J/ J e1 k5 j' \
btndisconnect- >Enabled=false;
, q) h5 ]" ]7 o6 f( F W( h4 MStatusBar1- >SimpleText=""; $ Z. O( Q- j3 {8 `9 p
} </P><P>. b8 F B/ ~0 q, e2 [" l- B9 f8 m' J
---- 此外在客户端还应该增加错误捕获机制,当用户输入无效的服务器名或服务器端没有处于监听状态时能够及时给用户反馈信息。 # R1 O$ \* }. Z) E. C
void __fastcall TForm1::ClientSocke
3 H1 F7 p* e, s8 ?/ `t1Error(TObject *Sender,
* c) @9 y0 a8 ATCustomWinSocket *Socket,
( ~9 o/ E+ H, q( s% jTErrorEvent ErrorEvent, int &ErrorCode)
) e7 A+ b7 u% w. q/ R{
8 v; O; Z6 B( L& w; |& ^* R$ oStatusBar1- >SimpleText="无法连接到:
: j# ?9 r( B2 V; I6 t# ]"+Socket- >RemoteHost; . M: i+ M$ X* K# Z4 f* r
ErrorCode=0;
1 |7 D& C: k" ?+ y2 F* H0 `1 H$ M1 P} </P><P>用C++Builder获取应用程序图标 </P><P>现在,网上有大量的有关图标的共享软件或免费软件,而且很多也很好用,也方便。但是那毕竟是别人的,用起来总有些哪个,况且自己又喜欢编程,何不自己动手呢!说干就干,而且手头上有可视化编成的利器――C++Builder4.0,想来应该是很简单的一件事。 </P><P>首先启动C++Builder,新建一工程,在窗体上放置一个Button控件,一个Image控件,和一个OpenDialog控件,它们的名称均不必改动。双击Button控件,写如下代码: if(OpenDialog1->Execute()) </P><P>{ </P><P>FileName = OpenDialog1->FileName; </P><P>HICON hIcon; </P><P>// Total =(int) ExtractIcon( Form1->Handle, FileName.c_str(), -1); </P><P> </P><P>Icon = new TIcon(); </P><P>hIcon = ExtractIcon( Form1->Handle, FileName.c_str(), 0); </P><P>Icon->Handle=hIcon; </P><P> </P><P>Icon->SaveToFile(TempFile); </P><P>Image1->Picture->LoadFromFile(TempFile); </P><P>} </P><P>其中:FileName,TempFile,Icon在其头文件中定义:AnsiString TempFile, FileName ; Ticon *Icon; </P><P>这样,你所选定的程序的第一个图标就在Image控件中显示了出来。本程序所用的是Windows API ExtractIcon来获取图表的,因此它只能获取可执行文件的图标,如果想获取任意文件的图标,那末你可以调用Windows API 的SHGetFileInfo函数来完成,SHGetFileInfo所能完成的任务有很多,具体用法可参见Win32的帮助文件。 </P><P>, T7 ]+ `8 I, s# ?
BIG5到GB的转换技术 </P><P>中文因为数量太多,所以与英文用ASCII码一个字节表示不同,它使用两个字节来表示。通过计算这两个字节,我们可以得到其表示的汉字在中文字库中的位置。读取该位置的若干字节,以获得表示这个汉字的点阵信息。有了这些信息,就可以分别在DOS或WINDOWS中显示该汉字。事实上,在文本文件中保存的就是每个汉字对应的两个字节编码,而显示问题由中文操作系统自动解决。
h: B0 R/ Z, Q- T汉字编码并不统一,我们使用的是GB码,而台湾地区使用的是BIG5码。BIG5码文件中保存的是汉字相应的BIG5编码,GB码文件中保存的是汉字相应的GB编码(这也就是“乱码现象”的来由)。所以转换工作的关键是有一个记录每个BIG5编码对应GB编码的码表文件。
& P7 x' W/ p+ d/ N- T. a4 S第一步 制作码表文件 6 b2 [7 F5 `0 Q; E( ^$ b, B
BIG5码编码规则是这样的:每个汉字由两个字节构成,第一个字节的范围从0X81-0XFE,共126种。第二个字节的范围分别为0X40-0X7E,0XA1-0XFE,共157种。也就是说,利用这两个字节共可定义出 126 * 157=19782种汉字。这些汉字的一部分是我们常用到的,如一、丁,这些字我们称为常用字,其BIG5码的范围为0XA440-0XC671,共5401个。较不常用的字,如滥、调,我们称为次常用字,范围为 0XC940-0XF9FE,共7652个,剩下的便是一些特殊字符。
8 N. h, `) z. a制作码表文件的原理是这样的:首先将所有的BIG5编码写入一个文件,然后,使用具有BIG5码到GB码转换功能的软件,如地球村、东方快车、四通利方,将文件转换为GB码文件,即得到码表文件。
7 k. ~, o4 C$ N$ u下面的源程序将所有可能的BIG5编码(0XA100-0XFEFF)写入文件“Table.TXT”。
" b' u1 }8 W( l' ]//TURBO C++ 3.0
8 ?! w1 u" s1 X#include <Stdio.h>
: N" w1 i5 H. _ `#include <stdlib.h>
) O! g0 r6 r4 E! w% J0 `void main(){
9 `+ ]. D- R1 g. O4 X0 b; Q" ^FILE * codefile; , F9 `$ E/ F9 _4 Y, X) l; v
int i,j,k;
4 t1 h! s t. l N7 C1 n6 Fcodefile=fopen("table.txt","w+b"); - [- J" p- G% j% [6 e9 W0 y' R
for (i=0xa1;i<=0xfe;I++){
( S \% {9 h; q9 Wfor(j=0x00;j<=0xff;j++){ 2 c6 v5 V% \: H" r: _
fwrite(& i,1,1,codefile);
/ X5 J: I8 _+ e8 @$ q0 lfwrite(& j,1,1,codefile);} # u, Y! \0 D; a# Y$ D0 I
}
! B, ~& v1 n4 Q3 U& Pfclose(codefile);
3 @. c. D$ u u$ z3 m; A: rreturn; 4 X9 m0 O+ v% s' t1 Y5 \8 y
} 1 a' ~' i7 @' Q: a
运行地球村、东方快车或四通利方,将“Table.txt”从BIG5码转换为GB码,即获得码表文件。 / u# n7 E0 x: @' k
第二步 转换
: i- U% Q; I& P% p- L下面的源程序,将BIG5码文件转换为GB码文件。
5 D. ?' @0 F; x8 {//TURBO C++3.0 + R1 A2 Y% F& [
#include <stdio.h> ) ^0 o+ ]) V5 _9 Y7 ~7 F( ^
#include <stdlib.h>
+ ^/ p4 L9 z1 G4 a6 M0 Ovoid main(){ 9 }' J1 p! u2 k* b
int que, wei;
7 X" L$ H& W$ d& c$ zFILE * sourcefile; 0 t& b- O3 E- f5 Z; Q7 S$ H0 L% b2 F
FILE * tabfile;
) _4 r! M, {; rFILE * destfile; : L4 _, [ f( h4 S6 ~8 O6 O ?
sourcefile = fopen("big.txt', "r+b"); # Z; {" R, w7 {# m( ^
//BIG5 码文件 3 A" C* B& s) j' I
tabfile = fopen("table.txt", 'r+b");
& e# ~- |& \, m' p# z5 Z+ s//码表文件 + O9 a- q$ i( l# x6 s6 U# ^
destfile = fopen("gb.txt","w+b");
' m1 X0 g3 w; J( {" C0 ^- i//转换生成的GB码文件 8 E: W5 P! B" y) K7 D, r7 U
while (!feof(sourcefile)){ ) u; P4 ]% ~8 g- B* o: {
fread(& que,1,1,sourcefile);
7 b7 R0 C* P. M$ _% J3 @if (feof(sourcefile)){
W$ d {9 ]$ A8 w+ u: U2 h2 Nbreak; } : w8 l7 f8 l+ s$ f+ r. |
if (que> =0xa1 && que <=0xfe) % m0 M9 i+ l* g( a* @6 }
//叛断是否汉字(BIG5编码)
3 w- |) {/ X1 ]% g% B) v4 O( k. K{fread(& wei,1,1,sourcefile); " b. \ b- E4 q7 |( `7 _& Y
if (wei<0xa1) wei = wei - 0x40; 3 ~& h/ t! {/ ^& u, s% ^
if (wei>=0xa1) wei = wei - 0xa1 + 0x7e - 0x40 + 1;
: X( o" v( l" e4 }fseek(tabfile, 2 * ((que -0xa1) * (0xfe - 0xa1 + 1 + 0x7e - 0x40 + 1 ) + wei), SEEK_SET); . W X" s( v1 r5 F8 y2 m" c1 A
fread(& que,1,1,tabfile);
* N: R, u- F; |/ kfread(& wei,1,1,tabfile);
$ t: R" I) l g5 F! B* b! y Pfwrite(& que,1,1,destfile);
& ` h+ Q% L S9 mfwrite(& wei,1,1,destfile);
' v0 J% u) F- ^}
0 F1 W1 a- r/ S6 J/ Q7 |/ K9 U xelse
1 p1 q& z! s% d/ A* Sfwrite(& que,1,1,destfile); //处理英文
+ P$ h2 T% f0 f$ z" s" E9 t0 ^} : p' k3 M# n0 X j: Q9 J: Z
fclose(sourcefile); & e9 i4 b. y- l( W' \) F7 l* H
fclose(tabfile); 6 q1 [3 U3 x) _# v! a# a+ ?
fclose(destfile);
) d% |8 }8 a4 j! o) oreturn; , L5 E5 ^" u8 x3 a/ s6 _5 Y1 ]
} 6 T! M" L% u; v5 J" b: J6 T
以上程序在Win95/97,TC3.0 通过。稍加修改,也可用于VC或VB程序中。用同样的方法,我们也可以将GB码转换为BIG5码。 </P><P>C++BUILDER让你的任务栏图标动起来 </P><P>---- 在windows环境下上网时,你有没有注意到在屏幕的右下脚的任务栏上有一个动画图标呢?它一闪一闪的,形象的表示出网络此时正在传输数据。关于任务栏图标编程的文章有不少,可是如何才能编制出动态图标呢?在C++Builder中可以比较方便的实现。 </P><P>---- 其基本编程思路是:通过设置Timer时钟控件使应用程序在规定的时间间隔内发送特定的消息,使任务栏图标不断更改,从而形成动画效果。实现方法为在应用程序的表单中加载几个Image控件,使他们装载相应的图画,几幅图画按顺序连续的被显示,就形成了动画。 </P><P>---- 在这里,我们用一个门的开关动画来做例子,在表单上放置一个Timer控件,两个Image,分别装载“开门”和“关门”两幅图。开始加入代码。 </P><P>---- 应用程序必须用发送消息的办法通知任务栏增加,删除,和修改图标。发送消息必须调用Shell_NotifyIcon。它的原形为: </P><P>WINSHELLAPI BOLL WINAPI Shell_NotifyIcon(
/ Y ?3 I2 A. ^+ Q% L6 MDWORD dwMessage, POINTIFYCONDATA pnid); </P><P>第一个参数 dwMessage是发送消息的标志,可以选
- s5 s3 f7 ^' N% F( l0 ~7 tNIM_ADD // 往任务栏通知区添加图标 3 L: q" D# z8 n8 [* S% c0 W- x
NIM_DELETE //往任务栏通知区删除图标
: |5 I5 B: ~! s+ ^) [NIM_MODIFY //通知任务栏通知区修改图标 </P><P>编制消息发送函数TrayMessage : n1 ]8 e5 F7 g5 l) h
bool __fastcall TForm1::TrayMessage(DWORD dwMessage) . R& M' b0 ?/ j- o/ r
{ - Z- H! f& d$ y6 x! Q! {/ X: e
NOTIFYICONDATA tnd;
4 ^- ]9 e" e" U4 i: |3 XPSTR pszTip;
+ Q1 v" F. x# P4 r0 F: bpszTip = TipText();
/ z; X! _8 p X2 ~+ Etnd.cbSize= sizeof(NOTIFYICONDATA); 1 h' ]/ _6 w8 T& u
//结构的大小 ; J1 u0 w' m' A0 C' P3 V
tnd.uCallbackMessage = MYWM_NOTIFY; ) c# l& M2 Q7 r( g6 e& _) c
//自定义回调消息,在头文件中声明
) E2 n/ h6 n9 o/ Qtnd.hWnd= Handle; ! O( D4 ^# Y' b; U
//接受回调消息的窗口句柄 $ X" _* s. Y' i- q3 H/ M
tnd.uID = IDC_MYICON; ' V2 v; ?. e0 e, [- ]
//图标标志号 8 `0 S8 r7 n- A* G, A
tnd.uFlags= NIF_MESSAGE | NIF_ICON | NIF_TIP; ' k T+ w! Q" U3 ?3 h; U
//指定以下三个参数哪个包含有效数据
3 W" v7 k1 k, n2 n% z% g" z6 L- i& |0 rif (dwMessage == NIM_MODIFY)
. M L9 A! n( f6 p# I0 ]{
/ @1 I- t: g* `& ]4 Htnd.hIcon = + ?0 Q: W4 G$ h
(HICON)IconHandle(); //取得图标句柄 5 k5 w0 {6 H7 ^, i9 H1 h6 k
if (pszTip) % k* k S7 ]5 t
lstrcpyn(tnd.szTip, pszTip, 8 w7 B* e( B8 |4 X; A# h
sizeof(tnd.szTip)); ; J8 J! s# ?5 b4 k9 S
else
3 M, B& S9 P2 d" A% Qtnd.szTip[0] = '\0';
! P( K3 V: I4 v0 Y% i' [4 ^} ' J" @3 P: ]* _
else M9 j d3 n9 p' i8 p- f" |+ ~7 {
{
/ V3 T2 t5 c) X3 }tnd.hIcon = NULL;
/ R" H8 H _9 ?+ q) mtnd.szTip[0] = '\0';
+ c# m! ]/ k7 r+ b9 P}
; M5 J1 v8 f' Z* {% l" x" }- P- Ireturn (Shell_NotifyIcon(dwMessage, &tnd)); . b5 V6 ^- d# J$ g# j7 O
} / _0 J9 F- o' D# F. i6 j
编制取得图标句柄的函数
2 A* M! U3 q1 ]/ a9 E2 G& }HICON __fastcall TForm1::IconHandle(void)
8 Y' s# A' m$ G' b, d{ 9 A4 T7 Z$ H( j, m* l
if (n==1) : O% T) K9 x1 w$ S1 `2 F$ y( S- T3 _
{ return (Image1- >Picture->Icon- >Handle); / y# n0 {6 G# \" O8 a8 O, T. T! _
//n是全局变量,1为显示Image1,0为Image2 . c g: N5 b: o1 F& p% N. D6 o
} 0 Q$ ^6 l7 M( H) Q/ |
else 7 H- K6 ^6 P) X' o2 H9 _
{ return (Image2- >Picture- >Icon- >Handle);
) c U0 P" m. B: {1 E}
/ \/ Y: j8 }& I% e$ ?; r}
! r& x5 U. u+ w* k编制图标状态转换函数 </P><P>void __fastcall TForm1::ToggleState(void) 1 r& {6 H$ V" y4 c% U' J% Q
{ , x: V5 s5 o `# T0 v+ e9 ~% O
if (n==1) //n为图标句柄锁,是全局变量,
3 ]" g, x9 W5 u) m5 I1为显示Image1,0为Image2 \; M, u9 t' H S
{ % D$ J- B# `4 }4 N5 ~" l
n=n-1;
6 H: F; H4 o: g2 R# z}
1 y* ~6 \. I, X+ |6 Q; kelse
* M; E4 J1 A' S7 a$ z) Z7 m{ + e2 b. M' |) R. i! q; I+ k
n=n+1;
a' S4 k% k5 s3 n} % U+ N( u }0 c
TrayMessage(NIM_MODIFY);
r4 z! T1 r* U! J5 n//发送图标变换消息
9 R2 D. M5 J0 P o) b1 H7 c5 @} </P><P>
) i* r- c" k x5 \+ l- w( c对Timer控件编制代码,设它的Interval
/ q- P0 U& E* N( z- T( q5 x0 F属性为1000,即定时器每一秒响应一次。为 Ontimer
4 n. z+ c5 A* _% W0 t. ]* p% d- E事件键入代码: </P><P>void __fastcall TForm1::Timer1Timer(TObject *Sender) * B H0 C" |4 `5 q
{ ToggleState( ); $ ^+ r' |$ D/ l/ c" {% c+ X6 k% i3 E
} </P><P>---- 由于篇幅有限,以上只列出了基本部分的代码,其他功能的实现,如关闭程序,打开窗口等,比较简单,不在赘述。程序运行时,你将看到在屏幕的右下角任务栏有一扇门打开又关闭的动画图标。是不是很有趣,快编一个你喜欢的吧。 </P><P>TFORM </P><P>) X4 b5 E- C3 S% a% i3 _
一、让窗口总是在最前面
6 e) H# U) g2 k ]( ]7 oForm 的FormStyle属性设置为fsStayOnTop值。 </P><P>二、 动 态 调 用 窗 体Form ( W& j$ A; ~8 O5 [( U# R
在 缺 省 情 况 下, 由File/New Form 生 成 添 加 入 项 目 文 件 中 的 窗 体 都 具 有"Auto Create"( 自动 创 建) 的 特 性。 即 只 要 程 序 运 行, 该 窗 体 就 存 在 于 内 存中 了, 不 管 当 前 它 是 否 被 调 用。 具 有 这 种 特 性 的 窗 体 一 般适 用 于 窗 体 属 性 比 较 固 定、 经 常 被 调 用 的 情 况。 其 优点 是 速 度 快, 缺 点 是 占 用 内 存。 在 实 际 程 序 设 计 中, 会 遇见 大 量 类 似 对 话 框 功 能 的 窗 体, 它 们 用 于 显 示 状 态 或 输入 信 息, 仅 须 在 程 序 中 调 用 一 下, 完 成 其 功 能 就 行 了, 无需 常 驻 内 存。 这 时 可 以 通 过 选 择Project/Options/Forms, 将"Auto--Create forms " 栏 中 相 应 的 窗 体, 如Form1, 用" >" 键 移 动 到 "Available forms" 栏 中, 并 在 程 序 需 调 用 该 窗 体 处, 加 入 下 列 语 句: </P><P>TForm1 *myform=new TForm1(this); </P><P>myform- >ShowModal(); </P><P>delete myform; </P><P>窗 体Form1 仅 是 在 需要 调 用 时 才 调 入 内 存,调 用 完 成 后, 即 用delete 清 除 出 内 存。这 样 可 减 少 程 序 对 内 存 资 源 的 占 用。 </P><P>三、遍 历 窗 体 控 件 的 方 法
6 y X. ]- h0 |2 b5 j要 访 问 或 修 改 窗 体 上的 控 件, 方 法 很 简 单, 以TEdit 为 例 子: </P><P>Edit1- >Text=""; </P><P>Edit2- >Text=""; </P><P>但 如 果 窗 体 上 有 十 来个 像Edit1 这 样 的 控 件, 需 要 进 行 相 同 的 初 始 化, 用 上 面 的方 法 一 个 一 个 地 进 行, 岂 不 麻 烦 ! 所 以 有 必 要 掌 握 遍 历窗 体 控 件 的 方 法。 在 介 绍 该 方 法 之 前, 让 我 们 先了 解 一 下 窗 体Form 的Components 和Controls 属 性。 参 见 表 一。
' G* k, W" v' R' _% t$ `表 一 </P><P>属性 类型 说明 </P><P>ComponentCount Int 目前Form上各类 ' H# _- n$ L) m& r( D
控件的总数 </P><P>Components TCompont* 目前Form上指向
6 D/ r& v8 e1 I) f. c所有控件的数组 </P><P>目前Form上指向 $ w, c. H- W) Z3 |0 S0 u
所有控件的数组
) Z4 Z H) P5 I. ?! pControlCount
' \$ f( r' e( ?; l8 WInt 8 {. ]8 X. t* e7 a; [' ^/ Z$ N
目前Form上某一子
- k- {. F8 V% X区域上各类控件的总数 / Q, u' A9 {& j1 h( p
Controls TControl* </P><P>目前Form上指向某一子
8 M5 ?- y, C; J区域上所有控件的数组 </P><P>
( z! }2 z& K2 M- p' k以 图 一 为 例(图 略) 说 明,Form1 的ComponentCount=6, 而Panel1 的ControlCount=4., </P><P>其 中: 数 组 对象 </P><P>Components[0] Panel1 </P><P>Components[1] Label1 </P><P>Components[2] Edit1 </P><P>Components[3] Label2 </P><P>Components[4] Edit2 </P><P>Components[5] Button1 </P><P>
! D# ]- q g3 s; s0 o* A o7 _数 组 对 象 </P><P>Controls[0] Label1 </P><P>Controls[1] Edit1 </P><P>Controls[2] Label2 </P><P>Controls[3] Edit2 </P><P>
3 h, C c. t! t下 面 这 段 代 码 完 成 了 对Panel1 上 所 有TEdit 控 件 的 遍 历 初 始 化。 读 者 稍 加 修 改, 即 可 对 其它 控 件 进 行 遍 历。 这 里 有 一 个 小 技 巧, 我 们 把 需 要 进 行 初始 化 的 控 件 放 置 在 了 一Panel1 上, 与 不 需 要 初 始 化 的 控 件区 分 开 来, 这 样 便 于 编 程。
+ B: q7 ?; f( j2 K5 z( q6 t: LAnsiString namestring="TEdit";
/ O. w* m* r$ nfor(int i=1;i< Panel1- > ControlCount;i++) * Q2 C, V7 Z/ L+ E
{ $ n* R% k! H% \' s* S
if(Panel1- > Controls- > ClassNameIs(namestring)) </P><P>{ </P><P>TEdit *p=dynamic_cast < TEdit* > (Panel1- >Controls); </P><P>P- >Text=""; </P><P>}
& {) s4 \" \; t$ j/ [4 X! @} </P><P>四、不规则窗口 </P><P>1.在窗口定义中,加入HRGN hWndRgn; 8 R4 V) D, h& p# ?+ s) {6 t
2.在TForm::OnCreate()消息函数最后,加入下面的代码:
) y) J- u! K0 l9 x- [3 ^: khWndRgn=::CreateEllipticRgn(0,0,Width,Height);
$ Q' p) M: e. o7 [::SetWindowRgn(hWndRgn,TRUE); - v# x$ p! P$ k( X5 ?2 h5 v. Y/ F
3.设置TForm的属性为无标题,无边框。
0 y8 D" U# _" l% U+ t: Y V1 |( u6 j4.编译连接应用程序,就可以看到一个椭圆形窗口。 </P><P>五、MDI Form </P><P>1.Application->CreateForm(__classid(Tjjcginput), &jjcginput); </P><P>后不用在使用显示Form的语句就可以显示出来了。 </P><P>2.form 的onclose 事件必须用下面语句释放空间:
! ?( P) ~: y3 @9 R( rvoid __fastcall TMDIChild::FormClose(TObject *Sender, TCloseAction &Action)
0 v7 o* n6 n$ `+ ]{
0 g4 M" n0 ?" C$ q; @Action = caFree; ! f; s; V9 W! v
} </P><P>用BCB在windows桌面创建快捷方式 </P><P>API提供了一个叫做IShellLink的COM接口允许我们创建快捷方式。为在桌面创建快捷方式,我们创建一个IShellLink对象,设置它的属性,然后把这个link保存到desktop目录。 </P><P>下面的例子代码演示了怎样创建一个快捷方式。在这个例子里,这个快捷方式保存在C:\Drive目录下。 </P><P>//---------------------------------------------------------------------- : {& c* r9 s1 u
include <shlobj.h> </P><P>void __fastcall TForm1::Button1Click(TObject *Sender)
' I* D+ Z1 R% U6 b8 T{
8 ?: M8 W: \, b1 `$ t( Gif(OpenDialog1->Execute())
' K8 d: }& T6 C" M6 S# fCreateShortCut(OpenDialog1->FileName);
6 R2 a# R! E V% f* t* ]( z, Z* ?} 6 q5 V: J6 V$ `0 a) y5 O) O
//---------------------------------------------------------------------- 8 z7 S/ b; \% I+ j# g* Z# O
void TForm1::CreateShortCut(const AnsiString &file)
; P; C" Q4 S) ~. p# `{ 0 ?; P: p. d+ l/ g
IShellLink* pLink;
- ] q/ H! F3 J% TIPersistFile* pPersistFile; : v) U- }- r" _; {0 U
if(SUCCEEDED(CoInitialize(NULL)))
6 Q# Y. F& H* y5 G: E( @& W{ " j1 H+ y3 v6 H$ \! S. z
if(SUCCEEDED(CoCreateInstance(CLSID_ShellLink, NULL,
. I7 p- [1 g6 T3 N4 ], S7 v$ g- L* `* W [CLSCTX_INPROC_SERVER, 0 b/ O- M4 w# |- h- p; j' H0 a
IID_IShellLink, (void **) &pLink))) + @' k5 X! J5 e9 O: P
{ $ U5 b( n- T% H" T
pLink->SetPath(file.c_str()); . p E x, ~& B, K7 Q3 R. T
pLink->SetDescription("Woo hoo, look at Homer's shortcut"); , }! B% v: }6 ~% y
pLink->SetShowCmd(SW_SHOW);
- O8 D0 b2 l7 M: a6 p9 Lif(SUCCEEDED(pLink->QueryInterface(IID_IPersistFile, 2 f8 K' j3 c9 J. s# N' Z$ ~: W
(void **)&pPersistFile)))
, v/ B" [8 r6 I) T3 J{ 4 Y$ r- \9 {0 R- L- v! \1 z: o
WideString strShortCutLocation("C:\\bcbshortcut.lnk");
2 }( K( M# T" c, N: jpPersistFile->Save(strShortCutLocation.c_bstr(), TRUE);
: K$ O* R! E* f U' n8 Y- HpPersistFile->Release();
$ s8 Y+ L9 j. e- W} . N; s1 i5 |# ~: x
pLink->Release(); 2 }! W5 U1 j" S3 h. @- W+ ^
} </P><P>CoUninitialize();
6 D, H+ v8 E0 |: B3 [, A4 Q" V}
3 k. ]6 ?# a& A( W}
6 ~1 B: w. C9 F: {6 L1 `) d5 W//----------------------------------------------------------------------
, \+ x/ R5 F4 j: [$ z! N& ~5 H2 l上面的例子只是把快捷方式文件保存到了c:\drive目录下,但没保存到desktop目录下。 </P><P>要让快捷方式出现在桌面上,只须把快捷方式文件保存到desktop目录下。首先我们要找到windows的desktop目录,请参阅判断windows的Desktop及相关目录这一节。一旦我们知道了desktop所在的目录,我们就能将快捷方式文件保存到desktop目录下。然后windows就能将快捷方式图标显示到桌面上。下面是经过改进了的例子: </P><P>//---------------------------------------------------------------------- 1 g7 y& b$ _ Q2 D+ y
void TForm1::CreateShortCut(const AnsiString &file)
0 _* X# r4 y* c. v{
* V: p$ ?; [6 Z: B6 f, H& Q+ ZIShellLink* pLink; - t. x# O9 N- W' o
IPersistFile* pPersistFile;
3 K2 j8 k( ~9 x0 P1 QLPMALLOC ShellMalloc; f; V1 R: C! C( B0 |' [: Q3 T4 _
LPITEMIDLIST DesktopPidl;
& ]8 @" k# W3 b2 m5 Lchar DesktopDir[MAX_PATH]; </P><P>if(FAILED(SHGetMalloc(&ShellMalloc)))
. s7 {3 n7 l G4 L4 m" I ^return; </P><P>if(FAILED(SHGetSpecialFolderLocation(NULL, ( S: b. e9 }% `+ Y
CSIDL_DESKTOPDIRECTORY, : ~; k, [6 G# x( ]4 Z, @! P
&DesktopPidl)))
; T0 _1 w6 n2 g% u' v; s0 Mreturn; </P><P>if(!SHGetPathFromIDList(DesktopPidl, DesktopDir)) U r1 N- [* |# {8 u# J$ z& W
{
. A7 P z8 U: P- Q1 A8 ZShellMalloc->Free(DesktopPidl); ) ]0 h" N ?" {0 I3 {
ShellMalloc->Release();
' D B% l+ M8 q9 p: \2 a& y4 vreturn;
+ X' A# S; W' V5 E2 B4 _, s} </P><P>ShellMalloc->Free(DesktopPidl); 1 o" c2 L0 h; I4 ]! J; D. G: l
ShellMalloc->Release(); </P><P>if(SUCCEEDED(CoInitialize(NULL))) : n* \1 Z @0 d) W" ]3 i" E
{
" w1 S+ j" n1 m6 e7 {- qif(SUCCEEDED(CoCreateInstance(CLSID_ShellLink, NULL, : C$ E1 z# s) I" F4 \2 n1 d
CLSCTX_INPROC_SERVER, K, Q( v: X4 v/ j/ ?, }3 U
IID_IShellLink, (void **) &pLink)))
" M) a$ f8 Q4 T* N{
* F Q, E4 X9 F' f" gpLink->SetPath(file.c_str());
) C- }. t& L! |6 P% j* KpLink->SetDescription("Woo hoo, look at Homer's shortcut");
9 d2 T/ @0 S, tpLink->SetShowCmd(SW_SHOW); </P><P>if(SUCCEEDED(pLink->QueryInterface(IID_IPersistFile, ! B. q( x& ^" q1 L0 |
(void **)&pPersistFile))) . } z( s" i w- k
{ </P><P>WideString strShortCutLocation(DesktopDir);
+ Y I" y8 M% V2 D4 EstrShortCutLocation += "<a>\\bcbshortcut.lnk</A>"; & p& C3 n8 N1 _+ l( }0 P* k/ `
pPersistFile->Save(strShortCutLocation.c_bstr(), TRUE); & T3 X0 w( [; L$ I+ B& W
pPersistFile->Release();
( I' ?+ _- {( ~8 U0 s& y. B}
7 X: g& m% u% k3 C0 A" N+ q. SpLink->Release(); ; v* s. G' X' }$ Q4 W8 ?3 J& }' }
} : [) i5 u8 I0 D
CoUninitialize();
3 R# v- S0 R6 H1 `7 @4 [} & y) W3 @1 O9 N& Y: n# k" T( j
} ) X+ ?8 a# X, |* z4 Y: }" B
//---------------------------------------------------------------------- 8 B+ t6 C7 g0 C* j# ^' C
不要陷于COM的泥沼之中 ^- g6 p' k. a0 e# V0 m
创建快捷方式包括一些对COM的使用。不要让你陷入到COM的复杂之中。COM只是创建和使用对象的一种方法。在这个例子里我们可以考虑不使用COM而是用等价的C++技术。 </P><P>COM code C++ psuedo-equivalent ! Z- x7 U1 _8 R" p
IShellLink* pLink; TShellLink *Link; ; \+ l/ [. e) h' M+ j4 w
IPersistFile* pPersistFile; TPersistFile *PersistFile; </P><P>CoInitialize(); </P><P>
* g# N: D' J. b% S' Q0 @" s2 sCoCreateInstance(CLSID_ShellLink, Link = new TShellLink;
2 ^4 M/ |, X" X4 I( e/ u0 Q2 ONULL,
, Q7 M( v# W( ZCLSCTX_INPROC_SERVER, 7 T! X9 V ~) ]2 i4 `, d
IID_IShellLink,
1 Y7 L7 P1 Q! @4 C9 @& w1 \3 d(void **) &pLink) </P><P>5 L9 K' @# B. k
pLink->SetPath(file.c_str()); Link->SetPath(file.c_str()); 3 g+ c" H, ?# s6 t9 n* \0 [
pLink->SetShowCmd(SW_SHOW); Link->SetShowCmd(SW_SHOW); </P><P>2 B$ Y7 J+ x7 q) N* M; b5 H+ X
pLink->QueryInterface(IID_IPersistFile PersistFile = 1 B: `1 n9 b2 b2 b3 _
(void **)&pPersistFile))) dynamic_cast<TPersistFile*>(Link); </P><P>pPersistFile->Save("C:\\", TRUE); PersistFile->Save("C:\\"); </P><P>
( @: V% E3 s2 D3 X& `. OpPersistFile->Release(); delete PersistFile & B' c0 I4 T# }# ]
pLink->Release(); delete Link; </P><P>CoUninitialize(); </P><P>
( D& K# y. E6 s+ u- |+ F& M& `读磁片磁区 </P><P>+ V1 u' S4 `1 @ w2 T
一、以前的DOS版要读、写、格式化第0轨的第1个磁区,程式大致如下: </P><P>char buffer[512]; </P><P>reg.x.dx=0 ; /* for drive A *
3 P1 O! B5 t# O$ s& ^: {reg.x.cx=0x0001 /* for boot sector */ 1 E6 S! B2 a) q8 J
reg.x.bx=FP_OFF(buffer); 8 ?: Q' M$ r9 U8 H1 q
sreg.es=FP_SEG(buffer); ! t) s" y9 P2 X; c
resg.x.ax=0x0201; /* 02 for Read, 03 for Write ,05 for Format */ % }/ b& v% U7 B% \6 G: g
int86x(0x13,?,?,&sreg); </P><P>那麽在windows 下转换为呼叫 DeviceIoControl 以便格式化、读取、写入该磁轨,DIOC_REGISTERS 这struct 在套上 DOS 下 Int21对HDD或FDD 的各项参数如要格式化是Int21也是有, 但Windows下也另有提供。 </P><P>l#pragma pack(push, 1)
0 {4 e. m8 r4 kstruct DIOC_REGISTERS {
1 Q% P4 l- e3 i, c, p3 ODWORD reg_EBX; ( w2 ?! n( Z; S6 i, J( f+ E
DWORD reg_EDX;
8 w% K7 S0 F; `/ i* A6 x) KDWORD reg_ECX; : h* g$ _5 r0 p$ \2 Q' ?
DWORD reg_EAX;
% n7 P V0 ^) |# n" z; W- O' qDWORD reg_EDI;
8 E6 b$ q0 \+ f" v3 x4 R( \DWORD reg_ESI; ; @9 _; @8 C e k7 n$ ]
DWORD reg_Flags;
7 i0 Z9 J- K4 C' u+ l. e};
( o9 O! T [/ P9 r- \( Y#pragma pack(pop) </P><P>sDiskImageInfo->hDevice = ::CreateFile("<A>\\\\.\\vwin32</A>", 0, 0, NULL, 0,
' A0 U0 ~! x @6 g, ]/ kFILE_FLAG_DELETE_ON_CLOSE, NULL); 5 I" m" i8 {3 k8 V+ D' v2 p! f
if( sDiskImageInfo->hDevice == INVALID_HANDLE_VALUE)
& T9 G8 f& u' c, F5 PbRunNext = false; </P><P>// Reset Floppy Disk
' T, ~( `2 y) b# b; E; h3 ureg.reg_EBX = 0; , V8 h& y/ q$ l2 U& F
reg.reg_EAX = 0x0000; // IOCTL for block devices
' E7 x# ]# J# Breg.reg_EDX = sDiskImageInfo->Driver;
2 B9 Y/ l' Z+ R1 N9 i5 e/ }9 vreg.reg_EDI = 0; reg.reg_ESI= 0;
; s) C `/ y/ s) R( ?4 Nreg.reg_Flags = 0x0001; // assume error (carry flag is set)
" V, I; L: _, J) Q0 l9 K# n SdwResult = :eviceIoControl( sDiskImageInfo->hDevice, ! N. R0 z/ M* X; b8 c( h
VWIN32_DIOC_DOS_INT13, " S, I P, G: z! l/ n" t
?, sizeof(DIOC_REGISTERS), ?, : b$ W) ~: Q8 t1 \8 t. _- a
sizeof(DIOC_REGISTERS), &cb, 0); </P><P>// Seek Floppy
3 J& q) A; G5 O8 Vreg.reg_EBX = 0; $ u1 y0 W2 h) W. g
reg.reg_EAX = 0x0C00; // IOCTL for block devices k# } ]: q6 i' e+ A
reg.reg_ECX = ( sDiskImageInfo->nC << 8) | sDiskImageInfo->nS;
& e& i! Y7 a5 R& v" O( j/ i) Kreg.reg_EDX = ( sDiskImageInfo->nH << 8) | sDiskImageInfo->Driver;
. n3 A5 r8 M: ]3 \! Wreg.reg_EDI = 0;
' P( S N( u% c% V3 d3 V8 Greg.reg_ESI= 0;
9 e8 H' P5 _3 ], F) V- Ureg.reg_Flags = 0x0001; // assume error (carry flag is set)
8 T1 ?- C- A" ]0 v+ hdwResult = :eviceIoControl( sDiskImageInfo->hDevice, 8 c8 ^, ~4 r' n4 a. [
VWIN32_DIOC_DOS_INT13, & M: ^+ F( w0 ~$ b
?, sizeof(DIOC_REGISTERS), ?, " s' q4 d) v$ O$ V0 e9 s
sizeof(DIOC_REGISTERS), &cb, 0); </P><P>// Read Floppy & v7 r( r+ t1 S% j% Q% d7 |& z! L
R_CreateDiskImageFile:
! p* M# o; v, m oreg.reg_EBX = 0; - o3 G) E4 b* y9 L4 g2 u
reg.reg_EAX = 0x0200 | 0x01; // IOCTL for block devices 3 O1 l; n4 x- Z) a# h4 _7 Y- E$ s
reg.reg_ECX = ( sDiskImageInfo->nC << 8) | sDiskImageInfo->nS; 5 R, O- o% w% r% k, ~
reg.reg_EDX = ( sDiskImageInfo->nH << 8) | sDiskImageInfo->Driver;
8 J" Y/ T p- Z+ Yreg.reg_EBX = (DWORD) &m_Buf;
9 ~" M! r# r, preg.reg_EDI = 0;
+ n, O( P! J! B0 z8 F5 u4 ^. Greg.reg_ESI= 0; & j/ p. q* W% j" r8 ?
reg.reg_Flags = 0x0001; // assume error (carry flag is set)
: c0 t7 ]6 ]1 S# _dwResult = :eviceIoControl( hDevice, VWIN32_DIOC_DOS_INT13, ' ?) E n2 _- |1 @" G9 M1 k6 ~8 G
?, sizeof(DIOC_REGISTERS), ?,
( n! W5 a* e$ G" f! V! X1 A- X9 j! psizeof(DIOC_REGISTERS), &cb, 0); # o- B( @+ ^# W* T. w
if (!dwResult || (reg.reg_Flags & 0x0001)) - X1 U' L+ L! @: Q5 \4 `6 M
{ ) l2 u8 b, O/ J6 h6 \
} </P><P>I/O 端 口 读 写 的 实 现 </P><P>- k6 w* d: O; D6 _3 g( d
细 心 的 读 者 会 发现,C++ Builder 不 再 支 持 如inportb()、outportb() 一 类I/O 端 口 读 写指 令 了。 准 确 地 说, 在Windows 环 境 下,Borland C++ 仅 支 持16 位应 用 程 序 的 端 口 操 作, 对32 位 应 用 程 序 的 端 口 操 作 不 再 支持, 而C++ Builder 开 发 出 来 的 程 序 是32 位 的。 我 个 人 以 为, 这是C++ Builder 设 计 者 的 败 笔。 因 为PC 机 中,I/O 地 址 空 间 与 内存 地 址 空 间 从 来 都 是 各 自 独 立 的。 看 看Delphi, 不 就 通 过Port 数 组 实 现 了 对I/O 端 口 的 访 问 了 吗? 搞 不 清 楚 为 什 么C++ Builder 就 没 有 提 供 类 似 的 机 制 ? 下 面 这 几 个 函 数 是 笔 者 从 网 上淘 下 来 的, 经 过 验 证, 在Windows95 环 境 下, 的 确 可 实 现 对I/O 端 口 的 读 写。 读 者 可 以 借 鉴 使 用。
' X& T' B$ i7 {& ?& svoid outportb(unsigned short int port, unsigned char value) </P><P>{ </P><P>// mov edx, *(&port); </P><P>__emit__(0x8b, 0x95, &port); </P><P>// mov al, *(&value); </P><P>__emit__(0x8a, 0x85, &value); </P><P>// out dx, al; </P><P>__emit__(0x66, 0xee); </P><P>} </P><P>void outportw(unsigned short int port, unsigned short int value) </P><P>{ </P><P>// mov edx, *(&port); </P><P>__emit__(0x8b, 0x95, &port); </P><P>// mov ax, *(&value); </P><P>__emit__(0x66, 0x8b, 0x85, &value); </P><P>// out dx, ax; </P><P>__emit__(0xef); </P><P>} </P><P>unsigned char inportb(unsigned short int port) </P><P>{ </P><P>unsigned char value; </P><P>// mov edx, *(&port); </P><P>__emit__(0x8b, 0x95, &port); </P><P>// in al, dx; </P><P>__emit__(0x66, 0xec); </P><P>// mov *(&value), al; </P><P>__emit__(0x88, 0x85, &value); </P><P>return value; </P><P>} </P><P>unsigned short int inportw(unsigned short int port) </P><P>{ </P><P>unsigned short int value; </P><P>// mov edx, *(&port); </P><P>__emit__(0x8b, 0x95, &port); </P><P>// in ax, dx </P><P>__emit__(0xed); </P><P>// mov *(&value), ax </P><P>__emit__(0x66, 0x89, 0x85, &value); </P><P>return value; </P><P>} </P><P>) t- w: z" s# n: h
检 测 鼠 标 位 置 </P><P>例如,通过一个定时器Timer1的触发事件源来检测鼠标位置 </P><P>void __fastcall TForm1::Timer1Timer(TObject *Sender) </P><P>{ </P><P>TPoint pt; </P><P>GetCursorPos(&pt); </P><P>Label1->Caption = "(" +IntToStr(pt.x) +")(" +IntToStr(pt.y) +")"; </P><P>} </P><P>令Win32 应 用 程 序 跳 入 系 统 零 层 </P><P>
( [, I& ?; i8 j) q众 所 周 知, 在Windows95/98 的Win32 on Intel x86 体 系 中 利 用 了 处 理 器 的 三 环 保 护 模 型 中 的 零 环(Ring0, 最 高 权 限 级 别) 和 三 环(Ring3, 最 低 权 限 级 别)。 一 般 应 用 程 序 都 运 行 在Ring3 下, 受 到 严 格 的" 保 护", 只 能 规 矩 地 使 用Win32API。 如 果 我 们 想 进 行 一 些 系 统 级 的 操 作, 例 如 在 嵌 入 汇 编 中 使 用 诸 如"Mov EAX,CR0", 或 像 在DOS 下 那 样 调 用 一 些 必 不 可 少 的 系 统 服 务( 如BIOS,DPMI 服 务) 而 用"Int xx", 都 会 导 致" 非 法 操 作"。 但 这 种 能 力 有 时 是 必 不 可 少 的, 一 到 这 种 时 候Microsoft 就 " 建 议 编 写 一 个VxD"。VxD 大 家 早 有 所 闻 了, 在VxD 里, 不 但 可 以 执 行CPU 的 所 有 指 令, 而 且 可 以 调 用VMM( 虚 拟 机 管 理 器) 和 其 他VxD 提 供 的 上 千 个 系 统 级 服 务。 获 得 这 一 能 力 的 最 本 质 原 因 在 于 它 运 行 在Ring0, 与 系 统 内 核 同 一 级 别。 但 是 它 体 系 的 复 杂 性、 开 发 工 具 的 不 易 获 得、 帮 助 文 档 的 不 完 备, 使Microsoft 排 除 了 一 大 批 程 序 员 和 竞 争 对 手。 而 将 在Windows2000(Windows98 也 开 始 支 持) 中 取 代VxD 的WDM 对Win95 程 序 员 也 是 个 噩 梦, 它 需 要 了 解Windows NT 核 心 驱 动 模 型。 </P><P>----有 没 有 简 单 一 些 的 办 法 呢 ? 我 们 可 以 令 一 个 普 通Win32 应 用 程 序 运 行 在Ring0 下, 从 而 获 得VxD 的 能 力 吗 ? 答 案 是 肯 定 的。 下 面 我 们 就 简 述 一 下 这 一 技 巧, 有 关Intel x86 保 护 模 式 的 基 础 知 识 请 大 家 看 有 关 书 籍。 </P><P>----首 先 此 技 巧 基 于 以 下 理 论 根 据: </P><P>----一、SIDT 指 令( 将 中 断 描 述 符 表 寄 存 器 IDTR - -64 位 宽,16 ~47Bit 存 有 中 断 描 述 符 表IDT 基 地 址 - - 的 内 容 存 入 指 定 地 址 单 元) 不 是 特 权 指 令, 就 是 说 我 们 可 以 在Ring3 下 执 行 该 指 令, 获 得IDT 的 基 地 址, 从 而 修 改IDT, 增 加 一 个 中 断 门 安 置 我 们 的 中 断 服 务, 一 旦Ring3 程 序 中 产 生 此 中 断,VMM 就 会 调 用 此 中 断 服 务 程 序, 而 此 中 断 服 务 程 序 就 运 行 在Ring0 下 了。 这 一 点 与 在DOS 下 非 常 相 似。 </P><P>----二、Windows95 Win32 应 用 程 序 运 行 一 个 映 射 到 全 部4G 内 存 的 段 中, 选 择 子 为0137h,Ring0 中 的VxD 运 行 在 另 一 个 映 射 到 全 部4G 内 存 的 段 中, 选 择 子028h, 这 两 个 段 除 了 选 择 子 决 定 的 访 问 权 限 不 同 外, 没 什 么 不 同, 各 自 段 中 相 同 的 偏 移 量 对 应 了 相 同 的 线 性 地 址。 所 以 我 们 放 在Win32 应 用 程 序 中 的 中 断 服 务 程 序 可 以 以Ring3 的 段 偏 移 量 被Ring0 中 的VMM 寻 址。 </P><P>----下 面 我 们 以 具 体 例 子 进 一 步 说 明, 程 序 中 有 详 细 注 释。 </P><P>----这 是 一 个Win32 Console Program( 控 制 台 应 用 程 序), 虽 然 运 行 中 看 起 来 很 像DOS 筐 中 运 行 的 实 模 式DOS 程 序, 但 它 是 货 真 价 实 的 运 行 在Ring3 下 的Win32 程 序。 用Visual C + + 5.0 AppWizard 创 建 一 个Win32 Console Program 项 目, 添 加 以 下.CPP 文 件, 编 译 即 可。 </P><P>#include
: L/ I8 ~- S1 `! j#include
/ e) F1 D7 g" K5 `( U#include 7 U* t$ N, H+ S! a, s0 M+ g
#include 7 @, o- ]( X% O/ h5 Q7 i& W
// 若 无DDK 带 下 划 线 的 可 略 去, " X4 ^ R# A% t6 V# s
这 些 语 句 演 示 了 调 用VMM/VXD 服 务
0 O9 O- `% @& ~" S( T, r0 ^5 NDWORDLONG IDTR,SavedGate;
( G7 y" U1 e' [WORD OurGate[4]={0,0x0028,0xee00,0x0000};
# g7 m+ V( ?; u+ T- |+ I// 中 断 门 描 述 符 格 式 如 下: </P><P>
' U1 h8 d7 |7 G5 ^/ @- I; ZDWORD _eax,_ecx,_cr0;
, A* Q' ~! r* n& R) p8 DWORD vmmver; ! h# t# |, `$ R# F0 |
HVM sysvm; </P><P>void nothing()
$ Q: h" g) N2 F/ d- @! O{
+ e) n6 q4 v& x1 v0 p( q2 f//Used to test call in Ring0 8 N- O! X t# W* |" L* J: X
sysvm=Get_Sys_VM_Handle(); ( p2 y" N) R( O% X
} </P><P>void __declspec( naked ) Ring0Proc(void)
3 ^7 H6 U8 `9 G/ w8 _// 中 断 例 程, 运 行 在Ring0
3 k. Q; \# G" U1 v1 E( p{
9 M1 B/ a m, x; ~_asm{ 2 I4 `# {& u( h) o' \2 {/ _" q
mov _eax,eax //
, g/ Y( U6 [' l# Mmov _ecx,ecx //
6 ~# k0 \2 K7 B3 x$ Amov eax, CR0 ; Y5 i5 I5 w8 a5 Z
// 测 试Ring3 中 不 能 执 行 的 特 权 指 令 - V. h) `9 `. J* ~: U5 X$ _
mov _cr0,eax // ' l4 S& [. z$ X7 c8 d
} ! y0 i: ^( ?# I [1 g9 I$ v. |- j
VMMCall(Get_VMM_Version); 3 W/ i: P& [! [3 _1 X
// 调 用VMM 服 务 7 P$ @5 W S0 @( u* Q" n
_asm{
$ w- [# b. o( ^3 {, s! z+ {mov vmmver,ax
" z1 J% j# }2 A' M/ i# i}
7 I$ t/ ], {: Z, K! \nothing();
% i# a5 B' P* n' ~; c: Q// 测 试 在 运 行 于Ring0 的 - [( Z/ z( f& H* x
中 断 例 程 中 调 用 子 / ]" J/ \; G* H8 t0 x
_asm iretd ( g5 Z- E, I- Z: C
// 中 断 返 回, 与 在 实 模 式 # R+ X* C* D+ U2 c/ H3 g7 j# I
编 程 无 本 质 区 别
+ j6 m+ ?! ^4 ~ R, D* x}
5 O7 g8 b. ~- F( J- H& B7 R6 Hvoid main() // 主 程 序
6 _1 S( a: X- z" _* G( g{
! p* p$ x3 \8 [( {7 Q! }1 V9 V_asm{ - Z+ ?& {( p+ Q& Q" l6 T
mov eax, offset Ring0Proc / Z2 [, v$ N& a' \6 b" I
mov [OurGate], ax // 将 中 断 函 数 的 地 址 ; m. m7 v" m: v7 A
shr eax, 16 // 填 入 新 造 的 中 断 门
2 @" G4 _( Q! [# s1 vmov [OurGate +6], ax // 描 述 符 </P><P>sidt fword ptr IDTR - X9 G, O" }* j0 k" y1 i3 W. ^$ |3 U
// 将 中 断 描 述 符 表 寄 存 器(IDTR)
% ^1 T3 t) p4 }- h的 内 容 取 出 * n+ Z7 k0 h! M* u
mov ebx, dword ptr [IDTR +2]
, ?2 V5 X, @( s/ w8 O- o `' I// 取 出 中 断 描 述 符 表(IDT) 基 地 址 8 g4 \- A0 d$ H# S, M
add ebx, 8 *9 ' P& \! d% | h
// 计 算Int 9 的 描 述 符 应 放 置 的 地 址 选 用
# C4 T4 m7 D0 `2 gInt9 是 因 为 它 在Win32 保 护 模 式 下 未 占 用 </P><P>mov edi, offset SavedGate : l* I& @$ C, D; o; z+ ^2 d8 U
mov esi, ebx
, H" x H3 o2 [movsd // 保 存 原 来 的Int 9 描 述 符 到 9 T8 ]2 b( b% |6 u( b7 C
movsd //SavedGate 以 便 恢 复 </P><P>mov edi, ebx
3 N$ L4 x5 j6 [mov esi, offset OurGate
" l0 h$ a+ h8 V, N, B$ m+ M9 F# Gmovsd // 替 换 原 来 的 中 断 门 描 述 符 8 ~/ B5 L1 a* q4 g
movsd // 以 安 装 中 断 服 务 例 程 </P><P>mov eax,0x6200 ' I( @: T% K/ U9 N' [
// 用 以 测 试 放 在EAX 中 的 数 据 # i* x- u! F f
能 否 正 确 传 到Ring0 中 断
! @$ d$ K& a7 Dmov ecx,0 ; T3 D7 q, ?0 z) P% g# }
// 用 以 测 试 放 在ECX 中 的 数 据 0 R$ \# j* X; r5 _" Z( N
能 否 正 确 传 到Ring0 中 断 - C; A' _0 y) i/ D3 u
mov ecx,0 - t' J6 |$ ]+ k* S k2 k! y
// 用 以 测 试 放 在ECX 中 的 数 据 / {- [* B3 [1 q7 z3 ]! v5 r) m3 I
能 否 正 确 传 到Ring0 中 断
% \1 |% ]* G6 f* p' g, Z. o/ M+ x// 因 为 很 多VxD 服 务 都 用 . S% N! b, T2 b6 v# M, m! L
此 二 寄 存 器 传 递 参 数
/ O) ]- E2 q2 `1 K% Xint 9h 7 ^' q( b' k2 }" e6 r6 e3 S: w
// 人 为 触 发 中 断, 平 时 会 出 现
( }/ D, o* Z, e6 F6 j保 护 错 误 蓝 屏 或 非 法 操 9 H8 x2 l5 b2 X. y$ ?% q" F
// 作 对 话 框, 现 在 安 装 了 1 \3 S- K P7 d; A3 }; z M( b- T
// 中 断 服 务 例 程 后, 就 会 通 过 7 P4 Q3 M1 r& Z7 C7 x
//VMM 在Ring0 调 用 中 断 服 务 例 程 4 V% [3 z" T2 M% i0 s
- -Ring0Proc </P><P>mov edi, ebx
! s" a# v0 E4 X. Jmov esi, offset SavedGate
% E+ m1 ]2 h0 o3 ?4 w) i- }movsd // 恢 复 原 来 的 中 断 门 描 述 符 ' M( r8 N' X y, K5 ~7 k/ }
movsd
+ f( }5 |$ i. Q# l0 A}
" [: Z% X% ^! H% _3 P# v5 Scout<<"CR0="<<_cr0< } _getch(); if(0="=_getch())" while(_kbhit()="=0);" do{} continue.?< </P><P>0 S; H$ C$ Q, S+ G" l
如何取得Memo的行和列 </P><P>
6 v4 Q, i7 K5 T; b" Y! E7 a+ c 新建一个应用,在窗体Form1上添加两个TLabel组件名为Label1,Label2;
* d+ J- [1 o( x; ]; K1 b% m6 h添加两个TButton组件名为Button1,Button2;添加一个TMemo组件名为Memo1。
0 s# r* R; l7 b) A% ?然后在代码编辑器中添加以下代码。
' a- o% F3 j, R5 t8 C! O8 S2 w0 w3 i: [+ ^ void __fastcall TForm1::Button1Click(TObject *Sender) ; }5 j8 I) L0 o! B5 _
{ ' Z- ?1 }1 W4 M% }. G- A* i/ n
Label1→Caption=SendMessage(Memo1→Handle,EM_LINEFROMCHAR,-1,0)+1; 9 Z$ s( }) |/ K/ k4 Z/ d3 @
} 3 R8 P4 j9 T; |, U
# {5 X- n4 Z' x( b& b6 U, _ void __fastcall TForm1::Button2Click(TObject *Sender)
3 {+ F* n5 f0 G9 H" B+ ?2 t { ) l2 j* K! C1 [9 a
Label2→Caption=Memo1→SelStart-SendMessage(Memo1→Handle,EM_LINEINDEX,-1,0)+1;
7 S& s* q+ f2 B( F: S @ y } / p6 r7 _1 I, f4 D0 |
这种方法同样适用于RichEdit。 </P><P>使用Sockets </P><P>
+ c3 ^8 F( ^. R" d" R使用sockets Socket控件让你建立一个利用TCP/IP和有关的协议与其他系统进行通信的应用。使用Sockets,你能够读和写通过它连接的其他机器,而不用担心实际的网络软件的相关细节。Sockets提供基于TCP/IP协议的连接。除此以外还能很好的工作,在其他相关的协议,例如Xerox Network System (XNS), Digital's DEC net, or Novell's IPX/SPX 家族。 - w6 V; ?9 m2 E3 `, _
C++ Builder提供你写网络服务器或客户应用程序去读和写其他的系统。一个服务或客户程序通常专注于一个单一的服务如超文本传送协议(HTTP)或文件传输协议(FTP)。使用server sockets,一个应用程序可以提供这些服务中的一个去连接一个希望使用服务的客户程序。Client sockets允许一个应用使用这些服务中的一个去连接提供这个服务的服务应用。 ( n+ a, n' C+ w5 y( d6 [
使用sockets去写应用程序,你必须理解下面这些知识:
4 p3 V7 Y, q; _* ^! f2 y G一、服务工具
: }& Y9 \8 E& K$ y当你需要写网络服务或客户应用时,Sockets提供一种接合。对于许多服务,象
- F$ H: ?( Z" JHTTP 或 FTP,第三方服务商提供这些服务已经相当有效。有些甚至随着操作系统捆绑而来,以便不用你自己写。然而,当你想更多的控制服务的实现,如想让你的应用程序与网络通信更加紧密,或当没有一个服务能提供你特殊需要的服务时,你可能想建立你自己的服务或客户应用。例如,工作在分布式data sets时,你可能想为数据库写一层与其他系统通信的应用。想使用Sockets实现一个服务,你必须理解: </P><P>1.服务协议
( p: i0 a: h2 i6 ]( l, [* V在你写一个网络服务或客户程序前,你必须明白你的应用将提供或使用什么服务。你的网络应用必须支持许多服务的标准协议。如果你为标准的服务例如HTTP,FTP写网络应用,或even finger or time,你必须先理解与其他系统通信所使用的协议。特殊服务细节你必须看提供的或使用的文档。
1 x7 D Q1 d8 n% K6 i如果你的应用程序提供一个新的服务与其他系统通信,第一步是为这个服务的 ! K1 z6 Y& M# _0 X2 I! h' Y: e/ L3 a
服务端和客户端设计通信协议。什么信息将发送?如何整理这些信息?如何对这些信息进行编码? </P><P>应用程序通信
# p5 c4 p. ]% ^* q" L0 ] X经常的,你的网络服务端或客户端应用程序要提供一层在网络软件和一个应用之间使用的服务。例如,一个HTTP服务站点在INternet与一个Web 服务应用之间为HTTP请求信息提供内容和应答。
- L4 _9 X& d/ `9 O0 t( G( w9 s在你的网络应用(或客户应用)和网络软件之间Sockets 提供一个接口。你必须提供一个接口,在你的应用程序与应用间使用。你可以拷贝第三方服务商提供的标准API(例如ISAPI),或你可以设计和发布你自己的API. </P><P>2.理解服务和端口
4 j Z0 Y( u) f" \# K2 V2 S许多标准服务都有关联的、指定的端口号。当 执行服务时,你可以为服务考虑一个端口号。如果你实现一个标准服务, Windows socket objects 提供一些方法让你为服务寻找端口号。如果提供一个新的服务,在基于Windows 95 或 NT机器上,你能够在文件Services中为你的服务指定一个相关联的端口号。设置Services文件的更多信息请看微软 的Windows Sockets文档。 </P><P>二、Socket连接的类型 $ q- \% N9 p# x* Q# W; f
Socket连接可以分成三个基本的类型,它们反映了如何开始连接和本地Socket 连接是什么。这三个类型是: </P><P>1.客户端连接
' d3 S0 S1 a- s8 P客户端连接是一个本地系统的客户端socket与一个远程系统上的服务端Socket连接。客户端连接由客户端Socket开始。首先,客户端Socket必须描述它想连接到的服务端Socket. 接着客户端socket查找服务端socket,当找到服务器时,就要求连接。服务端socket可能不能完成正确的连接。服务器sockets维持一个客户端请求队列,在他们有时间时完成连接。当服务端socket接受客户端连接,服务端socket
) \$ w. a/ C0 e% I3 M- f* ~将向它想连接的客户socket发送一个完整的描述,客户端的连接完成。 </P><P>2.倾听连接
0 b' l7 C4 S [7 x( a0 K服务器 socket不会去定位客户端,代替的,他们形成被动的,"半连接"状态,倾听来自客户端的请求。服务器 sockets形成一个队列,存放 它们听到的连接请求。这个队列记录着客户端连接请求就象他们已连接进来一样。当服务器sockets同意客户连接请求时,它形成一个新的socket去连接客户端,因此这个倾听连接能保持开放状态允许其他客户端请求。 </P><P>3.服务端连接
0 g& u7 g. s1 P, V+ D7 ]当倾听socket同意一个客户端请求时,服务器端socket形成一个服务器连接。当服务器端同意连接时,向客户端发送一个服务端socket描述以完成连接,当客户端socket收到这个描述时这个连接得到确认,连接完成。一但连接到客户端的Socket完成,服务端连接就不能识别从一个客户端来的连接。末端双方有同样的能力去接收同样的事件类型。只有倾听(listening)连接是根本不同的,它只有一个单一的末端。 </P><P>三、sockets描述 - J2 | B8 z, ?6 b, n
Sockets让你的网络应用软件通过网络与其他系统进行通信。在网络连接中每个socket可以看成一个终端点。它有一个指定的地址。 </P><P>*这个系统正在运行 9 ?5 f6 q L' R( a0 {& g& }
*它理解的接口类型
: o# ]) ], `$ P3 p*用来连接的端口
/ t; F% a* _. @: U- e9 N: t5 _一个完整的socket连接描述,你必须提供sockets 在连接两端的地址。在你开始一个socket连接前,你必须完整的描述你想得到的连接。有些信息可以从你的应用 9 i- W3 |7 L5 X$ o
软件运行的系统平台上得到。例如,你不需要描述一个客户端socket的本地IP地址--这个信息可以从操作系统上获得。你必须提供你工作所依靠的socket的类型的信息。客户端socket必须描述他们想连接的服务器。侦听服务器sockets必须描述他们提供反应的服务器的端口。一个socket 连接终端的完整描述包括两部分: </P><P>1.IP地址
0 N2 I7 E7 w" H8 x: m2 O主机是这样一个系统,它运行着包含有socket的应用程序。你必须描述主机给socket,通过给出主机的IP地址来完成这个描述。IP地址是一个有四个数字(byte)值的,在标准internet点付内的字符串。 $ \- N7 L& ~ D# |
例如123.197.1.2
& d7 B7 W* e7 n9 ^. b1 \! ^; H一个简单的系统可以支持多于一个的IP地址。IP地址通常难于记忆并且容易打错。一个可供选择的方法是使用主机名。主机名就是IP地址的别名,它就是你常看到的统一资源定位(URLs)。它是一个字符串,包括了域名和服务。 8 i9 _+ b9 Z- z0 O( a* i. W
例如 <a href="http://www.wsite.com" target="_blank" >http://www.wsite.com</A>
6 D. I6 O& n! x1 J l% e许多内部网提供给主机的名字对应的系统IP地址是internetIP地址。在windows95 和NT机器上,如果一个主机名不能用,你可以在HOSTS文件中为你的本地IP地址(这个本地IP地址应该是指你想连接的主机IP地址--zyqsj)建立一个进入的名字。 + ~9 q9 E7 P3 h1 |
关于HOSTS文件的更多信息请看WINDOWS SOCKETS的文档。
6 Q$ V$ x4 r/ a服务器sockets不需要指定主机。本地IP地址可以从系统中读到。如果本地系统支持多于一个的IP地址,服务器sockets将同时在所有的IP地址上侦听客户端请求。当一个服务器socket同意一个连接,客户端提供一个远程IP地址。客户sockets必须指定远程主机通过提供主机名或者IP地址。 </P><P>在主机名和IP地址间作一个选择 3 r& e0 y2 j% Q' t& N$ D3 a7 H3 J
许多应用软件使用一个主机名去指定一个系统。主机名容易记住和容易检查排版错误。进一步讲,服务器能改变系统或与IP地址关联的特殊的主机名。使用一个主机名,能够允许客户端通过主机名描述找到抽象的站点,即使主机使用一个新的IP地址。
6 G3 C6 P$ n0 ~# a如果主机名是未知的,客户socket必须指定服务器系统使用的IP地址。通过给一个IP地址来指定服务器将更快。当你提供主机名时,socket在定位服务器系统前,必须搜寻与这个主机名相关的IP地址。 </P><P>2.端口号
. O$ q+ K' u2 h) v# _" ?- W虽然IP得地址提供了足够的信息去找到socket连接中位于另一端的系统,你通常还需要指定那个系统的端口号。没有端口号,一个系统在同一时间只能进行一个单一的连接。端口号是唯一标识那允许一个独立系统连接到支持同时多个连接的主机,每个连接都必须指定一个端口号。 # Q1 e* F) L. J9 Y+ O+ P7 l
在网络应用中,对于服务器工具来说端口号是一个数字代码。有一个习惯就是侦听服务连接到他们自己固定的端口号上,以便他们能找到客户端sockets.服务器socket监听为他们提供服务的相关端口号。当他们允许给予一个客户端socket连接时,他们创建一个独立的socket连接,使用不同的专用的端口号。通过这个方法,能持续的监听相关服务的端口号。 # ?9 }( A+ G' s) f
客户端socket使用一个专用的本地端口号,就不用其他的socket去寻找它们。他们指定他们想连接的服务器端socket的端口号,这样他们就能找到服务器应用程序。常常的,这个端口号是通过命名想连接的服务来间接指定的。 </P><P>四、使用socket控件
% q4 Q; d$ n" o" p4 @/ @8 tC++Builder提供两个socket控件,客户端sockets和服务器sockets.他们允许你的网络应用构成连接其他的机器和允许你通过这个连接来读写信息。与每个socket控件相关联的是windows socket对象,它们在终端的的作用是一个实际的socket连接。socket控件使用windows socket对象去封装windows socket API 调用,所以你的应用不用去关心连接建立的细节或管理socket信息。
8 N4 O* w# h' ]! d/ |, _如果你想利用windows socket API调用或自定义连接细节,socket控件提供了便利,你可以使用windows socket对象的properies,events和方法。 </P><P>1.使用客户端sockets . [, H, c! V' f( N! b5 J
添加一个客户端socket控件(TClientSocket)到你的form或data module 使你的应用成为一个TCP/IP客户。客户sockets允许你指定你想连接的服务器socket和你希望服务器提供的服务。一但你描述你想得到的连接,你可以使用客户socket控件去完成连接服务。
5 @- d( z$ Y/ D, ^- y1 J" b每个客户socket控件使用独立的客户windows socket对象(TClientWinSocket)去应答连接中的客户终端。使用客户sockets去: </P><P>A.指定想得到的服务 : n- V# h; Q5 j1 M0 T9 i
客户socket控件有一个数字properties,允许你指定想连接的服务器系统和端口。你可以通过主机名来指定服务器系统,使用Host property。
" M9 r4 w/ D' P& F& w6 H9 z! r. n! R如果你不知道主机名,或者你关心找到服务器的速度,你可以指定服务器系统的IP地址,通过使用 Address property。你必须指定IP地址和主机名中的一个。
0 m* P* _. v1 y5 U# }如果你两个都指定,客户socket控件将使用主机名。除服务器系统外,你必须指定你的客户socket将连接的在服务器系统上的端口。你能够直接使用Port property来指定服务端口号。或者直接在Service property使用想得到的服务的名字。如果你指定端口号和服务名,客户socket控件将使用服务名。 </P><P>B.建立连接
; f& ]* W4 \7 ~* }, u H一旦你在客户socket控件中完成了设置描述你想连接的服务器的属性,你就可以进行连接,通过调用Open方法。如果你想你的应用启动时自动建立连接,在设计时设置Active property为true,通过使用Object Inspector来设置。 </P><P>C.取得关于连接的信息 - ~4 A4 L8 q6 s4 g {! H
完成连接到服务器socket后,你可以使用与你的客户socket控件相关的客户windows socket object去取得关于连接的信息。使用Socket property去访问client windows socket object。windows socket object 有一个properties,它能让你确定在连接的两端客户和服务器使用的地址和端口号。 % O% M2 t6 f* Z ~8 V0 _' z3 ]
当使用一个windows socket API调用时,你可以使用SocketHandle property区获得socket连接使用的handle。你可以使用Handle property去访问windows,以便接收来自socket连接的信息。AsyncStyles property决定哪种信息类型是windows handle要接收的。 </P><P>D.关闭连接
9 c+ Y# K, v8 L2 J9 t/ y& h9 F6 z当你完成通讯想关闭socket 连接时,你能够通过调用Close方法来关闭连接。连接可能要由服务器端来关闭。如果是这种情况,你将收到一个OnDisconnect 事件的通知。 </P><P>2.使用服务器sockets
! h+ {" q# T2 c- f. w. d3 I' S添加一个服务端socket控件(TServerSocket)到你的form或data module使你的应用成为一个TCP/IP服务器。服务器sockets允许你指定你想提供的服务或你想用来监听客户请求时使用的端口。你可以使用服务器socket控件去监听和允许客户连接请求。每个服务器socket控件使用一个单一的服务器windows socket Object(TServerWinSocket)去应答在服务器端监听到的连接。它通常使用一个服务器客户winodws socket Object(TServerClientWinSocket)应答在服务器端每个活动的,连接着得到允许服务的客户socket。使用服务器sockets去: </P><P>A.指定端口 + @3 Z0 B2 X' U) s! v7 u
在你的服务器socket能够监听客户请求之前,你必须指定一个端口给你的监听服务。你可以使用Port property来指定这个端口。如果你的服务器应用提供一个标准的服务,这个服务使用一个习惯使用的相关联的端口。你能够使用Service property直接指定端口号。使用Service property是一个好的主意,能够减少设置端口号时的错误。如果你既指定了Port property,又指定了Service property,服务socket将使用服务名。 </P><P>B.监听客户请求
& M" j& V* u* l; V' v! T一旦你在server socket控件上设置好你的端口号,你就能够通过在运行时通过调用Open方法来监听一个连接。如果你希望你的应用程序能够在启动的时候自动监听连接,在设计的时候通过使用Object Inspector设置Active 属性为true。 </P><P>C.连接到客户端。 ( R; P& ?/ y% Z7 e+ M1 w
当监听服务socket控件接收到一个客户端连接请求时他们将自动接受这个请求。当你没次收到通知时,OnClientConnetc事件将发生。 </P><P>D.取得关于连接的信息 & `/ x& v% v2 w+ Z
一但你的服务器socket打开了监听连接,你能够使用与你服务器socket控件相关联的服务器windows socket object来取得关于连接的信息。使用Socket property去访问server windows socket object.windows socket object有一个属性能够让你找到关于所有活动的客户socket连接这些客户socket是你通过服务器socket控件允许连接的。使用Handle属性去存取windows通过socket连接收到的信息。
4 O3 W# b' H: ~- M$ b2 C每个活动的,连接到客户应用是通过服务、客户windows socket bject (TServerClientWinSocket)封装的。你能够通过server windows socket object的连接属性来访问所有的这些。这些server client windows socket object有些属性让你能够决定哪些地址和端口号给连接的两端--客户和服务器socket使用。当你使用windows socket API调用时,可以使用SocketHandle属性去获得socket连接使用的handle。你能够使用Handle属性去访问windows从socket连接处得来的信息。AsyncStyles属性决定windows handle将接收哪种类型的信息。 </P><P>E.关闭连接 2 x8 a$ _! R( U' k- @9 w
当你决定关闭监听连接时,调用Close方法。这将关闭所有打开着的,连接到客户应用的连接,取消任何尚未同意的连接,接着关闭监听连接以便你的服务socket控件不在接受任何新的连接。当客户端关闭他们自己独立的连接到你的server socket的连接时,你可以在OnClientDisconnect事件中得到讯息。 </P><P>五、socket事件的应答 ! Y# s$ G) d3 M. N
当使用sockets写应用程序时,大多数工作发生在socket控件的handler事件中.当通过socket连接开始读或写时,OnRead和OnWrite事件在non-blocking client sockets中发生从而通知sockets.同样的,服务器sockets(blocking or non-blocking)收到OnClientRead和OnClientWrite事件. + F" W; ^+ f( I" W% ^) `" y
当服务器结束一个连接时,客户scokets收到一个OnDisconnect事件.当客户端结束一个连接时,服务器socket收到一个OnClientDisconnect事件.
; [$ {; H) L, l/ g另外,客户端Sockets和服务器端socket从连接中收到一个错误信息时,都将产生有个错误事件. </P><P>错误事件:客户sockets和服务器sockets通常会产生一个OnError事件,当他们从连接中收到一个错误信息的时候.你能够写一个OnError事件处理去响应这些错误信息.这个OnError事件处理提供传送关于socket试图做什么的时候这个错误发生的信息,以及错误信息提供的错误代码.你可以在OnError事件处理中对这个错误作出响应,并且把错误代码改为0,以避免socket产生一个例外. </P><P>当开始和完成发生时,socket控件通常会收到一个事件号(number of events).如果你的应用程序需要改变socket开始操作的处理过程或通过连接开始读或写操作时,你将写事件handlers去应答这些client events和server events. </P><P>A.client events
; s. n( ~8 }- D9 J! h$ W c当一个客户socket打开一个连接时,以下事件发生:
! u: ?9 ^3 d; ?5 p8 O; q1 y1.一个OnLookup事件最先发生,它试图去定位server socket.在这里你不能改变Host,Address,Port,Service属性去改变你想定位的服务器.你能够使用Socket属性去访问client windows socket object,并且使用它的SocketHandle属性去调用windows API,以便改变socket的客户属性.例如,如果你想在客户应用软件中设置端口号,你必须在server client连接前做这件事. ' a6 q5 d t1 R* r N" ~. b
2.windows socket设置和初始化事件通知.
) I8 ~: N5 a7 a4 ^) h3 W3.当找到server socket时一个OnConnecting事件发生.在这事件中,windows Socket object可以利用的是通过socket属性提供关于连接的另一端的服务socket的一些信息.这是获得实际使用来连接的端口和IP地址的第一个机会,它可能不同于从监听socket处同意连接时得到的端口或IP地址. % L6 E5 }8 p. u3 X$ T( w: ?( S
4.服务器同意连接请求,客户端socket完成连接.
! G; C1 i: `, }7 P5 N* h: _8 Y5.当一个连接得到确定后,一个OnConnect事件发生.如果你的socket立即开始通过连接读或写,就应写一个OnConnect事件Handler去作这件事. </P><P>B.服务器端事件(server events)
: Q- t4 p" {$ [+ q5 n( n1 @# o服务器socket控件通过两中方式连接:监听连接和连接到客户应用.服务器socket收到这两个连接的所有事件. </P><P>监听时事件
5 S5 U+ H, }7 q! x当构成监听连接前,OnListen事件发生.在这个时候你能够通过socket属性获得server windows socket object.你能够使用它的SocketHandle属性去改变socket,在socket打开监听之前.例如,如果你想限定监听服务使用的IP地址,你可以在这个OnListen事件Handler中做. </P><P>与客户端连接的事件
0 |8 w1 q7 r* s) o2 ]当一个服务器socket同意一个客户连接请求时,接下来的事件发生:
/ Z! Q, n# T$ G2 f% i1.服务器socket产生一个OnGetSocket事件,通过windows socket handle传送给连接的另一端的socket.如果你想提供自己定义的TServerClientWinSocket of descendant,你可以在OnGetSocket 事件 handler中建立,将被用来替代TServerClientWinSocket. ! x* d& E' b+ I5 _+ @; p
2.一个OnAccept事件发生,传送新的TServerClientWinSocket对象给事件句柄.这是第一个要点,当你使用TServerClientWinSocket的属性去获得被连接中服务的那端的客户的信息时.
) {2 c; ?7 H+ M" Y S9 U) _3.如果服务类型是stThreadBlocking,一个OnGetThread事件发生.如果你想提供自己定义的TServerClientThread子类,你可以在OnGetThread事件句柄中建立一个,它将替代TServerClientThread.
$ M& i3 F% ? n6 m z( a* Q4.如果服务类型是stThreadBlocking,一个ONThreadStart事件发生当这个线程(thread)开始执行时.如果你想执行任何初始化这个线程,或调用一些windows socket API在这线程开始通过连接读和写之前,应该使用OnThreadStart事件句柄.
0 f7 I5 ], T9 r' ^# H' q' z. e# X5.当客户端完成一个连接时,一个OnClientConnect事件发生.如果是non-blocking服务,你可能想开始通过socket连接在这端进行读或写操作. </P><P>六、通过socket连接进行读和写 9 _/ r. N; I2 v3 U, A) ^
通过socket连接到其他机器的原因是想通过这些连接来读和写信息.什么信息是你要读和写的,或者当你想读和写时是依靠哪些socket连接的相关服务的. ; s. L1 U- |* R' ~+ y$ T! g
通过sockets进行读和写可以是异步的,所以在你的网络应用中不需要阻塞其他代码的执行.这是调用non-blocking connection.你也同样可以通过blocking connection,这时你的下一行代码的执行必须等到读或写操作完成. </P><P>A.Non-blocking连接,读和写是异步的, 所以在你的网络应用中不需要阻塞其他代码的执行.建立一个Non-blocking连接:
) Q# R0 u7 _2 K/ t1.在客户socket中设置ClientType属性为ctNonBlocking.
- L0 d! J# ~$ |6 @: m) i1 E2.在服务器socket中设置ServerType属性为stNonBlocking.
! c3 A' }. ]3 G# a当连接是non-blocking时,连接的另一端企图读或写时读和写事件将把这个信息通知你的socket. </P><P>读和写操作事件 / o+ u% }' A. `! r
Non-blocking sockets想通过连接读或写时,它会产生一个读和写操作事件通知你的socket.在客户端sockets,你可以在OnRead或OnWrite事件句柄中对这些事件做出反应.在服务器端Scokets,可以在OnClientRead或OnClientWrite事件句柄中对这些事件做出反应.与socket连接相关联的windows socket object在事件句柄的读或写中被当作一个参数.Windows socket object提供一个方法号(number of methods)以允许你通过连接读或写.
7 ^$ l: S2 x) ~通过socket连接读,使用ReceiveBuf或ReceiveText方法.在使用ReceiveBuf方法前,使用Receivelength方法去确定在连接的另一端socket准备发送的字节数(number of bytes).
( Q* l8 R. G# K8 ]) @, l# T5 Y通过socket连接写,使用SendBuf,SendStream,或SendText方法.如果你通过socket发送信息后不在需要socket连接,你可以使用SendStreamThenDrop方法. SendStreamThenDrop在写完所有的信息后将关闭Socket连接,它能够从stream读信息.如果你使用SendStream或SendStreamThenDrop方法,不要释放Stream object, socket在连接结束后会自动释放这个Stream.
& m2 Y' j/ F) X. k) N: _2 c2 D* y' h注意:SendStreamThenDrop将关闭一个独立的客户连接服务,而不是监听连接. </P><P>B.Blocking connections
7 Z8 |9 o% ^: o4 `当你使用的连接是Blocking时,你的Socket必须通过连接发起读或写操作,胜过被动的等待从socket连接发来的通知. 当你的连接末端的读和写操作发生改变时使用Blocking socket.对于客户端sockets,设置ClientType属性为ctBlocking 以便构成一个blocing connection.根据你的客户端应用想完成什么,你可能想建立一个执行线程去完成读或写操作,以便你的应用能够继续执行其他的线程,当它在等待通过连接读或写操作的完成.
& l6 S5 y) `3 \& K4 R$ p对于服务器sockets,设置ServerType属性为stThreadBlocking以便构成一个blocking connection.因为blocking connections在等待通过连接读或写信息完成时挂起了其他代码的执行,服务器socket控件通常产生一个新的执行线程给每一个客户连接,当ServerType设置为stThreadBlocking时.许多使用Blocking连接的应用都写使用线程(using threads.甚至如果你不使用线程,你可能也想使用(using) TWinSocketStream去读和写.
! n n* w1 q/ d, S" v. w& ]1)using threads B6 ]' Q6 q4 W2 w* F, n
当使用一个blocking connection进行读或写操作时,客户sockets不会自动产生一个新线程.如果你的客户应用程序没有什么事做,直到读或写信息完成,那么这正是你想要的.如果你的应用包括了一个用户界面,它还需要响应用户的操作,那么,你可能想产生一个独立的线程去读写.当服务器sockets形成一个blocking连接时,他们常常产生独立的线程给每一个客户连接,所以没有客户需要等待直到其他客户完成通过连接读或写操作.在默认情况下,服务器sockets使用TServerClientThread对象去实现为每个连接执行不同的线程.
1 i9 X* L) i3 lTServerClientThread对象模拟发生在non-blocking连接中的OnClientRead和OnClientWrite事件.可是,这些事件发生在监听socket上时,不是本地线程(thread-local).如果客户请求频繁,你将想建立你自己的TServerClientThread子类去提供一个安全线程(Thread-Safe)去完成读和写操作. ! s" f' E9 L. ^# p6 q
当写客户线程或写服务器线程时,你能够使用TwinSocketStream去做实际的读写操作. ; k; x+ l6 h% z/ `) N+ A
A)写客户端线程
6 u+ a- M$ g4 i z为客户端连接写一个线程,定义一个新线程对象,使用新线程对象对话框.你的新线程对象Execute方法的句柄的通过线程连接进行读写操作的细节,可以建立一个TWinSocketStream对象,然后使用它来读或写.
! L8 n2 A v4 ?使用你自己的线程,在OnConnect事件句柄中建立它.关于建立和运行线程的更多信息,请看Executing thread objects.
4 ~5 n3 j$ p' Y/ |( ~ k( t7 V例子:这个例子显示一个应用的客户线程在连接确定后向服务器发出写请求.
/ L' ?* Q/ f; x) M1 ?void __fastcall TMyClientThread::Execute()
3 c+ D! j/ }, e{
- B5 K. j4 ?( ^, m, L- S4 o4 J m5 Twhile (!Terminated && ClientSocket1->Active)
0 |# z2 Q+ `! |3 K6 j" }- I( u// make sure connection is active
5 B$ b5 J, F2 L6 `& Z; F; r{ 5 [6 E2 W* f4 ?! c' ?- u
try
3 N" p9 d% Y. m{
( O+ h+ U7 [( f3 k% NTWinSocketStream *pStream = new TWinSocketStream(ClientSocket1.Socket,60000); d( l; i9 Z; p- }7 o& W
try 6 M0 T+ o9 v" U* X3 s& q3 N8 D
{ 3 @/ L. J. y+ ~& p0 J" h
char buffer[10];
9 Q N. [- |2 M w) pGetNextRequest(buffer);
8 B4 L+ ?) T0 N; ]" Q% c// GetNextRequest must be a thread-safe method % m" g: i$ K$ C3 \4 h
// write a request to the server . y0 W( L$ e/ o3 Y: L, X! K
pStream->Write(buffer,strlen(buffer) + 1);
2 M8 U* S+ X5 Q1 p. c; \' M' C// continue the communication (eg read a response) </P><P>}
9 d% W2 l- a" K4 d* n3 r/ ?__finally </P><P>{ l+ x4 S/ T U: R2 V
delete pStream; 8 Y u8 O0 b4 B Z, j$ B; a
}
3 A. d0 W" X7 W7 Z+ h8 P" l* q} ; ]" C0 T/ Y$ e9 [5 U7 e
catch (Exception &E)
6 k* v* N! T. G+ y; j/ K. C{
( Q" u$ V# @$ l* @3 o/ P5 yif (!E.ClassNameIs("EAbort")) 5 p2 X' J( V; G# j3 r
Synchronize(HandleThreadException()); 1 A7 ~6 l* ^ }! P& b6 z
// you must write HandleThreadException
# O! _1 Z5 N0 Y: A5 s: N' _} 9 ^: n$ P) L! Y9 Q
}
$ X% }# P* F) @+ {" T& r2 [, `- X} </P><P>B)写服务器线程 ' e8 ?3 }; A' Z4 k) k6 w( _+ ~
服务器连接线程由TServerClientThread派生.因为这个,不能使用新线程对象对话框.替代的,手动声明你的线程如下: </P><P>class PACKAGE TMyServerThread : ' H8 p! @6 D0 r; T* P
public ScktComp::TServerClientThread 5 Q( G5 n$ }6 y( o3 l
{ ! h* T1 A+ J2 J( d/ c7 `5 G& J
public - b, A& A! A. _% S6 N8 {
void __fastcall ClientExecute(void);
7 e' D- I4 h: V: q} </P><P>注意你将用重载ClientExcute方法替代Execute方法.执行ClientExecute方法必须为客户端连接写一个同样的Execute方法线程.然而,当你从控件栏上放一个客户socket控件到你的应用上时来替代这个方法时.监听服务socket同意一个连接时,服务客户线程必须使用TServerClientWinSocket对象来建立.这可以利用共公共的CientSocket属性.另外,你能够使用HandleException这个protected性的方法,胜过
' ]( P2 q( _$ f你自己写你的thread-safe例外操作. </P><P>警告:Server sockets会缓存他们使用到的线程.确信ClientExecute方法执行一些必要的初始化操作,以便它们在最后执行时不致于产生不利的结果. </P><P>当你使用你的线程时,在OnGetThread事件句柄中建立它.当建立线程,设置CreateSuspended参数为false. 1 D! m' t \, q0 v) U
例子:这个例子显示一个为一个应用服务的线程,这个应用是在连接确定后由客户端来的读请求. </P><P>void __fastcall TMyServerThread::ClientExecute()
K# G" q) A4 J* }! s{ 2 @- \" a+ N4 l# u, a" A/ e
while (!Terminated && ClientSocket->Connected)
& m2 I% a s5 m6 N" L' k3 B, }// make sure connection is active
( d$ b) v% U8 m7 N{
! @$ x" o# o: x/ ?/ z$ Itry 2 l8 ^; J7 ^( @: m+ E. U7 B
{ # J2 n3 }0 }6 g
TWinSocketStream *pStream = new TWinSocketStream(ClientSocket,
4 S! h- R8 }: y! T60000);
/ z. I4 z. d1 k% [! ^ G. ptry
" x6 N; ]0 y# W, s- d. [{
8 c: e- q$ `! `8 G) l. ?0 j: ~! cchar buffer[10];
6 v' v( v% z: B. a. E, ^memset(buffer, 0, sizeof(buffer)); 1 I4 S% W) O4 v" _/ C
if (pStream->WaitForData(60000)) * Z' l2 Y9 X$ R
// give the client 60 seconds to start writing
# _+ S6 t6 E4 E3 K8 Q( } Y{ ! ^+ q$ _' j4 X& m/ w* f
if (pStream->Read(buffer, sizeof(buffer) == 0) </P><P>ClientSocket->Close();
$ [: t2 J" H* s1 z' G// if can't read in 60 seconds, close the connection , U: k0 a: e6 h" n9 T4 E; Y
// now process the request
* }% p) t6 y1 x} - M, H# r6 \+ @* W* O+ m
else
9 u) b# n' b% {/ gClientSocket->Close(); : P" r) m4 y ~
} * G+ M3 q( M0 Y% N6 y
__finally </P><P>{
4 e' G: |2 f# ?1 D$ J: q( z1 Edelete pStream; # J! ^: u8 k, x5 ~
}
, Q- D& D8 R9 k& A, l( B} ' c6 A7 R( w5 v: t( M- p! t- R
catch (...)
7 }3 c( H/ M7 C# A$ w/ A: r: R x{
# ]5 J" j2 [: S" p' ^8 AHandleException(); & O2 s- K; H: j
}
' }3 l( n6 M4 q" ^# f} # X2 R8 s/ f) J9 b6 l( Z# E
} </P><P>C.使用TwinSocketStream 8 y1 o4 `' E: U* t( ?( I+ I
当为一个blocking连接实现一个线程时,你必须确定在连接的另一端的socket是准备写还是读.Blocking连接不会通知socket当它准备好写或读操作的时候.想看看连接是否准备好,使用TWinSocketStream对象.TWinSocketStream提供一个方法去帮助调整读或写操作时间的选择.调用WaitForData方法去等待,直到socket另一端的
+ Q" B4 d# D" C" X5 w/ V1 B- k% W5 P/ R准备好写操作.当读写操作使用TWinSocketStream时,如果读或写操作在指定的时间期限内未能完成,Stream将发生超时.这个超时被当作一个结果,socket应用不会暂停,而是不断的通过一个dropped connection试图读或写. </P><P>注意:你不能在non-blocking连接中使用TWinSocketStream </P> |
|