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

« back to all changes in this revision

Viewing changes to lcl/include/tabcontrol.inc

  • 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:
77
77
  FTabWidth:=AValue;
78
78
end;
79
79
 
80
 
constructor TTabControlStrings.Create(TheTabControl: TCustomTabControl);
 
80
constructor TTabControlStrings.Create(TheTabControl: TTabControl);
81
81
begin
82
82
  inherited Create;
83
83
  FTabControl:=TheTabControl;
184
184
  FNoteBook.Pages[Index]:=S;
185
185
end;
186
186
 
187
 
procedure TTabControlNoteBookStrings.PutObject(Index: Integer; AObject: TObject
188
 
  );
 
187
procedure TTabControlNoteBookStrings.PutObject(Index: Integer; AObject: TObject);
189
188
begin
190
189
  FNoteBook.Pages.Objects[Index]:=AObject;
191
190
end;
230
229
  FNoteBook.PageIndex:=AValue;
231
230
end;
232
231
 
233
 
constructor TTabControlNoteBookStrings.Create(TheTabControl: TCustomTabControl);
 
232
constructor TTabControlNoteBookStrings.Create(TheTabControl: TTabControl);
234
233
begin
235
234
  inherited Create(TheTabControl);
236
 
  FNoteBook := TNoteBook{%H-}.Create(nil);
 
235
  FNoteBook := TCustomTabControl{%H-}.Create(nil);
237
236
  FNoteBook.ControlStyle := FNoteBook.ControlStyle + [csNoDesignSelectable];
238
237
  FNoteBook.Parent := TabControl;
239
238
  FNoteBook.OnGetImageIndex := @NBGetImageIndex;
240
239
  FNoteBook.OnChanging := @NBChanging;
241
 
  FNoteBook.OnPageChanged := @NBPageChanged;
 
240
  FNoteBook.OnChange := @NBPageChanged;
242
241
  TabControlBoundsChange;
243
242
end;
244
243
 
314
313
  Result:=FNoteBook.TabIndexAtClientPos(Point(X, Y));
315
314
end;
316
315
 
317
 
{ TCustomTabControl }
 
316
{ TTabControl }
318
317
 
319
 
procedure TCustomTabControl.AdjustDisplayRect(var ARect: TRect);
 
318
procedure TTabControl.AdjustDisplayRect(var ARect: TRect);
320
319
begin
321
320
  AdjustDisplayRectWithBorder(ARect);
322
321
  if TabPosition<>tpTop then
329
328
    ARect.Right:=Max(Min(ARect.Right,ARect.Right-BorderWidth),ARect.Left);
330
329
end;
331
330
 
332
 
function TCustomTabControl.GetDisplayRect: TRect;
 
331
function TTabControl.GetDisplayRect: TRect;
333
332
begin
334
333
  Result:=ClientRect;
335
334
  AdjustDisplayRect(Result);
336
335
end;
337
336
 
338
 
function TCustomTabControl.GetHotTrack: Boolean;
 
337
function TTabControl.GetHotTrack: Boolean;
339
338
begin
340
339
  Result:=TTabControlStrings(FTabs).HotTrack;
341
340
end;
342
341
 
343
 
function TCustomTabControl.GetMultiLine: Boolean;
 
342
function TTabControl.GetMultiLine: Boolean;
344
343
begin
345
344
  Result:=TTabControlStrings(FTabs).MultiLine;
346
345
end;
347
346
 
348
 
function TCustomTabControl.GetMultiSelect: Boolean;
 
347
function TTabControl.GetMultiSelect: Boolean;
349
348
begin
350
349
  Result:=TTabControlStrings(FTabs).MultiSelect;
351
350
end;
352
351
 
353
 
function TCustomTabControl.GetOwnerDraw: Boolean;
 
352
function TTabControl.GetOwnerDraw: Boolean;
354
353
begin
355
354
  Result:=TTabControlStrings(FTabs).OwnerDraw;
356
355
end;
357
356
 
358
 
function TCustomTabControl.GetRaggedRight: Boolean;
 
357
function TTabControl.GetRaggedRight: Boolean;
359
358
begin
360
359
  Result:=TTabControlStrings(FTabs).RaggedRight;
361
360
end;
362
361
 
363
 
function TCustomTabControl.GetScrollOpposite: Boolean;
 
