[转帖]C++ Builder 高手进阶

ilikenba

<DIV class=HtmlCode>C++ Builder 高手进阶
0 E, O8 _8 k0 N7 o* L8 p5 T（一） 编写弹出广告杀手
. y$ w- A2 ^2 B
8 v: c# \5 U  S( q; Q& ^<a href="mailtnxyc_twz@163.com" target="_blank" >nxyc_twz@163.com</A>

一、系统分析
- v) y7 P& W3 a) g1 c+ Y) C- f
作为一名软件开发人员，必然会经常上网查找资料，可讨厌的广告真让人心烦。有没有办法自动关闭这些广告呢？答案是肯定的！也许你会说：“网上这类软件多的是，随便找一个不就行了？”，你说的确实不错，可作为一名软件开发人员，总不能什么都靠别人吧？自己动手作一个如何？说干就干，首先得找出弹出广告窗口的工作原理：
* e  N/ X9 M( `4 g; t! ?0 v) @
8 x% S7 ]% q( _1． 使用自己的《系统窗口分析器》（在下一期讲述其开发过程），轻易地就发现弹出广告窗口的特征：其窗口类是CabinetWClass或IEFrame。
! W- x; ~( b" g* @& {  K+ U  M- R* B: t
2． 如果找出窗口类是CabinetWClass或IEFrame的窗口，向其发送WM_CLOSE不就OK了吗？心里不由一阵窃喜！

3． 使用定时器定时进行检测，找到符合条件的窗口就向其发送WM_CLOSE消息。

二、实战前沿
. K% U, U; C2 M, Z8 C
道理讲明了，可如何找到窗口类名呢？这就需要使用API函数了：
! W/ h2 `% j: V0 k' Y
GetWindowText ：取得窗口文本

GetWindow ：取得窗口句柄
5 ?+ q! z+ M! _4 H( g
5 n% `/ h# j5 v. X% V8 M" IGetClassName ：取得类名

0 U1 w* v: \. [% G5 H/ }  S1 e. GPostMessage ：发送消息

1 s9 T% Y8 n4 h6 [SetWindowLong ：设置方式
2 B" v; @4 S; A/ G' p6 B$ n. y
具体用法请查阅相关资料。

- z- ~- m0 l3 T1 I5 r* M5 w* y三、设计流程

! h4 g5 T' `. y* I* ~1． 启动C++Builder 5，新建一个Application，将Form的Name设置为Form1，其BoldStyle设置为bsNone，在Form的Icon中设置好图标。

2． 定义数据变量：
2 [) Q3 x; k+ _, W
$ ?' C+ ~. n( @4 j0 `TRAYICON_ID = 1;
, b9 j' R! t- f' ^% f, U
ICONEVENT = WM_APP + 100;
! N8 S* N# J, @% ~
TNotifyIconData TrayIcon ;
- l9 ~2 |5 a3 B6 @" @+ o
8 N0 B: Y2 f: u; N& X3． 拖放一个Timer控件和一个Popmenu控件到窗体上。Timer的属性：Name-&gt;Timer1，Interval-&gt;1000；Popmenu1上追加三个子项：继续-&gt;ContinueCmd，PauseCmd-&gt;暂停，ExitCmd-&gt;退出。

4． 使应用程序进入系统托盘：void TrayIconCmd(void);
2 ], b; L* w1 ^  ~0 @" S
TrayIcon.cbSize = sizeof(TNotifyIconData);

9 z* r8 j3 f$ ~- v0 k+ s# u4 cTrayIcon.hWnd = Handle;

% S: ]1 l8 e9 U. U7 Q  S, @TrayIcon.uID = ID_TRAYICON;

3 v/ X6 b+ ?& o; C( ~TrayIcon.uFlags = NIF_ICON | NIF_MESSAGE | NIF_TIP;

( g- t7 d# k$ ?/ f% Z9 l, GTrayIcon.uCallBackMessage = ICONEVENT;
5 o* Q% ?6 o" q8 ^5 V
; q- F' j3 I) G* S" P. x, ^TrayIcon.hIcon = Form1-&gt;Icon-&gt;Handle;
1 |, ?8 q' Q' D/ x" E/ m7 M
$ m& k$ a9 H+ i* o1 i* g  l/ JTrayIcon.szTip = “广告窗口杀手”;
3 Y; H0 ^7 d$ ^$ k" k3 u& h
Shell_NotifyIcon(NM_ADD, &amp;TrayIcon);
1 i+ b" ?7 b( z" a! g- w, o
* U0 q% Z% }- q1 c5． 使应用程序退出系统托盘：void TrayIconExit(void);
* o2 V7 i5 u  z/ v8 f' I) X8 G, [
8 d, h( S3 s1 b* I& gShell_NotifyIcon(NIM_DELETE, &amp;TrayIcon );
5 O8 y- l& j1 w3 ?6 ?! r! B/ e
! n, V9 r, _, A% o: H! ]/ W0 Y" g6． 使应用程序启动后直接进入系统托盘：编写Form1的OnCreate事件

TrayIconCmd(); //在系统托盘中安装图标
: q0 F  Z9 O" {: I" V* J
6 d3 J0 d6 U  UWidth = 0;

SetWindowLong(Application-&gt;Handle, GWL_EXSTYLE, WS_EX_TOOLWINDOW);

7． 从系统托盘中卸载图标：编写Form1的OnClose事件
! S' m  @2 }0 R/ r( A& }* z
TrayIconExit();

+ a" x: l, U: _" ]/ w! W8． 自定义消息TrayIconOnClick：

7 L6 G0 j# }5 ]( g# J, i在头文件.h中定义：

private:
4 @4 v8 L7 w# c, G1 L( B6 A* g  h- i
MESSAGE void __fastcall TrayIconOnClick(Tmessage &amp;message);

BEGIN_MESSAGE_MAP
# c- i/ v+ O' l# D
3 Y! A/ ?. p! k# ?MESSAGE_HANDLER(ICONEVENT, Tmessage, TrayIconOnClick);

9 c, ~, A8 n$ P, d1 H# mEND_MESSAGE_MAP(Tform)
. h7 ~& s! m# W9 Z
9． 鼠标点击系统托盘图标(TrayIconOnClick)，则弹出菜单：
$ X2 h9 E" b4 E# r4 K
/ Y* t% n7 D) \. h/ L( j6 c6 I4 ~' tTpoint p;

$ v8 q% P( Y& p& F, _if( message.lParam == WM_LBUTTONDOWN ||

message.lPram == WM_RBUTTONDOWN)
/ O. ~2 ]3 g7 `, k0 W8 @
/ ]" |/ P) \# B* k: b{

PopupMenu1-&gtopupComponent = Form1;

0 Q% U3 o! w" I* k2 ?* u& v7 PSetForegroundWindow(Handle);
% u1 z+ E4 i# r' i; A5 w
GetCursorPos(p);
) l3 d: }- e; P
1 R7 N9 j8 n  o6 e8 TPopupMenu-&gtopup(p.x,p.y);
( N1 ?: D- W" h& W2 S" Y4 k
2 D9 Z+ k+ c8 U" c}
% W, a( ~* J, U
6 ^# C8 u1 m  T( |" R10． 枚举指定窗口句柄的所有子窗口：void MENumChildWindows(HWND hand);
: h5 J1 F( `! S
- Z4 ~, c4 M7 k0 z2 Vchar tempstr[255];

bool IsPopWindow = true;

HWND h = GetWindow(hand, GW_CHILD);
  X5 L3 E4 h, [$ }4 R
" g# O; d- g  ]) x- t& R7 h$ Vwhile(h)

# W# o/ j4 a& s  [7 J: S{
$ @8 p6 ?4 B. K  o+ M) i
8 }8 r6 M3 H# c3 NGetClassName(h, tempstr, 256);

4 Z+ s# G2 d2 u# P# Tif( !strcmp(tempstr, “WorkerA”) || !strcmp( tempstr, “WorkerW”))

! C% w! `4 @9 \  K# S3 Uif( IsWindowVisible(h) ) IsPopWindow = false;
. L; T7 v# V9 i
1 A/ N3 q3 s$ k& i" U: _" Oh = GetWindow(h, GW_HWNDNEXT);
; c' }% U3 d  ?1 O
* N9 s; J% b  K( n, x}

if( IsPopWindw )PostMessage(hand, WM_CLOSE, 0, 0);

  q' q* \" Z& n, Q" W. B  J11． 双击Timer控件，添加其事件OnTimer：
" i6 s9 d% g2 ?4 Z  R
char Text[255];

8 f% ?+ k1 E0 fHWnd h := GetWindow(Handle, GW_HWNDFIRST);
0 e+ H7 X) C( p7 k
. ~0 {1 b- W$ U1 S3 ^- Iwhile(h)

, H% y! ~$ x8 [9 S9 d{
8 N9 b5 G9 c) w- j4 v* Y
if (GetWindowText(h, Text, 255) &gt; 0)

3 a8 y3 d( ]" u, E8 H1 m; uif (GetClassName(h,Text , 255)&gt;0)

4 n& F5 b! n% |: W" ?! Yif ( !strcmp( Text, “CabinetWClass”) || !strcmp(Text, “IEFrame”))
& G- R4 i/ D3 b4 y9 L
EnumChildWindows(h);

4 y! X4 h, c9 R9 Z( oh = GetWindow(h, GW_HWNDNEXT);

}

  t0 ~6 E+ U6 Q* A8 F9 U12．编写菜单响应事件：

" T2 G9 l% V/ ?+ n( B* ^ContinueCmd：继续
! E# |0 Z! E3 n5 X! N
8 D$ d, t1 w. b. ^; TTimer1-&gt;Enabled = true;

PauseCmd-&gt;Checked = false;
- c  l5 g0 g; e$ F1 A' Z: H/ e
ContinueCmd-&gt;Checked = true;

PauseCmd：暂停

5 J" W) T* j2 D- b8 E3 CTimer1-&gt;Enabled = false;
' H) ~6 b/ d# G% i
PauseCmd-&gt;Checked = true;

ContinueCmd-&gt;Checked = false;

ExitCmd:：退出

Close();

3 {) W5 i2 B! g& Q
$ ^- G# q6 f* K0 q1 q# u
1 l) x- P/ n2 F7 w（二）系统窗口分析器
* P5 z" z% N; o" R7 i0 o
7 c* \, d. Y: g5 `<a href="mailtnxyc_twz@163.com" target="_blank" >nxyc_twz@163.com</A>

记得《超级解霸》作者梁肇新先生曾在电脑报上发表过系列文章《开发手记》，写的极有深度，令我获益匪浅。其在文中称，每次要写一个新功能或新的界面时，总喜欢用spy++对现有类似软件进行分析，可非常容易地得到其采用的什么类或什么消息机制，从而可轻而易举地模仿出相关的功能。我在具体的软件开发工作中，也经常这样做，有时确实可起到事半功倍的作用。但本篇不是教你如何使用spy++，而是要教你如何自己编写一个类似于spy++的软件。
+ h8 S8 I( q0 i4 \; \
一、 系统分析

要实现spy++的功能，首先要知道如何获取当前窗口句柄，以及当前窗口类。程序中主要使用定时器实现实时窗口句柄采集。
4 q8 D* a* n& q& [0 N1 w' o
; Q4 g! S4 ~- j4 `) h二、 开发前沿

这里用到的API函数有：
* [8 k1 Z& ~) }# ~& i
SystemParametersInfo：取得指定的系统参数
4 A" _  ]8 @& U9 S5 H0 ^
8 m! A6 A6 p1 ?SetWindowPos：设置窗口位置

: j( N+ G" a2 _: ^) ^GetCursorPos： //获得光标的位置
4 }! C- {2 ]0 x: n0 _; Q
# I: J: d1 M( u, h+ }$ f. UWindowFromPoint： //取得光标位置的窗口句柄

GetClassName：//获得类名
( E4 t7 p/ ^0 M6 X+ B! e
8 r! u9 c, O5 d( q6 u3 }( s( hSendMessage： //获得窗口信息

三、 设计流程
$ B" f& Y6 o2 A! k8 I1 F
1．初始化应用程序窗口，使其总显示在最顶层：
+ e& @  s- e5 s9 t3 l
void __fastcall TSpyForm::FormCreate(TObject *Sender)
" x' N- r  t5 P" B% |  C, M: z. @% c: W
{
9 o" }1 |( o- q) H: ?& q
//初始化
) {+ _" E! r! `/ d, C' W
TRect R;

//取得桌面大小，并计算出程序窗口的位置
" Y7 s. e/ S. `- g9 w
SystemParametersInfo(SPI_GETWORKAREA,0,&amp;R,0);
6 {. U2 ~7 d4 Q3 t# o& r
& ^' j. n" ]: c3 w6 u6 ~. C! CLeft = R.Right - Width; //窗口左上角列坐标

Top = R.Bottom - Height; //窗口左上角行坐标
. O% p, |$ e+ O# [
( J$ j5 {0 |9 x) r/ ASetStayOnTop(this, true); //设置为总在最前面显示

}
. \* g0 A& K0 k; ]; |5 ^  i
* G: D; x) f) e! y" e% [2．相关设置为总在最顶层显示函数：
& m& n7 Z7 Z: s# D  a: a
void TSpyForm::SetStayOnTop(TForm * Form, bool Value)

6 f9 j2 W- B5 t) [5 o3 U{
. b- W- d0 v& ?9 |  s
//设置窗口是否总在最前面显示

4 H- E" r: c5 X$ W, \7 b5 hif ( Value )SetWindowPos(Form-&gt;Handle, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE);
. C, e0 \) y  D" {8 w+ ?
else SetWindowPos(Form-&gt;Handle, HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE);
9 V+ y1 V# I( l3 B; N
}

3．定时器响应函数：

9 \3 F  b# g$ n/ M$ lvoid __fastcall TSpyForm::TimerTimer(TObject *Sender)
  ^" U" c$ G/ H  i
