trunk/design/IBTransactionEdit.pas

{************************************************************************}
{                                                                        }
{       Borland Delphi Visual Component Library                          }
{       InterBase Express core components                                }
{                                                                        }
{       Copyright (c) 1998-2000 Inprise Corporation                      }
{                                                                        }
{    InterBase Express is based in part on the product                   }
{    Free IB Components, written by Gregory H. Deatz for                 }
{    Hoagland, Longo, Moran, Dunst & Doukas Company.                     }
{    Free IB Components is used under license.                           }
{                                                                        }
{    The contents of this file are subject to the InterBase              }
{    Public License Version 1.0 (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.Inprise.com/IPL.html }
{    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 was created by InterBase Software Corporation     }
{       and its successors.                                              }
{    Portions created by Inprise Corporation are Copyright (C) Inprise   }
{       Corporation. All Rights Reserved.                                }
{    Contributor(s): Jeff Overcash                                       }
{                                                                        }
{************************************************************************}

unit IBTransactionEdit;

{$MODE Delphi}

interface

uses
  {Windows,} Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
  StdCtrls, IBDataBase, IB, ExtCtrls, IBXConst, LResources;

type

  { TIBTransactionEditForm }

  TIBTransactionEditForm = class(TForm)
    GroupBox1: TGroupBox;
    HelpBtn: TButton;
    Cancelbtn: TButton;
    OKBtn: TButton;
    rbOtherButton: TRadioButton;
    rbSnapShot: TRadioButton;
    rbReadCommitted: TRadioButton;
    rbReadOnlyTableStability: TRadioButton;
    rbReadWriteTableStability: TRadioButton;
    TransactionParams: TMemo;
    Panel1: TPanel;
    Label1: TLabel;
    procedure OKBtnClick(Sender: TObject);
    procedure rbSnapShotClick(Sender: TObject);
    procedure rbReadCommittedClick(Sender: TObject);
    procedure rbReadOnlyTableStabilityClick(Sender: TObject);
    procedure rbReadWriteTableStabilityClick(Sender: TObject);
    procedure FormCreate(Sender: TObject);
    procedure HelpBtnClick(Sender: TObject);
    procedure TransactionParamsClick(Sender: TObject);
    procedure TransactionParamsExit(Sender: TObject);

  private
    { Private declarations }
    Transaction: TIBTransaction;
    function Edit: Boolean;
    procedure ParseParams;
    procedure ClearParamSelection;

  public
    { Public declarations }
  end;

var
  IBTransactionEditForm: TIBTransactionEditForm;

  function EditIBtransaction(Atransaction: TIBtransaction): Boolean;

implementation

{$R *.lfm}

function EditIBtransaction(ATransaction: TIBtransaction): Boolean;
begin
  with TIBtransactionEditForm.Create(Application) do
  try
    Transaction := ATransaction;
    Result := Edit;
  finally
    Free;
  end;
end;

function TIBtransactionEditForm.Edit: Boolean;
begin
  TransactionParams.Lines := Transaction.Params;
  ParseParams;
  Result := False;
  if ShowModal = mrOk then
  begin
    Transaction.Params := TransactionParams.Lines;
    Result := True;
  end;
end;

type
  TTransactionParam = (concurrency, read_committed, rec_version, nowait,
    consistency, read, write);
  TTransactionParams = set of TTransactionParam;

procedure TIBTransactionEditForm.ParseParams;
var
  I: Integer;
  st: string;
  Value: TTransactionParams;

begin
  Value := [];
  for I := 0 to TransactionParams.Lines.Count - 1 do
  begin
    st := LowerCase(Trim(TransactionParams.Lines[I]));
    if st = '' then
      continue;
    if st = 'concurrency' then
      Include(Value, concurrency)
    else if st = 'read_committed' then
      Include(Value, read_committed)
    else if st = 'rec_version' then
      Include(Value, rec_version)
    else if st = 'nowait' then
      Include(Value, nowait)
    else if st = 'read' then
      Include(Value, read)
    else if st = 'write' then
      Include(Value, write)
    else if st = 'consistency' then
      Include(Value, consistency)
    else begin
      Value := [];
      break;
    end;
  end;
  ClearParamSelection;
  if Value = [concurrency, nowait] then
    rbSnapShot.Checked := True
  else if Value = [read_committed, rec_version, nowait] then
    rbReadCommitted.Checked := True
  else if Value = [read, consistency] then
    rbReadOnlyTableStability.Checked := True
  else if Value = [write, consistency] then
    rbReadWriteTableStability.Checked := True
  else
    rbOtherButton.Checked := true
end;

procedure TIBTransactionEditForm.ClearParamSelection;
begin
  rbSnapShot.Checked := False;
  rbReadCommitted.Checked := False;
  rbReadOnlyTableStability.Checked := False;
  rbReadWriteTableStability.Checked := False;
end;

procedure TIBTransactionEditForm.OKBtnClick(Sender: TObject);
begin
  ModalResult := mrNone;
  if Transaction.Active then
  begin
    if MessageDlg(SCommitTransaction, mtConfirmation,
      mbOkCancel, 0) <> mrOk then Exit;
    Transaction.Rollback;
  end;
  ModalResult := mrOk;
end;

procedure TIBTransactionEditForm.FormCreate(Sender: TObject);
begin
//  HelpContext := hcDIBTransactionEdit;
end;

procedure TIBTransactionEditForm.HelpBtnClick(Sender: TObject);
begin
  Application.HelpContext(HelpContext);
end;

procedure TIBTransactionEditForm.rbSnapShotClick(Sender: TObject);
begin
  TransactionParams.clear;
  TransactionParams.Lines.Add('concurrency'); { do not localize }
  TransactionParams.Lines.Add('nowait'); { do not localize }
end;

procedure TIBTransactionEditForm.rbReadCommittedClick(Sender: TObject);
begin
  TransactionParams.clear;
  TransactionParams.Lines.Add('read_committed'); { do not localize }
  TransactionParams.Lines.Add('rec_version'); { do not localize }
  TransactionParams.Lines.Add('nowait'); { do not localize }
end;

procedure TIBTransactionEditForm.rbReadOnlyTableStabilityClick(Sender: TObject);
begin
  TransactionParams.clear;
  TransactionParams.Lines.Add('read'); { do not localize }
  TransactionParams.Lines.Add('consistency'); { do not localize }
end;

procedure TIBTransactionEditForm.rbReadWriteTableStabilityClick(Sender: TObject);
begin
  TransactionParams.clear;
  TransactionParams.Lines.Add('write'); { do not localize }
  TransactionParams.Lines.Add('consistency'); { do not localize }
end;

procedure TIBTransactionEditForm.TransactionParamsClick(Sender: TObject);
begin
  ClearParamSelection;
end;

procedure TIBTransactionEditForm.TransactionParamsExit(Sender: TObject);
begin
  ParseParams;
end;


end.
Revision:	19
Committed:	Mon Jul 7 13:00:15 2014 UTC (10 years, 5 months ago) by tony
Content type:	text/x-pascal
File size:	7537 byte(s)
Log Message:	Committing updates for Release R1-1-0
#	Content
1	{************************************************************************}
2	{ }
3	{ Borland Delphi Visual Component Library }
4	{ InterBase Express core components }
5	{ }
6	{ Copyright (c) 1998-2000 Inprise Corporation }
7	{ }
8	{ InterBase Express is based in part on the product }
9	{ Free IB Components, written by Gregory H. Deatz for }
10	{ Hoagland, Longo, Moran, Dunst & Doukas Company. }
11	{ Free IB Components is used under license. }
12	{ }
13	{ The contents of this file are subject to the InterBase }
14	{ Public License Version 1.0 (the "License"); you may not }
15	{ use this file except in compliance with the License. You }
16	{ may obtain a copy of the License at http://www.Inprise.com/IPL.html }
17	{ Software distributed under the License is distributed on }
18	{ an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either }
19	{ express or implied. See the License for the specific language }
20	{ governing rights and limitations under the License. }
21	{ The Original Code was created by InterBase Software Corporation }
22	{ and its successors. }
23	{ Portions created by Inprise Corporation are Copyright (C) Inprise }
24	{ Corporation. All Rights Reserved. }
25	{ Contributor(s): Jeff Overcash }
26	{ }
27	{************************************************************************}
28
29	unit IBTransactionEdit;
30
31	{$MODE Delphi}
32
33	interface
34
35	uses
36	{Windows,} Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
37	StdCtrls, IBDataBase, IB, ExtCtrls, IBXConst, LResources;
38
39	type
40
41	{ TIBTransactionEditForm }
42
43	TIBTransactionEditForm = class(TForm)
44	GroupBox1: TGroupBox;
45	HelpBtn: TButton;
46	Cancelbtn: TButton;
47	OKBtn: TButton;
48	rbOtherButton: TRadioButton;
49	rbSnapShot: TRadioButton;
50	rbReadCommitted: TRadioButton;
51	rbReadOnlyTableStability: TRadioButton;
52	rbReadWriteTableStability: TRadioButton;
53	TransactionParams: TMemo;
54	Panel1: TPanel;
55	Label1: TLabel;
56	procedure OKBtnClick(Sender: TObject);
57	procedure rbSnapShotClick(Sender: TObject);
58	procedure rbReadCommittedClick(Sender: TObject);
59	procedure rbReadOnlyTableStabilityClick(Sender: TObject);
60	procedure rbReadWriteTableStabilityClick(Sender: TObject);
61	procedure FormCreate(Sender: TObject);
62	procedure HelpBtnClick(Sender: TObject);
63	procedure TransactionParamsClick(Sender: TObject);
64	procedure TransactionParamsExit(Sender: TObject);
65
66	private
67	{ Private declarations }
68	Transaction: TIBTransaction;
69	function Edit: Boolean;
70	procedure ParseParams;
71	procedure ClearParamSelection;
72
73	public
74	{ Public declarations }
75	end;
76
77	var
78	IBTransactionEditForm: TIBTransactionEditForm;
79
80	function EditIBtransaction(Atransaction: TIBtransaction): Boolean;
81
82	implementation
83
84	{$R *.lfm}
85
86	function EditIBtransaction(ATransaction: TIBtransaction): Boolean;
87	begin
88	with TIBtransactionEditForm.Create(Application) do
89	try
90	Transaction := ATransaction;
91	Result := Edit;
92	finally
93	Free;
94	end;
95	end;
96
97	function TIBtransactionEditForm.Edit: Boolean;
98	begin
99	TransactionParams.Lines := Transaction.Params;
100	ParseParams;
101	Result := False;
102	if ShowModal = mrOk then
103	begin
104	Transaction.Params := TransactionParams.Lines;
105	Result := True;
106	end;
107	end;
108
109	type
110	TTransactionParam = (concurrency, read_committed, rec_version, nowait,
111	consistency, read, write);
112	TTransactionParams = set of TTransactionParam;
113
114	procedure TIBTransactionEditForm.ParseParams;
115	var
116	I: Integer;
117	st: string;
118	Value: TTransactionParams;
119
120	begin
121	Value := [];
122	for I := 0 to TransactionParams.Lines.Count - 1 do
123	begin
124	st := LowerCase(Trim(TransactionParams.Lines[I]));
125	if st = '' then
126	continue;
127	if st = 'concurrency' then
128	Include(Value, concurrency)
129	else if st = 'read_committed' then
130	Include(Value, read_committed)
131	else if st = 'rec_version' then
132	Include(Value, rec_version)
133	else if st = 'nowait' then
134	Include(Value, nowait)
135	else if st = 'read' then
136	Include(Value, read)
137	else if st = 'write' then
138	Include(Value, write)
139	else if st = 'consistency' then
140	Include(Value, consistency)
141	else begin
142	Value := [];
143	break;
144	end;
145	end;
146	ClearParamSelection;
147	if Value = [concurrency, nowait] then
148	rbSnapShot.Checked := True
149	else if Value = [read_committed, rec_version, nowait] then
150	rbReadCommitted.Checked := True
151	else if Value = [read, consistency] then
152	rbReadOnlyTableStability.Checked := True
153	else if Value = [write, consistency] then
154	rbReadWriteTableStability.Checked := True
155	else
156	rbOtherButton.Checked := true
157	end;
158
159	procedure TIBTransactionEditForm.ClearParamSelection;
160	begin
161	rbSnapShot.Checked := False;
162	rbReadCommitted.Checked := False;
163	rbReadOnlyTableStability.Checked := False;
164	rbReadWriteTableStability.Checked := False;
165	end;
166
167	procedure TIBTransactionEditForm.OKBtnClick(Sender: TObject);
168	begin
169	ModalResult := mrNone;
170	if Transaction.Active then
171	begin
172	if MessageDlg(SCommitTransaction, mtConfirmation,
173	mbOkCancel, 0) <> mrOk then Exit;
174	Transaction.Rollback;
175	end;
176	ModalResult := mrOk;
177	end;
178
179	procedure TIBTransactionEditForm.FormCreate(Sender: TObject);
180	begin
181	// HelpContext := hcDIBTransactionEdit;
182	end;
183
184	procedure TIBTransactionEditForm.HelpBtnClick(Sender: TObject);
185	begin
186	Application.HelpContext(HelpContext);
187	end;
188
189	procedure TIBTransactionEditForm.rbSnapShotClick(Sender: TObject);
190	begin
191	TransactionParams.clear;
192	TransactionParams.Lines.Add('concurrency'); { do not localize }
193	TransactionParams.Lines.Add('nowait'); { do not localize }
194	end;
195
196	procedure TIBTransactionEditForm.rbReadCommittedClick(Sender: TObject);
197	begin
198	TransactionParams.clear;
199	TransactionParams.Lines.Add('read_committed'); { do not localize }
200	TransactionParams.Lines.Add('rec_version'); { do not localize }
201	TransactionParams.Lines.Add('nowait'); { do not localize }
202	end;
203
204	procedure TIBTransactionEditForm.rbReadOnlyTableStabilityClick(Sender: TObject);
205	begin
206	TransactionParams.clear;
207	TransactionParams.Lines.Add('read'); { do not localize }
208	TransactionParams.Lines.Add('consistency'); { do not localize }
209	end;
210
211	procedure TIBTransactionEditForm.rbReadWriteTableStabilityClick(Sender: TObject);
212	begin
213	TransactionParams.clear;
214	TransactionParams.Lines.Add('write'); { do not localize }
215	TransactionParams.Lines.Add('consistency'); { do not localize }
216	end;
217
218	procedure TIBTransactionEditForm.TransactionParamsClick(Sender: TObject);
219	begin
220	ClearParamSelection;
221	end;
222
223	procedure TIBTransactionEditForm.TransactionParamsExit(Sender: TObject);
224	begin
225	ParseParams;
226	end;
227
228
229	end.