362
function TTabControl.GetScrollOpposite: Boolean;
364
363
begin
365
364
  Result:=TTabControlStrings(FTabs).ScrollOpposite;
366
365
end;
367
366
 
368
 
function TCustomTabControl.GetTabHeight: Smallint;
 
367
function TTabControl.GetTabHeight: Smallint;
369
368
begin
370
369
  Result:=TTabControlStrings(FTabs).TabHeight;
371
370
end;
372
371
 
373
 
function TCustomTabControl.GetTabIndex: Integer;
 
372
function TTabControl.GetTabIndex: Integer;
374
373
begin
375
374
  Result:=TTabControlStrings(FTabs).TabIndex;
376
375
end;
377
376
 
378
 
function TCustomTabControl.GetTabWidth: Smallint;
 
377
function TTabControl.GetTabWidth: Smallint;
379
378
begin
380
379
  Result:=TTabControlStrings(FTabs).TabWidth;
381
380
end;
382
381
 
383
 
procedure TCustomTabControl.SetHotTrack(const AValue: Boolean);
 
382
procedure TTabControl.SetHotTrack(const AValue: Boolean);
384
383
begin
385
384
  TTabControlStrings(FTabs).HotTrack:=AValue;
386
385
end;
387
386
 
388
 
procedure TCustomTabControl.SetImages(const AValue: TCustomImageList);
 
387
procedure TTabControl.SetImages(const AValue: TCustomImageList);
389
388
begin
390
389
  if FImages = AValue then Exit;
391
390
  if FImages <> nil then
392
391
    FImages.RemoveFreeNotification(Self);
393
 
  FImages := AValue;
 
392
  FImages := TImageList(AValue);
394
393
  if FImages <> nil then
395
394
    FImages.FreeNotification(Self);
396
395
  TTabControlStrings(FTabs).Images := FImages;
397
396
end;
398
397
 
399
 
procedure TCustomTabControl.SetMultiLine(const AValue: Boolean);
 
398
procedure TTabControl.SetMultiLine(const AValue: Boolean);
400
399
begin
401
400
  TTabControlStrings(FTabs).MultiLine:=AValue;
402
401
end;
403
402
 
404
 
procedure TCustomTabControl.SetMultiSelect(const AValue: Boolean);
 
403
procedure TTabControl.SetMultiSelect(const AValue: Boolean);
405
404
begin
406
405
  TTabControlStrings(FTabs).MultiSelect:=AValue;
407
406
end;
408
407
 
409
 
procedure TCustomTabControl.SetOwnerDraw(const AValue: Boolean);
 
408
procedure TTabControl.SetOwnerDraw(const AValue: Boolean);
410
409
begin
411
410
  TTabControlStrings(FTabs).OwnerDraw:=AValue;
412
411
end;
413
412
 
414
 
procedure TCustomTabControl.SetRaggedRight(const AValue: Boolean);
 
413
procedure TTabControl.SetRaggedRight(const AValue: Boolean);
415
414
begin
416
415
  TTabControlStrings(FTabs).RaggedRight:=AValue;
417
416
end;
418
417
 
419
 
procedure TCustomTabControl.SetScrollOpposite(const AValue: Boolean);
 
418
procedure TTabControl.SetScrollOpposite(const AValue: Boolean);
420
419
begin
421
420
  TTabControlStrings(FTabs).ScrollOpposite:=AValue;
422
421
end;
423
422
 
424
 
procedure TCustomTabControl.SetStyle(const AValue: TTabStyle);
 
423
procedure TTabControl.SetStyle(const AValue: TTabStyle);
425
424
begin
426
425
  if FStyle=AValue then exit;
427
426
  FStyle:=AValue;
428
427
  // ToDo
429
428
end;
430
429
 
431
 
procedure TCustomTabControl.SetTabHeight(const AValue: Smallint);
 
430
procedure TTabControl.SetTabHeight(const AValue: Smallint);
432
431
begin
433
432
  TTabControlStrings(FTabs).TabHeight:=AValue;
434
433
end;
435
434
 
436
 
procedure TCustomTabControl.SetTabPosition(const AValue: TTabPosition);
 
435
procedure TTabControl.SetTabPosition(const AValue: TTabPosition);
437
436
begin
438
437
  if FTabPosition=AValue then exit;