- ~5 G: ]9 r/ L9 N  r{
4 _- q; U' ^4 z% H& l/ U
+ C' z. f4 A7 I) ?4 L" ~//用定时器每隔0.1秒进行一切判断，以达到系统信息的实时显示
; T" l' o4 Z6 g
TPoint Pos;
/ V. O: }. M& p8 o, P6 y- U5 P
7 U7 I0 `3 x3 }+ Y0 cHWND Handle;

9 y7 i# {$ i8 I- V" Vchar Buf[1024];

# t' W, q; s! I' _6 Y! C# aGetCursorPos(&ampos); //获得光标的位置
/ }7 ]/ ?2 a3 i) F7 p! O6 l
8 i1 h8 q; ^2 g% q0 g8 JHandle = WindowFromPoint(Pos); //取得光标位置的窗口句柄

) N. S4 K: f4 I; {& NHandleEdit-&gt;Text = IntToStr((int)Handle); //显示窗口句柄
- h( T* X# e- J% y' j, |9 O
GetClassName(Handle, Buf, 1024); //获得类名
# ]6 D- f) J+ G, J+ ~$ Y2 ?
$ a' i- j3 c2 S! E# \% T4 B- I- _ClassEdit-&gt;Text = Buf; //显示类名
/ m* W! x- f" t5 c- r6 x& H8 e
/ I! u: t- y7 v) P0 ~SendMessage(Handle, WM_GETTEXT, 1024, Integer(&amp;Buf)); //获得窗口信息

% F2 c& ~2 Y8 V% b: }$ vTextEdit-&gt;Text = Buf; //显示窗口信息
, B& j0 g  s, K
& _; q0 v8 d5 {+ v$ U6 i6 P' L7 ?}
) L4 w6 P0 J+ M1 |) |
4．设置是否在最顶层显示：

void __fastcall TSpyForm::OnTopCheckBoxClick(TObject *Sender)

* Y1 a, m$ ^1 l{

//设置最前面显示
! ^% E" e# i% A; @" q0 P8 ?8 \
9 Y7 ^: `5 `$ T* X& s/ S, VSetStayOnTop(this, OnTopCheckBox-&gt;Checked);

}
* F; b2 N6 U  N3 r1 ~0 B% Y

6 Z2 e& c& X& E4 R! X' S（三）用BCB设计DBTreeView组件
, G; ^( L# L5 P0 r/ a

1 c+ ?6 F: s+ V5 l8 ?
一、 系统分析

现在使用BCB的以越来越多，可是你有没有意识到，你所使用的控件究竟有几个是用C++编写的？答案肯定让人无法忍受，既然无法忍受何不亲自操刀写一套属于BCB自己的组件呢？我希望从我开始，众位高手能同心协力，共同打造真正属于BCB自己的组件！我不想讲述BCB设计组件的基础知识，因为这些在《C++Builder 5开发人员指南》中有详细的介绍。

我们所设计的DBTreeView派生自TtreeView组件，因此它将具有TtreeView组件的一切特性，我们要做的就是使其具有数据感知能力，与数据直接连接进行直接通信。要构造Tree形结构，我们应使每一个节点具备如下特征：每个节点有一个唯一标识符ID和一个父标识ParentID，（最顶层节点的Parent为空）为了显示相关内容，则还需要一上显示字段FDisplayField。该组件的工作原理已经很清晰了：通过每个节点的ID与ParentID定位数据记录，然后将相关字段内容赋给FdisplayField显示。

二、 开发前沿
& f7 P5 m3 h2 M  @. T$ C5 q( i
该组件中最重的技术莫过于数据感知了，下面就介绍一下数据感知 技术：
: p4 t. ^2 M- ^5 p0 M+ \
要使某个组件成为数据感知的，我们必须给它提供所需的数据连接以便和数据训数据成员通信，这个数据连接类是TFieldDataLink。数据感知组件有其自己的数据连接类，数据连接由组件负责创建、初始化和销毁。建立连接通常需要3步：

1． 将数据连接类（TFieldDataLink）声明为组件的成员；

2． 声明适当的读、写访问属性；

" e" L  d, H+ Q( f3． 初始化数据连接。

# m  j- l# V+ u7 G9 T- ^3 z4 T" s三、 设计流程

//DBTreeView头文件

& Q' p8 d* }4 H% W" f/在头文件中添加以下三行，因为/数据连接类需要这三个头文件中的声明

+ T( u) \& d5 ]! D#include &lt;Db.hpp&gt;
& `+ f4 r% S( u
8 f+ S7 c6 d0 |/ u/ ^2 t#include &lt;DbTables.hpp&gt;
) D& t& ^/ ?8 b
, u/ L) C; Y6 a/ I/ ?#include &lt;DbCtrls.hpp&gt;

//定义事件，用来响应设置节点位图事件

typedef void __fastcall (__closure *TDBTVSetImageIndexEvent)(System::TObject* Sender, int ID, int ParentID, int Level, int&amp; ImageIndex, int&amp; SelectedIndex);

//定义节点结构

2 L1 m  i. H; b) W/ @: S% F3 z6 Xstruct TDBTreeNodeData

{

int ID; //节点唯一标识
, t+ o/ Z2 @+ T
" _9 V( {8 e& ^+ c: kint ParentID; //节点父标识，它为空时表示此节点是最顶层节点

};
, G) T+ A* G0 @  X5 L( U& ?
' e! g7 |# T  Y& p

6 p) {/ a! o* q+ gclass PACKAGE TDBTreeView : public TTreeView

: a, w  A3 Y9 f9 g% B# B# v) i{

' A; |: X4 d% _' L7 l: zprivate:
9 p$ h' \) M! w3 F7 A3 N
0 ~0 J, l, B7 X6 OTFieldDataLink* FDataLink; //声明数据连接成员

AnsiString FParentIDField; //父标识字段
2 }6 x5 \3 K7 k2 t' e
AnsiString FPrimaryIDField; //主标识字段
4 a) g4 u2 z5 k. t  ]) M
AnsiString FDisplayField; //显示字段
& k0 H& O, B; W4 u' C
bool FActive; //是否为活动状态
6 k  [8 ~* ^1 a6 n
* `( n2 Y$ d9 Y1 }# W9 Ibool FAllowModifyDB; //是否允许修改
9 B+ U- p1 P3 }" \' R
- w3 U3 S5 P6 m; Y, k% W8 @TDBTVSetImageIndexEvent FOnSetImageIndex; //声明事件



void __fastcall SetActive(bool Value); //设置状态

void __fastcall SetDataSource(Db::TDataSource* Value); //设置数据源

TDataSource* __fastcall GetDataSource(); //取得数据源

, }- A+ C- k! m6 b
/ c, r/ R: z& T& M' }8 M; S
: H% c& w% p8 @' z* U# }: Evoid __fastcall ClearAllNodes(); //删除所有节点

3 y5 g7 {2 J% G: [& U) z7 Avoid __fastcall FillTreeNodes(int ParentID, TTreeNode* Node); //填充节点

void __fastcall FillChildTreeNodes(int ParentID, TTreeNode* Node, bool Nest = false); //填充子节点
  G$ Y; Q$ u  K" Y+ O- B$ d  K
" M3 g' }, u$ E7 qvoid __fastcall AddDataToNode(TTreeNode* Node, TDBTreeNodeData&amp; Data);//追加数据到节点
: }$ b. b# S) X. A! r- x
protected:

//以下以个方法用来重载TreeView的相关方法
, x* U3 m$ B3 e% k4 Z
0 z* x, ?" ]2 m7 V( F$ ?virtual void __fastcall Loaded(void); //Load方法
. C9 L  I/ C5 l
& v4 U$ H7 d# g& ~0 K! c: \virtual void __fastcall Notification(Classes::TComponent* AComponent, Classes::TOperation Operation); //事件

DYNAMIC void __fastcall Edit(const tagTVITEMA &amp;Item);//Edit方法
# T( I! ?) B5 b' V
DYNAMIC void __fastcall Expand(TTreeNode* Node);//Expand方法

DYNAMIC void __fastcall KeyDown(Word &amp;Key, Classes::TShiftState Shift);//键盘事件

8 b, C- W4 k# X) [9 A# PDYNAMIC void __fastcall Change(TTreeNode* Node);//节点改变事件
+ D. k- E- ^% h3 A- C! q! v
' J- e7 r& N, o3 |' evirtual bool __fastcall CustomDrawItem(TTreeNode* Node, TCustomDrawState State, TCustomDrawStage Stage, bool &ampaintImages);//自绘节点事件
- F+ P& T( C0 }( k7 k


public:

__fastcall TDBTreeView(TComponent* Owner);//构造函数
9 X0 r: y9 x/ ?% m0 M$ D3 ~( D; r
, N- \- n' l* X% S; @__fastcall ~TDBTreeView();//析构函数



TDBTreeNodeData __fastcall GetNodeData(TTreeNode* Node);//取得指定节点数据
0 p8 E  \' `! q) n# c
void __fastcall FullExpand(void); //展开所有节点
6 M- f+ x. X1 F+ o1 `/ Y0 {
__property bool Active = {read = FActive, write = SetActive};//属性活动状态

__published:
& t! W; A1 b+ Y* [) N
//以下定义在属性编辑器中用到的几个属性

3 \* ]- N( [' C3 q__property bool AllowModifyDB = {read = FAllowModifyDB, write = FAllowModifyDB};//是否允许编辑

__property AnsiString ParentIDField = {read = FParentIDField, write = FParentIDField};//父标识
/ v, F# h7 X7 r/ y
& C4 G0 ^& t, y* A- q, o__property AnsiString PrimaryIDField = {read = FPrimaryIDField, write = FPrimaryIDField};//主标识

1 D9 X. U" F: G5 h' s__property AnsiString DisplayField = {read = FDisplayField, write = FDisplayField};//显示字段

4 f, J. {. t& E. Q__property TDataSource* DataSource = {read=GetDataSource, write=SetDataSource};//数据源
$ S! F' U* u0 [9 _; U/ \
4 z8 a* j/ @! A__property TDBTVSetImageIndexEvent OnSetImageIndex = {read=FOnSetImageIndex, write=FOnSetImageIndex};//设置节点位图事件
, s1 s0 ~( D4 O: X7 E
7 D, I" A/ C; s7 e8 Q};

//下面的类用来填充字段列表

6 I6 P  e4 H  b/ o5 ~8 ?class TFieldNameProperty : public TStringProperty
/ k( G& {4 S& f! e  w" S1 H: M8 X' v! ?
- h: N; I& q% i+ T' R+ A{
2 [! M" h; i5 }: `7 P# S1 Z5 ^6 y
public:

TPropertyAttributes __fastcall GetAttributes(void)

{
! y) H: X( _6 L! w; A
2 g( P. u& ]  R/ o+ P2 B" ?. Yreturn TPropertyAttributes() &lt;&lt; paValueList;
/ [, `, \3 c! W0 I+ [( v
! n. I+ I& W. F}



void __fastcall GetValues(Classes::TGetStrProc Proc);
' Q  R2 h$ Z- V9 l
9 H. }, t" _$ ^2 ^};


（三）用BCB设计DBTreeView组件（续一）
$ K$ @+ H. _) I" b$ o+ X
& _1 W& {+ v. Z: q
//DBTreeView详细设计.CPP文件

__fastcall TDBTreeView::TDBTreeView(TComponent* Owner)

: TTreeView(Owner)
. |) J. w* R* q' a1 o0 P
- Y  l4 X8 `# C5 `  Q{

4 c* v# i% y, w0 x% W" z6 z//在构造函数中对相关数据进行初始化

/ U  ~; C' t6 yFDataLink = new TFieldDataLink; //建立数据连接类
8 \! @8 a& q7 F
; L) ?8 y/ t& L; G8 h- v& XFParentIDField = ""; //将节点父标识设置为空
* d; ]2 {& L/ e7 s% m
FPrimaryIDField = ""; //将节点主标识设置为空

( X6 M, a4 p8 G# B" M! \- l* B! J+ ~FDisplayField = ""; //将显示字段设置为空

FActive = false; //设置为非活动状态

! t% P, c# }5 d% N" XFAllowModifyDB = false; //设置数据集不允许修改

}
$ x% R, U0 Z- i3 R
. n  P  h3 y) G__fastcall TDBTreeView::~TDBTreeView()

{//在析构函数中释放构造函数分配的资源

delete FDataLink; //释放数据连接类

}

void __fastcall TDBTreeView::SetActive(bool Value)

, C# S" U2 a! W* e3 T3 l5 Y6 u& ?{
6 J" `. _7 J+ H) @& E1 m
0 N: g( p3 w. l! ]- l: f: B//设置状态是否为活动

* ?9 H. _, l9 f. ?% m$ aif (FActive != Value) //如果指定状态与当前状态一样，则不做处理，直接返回
, `: N% S3 @# k: c! _
{//否则
, H0 \# b! [- K8 I
0 `1 ~5 h" r, F8 v" z2 I0 s# vif (Value)//如果指定值为true则
) ], z7 x. W1 B. E- f, m9 p
1 k$ A" g$ a; }, x! j: C8 e/ B{

if (FDataLink-&gt;DataSource == NULL)//如果未指定数据源则抛出一个异常
% Y9 J" J: ^; ?9 U' f# H" u
5 @. o  H1 g8 [, y' Sthrow Exception("Missing DataSource property.");
! m( N, V/ A3 Z3 k9 n- c# X+ q, z7 ~
if (FDataLink-&gt;DataSource-&gt;DataSet == NULL)//否则，如果数据源中未指定数据集，也抛出一个异常
) @* E1 R8 F# H* ^6 O0 b
. k+ D  a$ [6 }+ lthrow Exception("Invalid DataSource.");
9 i7 J4 W1 E( N4 H- O1 F- K: E9 \) F


& H/ y0 h* z% [$ Q  g, e3 tif (FParentIDField == "")//如果父标识字段为空，抛出一个异常

9 P3 V7 ?; R; B6 kthrow Exception("Missing ParentIDField property.");

' Y0 m; F- Y  A( vif (FPrimaryIDField == "")//如果主标识字段为空，抛出一个异常
9 ^! T+ ^/ r7 b
# n" c4 {/ x3 q0 ?: xthrow Exception("Missing PrimaryIDField property.");

- [3 j& x9 q4 ?+ iif (FDisplayField == "")//如果显示字段为空抛出一个异常

; T3 z+ \: D/ U$ L8 k8 Cthrow Exception("Missing DisplayField property.");

* j7 x& P8 Z0 Y7 N//补充说明：从以上几个异常您应该不难看出我们这个组件需要的环境：
. P/ K: W: h) |' m
' j% o+ [8 k9 W; M% ]1 X$ u//必须指定数据源，数据集，节点父标识字段，主标识字段，显示字段
' X1 a% @- C* j/ c) R
+ {/ j  x, R) a2 m2 d9 C; aClearAllNodes();//删除原来所有节点

, V+ A$ P% ^, b& XFillTreeNodes(0, NULL);//填充所有数据到各节点
' S" ~+ d3 G$ h. b! G) Z& f
}
& l, N+ u& o7 {, [, e; v
else
5 e6 L5 ]' C% e. u
{//如果指定值为false则
$ _; s  |0 K6 W
ClearAllNodes(); //删除所有节点

8 P$ u4 J$ g  |0 i  o, I( e}
/ P' I- z1 h% K8 s+ C9 q) L7 p$ g
FActive = Value; //将指定值赋给FActive
+ Q4 ]4 y/ K" T! H+ [
}
# J% m$ l% V/ C) {8 e! S) f1 X
}

