1 {
2 ***************************************************************************
3 * *
4 * This source is free software; you can redistribute it and/or modify *
5 * it under the terms of the GNU General Public License as published by *
6 * the Free Software Foundation; either version 2 of the License, or *
7 * (at your option) any later version. *
8 * *
9 * This code is distributed in the hope that it will be useful, but *
10 * WITHOUT ANY WARRANTY; without even the implied warranty of *
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
12 * General Public License for more details. *
13 * *
14 * A copy of the GNU General Public License is available on the World *
15 * Wide Web at <http://www.gnu.org/copyleft/gpl.html>. You can also *
16 * obtain it by writing to the Free Software Foundation, *
17 * Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1335, USA. *
18 * *
19 ***************************************************************************
20
21 Author: Balázs Székely
22 Abstract:
23 The implementation of IDE Coolbar.
24 ToDo:
25 Extract an interface from here and put it to IdeIntf package.
26 }
27
28 unit IdeCoolbarData;
29
30
31 {$mode objfpc}{$H+}
32
33 interface
34
35 uses
36 Classes, SysUtils, fgl,
37 // LCL
38 LCLProc, ComCtrls, Controls, Graphics, Dialogs, ToolWin,
39 // LazUtils
40 Laz2_XMLCfg,
41 // IdeIntf
42 IDEImagesIntf,
43 // IDE
44 LazarusIDEStrConsts, ToolbarConfig;
45
46 type
47
48 // Option classes take care of saving / loading environment options data.
49 // They don't contain LCL components.
50
51 { TIDEToolBarOptions }
52
53 TIDEToolBarOptions = class(TIDEToolBarOptionsBase)
54 private
55 FPosIndex: Integer;
56 FBreak: Boolean;
57 public
58 //constructor Create;
59 //destructor Destroy; override;
60 function Equals(Opts: TIDEToolBarOptions): boolean; overload;
61 procedure Assign(Source: TIDEToolBarOptions);
62 procedure CopyPosFromBand(Band: TCoolBand);
63 procedure Load(XMLConfig: TXMLConfig; SubPath: String);
64 procedure Save(XMLConfig: TXMLConfig; SubPath: String);
65 published
66 property Break: Boolean read FBreak write FBreak;
67 property PosIndex: Integer read FPosIndex write FPosIndex;
68 end;
69
70
71 { TIDEToolBarOptionList }
72
73 Ttbo = specialize TFPGObjectList<TIDEToolBarOptions>;
74 TIDEToolBarOptionList = class(Ttbo)
75 procedure Assign(Source: TIDEToolBarOptionList);
76 end;
77
78 { TIDECoolBarOptions }
79
80 TIDECoolBarOptions = class
81 private
82 FVisible: Boolean;
83 FWidth: Integer;
84 FGrabStyle: Integer;
85 FGrabWidth: Integer;
86 FBorderStyle: Integer; //TFormBorderStyle;
87 FToolBars: TIDEToolBarOptionList;
88 procedure CreateDefaultToolbars;
89 public
90 constructor Create;
91 destructor Destroy; override;
92 procedure Clear;
93 procedure Assign(Source: TIDECoolBarOptions);
94 function EqualToolbars(Opts: TIDECoolBarOptions): boolean;
95 procedure Load(XMLConfig: TXMLConfig; Path: String);
96 procedure Save(XMLConfig: TXMLConfig; Path: String);
97 public
98 property Visible: Boolean read FVisible write FVisible;
99 property Width: Integer read FWidth write FWidth;
100 property GrabStyle: Integer read FGrabStyle write FGrabStyle;
101 property GrabWidth: Integer read FGrabWidth write FGrabWidth;
102 property BorderStyle: Integer read FBorderStyle write FBorderStyle;
103 property ToolBars: TIDEToolBarOptionList read FToolBars;
104 end;
105
106 { TDefaultCoolBarOptions }
107
108 TDefaultCoolBarOptions = class(TIDECoolBarOptions)
109 public
110 constructor Create;
111 destructor Destroy; override;
112 end;
113
114 // Actual Coolbar and its member Toolbars
115
116 TOnToolBarClick = procedure(Sender: TObject) of object;
117
118 { TIDEToolBar }
119
120 TIDEToolBar = class(TIDEToolbarBase)
121 private
122 FCurrentOptions: TIDEToolBarOptions;
123 FOnToolbarClick: TOnToolBarClick;
124 procedure DoToolBarClick(Sender: TObject);
125 public
126 constructor Create(AOwner: TComponent); override;
127 destructor Destroy; override;
128 procedure ClearToolbar;
129 procedure UseCurrentOptions;
130 public
131 property CurrentOptions: TIDEToolBarOptions read FCurrentOptions;
132 property OnToolBarClick: TOnToolbarClick read FOnToolbarClick write FOnToolbarClick;
133 end;
134
135 TIDEToolBarList = specialize TFPGObjectList<TIDEToolBar>;
136
137 { TIDECoolBar }
138
139 TIDECoolBar = class
140 private
141 FCoolBar: TCoolBar; // The actual CoolBar, not owned by this class.
142 FCoolBarToolBars: TIDEToolBarList;
143 FIsVisible: Boolean; //cannot hide/show the coolbar on toolbar_options, instead we use a variable
144 FWidth: Integer; //same as Isvisible
145 // Used for assigning and testing the default configuration.
146 FDefaultOptions: TDefaultCoolBarOptions;
147 procedure DisableToolbarButtons(IDEToolbar: TIDEToolBar);
148 procedure SetIsVisible(AValue: Boolean);
149 procedure ToolBarClick(Sender: TObject);
150 public
151 constructor Create(ACoolBar: TCoolBar);
152 destructor Destroy; override;
153 procedure SetCoolBarDefaults;
154 procedure SetToolBarDefaults;
155 procedure CopyFromRealCoolbar(RealCoolbar: TCoolBar);
156 procedure CopyFromOptions(Options: TIDECoolBarOptions);
157 procedure CopyToOptions(Options: TIDECoolBarOptions);
158 function Add: TIDEToolBar;
159 function AddBand(ToolBar: TToolBar; aBreak: Boolean): TCoolBand;
160 procedure AddExtra;
161 procedure Delete;
162 function FindByToolBar(const aToolBar: TToolBar): Integer;
163 procedure Config;
164 procedure Sort;
165 procedure PopulateToolBar;
166 function GetSelectedBand: Integer;
167 function IsDefaultCoolbar: Boolean;
168 function IsDefaultToolbar: Boolean;
169 procedure SelectBand(const ID: integer);
170 procedure SelectBandAtXY(X, Y: integer);
171 public
172 property ToolBars: TIDEToolBarList read FCoolBarToolBars;
173 property CoolBar: TCoolBar read FCoolBar;
174 property IsVisible: Boolean read FIsVisible write SetIsVisible;
175 property Width: Integer read FWidth write FWidth;
176 end;
177
178 var
179 IDECoolBar: TIDECoolBar;
180
181 implementation
182
183 const
184 BasePath = 'IDECoolBarOptions/';
185
186 { TIDEToolBarOptions }
187
Equalsnull188 function TIDEToolBarOptions.Equals(Opts: TIDEToolBarOptions): boolean;
189 begin
190 Result := inherited Equals(Opts)
191 and (FPosIndex = Opts.FPosIndex) and (FBreak = Opts.FBreak);
192 end;
193
194 procedure TIDEToolBarOptions.Assign(Source: TIDEToolBarOptions);
195 begin
196 inherited Assign(Source);
197 FPosIndex := Source.FPosIndex;
198 FBreak := Source.FBreak;
199 end;
200
201 procedure TIDEToolBarOptions.CopyPosFromBand(Band: TCoolBand);
202 begin
203 FPosIndex := Band.Index;
204 FBreak := Band.Break;
205 end;
206
207 procedure TIDEToolBarOptions.Load(XMLConfig: TXMLConfig; SubPath: String);
208 begin
209 FBreak := XMLConfig.GetValue(SubPath + 'Break/Value', False);
210 LoadButtonNames(XMLConfig, SubPath);
211 end;
212
213 procedure TIDEToolBarOptions.Save(XMLConfig: TXMLConfig; SubPath: String);
214 begin
215 XMLConfig.SetDeleteValue(SubPath + 'Break/Value', FBreak, False);
216 SaveButtonNames(XMLConfig, SubPath);
217 end;
218
219 { TIDEToolBarOptionList }
220
221 procedure TIDEToolBarOptionList.Assign(Source: TIDEToolBarOptionList);
222 var
223 tbo: TIDEToolBarOptions;
224 i: Integer;
225 begin
226 Clear;
227 for i := 0 to Source.Count-1 do
228 begin
229 tbo := TIDEToolBarOptions.Create;
230 tbo.Assign(Source[i]);
231 Add(tbo);
232 end;
233 end;
234
235 { TIDECoolBarOptions }
236 constructor TIDECoolBarOptions.Create;
237 begin
238 inherited Create;
239 FToolBars := TIDEToolBarOptionList.Create;
240 end;
241
242 destructor TIDECoolBarOptions.Destroy;
243 begin
244 FToolBars.Free;
245 inherited Destroy;
246 end;
247
248 procedure TIDECoolBarOptions.Clear;
249 begin
250 FToolBars.Clear;
251 end;
252
253 procedure TIDECoolBarOptions.Assign(Source: TIDECoolBarOptions);
254 begin
255 FVisible := Source.FVisible;
256 FWidth := Source.FWidth;
257 FGrabStyle := Source.FGrabStyle;
258 FGrabWidth := Source.FGrabWidth;
259 FBorderStyle := Source.FBorderStyle;
260 FToolBars.Assign(Source.FToolBars);
261 end;
262
EqualToolbarsnull263 function TIDECoolBarOptions.EqualToolbars(Opts: TIDECoolBarOptions): boolean;
264 var
265 I: Integer;
266 begin
267 Result := (FToolBars.Count = Opts.FToolBars.Count);
268 if not Result then Exit;
269 for I := 0 to FToolBars.Count-1 do
270 if not FToolBars[I].Equals(Opts.FToolBars[I]) then Exit(False);
271 end;
272
273 procedure TIDECoolBarOptions.CreateDefaultToolbars;
274 var
275 ToolBarOpts: TIDEToolBarOptions;
276 begin
277 //standard toolbar defaults
278 ToolBarOpts := TIDEToolBarOptions.Create;
279 ToolBarOpts.PosIndex := 0;
280 ToolBarOpts.Break := False;
281 with ToolBarOpts.ButtonNames do
282 begin
283 Add('NewUnit');
284 Add('NewForm');
285 Add(cIDEToolbarDivider);
286 Add('Open');
287 Add('Save');
288 Add('SaveAll');
289 Add(cIDEToolbarDivider);
290 Add('Toggle between Unit and Form');
291 Add(cIDEToolbarDivider);
292 Add('Manage desktops');
293 end;
294 FToolBars.Add(ToolBarOpts);
295
296 //debug toolbar defaults
297 ToolBarOpts := TIDEToolBarOptions.Create;
298 ToolBarOpts.PosIndex := 1;
299 ToolBarOpts.Break := True;
300 with ToolBarOpts.ButtonNames do
301 begin
302 Add('View Units');
303 Add('View Forms');
304 Add(cIDEToolbarDivider);
305 Add('Change build mode');
306 Add('Run program');
307 Add('Pause program');
308 Add('Stop program');
309 Add('Step over');
310 Add('Step into');
311 Add('Step out');
312 end;
313 FToolBars.Add(ToolBarOpts);
314 end;
315
316 procedure TIDECoolBarOptions.Load(XMLConfig: TXMLConfig; Path: String);
317 var
318 ToolBarOpt: TIDEToolBarOptions;
319 ToolBarCount: Integer;
320 I: Integer;
321 begin
322 Path := Path + BasePath;
323 ToolbarCount := XMLConfig.GetValue(Path + 'Count', 0);
324 if ToolBarCount = 0 then // Old format
325 ToolbarCount := XMLConfig.GetValue(Path + 'ToolBarCount/Value', 0);
326 FVisible := XMLConfig.GetValue(Path + 'Visible/Value', True);
327 FWidth := XMLConfig.GetValue(Path + 'Width/Value', 230);
328 FGrabStyle := XMLConfig.GetValue(Path + 'GrabStyle/Value', 1);
329 FGrabWidth := XMLConfig.GetValue(Path + 'GrabWidth/Value', 5);
330 FBorderStyle := XMLConfig.GetValue(Path + 'BorderStyle/Value', 1);
331 if ToolBarCount > 0 then
332 begin
333 FToolBars.Clear;
334 for I := 0 to ToolbarCount-1 do
335 begin
336 ToolBarOpt := TIDEToolBarOptions.Create;
337 FToolBars.Add(ToolBarOpt);
338 ToolBarOpt.PosIndex := I;
339 ToolBarOpt.Load(XMLConfig, Path + 'ToolBar' + IntToStr(I+1) + '/');
340 end;
341 end;
342 if ToolBarCount = 0 then
343 CreateDefaultToolbars;
344 end;
345
346 procedure TIDECoolBarOptions.Save(XMLConfig: TXMLConfig; Path: String);
347 var
348 DefaultOpts: TDefaultCoolBarOptions;
349 I: Integer;
350 begin
351 DefaultOpts := TDefaultCoolBarOptions.Create;
352 try
353 Path := Path + BasePath;
354 XMLConfig.DeletePath(Path);
355 XMLConfig.SetDeleteValue(Path + 'Visible/Value', FVisible, True);
356 XMLConfig.SetDeleteValue(Path + 'Width/Value', FWidth, 0);
357 XMLConfig.SetDeleteValue(Path + 'GrabStyle/Value', FGrabStyle, 1);
358 XMLConfig.SetDeleteValue(Path + 'GrabWidth/Value', FGrabWidth, 5);
359 XMLConfig.SetDeleteValue(Path + 'BorderStyle/Value', FBorderStyle, 1);
360 if EqualToolbars(DefaultOpts) then Exit;
361 if FToolBars.Count > 0 then
362 begin
363 XMLConfig.SetDeleteValue(Path + 'Count', FToolBars.Count, 0);
364 for I := 0 to FToolBars.Count - 1 do
365 FToolBars[I].Save(XMLConfig, Path + 'ToolBar' + IntToStr(I+1) + '/');
366 end;
367 finally
368 DefaultOpts.Free;
369 end;
370 end;
371
372 { TDefaultCoolBarOptions }
373
374 constructor TDefaultCoolBarOptions.Create;
375 begin
376 inherited Create;
377 //coolbar defaults
378 FVisible := True;
379 FWidth := 230;
380 FGrabStyle := 1;
381 FGrabWidth := 5;
382 FBorderStyle := 1;
383 //toolbar defaults
384 CreateDefaultToolbars;
385 end;
386
387 destructor TDefaultCoolBarOptions.Destroy;
388 begin
389 inherited Destroy;
390 end;
391
392 { TIDEToolBar }
393
394 constructor TIDEToolBar.Create(AOwner: TComponent);
395 begin
396 inherited Create(AOwner);
397 FToolBar := TToolbar.Create(nil);
398 with FToolBar do
399 begin
400 ButtonHeight := 22;
401 ButtonWidth := 22;
402 Height := 22;
403 Width := 0;
404 Flat := True;
405 AutoSize := True;
406 Transparent := True;
407 EdgeInner := esNone;
408 EdgeOuter := esNone;
409 Images := IDEImages.Images_16;
410 ShowHint := True;
411 OnClick := @DoToolBarClick;
412 end;
413 FCurrentOptions := TIDEToolBarOptions.Create;
414 end;
415
416 destructor TIDEToolBar.Destroy;
417 begin
418 FCurrentOptions.Free;
419 FToolBar.Free;
420 inherited Destroy;
421 end;
422
423 procedure TIDEToolBar.ClearToolbar;
424 var
425 i: Integer;
426 begin
427 FToolBar.BeginUpdate;
428 try
429 for i := FToolBar.ButtonCount - 1 downto 0 do
430 FToolBar.Buttons[i].Free
431 finally
432 FToolBar.EndUpdate;
433 end;
434 end;
435
436 procedure TIDEToolBar.UseCurrentOptions;
437 begin
438 ClearToolbar;
439 CopyFromOptions(FCurrentOptions);
440 end;
441
442 procedure TIDEToolBar.DoToolBarClick(Sender: TObject);
443 begin
444 if Assigned(FOnToolbarClick) then
445 FOnToolbarClick(FToolbar);
446 end;
447
448 { TIDECoolBar }
449
450 constructor TIDECoolBar.Create(ACoolBar: TCoolBar);
451 begin
452 inherited Create;
453 FCoolBar := ACoolBar;
454 FCoolBarToolBars := TIDEToolBarList.Create;
455 FDefaultOptions := TDefaultCoolBarOptions.Create;
456 if Assigned(FCoolBar) then begin
457 CopyFromOptions(FDefaultOptions);
458 SetCoolBarDefaults;
459 SetToolBarDefaults;
460 end;
461 end;
462
463 destructor TIDECoolBar.Destroy;
464 begin
465 FreeAndNil(FDefaultOptions);
466 FreeAndNil(FCoolBarToolBars);
467 inherited Destroy;
468 end;
469
470 procedure TIDECoolBar.SetIsVisible(AValue: Boolean);
471 begin
472 FIsVisible := AValue;
473 if Assigned(FCoolBar) then
474 FCoolBar.Visible := AValue;
475 end;
476
477 procedure TIDECoolBar.ToolBarClick(Sender: TObject);
478 var
479 CoolBand: TCoolBand;
480 begin
481 CoolBand := FCoolbar.Bands.FindBand(Sender as TToolBar);
482 if CoolBand <> nil then
483 SelectBand(CoolBand.Index);
484 end;
485
486 procedure TIDECoolBar.SetCoolBarDefaults;
487 begin
488 FCoolBar.Vertical := False;
489 FCoolBar.HorizontalSpacing := 1;
490 FCoolBar.VerticalSpacing := 3;
491 FCoolBar.FixedSize := True;
492 FCoolBar.EdgeInner := esNone;
493 FCoolBar.EdgeOuter := esNone;
494
495 FCoolBar.GrabStyle := TGrabStyle(1);
496 FCoolBar.GrabWidth := 5;
497 FCoolBar.BandBorderStyle := bsSingle;
498 end;
499
500 procedure TIDECoolBar.SetToolBarDefaults;
501 begin
502 CopyFromOptions(FDefaultOptions);
503 end;
504
505 procedure TIDECoolBar.CopyFromRealCoolbar(RealCoolbar: TCoolBar);
506 var
507 ToolBar: TToolBar;
508 I, J: Integer;
509 begin
510 for I := 0 to RealCoolbar.Bands.Count - 1 do
511 begin
512 if RealCoolbar.Bands[I].Control = nil then
513 Continue;
514 ToolBar := (RealCoolbar.Bands[I].Control as TToolBar);
515 J := FindByToolBar(ToolBar);
516 if J <> -1 then
517 ToolBars[J].CurrentOptions.CopyPosFromBand(RealCoolbar.Bands[I]);
518 end;
519 Sort;
520 end;
521
522 procedure TIDECoolBar.CopyFromOptions(Options: TIDECoolBarOptions);
523 var
524 I: Integer;
525 IDEToolBar: TIDEToolBar;
526 begin
527 FCoolBarToolBars.Clear;
528 for I := 0 to Options.FToolBars.Count - 1 do
529 begin
530 IDEToolBar := Add;
531 IDEToolBar.CurrentOptions.PosIndex := I;
532 IDEToolBar.CurrentOptions.Break := Options.FToolBars[I].Break;
533 IDEToolBar.CurrentOptions.ButtonNames.Assign(Options.FToolBars[I].ButtonNames);
534 end;
535 end;
536
537 procedure TIDECoolBar.CopyToOptions(Options: TIDECoolBarOptions);
538 var
539 I: Integer;
540 Opt: TIDEToolBarOptions;
541 begin
542 Options.FToolBars.Clear;
543 for I := 0 to FCoolBarToolBars.Count - 1 do
544 begin
545 Opt := TIDEToolBarOptions.Create;
546 Options.FToolBars.Add(Opt);
547 Opt.PosIndex := FCoolBarToolBars[I].CurrentOptions.PosIndex;
548 Opt.Break := FCoolBarToolBars[I].CurrentOptions.Break;
549 Opt.ButtonNames.Assign(FCoolBarToolBars[I].CurrentOptions.ButtonNames);
550 end;
551 end;
552
Addnull553 function TIDECoolBar.Add: TIDEToolBar;
554 begin
555 Result := TIDEToolBar.Create(Nil);
556 FCoolBarToolBars.Add(Result);
557 end;
558
AddBandnull559 function TIDECoolBar.AddBand(ToolBar: TToolBar; aBreak: Boolean): TCoolBand;
560 begin
561 Result := FCoolBar.Bands.Add;
562 Result.Break := aBreak;
563 Result.Control := Toolbar;
564 //Result.MinWidth := 25;
565 //Result.MinHeight := 22;
566 Result.FixedSize := True;
567 end;
568
569 procedure TIDECoolBar.AddExtra;
570 var
571 IDEToolbar: TIDEToolBar;
572 begin
573 IDEToolbar := Add;
574 IDEToolbar.CurrentOptions.Break := False;
575 IDEToolbar.OnToolBarClick := @ToolBarClick;
576 IDEToolbar.ToolBar.DisabledImages := IDEToolbar.ToolBar.Images;
577 SelectBand(AddBand(IDEToolbar.ToolBar, True).Index);
578 end;
579
580 procedure TIDECoolBar.Delete;
581 var
582 I: integer;
583 ToDelete: integer;
584 begin
585 if FCoolbar.Bands.Count = 1 then
586 begin
587 MessageDlg(lisCoolbarDeleteWarning, mtInformation, [mbOk], 0);
588 Exit;
589 end;
590 ToDelete := GetSelectedBand;
591 if ToDelete > -1 then
592 begin
593 if MessageDlg(lisCoolbarDeleteToolBar, mtConfirmation, [mbYes, mbNo], 0) = mrYes then
594 begin
595 if ToDelete < FCoolBar.Bands.Count-1 then
596 SelectBand(ToDelete + 1)
597 else if ToDelete > 0 then
598 SelectBand(ToDelete - 1);
599 I := FindByToolBar((FCoolBar.Bands.Items[ToDelete].Control as TToolBar));
600 Assert(I = ToDelete, 'TIDECoolBar.Delete: index mismatch.');
601 ToolBars.Delete(ToDelete);
602 end;
603 end;
604 end;
605
FindByToolBarnull606 function TIDECoolBar.FindByToolBar(const aToolBar: TToolBar): Integer;
607 var
608 I: Integer;
609 begin
610 for I := 0 to FCoolbarToolBars.Count-1 do
611 if ToolBars[I].ToolBar = aToolBar then
612 Exit(I);
613 Result := -1;
614 end;
615
616 procedure TIDECoolBar.Config;
617 var
618 ToConfig: Integer;
619 ToolBar: TToolBar;
620 IDEToolbar: TIDEToolBar;
621 begin
622 ToConfig := GetSelectedBand;
623 if ToConfig = -1 then
624 begin
625 MessageDlg(lisCoolbarSelectToolBar, mtInformation, [mbOk], 0);
626 Exit;
627 end;
628 ToolBar := FCoolbar.Bands.Items[ToConfig].Control as TToolBar;
629 Assert(Assigned(ToolBar), 'TIDECoolBar.Config: ToolBar=Nil.');
630 Assert(ToConfig=FindByToolBar(ToolBar), 'TIDECoolBar.Config: Indices differ!');
631 IDEToolbar := ToolBars[ToConfig];
632 if ShowToolBarConfig(IDEToolbar.CurrentOptions.ButtonNames) = mrOK then
633 DisableToolbarButtons(IDEToolbar);
634 FCoolbar.AutosizeBands;
635 end;
636
637 function Compare(const Item1, Item2: TIDEToolBar): Integer;
638 begin
639 Result := Item1.CurrentOptions.PosIndex - Item2.CurrentOptions.PosIndex;
640 end;
641
642 procedure TIDECoolBar.Sort;
643 begin
644 FCoolbarToolBars.Sort(@Compare);
645 end;
646
647 procedure TIDECoolBar.DisableToolbarButtons(IDEToolbar: TIDEToolBar);
648 var
649 I: Integer;
650 begin
651 IDEToolbar.UseCurrentOptions;
652 for I := 0 to Pred(IDEToolbar.ToolBar.ButtonCount) do
653 IDEToolbar.ToolBar.Buttons[I].Enabled := False;
654 end;
655
656 procedure TIDECoolBar.PopulateToolBar;
657 var
658 I: Integer;
659 IDEToolbar: TIDEToolBar;
660 begin
661 FCoolBar.Bands.Clear;
662 for I := 0 to ToolBars.Count - 1 do
663 begin
664 IDEToolbar := ToolBars[I];
665 IDEToolbar.OnToolBarClick := @ToolBarClick;
666 IDEToolbar.ToolBar.DisabledImages := IDEToolbar.ToolBar.Images;
667 AddBand(IDEToolbar.ToolBar, IDEToolbar.CurrentOptions.Break);
668 DisableToolbarButtons(IDEToolbar);
669 end;
670 if FCoolBar.Bands.Count > 0 then
671 SelectBand(0);
672 FCoolbar.AutosizeBands;
673 end;
674
GetSelectedBandnull675 function TIDECoolBar.GetSelectedBand: Integer;
676 var
677 I: Integer;
678 begin
679 for I := 0 to FCoolBar.Bands.Count - 1 do
680 if FCoolBar.Bands.Items[I].Color = clHighlight then
681 Exit(I);
682 Result := -1;
683 end;
684
IsDefaultCoolbarnull685 function TIDECoolBar.IsDefaultCoolbar: Boolean;
686 begin
687 Result := (FIsVisible) and (FCoolBar.BandBorderStyle = bsSingle) and
688 (FCoolBar.GrabStyle = gsDouble) and (FCoolBar.GrabWidth = 5) and
689 (FWidth = 230);
690 end;
691
IsDefaultToolbarnull692 function TIDECoolBar.IsDefaultToolbar: Boolean;
693 var
694 TempOpts: TIDECoolBarOptions;
695 begin
696 TempOpts := TIDECoolBarOptions.Create;
697 try
698 CopyToOptions(TempOpts);
699 Result := TempOpts.EqualToolbars(FDefaultOptions);
700 finally
701 TempOpts.Free;
702 end;
703 end;
704
705 procedure TIDECoolBar.SelectBand(const ID: integer);
706 var
707 I: integer;
708 Band: TCoolBand;
709 begin
710 FCoolbar.Color := clDefault;
711 for I := 0 to FCoolBar.Bands.Count - 1 do
712 begin
713 Band := FCoolBar.Bands.Items[I];
714 if I <> ID then
715 begin
716 Band.Color := clDefault;
717 Band.Control.Color := clDefault;
718 end
719 else
720 begin
721 Band.Color := clHighlight;
722 Band.Control.Color := clHighLight;
723 end;
724 end;
725 end;
726
727 procedure TIDECoolBar.SelectBandAtXY(X, Y: integer);
728 var
729 ABand: integer;
730 AGrabber: boolean;
731 begin
732 FCoolBar.MouseToBandPos(X, Y, ABand, AGrabber);
733 if ABand < 0 then
734 Exit;
735 if FCoolBar.Bands.Items[ABand].Color <> clHighlight then
736 SelectBand(ABand);
737 end;
738
739 end.
740