439
438
  FTabPosition:=AValue;
441
440
  ReAlign;
442
441
end;
443
442
 
444
 
procedure TCustomTabControl.SetTabs(const AValue: TStrings);
 
443
procedure TTabControl.SetTabs(const AValue: TStrings);
445
444
begin
446
445
  FTabs.Assign(AValue);
447
446
end;
448
447
 
449
 
procedure TCustomTabControl.SetTabWidth(const AValue: Smallint);
 
448
procedure TTabControl.SetTabWidth(const AValue: Smallint);
450
449
begin
451
450
  TTabControlStrings(FTabs).TabWidth:=AValue;
452
451
end;
453
452
 
454
 
function TCustomTabControl.CanChange: Boolean;
 
453
function TTabControl.CanChange: Boolean;
455
454
begin
456
455
  Result:=true;
457
456
  if FTabControlCreating then exit;
459
458
    FOnChanging(Self,Result);
460
459
end;
461
460
 
462
 
function TCustomTabControl.CanShowTab(ATabIndex: Integer): Boolean;
 
461
function TTabControl.CanShowTab(ATabIndex: Integer): Boolean;
463
462
begin
464
463
  Result:=true;
465
464
end;
466
465
 
467
 
procedure TCustomTabControl.Change;
 
466
procedure TTabControl.Change;
468
467
begin
469
468
  if FTabControlCreating then exit;
470
469
  if IsUpdating then begin
476
475
    FOnChange(Self);
477
476
end;
478
477
 
479
 
procedure TCustomTabControl.DrawTab(ATabIndex: Integer; const Rect: TRect;
480
 
  Active: Boolean);
481
 
begin
482
 
  if Assigned(FOnDrawTab) then
483
 
    FOnDrawTab(Self,TabIndex,Rect,Active)
484
 
  else
485
 
    Canvas.FillRect(Rect);
486
 
end;
487
 
 
488
 
function TCustomTabControl.GetImageIndex(ATabIndex: Integer): Integer;
 
478
function TTabControl.GetImageIndex(ATabIndex: Integer): Integer;
489
479
begin
490
480
  Result := ATabIndex;
491
481
  if Assigned(FOnGetImageIndex) then
492
482
    FOnGetImageIndex(Self, ATabIndex, Result);
493
483
end;
494
484
 
495
 
procedure TCustomTabControl.Loaded;
 
485
procedure TTabControl.Loaded;
496
486
begin
497
487
  inherited Loaded;
498
488
end;
499
489
 
500
 
procedure TCustomTabControl.CreateWnd;
 
490
procedure TTabControl.CreateWnd;
501
491
begin
502
492
  BeginUpdate;
503
493
  inherited CreateWnd;
504
494
  EndUpdate;
505
495
end;
506
496
 
507
 
procedure TCustomTabControl.DestroyHandle;
 
497
procedure TTabControl.DestroyHandle;
508
498
begin
509
499
  BeginUpdate;
510
500
  inherited DestroyHandle;
511
501
  EndUpdate;
512
502
end;
513
503
 
514
 