void __fastcall TDBTreeView::SetDataSource(Db::TDataSource* Value)
/ l- _5 \0 g% W8 |
{//设置数据源
+ w4 I/ C# g8 f$ L6 j+ ^6 A" @
if (Value != FDataLink-&gt;DataSource)//如果指定值与当前值不一样，则
2 e  M2 e4 P+ ?$ ]& ~9 Y
{
2 F' A) q0 m" Q1 p% M, f
1 ~1 _8 N1 n0 l$ S6 eFDataLink-&gt;DataSource = Value; //将数据源当前值设置为指定值

1 o% C: t  H: D4 l* \! v5 a}
) j+ x1 X! V( \4 [) U) P
5 `. A4 \3 I. C) X2 O: B: A9 Y' S}

TDataSource* __fastcall TDBTreeView::GetDataSource()
# I4 h7 _* I5 G+ d
{//获取数据源

return FDataLink-&gt;DataSource; //返回与数据源

. @! h9 {: ]. ^" Y5 D7 Y}

void __fastcall TDBTreeView::ClearAllNodes()

+ k4 t! G. s5 M% g; Z{//删除所有节点,调用TreeView的相关方法进行遍历式节点删除

for (int i=0; i&lt;this-&gt;Items-&gt;Count; i++)

+ b* B0 D9 O1 D! A: c7 Mdelete (TDBTreeNodeData*)(Items-&gt;Item-&gt;Data);

; \. _  ?; `$ G

; D! D1 H+ }" Gthis-&gt;Items-&gt;BeginUpdate();
( P! n, ~* Y. Q
this-&gt;Items-&gt;Clear();

this-&gt;Items-&gt;EndUpdate();
$ e' m) [9 L2 B. }' g, t
+ V! l, |, |" W/ p1 u}

4 n1 b" X8 ^! K/ Bvoid __fastcall TDBTreeView::FillTreeNodes(int ParentID, TTreeNode* Node)

{//填充数据到节点

TQuery* AQuery = new TQuery(this);//创建一个数据集控件

AnsiString strSql, strText;
: O; J0 h% i2 L
int iID, iParentID;
, p# w' K! q. f* H) Y# w) X4 o
# z) b% L! U) B  n9 x+ G2 ]int iImageIndex, iSelectedIndex;

TTreeNode* TreeNode;
4 p% ^# o2 O$ T& {  P' _
TDBTreeNodeData NodeData;

* I# h9 E0 Q1 T; S//用指定条件打开相关数据表
  a7 `# E. _7 s3 ]3 b" _# @% ?
7 z+ p6 m& v* EAQuery-&gt;DatabaseName = ((TTable*)(FDataLink-&gt;DataSource-&gt;DataSet))-&gt;DatabaseName;

! T; O8 _/ W7 m+ D3 ?0 ~AQuery-&gt;Close();//关闭数据集

AQuery-&gt;SQL-&gt;Clear();//清空原查询条件



/ Y/ K# F$ U0 M, ~6 H& ZstrSql = "SELECT * FROM " + ((TTable*)(FDataLink-&gt;DataSource-&gt;DataSet))-&gt;TableName + " WHERE ";
( [/ e6 x( K' H
/ \$ B. D0 j% A9 r' C1 \( ustrSql += FParentIDField + "=ID";
- e# ]( s% }) f0 y& C


AQuery-&gt;SQL-&gt;Add(strSql);//指定新的查询条件

1 d! b- B: L  k  _( V& TAQuery-&gtaramByName("ID")-&gt;AsInteger = ParentID;//取得父标识字段内容

AQuery-&gt;Open();//打开数据集
" n/ E3 I0 I7 ]! k$ K

9 J* i: c  |+ c
this-&gt;Items-&gt;BeginUpdate();//准备更新DBTreeView显示
9 X/ @. n3 m; f( @4 O/ l
( ?$ E9 e0 }- p$ m* \( Z! Y) ?
3 i" c1 }  l$ ~4 \
while (!AQuery-&gt;Eof)//数据没有到数据集尾，则

{
7 S6 Y# ]+ [1 s7 f
strText = AQuery-&gt;FieldByName(FDisplayField)-&gt;AsString;//取得显示字段内容
2 e5 }# v; p3 p# l' H! V" E: r
iID = AQuery-&gt;FieldByName(FPrimaryIDField)-&gt;AsInteger;//取得主标识字段内容
% y' [8 J5 |! q' r' \
# y( m  x' C2 y. }# f( j( ~* WiParentID = AQuery-&gt;FieldByName(FParentIDField)-&gt;AsInteger;//取得父标识字段内容
" p6 A3 }" o3 M" F. Y* }! ~- t2 i6 |
8 t5 h1 O2 l% {

TreeNode = this-&gt;Items-&gt;AddChild(Node, strText);//添加此子节点

; @3 w3 k3 h1 ^3 {; SiImageIndex = iSelectedIndex = -1;//将节点位图与选中时位图设置为空（-1）

if (FOnSetImageIndex) FOnSetImageIndex(this, iID, iParentID, TreeNode-&gt;Level, iImageIndex, iSelectedIndex);//如果位图设置发生变化，则触发相关事件

TreeNode-&gt;ImageIndex = iImageIndex;//设置节点位图及选中时的位图

TreeNode-&gt;SelectedIndex = iSelectedIndex;

7 n' e* U8 y' R2 w: b+ ^
  Y2 ^& j% t) |: w
NodeData.ID = iID;//设置节点标识及父标识
( i/ |& ~$ C: I) [, K6 b
NodeData.ParentID = iParentID;
2 x1 V. c, e; ~0 C( d6 Z$ [9 i4 \
4 ~8 v4 J( N6 X! t' m+ bAddDataToNode(TreeNode, NodeData);//追加数据到指定节点
/ h# `6 ?4 n0 j0 u+ J' P


0 ?( o2 ~; K( t4 V4 zFillChildTreeNodes(iID, TreeNode, false);//填充子节点

AQuery-&gt;Next(); //移到下条记录
+ c) ?8 F6 \3 M* \( Y1 [
}
9 e; A7 k5 L" f2 U( V
1 `, u" Q8 q6 _
( l& u1 ]6 V! T' S- C4 y
' a/ \) f9 E, K4 V6 p5 A9 F. O) Wthis-&gt;Items-&gt;EndUpdate(); //更新DBTreeView组件


  b/ A8 _9 B) g
/ h8 S; `, ?/ k; D% HAQuery-&gt;Close(); //关闭数据集
2 e/ b1 j3 e0 }& ^
/ d5 n) s* H4 H5 Q; Cdelete AQuery; //删除临时创建的数据集控件

; v. |2 W3 v. ?1 F+ ]$ i8 K- [* _}
# m0 C0 l& q: F2 [1 Z
（三）用BCB设计DBTreeView组件(续二）

; s' x1 f, {9 G0 j8 @void __fastcall TDBTreeView::FillChildTreeNodes(int ParentID, TTreeNode* Node, bool Nest)

& G$ u! i( W0 c0 l, Q, T2 z: w% `{//用指定值填充子节点
" _* P6 |$ s; h! D: y
TQuery* AQuery = new TQuery(this);//创建一个数据集控件
  @1 j4 }; a, V, `/ U+ {
AnsiString strSql, strText;
; J# }) q3 p* d4 D
int iID, iParentID;

int iImageIndex, iSelectedIndex;
" M: f* x' U& d9 B- B+ e! Q' ]% }
- o3 `, u$ u  v1 zTTreeNode* TreeNode;

TDBTreeNodeData NodeData;

//设置数据集的各项参数
+ b# ^  B/ _& X3 p4 G. O
) G  E$ y: n" X! O# `AQuery-&gt;DatabaseName = ((TTable*)(FDataLink-&gt;DataSource-&gt;DataSet))-&gt;DatabaseName;//设置数据库名
  G; T: U; d6 M! ^1 \3 x7 J
& [3 ]- s2 C1 Z# h( v$ VAQuery-&gt;Close();//关闭数据集

6 v3 u% K5 u5 U6 S% `AQuery-&gt;SQL-&gt;Clear();//清空原SQL语句
3 \  \; C. I5 E) F' b( {% q
  x$ w! e, h9 K: y5 ]( {% }1 s

- @0 r# _* v  D& E4 J. p, fstrSql = "SELECT * FROM " + ((TTable*)(FDataLink-&gt;DataSource-&gt;DataSet))-&gt;TableName + " WHERE ";

; m) j2 ~9 r% M( ostrSql += FParentIDField + "=ID";
6 _, e3 B1 O& y. l% v' Q6 J9 Y
; U0 ?: a' E5 G4 j2 I- K# J$ X" H3 V

/ w7 X% X  r: w4 _7 T6 h9 d" ]AQuery-&gt;SQL-&gt;Add(strSql);//指定新的SQL语句

AQuery-&gtaramByName("ID")-&gt;AsInteger = ParentID;
* B' d- x3 j. j6 O2 U/ ^
AQuery-&gt;Open();//打开数据集
" k& I& u; a5 |" m8 R4 T4 b


  {. v- C! l2 p0 x2 ^, vthis-&gt;Items-&gt;BeginUpdate();//开始更新DBTreeView组件显示

& \+ R  m% F" x
) \, B' {3 v, C) P& _% j7 l) u9 T2 T, h
while (!AQuery-&gt;Eof)//未到数据集尾部

{
& ]0 S9 R' S: T' ^& p
strText = AQuery-&gt;FieldByName(FDisplayField)-&gt;AsString;//取得显示字段内容
, K3 P1 l5 U+ f2 C1 O
9 M( N. \) N- i9 AiID = AQuery-&gt;FieldByName(FPrimaryIDField)-&gt;AsInteger;//取得主标识字段内容
& I4 Y  a% q3 R+ G- \4 ]1 L
iParentID = AQuery-&gt;FieldByName(FParentIDField)-&gt;AsInteger;//取得父标识字段内容

+ j" P" B/ r. u2 ^

TreeNode = this-&gt;Items-&gt;AddChild(Node, strText);//将上面取得的相关数据追加到新节点
: t2 Z+ ]% b' Z, d1 W: Q8 ~  j
' A* M* z5 T$ n% N# A- n& C8 t% z$ yiImageIndex = iSelectedIndex = -1;//设置节点位图与选中时位图
8 ]5 P( l. q5 i/ ]% d
if (FOnSetImageIndex) FOnSetImageIndex(this, iID, iParentID, TreeNode-&gt;Level, iImageIndex, iSelectedIndex);//如果设置位图发生变化，则触发相关事件

3 C5 _) \; U* ^. MTreeNode-&gt;ImageIndex = iImageIndex;//设置节点位图及选中时位图
2 V+ K: n* q) V  G/ A
TreeNode-&gt;SelectedIndex = iSelectedIndex;
4 x" d1 n+ q" T& i
" t, N% t# G5 x1 L3 M, ?

NodeData.ID = iID;//取得节点主标识，父标识，并按其追加一个新节点

NodeData.ParentID = iParentID;

AddDataToNode(TreeNode, NodeData);


1 c+ ~) F3 V" V' P! `
) `, d& a. Y+ f6 E9 Aif (Nest) FillChildTreeNodes(iID, TreeNode);//如果指定参数Nest为true，则递归调用以填充所有子节点
: v# |7 v3 g" d, o' W
5 @! ?/ S/ \% w) l: aAQuery-&gt;Next();//移动到下一条记录
# M3 D) z& C% a* S% G' `. \' }
- o! t! s( c. R- w/ f/ g4 L' l}



this-&gt;Items-&gt;EndUpdate();//结束DBTreeView组件更新


; h/ `1 W  Z  c
AQuery-&gt;Close();//关闭数据集
3 ^& Q4 r* u/ U, @4 _# ?
3 x7 B0 P/ U1 ~3 Q) ?9 w  d8 v% Idelete AQuery;//删除临时创建的数据集控件

" m( L& L7 y) J; j  }) o}
, |8 m2 x, y  {7 ]" J& D: _
void __fastcall TDBTreeView::AddDataToNode(TTreeNode* Node, TDBTreeNodeData&amp; Data)
/ S9 Q5 L9 u+ y5 y9 a0 M
{//追加数据到节点
, ]# H# F, f% U+ A- T& W
TDBTreeNodeData* pData = new TDBTreeNodeData;
5 E$ ?' R' |9 k- s. [# L
" T# R) e# F- w: Q. d7 I*pData = Data;

Node-&gt;Data = pData;

}
) _% M! Q. s- o* F5 p& F; I+ g9 B
$ V$ l; O4 i: D8 f$ I: g//---------------------------------------------------------------------------
! m1 m" J* O3 T0 D+ x
TDBTreeNodeData __fastcall TDBTreeView::GetNodeData(TTreeNode* Node)

{//取得指定节点的数据
4 }* ^8 f; X; n: s* }( s& t
return *(TDBTreeNodeData*)(Node-&gt;Data);
5 O# V0 ^5 }# S" T2 v( y" D
1 K! j' f% |& ^  t! Q7 ]4 s, w}

; Z' ?# x1 P, x" J( @- Y1 V//---------------------------------------------------------------------------

void __fastcall TDBTreeView:oaded(void)
5 H9 P. N5 e( k9 }2 H# X; x
{//调用原Load方法
, v+ c3 L7 p7 L5 T
TCustomTreeView:oaded();

/* TODO : Loaded */
8 v# E9 ?- v0 G# o  E6 r3 ~8 a
}
+ H9 H) a+ ?+ P; x$ Y
//---------------------------------------------------------------------------
3 h" w8 ~$ g- z+ p1 f$ x
2 }( d1 f: E3 e3 \4 E& n4 rvoid __fastcall TDBTreeView::Notification(Classes::TComponent* AComponent, Classes::TOperation Operation)
( z' Y6 c& D$ b, O0 @
6 p' L5 A' e9 L& O0 E  g{
' j8 R6 W8 a& s, [0 K* I# f8 U: O
1 @2 h3 u' ]" s! `//事件响应

TCustomTreeView::Notification(AComponent, Operation);//调用原方法

if ((Operation == opRemove) &amp;&amp; (FDataLink != NULL) &amp;&amp; (AComponent == DataSource))//如果操作为opRemove以及数据连接不为空且指定组件为数据源，则

DataSource = NULL;//使数据源为空
) C) V" e1 Y# K  i4 G2 y
}

# i# s0 Z, W- x$ O//---------------------------------------------------------------------------

void __fastcall TDBTreeView::Edit(const tagTVITEMA &amp;Item)
# U( N' H0 U/ e' Q5 p
{//编辑节点

TCustomTreeView::Edit(Item);//调用原方法
# ]* a  R$ [" D! t7 m5 z: v' A( c


if (FAllowModifyDB)//如果允许修改，则

{
) v, n! H. D3 O% I* E1 K: g; k7 z" h1 \
3 V( o" n; u# k) s1 eTTreeNode* Node;
( p0 h0 i: i# K' m( J
AnsiString DatabaseName = ((TTable*)(FDataLink-&gt;DataSource-&gt;DataSet))-&gt;DatabaseName;
9 k5 G* S1 z  k7 E" y$ T2 l6 E
AnsiString TableName = ((TTable*)(FDataLink-&gt;DataSource-&gt;DataSet))-&gt;TableName;

TDBTreeNodeData NodeData;
, i. a: {, j# O# R6 i
TQuery* AQuery = new TQuery(this);//新建一个数据集

- I% U$ W* j6 }; X7 nAnsiString strSql;

  J( |4 t. _" {1 @8 i8 i7 U+ s
# e* u2 z% G& T9 `( j' ]
if ((Item.state &amp; TVIF_PARAM) != 0) Node = (TTreeNode*)(Item.lParam);
3 _# R1 D$ l3 f* s  ?! t
else Node = Items-&gt;GetNode(Item.hItem);
4 ?, o( {9 F1 I( z+ f1 _

0 {4 H8 S! J9 v$ ~
- y4 M; y1 O' F8 n! v" wNodeData = GetNodeData(Node);

strSql = "UPDATE " + TableName + " SET " + FDisplayField + " =:NewDispText WHERE " + FPrimaryIDField + "=:ID";//用指定条件更新数据集
  w5 Q! m1 q- b' V1 I9 b, }  h* `

" G8 |& G# B2 k2 l
6 h8 t& O: e( x4 @AQuery-&gt;Close();//关闭数据集

AQuery-&gt;DatabaseName = DatabaseName;//设置数据库连接

AQuery-&gt;SQL-&gt;Clear();//清空原SQL语句

AQuery-&gt;SQL-&gt;Add(strSql);//追加SQL语句

AQuery-&gtaramByName("NewDispText")-&gt;AsString = Node-&gt;Text;//对SQL中的参数进行赋值
( [( ~7 B8 t" i7 R" j% ^+ O, J" K
AQuery-&gtaramByName("ID")-&gt;AsInteger = NodeData.ID;

AQuery-&gt;ExecSQL();//打开数据集
. i) E- h8 @8 H' c, g
, o/ o  l0 d/ d2 v- X2 v6 e7 P! Z6 G5 U

' y0 N# C' |- {6 P5 A' fdelete AQuery;//删除临时创建的数据集控件

}
" E- e2 j. P* ?: l; D
" d0 Z" s1 W0 Z: k}

3 P6 o& _2 ^. [+ J; y. c//---------------------------------------------------------------------------
$ e. n3 D: U  K" K4 T1 Y
+ Z0 L* [/ E5 d4 o! N1 X- Jvoid __fastcall TDBTreeView::Expand(TTreeNode* Node)

{//展开指定节点
# R. i0 [) x& R  d
TCustomTreeView::Expand(Node);//调用原原方法
) a- c0 U6 f1 D0 U2 E# i0 a

5 ~1 T" p  d/ [  m: G
4 L1 v( w) K2 Z$ t+ dTDBTreeNodeData NodeData;

, A/ I: u4 M- ~+ P3 }TTreeNode* ANode;



) o  o. ?8 e! ?) R7 e# [/ vfor (ANode = Node-&gt;getFirstChild(); ANode; ANode = Node-&gt;GetNextChild(ANode))//遍历指定节点的子节点

{

% H6 X6 n- A. A/ W' K/ i' s& }NodeData = GetNodeData(ANode);//取得节点数据
& C5 \3 F; ~( H2 C4 U
5 y. Z* P+ o6 ^if (ANode-&gt;Count == 0)//如果节点数据为0，则填充其子节点
# ~1 [2 u& _9 R" h
8 F1 @. V7 P- j& ^3 n2 LFillChildTreeNodes(NodeData.ID, ANode);

}
1 [+ i& E9 Q% _. D2 K. D
}

//---------------------------------------------------------------------------
% N0 H( V' r, l
void __fastcall TDBTreeView::KeyDown(Word &amp;Key, Classes::TShiftState Shift)
) l3 U* M: W) N  A# L" a
8 N. O& x; l. P6 @7 }{
& Y+ Z- W6 U. Y9 Q% _9 }7 I+ T5 Y
//键盘处理

TWinControl::KeyDown(Key, Shift);//调用原键盘处理方法


) h5 C5 _# ?) E! V% l
if (Key == VK_F2 &amp;&amp; Shift == TShiftState())//如果是Shift+F2则
" b' B+ D1 V5 w6 }6 e
  G: G3 M: o8 S# w# P{

8 H' b$ d. o& P0 k" H/* Handle 'F2' key */

if (this-&gt;Selected != NULL)//编辑当前选中的节点

6 T( H' W, w5 t3 t+ O; m8 H! P: ithis-&gt;Selected-&gt;EditText();

}
, }! N+ J$ H6 e( b/ ~! N, H
}
9 v4 e) K. F  j. }/ ?" ?, v
1 V# ~5 G( @, H+ t3 q//---------------------------------------------------------------------------
; R7 q3 T8 U! @1 C8 x  b
- Q0 H# j+ G, t; O' M$ Y7 lvoid __fastcall TDBTreeView::Change(TTreeNode* Node)

{//处理节点发生变化事件

/ Y1 u. ^2 X% s: G1 DTCustomTreeView::Change(Node);//调用原方法

/ t0 x- _/ J9 ]! M+ z" Jstatic TTreeNode* OldNode = NULL;
9 K  Q# r) t* s7 q" s9 X/ r
1 V* y$ w! ]. l6 V& d& r( g+ T: ]" DTTreeNode* SelectedNode = this-&gt;Selected;//取得已选节点指针

TDBTreeNodeData NodeData;

TTable *ATable = (TTable*)(FDataLink-&gt;DataSource-&gt;DataSet);//指定数据集
' M" i' w8 \, b9 O0 [
1 v+ U% A3 G4 T! l& l/ ~/ e

if (OldNode == SelectedNode) return;//如果旧节点等于选中的节点则直接返回

if (ATable == NULL) return;//如果数据集为空则直接返回
7 H5 a% E/ b% e0 z+ Z9 d) x
if (SelectedNode == NULL) return;//如果没有已选节点则直接返回

NodeData = GetNodeData(SelectedNode);//取得指定节点数据
( _3 T7 X, I* X* _) w! c% p) Z
ATable-&gt;SetKey();//按指定条件查找数据记录
; R! ~, p' w1 M/ k+ Q
4 W6 w9 W- i- @) m* c  AATable-&gt;FieldByName(FPrimaryIDField)-&gt;AsInteger = NodeData.ID;

