VCL类学习之(九) TDataModule

TDataModule centralizes the handling of nonvisual components in an application.

Unit

Classes

Description

Use a TDataModule object in an application to provide a location for centralized handling of nonvisual components. Typically these are data access components, such as TSQLDataSet, and TSQLConnection. DataModules are not limited to data access components, they can also contain other nonvisual components, such as TTimer, TOpenDialog, or TImageList).

At design time a TDataModule object provides a visual container into which a developer can place nonvisual components, set their properties, and write event handlers for them. To create a data module at design time, choose File | New Data Module.

In the unit file for the data module a developer may also place any business rules that are to be applied to the application.

To make the data module available to another unit in the application, select that unit, then choose File|Use Unit (when working in Delphi) or File|Include Unit Header (when working in C++) to add the data module to the uses clause for the unit.

1. { TDataModule }
3.   TDataModule = class(TComponent)
4.   private
5.     FDesignSize: TPoint;
6.     FDesignOffset: TPoint;
7.     FOnCreate: TNotifyEvent;
8.     FOnDestroy: TNotifyEvent;
9.     FOldCreateOrder: Boolean;
10.     procedure ReadHeight(Reader: TReader);
11.     procedure ReadHorizontalOffset(Reader: TReader);
12.     procedure ReadVerticalOffset(Reader: TReader);
13.     procedure ReadWidth(Reader: TReader);
14.     procedure WriteWidth(Writer: TWriter);
15.     procedure WriteHorizontalOffset(Writer: TWriter);
16.     procedure WriteVerticalOffset(Writer: TWriter);
17.     procedure WriteHeight(Writer: TWriter);
18.   protected
19.     procedure DoCreate; virtual;
20.     procedure DoDestroy; virtual;
21.     procedure DefineProperties(Filer: TFiler); override;
22.     procedure GetChildren(Proc: TGetChildProc; Root: TComponent); override;
23.     function HandleCreateException: Boolean; dynamic;
24.     procedure ReadState(Reader: TReader); override;
25.   public
26.     constructor Create(AOwner: TComponent); override;
27.     constructor CreateNew(AOwner: TComponent; Dummy: Integer = 0); virtual;
28.     destructor Destroy; override;
29.     procedure AfterConstruction; override;
30.     procedure BeforeDestruction; override;
31.     property DesignOffset: TPoint read FDesignOffset write FDesignOffset;
32.     property DesignSize: TPoint read FDesignSize write FDesignSize;
33.   published
34.     property OldCreateOrder: Boolean read FOldCreateOrder write FOldCreateOrder;
35.     property OnCreate: TNotifyEvent read FOnCreate write FOnCreate;
36.     property OnDestroy: TNotifyEvent read FOnDestroy write FOnDestroy;
37.   end;
39. { TDataModule }
41. constructor TDataModule.Create(AOwner: TComponent);
42. begin
43.   GlobalNameSpace.BeginWrite;
44.   try
45.     CreateNew(AOwner);
46.     if (ClassType <> TDataModule) and not (csDesigning in ComponentState) then
47.     begin
48.       if not InitInheritedComponent(Self, TDataModule) then
49.         raise EResNotFound.CreateFmt(SResNotFound, [ClassName]);
50.       if OldCreateOrder then DoCreate;
51.     end;
52.   finally
53.     GlobalNameSpace.EndWrite;
54.   end;
55. end;
57. procedure TDataModule.AfterConstruction;
58. begin
59.   if not OldCreateOrder then DoCreate;
60. end;
62. constructor TDataModule.CreateNew(AOwner: TComponent; Dummy: Integer);
63. begin
64.   inherited Create(AOwner);
66.   if Assigned(AddDataModule) and (Dummy >= 0) then
67.     AddDataModule(Self);
68. end;
70. procedure TDataModule.BeforeDestruction;
71. begin
72.   GlobalNameSpace.BeginWrite;
73.   Destroying;
74.   RemoveFixupReferences(Self, '');
75.   if not OldCreateOrder then DoDestroy;
76. end;
78. destructor TDataModule.Destroy;
79. begin
80.   if not (csDestroying in ComponentState) then GlobalNameSpace.BeginWrite;
81.   try
82.     if OldCreateOrder then DoDestroy;
83.     if Assigned(RemoveDataModule) then
84.       RemoveDataModule(Self);
85.     inherited Destroy;
86.   finally
87.     GlobalNameSpace.EndWrite;
88.   end;
89. end;
91. procedure TDataModule.DoCreate;
92. begin
93.   if Assigned(FOnCreate) then
94.   try
95.     FOnCreate(Self);
96.   except
97.     if not HandleCreateException then
98.       raise;
99.   end;
100. end;
102. procedure TDataModule.DoDestroy;
103. begin
104.   if Assigned(FOnDestroy) then
105.   try
106.     FOnDestroy(Self);
107.   except
108.     if Assigned(ApplicationHandleException) then
109.       ApplicationHandleException(Self);
110.   end;
111. end;
113. procedure TDataModule.DefineProperties(Filer: TFiler);
114. var
115.   Ancestor: TDataModule;
117.   function DoWriteWidth: Boolean;
118.   begin
119.     Result := True;
120.     if Ancestor <> nil then Result := FDesignSize.X <> Ancestor.FDesignSize.X;
121.   end;
123.   function DoWriteHorizontalOffset: Boolean;
124.   begin
125.     if Ancestor <> nil then
126.       Result := FDesignOffset.X <> Ancestor.FDesignOffset.X else
127.       Result := FDesignOffset.X <> 0;
128.   end;
130.   function DoWriteVerticalOffset: Boolean;
131.   begin
132.     if Ancestor <> nil then
133.       Result := FDesignOffset.Y <> Ancestor.FDesignOffset.Y else
134.       Result := FDesignOffset.Y <> 0;
135.   end;
137.   function DoWriteHeight: Boolean;
138.   begin
139.     Result := True;
140.     if Ancestor <> nil then Result := FDesignSize.Y <> Ancestor.FDesignSize.Y;
141.   end;
143. begin
144.   inherited DefineProperties(Filer);
145.   Ancestor := TDataModule(Filer.Ancestor);
146.   Filer.DefineProperty('Height', ReadHeight, WriteHeight, DoWriteHeight);
147.   Filer.DefineProperty('HorizontalOffset', ReadHorizontalOffset,
148.     WriteHorizontalOffset, DoWriteHorizontalOffset);
149.   Filer.DefineProperty('VerticalOffset', ReadVerticalOffset,
150.     WriteVerticalOffset, DoWriteVerticalOffset);
151.   Filer.DefineProperty('Width', ReadWidth, WriteWidth, DoWriteWidth);
152. end;
154. procedure TDataModule.GetChildren(Proc: TGetChildProc; Root: TComponent);
155. var
156.   I: Integer;
157.   OwnedComponent: TComponent;
158. begin
159.   inherited GetChildren(Proc, Root);
160.   if Root = Self then
161.     for I := 0 to ComponentCount - 1 do
162.     begin
163.       OwnedComponent := Components[I];
164.       if not OwnedComponent.HasParent then Proc(OwnedComponent);
165.     end;
166. end;
168. function TDataModule.HandleCreateException: Boolean;
169. begin
170.   if Assigned(ApplicationHandleException) then
171.   begin
172.     ApplicationHandleException(Self);
173.     Result := True;
174.   end
175.   else
176.     Result := False;
177. end;
179. procedure TDataModule.ReadState(Reader: TReader);
180. begin
181.   FOldCreateOrder := not ModuleIsCPP;
182.   inherited ReadState(Reader);
183. end;
185. procedure TDataModule.ReadWidth(Reader: TReader);
186. begin
187.   FDesignSize.X := Reader.ReadInteger;
188. end;
190. procedure TDataModule.ReadHorizontalOffset(Reader: TReader);
191. begin
192.   FDesignOffset.X := Reader.ReadInteger;
193. end;
195. procedure TDataModule.ReadVerticalOffset(Reader: TReader);
196. begin
197.   FDesignOffset.Y := Reader.ReadInteger;
198. end;
200. procedure TDataModule.ReadHeight(Reader: TReader);
201. begin
202.   FDesignSize.Y := Reader.ReadInteger;
203. end;
205. procedure TDataModule.WriteWidth(Writer: TWriter);
206. begin
207.   Writer.WriteInteger(FDesignSize.X);
208. end;
210. procedure TDataModule.WriteHorizontalOffset(Writer: TWriter);
211. begin
212.   Writer.WriteInteger(FDesignOffset.X);
213. end;
215. procedure TDataModule.WriteVerticalOffset(Writer: TWriter);
216. begin
217.   Writer.WriteInteger(FDesignOffset.Y);
218. end;
220. procedure TDataModule.WriteHeight(Writer: TWriter);
221. begin
222.   Writer.WriteInteger(FDesignSize.Y);
223. end;