procedure TCustomTabControl.Notification(AComponent: TComponent;
 
504
procedure TTabControl.Notification(AComponent: TComponent;
515
505
  Operation: TOperation);
516
506
begin
517
507
  inherited Notification(AComponent, Operation);
519
509
    Images := nil;
520
510
end;
521
511
 
522
 
procedure TCustomTabControl.SetTabIndex(Value: Integer);
 
512
procedure TTabControl.SetTabIndex(Value: Integer);
523
513
begin
524
514
  TTabControlStrings(FTabs).TabIndex:=Value;
525
515
end;
526
516
 
527
 
procedure TCustomTabControl.UpdateTabImages;
 
517
procedure TTabControl.UpdateTabImages;
528
518
begin
529
519
  TTabControlStrings(FTabs).UpdateTabImages;
530
520
end;
531
521
 
532
 
procedure TCustomTabControl.ImageListChange(Sender: TObject);
 
522
procedure TTabControl.ImageListChange(Sender: TObject);
533
523
begin
534
524
  TTabControlStrings(FTabs).ImageListChange(Sender);
535
525
end;
536
526
 
537
 
procedure TCustomTabControl.DoSetBounds(ALeft, ATop, AWidth, AHeight: integer);
 
527
procedure TTabControl.DoSetBounds(ALeft, ATop, AWidth, AHeight: integer);
538
528
begin
539
529
  inherited DoSetBounds(ALeft, ATop, AWidth, AHeight);
540
 
  TTabControlStrings(FTabs).TabControlBoundsChange;
 
530
  if FTabs <> nil then
 
531
    TTabControlStrings(FTabs).TabControlBoundsChange;
541
532
end;
542
533
 
543
 
class function TCustomTabControl.GetControlClassDefaultSize: TSize;
 
534
class function TTabControl.GetControlClassDefaultSize: TSize;
544
535
begin
545
536
  Result.CX := 200;
546
537
  Result.CY := 150;
547
538
end;
548
539
 
549
 
procedure TCustomTabControl.Paint;
 
540
procedure TTabControl.PaintWindow(DC: HDC);
 
541
var
 
542
  DCChanged: boolean;
 
543
begin
 
544
  DCChanged := (not FCanvas.HandleAllocated) or (FCanvas.Handle <> DC);
 
545
  if DCChanged then
 
546
    FCanvas.Handle := DC;
 
547
  try
 
548
    Paint;
 
549
  finally
 
550
    if DCChanged then FCanvas.Handle := 0;
 
551
  end;
 
552
end;
 
553
 
 
554
procedure TTabControl.Paint;
550
555
var
551
556
  ARect: TRect;
552
557
  TS: TTextStyle;
553
558
  Details: TThemedElementDetails;
 
559
  lCanvas: TCanvas;
554
560
begin
555
 
  //DebugLn(['TCustomTabControl.Paint Bounds=',dbgs(BoundsRect),' ClientRect=',dbgs(ClientRect),' CientOrigin=',dbgs(ClientOrigin)]);
 
561
  lCanvas := FCanvas;
 
562
 
 
563
  //DebugLn(['TTabControl.Paint Bounds=',dbgs(BoundsRect),' ClientRect=',dbgs(ClientRect),' CientOrigin=',dbgs(ClientOrigin)]);
556
564
  // clear only display area since button area is painted by another control
557
565
  // draw a frame
558
566
  ARect := ClientRect;
559
567
  AdjustDisplayRectWithBorder(ARect);
560
568
 
561
569
  Details := ThemeServices.GetElementDetails(ttPane);
562
 
  ThemeServices.DrawElement(Canvas.Handle, Details, ARect);
 
570
  ThemeServices.DrawElement(lCanvas.Handle, Details, ARect);
563
571
 
564
572
  InflateRect(ARect,BorderWidth,BorderWidth);
565
 
  Canvas.Frame3d(ARect, BorderWidth, bvRaised);
 
573
  lCanvas.Frame3d(ARect, BorderWidth, bvRaised);
566
574
 
567
575
  if (csDesigning in ComponentState) and (Caption <> '') then
568
576
  begin
569
577
    ARect:=GetDisplayRect;
570
 
    TS := Canvas.TextStyle;
 
578
    TS := lCanvas.TextStyle;
571
579
    TS.Alignment:=taCenter;
572
580
    TS.Layout:= tlCenter;
573
581
    TS.Opaque:= false;
574
582
    TS.Clipping:= false;
575
 
    Canvas.TextRect(ARect, ARect.Left, ARect.Top, Caption, TS);
 
583
    lCanvas.TextRect(ARect, ARect.Left, ARect.Top, Caption, TS);
576
584
  end;
577
585
end;
578
586
 
579
 
procedure TCustomTabControl.AdjustDisplayRectWithBorder(var ARect: TRect);
 
587
procedure TTabControl.AdjustDisplayRectWithBorder(var ARect: TRect);
580
588
var
581
589
  TabAreaSize: LongInt;
582
590
begin
589
597
  end;
590
598
end;
591
599
 
592
 
function TCustomTabControl.GetTabRectWithBorder: TRect;
 
600
function TTabControl.GetTabRectWithBorder: TRect;
593
601
var
594
602
  TabAreaSize: LongInt;
595
603
begin
603
611
  end;
604
612
end;
605
613
 
606
 
procedure TCustomTabControl.AdjustClientRect(var ARect: TRect);
 
614
procedure TTabControl.AdjustClientRect(var ARect: TRect);
607
615
begin
608
616
  AdjustDisplayRect(ARect);
609
617
end;
610
618
 
611
 
constructor TCustomTabControl.Create(TheOwner: TComponent);
 
619
constructor TTabControl.Create(TheOwner: TComponent);
612
620
begin
613
621
  FTabControlCreating:=true;
614
622
  inherited Create(TheOwner);
622
630
    SetInitialBounds(0, 0, CX, CY);
623
631
  BorderWidth:=2;
624
632
  FTabControlCreating:=false;
 
633
 
 
634
  FCanvas := TControlCanvas.Create;
 
635
  TControlCanvas(FCanvas).Control := Self;
625
636
end;
626
637
 
627
 
destructor TCustomTabControl.Destroy;
 
638
destructor TTabControl.Destroy;
628
639
begin
629
640
  BeginUpdate;
 
641
  FCanvas.Free;
630
642
  FreeThenNil(FTabs);
631
643
  FreeThenNil(FImageChangeLink);
632
644
  inherited Destroy;
633
645
end;
634
646
 
635
 
function TCustomTabControl.IndexOfTabAt(X, Y: Integer): Integer;
 
647
function TTabControl.IndexOfTabAt(X, Y: Integer): Integer;
636
648
begin
637
649
  Result:=TTabControlStrings(FTabs).IndexOfTabAt(X,Y);
638
650
end;
639
651
 
640
 
function TCustomTabControl.GetHitTestInfoAt(X, Y: Integer): THitTests;
 
652
function TTabControl.GetHitTestInfoAt(X, Y: Integer): THitTests;
641
653
begin
642
654
  Result:=TTabControlStrings(FTabs).GetHitTestInfoAt(X,Y);
643
655
end;
644
656
 
645
 
function TCustomTabControl.IndexOfTabWithCaption(const TabCaption: string
 
657
function TTabControl.IndexOfTabWithCaption(const TabCaption: string
646
658
  ): Integer;
647
659
begin
648
660
  Result:=0;
653
665
  Result:=-1;
654
666
end;
655
667
 
656
 
function TCustomTabControl.TabRect(Index: Integer): TRect;
 
668
function TTabControl.TabRect(Index: Integer): TRect;
657
669
begin
658
670
  Result:=TTabControlStrings(FTabs).TabRect(Index);
659
671
end;
660
672
 
661
 
function TCustomTabControl.RowCount: Integer;
 
673
function TTabControl.RowCount: Integer;
662
674
begin
663
675
  Result:=TTabControlStrings(FTabs).RowCount;
664
676
end;
665
677
 
666
 
procedure TCustomTabControl.ScrollTabs(Delta: Integer);
 
678
procedure TTabControl.ScrollTabs(Delta: Integer);
667
679
begin
668
680
  TTabControlStrings(FTabs).ScrollTabs(Delta);
669
681
end;
670
682
 
671
 
procedure TCustomTabControl.BeginUpdate;
 
683
procedure TTabControl.BeginUpdate;
672
684
begin
673
685
  if FTabs=nil then exit;
674
686
  TTabControlStrings(FTabs).BeginUpdate;
675
 
  //debugln('TCustomTabControl.BeginUpdate ',dbgs(IsUpdating));
 
687
  //debugln('TTabControl.BeginUpdate ',dbgs(IsUpdating));
676
688
end;
677
689
 
678
 
procedure TCustomTabControl.EndUpdate;
 
690
procedure TTabControl.EndUpdate;
679
691
begin
680
692
  if FTabs=nil then exit;
681
693
  TTabControlStrings(FTabs).EndUpdate;
682
 
  //debugln('TCustomTabControl.EndUpdate ',dbgs(IsUpdating));
 
694
  //debugln('TTabControl.EndUpdate ',dbgs(IsUpdating));
683
695
  if not TTabControlStrings(FTabs).IsUpdating then begin
684
696
    if FOnChangeNeeded then Change;
685
697
  end;
686
698
end;
687
699
 
688
 
function TCustomTabControl.IsUpdating: boolean;
 
700
function TTabControl.IsUpdating: boolean;
689
701
begin
690
702
  Result:=(FTabs<>nil) and TTabControlStrings(fTabs).IsUpdating;
691
703
end;