ATable-&gt;GotoKey();

OldNode = SelectedNode;//旧节点等于现在已选节点

6 c! j* `- I  k9 I! `}
' M' z; E, R& D9 j: y
//---------------------------------------------------------------------------
& _& V5 X  ~1 R% n) v
bool __fastcall TDBTreeView::CustomDrawItem(TTreeNode* Node, TCustomDrawState State, TCustomDrawStage Stage, bool &ampaintImages)

{

. M+ p, d; x. r! Q; V/ }9 R//自绘节点

bool Result;//调用原自绘方法

$ q) u! H% Z( C- Y1 X% F# EResult = TCustomTreeView::CustomDrawItem(Node, State, Stage, PaintImages);
- r6 L' o% [3 @4 O4 ?" q3 D
1 k7 E4 g2 E7 A5 ~

/* TODO : ... */

$ G/ U- v5 v" t2 G4 r! m0 ?' N8 r/ ?//TDBTreeNodeData NodeData = GetNodeData(Node);

8 X" X& J, d+ w3 d1 R- C+ M  Lreturn Result;
. o* T; A$ E; N
1 f' V. g# Z5 h* i' ]' [}
' k& x/ v) s3 V* h3 \- n# b
) i' X$ \: u% H- ~6 ?. r//---------------------------------------------------------------------------

& }% E; I" q7 x% R% V, n+ Pvoid __fastcall TDBTreeView::FullExpand(void)
8 x' O' q+ @! z- w% d) V, ?
' D0 i- `; ]; n0 C( Y5 ]# i$ ~" N{//展开所有节点

