← Back to branch summary

~ubuntu-branches/ubuntu/saucy/lazarus/saucy

« back to all changes in this revision

Viewing changes to debugger/breakpropertydlg.pas

  • Committer: Package Import Robot
  • Author(s): Paul Gevers, Abou Al Montacir, Bart Martens, Paul Gevers
  • Date: 2013-06-08 14:12:17 UTC
  • mfrom: (1.1.9)
  • Revision ID: package-import@ubuntu.com-20130608141217-7k0cy9id8ifcnutc
Tags: 1.0.8+dfsg-1
http://bugs.debian.org/708695
[ Abou Al Montacir ]
* New upstream major release and multiple maintenace release offering many
  fixes and new features marking a new milestone for the Lazarus development
  and its stability level.
  - The detailed list of changes can be found here:
    http://wiki.lazarus.freepascal.org/Lazarus_1.0_release_notes
    http://wiki.lazarus.freepascal.org/Lazarus_1.0_fixes_branch
* LCL changes:
  - LCL is now a normal package.
      + Platform independent parts of the LCL are now in the package LCLBase
      + LCL is automatically recompiled when switching the target platform,
        unless pre-compiled binaries for this target are already installed.
      + No impact on existing projects.
      + Linker options needed by LCL are no more added to projects that do
        not use the LCL package.
  - Minor changes in LCL basic classes behaviour
      + TCustomForm.Create raises an exception if a form resource is not
        found.
      + TNotebook and TPage: a new implementation of these classes was added.
      + TDBNavigator: It is now possible to have focusable buttons by setting
        Options = [navFocusableButtons] and TabStop = True, useful for
        accessibility and for devices with neither mouse nor touch screen.
      + Names of TControlBorderSpacing.GetSideSpace and GetSpace were swapped
        and are now consistent. GetSideSpace = Around + GetSpace.
      + TForm.WindowState=wsFullscreen was added
      + TCanvas.TextFitInfo was added to calculate how many characters will
        fit into a specified Width. Useful for word-wrapping calculations.
      + TControl.GetColorResolvingParent and
        TControl.GetRGBColorResolvingParent were added, simplifying the work
        to obtain the final color of the control while resolving clDefault
        and the ParentColor.
      + LCLIntf.GetTextExtentExPoint now has a good default implementation
        which works in any platform not providing a specific implementation.
        However, Widgetset specific implementation is better, when available.
      + TTabControl was reorganized. Now it has the correct class hierarchy
        and inherits from TCustomTabControl as it should.
  - New unit in the LCL:
      + lazdialogs.pas: adds non-native versions of various native dialogs,
        for example TLazOpenDialog, TLazSaveDialog, TLazSelectDirectoryDialog.
        It is used by widgetsets which either do not have a native dialog, or
        do not wish to use it because it is limited. These dialogs can also be
        used by user applications directly.
      + lazdeviceapis.pas: offers an interface to more hardware devices such
        as the accelerometer, GPS, etc. See LazDeviceAPIs
      + lazcanvas.pas: provides a TFPImageCanvas descendent implementing
        drawing in a LCL-compatible way, but 100% in Pascal.
      + lazregions.pas. LazRegions is a wholly Pascal implementation of
        regions for canvas clipping, event clipping, finding in which control
        of a region tree one an event should reach, for drawing polygons, etc.
      + customdrawncontrols.pas, customdrawndrawers.pas,
        customdrawn_common.pas, customdrawn_android.pas and
        customdrawn_winxp.pas: are the Lazarus Custom Drawn Controls -controls
        which imitate the standard LCL ones, but with the difference that they
        are non-native and support skinning.
  - New APIs added to the LCL to improve support of accessibility software
    such as screen readers.
* IDE changes:
  - Many improvments.
  - The detailed list of changes can be found here:
    http://wiki.lazarus.freepascal.org/New_IDE_features_since#v1.0_.282012-08-29.29
    http://wiki.lazarus.freepascal.org/Lazarus_1.0_release_notes#IDE_Changes
* Debugger / Editor changes:
  - Added pascal sources and breakpoints to the disassembler
  - Added threads dialog.
