tpsystools_4.04/source/StNVColl.pas

// Upgraded to Delphi 2009: Sebastian Zierer

(* ***** BEGIN LICENSE BLOCK *****
 * Version: MPL 1.1
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is TurboPower SysTools
 *
 * The Initial Developer of the Original Code is
 * TurboPower Software
 *
 * Portions created by the Initial Developer are Copyright (C) 1996-2002
 * the Initial Developer. All Rights Reserved.
 *
 * Contributor(s):
 *
 * ***** END LICENSE BLOCK ***** *)

{*********************************************************}
{* SysTools: StNVColl.pas 4.04                           *}
{*********************************************************}
{* SysTools: non visual component for TStCollection      *}
{*********************************************************}

{$I StDefine.inc}

unit StNVColl;

interface

uses
  Windows,  Classes,
  StBase, StColl, StNVCont;

type
  TStNVCollection = class(TStNVContainerBase)
  {.Z+}
  protected {private}
    {property variables}
    FContainer    : TStCollection; {instance of the container}
    FPageElements : Integer;

    {property methods}
    procedure SetPageElements(Value : Integer);

    {internal methods}
    procedure RecreateContainer;

  protected
    function GetOnCompare : TStCompareEvent;
      override;
    function GetOnDisposeData : TStDisposeDataEvent;
      override;
    function GetOnLoadData : TStLoadDataEvent;
      override;
    function GetOnStoreData : TStStoreDataEvent;
      override;
    procedure SetOnCompare(Value : TStCompareEvent);
      override;
    procedure SetOnDisposeData(Value : TStDisposeDataEvent);
      override;
    procedure SetOnLoadData(Value : TStLoadDataEvent);
      override;
    procedure SetOnStoreData(Value : TStStoreDataEvent);
      override;

  public
    constructor Create(AOwner : TComponent);
      override;
    destructor Destroy;
      override;
  {.Z-}

    property Container : TStCollection
      read FContainer;

  published
    property PageElements : Integer
      read FPageElements
      write SetPageElements default 1000;

    property OnCompare;
    property OnDisposeData;
    property OnLoadData;
    property OnStoreData;
  end;


implementation

{*** TStNVCollection ***}

constructor TStNVCollection.Create(AOwner : TComponent);
begin
  inherited Create(AOwner);

  {defaults}
  FPageElements := 1000;

  if Classes.GetClass(TStCollection.ClassName) = nil then
    RegisterClass(TStCollection);

  FContainer := TStCollection.Create(FPageElements);
end;

destructor TStNVCollection.Destroy;
begin
  FContainer.Free;
  FContainer := nil;

  inherited Destroy;
end;

function TStNVCollection.GetOnCompare : TStCompareEvent;
begin
  Result := FContainer.OnCompare;
end;

function TStNVCollection.GetOnDisposeData : TStDisposeDataEvent;
begin
  Result := FContainer.OnDisposeData;
end;

function TStNVCollection.GetOnLoadData : TStLoadDataEvent;
begin
  Result := FContainer.OnLoadData;
end;

function TStNVCollection.GetOnStoreData : TStStoreDataEvent;
begin
  Result := FContainer.OnStoreData;
end;

procedure TStNVCollection.RecreateContainer;
var
  HoldOnCompare     : TStCompareEvent;
  HoldOnDisposeData : TStDisposeDataEvent;
  HoldOnLoadData    : TStLoadDataEvent;
  HoldOnStoreData   : TStStoreDataEvent;
begin
  HoldOnCompare := FContainer.OnCompare;
  HoldOnDisposeData := FContainer.OnDisposeData;
  HoldOnLoadData := FContainer.OnLoadData;
  HoldOnStoreData := FContainer.OnStoreData;
  FContainer.Free;
  FContainer := TStCollection.Create(FPageElements);
  FContainer.OnCompare := HoldOnCompare;
  FContainer.OnDisposeData := HoldOnDisposeData;
  FContainer.OnLoadData := HoldOnLoadData;
  FContainer.OnStoreData := HoldOnStoreData;
end;

procedure TStNVCollection.SetOnCompare(Value : TStCompareEvent);
begin
  FContainer.OnCompare := Value;
end;

procedure TStNVCollection.SetOnDisposeData(Value : TStDisposeDataEvent);
begin
  FContainer.OnDisposeData := Value;
end;

procedure TStNVCollection.SetOnLoadData(Value : TStLoadDataEvent);
begin
  FContainer.OnLoadData := Value;
end;

procedure TStNVCollection.SetOnStoreData(Value : TStStoreDataEvent);
begin
  FContainer.OnStoreData := Value;
end;

procedure TStNVCollection.SetPageElements(Value : Integer);
begin
  FPageElements := Value;
  RecreateContainer;
end;