% Q9 J5 P+ _  c5 ^4 iif (!Active)//如果DBTreeView不是活动状态，则抛出一个异常
) p( E, `8 q" v: V8 i
throw Exception("DBTreeView is Inactive.");

1 G, i  n; u8 y* |- Bthis-&gt;Items-&gt;BeginUpdate();//开始更新DBTreeView

ClearAllNodes();//清空所有节点
- S1 ?# h8 L6 h! \: u% Q3 h% S  P
FillChildTreeNodes(0, NULL, true);//填充子节点
& y0 s3 H! h' }% P
this-&gt;Items-&gt;EndUpdate();//结束更新
! m9 J/ [! q* J8 ~. V4 h1 z! b
/ W+ h+ a9 M+ n- fTCustomTreeView::FullExpand();//调用原方法实现展开所有节点

}



//---------------------------------------------------------------------------
8 ]/ Y+ x7 M/ q% O5 i1 @
void __fastcall TFieldNameProperty::GetValues(Classes::TGetStrProc Proc)

{//取得字段值

int i;
, g" ?5 c& L6 H* I
/ ]1 Y  E0 Y9 B- I" X% x6 fTDBTreeView* ADBTreeView;
  k4 k* [- A3 e& |, [6 T

; ]# [. Q, T7 z3 y% _* b
' m  }" \- o0 QADBTreeView = (TDBTreeView*)GetComponent(0);
: ~" j( C$ V" e* C* a* E/ c- J
0 K4 Q0 U9 t# y9 l9 U& ]/ {if (ADBTreeView-&gt;DataSource != NULL)//如果DBTreeView的数据源不为空，则
2 s+ r$ U4 t$ \# G/ d/ V+ ?
{//遍历所有字段，并将其填充到相关字段属性中

for (i = 0; i &lt; ADBTreeView-&gt;DataSource-&gt;DataSet-&gt;FieldCount; i ++)

3 A1 T: ]3 e& P" [( vProc(ADBTreeView-&gt;DataSource-&gt;DataSet-&gt;Fields-&gt;Fields-&gt;FieldName);
3 o; F  n# g' i6 A7 ^$ M( E
" R9 W/ M( q4 W/ A* H+ Z}
; ~+ P7 {- j! b9 o( U
else

) s  z5 D# V: s$ r- `8 l) T{//否则抛出异常
4 j0 W% C# |! q3 t; I3 B
throw Exception("Missing DataSource property.");
7 h- R4 K# `: Q# D
6 g# U$ c, \; e$ i/ g: N3 M" N$ k}
/ G# q+ K! q3 h, T1 @5 o
8 }# S- |* [& m, U  |: T% b: q: v}
0 O- X( U( e! P- v0 \! Q
TTypeInfo* AnsiStringTypeInfo(void)

) y9 }4 f; x3 P) n! N{
! m' v( G2 Y, w4 Q2 g
//定义类型信息
) k( m% C: Y0 P  A6 F
' e& Z  s5 p% e. P9 ^6 M; V- ITTypeInfo* TypeInfo = new TTypeInfo;

$ q- ~% M' g3 F* ATypeInfo-&gt;Name = "AnsiString";

* R8 I" V; ]9 X* o- o: F: zTypeInfo-&gt;Kind = tkLString;
9 ^  g# F& ?# b- J+ M- r
5 y3 J( L4 w# @return TypeInfo;

/ {9 M1 i3 W% g! X# ]4 X) r0 f# ^7 T9 ^}


（三）用BCB设计DBTreeView组件（小结）
# [3 e$ F% @7 K8 i5 y! x& o版权声明：CSDN是本Blog托管服务提供商。如本文牵涉版权问题，CSDN不承担相关责任，请版权拥有者直接与文章作者联系解决。

5 V1 i0 l9 x5 }" D+ _
9 I! A( S9 U# e) B, J- w$ |
用BCB设计DBTreeView组件小结

, R. w7 o9 N* b" R# ]4 a( K续二的最后一个函数，你是不是感到很纳闷：这个函数到底是用来干什么的呢？下面听我慢慢道来：我使用这个函数主要是用来实现定制属性编辑器。细心的读者一定还记得，我设计的控件中有三个关键的数据成员：ParentID,PrimaryIDField,DisplayField，这三个成员的函义是什么？相信不用我多说。为了使它们的设置更人性化，我选择了用下拉框的方式显示它，而其具体内容则由数据表中的字段而来，那么很自然我便采用了TFieldNameProperty，通过对它的定制，我实现了属性编辑器的定制。

: a8 {2 b4 U6 {2 \; ]TTypeInfo* AnsiStringTypeInfo(void)
! u* s: E; w: b% ~' I
{
& @( e+ R+ L2 i9 i2 l& c
2 J4 p0 W' h& Y( {9 Y//定义类型信息
( q7 P; e$ R  _6 @, d) ~
( w) K5 a6 l3 J7 @  dTTypeInfo* TypeInfo = new TTypeInfo;

$ ]8 Y$ P1 y. q3 v& B3 lTypeInfo-&gt;Name = "AnsiString";
, R7 K. D0 a9 p* \, ~8 b, u
TypeInfo-&gt;Kind = tkLString;
, L% g- Q2 b( [( w- P+ d
return TypeInfo;
. d& v: d% ~2 b6 q
}
( N$ t' F" l' O8 W
namespace Dbtreeview
8 O% h! Y1 J& F" B" b) _* P* `) D8 B
{

( ~1 @2 J. Q6 _: b//注册组件

. @2 l, s0 Y9 i# K4 z6 t9 ?6 }void __fastcall PACKAGE Register()
0 W% u9 |+ d+ `
{
6 ?' Y& Z1 S0 ?. h
RegisterPropertyEditor(AnsiStringTypeInfo(), __classid(TDBTreeView), "arentIDField", __classid(TFieldNameProperty));//注册属性

4 ?! L' T) P) ], mRegisterPropertyEditor(AnsiStringTypeInfo(), __classid(TDBTreeView), "rimaryIDField", __classid(TFieldNameProperty));//注册属性

/ g; Q2 r$ O7 b) ]' GRegisterPropertyEditor(AnsiStringTypeInfo(), __classid(TDBTreeView), "DisplayField", __classid(TFieldNameProperty));//注册属性
5 p, v3 \% A2 a, T
TComponentClass classes[1] = {__classid(TDBTreeView)};

# ~* a2 n/ T6 R, A( e( D. i& rRegisterComponents("Data Controls", classes, 0);//注册组件
) P0 ]; y! E5 u2 `
}

8 u$ ?3 T' |$ ^+ C+ G}

到此为止，我已给出了用BCB实现DBTreeView的所有思路及代码，不知您感觉如何？要是觉得好就给点鼓励；要是觉得差，您也可以直言（好像是江湖卖艺^），我希望大家共同进步！
; n4 J4 t7 N8 |5 a
通过对这个组件的编写实践，你应该会用BCB进行一些组件的开发了吧？这里我再总结一下该组件设计中的要点，并为您以后设计组件提供一点建议：

1． 编写一个新的组件，首先要考虑从哪派生。你需要熟悉一下VCL结构，大致各种可视组件、不可视组件、窗口组件等的继承关系。建议你看看《C++Builder 5开发人员指南》和《C++ Builder 深度历险》。
8 B8 j6 \5 w" U; e+ Z
+ v/ @" m* ]) m( A2． 事件定义。事件其实就是某件事情发生时要做的处理，以DBTreeView中定制带参数的方法为例，我阐述一下定义的件的方法：

: U0 W4 [- C7 ptypedef void __fastcall (__closure *TDBTVSetImageIndexEvent)(System::TObject* Sender, int ID, int ParentID, int Level, int&amp; ImageIndex, int&amp; SelectedIndex);
* L: V  i" D$ {) c4 p% W5 d6 z
' I' R$ q8 T8 K5 @& BTDBTVSetImageIndexEvent是自定义的事件类型，ID,ParentID等是事件所需的参数。那么就可以这样定义事件：

4 ^8 U" b- Y+ a& ?Private:

( U& p6 g& Z) Q9 NTDBTVSetImageIndexEvent FonSetImageIndex;

__published:

__property TDBTVSetImageIndexEvent OnSetImageIndex = {read=FOnSetImageIndex, write=FOnSetImageIndex};

3． 定义消息。虽然我的DBTreeView中没使用消息，但消息的作用绝不容忽视。在BCB中定义消息的方法如下：
/ X3 W1 J1 Q' q0 x& q. j! z% @
( G6 o/ U5 K: _9 mprivate:
, f( A1 E7 r# Z
void __fastcall OnMyMessage(Tmessage &amp;Msg);//定义消息函数
# C0 E! T$ `0 P$ e5 e
( r1 _$ S# D( Y- u4 C' O6 B$ |  X% L# WBEGIN_MESSAGE_MAP
) H6 c+ L4 ^) p1 k; H1 g* ]& t
MESSAGE_HANDLE(消息，消息类型，消息函数)

& t0 }+ A- {; W4 F) p+ jEND_MESSAGE_MAP(父类)
$ p4 B/ M4 r7 q0 G3 y
; ?4 L$ y. w. C+ f, Z" k* a
, @  O) {% j, |5 W: _# |（四）动态显示任务栏图标
3 P6 X% Y+ k# d& H0 X! v
; Q" O: h$ I+ F<a href="mailtnxyc_twz@163.com" target="_blank" >nxyc_twz@163.com</A>

* ]$ u% h2 `" W3 s& H7 f8 L' w  ~5 a在应用程序运行时，有时可能会因为要处理的数据量很大而暂时失去反应，这样给用户的感觉极其不好，影响了软件的更广泛应用。利用多线程技术固然可以解决这个问题，可这里我并想使用多线程，我想示范一下如何编制动态任务栏图标。
& e4 v8 c& B' M* p
　　我的编程思路是：通过设置Timer时钟控件使应用程序在规定的时间间隔内发送特定的消息，使任务栏图标不断更改，从而形成动画效果。实现方法为在应用程序的窗体中拖放几个Image控件，使他们装载相应的图画，几幅图画按顺序连续的被显示，就形成了动画。

" [. y9 W# Y, C1 D　　应用程序必须用发送消息的办法通知任务栏增加，删除,和修改图标。发送消息必须调用Shell_NotifyIcon。它的原形为：

　　WINSHELLAPI BOLL WINAPI Shell_NotifyIcon(
9 G, ?' `, e" e　　DWORD dwMessage, POINTIFYCONDATA pnid);
0 G2 N: U* P; s0 R  {! |  T- v
4 R* f! v8 \6 F+ Q* \, |　　第一个参数 dwMessage是发送消息的标志，可以选
　　NIM_ADD // 往任务栏通知区添加图标
( k: A" i4 A' C　　NIM_DELETE //往任务栏通知区删除图标
　　NIM_MODIFY //通知任务栏通知区修改图标

# v( w& t* y' I* x  F编制消息发送函数TrayMessage
' |7 Y' D9 J* ~+ nbool __fastcall TForm1::TrayMessage(DWORD dwMessage)
{
  A7 X7 w$ x" kNOTIFYICONDATA tnd;
PSTR pszTip;
2 B+ C7 I$ o7 gpszTip = TipText();
tnd.cbSize= sizeof(NOTIFYICONDATA);
. v" \! b+ g4 @7 Z; \//结构的大小
tnd.uCallbackMessage = MYWM_NOTIFY;
//自定义回调消息，在头文件中声明
9 W1 p" @, j0 s7 j4 K" i' M+ Q4 g# stnd.hWnd= Handle;
* a1 a; b2 l1 v) g//接受回调消息的窗口句柄
3 V' @; a" ^" a- W9 mtnd.uID = IDC_MYICON;
//图标标志号
' S* [7 U1 ?- d: ~; Z  T$ h+ Ftnd.uFlags= NIF_MESSAGE | NIF_ICON | NIF_TIP；
# P5 [, F  g( t# J8 N& v//指定以下三个参数哪个包含有效数据
if (dwMessage == NIM_MODIFY)
{
5 i; R5 z' w! l1 o4 N! v/ P% Wtnd.hIcon =
(HICON)IconHandle(); //取得图标句柄
if (pszTip)
8 _9 v  f" c+ f4 d( n) Jlstrcpyn(tnd.szTip, pszTip,
2 N2 J) y, r- f1 j$ o+ G+ d4 Qsizeof(tnd.szTip));
( K. x. W+ g% ?: ~2 C3 q8 gelse
4 p* x( f& ~0 D6 Z$ Utnd.szTip[0] = '\0';
2 d, x- ]1 e! m0 x& _* l5 d}
else
6 R* J) H" g1 u" M5 W) V- j# M( ^5 c{
tnd.hIcon = NULL;
tnd.szTip[0] = '\0';
}
return (Shell_NotifyIcon(dwMessage, &amp;tnd));
}
编制取得图标句柄的函数
6 {7 U( e* L2 {9 G+ _; F1 WHICON __fastcall TForm1::IconHandle(void)
& k/ n0 D8 ^# Z{
  f8 O# b! a9 Q, |4 Q+ C2 [if (n==1)
8 O2 C( j# V0 k8 L, z4 y5 E* @( i4 ^{ return (Image1- &gticture-&gt;Icon- &gt;Handle);
! b( z! U- j& ]/ Q; P5 K/ J//n是全局变量，1为显示Image1,0为Image2
- m+ m: g3 t! `! m}
else
{ return (Image2- &gticture- &gt;Icon- &gt;Handle);
}
' b6 S* s4 k, u5 i  W4 l6 T* _. o. X}
编制图标状态转换函数

! _1 I4 `& ~. s( b( D+ {void __fastcall TForm1::ToggleState(void)
{
- ]) n1 W7 @' o/ N8 W' ?if (n==1) //n为图标句柄锁，是全局变量，
( [" q3 R+ w, c7 _7 Z, m- H4 K1为显示Image1,0为Image2
{
n=n-1;
" M* m9 V; A# v' i$ `& w* P7 R}
9 b: K+ V2 A- Q! A; ]else
4 j& K1 I+ l2 l4 j, `& ?6 n/ J9 \3 o# S{
n=n+1;
. s! u9 b4 Y  o6 r}
, ?, t5 m$ }0 a% ?TrayMessage(NIM_MODIFY);
//发送图标变换消息
& |4 b" s" t9 f" O}

9 D4 {' E1 M; v$ D0 S' j: }
; ^1 `0 u1 }( U3 T, q% n- |- d　　对Timer控件编制代码，设它的Interval属性为1000，即定时器每一秒响应一次。为 Ontimer事件键入代码：

void __fastcall TForm1::Timer1Timer(TObject *Sender)
{ ToggleState( );
$ S# _, R, `" F- P}

; O8 N7 d% w  s+ J0 k2 c  Z1 p  y
& m2 b3 G9 z; n# {/ o  z0 `3 V（五）用BCB编写多线程应用程序

<a href="mailtnxyc_twz@163.com" target="_blank" >nxyc_twz@163.com</A>


9 m4 s1 ~. F, k: n. L3 E4 D　
( A6 N& o$ G2 G1 g6 M　　随着Windows系统的全球性普及，多线程技术已越来越多地运用到许多软件设计中。使用多线程技术可全面提高应用程序的执行效率。以前为了实现多线程编程，基本上都是调用一系列的API函数，如CreateThread、ResumeThread等，不容易控制，还容易出错。在使用BCB以后，我才发现原来编写多线程程序也可以如此简单！BCB为我们提供了强大的TThread类，从而使得多线程编程变得非常简便易用。下面请跟我一起开始我们的BCB多线程编程之旅。
) v& G% f$ f; m. `& d- Z( b( X7 u　　1. 创建多线程程序：
　　首先，我介绍一下BCB中编写多线程程序的具体步骤。
1 o# g! y" M4 `. v, {　　在C＋＋Builder IDE环境下选择菜单File|New，在New栏中选中Thread Object，按OK，接下来弹出输入框，输入TThread对象子类的名字NewThread，这样C＋＋Builder自动为你创建了一个名为TNewThread的TThread子类。下面是TNewThread的部分源码：
　__fastcall NewThread::MyThread(bool CreateSuspended)
  E8 ~# V$ \, A　　 : TThread(CreateSuspended)
　　{//构造函数，可用来初始化一些信息
　　}
) d' A9 c5 s8 y+ _2 _　　void __fastcall NewThread::Execute()
) x/ h8 L& y7 C　　{
/ J& m5 h% ^: j5 v5 S, A　　 //多线程程序的核心，用来执行相关多线程操作
" O+ ?2 l) h: q' {9 F  Z　　}

2 W/ |$ D5 i* U' k# E* D' r- QBCB中的Execute（）函数是我们要在线程中实现的任务代码所在地。使用多线程时，动态创建一个TNewThread 对象，在构造函数中使用Resume（）方法，具体执行的代码使用Execute（）方法重载的代码。如果想创建更多的线程，只需要创建需要数量的TNewThread 而已。
　　通过以上步骤我们基本实现了在程序中如何创建一个线程，并使程序实现了多线程应用。但是，多线程应用的实现，并不是一件简单的工作，还需要考虑很多使多个线程能在系统中共存、互不影响的因素。比如，程序中公共变量的访问、资源的分配，如果处理不当，不仅线程会死锁陷入混乱，甚至可能会造成系统崩溃。总的来讲，在多线程编程中要注意共享对象和数据的处理，不能忽视。因此，下面我们要讲的就是多线程中常见问题:
　　2. 多线程中VCL对象的使用
5 k; d; v: C4 c1 w2 m　　我们都知道，C＋＋Builder编程是建立在VCL类库的基础上的。在程序中经常需要访问VCL对象的属性和方法。不幸的是，VCL类库并不保证其中对象的属性和方法是线程访问安全的（Thread_safe），访问VCL对象的属性或调用其方法可能会访问到不被别的线程所保护的内存区域而产生错误。因此，TThread对象提供了一个Synchronize方法，当需要在线程中访问VCL对象属性或调用方法时，通过Synchronize方法来访问属性或调用方法就能避免冲突，使各个线程之间协调而不会产生意外的错误。如下所示：
- V  C* ?, _9 f6 X* m　　void __fastcall TNewThread:ushTheButton(void)
0 ^' `2 M2 ^: E1 \; s! ]0 H　　
　　{
) o* n# |, z: ~1 p" x6 k$ q　　 Button1－&gt;Click();
9 |, ]' h8 t) u/ l" x+ ^　　}
　　
4 [: N6 w$ M, P: r- v　　void __fastcall TNewThread::Execute()
　　{
　　 ...
　　 Synchronize((TThreadMethod)PushTheButton);
　　 ...
" C) `- q1 j0 S# N　　}
7 ^% b' v" y( i( g# P& g4 L　　对Button1－〉Click（）方法的调用就是通过Synchronize（）方法来实现的，它可以自动避免发生多线程访问冲突。在C＋＋Builder中，虽然有一些VCL对象也是线程访问安全的（如TFont、TPen、TBrush等），可以不用Sychronize（）方法对它们的属性方法进行访问调用以提高程序性能，但是，对于更多的无法确定的VCL对象，还是强烈建议使用Synchronize（）方法确保程序的可靠性。
　　3. 多线程中公共数据的使用
　　程序设计中难免要在多个线程中共享数据或者对象。为了避免在多线程中因为同时访问了公共数据块而造成灾难性的后果，我们需要对公共数据块进行保护，直到一个线程对它的访问结束为止。这可以通过临界区域（Critical Section）的使用来实现，所幸的是在C＋＋Builder中，给我们提供了一个TCriticalSection对象来进行临界区域的划定。该对象有两个方法，Acquire（）和Release（）。它设定的临界区域可以保证一次只有一个线程对该区域进行访问。如下例所示：
% y0 A" R" A9 F5 _7 H1 N　　class TNewThread : public TThread
　　{
　　 ...
　　private:
0 U+ b; C0 e* f! c( [1 p0 U" p& C　　TCriticalSection pLockX；
　　int x;
$ ?) M: _# X' E  y! b! y8 u　　float y;
6 _* }/ I- }" @* k4 A4 w　　...
) s  U1 w9 Q/ |2 z& ?. s. T　　};
　　void __fastcall TNewThread::Execute()
6 {4 `) I& S7 M* C9 m/ A, K. Z! W　　{
' }9 e- ^) T  w; l: {% M　　...
　　pLockX－&gt;Acquire();
　　x＋＋;
( y) l2 T; O, b1 X0 |　　y=sin(x);
7 Q' D# ~2 @3 G* M3 s) ~　　pLockX－&gt;Release();
　　...
　　}
3 `3 Q& k$ s4 g+ `( t$ n　　这样，对公共变量x，y的访问就通过全局TCriticalSection 对象保护起来，避免了多个线程同时访问的冲突。
　　4. 多线程间的同步
# u2 T5 l+ \$ y, K( r% J　　当程序中多个线程同时运行，难免要遇到使用同一系统资源，或者一个线程的运行要依赖另一个线程的完成等等，这样需要在线程间进行同步的问题。由于线程同时运行，无法从程序本身来决定运行的先后快慢，使得线程的同步看起来很难实现。所幸的是Windows系统是多任务操作系统，系统内核为我们提供了事件（Event）、Mutex、信号灯(semaphore)和计时器4种对象来控制线程间的同步。在C＋＋Builder中，为我们提供了用于创建Event的TEvent 对象供我们使用。
　　当程序中一个线程的运行要等待一项特定的操作的完成而不是等待一个特定的线程完成时，我们就可以很方便地用TEvent对象来实现这个目标。首先创建一个全局的TEvent对象作为所有线程可监测的标志。当一个线程完成某项特定的操作时，调用TEvent对象的SetEvent（）方法，这样将设置这个标志，其他的线程可以通过监测这个标志获知操作的完成。相反，要取消这个标志，可以调用ResetEvent（）方法。在需要等待操作完成的线程中使用WaitFor（）方法，将一直等待这个标志被设置为止。注意WaitFor（）方法的参数是等待标志设置的时间，一般用INFINITE表示无限等待事件的发生，如果其它线程运行有误，很容易使这个线程死住（等待一个永不发生的事件）。
/ n6 x/ y. c- I0 z  ?7 O　　其实直接用Windows API函数也可以很方便地实现事件（Event）、信号（semaphore）控制技术。尤其是C＋＋Builder，在调用Windows API方面有着其它语言无可比拟的优势。所用的函数主要有：CreateSemaphore（）、CreateEvent（）、WaitForSingleObject（）、ReleaseSemaphore（）、SetEvent（）等等。

+ Y% ~7 N1 c  c; X% p$ O+ @4 W（六）在IE工具栏中添加按钮

0 b7 A0 _: Y# L' H) E  j

9 U' ]3 X- w8 B浏览器IE是我们使用频率最高的软件之一，如果能将应用程序集成到IE中，必将极大地方便用户的操作以及提高软件的附加值。幸好Microsoft已为我们提供了相应的接口，这使得我们的工作变得简单而有趣。

一、系统分析

通过对注册表的分析、对比，可以发现，IE工具栏按钮的设置在注册表的位置：
7 j3 q. v1 }9 a! e6 Q8 h
; I/ p& j4 u* }; uHKEY_LOCAL_MACHINE\SOFTWARE\MICROSOFT\INTERNET EXPLORER\EXTENSIONS\

1 c! ^5 h2 a( z% R/ \这样我们就可以通过以下的步骤来实现我们的目标：向IE工具栏中添加按钮
7 z. Z0 E0 O6 ~; N" J
1． 在上述路径下添加一个主键，键名任意，比如设置为：5D13E8D2-850A-101B-ARC0-4210102A8DA7；

2． 在上述主键下添加以下几个字符串：
" q- y. P" f& e
n BUTTONTEXT：按钮显示文本

" A8 q9 C( _; Q1 {' _n CLSID：标识符，必须设置为：{1FBA04EE-3024-11D2-8F1F-0000F87ABD16}

n DEFAULT VISIBLE：设置按钮是否被显示出来
; I% U' f* T4 m+ \; @. n0 C* g9 r
- ]/ `6 ^9 O/ u# u' Qn EXEC：单击按钮后要调用应用程序
/ N' M7 m' N# n1 A5 p- H
n ICON：按钮图标
* v8 w$ i$ J: [% }- K+ P: C
6 M+ `# L0 X+ v2 F5 S2 bn HOTICON：按钮的浮动图标
1 P4 s- ~4 K& T; B; _9 i
6 q7 h: y$ Q9 r" Q4 n! y4 r" ?0 w9 h二、设计流程
0 S* F: G, v2 i8 U; E% j7 p2 E3 T5 y
TRegistry rg = new TRegistry;
. Z7 c9 _( u+ R4 |+ R/ t3 V% Y6 G
rg-&gt;RootKey = HKEY_LOCAL_MACHINE;

rg-&gt;OpenKey(“SOFTWARE\MICROSOFT\INTERNET EXPLORER\EXTENSIONS\{5D13E8D2-850A-101B-ARC0-4210102A8DA7}”,true);
' u! B4 n" g" k1 R8 R, ~
rg-&gt;WriteString(“BUTTONTEXT”,”按钮名称”);
, r8 e; c. a8 e1 w' ~, r0 U# d
rg-&gt;WriteString(“CLSID”,”{1FBA04EE-3024-11D2-8F1F-0000F87ABD16}”);

rg-&gt;WriteString(“DEFAULT VISIBLE”,”YES”);
: v# E) o$ t1 {7 \# B
- ]1 v6 s- T; \- s7 v' U9 {rg-&gt;WriteString(“EXEC”,”应用程序路径”);

" l: h+ z* H9 a' hrg-&gt;WriteString('”ICON”,”图标路径”);

5 ?$ K' F) o6 F% q+ t, z, grg-&gt;WriteString(“HOTICON”,”浮动图标路径”);

rg-&gt;CloseKey();
' N) K2 Z" ]0 S& y# x  E
; g  F* S" C' Y% F4 n! d. ^delete rg;
（七）如何设计系统环境监控程序

你想实时掌握系统资源吗？比如，当前窗口、磁盘及内存使用情况、设备及环境变量设置情况、正在运行的程序及开机启动程序等。通过我的系列介绍，相信你一定可以深入地了解这些信息，并可随意地通过编程来控制它。

/ W0 E. a+ I1 T) V% @- R9 U一、如何获取当前窗口
4 H+ {. {2 ~. _
+ }' `/ r8 g$ b2 [这里需要一个API函数：EnumWindows。

函数功能：该函数枚举所有屏幕上的顶层窗口，办法是先将句柄传给每一个窗口，然后再传送给应用程序定义的回调函数。EnumThreadWindows函数继续到所有顶层窗口枚举完为止或回调函数返回FALSE为止函数原型：BOOL EnumWindows（WNDENUMPROC lpEnumFunc，LPARAM lParam）；
: g6 y* M6 ]: T; d6 z
参数：
6 d1 |8 Q3 D. B2 S
lpEnumFunc：指向一个应用程序定义的回调函数指针，请参看EnumWindowsProc。

lPararm：指定一个传递给回调函数的应用程序定义值。

5 ?5 r  j' M8 D! l1 w. S+ G返回值：如果函数成功，返回值为非零；如果函数失败，返回值为零。若想获得更多错误信息，请调用GetLastError函数。
. ]2 |/ [* g: e/ L# F
备注：EnumWindows函数不列举子窗口。

在循环体中调用这个函数比调用GetWindow函数更可靠。调用GetWindow函数中执行这个任务的应用程序可能会陷入死循环或指向一个已被销毁的窗口的句柄。


我编写的回调函数：bool __stdcall EnumProc(HWND hWnd,long lp);//详细定义如下：
- g' R7 |- O! ?% @# M
: h% [: a+ j- ibool __stdcall EnumProc(HWND hWnd,long lp)
$ i$ z& V7 g" T: b# P
; h! }& h' X0 b3 U/ ]1 G{
- s# s- P0 P4 m: u
if(hWnd==NULL) return false;//如果指定的窗口句柄为空，则退出
char title[60]; //保存窗口标题
char hwndStr[10]; //保存窗口句柄
char className[60];//保存类名
* D6 t& r, C, c7 GTListItem *mItem;//用来存储窗口信息：窗口标题、句柄及类名
% H) C9 ]5 E( b  w3 j9 ^) d9 MGetWindowText(hWnd,title,60);//取得指定窗口句柄的窗口标题
if (AnsiString(title)!= "" &amp;&amp; AnsiString(title)!= "Default IME")
  w3 r% {0 t  e, p
{//如果窗口标题不为空且不是输入法标题，则
; r/ l8 A$ f# X1 C: vmItem=MainForm-&gt;ListView1-&gt;Items-&gt;Add();//添加该窗口信息到列表中
sprintf(hwndStr,"%08x",hWnd);//将窗口句柄转化为16进制
mItem-&gt;Caption=AnsiString(title);
; z3 C; i1 P; [mItem-&gt;SubItems-&gt;Add(AnsiString(hwndStr));//添加窗口句柄
. C8 r! F0 M. V& I& DGetClassName(hWnd,className,60);//取得类名
0 \4 g" M0 C% C& amItem-&gt;SubItems-&gt;Add(AnsiString(className));//添加类名
) k" t1 a5 J# Y7 [( M}
+ j; r9 n! k' H0 S: J5 Lreturn true;
6 }/ A+ Z+ f# c2 x0 H9 R}

获取当前窗口：EnumWindows((WNDENUMPROC)EnumProc,0);

《未完待续》
( o: W2 M; M. g' q* v; N* _1 h
( E0 K& F1 r3 K: Z0 E
; i6 q( P# C; |7 z/ V0 z（八）TServerSocket和TClientSocket应用技巧

1 y* b3 q& [" b+ `:nxyc_twz@163.com

3 J9 X) _& ^# |5 d在网络编程中，WinSocket API编程是最基本，也是最繁锁的部分。但是，如果你是采用C++Builder 5 作为编程平台，事情就变得简单的多了！通过我的介绍，相信你一定能快速掌握设计基于C/S体系的方法与技巧。
% @: M; H, n# V1 v+ g9 N. q( I8 I, n在BCB中，TServerSocket和TClientSocket涵盖了基本的WinSocket编程，其中TServerSocket作为服务器方使用，TClientSocket作为客户端使用，这两个组件本身并不提供Socket连接，但是他们都有一个Socket属性，这个属性才提供了Socket连接。下面就先向大家介绍一下这两个组件常用的方法属性，然后在通过一个例子来看看这两个组件的使用。
% `; A; c! G& j, H0 T  M3 H1)TServerSocket
名称 类型 说明
* I7 u) H" w3 W& t6 FSocket TServerWinSocket 最重要的属性,提供Socket连接,事实上发送/接收数据都要靠这个属性.
Port int 要监听的端口,如果在Service属性中指定了服务类型,此属性将被忽略.
Service AnsiString 提供的服务，如HTTP、FTP等，如果在这里指定了服务类型，
Port将被忽略，因为各种服务都有特定的端口，如FTP:21、HTTP:80
+ a  @1 Y# l/ n$ S! QServerType TServerType 设置与客户连接的方式，取值为两个枚举常量stNonBlocking和
stThreadBlocking，stNonBlocking表示用非阻塞方式连接每一个客户
每个连接都在一个单独的线程中处理。并用OnClientRead()和
0 i: h" k/ J, Q2 ^# B  v. g( o% R5 rOnClientWrite()通知服务器端的Socker进行读写。stThreadBlocking
8 p2 D7 i# t' L4 {3 h表示以阻塞方式连接客户，即以主动查询的方式可客户连接。
* d: v9 g2 m* p2 U1 C0 R$ z) e* Q0 d$ yActive bool 激活服务，相当于调用Open()方法。
" }- p& d2 K! e: T! {4 @! s
OnAccept事件当有客户请求连接时触发
. `% z; b# K+ o4 P# S5 c2 HOnClientRead事件通知服务器去读取有关信息。OnClientWrite与此类似。
2 g/ u, P7 [' k
2)TClientSocket
- m5 \$ I; |' {名称 类型 说明
$ F9 v+ W3 f% y* Z# JSocket TClientWinSocket 同TServerSocket
& H# [8 }3 S  m$ n2 T3 J* l' _; O9 wActive bool 同TServerSocket
Address AnsiString 服务器的IP地址，如202.98.35.14
ClientType TClientType 与服务器连接方式，取值为两个枚举常量ctNonBlocking，tBlocking。
ctNonBlocking表示非阻塞方式，ctBlocking表示阻塞方式，详见上例。
, ]: w6 H' c- D9 g8 c0 QHost AnsiString 要连接的主机名，如www.cpcw.com
Port int 同TServerSocket
Service AnsiString 同TServerSocket
, V, ?' R% _! Z% b
OnConnect事件当连接时发生，OnConnecting、OnDisConnect与此类似
OnRead事件通知客户机去读取有关信息。OnWrite与此类似。

TServerSocket和TClientSocket只提供基本的服务器/客户机的连接，真正提供数据传输的是它们都有的属性Socket，它的类型分别是TServerWinSocket和TClientWinSocket，而TServerWinSocket和TClientWinSocket的父类都是TCustomWinSocket，下面我们就来看看TServerWinSocket和TClientWinSocket常用的属性和方法。
) v* b5 ~' T' g. w" Y
共同的属性方法（来源于TCustomWinSocket）
名称 类型 说明
Connected bool 检查是否连接成功
) w( M0 Z- a& X5 kLocalAddress AnsiString 本地IP地址，与此类似LocalHost：本机域名，LocalPort：本机端口
RemoteAddress AnsiString 另一端的IP地址，与此类似RemoteHost：另一端域名，
7 Y9 y1 d! t2 }3 @& jRemotePort：另一端端口
SocketHandle int 只读，返回Socket对象的Windows句柄,调用WinSocket API函数会用到它。
Handle HWND Socket能够接受到的异步事件都是以Windows消息的形式发送给此句柄的。

; ^" @$ V8 ~+ t: m1 B) v+ _9 A; uClose()方法作为服务器，关闭所有连接；作为客户机，关闭自己与服务器的连接
SendText(AnsiString)方法发送一个字符串，
SendBuf(void* buff,int count)发送缓冲区buff中的count个字节，返回实际发送的字节数
6 h- s3 k( ]# |2 mSendStream(TStream* AStream)发送一个流到Socket中。
ReceiveText()从Socket中读取并返回一个字符串。
+ o( `3 s2 U& m9 e) F& yReceiveLength()从Socket读取数据需多少字节的缓冲区。
9 k2 c; \8 }4 Q# q" {ReceiveBuf(void* buff,int count)从Socket中读取count字节的数据到buff。

) r% _) x' c8 g0 }7 QTClientWinSocket
TClientWinSocket只增加了一个ClientType属性，
用于决定与服务器的连接类型(参见TClientSocket-&gt;ClientType)。
9 E! n4 d% w/ d: I% ~5 {. W4 U
TServerWinSocket
( v, L% `; Q' \- F1 h
名称 类型说明
ServerType 　服务类型，参见TServerSocket-&gt;ServerType。
ActiveConnection int只读，返回当前活动的连接数。
0 i7 e+ u$ w9 |4 l% u6 Y, C6 ?Connection TCustomWinSocket数组，索引n表示第n+1个连接，如Connection[0]表示第一个连接。
5 K( y, h# [( ~1 ?# M
有了这些知识，我们就可以完成一些基本的WinSocket编程了，下面就结合一个简单的闲聊程序来看看具体的应用。
首先在窗体上放置以下VCL组件，并修改相应属性：
类型 Name 属性 Caption/Text 说明
TCheckBox ckListen 监听当选取时，本程序作为服务器
5 _" o  u) B& I1 j& ~! ]1 vTCheckBox ckConnect 连接当选取时，本程序作为客户机
- k( F# Y$ s, j7 M" c1 l3 z- pTEdit edName 无名氏闲聊时所用的名字。
TBitBtn bbtSave&amp;S 保存单击时保存谈话内容
TBitBtn bbtClose&amp;C 关闭单击时关闭此窗口(设置Kind=bkClose)
7 ^: z8 b. U9 f. gTEdit edTalk 　在此输入谈话内容
TMemo mmTalk 　在此显示谈话内容
TServerSocket ServerSocket1　作服务器时使用(设置Port=2222)
( G- j! c9 ]6 F  aTClientSocket ClientSocket1　作为客户时使用(设置Port=2222)
* e0 D. c( I$ b4 s# x  xTSaveDialog sdTalk　 保存文件时的选项(设置DefaultExt="*.txt",Filter=文本文件(*.TXT)
|*.txt|所有文件(*.*)|*.*)。
2 R& Q+ k" F# aTStatusBar StatusBar1 　用于显示一些提示信息，只要在属性"annels"中加一栏即可

程序作为服务器的设置：
, s% O$ f$ M/ k0 [, h% u当单击"监听"时，如果没有监听则开始监听，在提示栏中显示"监听"，并把"连接"这个复选框无效。如果已经监听，则取消监听，并使"连接"这个复选框有效。所以，在ckListen的OnClick事件中加入以下代码：

6 z  t5 \9 `( a$ `
if(ServerSocket1-&gt;Active)
% g  n/ W9 Y4 [8 V- f& E5 A% W{
/ G! h: M$ W3 SServerSocket1-&gt;Active=false;
/ \2 U, ~* [* zckListen-&gt;Checked=false;
StatusBar1-&gtanels-&gt;Items[0]-&gt;Text="";
}
else
{
5 d1 Y$ U) x1 T) _, ?9 V+ SServerSocket1-&gt;Active=true;
  P9 C9 I$ G" O6 J6 o5 A- s5 D; l- C1 gckListen-&gt;Checked=true;
ClientSocket1-&gt;Active=false;
+ C& K3 r/ a0 \. d5 z% D  f* BStatusBar1-&gtanels-&gt;Items[0]-&gt;Text="监听..." ;
}
# f8 V& S# x) g& ]/ F4 {ckConnect-&gt;Enabled=!(ckListen-&gt;Checked);
8 V2 \! H. y6 b
3 h9 T& |6 }4 Y+ |当有客户加入时，向所有的客户发出通知：并在自已的mmTalk加入此消息：所以在ServerSocket1的OnAccept事件中加入如下代码：

( P* o, Y9 M2 vint i;
AnsiString str1="服务器消息："+Socket-&gt;RemoteHost+"加入";
$ @3 N- p; J  Z5 D3 V* ^for(i=0;i&lt;ServerSocket1-&gt;Socket-&gt;ActiveConnections;i++)
ServerSocket1-&gt;Socket-&gt;Connections-&gt;SendText("服务器消息："+Socket-&gt;RemoteHost+"加入");
3 h' C6 n2 u+ e9 gStatusBar1-&gtanels-&gt;Items[0]-&gt;Text=str1;
mmTalk-&gt;Lines-&gt;Add(str1);

5 [* F# |8 t, h9 w8 L  P- N& l当客户机通知服务器读信息时，首先读出字符串，然后把读到的字符串发送到每一台连接的客户，并在自已的mmTalk中加入客户发送来的字符串。所以，在TServerSocket的OnClientRead事件中加入以下代码：

+ u1 j2 ~3 L" d  c/ U8 H' _AnsiString str1=Socket-&gt;ReceiveText();
; T" T  G! \/ \mmTalk-&gt;Lines-&gt;Add(str1);
int i;
8 y: Z' d3 |, Qfor(i=0;i&lt;ServerSocket1-&gt;Socket-&gt;ActiveConnections;i++)
ServerSocket1-&gt;Socket-&gt;Connections-&gt;SendText(str1);
+ x; }3 H2 [. V- K7 v/ v
" ^' u6 E6 ?: s8 s0 [程序作为客户机的设置：
; y' F; T  \1 D  Q; y' ^: n当单击"连接"时，如果还未连接，则询问要连接的主机，然后连接之，屏蔽"监听"；如果已经连接，则断开连接。"监听"使能。所以，在ckConnect的OnClick事件中加入以下代码：

if(ClientSocket1-&gt;Active)
{
ClientSocket1-&gt;Active=false;
5 K& W, b7 d2 Y( N" PckConnect-&gt;Checked =false;
}
+ t& m& s3 ?8 J9 telse
! _; _% `. w( c: N: n{
AnsiString Server="localhost";
if(InputQuery("连接","请输入要连接的主机地址：",Server))
* o* e3 a2 A! Q5 x4 @$ |% ]+ `{
ClientSocket1-&gt;Host=Server;
. x' i- t( f7 W5 _& C' J6 [ClientSocket1-&gt;Active=true;
/ |; D0 {/ r# E/ N% n, A- z1 TckConnect-&gt;Checked =true;
}
}
ckListen-&gt;Enabled= !(ckConnect-&gt;Checked);

9 M8 m0 {4 G8 F: d7 a7 _2 V1 z当连接服务器成功时，在状态栏中显示此信息，所以，在ClientSocket1的ClientSocket1Connect中加入：

StatusBar1-&gtanels-&gt;Items[0]-&gt;Text ="连接到主机："+Socket-&gt;RemoteHost;
: U7 o/ |1 z  e) o; N% v当服务器发送字符串来时，把它加入mmTalk中，但如果本字符串就是自已发送的(因为服务器会把收到的消息发给每一客户)，为条信息就是重复的，所以，要比较mmTalk中最后两条信息是否相同，如果相同，则删除重复信息。代码如下：
! ]; a  C/ O: o% m/ H' ^' X; G0 ~
! V, ]: L6 w4 d& Z- e9 }mmTalk-&gt;Lines-&gt;Add(Socket-&gt;ReceiveText());
int i=mmTalk-&gt;Lines-&gt;Count-1;
if(mmTalk-&gt;Lines-&gt;Strings==mmTalk-&gt;Lines-&gt;Strings[i-1])
- A; y4 P, b2 W0 V* nmmTalk-&gt;Lines-&gt;Delete(i);

公用部分
当在edTalk输入交谈内容，按回车键表示输入完成，此时把交谈内容发送出去并清除edTalk的内容。在发送信息时，要看本程序是作为服务器还是客户机，如果是服务器则把信息发送到每一个客户；如果是作为客户则把信息发送到服务器。代码如下：

if(Key==13)
{
" f, ^& R/ O6 B9 ^9 HmmTalk-&gt;Lines-&gt;Add(edName-&gt;Text+"："+edTalk-&gt;Text);
if(ckListen-&gt;Enabled&amp;&amp;ckConnect-&gt;Enabled==false)
//"监听"有效，"连接"无效。表示是服务器
{
int i;
for(i=0;i&lt;ServerSocket1-&gt;Socket-&gt;ActiveConnections;i++)
* ^" v3 t4 b* H6 [( `ServerSocket1-&gt;Socket-&gt;Connections-&gt;SendText(edName-&gt;Text+"："+edTalk-&gt;Text);
  Z' w# M- L! W3 g}
8 O  _- E1 \4 ]" k& L; Celse
{
, x7 l: ^8 s* d: Y; wClientSocket1-&gt;Socket-&gt;SendText(edName-&gt;Text+"："+edTalk-&gt;Text);
}
edTalk-&gt;Text="";
}

mmTalk的内容不可能永远增加，所以当它有100行时就清空它，在mmTalk的OnChange事件中检查：

if(mmTalk-&gt;Lines-&gt;Count&gt;=100)mmTalk-&gt;Lines-&gt;Clear();
* c: }0 |; M" m, z; c
8 o( R& x: c" M! x6 G当然你也可以双击mmTalk来清空它，在mmTalk的OnDblClick事件中加入：

8 R+ x- q+ ?0 I. q3 h8 L) KmmTalk-&gt;Lines-&gt;Clear();
. k, \5 U0 i) w7 f# E当你觉得谈话的内容很有意思，你可以单击bbtSave打开保存对话框设置保存特性，所以在bbtSave的onClick中加入代码：
  ]* K% ~. B! _; h( `
if(sdTalk-&gt;Execute())
mmTalk-&gt;Lines-&gt;SaveToFile(sdTalk-&gt;FileName);

我们的闲聊程序完成了，在局域网中试试吧？如果你只有一台机器，客户程序在连接时服务器时输入localhost或你机器的名字就可以了。
* [0 L4 r, S! U* x; c9 ^
（九）读写端口的两种技巧
$ y9 L) k' D' J5 B6 P
: N! c3 Y0 k5 O5 p0 [<a href="mailtnxyc_twz@163.com" target="_blank" >nxyc_twz@163.com</A>

在C++Builder中，不能够使用Turbo C中的outputb和inputb端口读写函数。但我们可以有另外两种办法实现这个功能。一种为内嵌汇编语言，另一种为使用__emit__函数。
* R) l0 U. q4 v7 c" I! D
0 m* C3 N  W. {7 [+ Z! h* \# B1 通过内嵌汇编语言实现端口的读写

在C++Builder中，汇编语句必须被包含在以关键字asm为起始的一对大括号中：

asm {
/ ~" b% `: B) f' T
汇编语句1
7 [1 w$ T5 f! |# x
……
/ `+ K$ p3 h, j8 D1 E
; h4 J1 i% |0 h2 f! x. r8 o- V6 ~2 e}

! m( ]8 z, I7 X: C5 G% V利用内嵌汇编语言编制端口输出函数如下：

void OutPort(unsigned short port,unsigned char value)//port参数为输出端口地址，value参数为输出值
% y- J* F/ k5 s0 H8 J7 o{
0 y2 N, e  O3 e, v1 j: Aasm{
1 b# Y" L2 d% |, C6 Pmov dx , port //把端口地址送到处理器DX寄存器中
mov al , value // 把value 送到处理器AL寄存器中
9 }0 |+ V; ~, s8 V4 E: pout dx , al // 把AL寄存器中的值送到端口
9 v* R5 a* W. d) q& V# q};

}
0 q( n- a) n4 k% j9 f/ D5 G0 R
$ D+ B* S& q, j9 c9 A0 C该函数将无符号字符型8位的数据value写入地址为port的端口上，port的数据类型是unsigned short ，16位无符号短整形。
利用内嵌汇编语言编制端口输入函数如下：
) D% F- \" Y& Z# N
( |/ E2 V; s/ z9 I1 ^  |+ Uunsigned char InPort(unsigned short port)//port参数为输入端口地址，返回为输入值
{
6 x7 E; B1 t8 D% r6 }) I- lunsigned char value ;
　asm{
$ v* C) b7 R& S0 A& k4 bmov dx , port // 把端口地址送到处理器DX寄存器中
# t" T4 i7 v9 L9 v4 kin al, dx // 从DX指定端口中将一数据送到AL寄存器中
% _$ p# f! v! V% dmov ind , value // 把AL寄存器中的值赋给value
};
return value; //返回端口数据
}

函数InPort从地址为port的端口读入一个无符号8位的字符型数据，其其参数只一个，即端口号。返回的数据为unsigned char类型的，为从端口读取的值。

3 e: }! o4 `0 m
2 通过__emit__函数实现端口的读写

6 S! g4 m: G; I5 P( H/ _$ ~" M8 `2 ~__emit__ 函数一般极少用到。其用法如下：
  g2 T2 h2 R$ E) G5 Z9 q3 A6 \
void _ _emit_ _(argument, . . .);

1 r5 P( _8 w! z) A该函数为C＋＋Builder 的一个内部函数，调用的参数为机器语言指令。它在编译的时侯，将机器语言指令直接嵌入目标码中，不必借助于汇编语言和汇编编译程序。
如果想使用__emit__ 函数，必须熟悉80x86处理器的机器语言指令。如果调用的参数是错误机器语言指令，则程序将非正常运行,并很容易导致死机。
" Z5 Z0 s$ g6 T% {+ ~8 c5 @
利用__emit__函数编制端口输出函数如下：

void OutPort(unsigned short port,unsigned char value)//port参数为输出端口地址，value参数为输出值
{
__emit__(0x8b,0x95,&amp;port); // 把端口地址送到处理器EDX寄存器中
　__emit__(0x8a,0x85,&amp;value); // 把value 送到处理器AL寄存器中
　__emit__(0x66,0xee); // 把AL寄存器中的值送到端口

5 `% r* q" ?  }9 e3 f8 W}

- m8 c& Y* }  S( o9 r. Z% G! w利用__emit__函数编制端口输入函数如下：
& t: _2 x1 n' V* Y1 x0 E# d
/ A; M+ c' |2 {7 t: I3 Hunsigned char InPort(unsigned short port)//port参数为输入端口地址，返回为输入值
0 K4 z4 O: d/ M{
unsigned char value ;
　__emit__(0x8b,0x95,&amp;port) ; // 把端口地址送到处理器DX寄存器中
/ K! y/ @( N7 b* [　__emit__(0x66,0xec); // 从DX指定端口中将一数据送到AL寄存器中
　__emit__(0x88,0x85,&amp;value); // 把AL寄存器中的值赋给value
+ S5 s1 E% }) K: h" r8 l% @return value; //返回端口数据
}
3 K( ]- E7 T3 |2 r$ N
% K* Q+ ?+ ^- Q% y: o由这两种方法所编制的函数注释可以看出，它们每一句的功能都是一样的，只是一个是嵌入了汇编语言，另一个是直接使用机器语言。
: q1 m- v  W/ N' N) c" w
' k( U9 U4 C# s2 _0 H( R/ O% U- K
3 应用举例

在C++Builder中，通过File/New Application菜单新建一工程。
9 H6 R5 ~* \  K1 T, w* p3 q
在表单中加两个Button控件，Caption分别为“写端口”和“读端口”。
; z$ i. X9 ?. _6 {- w
) ]: b2 m' @! r$ ^  M' u将第一种方法所编制的OutPort和InPort函数拷贝到表单的头文件中，并把这两个函数作为表单类的在表单类的公有成员函数。
( |& M5 `5 m0 t7 @' Q3 n! U
7 J7 S" M9 a7 }分别双击两个Button控件，产生OnClick事件函数。在单元文件的.cpp文件添加如下代码：
" k4 K* v2 m8 H5 r; X$ K9 d
9 e! Y! y; q* [8 P* O% E9 X7 d//---------------------------------------------------------------------------

void __fastcall TForm1::Button1Click(TObject *Sender)

' h7 {( S; j3 A1 K, t5 N: Z" G{
4 Z, M0 f8 G+ S% eOutPort(0x378,0x00);//向地址为378H的端口输出数据
OutPort(0x379,0x00);//向地址为379H的端口输出数据
}

//---------------------------------------------------------------------------
3 m  g+ R2 m' h
void __fastcall TForm1::Button2Click(TObject *Sender)

{
4 T( A, d' ^8 A4 c; {  {( Vint value;
value=InPort(0x37a);//从地址为37aH的端口读入数据
}

//---------------------------------------------------------------------------


1 R% Z  H$ `8 L) ^; b) w（十）如何实现控件数组
& Z% O5 O- [$ ]* L7 A; @



在C++ Builder中，没有提供像VB中控件数组的功能,很令遗憾。经过一番琢摸，终于解决了这个问题。技巧不敢独享，奉献出来供大家交流。
$ X: y. j! Z& |' J9 V4 r
7 u" T: F& s+ V# b- m; _
在VB中，控件数组可以 ：
1 z. \* l# b7 R- W* E
" l# ~6 I# I  [
允许多个控件共享同一个事件句柄
提供了运行期间增加一个控件的机制
提供了一种方便的组合控件的方法。
前两项在C++ Builder中早已实现,而且CB更有一个优点。即不同类型的控件可以使用相同的句柄(只需在相关控件的Object Inspector窗口中的EVENT事件设置即可)。
　　 C++ Builder中使用了Tlist类对象来组合控件数组,与VB控件数组元素必须为同一类型控件相比较,C++ Builder中的Tlist类对象可以组合任意类型的控件而不必强求同一种类,这样就大大地方便了程序开发者。例如可以把在不同Panel面板控件上的所有控件组合为一个控件数组。
! P. l( p- |5 s# i+ C) G' P- S　　 在具体的开发实践中，我采用Tlist类对象创建、维护了多类型的控件数组。其实现原理与方法详见以下的原程序代码。实例程序实现了动态创建一个包含8个TEdit类型控件和4个TImage类型控件的控件数组,在程序运行中对所创建的控件进行修改、维护的功能。
& s9 ^6 i4 C; f- }0 q　　 1、创建一个新的工程文件(New Application),在Form1上放置两个TPanel类型的Panel1和Panel2,调整大小合适,再在窗体下方放置四个TButton类型Button1,Button2,Button3,Button4,设置控件属性如下：Button1-&gt;Caption="新建控件数组",Button2-&gt;Caption="改变控件位置", Button3-&gt;Caption="还原到原位置", Button4-&gt;Caption="退出"；Button2-&gt;Enabled=false,Button3-&gt;Enabled=false。
　　2、在文件Unit1.H中加入以下声明：
　　class TForm1 : public TForm
　　 {
. j- B) q* [1 R0 ]5 U0 O# K　　 published: // IDE-managed Components
& S3 r* f$ `' ]$ p- f$ B, w　　 TPanel *Panel1;
" P! u3 ^3 A+ |: N% r3 ?: H. @1 X　　 TPanel *Panel2;
& ]4 z4 l5 d0 X/ |! C+ F! W　　 TButton *Button1;
% H  k4 k4 W1 x; Z　　 TButton *Button2;
( t+ A: m. ~) Y: r　　 TButton *Button3;
　　 TButton *Button4;
/ w! w3 m9 P% L$ x/ @　　 private: // User declarations
# Z* _# H9 Y+ b( ?# X  X, ]7 t' n　　 TList *MyVCL;
　　 public: // User declarations
0 W: Q" {- o. H6 w4 r# ]　　 __fastcall TForm1(TComponent* Owner);
8 Y7 k9 L+ ^2 {8 q' A  M　　 virtual __fastcall ~TForm1( );
　　};
　　3、切换到工程的Form界面,双击工程的主界面Form,创建一个OnCreate事件句柄,在文件Unit1.CPP中加入以下代码：
　　void __fastcall TForm1::FormCreate(TObject *Sender)
  k7 A  i& L: T6 T8 }　　{
　　 MyVCL = new TList;//创建TList对象
3 h, G5 k! w8 C' t! J: b. |　　}
　　将TForm1析构函数加入到文件Unit1.CPP中：
　　__fastcall TForm1::~TForm1()
/ O8 Y. @3 W* \# u　　{
8 b, m) ]9 G5 Z) o　　 delete MyVCL; //删除TList对象
　　}
* }. y1 Q; }  P" Q　　 4、双击标签(Caption)为"创建控件数组"的按钮,创建一个OnClick事件句柄,添加以下代码到OnClick事件句柄中：
　　void __fastcall TForm1::Button1Click(TObject *Sender)
　　{
$ w: V% ?# u: V$ X' Z　　 //创建新的控件,调整其位置,并加入到MyVcl(TList 类)之中
- {: l- ?/ o* Y3 G　　 int temptop=5;
　　 for (int i=0;i&lt;4;i++)

  T- b! ~! d0 Q1 p$ S6 L$ h* J{
8 ~5 N+ @4 c, r9 @' S: Q　　 TEdit *EditNow = new TEdit(this);
1 t: {8 q: Q1 K: ~+ U6 L, A  z+ o　 　 EditNow-&gtarent=Panel1;
　　 EditNow-&gt;Text= IntToStr(i);
　　 EditNow-&gt;ReadOnly=true;
$ k/ @6 G% x! `　　 EditNow-&gt;Top=temptop;
* Q& Z9 `' P& `4 |; Q2 l% V9 q8 f　　 EditNow-&gt;Height=24;
　　 EditNow-&gt;Width=24;
. m, W, p0 n* ^1 }) ?: Y. B　　 EditNow-&gt;Left=10;
4 K; Z" k4 o! ]8 l8 l" z- `　　 MyVCL-&gt;Add(EditNow); //加入到控件数组中
　　 TImage *ImageOff= new TImage(this);
0 E8 M2 n2 P3 |# S9 D　 　 ImageOff-&gtarent=Panel1;
　　 ImageOff-&gticture-&gt;LoadFromFile("None.BMP");
　　 ImageOff-&gt;Top=temptop;
( }; u! S5 b; w1 }$ U　　 ImageOff-&gt;Height=24;
　　 ImageOff-&gt;Width=24;
8 J0 p% k* r7 Q　　 ImageOff-&gt;Left=EditNow-&gt;Left+EditNow-&gt;Width;
　　 MyVCL-&gt;Add(ImageOff); //加入到控件数组中
9 N* w1 n8 t7 q  ~/ a- e8 Y- N0 |　　 TEdit *EditStatus = new TEdit(this);
　　 EditStatus-&gtarent=Panel1;
  @) l- Y: }0 g. J8 A　　 EditStatus-&gt;Font-&gt;Name = "Arial";
/ b9 o7 s) G) W  e　　 EditStatus-&gt;Font-&gt;Size = 12;
　　 EditStatus-&gt;Text="禁止访问";
% O. S) Y9 b( w( z. t! d% T; p　 　 EditStatus-&gt;ReadOnly=true;
. s4 A6 ]0 T' Q: G% H0 ?) O0 U　　 EditStatus-&gt;Top=temptop;
　　 EditStatus-&gt;Height=24;
0 i" }# O+ _0 P1 u: A- \8 W4 K6 \　　 EditStatus-&gt;Width=80;
6 T$ I; h- d0 D; i7 T" W4 @, f　　 EditStatus-&gt;Left= ImageOff-&gt;Left+ImageOff-&gt;Width;
　　 MyVCL-&gt;Add(EditStatus); //加入到控件数组中
　 　 temptop=temptop+24+5;
　　 }
　　 Button1-&gt;Enabled=false;
6 L& r5 T- N: W# J; [" k+ W　　 Button2-&gt;Enabled=true;
　　 }
, Q5 G- R' x  h2 F' q+ O6 U% c　　5、同4所示方法,依次双击标签的标题(Caption)为"改变控件位置"、 "还原到原位置"、 "退出"的按钮,创建对应的OnClick事件句柄,添加以下代码到对应的OnClick事件句柄中：
　　void __fastcall TForm1::Button2Click(TObject *Sender)
( _  W" i  s. W' C6 ^　　{
　　 for (int i=0;i&lt;4;i++)
/ G! \8 n# f, }' ^5 k% S　　 ((TImage*)MyVCL-&gt;Items[i*3+1])-&gtarent=Panel2;
/ ]+ j; H# A& p; u6 C# F1 {( ?　　 Button2-&gt;Enabled=false;
: h# t) M6 C5 L7 ^$ h　　 Button3-&gt;Enabled=true;
　　}
. i4 D) c+ w  _3 T) E　　void __fastcall TForm1::Button3Click(TObject *Sender)
. p0 s* {' z- Q) r3 H. j0 A9 r2 g! q　　{
　　 for (int i=0;i&lt;4;i++)
　　 ((TImage*)MyVCL-&gt;Items[i*3+1])-&gtarent=Panel1;
% G# M6 M/ Q  {7 }4 r  B9 }& `　　 Button3-&gt;Enabled=false;
　　 Button2-&gt;Enabled=true;
0 l0 M5 n: l, n& M, Q7 C) c　　}
, s; U! u% n3 q0 J' }0 z9 E　　void __fastcall TForm1::Button4Click(TObject *Sender)
　　{
- i! j( X' @  J5 V　　 Close(); //关闭窗体
1 u9 ?1 v( T: n  O2 v: |& ~0 I　　}
　　由上所述,实际的代码大多只是用于设定控件位置和基本属性,真正实现控件数组功能的代码并不太多,也不复杂,而且十分的灵活；需要注意的是使用TList类对象组合中的各项控件之前,必须先将其强制转换为一个对象指针以指明其类型,才能对其属性进行修改/赋值操作。
5 l% Y4 W" S( z6 E" s! [$ S( N
5 r  T: C) Y: W+ r# u7 Z6 ^; m  R（十）用Sender参数实现代码重用
/ _6 ?0 e3 x% t. I
<a href="mailtnxyc_twz@163.com" target="_blank" >nxyc_twz@163.com</A>
" N" ^6 Z, C: g6 M1 x
面向对象的编程工具的特点之一就是要提高代码重用性（Reuse），BCB当然可以实现这一功能。我们都知道，在BCB中，大部分程序代码都直接或间接的对应着一个事件，此程序称为事件处理句柄，它实际上就是一个过程。从应用程序的工程到窗口、组件和程序，BCB强调的是其开发过程中每一层次的重用性，可以充分利用已编写过的代码来减少工作量，更会使你的程序变得优美。代码段间的共享都跟发生该事件的控件有关，需要根据控件类型做出相应的处理，这时就要用到Sender参数。
9 l8 p! a7 O- A0 p
每个函数的开头都有形如：
8 b) s, j( R$ Dvoid _fastcall Tform1::Button1Click(TObject *Sender)
" g( W, s) @! C' `' \
其中的Sender是一个Tobject类型的参数，它告诉BCB哪个控件接收到这个事件并调用相应的处理过程。我们可以编写一个单一的事件处理句柄，通过Sender参数和if语句或者case语句配合，来处理多个组件。在Delphi中可以用IS来测试Sender类型，或者用AS进行类型转换，BCB我们只在用dynamic_cast来进行上面两个工作，下面把dynamic_cast的用法说明一下。

dynamic_cast 可以把某种对象强制转成另一个类，类型转换成功则返回一个值是0的指针，失败则丢出一个异常处理信息：Bad_cast，但你放心不会导致系统死机，所以可以放心使用。其程式：
dynamic_cast &lt;T&gt; (ptr)
T参数一定要是一个指针、void 、或是已经定义过的类，而ptr参数则必须是一个指针（pointer） 或是一个引用（reference）。如果T的类型是void，那么ptr则是一个可以访问最下面类里的任何成员，当然这样的类将不可以是基础类。

7 L. P) v0 p2 i! Q6 k/ H1．进行判断
我们用dynamic_case来测试Sender，以便找到调用这个事件的处理句柄或组件的类型。如，并窗口编辑框和标签的Click事件的处理句柄都指向窗口的xxx函数，编辑框和标签对Click事件有不同的反应：
void _fastcall TForm1::xxx(Tobject *Sender)
6 ~' M/ |) r, B{
" ]) }6 Z* D( Fif(dynamic_cast&lt;TEdit *&gt;(Sender)
showmessage(“This is a editbox”);
if(dynamic_cast&lt;TLabel *&gt;(Sender)
4 P+ l( m# O1 @. J: R$ Gshowmessage(“This is a label”);
}
& [; z. {: f& ^  v5 c6 H, R0 ^2 g
2．强制进行类型转换
将若干继承同一父类的子类强制转换成该父类。如窗口中有一个TEdit类控件和一个TMemo控件，它们实际上都继承于TCustomEdit类，如果你要为二者的某一事件提供同样的处理，可以将二者事件句柄都指向自定义的函数yyy:
void _fastcall TForm1::yyy(Tobject *Sender)
# o: B, l- K: T$ K{
+ `, N3 c* j( n+ mdynamic_cast&lt;TCustomEdit *&gt;(Sender).text=”This is some demo text”;
; U. a9 M( o: d; }}
在这里，先把TEdit类和TMemo类均强制转换成TCustomEdit类，再对其父类的属性进行赋值。
' Y( D1 e4 {3 V使用Sender参数可以通过单一函数段处理多类组件，真正体现了BCB的面向对象的重用性。</DIV>