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

« back to all changes in this revision

Viewing changes to ide/projectinspector.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
[ 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:
1
 
{  $Id: projectinspector.pas 31041 2011-06-04 11:45:59Z juha $  }
2
1
{
3
2
 /***************************************************************************
4
3
                          projectinspector.pas
30
29
 
31
30
  Abstract:
32
31
    TProjectInspectorForm is the form of the project inspector.
 
32
 
 
33
  ToDo:
 
34
    - show lfm/lrs files as sub items
 
35
    - dnd move
 
36
    - project groups:
 
37
      - activate
 
38
   popup menu:
 
39
      - copy file name
 
40
      - save
 
41
      - options
 
42
      - activate
 
43
      - compile
 
44
      - build
 
45
      - view source
 
46
      - close
 
47
      - remove project
 
48
      - build sooner Ctrl+Up
 
49
      - build later Ctrl+Down
 
50
      - compile all from here
 
51
      - build all from here
33
52
}
34
53
unit ProjectInspector;
35
54
 
38
57
interface
39
58
 
40
59
uses
41
 
  Classes, SysUtils, LCLProc, AvgLvlTree, Forms, Controls, Buttons,
 
60
  Classes, SysUtils, LCLProc, LCLType, AvgLvlTree, Forms, Controls, Buttons,
42
61
  ComCtrls, StdCtrls, Menus, Dialogs, Graphics, FileUtil, ExtCtrls,
43
 
  LazIDEIntf, IDECommands,
 
62
  LazIDEIntf, IDEHelpIntf, IDECommands,
44
63
  LazarusIDEStrConsts, IDEProcs, IDEOptionDefs, EnvironmentOpts,
45
 
  Project, AddToProjectDlg, PackageSystem, PackageDefs;
 
64
  Project, AddToProjectDlg, PackageSystem, PackageDefs, TreeFilterEdit;
46
65
  
47
66
type
48
67
  TOnAddUnitToProject =
55
74
                           ADependency: TPkgDependency): TModalResult of object;
56
75
 
57
76
  TProjectInspectorFlag = (
 
77
    pifAllChanged,
58
78
    pifItemsChanged,
59
79
    pifButtonsChanged,
60
 
    pifTitleChanged
 
80
    pifTitleChanged,
 
81
    pifWasHidden
61
82
    );
62
83
  TProjectInspectorFlags = set of TProjectInspectorFlag;
63
84
 
64
85
  { TProjectInspectorForm }
65
86
 
66
87
  TProjectInspectorForm = class(TForm)
67
 
    AddBitBtn: TSpeedButton;
68
88
    BtnPanel: TPanel;
69
 
    OpenBitBtn: TSpeedButton;
 
89
    DirectoryHierarchyButton: TSpeedButton;
 
90
    FilterEdit: TTreeFilterEdit;
 
91
    OpenButton: TSpeedButton;
70
92
    ItemsTreeView: TTreeView;
71
93
    ItemsPopupMenu: TPopupMenu;
72
 
    OptionsBitBtn: TSpeedButton;
73
 
    RemoveBitBtn: TSpeedButton;
 
94
    SortAlphabeticallyButton: TSpeedButton;
 
95
    // toolbar
 
96
    ToolBar: TToolBar;
 
97
    // toolbuttons
 
98
    AddBitBtn: TToolButton;
 
99
    RemoveBitBtn: TToolButton;
 
100
    OptionsBitBtn: TToolButton;
 
101
    HelpBitBtn: TToolButton;
74
102
    procedure AddBitBtnClick(Sender: TObject);
 
103
    procedure DirectoryHierarchyButtonClick(Sender: TObject);
75
104
    procedure ItemsPopupMenuPopup(Sender: TObject);
76
105
    procedure ItemsTreeViewDblClick(Sender: TObject);
77
 
    procedure ItemsTreeViewKeyDown(Sender: TObject; var Key: Word;
78
 
      Shift: TShiftState);
 
106
    procedure ItemsTreeViewGetImageIndex(Sender: TObject; Node: TTreeNode);
 
107
    procedure ItemsTreeViewKeyDown(Sender: TObject; var Key: Word; Shift: TShiftState);
79
108
    procedure ItemsTreeViewSelectionChanged(Sender: TObject);
80
109
    procedure MoveDependencyUpClick(Sender: TObject);
81
110
    procedure MoveDependencyDownClick(Sender: TObject);
82
111
    procedure SetDependencyDefaultFilenameMenuItemClick(Sender: TObject);
83
112
    procedure SetDependencyPreferredFilenameMenuItemClick(Sender: TObject);
84
113
    procedure ClearDependencyFilenameMenuItemClick(Sender: TObject);
85
 
    procedure OpenBitBtnClick(Sender: TObject);
 
114
    procedure OpenButtonClick(Sender: TObject);
86
115
    procedure OptionsBitBtnClick(Sender: TObject);
 
116
    procedure HelpBitBtnClick(Sender: TObject);
87
117
    procedure ProjectInspectorFormShow(Sender: TObject);
88
118
    procedure ReAddMenuItemClick(Sender: TObject);
89
119
    procedure RemoveBitBtnClick(Sender: TObject);
90
120
    procedure RemoveNonExistingFilesMenuItemClick(Sender: TObject);
 
121
    procedure SortAlphabeticallyButtonClick(Sender: TObject);
91
122
    procedure ToggleI18NForLFMMenuItemClick(Sender: TObject);
92
123
  private
 
124
    FIdleConnected: boolean;
93
125
    FOnAddDependency: TAddProjInspDepEvent;
94
126
    FOnAddUnitToProject: TOnAddUnitToProject;
95
127
    FOnOpen: TNotifyEvent;
97
129
    FOnRemoveDependency: TRemoveProjInspDepEvent;
98
130
    FOnRemoveFile: TRemoveProjInspFileEvent;
99
131
    FOnShowOptions: TNotifyEvent;
 
132
    FShowDirectoryHierarchy: boolean;
 
133
    FSortAlphabetically: boolean;
100
134
    FUpdateLock: integer;
101
135
    FLazProject: TProject;
102
 
    FilesNode: TTreeNode;
 
136
    FFilesNode: TTreeNode;
 
137
    FNextSelectedPart: TObject;// select this file/dependency on next update
103
138
    DependenciesNode: TTreeNode;
104
139
    RemovedDependenciesNode: TTreeNode;
105
140
    ImageIndexFiles: integer;
111
146
    ImageIndexRegisterUnit: integer;
112
147
    ImageIndexText: integer;
113
148
    ImageIndexBinary: integer;
 
149
    ImageIndexDirectory: integer;
114
150
    FFlags: TProjectInspectorFlags;
115
151
    procedure SetDependencyDefaultFilename(AsPreferred: boolean);
 
152
    procedure SetIdleConnected(const AValue: boolean);
116
153
    procedure SetLazProject(const AValue: TProject);
 
154
    procedure SetShowDirectoryHierarchy(const AValue: boolean);
 
155
    procedure SetSortAlphabetically(const AValue: boolean);
117
156
    procedure SetupComponents;
118
 
    procedure UpdateProjectItems;
 
157
    function ChooseImageIndex(Str: String; Data: TObject; var AIsEnabled: Boolean): Integer;
 
158
    procedure UpdateProjectFiles;
119
159
    procedure UpdateRequiredPackages;
120
 
    procedure UpdateRemovedRequiredPackages;
121
 
    function GetImageIndexOfFile(AFile: TUnitInfo): integer;
122
160
    procedure OnProjectBeginUpdate(Sender: TObject);
123
161
    procedure OnProjectEndUpdate(Sender: TObject; ProjectChanged: boolean);
124
162
  protected
125
163
    procedure KeyUp(var Key: Word; Shift: TShiftState); override;
126
 
    function ProjectFileToNodeText(AFile: TUnitInfo): string;
127
 
    function CompareUnitInfos(Tree: TAvgLvlTree; UnitInfo1, UnitInfo2: Pointer): integer;
 
164
    procedure IdleHandler(Sender: TObject; var Done: Boolean);
 
165
    procedure UpdateShowing; override;
128
166
  public
129
167
    constructor Create(TheOwner: TComponent); override;
130
168
    destructor Destroy; override;
131
169
    procedure BeginUpdate;
132
170
    procedure EndUpdate;
133
171
    function IsUpdateLocked: boolean;
134
 
    procedure UpdateAll;
 
172
    procedure UpdateAll(Immediately: boolean);
135
173
    procedure UpdateTitle;
136
174
    procedure UpdateButtons;
137
 
    procedure UpdateItems;
 
175
    procedure UpdateItems(Immediately: boolean);
138
176
    function GetSelectedFile: TUnitInfo;
139
177
    function GetSelectedDependency: TPkgDependency;
140
 
    function StoreCurrentTreeSelection: TStringList;
141
 
    procedure ApplyTreeSelection(ASelection: TStringList; FreeList: boolean);
142
178
  public
143
179
    property LazProject: TProject read FLazProject write SetLazProject;
144
180
    property OnOpen: TNotifyEvent read FOnOpen write FOnOpen;
153
189
                             read FOnRemoveDependency write FOnRemoveDependency;
154
190
    property OnReAddDependency: TAddProjInspDepEvent
155
191
                             read FOnReAddDependency write FOnReAddDependency;
 
192
    property SortAlphabetically: boolean read FSortAlphabetically write SetSortAlphabetically;
 
193
    property ShowDirectoryHierarchy: boolean read FShowDirectoryHierarchy write SetShowDirectoryHierarchy;
 
194
    property IdleConnected: boolean read FIdleConnected write SetIdleConnected;
156
195
  end;
157
196
  
158
197
var
166
205
uses
167
206
  IDEImagesIntf;
168
207
 
 
208
 
169
209
{ TProjectInspectorForm }
170
210
 
171
211
procedure TProjectInspectorForm.ItemsTreeViewDblClick(Sender: TObject);
172
212
begin
173
 
  OpenBitBtnClick(Self);
 
213
  OpenButtonClick(Self);
 
214
end;
 
215
 
 
216
procedure TProjectInspectorForm.ItemsTreeViewGetImageIndex(Sender: TObject; Node: TTreeNode);
 
217
begin
 
218
 
174
219
end;
175
220
 
176
221
procedure TProjectInspectorForm.ItemsTreeViewKeyDown(Sender: TObject;
191
236
procedure TProjectInspectorForm.MoveDependencyUpClick(Sender: TObject);
192
237
var
193
238
  Dependency: TPkgDependency;
194
 
  OldSelection: TStringList;
195
239
begin
196
240
  Dependency:=GetSelectedDependency;
197
 
  if (Dependency=nil) or (Dependency.Removed)
 
241
  if SortAlphabetically or (Dependency=nil) or Dependency.Removed
198
242
  or (Dependency.PrevRequiresDependency=nil) then exit;
199
 
  ItemsTreeView.BeginUpdate;
200
 
  OldSelection:=StoreCurrentTreeSelection;
201
243
  LazProject.MoveRequiredDependencyUp(Dependency);
202
 
  ApplyTreeSelection(OldSelection,true);
203
 
  ItemsTreeView.EndUpdate;
204
244
end;
205
245
 
206
246
procedure TProjectInspectorForm.MoveDependencyDownClick(Sender: TObject);
207
247
var
208
248
  Dependency: TPkgDependency;
209
 
  OldSelection: TStringList;
210
249
begin
211
250
  Dependency:=GetSelectedDependency;
212
 
  if (Dependency=nil) or (Dependency.Removed)
 
251
  if SortAlphabetically or (Dependency=nil) or Dependency.Removed
213
252
  or (Dependency.NextRequiresDependency=nil) then exit;
214
 
  ItemsTreeView.BeginUpdate;
215
 
  OldSelection:=StoreCurrentTreeSelection;
216
253
  LazProject.MoveRequiredDependencyDown(Dependency);
217
 
  ApplyTreeSelection(OldSelection,true);
218
 
  ItemsTreeView.EndUpdate;
219
254
end;
220
255
 
221
 
procedure TProjectInspectorForm.SetDependencyDefaultFilenameMenuItemClick(
222
 
  Sender: TObject);
 
256
procedure TProjectInspectorForm.SetDependencyDefaultFilenameMenuItemClick(Sender: TObject);
223
257
begin
224
258
  SetDependencyDefaultFilename(false);
225
259
end;
226
260
 
227
 
procedure TProjectInspectorForm.SetDependencyPreferredFilenameMenuItemClick(
228
 
  Sender: TObject);
 
261
procedure TProjectInspectorForm.SetDependencyPreferredFilenameMenuItemClick(Sender: TObject);
229
262
begin
230
263
  SetDependencyDefaultFilename(true);
231
264
end;
232
265
 
233
 
procedure TProjectInspectorForm.ClearDependencyFilenameMenuItemClick(
234
 
  Sender: TObject);
 
266
procedure TProjectInspectorForm.ClearDependencyFilenameMenuItemClick(Sender: TObject);
235
267
var
236
268
  CurDependency: TPkgDependency;
237
269
begin
273
305
        if Assigned(OnAddUnitToProject) then begin
274
306
          if OnAddUnitToProject(Self,NewFile)<>mrOk then break;
275
307
        end;
 
308
        FNextSelectedPart:=NewFile;
276
309
      end;
277
 
      UpdateAll;
 
310
      UpdateAll(false);
278
311
      EndUpdate;
279
312
    end;
280
313
  
283
316
      BeginUpdate;
284
317
      if Assigned(OnAddDependency) then
285
318
        OnAddDependency(Self,AddResult.Dependency);
286
 
      UpdateItems;
 
319
      FNextSelectedPart:=AddResult.Dependency;
 
320
      UpdateItems(false);
287
321
      EndUpdate;
288
322
    end;
289
323
  
292
326
  AddResult.Free;
293
327
end;
294
328
 
 
329
procedure TProjectInspectorForm.DirectoryHierarchyButtonClick(Sender: TObject);
 
330
begin
 
331
  ShowDirectoryHierarchy:=DirectoryHierarchyButton.Down;
 
332
end;
 
333
 
295
334
procedure TProjectInspectorForm.ItemsPopupMenuPopup(Sender: TObject);
296
335
var
297
336
  ItemCnt: integer;
323
362
  ItemCnt:=0;
324
363
  CurFile:=GetSelectedFile;
325
364
  if CurFile<>nil then begin
326
 
    AddPopupMenuItem(lisOpenFile, @OpenBitBtnClick, true);
327
 
    AddPopupMenuItem(lisPckEditRemoveFile, @RemoveBitBtnClick,
328
 
      RemoveBitBtn.Enabled);
 
365
    AddPopupMenuItem(lisOpenFile, @OpenButtonClick, true);
 
366
    AddPopupMenuItem(lisPckEditRemoveFile, @RemoveBitBtnClick, RemoveBitBtn.Enabled);
329
367
    if FilenameIsPascalSource(CurFile.Filename) then begin
330
368
      Item:=AddPopupMenuItem(lisDisableI18NForLFM,
331
369
                             @ToggleI18NForLFMMenuItemClick,true);
335
373
  end;
336
374
  CurDependency:=GetSelectedDependency;
337
375
  if CurDependency<>nil then begin
 
376
    AddPopupMenuItem(lisMenuOpenPackage, @OpenButtonClick, true);
338
377
    if CurDependency.Removed then begin
339
 
      AddPopupMenuItem(lisMenuOpenPackage, @OpenBitBtnClick, true);
340
378
      AddPopupMenuItem(lisPckEditReAddDependency, @ReAddMenuItemClick,
341
379
                       AddBitBtn.Enabled);
342
380
    end else begin
343
 
      AddPopupMenuItem(lisMenuOpenPackage, @OpenBitBtnClick, true);
344
381
      AddPopupMenuItem(lisPckEditRemoveDependency, @RemoveBitBtnClick,
345
382
                       RemoveBitBtn.Enabled);
346
383
      AddPopupMenuItem(lisPckEditMoveDependencyUp, @MoveDependencyUpClick,
366
403
    ItemsPopupMenu.Items.Delete(ItemsPopupMenu.Items.Count-1);
367
404
end;
368
405
 
369
 
procedure TProjectInspectorForm.OpenBitBtnClick(Sender: TObject);
 
406
procedure TProjectInspectorForm.OpenButtonClick(Sender: TObject);
370
407
begin
371
408
  if Assigned(OnOpen) then OnOpen(Self);
372
409
end;
376
413
  if Assigned(OnShowOptions) then OnShowOptions(Self);
377
414
end;
378
415
 
 
416
procedure TProjectInspectorForm.HelpBitBtnClick(Sender: TObject);
 
417
begin
 
418
  LazarusHelp.ShowHelpForIDEControl(Self);
 
419
end;
 
420
 
379
421
procedure TProjectInspectorForm.ProjectInspectorFormShow(Sender: TObject);
380
422
begin
381
 
  UpdateAll;
 
423
  UpdateAll(false);
382
424
end;
383
425
 
384
426
procedure TProjectInspectorForm.ReAddMenuItemClick(Sender: TObject);
420
462
  end;
421
463
end;
422
464
 
423
 
procedure TProjectInspectorForm.RemoveNonExistingFilesMenuItemClick(
424
 
  Sender: TObject);
 
465
procedure TProjectInspectorForm.RemoveNonExistingFilesMenuItemClick(Sender: TObject);
425
466
var
426
467
  AnUnitInfo: TUnitInfo;
427
468
  NextUnitInfo: TUnitInfo;
432
473
  AnUnitInfo:=LazProject.FirstPartOfProject;
433
474
  while AnUnitInfo<>nil do begin
434
475
    NextUnitInfo:=AnUnitInfo.NextPartOfProject;
435
 
    if (not AnUnitInfo.IsVirtual)
436
 
    and (not FileExistsUTF8(AnUnitInfo.Filename)) then begin
 
476
    if not (AnUnitInfo.IsVirtual or FileExistsUTF8(AnUnitInfo.Filename)) then begin
437
477
      AnUnitInfo.IsPartOfProject:=false;
438
478
      HasChanged:=true;
439
479
    end;
441
481
  end;
442
482
  if HasChanged then begin
443
483
    LazProject.Modified:=true;
444
 
    UpdateAll;
 
484
    UpdateProjectFiles;
445
485
  end;
446
486
end;
447
487
 
 
488
procedure TProjectInspectorForm.SortAlphabeticallyButtonClick(Sender: TObject);
 
489
begin
 
490
  SortAlphabetically:=SortAlphabeticallyButton.Down;
 
491
end;
 
492
 
448
493
procedure TProjectInspectorForm.ToggleI18NForLFMMenuItemClick(Sender: TObject);
449
494
var
450
495
  CurFile: TUnitInfo;
468
513
    FLazProject.OnBeginUpdate:=@OnProjectBeginUpdate;
469
514
    FLazProject.OnEndUpdate:=@OnProjectEndUpdate;
470
515
  end;
471
 
  UpdateAll;
472
 
end;
473
 
 
474
 
procedure TProjectInspectorForm.SetDependencyDefaultFilename(
475
 
  AsPreferred: boolean);
 
516
  UpdateAll(false);
 
517
end;
 
518
 
 
519
procedure TProjectInspectorForm.SetShowDirectoryHierarchy(const AValue: boolean);
 
520
begin
 
521
  if FShowDirectoryHierarchy=AValue then exit;
 
522
  FShowDirectoryHierarchy:=AValue;
 
523
  DirectoryHierarchyButton.Down:=FShowDirectoryHierarchy;
 
524
  FilterEdit.ShowDirHierarchy:=FShowDirectoryHierarchy;
 
525
  FilterEdit.InvalidateFilter;
 
526
end;
 
527
 
 
528
procedure TProjectInspectorForm.SetSortAlphabetically(const AValue: boolean);
 
529
begin
 
530
  if FSortAlphabetically=AValue then exit;
 
531
  FSortAlphabetically:=AValue;
 
532
  SortAlphabeticallyButton.Down:=SortAlphabetically;
 
533
  FilterEdit.SortData:=SortAlphabetically;
 
534
  FilterEdit.InvalidateFilter;
 
535
end;
 
536
 
 
537
procedure TProjectInspectorForm.SetDependencyDefaultFilename(AsPreferred: boolean);
476
538
var
477
539
  NewFilename: String;
478
540
  CurDependency: TPkgDependency;
481
543
  if (CurDependency=nil) then exit;
482
544
  if CurDependency.RequiredPackage=nil then exit;
483
545
  NewFilename:=CurDependency.RequiredPackage.Filename;
484
 
  if (NewFilename=CurDependency.DefaultFilename)
 
546
  if (NewFilename=CurDependency.DefaultFilename) // do not use CompareFilenames
485
547
  and (CurDependency.PreferDefaultFilename=AsPreferred) then exit;
486
548
  CurDependency.DefaultFilename:=NewFilename;
487
549
  CurDependency.PreferDefaultFilename:=AsPreferred;
490
552
  UpdateButtons;
491
553
end;
492
554
 
 
555
procedure TProjectInspectorForm.SetIdleConnected(const AValue: boolean);
 
556
begin
 
557
  if FIdleConnected=AValue then exit;
 
558
  FIdleConnected:=AValue;
 
559
  if FIdleConnected then
 
560
    Application.AddOnIdleHandler(@IdleHandler)
 
561
  else
 
562
    Application.RemoveOnIdleHandler(@IdleHandler);
 
563
end;
 
564
 
493
565
procedure TProjectInspectorForm.SetupComponents;
 
566
 
 
567
  function CreateToolButton(AName, ACaption, AHint, AImageName: String; AOnClick: TNotifyEvent): TToolButton;
 
568
  begin
 
569
    Result := TToolButton.Create(Self);
 
570
    Result.Name := AName;
 
571
    Result.Caption := ACaption;
 
572
    Result.Hint := AHint;
 
573
    if AImageName <> '' then
 
574
      Result.ImageIndex := IDEImages.LoadImage(16, AImageName);
 
575
    Result.ShowHint := True;
 
576
    Result.OnClick := AOnClick;
 
577
    Result.AutoSize := True;
 
578
    Result.Parent := ToolBar;
 
579
  end;
 
580
 
 
581
  function CreateDivider: TToolButton;
 
582
  begin
 
583
    Result := TToolButton.Create(Self);
 
584
    Result.Style := tbsDivider;
 
585
    Result.AutoSize := True;
 
586
    Result.Parent := ToolBar;
 
587
  end;
 
588
 
494
589
begin
495
 
  ItemsTreeView.Images := IDEImages.Images_16;
496
 
  ImageIndexFiles := IDEImages.LoadImage(16, 'pkg_files');
497
 
  ImageIndexRequired := IDEImages.LoadImage(16, 'pkg_required');
498
 
  ImageIndexConflict := IDEImages.LoadImage(16, 'pkg_conflict');
 
590
  ImageIndexFiles           := IDEImages.LoadImage(16, 'pkg_files');
 
591
  ImageIndexRequired        := IDEImages.LoadImage(16, 'pkg_required');
 
592
  ImageIndexConflict        := IDEImages.LoadImage(16, 'pkg_conflict');
499
593
  ImageIndexRemovedRequired := IDEImages.LoadImage(16, 'pkg_removedrequired');
500
 
  ImageIndexProject := IDEImages.LoadImage(16, 'item_project');
501
 
  ImageIndexUnit := IDEImages.LoadImage(16, 'item_unit');
502
 
  ImageIndexRegisterUnit := IDEImages.LoadImage(16, 'pkg_registerunit');
503
 
  ImageIndexText := IDEImages.LoadImage(16, 'pkg_text');
504
 
  ImageIndexBinary := IDEImages.LoadImage(16, 'pkg_binary');
505
 
 
506
 
  OpenBitBtn.LoadGlyphFromLazarusResource('laz_open');
507
 
  AddBitBtn.LoadGlyphFromLazarusResource('laz_add');
508
 
  RemoveBitBtn.LoadGlyphFromLazarusResource('laz_delete');
509
 
  OptionsBitBtn.LoadGlyphFromLazarusResource('menu_environment_options');
510
 
 
511
 
  OpenBitBtn.Caption:='';
512
 
  AddBitBtn.Caption:='';
513
 
  RemoveBitBtn.Caption:='';
514
 
  OptionsBitBtn.Caption:='';
515
 
  OpenBitBtn.Hint:=lisOpenFile;
516
 
  AddBitBtn.Hint:=lisCodeTemplAdd;
517
 
  RemoveBitBtn.Hint:=lisExtToolRemove;
518
 
  OptionsBitBtn.Hint:=dlgFROpts;
 
594
  ImageIndexProject         := IDEImages.LoadImage(16, 'item_project');
 
595
  ImageIndexUnit            := IDEImages.LoadImage(16, 'item_unit');
 
596
  ImageIndexRegisterUnit    := IDEImages.LoadImage(16, 'pkg_registerunit');
 
597
  ImageIndexText            := IDEImages.LoadImage(16, 'pkg_text');
 
598
  ImageIndexBinary          := IDEImages.LoadImage(16, 'pkg_binary');
 
599
  ImageIndexDirectory       := IDEImages.LoadImage(16, 'pkg_files');
 
600
 
 
601
  ItemsTreeView.Images      := IDEImages.Images_16;
 
602
  ToolBar.Images            := IDEImages.Images_16;
 
603
  FilterEdit.OnGetImageIndex:=@ChooseImageIndex;
 
604
 
 
605
  AddBitBtn     := CreateToolButton('AddBitBtn', lisAdd, lisPckEditAddAnItem, 'laz_add', @AddBitBtnClick);
 
606
  RemoveBitBtn  := CreateToolButton('RemoveBitBtn', lisRemove, lisPckEditRemoveSelectedItem, 'laz_delete', @RemoveBitBtnClick);
 
607
  CreateDivider;
 
608
  OptionsBitBtn := CreateToolButton('OptionsBitBtn', dlgFROpts, lisPckEditEditGeneralOptions, 'menu_environment_options', @OptionsBitBtnClick);
 
609
  HelpBitBtn    := CreateToolButton('HelpBitBtn', GetButtonCaption(idButtonHelp), lisPkgEdThereAreMoreFunctionsInThePopupmenu, 'menu_help', @HelpBitBtnClick);
 
610
 
 
611
  OpenButton.LoadGlyphFromLazarusResource('laz_open');
 
612
  OpenButton.Caption:='';
 
613
  OpenButton.Hint:=lisOpenFile2;
 
614
  SortAlphabeticallyButton.Hint:=lisPESortFilesAlphabetically;
 
615
  SortAlphabeticallyButton.LoadGlyphFromLazarusResource('pkg_sortalphabetically');
 
616
  DirectoryHierarchyButton.Hint:=lisPEShowDirectoryHierarchy;
 
617
  DirectoryHierarchyButton.LoadGlyphFromLazarusResource('pkg_hierarchical');
519
618
 
520
619
  with ItemsTreeView do begin
521
 
    FilesNode:=Items.Add(nil, dlgEnvFiles);
522
 
    FilesNode.ImageIndex:=ImageIndexFiles;
523
 
    FilesNode.SelectedIndex:=FilesNode.ImageIndex;
 
620
    FFilesNode:=Items.Add(nil, dlgEnvFiles);
 
621
    FFilesNode.ImageIndex:=ImageIndexFiles;
 
622
    FFilesNode.SelectedIndex:=FFilesNode.ImageIndex;
524
623
    DependenciesNode:=Items.Add(nil, lisPckEditRequiredPackages);
525
624
    DependenciesNode.ImageIndex:=ImageIndexRequired;
526
625
    DependenciesNode.SelectedIndex:=DependenciesNode.ImageIndex;
527
626
  end;
528
627
end;
529
628
 
530
 
procedure TProjectInspectorForm.UpdateProjectItems;
 
629
function TProjectInspectorForm.ChooseImageIndex(Str: String; Data: TObject;
 
630
                                                var AIsEnabled: Boolean): Integer;
 
631
begin
 
632
  if Data is TUnitInfo then begin
 
633
    if FilenameIsPascalUnit(TUnitInfo(Data).Filename) then
 
634
      Result:=ImageIndexUnit
 
635
    else if (LazProject<>nil) and (LazProject.MainUnitinfo=Data) then
 
636
      Result:=ImageIndexProject
 
637
    else
 
638
      Result:=ImageIndexText;
 
639
  end
 
640
  else if Data is TPkgDependency then begin
 
641
    if TPkgDependency(Data).Removed then
 
642
      Result:=ImageIndexRemovedRequired
 
643
    else if TPkgDependency(Data).LoadPackageResult=lprSuccess then
 
644
      Result:=ImageIndexRequired
 
645
    else
 
646
      Result:=ImageIndexConflict;
 
647
  end;
 
648
end;
 
649
 
 
650
procedure TProjectInspectorForm.UpdateProjectFiles;
531
651
var
532
652
  CurFile: TUnitInfo;
533
 
  CurNode: TTreeNode;
534
 
  NodeText: String;
535
 
  NextNode: TTreeNode;
536
 
  Tree: TAvgLvlTree;
537
 
  AVLNode: TAvgLvlTreeNode;
 
653
  FilesBranch: TTreeFilterBranch;
 
654
  Filename: String;
538
655
begin
539
656
  ItemsTreeView.BeginUpdate;
540
 
  if LazProject<>nil then begin
541
 
    Tree:=TAvgLvlTree.CreateObjectCompare(@CompareUnitInfos);
542
 
    CurFile:=LazProject.FirstPartOfProject;
543
 
    while CurFile<>nil do begin
544
 
      Tree.Add(CurFile);
545
 
      CurFile:=CurFile.NextPartOfProject;
546
 
    end;
547
 
    AVLNode:=Tree.FindLowest;
548
 
    CurNode:=FilesNode.GetFirstChild;
549
 
    while AVLNode<>nil do begin
550
 
      CurFile:=TUnitInfo(AVLNode.Data);
551
 
      NodeText:=ProjectFileToNodeText(CurFile);
552
 
      if CurNode=nil then
553
 
        CurNode:=ItemsTreeView.Items.AddChild(FilesNode,NodeText)
554
 
      else
555
 
        CurNode.Text:=NodeText;
556
 
      CurNode.ImageIndex:=GetImageIndexOfFile(CurFile);
557
 
      CurNode.SelectedIndex:=CurNode.ImageIndex;
558
 
      CurNode:=CurNode.GetNextSibling;
559
 
      AVLNode:=Tree.FindSuccessor(AVLNode);
560
 
    end;
561
 
    while CurNode<>nil do begin
562
 
      NextNode:=CurNode.GetNextSibling;
563
 
      CurNode.Free;
564
 
      CurNode:=NextNode;
565
 
    end;
566
 
    FilesNode.Expanded:=true;
567
 
    Tree.Free;
568
 
  end else begin
569
 
    // delete file nodes
570
 
    FilesNode.HasChildren:=false;
 
657
  try
 
658
    FilesBranch:=FilterEdit.GetBranch(FFilesNode);
 
659
    if LazProject<>nil then begin
 
660
      FilterEdit.SelectedPart:=FNextSelectedPart;
 
661
      FilterEdit.ShowDirHierarchy:=ShowDirectoryHierarchy;
 
662
      FilterEdit.SortData:=SortAlphabetically;
 
663
      FilterEdit.ImageIndexDirectory:=ImageIndexDirectory;
 
664
      // collect and sort files
 
665
      CurFile:=LazProject.FirstPartOfProject;
 
666
      while CurFile<>nil do begin
 
667
        Filename:=CurFile.GetShortFilename(true);
 
668
        if Filename<>'' then
 
669
          FilesBranch.AddNodeData(Filename, CurFile, CurFile.Filename);
 
670
        CurFile:=CurFile.NextPartOfProject;
 
671
      end;
 
672
    end;
 
673
    FilterEdit.InvalidateFilter;            // Data is shown by FilterEdit.
 
674
  finally
 
675
    ItemsTreeView.EndUpdate;
571
676
  end;
572
 
  ItemsTreeView.EndUpdate;
573
677
end;
574
678
 
575
679
procedure TProjectInspectorForm.UpdateRequiredPackages;
576
680
var
577
681
  Dependency: TPkgDependency;
 
682
  RequiredBranch, RemovedBranch: TTreeFilterBranch;
578
683
  NodeText, AFilename: String;
579
 
  CurNode: TTreeNode;
580
 
  NextNode: TTreeNode;
581
 
begin
582
 
  ItemsTreeView.BeginUpdate;
583
 
  if LazProject<>nil then begin
584
 
    Dependency:=LazProject.FirstRequiredDependency;
585
 
    CurNode:=DependenciesNode.GetFirstChild;
586
 
    while Dependency<>nil do begin
587
 
      NodeText:=Dependency.AsString;
588
 
      if Dependency.DefaultFilename<>'' then begin
589
 
        AFilename:=Dependency.MakeFilenameRelativeToOwner(
590
 
                                                    Dependency.DefaultFilename);
591
 
        if Dependency.PreferDefaultFilename then
592
 
          NodeText:=Format(lisCEIn, [NodeText,AFilename])  // like the 'in' keyword in the uses section
593
 
        else
594
 
          NodeText:=Format(lisPckEditDefault, [NodeText, AFilename]);
595
 
      end;
596
 
      if CurNode=nil then
597
 
        CurNode:=ItemsTreeView.Items.AddChild(DependenciesNode,NodeText)
598
 
      else
599
 
        CurNode.Text:=NodeText;
600
 
      if Dependency.LoadPackageResult=lprSuccess then
601
 
        CurNode.ImageIndex:=ImageIndexRequired
602
 
      else
603
 
        CurNode.ImageIndex:=ImageIndexConflict;
604
 
      CurNode.SelectedIndex:=CurNode.ImageIndex;
605
 
      Dependency:=Dependency.NextRequiresDependency;
606
 
      CurNode:=CurNode.GetNextSibling;
607
 
    end;
608
 
    while CurNode<>nil do begin
609
 
      NextNode:=CurNode.GetNextSibling;
610
 
      CurNode.Free;
611
 
      CurNode:=NextNode;
612
 
    end;
613
 
    DependenciesNode.Expanded:=true;
614
 
  end else begin
615
 
    // delete dependency nodes
616
 
    DependenciesNode.HasChildren:=false;
617
 
  end;
618
 
  ItemsTreeView.EndUpdate;
619
 
end;
620
 
 
621
 
procedure TProjectInspectorForm.UpdateRemovedRequiredPackages;
622
 
var
623
 
  Dependency: TPkgDependency;
624
 
  NodeText: String;
625
 
  CurNode: TTreeNode;
626
 
  NextNode: TTreeNode;
627
 
begin
628
 
  ItemsTreeView.BeginUpdate;
629
 
  if (LazProject<>nil) and (LazProject.FirstRemovedDependency<>nil) then begin
630
 
    Dependency:=LazProject.FirstRemovedDependency;
631
 
    if RemovedDependenciesNode=nil then begin
632
 
      RemovedDependenciesNode:=
633
 
        ItemsTreeView.Items.Add(DependenciesNode,
634
 
          lisProjInspRemovedRequiredPackages);
635
 
      RemovedDependenciesNode.ImageIndex:=ImageIndexRemovedRequired;
636
 
      RemovedDependenciesNode.SelectedIndex:=RemovedDependenciesNode.ImageIndex;
637
 
    end;
638
 
    CurNode:=RemovedDependenciesNode.GetFirstChild;
639
 
    while Dependency<>nil do begin
640
 
      NodeText:=Dependency.AsString;
641
 
      if CurNode=nil then
642
 
        CurNode:=ItemsTreeView.Items.AddChild(RemovedDependenciesNode,NodeText)
643
 
      else
644
 
        CurNode.Text:=NodeText;
645
 
      CurNode.ImageIndex:=RemovedDependenciesNode.ImageIndex;
646
 
      CurNode.SelectedIndex:=CurNode.ImageIndex;
647
 
      Dependency:=Dependency.NextRequiresDependency;
648
 
      CurNode:=CurNode.GetNextSibling;
649
 
    end;
650
 
    while CurNode<>nil do begin
651
 
      NextNode:=CurNode.GetNextSibling;
652
 
      CurNode.Free;
653
 
      CurNode:=NextNode;
654
 
    end;
655
 
    RemovedDependenciesNode.Expanded:=true;
656
 
  end else begin
657
 
    // delete removed dependency nodes
658
 
    if RemovedDependenciesNode<>nil then
 
684
begin
 
685
  ItemsTreeView.BeginUpdate;
 
686
  try
 
687
    RequiredBranch:=FilterEdit.GetBranch(DependenciesNode);
 
688
    Dependency:=Nil;
 
689
    if LazProject<>nil then begin
 
690
      // required packages
 
691
      Dependency:=LazProject.FirstRequiredDependency;
 
692
      while Dependency<>nil do begin
 
693
        // Figure out the item's caption
 
694
        NodeText:=Dependency.AsString;
 
695
        if Dependency.DefaultFilename<>'' then begin
 
696
          AFilename:=Dependency.MakeFilenameRelativeToOwner(Dependency.DefaultFilename);
 
697
          if Dependency.PreferDefaultFilename then
 
698
            NodeText:=Format(lisCEIn, [NodeText,AFilename])  // like the 'in' keyword in the uses section
 
699
          else
 
700
            NodeText:=Format(lisPckEditDefault, [NodeText, AFilename]);
 
701
        end;
 
702
        // Add the required package under the branch
 
703
        RequiredBranch.AddNodeData(NodeText, Dependency);
 
704
        Dependency:=Dependency.NextRequiresDependency;
 
705
      end;
 
706
 
 
707
      // removed required packages
 
708
      Dependency:=LazProject.FirstRemovedDependency;
 
709
      if Dependency<>nil then begin
 
710
        // Create root node for removed dependencies if not done yet.
 
711
        if RemovedDependenciesNode=nil then begin
 
712
          RemovedDependenciesNode:=ItemsTreeView.Items.Add(DependenciesNode,
 
713
                                                  lisProjInspRemovedRequiredPackages);
 
714
          RemovedDependenciesNode.ImageIndex:=ImageIndexRemovedRequired;
 
715
          RemovedDependenciesNode.SelectedIndex:=RemovedDependenciesNode.ImageIndex;
 
716
        end;
 
717
        RemovedBranch:=FilterEdit.GetBranch(RemovedDependenciesNode);
 
718
        // Add all removed dependencies under the branch
 
719
        while Dependency<>nil do begin
 
720
          RemovedBranch.AddNodeData(Dependency.AsString, Dependency);
 
721
          Dependency:=Dependency.NextRequiresDependency;
 
722
        end;
 
723
      end;
 
724
    end;
 
725
 
 
726
    // Dependency is set to removed required packages if there is active project
 
727
    if (Dependency=nil) and (RemovedDependenciesNode<>nil) then begin
 
728
      // No removed dependencies -> delete the root node
 
729
      FilterEdit.DeleteBranch(RemovedDependenciesNode);
659
730
      FreeThenNil(RemovedDependenciesNode);
 
731
    end;
 
732
    FilterEdit.InvalidateFilter;
 
733
  finally
 
734
    ItemsTreeView.EndUpdate;
660
735
  end;
661
 
  ItemsTreeView.EndUpdate;
662
 
end;
663
 
 
664
 
function TProjectInspectorForm.GetImageIndexOfFile(AFile: TUnitInfo): integer;
665
 
begin
666
 
  if FilenameIsPascalUnit(AFile.Filename) then
667
 
    Result:=ImageIndexUnit
668
 
  else if (LazProject<>nil) and (LazProject.MainUnitinfo=AFile) then
669
 
    Result:=ImageIndexProject
670
 
  else
671
 
    Result:=ImageIndexText;
672
736
end;
673
737
 
674
738
procedure TProjectInspectorForm.OnProjectBeginUpdate(Sender: TObject);
679
743
procedure TProjectInspectorForm.OnProjectEndUpdate(Sender: TObject;
680
744
  ProjectChanged: boolean);
681
745
begin
682
 
  UpdateAll;
 
746
  UpdateAll(false);
683
747
  EndUpdate;
684
748
end;
685
749
 
689
753
  ExecuteIDEShortCut(Self,Key,Shift,nil);
690
754
end;
691
755
 
692
 
function TProjectInspectorForm.ProjectFileToNodeText(AFile: TUnitInfo): string;
 
756
procedure TProjectInspectorForm.IdleHandler(Sender: TObject; var Done: Boolean);
693
757
begin
694
 
  Result:=CreateRelativePath(AFile.Filename,LazProject.ProjectDirectory);
 
758
  if not IsVisible then begin
 
759
    Include(FFlags,pifWasHidden);
 
760
    IdleConnected:=false;
 
761
    exit;
 
762
  end;
 
763
  Exclude(FFlags,pifWasHidden);
 
764
  if FUpdateLock>0 then begin
 
765
    IdleConnected:=false;
 
766
    exit;
 
767
  end;
 
768
  if pifAllChanged in FFlags then
 
769
    UpdateAll(true)
 
770
  else if pifItemsChanged in FFlags then
 
771
    UpdateItems(true)
 
772
  else if pifTitleChanged in FFlags then
 
773
    UpdateTitle
 
774
  else if pifButtonsChanged in FFlags then
 
775
    UpdateButtons
 
776
  else
 
777
    IdleConnected:=false;
695
778
end;
696
779
 
697
 
function TProjectInspectorForm.CompareUnitInfos(Tree: TAvgLvlTree;
698
 
  UnitInfo1, UnitInfo2: Pointer): integer;
699
 
var
700
 
  ShortFilename1: String;
701
 
  ShortFilename2: String;
 
780
procedure TProjectInspectorForm.UpdateShowing;
702
781
begin
703
 
  ShortFilename1:=CreateRelativePath(TUnitInfo(UnitInfo1).Filename,
704
 
                                     LazProject.ProjectDirectory);
705
 
  ShortFilename2:=CreateRelativePath(TUnitInfo(UnitInfo2).Filename,
706
 
                                     LazProject.ProjectDirectory);
707
 
  Result:=CompareFilenames(ShortFilename1,ShortFilename2);
 
782
  inherited UpdateShowing;
 
783
  if IsVisible and (pifWasHidden in FFlags) then begin
 
784
    Exclude(FFlags,pifWasHidden);
 
785
    if FFlags<>[] then begin
 
786
      // the form is visible again and some updates are pending
 
787
      IdleConnected:=true;
 
788
    end;
 
789
  end;
708
790
end;
709
791
 
710
792
function TProjectInspectorForm.GetSelectedFile: TUnitInfo;
711
793
var
712
794
  CurNode: TTreeNode;
713
 
  NodeText: String;
 
795
  Item: TFileNameItem;
714
796
begin
715
797
  Result:=nil;
716
798
  if LazProject=nil then exit;
717
799
  CurNode:=ItemsTreeView.Selected;
718
 
  if (CurNode=nil) or (CurNode.Parent<>FilesNode) then exit;
719
 
  Result:=LazProject.FirstPartOfProject;
720
 
  while (Result<>nil) do begin
721
 
    NodeText:=ProjectFileToNodeText(Result);
722
 
    if NodeText=CurNode.Text then exit;
723
 
    Result:=Result.NextPartOfProject;
 
800
  if (CurNode=nil) then exit;
 
801
  //debugln(['TProjectInspectorForm.GetCurrentFile ',DbgSName(TObject(CurNode.Data)),' ',CurNode.Text]);
 
802
  if TObject(CurNode.Data) is TFileNameItem then
 
803
  begin
 
804
    Item:=TFileNameItem(CurNode.Data);
 
805
    //debugln(['TProjectInspectorForm.GetCurrentFile Item=',Item.Filename,' ',Item.IsDirectory]);
 
806
    Result:=LazProject.UnitInfoWithFilename(Item.Filename);
724
807
  end;
725
808
end;
726
809
 
727
810
function TProjectInspectorForm.GetSelectedDependency: TPkgDependency;
728
811
var
729
812
  CurNode: TTreeNode;
730
 
  NodeIndex: Integer;
 
813
  Branch: TTreeFilterBranch;
 
814
  AnObject: TObject;
731
815
begin
732
816
  Result:=nil;
733
817
  if LazProject=nil then exit;
734
818
  CurNode:=ItemsTreeView.Selected;
735
 
  if (CurNode=nil) then exit;
736
 
  NodeIndex:=CurNode.Index;
737
 
  if (CurNode.Parent=DependenciesNode) then begin
738
 
    Result:=GetDependencyWithIndex(LazProject.FirstRequiredDependency,
739
 
                                   pdlRequires,NodeIndex);
740
 
  end;
741
 
  if (CurNode.Parent=RemovedDependenciesNode) then begin
742
 
    Result:=GetDependencyWithIndex(LazProject.FirstRemovedDependency,
743
 
                                   pdlRequires,NodeIndex);
744
 
  end;
745
 
end;
746
 
 
747
 
function TProjectInspectorForm.StoreCurrentTreeSelection: TStringList;
748
 
var
749
 
  ANode: TTreeNode;
750
 
begin
751
 
  Result:=TStringList.Create;
752
 
  ANode:=ItemsTreeView.Selected;
753
 
  while ANode<>nil do begin
754
 
    Result.Insert(0,ANode.Text);
755
 
    ANode:=ANode.Parent;
756
 
  end;
757
 
end;
758
 
 
759
 
procedure TProjectInspectorForm.ApplyTreeSelection(ASelection: TStringList;
760
 
  FreeList: boolean);
761
 
var
762
 
  ANode: TTreeNode;
763
 
  CurText: string;
764
 
begin
765
 
  ANode:=nil;
766
 
  while ASelection.Count>0 do begin
767
 
    CurText:=ASelection[0];
768
 
    if ANode=nil then
769
 
      ANode:=ItemsTreeView.Items.GetFirstNode
770
 
    else
771
 
      ANode:=ANode.GetFirstChild;
772
 
    while (ANode<>nil) and (ANode.Text<>CurText) do
773
 
      ANode:=ANode.GetNextSibling;
774
 
    if ANode=nil then break;
775
 
    ASelection.Delete(0);
776
 
  end;
777
 
  if ANode<>nil then ItemsTreeView.Selected:=ANode;
778
 
  if FreeList then ASelection.Free;
 
819
  if Assigned(CurNode) and Assigned(CurNode.Parent)
 
820
  and ((CurNode.Parent=DependenciesNode) or (CurNode.Parent=RemovedDependenciesNode))
 
821
  then begin
 
822
    Branch:=FilterEdit.GetExistingBranch(CurNode.Parent);
 
823
    Assert(Assigned(Branch));
 
824
    AnObject := Branch.GetData(CurNode.Index);
 
825
    if (AnObject <> nil) and (AnObject is TPkgDependency) then
 
826
      Result := TPkgDependency(AnObject);
 
827
  end;
779
828
end;
780
829
 
781
830
constructor TProjectInspectorForm.Create(TheOwner: TComponent);
784
833
  Name:=NonModalIDEWindowNames[nmiwProjectInspector];
785
834
  Caption:=lisMenuProjectInspector;
786
835
  KeyPreview:=true;
787
 
 
788
836
  SetupComponents;
789
837
  KeyPreview:=true;
790
838
end;
791
839
 
792
840
destructor TProjectInspectorForm.Destroy;
793
841
begin
794
 
  BeginUpdate;
 
842
  IdleConnected:=false;
795
843
  LazProject:=nil;
796
844
  inherited Destroy;
797
 
  if ProjInspector=Self then ProjInspector:=nil;
 
845
  if ProjInspector=Self then
 
846
    ProjInspector:=nil;
798
847
end;
799
848
 
800
849
procedure TProjectInspectorForm.BeginUpdate;
806
855
begin
807
856
  if FUpdateLock=0 then RaiseException('TProjectInspectorForm.EndUpdate');
808
857
  dec(FUpdateLock);
809
 
  if FUpdateLock=0 then begin
810
 
    if pifTitleChanged in FFlags then UpdateTitle;
811
 
    if pifItemsChanged in FFlags then UpdateItems;
812
 
    if pifButtonsChanged in FFlags then UpdateButtons;
813
 
  end;
814
858
end;
815
859
 
816
860
function TProjectInspectorForm.IsUpdateLocked: boolean;
818
862
  Result:=FUpdateLock>0;
819
863
end;
820
864
 
821
 
procedure TProjectInspectorForm.UpdateAll;
 
865
procedure TProjectInspectorForm.UpdateAll(Immediately: boolean);
822
866
begin
 
867
  if (FUpdateLock>0) or (not Visible) then begin
 
868
    Include(FFlags,pifAllChanged);
 
869
    IdleConnected:=true;
 
870
    exit;
 
871
  end;
 
872
  Exclude(FFlags,pifAllChanged);
823
873
  UpdateTitle;
824
874
  UpdateButtons;
825
 
  UpdateItems;
 
875
  UpdateItems(true);
826
876
end;
827
877
 
828
878
procedure TProjectInspectorForm.UpdateTitle;
831
881
begin
832
882
  if (FUpdateLock>0) or (not Visible) then begin
833
883
    Include(FFlags,pifTitleChanged);
 
884
    IdleConnected:=true;
834
885
    exit;
835
886
  end;
836
887
  Exclude(FFlags,pifTitleChanged);
837
888
  if LazProject=nil then
838
889
    Caption:=lisMenuProjectInspector
839
890
  else begin
840
 
    NewCaption:=LazProject.Title;
 
891
    NewCaption:=LazProject.GetTitle;
841
892
    if NewCaption='' then
842
893
      NewCaption:=ExtractFilenameOnly(LazProject.ProjectInfoFile);
843
894
    Caption:=Format(lisProjInspProjectInspector, [NewCaption]);
851
902
begin
852
903
  if (FUpdateLock>0) or (not Visible) then begin
853
904
    Include(FFlags,pifButtonsChanged);
 
905
    IdleConnected:=true;
854
906
    exit;
855
907
  end;
856
908
  Exclude(FFlags,pifButtonsChanged);
860
912
    CurDependency:=GetSelectedDependency;
861
913
    RemoveBitBtn.Enabled:=((CurFile<>nil) and (CurFile<>LazProject.MainUnitInfo))
862
914
                      or ((CurDependency<>nil) and (not CurDependency.Removed));
863
 
    OpenBitBtn.Enabled:=((CurFile<>nil)
 
915
    OpenButton.Enabled:=((CurFile<>nil)
864
916
                     or ((CurDependency<>nil) and (not CurDependency.Removed)));
865
917
    OptionsBitBtn.Enabled:=true;
866
918
  end else begin
867
919
    AddBitBtn.Enabled:=false;
868
920
    RemoveBitBtn.Enabled:=false;
869
 
    OpenBitBtn.Enabled:=false;
 
921
    OpenButton.Enabled:=false;
870
922
    OptionsBitBtn.Enabled:=false;
871
923
  end;
872
924
end;
873
925
 
874
 
procedure TProjectInspectorForm.UpdateItems;
 
926
procedure TProjectInspectorForm.UpdateItems(Immediately: boolean);
875
927
begin
876
928
  if (FUpdateLock>0) or (not Visible) then begin
877
929
    Include(FFlags,pifItemsChanged);
 
930
    IdleConnected:=true;
878
931
    exit;
879
932
  end;
880
933
  Exclude(FFlags,pifItemsChanged);
881
934
  ItemsTreeView.BeginUpdate;
882
 
  UpdateProjectItems;
883
 
  UpdateRequiredPackages;
884
 
  UpdateRemovedRequiredPackages;
885
 
  ItemsTreeView.EndUpdate;
 
935
  try
 
936
    UpdateProjectFiles;
 
937
    UpdateRequiredPackages;
 
938
  finally
 
939
    ItemsTreeView.EndUpdate;
 
940
  end;
886
941
end;
887
942
 
888
943
end.