end.
1	// Upgraded to Delphi 2009: Sebastian Zierer
2
3	(* *** BEGIN LICENSE BLOCK ***
4	* Version: MPL 1.1
5	*
6	* The contents of this file are subject to the Mozilla Public License Version
7	* 1.1 (the "License"); you may not use this file except in compliance with
8	* the License. You may obtain a copy of the License at
9	* http://www.mozilla.org/MPL/
10	*
11	* Software distributed under the License is distributed on an "AS IS" basis,
12	* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
13	* for the specific language governing rights and limitations under the
14	* License.
15	*
16	* The Original Code is TurboPower SysTools
17	*
18	* The Initial Developer of the Original Code is
19	* TurboPower Software
20	*
21	* Portions created by the Initial Developer are Copyright (C) 1996-2002
22	* the Initial Developer. All Rights Reserved.
23	*
24	* Contributor(s):
25	*
26	* *** END LICENSE BLOCK *** *)
27
28	{*********************************************************}
29	{* SysTools: StNVColl.pas 4.04 *}
30	{*********************************************************}
31	{* SysTools: non visual component for TStCollection *}
32	{*********************************************************}
33
34	{$I StDefine.inc}
35
36	unit StNVColl;
37
38	interface
39
40	uses
41	Windows, Classes,
42	StBase, StColl, StNVCont;
43
44	type
45	TStNVCollection = class(TStNVContainerBase)
46	{.Z+}
47	protected {private}
48	{property variables}
49	FContainer : TStCollection; {instance of the container}
50	FPageElements : Integer;
51
52	{property methods}
53	procedure SetPageElements(Value : Integer);
54
55	{internal methods}
56	procedure RecreateContainer;
57
58	protected
59	function GetOnCompare : TStCompareEvent;
60	override;
61	function GetOnDisposeData : TStDisposeDataEvent;
62	override;
63	function GetOnLoadData : TStLoadDataEvent;
64	override;
65	function GetOnStoreData : TStStoreDataEvent;
66	override;
67	procedure SetOnCompare(Value : TStCompareEvent);
68	override;
69	procedure SetOnDisposeData(Value : TStDisposeDataEvent);
70	override;
71	procedure SetOnLoadData(Value : TStLoadDataEvent);
72	override;
73	procedure SetOnStoreData(Value : TStStoreDataEvent);
74	override;
75
76	public
77	constructor Create(AOwner : TComponent);
78	override;
79	destructor Destroy;
80	override;
81	{.Z-}
82
83	property Container : TStCollection
84	read FContainer;
85
86	published
87	property PageElements : Integer
88	read FPageElements
89	write SetPageElements default 1000;
90
91	property OnCompare;
92	property OnDisposeData;
93	property OnLoadData;
94	property OnStoreData;
95	end;
96
97
98	implementation
99
100	{* TStNVCollection *}
101
102	constructor TStNVCollection.Create(AOwner : TComponent);
103	begin
104	inherited Create(AOwner);
105
106	{defaults}
107	FPageElements := 1000;
108
109	if Classes.GetClass(TStCollection.ClassName) = nil then
110	RegisterClass(TStCollection);
111
112	FContainer := TStCollection.Create(FPageElements);
113	end;
114
115	destructor TStNVCollection.Destroy;
116	begin
117	FContainer.Free;
118	FContainer := nil;
119
120	inherited Destroy;
121	end;
122
123	function TStNVCollection.GetOnCompare : TStCompareEvent;
124	begin
125	Result := FContainer.OnCompare;
126	end;
127
128	function TStNVCollection.GetOnDisposeData : TStDisposeDataEvent;
129	begin
130	Result := FContainer.OnDisposeData;
131	end;
132
133	function TStNVCollection.GetOnLoadData : TStLoadDataEvent;
134	begin
135	Result := FContainer.OnLoadData;
136	end;
137
138	function TStNVCollection.GetOnStoreData : TStStoreDataEvent;
139	begin
140	Result := FContainer.OnStoreData;
141	end;
142
143	procedure TStNVCollection.RecreateContainer;
144	var
145	HoldOnCompare : TStCompareEvent;
146	HoldOnDisposeData : TStDisposeDataEvent;
147	HoldOnLoadData : TStLoadDataEvent;
148	HoldOnStoreData : TStStoreDataEvent;
149	begin
150	HoldOnCompare := FContainer.OnCompare;
151	HoldOnDisposeData := FContainer.OnDisposeData;
152	HoldOnLoadData := FContainer.OnLoadData;
153	HoldOnStoreData := FContainer.OnStoreData;
154	FContainer.Free;
155	FContainer := TStCollection.Create(FPageElements);
156	FContainer.OnCompare := HoldOnCompare;
157	FContainer.OnDisposeData := HoldOnDisposeData;
158	FContainer.OnLoadData := HoldOnLoadData;
159	FContainer.OnStoreData := HoldOnStoreData;
160	end;
161
162	procedure TStNVCollection.SetOnCompare(Value : TStCompareEvent);
163	begin
164	FContainer.OnCompare := Value;
165	end;
166
167	procedure TStNVCollection.SetOnDisposeData(Value : TStDisposeDataEvent);
168	begin
169	FContainer.OnDisposeData := Value;
170	end;
171
172	procedure TStNVCollection.SetOnLoadData(Value : TStLoadDataEvent);
173	begin
174	FContainer.OnLoadData := Value;
175	end;
176
177	procedure TStNVCollection.SetOnStoreData(Value : TStStoreDataEvent);
178	begin
179	FContainer.OnStoreData := Value;
180	end;
181
182	procedure TStNVCollection.SetPageElements(Value : Integer);
183	begin
184	FPageElements := Value;
185	RecreateContainer;
186	end;
187
188
189	end.