* Components changes:
  - TAChart: many fixes and new features
  - CodeTool: support Delphi style generics and new syntax extensions.
  - AggPas: removed to honor free licencing. (Closes: Bug#708695)
[Bart Martens]
* New debian/watch file fixing issues with upstream RC release.
[Abou Al Montacir]
* Avoid changing files in .pc hidden directory, these are used by quilt for
  internal purpose and could lead to surprises during build.
[Paul Gevers]
* Updated get-orig-source target and it compinion script orig-tar.sh so that they
  repack the source file, allowing bug 708695 to be fixed.

Show diffs side-by-side

added added

removed removed

Lines of Context:
debugger/breakpropertydlg.pas
5
5
interface
6
6
 
7
7
uses
8
 
  Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs, LCLProc,
9
 
  ExtCtrls, StdCtrls, Buttons, DebuggerDlg, Debugger, ButtonPanel, EditBtn,
10
 
  BaseDebugManager, IDEContextHelpEdit, LazarusIDEStrConsts, InputHistory;
 
8
  Classes, SysUtils, Forms, Controls, Graphics, Dialogs, ExtCtrls, StdCtrls,
 
9
  ButtonPanel, EditBtn, Spin, IDEHelpIntf, BreakPropertyDlgGroups, DebuggerDlg,
 
10
  Debugger, BaseDebugManager, LazarusIDEStrConsts, InputHistory, IDEProcs;
11
11
 
12
12
type
13
13
 
15
15
 
16
16
  TBreakPropertyDlg = class(TDebuggerDlg)
17
17
    ButtonPanel: TButtonPanel;
 
18
    chkTakeSnap: TCheckBox;
 
19
    chkLogCallStack: TCheckBox;
18
20
    chkEnableGroups: TCheckBox;
19
21
    chkDisableGroups: TCheckBox;
20
22
    chkEvalExpression: TCheckBox;
23
25
    cmbGroup: TComboBox;
24
26
    edtCondition: TComboBox;
25
27
    edtEvalExpression: TEdit;
 
28
    edtLine: TSpinEdit;
26
29
    edtLogMessage: TEdit;
27
30
    edtEnableGroups: TEditButton;
28
31
    edtDisableGroups: TEditButton;
29
32
    edtAutocontinueMS: TEdit;
30
33
    edtCounter: TEdit;
31
34
    edtFilename: TEdit;
32
 
    edtLine: TEdit;
33
35
    gbActions: TGroupBox;
 
36
    Label1: TLabel;
 
37
    lblWatchKind: TLabel;
 
38
    lblWatchScope: TLabel;
 
39
    lblLogCallStackLimit: TLabel;
34
40
    lblMS: TLabel;
35
41
    lblFileName: TLabel;
36
42
    lblLine: TLabel;
38
44
    lblHitCount: TLabel;
39
45
    lblGroup: TLabel;
40
46
    lblAutoContinue: TLabel;
 
47
    edtLogCallStack: TSpinEdit;
 
48
    rbWrite: TRadioButton;
 
49
    rbRead: TRadioButton;
 
50
    rbReadWrite: TRadioButton;
 
51
    rbGlobal: TRadioButton;
 
52
    rbLocal: TRadioButton;
 
53
    rgWatchKind: TPanel;
 
54
    rgWatchScope: TPanel;
41
55
    procedure btnHelpClick(Sender: TObject);
42
56
    procedure btnOKClick(Sender: TObject);
43
57
    procedure BreakPointRemove(const ASender: TIDEBreakPoints;
44
58
      const ABreakpoint: TIDEBreakPoint);
45
59
    procedure BreakPointUpdate(const ASender: TIDEBreakPoints;
46
60
      const ABreakpoint: TIDEBreakPoint);
 
61
    procedure chkDisableGroupsChange(Sender: TObject);
 
62
    procedure chkEnableGroupsChange(Sender: TObject);
 
63
    procedure chkEvalExpressionChange(Sender: TObject);
 
64
    procedure chkLogCallStackChange(Sender: TObject);
 
65
    procedure chkLogMessageChange(Sender: TObject);
 
66
    procedure cmbGroupKeyPress(Sender: TObject; var Key: char);
 
67
    procedure edtDisableGroupsButtonClick(Sender: TObject);
 
68
    procedure edtEnableGroupsButtonClick(Sender: TObject);
47
69
  private
48
70
    FBreakpointsNotification : TIDEBreakPointsNotification;
49
71
    FBreakpoint: TIDEBreakPoint;
 
72
    FUpdatingInfo: Boolean;
50
73
  protected
51
74
    procedure DoEndUpdate; override;
52
75
    procedure UpdateInfo;
67
90
  UpdateInfo;
68
91
end;
69
92
 
 
93
procedure TBreakPropertyDlg.chkDisableGroupsChange(Sender: TObject);
 
94
begin
 
95
  edtDisableGroups.Enabled := chkDisableGroups.Checked;
 
96
end;
 
97
 
 
98
procedure TBreakPropertyDlg.chkEnableGroupsChange(Sender: TObject);
 
99
begin
 
100
  edtEnableGroups.Enabled := chkEnableGroups.Checked;
 
101
end;
 
102
 
 
103
procedure TBreakPropertyDlg.chkEvalExpressionChange(Sender: TObject);
 
104
begin
 
105
  edtEvalExpression.Enabled := chkEvalExpression.Checked;
 
106
end;
 
107
 
 
108
procedure TBreakPropertyDlg.chkLogCallStackChange(Sender: TObject);
 
109
begin
 
110
  edtLogCallStack.Enabled := chkLogCallStack.Checked;
 
111
end;
 
112
 
 
113
procedure TBreakPropertyDlg.chkLogMessageChange(Sender: TObject);
 
114
begin
 
115
  edtLogMessage.Enabled := chkLogMessage.Checked;
 
116
end;
 
117
 
 
118
procedure TBreakPropertyDlg.cmbGroupKeyPress(Sender: TObject; var Key: char);
 
119
begin
 
120
  if Key = ';' then Key := #0;
 
121
end;
 
122
 
 
123
procedure TBreakPropertyDlg.edtDisableGroupsButtonClick(Sender: TObject);
 
124
var
 
125
  s: TCaption;
 
126
begin
 
127
  if FBreakpoint = nil then Exit;
 
128
  s := edtDisableGroups.Text;
 
129
  if ExecuteBreakPointGroupDlg(FBreakpoint, s, DebugBoss.BreakPointGroups, bgaDisable) = mrok
 
130
  then edtDisableGroups.Text := s;
 
131
end;
 
132
 
 
133
procedure TBreakPropertyDlg.edtEnableGroupsButtonClick(Sender: TObject);
 
134
var
 
135
  s: TCaption;
 
136
begin
 
137
  if FBreakpoint = nil then Exit;
 
138
  s := edtEnableGroups.Text;
 
139
  if ExecuteBreakPointGroupDlg(FBreakpoint, s, DebugBoss.BreakPointGroups, bgaEnable) = mrok
 
140
  then edtEnableGroups.Text := s;
 
141
end;
 
142
 
70
143
procedure TBreakPropertyDlg.btnHelpClick(Sender: TObject);
71
144
begin
72
 
  ShowContextHelpForIDE(Self);
 
145
  LazarusHelp.ShowHelpForIDEControl(Self);
73
146
end;
74
147
 
75
148
procedure TBreakPropertyDlg.BreakPointRemove(
80
153
end;
81
154
 
82
155
procedure TBreakPropertyDlg.btnOKClick(Sender: TObject);
 
156
  function CheckGroupList(Alist: TStringList): Boolean;
 
157
  var
 
158
    i: Integer;
 
159
    r: TModalResult;
 
160
    s: String;
 
161
    NewGroup: TIDEBreakPointGroup;
 
162
  begin
 
163
    Result := True;
 
164
    s := '';
 
165
  for i := 0 to Alist.Count-1 do begin
 
166
      if Alist[i] = '' then continue;
 
167
      if DebugBoss.BreakPointGroups.GetGroupByName(Alist[i]) = nil then
 
168
        s := s + ', ' + Alist[i];
 
169
    end;
 
170
    if s = '' then exit;
 
171
    delete(s, 1, 2);
 
172
    r := MessageDlg(Format(dbgBreakPropertyGroupNotFound, [LineEnding, s]),
 
173
                    mtConfirmation, [mbYes, mbIgnore, mbCancel], 0);
 
174
    if r = mrCancel then exit(False);
 
175
    if r = mrYes then begin
 
176
      for i := 0 to Alist.Count-1 do begin
 
177
        if Alist[i] = '' then continue;
 
178
        if DebugBoss.BreakPointGroups.GetGroupByName(Alist[i]) = nil then begin
 
179
          NewGroup := TIDEBreakPointGroup(DebugBoss.BreakPointGroups.Add);
 
180
          NewGroup.Name := Alist[i];
 
181
        end;
 
182
      end;
 
183
    end;
 
184
  end;
83
185
var
84
186
  Actions: TIDEBreakPointActions;
 
187
  GroupName: String;
 
188
  NewGroup: TIDEBreakPointGroup;
 
189
  ws: TDBGWatchPointScope;
 
190
  wk: TDBGWatchPointKind;
 
191
  i: SizeInt;
 
192
  EnableGroupList, DisableGroupList: TStringList;
85
193
begin
86
194
  if FBreakpoint = nil then Exit;
87
195
 
88
 
  FBreakpointsNotification.OnUpdate := nil;
89
 
  // filename
90
 
  // line
91
 
  FBreakpoint.SetLocation(edtFilename.Text, StrToIntDef(edtLine.Text, 1));
92
 
  // expression
93
 
  FBreakpoint.Expression := edtCondition.Text;
94
 
  // hitcount
95
 
  FBreakpoint.BreakHitCount := StrToIntDef(edtCounter.Text, FBreakpoint.HitCount);
96
 
  //auto continue
97
 
  FBreakpoint.AutoContinueTime := StrToIntDef(edtAutocontinueMS.Text, FBreakpoint.AutoContinueTime);
98
 
  // group
99
 
  FBreakpoint.Group := DebugBoss.BreakPointGroups.GetGroupByName(cmbGroup.Text);
100
 
  // actions
101
 
  Actions := [];
102
 
  if chkActionBreak.Checked then Include(Actions, bpaStop);
103
 
  if chkDisableGroups.Checked then Include(Actions, bpaDisableGroup);
104
 
  if chkEnableGroups.Checked then Include(Actions, bpaEnableGroup);
105
 
//  if chkEvalExpression.Checked then Include(Actions, bpaEValExpression);
106
 
//  if chkLogMessage.Checked then Include(Actions, bpaLogMessage);
107
 
  FBreakpoint.Actions := Actions;
108
 
 
109
 
  InputHistories.HistoryLists.GetList('BreakPointExpression', True).Add(edtCondition.Text);
 
196
  EnableGroupList := TStringList.Create;
 
197
  DisableGroupList := TStringList.Create;
 
198
 
 
199
  try
 
200
    EnableGroupList.Delimiter := ';';
 
201
    DisableGroupList.Delimiter := ';';
 
202
 
 
203
    EnableGroupList.DelimitedText := edtEnableGroups.Text+';'+edtDisableGroups.Text;
 
204
    if not CheckGroupList(EnableGroupList) then begin
 
205
      ModalResult :=  mrNone;
 
206
      exit;
 
207
    end;
 
208
 
 
209
    EnableGroupList.DelimitedText := edtEnableGroups.Text;
 
210
    DisableGroupList.DelimitedText := edtDisableGroups.Text;
 
211
 
 
212
    FBreakpointsNotification.OnUpdate := nil;
 
213
    case FBreakpoint.Kind of
 
214
      bpkSource:
 
215
        begin
 
216
          // filename + line
 
217
          FBreakpoint.SetLocation(edtFilename.Text, edtLine.Value);
 
218
        end;
 
219
      bpkAddress:
 
220
        begin
 
221
          FBreakpoint.SetAddress(StrToQWordDef(edtFilename.Text, 0));
 
222
        end;
 
223
      bpkData:
 
224
        begin
 
225
          if rbGlobal.Checked
 
226
          then ws := wpsGlobal
 
227
          else ws := wpsLocal;
 
228
          wk := wpkWrite;
 
229
          if rbRead.Checked
 
230
          then wk := wpkRead;
 
231
          if rbReadWrite.Checked
 
232
          then wk := wpkReadWrite;
 
233
          FBreakpoint.SetWatch(edtFilename.Text, ws, wk);
 
234
        end;
 
235
    end;
 
236
    // expression
 
237
    FBreakpoint.Expression := edtCondition.Text;
 
238
    // hitcount
 
239
    FBreakpoint.BreakHitCount := StrToIntDef(edtCounter.Text, FBreakpoint.HitCount);
 
240
    //auto continue
 
241
    FBreakpoint.AutoContinueTime := StrToIntDef(edtAutocontinueMS.Text, FBreakpoint.AutoContinueTime);
 
242
    // group
 
243
    GroupName := cmbGroup.Text;
 
244
    NewGroup := DebugBoss.BreakPointGroups.GetGroupByName(GroupName);
 
245
    if not Assigned(NewGroup) and (GroupName <> '') then
 
246
    begin
 
247
      NewGroup := TIDEBreakPointGroup(DebugBoss.BreakPointGroups.Add);
 
248
      NewGroup.Name := GroupName;
 
249
    end;
 
250
    FBreakpoint.Group := NewGroup;
 
251
    // enable groups
 
252
    for i := 0 to DebugBoss.BreakPointGroups.Count-1 do begin
 
253
      NewGroup := DebugBoss.BreakPointGroups[i];
 
254
      if EnableGroupList.IndexOf(NewGroup.Name) >= 0
 
255
      then FBreakpoint.EnableGroupList.Add(NewGroup)
 
256
      else FBreakpoint.EnableGroupList.Remove(NewGroup);
 
257
    end;
 
258
    // disable groups
 
259
    for i := 0 to DebugBoss.BreakPointGroups.Count-1 do begin
 
260
      NewGroup := DebugBoss.BreakPointGroups[i];
 
261
      if DisableGroupList.IndexOf(NewGroup.Name) >= 0
 
262
      then FBreakpoint.DisableGroupList.Add(NewGroup)
 
263
      else FBreakpoint.DisableGroupList.Remove(NewGroup);
 
264
    end;
 
265
    // actions
 
266
    Actions := [];
 
267
    if chkActionBreak.Checked then Include(Actions, bpaStop);
 
268
    if chkDisableGroups.Checked then Include(Actions, bpaDisableGroup);
 
269
    if chkEnableGroups.Checked then Include(Actions, bpaEnableGroup);
 
270
    if chkEvalExpression.Checked then Include(Actions, bpaEValExpression);
 
271
    if chkLogMessage.Checked then Include(Actions, bpaLogMessage);
 
272
    if chkLogCallStack.Checked then Include(Actions, bpaLogCallStack);
 
273
    if chkTakeSnap.Checked then include(Actions, bpaTakeSnapshot);
 
274
    FBreakpoint.Actions := Actions;
 
275
    FBreakpoint.LogEvalExpression := edtEvalExpression.Text;
 
276
    FBreakpoint.LogMessage := edtLogMessage.Text;
 
277
    FBreakpoint.LogCallStackLimit := edtLogCallStack.Value;
 
278
 
 
279
    InputHistories.HistoryLists.GetList('BreakPointExpression', True,
 
280
      rltCaseSensitive).Add(edtCondition.Text);
 
281
  finally
 
282
    EnableGroupList.Free;
 
283
    DisableGroupList.Free;
 
284
  end;
110
285
end;
111
286
 
112
287
procedure TBreakPropertyDlg.DoEndUpdate;
118
293
procedure TBreakPropertyDlg.UpdateInfo;
119
294
var
120
295
  Actions: TIDEBreakPointActions;
 
296
  I: Integer;
 
297
  s: String;
121
298
begin
 
299
  FUpdatingInfo := True;
122
300
  if FBreakpoint = nil then Exit;
123
 
  // filename
124
 
  edtFilename.text := FBreakpoint.Source;
125
 
  // line
126
 
  if FBreakpoint.Line > 0
127
 
  then edtLine.Text := IntToStr(FBreakpoint.Line)
128
 
  else edtLine.Text := '';
 
301
  case FBreakpoint.Kind of
 
302
    bpkSource:
 
303
      begin
 
304
        // filename
 
305
        edtFilename.Text := FBreakpoint.Source;
 
306
        // line
 
307
        if FBreakpoint.Line > 0
 
308
        then edtLine.Value := FBreakpoint.Line
 
309
        else edtLine.Value := 0;
 
310
      end;
 
311
    bpkAddress:
 
312
      begin
 
313
        edtFilename.Text := '$' + IntToHex(FBreakpoint.Address, 8); // todo: 8/16 depends on platform
 
314
      end;
 
315
    bpkData:
 
316
      begin
 
317
        edtFilename.Text := FBreakpoint.WatchData;
 
318
        rbGlobal.Checked := FBreakpoint.WatchScope = wpsGlobal;
 
319
        rbLocal.Checked := FBreakpoint.WatchScope = wpsLocal;
 
320
        rbWrite.Checked := FBreakpoint.WatchKind = wpkWrite;
 
321
        rbRead.Checked := FBreakpoint.WatchKind = wpkRead;
 
322
        rbReadWrite.Checked := FBreakpoint.WatchKind = wpkReadWrite;
 
323
      end;
 
324
  end;
129
325
  // expression
130
326
  edtCondition.Text := FBreakpoint.Expression;
131
327
  // hitcount
133
329
  // auto continue
134
330
  edtAutocontinueMS.Text := IntToStr(FBreakpoint.AutoContinueTime);
135
331
  // group
 
332
  for I := 0 to DebugBoss.BreakPointGroups.Count - 1 do
 
333
    cmbGroup.Items.Add(DebugBoss.BreakPointGroups[I].Name);
136
334
  if FBreakpoint.Group = nil
137
335
  then cmbGroup.Text := ''
138
336
  else cmbGroup.Text := FBreakpoint.Group.Name;
 
337
  // enable groups
 
338
  s := '';
 
339
  for i := 0 to FBreakpoint.EnableGroupList.Count - 1 do begin
 
340
    if s <> '' then s := s + ';';
 
341
    s := s + FBreakpoint.EnableGroupList[i].Name;
 
342
  end;
 
343
  edtEnableGroups.Text := s;
 
344
  // disable groups
 
345
  s := '';
 
346
  for i := 0 to FBreakpoint.DisableGroupList.Count - 1 do begin
 
347
    if s <> '' then s := s + ';';
 
348
    s := s + FBreakpoint.DisableGroupList[i].Name;
 
349
  end;
 
350
  edtDisableGroups.Text := s;
139
351
 
140
352
  // actions
141
353
  Actions := FBreakpoint.Actions;
142
354
  chkActionBreak.Checked := bpaStop in Actions;
143
355
  chkDisableGroups.Checked := bpaDisableGroup in Actions;
144
356
  chkEnableGroups.Checked := bpaEnableGroup in Actions;
145
 
//  chkEvalExpression.Checked := bpaEValExpression in Actions;
146
 
//  chkLogMessage.Checked := bpaLogMessage in Actions;
 
357
  chkEvalExpression.Checked := bpaEValExpression in Actions;
 
358
  chkLogMessage.Checked := bpaLogMessage in Actions;
 
359
  edtLogMessage.Text := FBreakpoint.LogMessage;
 
360
  edtEvalExpression.Text := FBreakpoint.LogEvalExpression;
 
361
  chkLogCallStack.Checked := bpaLogCallStack in Actions;
 
362
  edtLogCallStack.Value := FBreakpoint.LogCallStackLimit;
 
363
  chkTakeSnap.Checked := bpaTakeSnapshot in Actions;
 
364
  FUpdatingInfo := False;
147
365
end;
148
366
 
149
367
constructor TBreakPropertyDlg.Create(AOwner: TComponent; ABreakPoint: TIDEBreakPoint);
151
369
  inherited Create(AOwner);
152
370
 
153
371
  Caption := lisBreakPointProperties;
154
 
  lblFileName.Caption := lisPEFilename;
155
 
  lblLine.Caption := lisLine;
 
372
  case ABreakPoint.Kind of
 
373
    bpkSource:
 
374
      begin
 
375
        lblFileName.Caption := lisPEFilename;
 
376
        lblLine.Caption := lisLine;
 
377
      end;
 
378
    bpkAddress:
 
379
      begin
 
380
        lblFileName.Caption := lisAddress;
 
381
        lblLine.Visible := False;
 
382
        edtLine.Visible := False;
 
383
        edtFilename.ReadOnly := False;
 
384
        edtFilename.Color := clDefault;
 
385
      end;
 
386
    bpkData:
 
387
      begin
 
388
        lblFileName.Caption := lisWatchData;
 
389
        lblLine.Visible := False;
 
390
        edtLine.Visible := False;
 
391
        edtFilename.ReadOnly := False;
 
392
        edtFilename.Color := clDefault;
 
393
        lblWatchKind.Visible := True;
 
394
        lblWatchScope.Visible := True;
 
395
        rgWatchKind.Visible := True;
 
396
        rgWatchScope.Visible := True;
 
397
        lblWatchScope.Caption := lisWatchScope;
 
398
        lblWatchKind.Caption := lisWatchKind;
 
399
        rbGlobal.Caption := lisWatchScopeGlobal;
 
400
        rbLocal.Caption := lisWatchScopeLocal;
 
401
        rbWrite.Caption := lisWatchKindWrite;
 
402
        rbRead.Caption := lisWatchKindRead;
 
403
        rbReadWrite.Caption := lisWatchKindReadWrite;
 
404
      end;
 
405
  end;
156
406
  lblCondition.Caption := lisCondition + ':';
157
407
  lblHitCount.Caption := lisHitCount + ':';
158
408
  lblAutoContinue.Caption := lisAutoContinueAfter;
160
410
  lblGroup.Caption := lisGroup + ':';
161
411
  gbActions.Caption := lisActions;
162
412
  chkActionBreak.Caption := lisBreak;
163
 
  chkEnableGroups.Caption := lisEnableGroup;
164
 
  chkDisableGroups.Caption := lisDisableGroup;
 
413
  chkEnableGroups.Caption := lisEnableGroups;
 
414
  chkDisableGroups.Caption := lisDisableGroups;
165
415
  chkEvalExpression.Caption := lisEvalExpression;
166
416
  chkLogMessage.Caption := lisLogMessage;
167
 
  edtCondition.Items.Assign(InputHistories.HistoryLists.GetList('BreakPointExpression', True));
 
417
  chkLogCallStack.Caption := lisLogCallStack;
 
418
  lblLogCallStackLimit.Caption := lisLogCallStackLimit;
 
419
  chkTakeSnap.Caption := lisTakeSnapshot;
 
420
  edtCondition.Items.Assign(InputHistories.HistoryLists.GetList(
 
421
    'BreakPointExpression', True,rltCaseSensitive));
168
422
 
169
423
  FBreakpoint := ABreakPoint;
170
424
  FBreakpointsNotification := TIDEBreakPointsNotification.Create;
173
427
  FBreakpointsNotification.OnRemove := @BreakPointRemove;
174
428
  UpdateInfo;
175
429
 
176
 
  ButtonPanel.OKButton.OnClick := @btnOKClick;
177
 
  ButtonPanel.HelpButton.OnClick := @btnHelpClick;
 
430
  ButtonPanel.OKButton.Caption:=lisMenuOk;
 
431
  ButtonPanel.HelpButton.Caption:=lisMenuHelp;
 
432
  ButtonPanel.CancelButton.Caption:=lisCancel;
178
433
end;
179
434
 
180
435
destructor TBreakPropertyDlg.Destroy;