开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Delphi控件源码 > 查看源码
bsSkinTabs.pas
资源名称：qqdelphiprog.rar　[点击查看]
上传用户：hylc_2004
上传日期：2014-01-23
资源大小：46800k
文件大小：68k
源码类别：

Delphi控件源码

开发平台：

Delphi

bsSkinTabs.pas：源码内容
  1. {*******************************************************************}
  2. {                                                                   }
  3. {       Almediadev Visual Component Library                         }
  4. {       BusinessSkinForm                                            }
  5. {       Version 2.90                                                }
  6. {                                                                   }
  7. {       Copyright (c) 2000-2004 Almediadev                          }
  8. {       ALL RIGHTS RESERVED                                         }
  9. {                                                                   }
  10. {       Home:  http://www.almdev.com                                }
  11. {       Support: support@almdev.com                                 }
  12. {                                                                   }
  13. {*******************************************************************}
  15. unit bsSkinTabs;
  17. {$P+,S-,W-,R-}
  18. {$WARNINGS OFF}
  19. {$HINTS OFF}
  21. interface
  23. uses SysUtils, Windows, Messages, Classes, Graphics, Controls, Forms, StdCtrls,
  24.      CommCtrl, ComCtrls, ExtCtrls, bsSkinData, bsSkinBoxCtrls;
  25. type
  27.   TbsSkinCustomTabSheet = class(TTabSheet)
  28.   protected
  29.     procedure WMSize(var Msg: TWMSize); message WM_SIZE;
  30.     procedure WMEraseBkGnd(var Msg: TWMEraseBkGnd); message WM_ERASEBKGND;
  31.   public
  32.     procedure PaintBG(DC: HDC);
  33.     constructor Create(AOwner: TComponent); override;
  34.     destructor Destroy; override;
  35.   end;
  37.   TbsSkinTabSheet = class(TbsSkinCustomTabSheet)
  38.   protected
  39.     procedure Notification(AComponent: TComponent; Operation: TOperation); override;
  40.   public
  41.     constructor Create(AOwner : TComponent); override;
  42.     destructor Destroy; override;
  43.   end;
  45.   TbsSkinPageControl = class(TPageControl)
  46.   private
  47.     FActiveTab, FOldActiveTab: Integer;
  48.     FActiveTabIndex, FOldActiveTabIndex: Integer;
  49.     function GetPosition: Integer;
  50.     function  GetInVisibleItemCount: Integer;
  51.     procedure OnUpDownChange(Sender: TObject);
  52.     procedure DrawTabs(Cnvs: TCanvas);
  53.     procedure DrawTab(TI: Integer; const Rct: TRect; Active, MouseIn: Boolean; Cnvs: TCanvas);
  54.     function GetItemRect(index: integer): TRect;
  55.     procedure SetItemSize(AWidth, AHeight: integer);
  56.     procedure CheckScroll;
  57.     procedure ShowSkinUpDown;
  58.     procedure HideSkinUpDown;
  59.     procedure TestActive(X, Y: Integer);
  60.   protected
  61.     //
  62.     FSD: TbsSkinData;
  63.     FSkinDataName: String;
  64.     FIndex: Integer;
  65.     FSkinUpDown: TbsSkinUpDown;
  66.     FDefaultFont: TFont;
  67.     FUseSkinFont: Boolean;
  68.     FDefaultItemHeight: Integer;
  69.     procedure SetDefaultItemHeight(Value: Integer);
  70.     procedure SetDefaultFont(Value: TFont);
  71.     procedure Change; override;
  72.     procedure GetSkinData;
  73.     //
  74.     procedure Notification(AComponent: TComponent;
  75.       Operation: TOperation); override;
  76.     procedure SetSkinData(Value: TbsSkinData);
  77.     procedure WMEraseBkGnd(var Msg: TWMEraseBkGnd); message WM_ERASEBKGND;
  78.     procedure WMHSCROLL(var Msg: TWMEraseBkGnd); message WM_HSCROLL;
  79.     procedure WMSize(var Msg: TWMSize); message WM_SIZE;
  80.     procedure PaintDefaultWindow(Cnvs: TCanvas);
  81.     procedure PaintSkinWindow(Cnvs: TCanvas);
  82.     procedure PaintWindow(DC: HDC); override;
  83.     procedure WndProc(var Message:TMessage); override;
  84.     procedure MouseMove(Shift: TShiftState; X, Y: Integer); override;
  85.     procedure MouseDown(Button: TMouseButton; Shift: TShiftState;
  86.                         X, Y: Integer); override;
  87.     procedure CMMouseLeave(var Message: TMessage); message CM_MOUSELEAVE;
  88.   public
  89.     //
  90.     Picture: TBitMap;
  91.     SkinRect, ClRect, TabRect,
  92.     ActiveTabRect, FocusTabRect, MouseInTabRect: TRect;
  93.     TabsBGRect: TRect;
  94.     LTPoint, RTPoint, LBPoint, RBPoint: TPoint;
  95.     TabLeftOffset, TabRightOffset: Integer;
  96.     FontName: String;
  97.     FontStyle: TFontStyles;
  98.     FontHeight: Integer;
  99.     FontColor, ActiveFontColor, FocusFontColor, MouseInFontColor: TColor;
  100.     UpDown: String;
  101.     BGPictureIndex: Integer;
  102.     //
  103.     constructor Create(AOwner: TComponent); override;
  104.     destructor Destroy; override;
  105.     procedure ChangeSkinData;
  106.     procedure Loaded; override;
  107.     procedure UpDateTabs;
  108.   published
  109.     property DefaultFont: TFont read FDefaultFont write SetDefaultFont;
  110.     property UseSkinFont: Boolean read FUseSkinFont write FUseSkinFont;
  111.     property DefaultItemHeight: Integer read FDefaultItemHeight write SetDefaultItemHeight;
  112.     property SkinData: TbsSkinData read FSD write SetSkinData;
  113.     property SkinDataName: String read FSkinDataName write FSkinDataName;
  114.     property Color;
  115.     property ActivePage;
  116.     property Align;
  117.     property Anchors;
  118.     property BiDiMode;
  119.     property Constraints;
  120.     property DockSite;
  121.     property DragCursor;
  122.     property DragKind;
  123.     property DragMode;
  124.     property Enabled;
  125.     property Font;
  126.     property HotTrack;
  127.     property Images;
  128.     property OwnerDraw;
  129.     property ParentBiDiMode;
  130.     property ParentFont;
  131.     property ParentShowHint;
  132.     property PopupMenu;
  133.     property RaggedRight;
  134.     property ScrollOpposite;
  135.     property ShowHint;
  136.     property TabHeight;
  137.     property TabOrder;
  138.     property TabPosition;
  139.     property TabStop;
  140.     property TabWidth;
  141.     property Visible;
  142.     property OnChange;
  143.     property OnChanging;
  144.     property OnDockDrop;
  145.     property OnDockOver;
  146.     property OnDragDrop;
  147.     property OnDragOver;
  148.     property OnDrawTab;
  149.     property OnEndDock;
  150.     property OnEndDrag;
  151.     property OnEnter;
  152.     property OnExit;
  153.     property OnGetImageIndex;
  154.     property OnGetSiteInfo;
  155.     property OnMouseDown;
  156.     property OnMouseMove;
  157.     property OnMouseUp;
  158.     property OnResize;
  159.     property OnStartDock;
  160.     property OnStartDrag;
  161.     property OnUnDock;
  162.   end;
  164.   TbsSkinTabControl = class(TTabControl)
  165.   private
  166.     FOldTop, FOldBottom: Integer;
  167.     FActiveTab, FOldActiveTab: Integer;
  168.     function GetPosition: Integer;
  169.     function  GetInVisibleItemCount: Integer;
  170.     procedure OnUpDownChange(Sender: TObject);
  171.     procedure DrawTabs(Cnvs: TCanvas);
  172.     procedure DrawTab(TI: Integer; const Rct: TRect; Active, MouseIn: Boolean; Cnvs: TCanvas);
  173.     function GetItemRect(index: integer): TRect;
  174.     procedure SetItemSize(AWidth, AHeight: integer);
  175.     procedure CheckScroll;
  176.     procedure ShowSkinUpDown;
  177.     procedure HideSkinUpDown;
  178.     procedure TestActive(X, Y: Integer);
  179.   protected
  180.     //
  181.     FSD: TbsSkinData;
  182.     FSkinDataName: String;
  183.     FIndex: Integer;
  184.     FSkinUpDown: TbsSkinUpDown;
  185.     FDefaultFont: TFont;
  186.     FUseSkinFont: Boolean;
  187.     FDefaultItemHeight: Integer;
  188.     procedure SetDefaultItemHeight(Value: Integer);
  189.     procedure SetDefaultFont(Value: TFont);
  190.     procedure WMSize(var Msg: TWMSize); message WM_SIZE;
  191.     procedure WMPaint(var Msg: TWMPaint); message WM_PAINT;
  192.     procedure GetSkinData;
  193.     //
  194.     procedure Notification(AComponent: TComponent;
  195.       Operation: TOperation); override;
  196.     procedure SetSkinData(Value: TbsSkinData);
  197.     procedure WMEraseBkGnd(var Msg: TWMEraseBkGnd); message WM_ERASEBKGND;
  198.     procedure WMHSCROLL(var Msg: TWMEraseBkGnd); message WM_HSCROLL;
  199.     procedure PaintDefaultWindow(Cnvs: TCanvas);
  200.     procedure PaintSkinWindow(Cnvs: TCanvas);
  201.     procedure PaintWindow(DC: HDC); override;
  202.     procedure WndProc(var Message:TMessage); override;
  203.     procedure Change; override;
  204.     procedure MouseMove(Shift: TShiftState; X, Y: Integer); override;
  205.     procedure MouseDown(Button: TMouseButton; Shift: TShiftState;
  206.       X, Y: Integer); override;
  207.     procedure CMMouseLeave(var Message: TMessage); message CM_MOUSELEAVE;
  208.   public
  209.     //
  210.     Picture: TBitMap;
  211.     SkinRect, ClRect, TabRect,
  212.     ActiveTabRect, FocusTabRect, MouseInTabRect: TRect;
  213.     TabsBGRect: TRect;
  214.     LTPoint, RTPoint, LBPoint, RBPoint: TPoint;
  215.     TabLeftOffset, TabRightOffset: Integer;
  216.     FontName: String;
  217.     FontStyle: TFontStyles;
  218.     FontHeight: Integer;
  219.     FontColor, ActiveFontColor, FocusFontColor, MouseInFontColor: TColor;
  220.     UpDown: String;
  221.     BGPictureIndex: Integer;
  222.     //
  223.     constructor Create(AOwner: TComponent); override;
  224.     destructor Destroy; override;
  225.     procedure ChangeSkinData;
  226.     procedure Loaded; override;
  227.     procedure UpDateTabs; 
  228.   published
  229.     property DefaultFont: TFont read FDefaultFont write SetDefaultFont;
  230.     property UseSkinFont: Boolean read FUseSkinFont write FUseSkinFont;
  231.     property DefaultItemHeight: Integer read FDefaultItemHeight write SetDefaultItemHeight;
  232.     property SkinData: TbsSkinData read FSD write SetSkinData;
  233.     property SkinDataName: String read FSkinDataName write FSkinDataName;
  234.     property Color;
  235.     property Align;
  236.     property Anchors;
  237.     property BiDiMode;
  238.     property Constraints;
  239.     property DockSite;
  240.     property DragCursor;
  241.     property DragKind;
  242.     property DragMode;
  243.     property Enabled;
  244.     property Font;
  245.     property HotTrack;
  246.     property Images;
  247.     property OwnerDraw;
  248.     property ParentBiDiMode;
  249.     property ParentFont;
  250.     property ParentShowHint;
  251.     property PopupMenu;
  252.     property RaggedRight;
  253.     property ScrollOpposite;
  254.     property ShowHint;
  255.     property TabHeight;
  256.     property TabOrder;
  257.     property TabPosition;
  258.     property TabStop;
  259.     property TabWidth;
  260.     property Visible;
  261.     property OnChange;
  262.     property OnChanging;
  263.     property OnDockDrop;
  264.     property OnDockOver;
  265.     property OnDragDrop;
  266.     property OnDragOver;
  267.     property OnDrawTab;
  268.     property OnEndDock;
  269.     property OnEndDrag;
  270.     property OnEnter;
  271.     property OnExit;
  272.     property OnGetImageIndex;
  273.     property OnGetSiteInfo;
  274.     property OnMouseDown;
  275.     property OnMouseMove;
  276.     property OnMouseUp;
  277.     property OnResize;
  278.     property OnStartDock;
  279.     property OnStartDrag;
  280.     property OnUnDock;
  281.   end;
  283. implementation
  285. uses Consts, ComStrs, bsUtils, ImgList, BusinessSkinForm, bsEffects;
  288. procedure DrawRotate90_1(Cnvs: TCanvas; B: TBitMap; X, Y: Integer);
  289. var
  290.   B1, B2: TbsEffectBmp;
  291. begin
  292.   B1 := TbsEffectBmp.CreateFromhWnd(B.Handle);
  293.   B2 := TbsEffectBmp.Create(B1.Height, B1.Width);
  294.   B1.Rotate90_1(B2);
  295.   B2.Draw(Cnvs.Handle, X, Y);
  296.   B1.Free;
  297.   B2.Free;
  298. end;
  300. procedure DrawFlipVert(B: TBitMap);
  301. var
  302.   B1, B2: TbsEffectBmp;
  303. begin
  304.   B1 := TbsEffectBmp.CreateFromhWnd(B.Handle);
  305.   B2 := TbsEffectBmp.Create(B1.Width, B1.Height);
  306.   B1.FlipVert(B2);
  307.   B2.Draw(B.Canvas.Handle, 0, 0);
  308.   B1.Free;
  309.   B2.Free;
  310. end;
  312. procedure DrawRotate90_2(Cnvs: TCanvas; B: TBitMap; X, Y: Integer);
  313. var
  314.   B1, B2: TbsEffectBmp;
  315. begin
  316.   B1 := TbsEffectBmp.CreateFromhWnd(B.Handle);
  317.   B2 := TbsEffectBmp.Create(B1.Height, B1.Width);
  318.   B1.Rotate90_2(B2);
  319.   B2.Draw(Cnvs.Handle, X, Y);
  320.   B1.Free;
  321.   B2.Free;
  322. end;
  324. procedure DrawTabGlyphAndText(Cnvs: TCanvas; W, H: Integer; S: String;
  325.                               IM: TCustomImageList; IMIndex: Integer;
  326.                               AEnabled: Boolean);
  328. var
  329.   R, TR: TRect;
  330.   GX, GY, GW, GH, TW, TH: Integer;
  331. begin
  332.   R := Rect(0, 0, 0, 0);
  333.   DrawText(Cnvs.Handle, PChar(S), Length(S), R, DT_CALCRECT);
  334.   TW := RectWidth(R) + 2;
  335.   TH := RectHeight(R);
  336.   GW := IM.Width;
  337.   GH := IM.Height;
  338.   GX := W div 2 - (GW + TW + 2) div 2;
  339.   GY := H div 2 - GH div 2;
  340.   TR.Left := GX + GW + 2;
  341.   TR.Top := H div 2 - TH div 2;
  342.   TR.Right := TR.Left + TW;
  343.   TR.Bottom := TR.Top + TH;
  344.   DrawText(Cnvs.Handle, PChar(S), Length(S), TR, DT_CENTER);
  345.   IM.Draw(Cnvs, GX, GY, IMIndex, AEnabled);
  346. end;
  348. constructor TbsSkinCustomTabSheet.Create(AOwner: TComponent);
  349. begin
  350.   inherited Create(AOwner);
  351.   Align := alClient;
  352.   ControlStyle := ControlStyle + [csAcceptsControls, csNoDesignVisible];
  353.   Visible := False;
  354. end;
  356. destructor TbsSkinCustomTabSheet.Destroy;
  357. begin
  358.   inherited Destroy;
  359. end;
  361. procedure TbsSkinCustomTabSheet.WMEraseBkGnd;
  362. begin
  363.   PaintBG(Msg.DC);
  364. end;
  366. procedure TbsSkinCustomTabSheet.WMSize;
  367. begin
  368.   inherited;
  369.   RePaint;
  370. end;
  372. procedure TbsSkinCustomTabSheet.PaintBG;
  373. var
  374.   C: TCanvas;
  375.   TabSheetBG: TBitMap;
  376.   PC: TbsSkinPageControl;
  377.   X, Y, XCnt, YCnt, w, h, w1, h1: Integer;
  378. begin
  379.   if (Width <= 0) or (Height <=0) then Exit;
  380.   PC := TbsSkinPageControl(Parent);
  381.   if PC = nil then Exit;
  382.   PC.GetSkinData;
  383.   C := TCanvas.Create;
  384.   C.Handle := DC;
  386.   if (PC.FSD <> nil) and (not PC.FSD.Empty) and
  387.      (PC.FIndex <> -1) and (PC.BGPictureIndex <> -1)
  388.   then
  389.     begin
  390.       TabSheetBG := TBitMap(PC.FSD.FActivePictures.Items[PC.BGPictureIndex]);
  391.       if (Width > 0) and (Height > 0)
  392.       then
  393.         begin
  394.           XCnt := Width div TabSheetBG.Width;
  395.           YCnt := Height div TabSheetBG.Height;
  396.           for X := 0 to XCnt do
  397.           for Y := 0 to YCnt do
  398.           C.Draw(X * TabSheetBG.Width, Y * TabSheetBG.Height, TabSheetBG);
  399.         end;
  400.       C.Free;
  401.       Exit;
  402.     end;
  405.   w1 := Width;
  406.   h1 := Height;
  408.   if PC.FIndex <> -1
  409.   then
  410.     with PC do
  411.     begin
  412.       TabSheetBG := TBitMap.Create;
  413.       TabSheetBG.Width := RectWidth(ClRect);
  414.       TabSheetBG.Height := RectHeight(ClRect);
  415.       TabSheetBG.Canvas.CopyRect(Rect(0, 0, TabSheetBG.Width, TabSheetBG.Height),
  416.         PC.Picture.Canvas,
  417.           Rect(SkinRect.Left + ClRect.Left, SkinRect.Top + ClRect.Top,
  418.                SkinRect.Left + ClRect.Right,
  419.                SkinRect.Top + ClRect.Bottom));
  420.       w := RectWidth(ClRect);
  421.       h := RectHeight(ClRect);
  422.       XCnt := w1 div w;
  423.       YCnt := h1 div h;
  424.       for X := 0 to XCnt do
  425.       for Y := 0 to YCnt do
  426.         C.Draw(X * w, Y * h, TabSheetBG);
  427.       TabSheetBG.Free;
  428.     end
  429.   else
  430.   with C do
  431.   begin
  432.     Brush.Color := clbtnface;
  433.     FillRect(Rect(0, 0, w1, h1));
  434.   end;
  435.   C.Free;
  436. end;        
  439. {TTabSheetes}
  440. constructor TbsSkinTabSheet.Create(AOwner : TComponent);
  441. begin
  442.   inherited Create(AOwner);
  443. end;
  445. destructor TbsSkinTabSheet.Destroy;
  446. begin
  447.   inherited Destroy;
  448. end;
  450. procedure TbsSkinTabSheet.Notification(AComponent: TComponent; Operation: TOperation);
  451. begin
  452.   inherited Notification(AComponent, Operation);
  453. end;
  455. { TbsSkinPageControl }
  457. constructor TbsSkinPageControl.Create(AOwner: TComponent);
  458. begin
  459.   inherited Create(AOwner);
  460.   Ctl3D := False;
  461.   FIndex := -1;
  462.   Picture := nil;
  463.   Font.Name := 'Arial';
  464.   Font.Style := [];
  465.   Font.Color := clBtnText;
  466.   Font.Height := 14;
  467.   FSkinUpDown := nil;
  468.   FSkinDataName := 'tab';
  469.   FDefaultFont := TFont.Create;
  470.   FDefaultFont.Name := 'Arial';
  471.   FDefaultFont.Style := [];
  472.   FDefaultFont.Color := clBtnText;
  473.   FDefaultFont.Height := 14;
  474.   FDefaultItemHeight := 20;
  475.   FActiveTab := -1;
  476.   FOldActiveTab := -1;
  477.   FActiveTabIndex := -1;
  478.   FOldActiveTabIndex := -1;
  479.   FUseSkinFont := True;
  480. end;
  482. destructor TbsSkinPageControl.Destroy;
  483. begin
  484.   FDefaultFont.Free;
  485.   inherited Destroy;
  486. end;
  488. procedure TbsSkinPageControl.UpDateTabs;
  489. begin
  490.   if FIndex <> -1
  491.   then
  492.     begin
  493.       if TabHeight <= 0
  494.       then
  495.         SetItemSize(TabWidth, RectHeight(TabRect))
  496.       else
  497.         SetItemSize(TabWidth, TabHeight);
  498.     end
  499.   else
  500.     begin
  501.       if TabHeight <= 0
  502.       then
  503.         SetItemSize(TabWidth, FDefaultItemHeight)
  504.       else
  505.         SetItemSize(TabWidth, TabHeight);
  506.     end;
  507.   if MultiLine and (FSkinUpDown <> nil)
  508.   then
  509.     HideSkinUpDown;
  510.   ReAlign;
  511. end;
  513. procedure TbsSkinPageControl.CMMouseLeave;
  514. var
  515.   R: TRect;
  516. begin
  517.   if (FOldActiveTabIndex <> - 1) and (FOldActiveTabIndex <> TabIndex) and
  518.      (FOldActiveTabIndex < PageCount)
  519.   then
  520.     begin
  521.       R := GetItemRect(FOldActiveTabIndex);
  522.       DrawTab(FOldActiveTab, R, False, False, Canvas);
  523.       FOldActiveTabIndex := -1;
  524.       FOldActiveTab := -1;
  525.     end;
  527.   if (FActiveTabIndex <> - 1) and (FActiveTabIndex <> TabIndex) and
  528.      (FActiveTabIndex < PageCount)
  529.   then
  530.     begin
  531.       R := GetItemRect(FActiveTabIndex);
  532.       DrawTab(FActiveTab, R, False, False, Canvas);
  533.       FActiveTabIndex := -1;
  534.       FActiveTab := -1;
  535.     end;
  536. end;
  538. procedure TbsSkinPageControl.MouseDown;
  539. begin
  540.   inherited;
  541.   if (Button = mbLeft) and not (csDesigning in ComponentState)
  542.   then
  543.     TestActive(X, Y);
  544. end;
  546. procedure TbsSkinPageControl.MouseMove;
  547. begin
  548.  inherited;
  549.  if  not (csDesigning in ComponentState)
  550.  then
  551.    TestActive(X, Y);
  552. end;
  554. procedure TbsSkinPageControl.SetDefaultItemHeight;
  555. begin
  556.   FDefaultItemHeight := Value;
  557.   if FIndex = -1
  558.   then
  559.     begin
  560.       SetItemSize(TabWidth, FDefaultItemHeight);
  561.       Change;
  562.       ReAlign;
  563.     end;
  564. end;
  567. procedure TbsSkinPageControl.SetDefaultFont;
  568. begin
  569.   FDefaultFont.Assign(Value);
  570. end;
  572. procedure TbsSkinPageControl.OnUpDownChange(Sender: TObject);
  573. begin
  574.   FSkinUpDown.Max := GetInVisibleItemCount;
  575.   SendMessage(Handle, WM_HSCROLL,
  576.     MakeWParam(SB_THUMBPOSITION, FSkinUpDown.Position), 0);
  577. end;
  579. function TbsSkinPageControl.GetPosition: Integer;
  580. var
  581.   i, j: Integer;
  582.   R: TRect;
  583. begin
  584.   j := 0;
  585.   for i := 0 to PageCount - 1 do
  586.   begin
  587.     R := GetItemRect(i);
  588.     if R.Right <= 0 then inc(j);
  589.   end;
  590.   Result := j;
  591. end;
  593. function TbsSkinPageControl.GetInVisibleItemCount;
  594. var
  595.   i, j, k: Integer;
  596.   R: TRect;
  597.   Limit: Integer;
  598. begin
  599.   if FSkinUpDown = nil
  600.   then
  601.     Limit := Width - 3
  602.   else
  603.     Limit := Width - FSkinUpDown.Width - 3;
  604.   j := 0;
  605.   k := -1;
  606.   for i := 0 to PageCount - 1 do
  607.   if Pages[i].TabVisible
  608.   then
  609.   begin
  610.     inc(k);
  611.     R := GetItemRect(k);
  612.     if (R.Right > Limit) or (R.Right <= 0)
  613.     then inc(j);
  614.   end;
  615.   Result := j;
  616. end;
  618. procedure TbsSkinPageControl.CheckScroll;
  619. var
  620.   Wnd: HWND;
  621.   InVCount: Integer;
  622. begin
  623.   Wnd := FindWindowEx(Handle, 0, 'msctls_updown32', nil);
  624.   if Wnd <> 0 then DestroyWindow(Wnd);
  625.   InVCount := GetInVisibleItemCount;
  626.   if ((InVCount = 0) or MultiLine) and (FSkinUpDown <> nil)
  627.   then
  628.     HideSkinUpDown
  629.   else
  630.   if (InVCount > 0) and (FSkinUpDown = nil)
  631.   then
  632.     ShowSkinUpDown;
  633.   if FSkinUpDown <> nil
  634.   then
  635.     begin
  636.       FSkinUpDown.Max := InVCount;
  637.       FSkinUpDown.Left := Width - FSkinUpDown.Width;
  638.       if TabPosition = tpTop
  639.       then
  640.         FSkinUpDown.Top := 0
  641.       else
  642.        FSkinUpDown.Top := Height - FSkinUpDown.Height;
  643.     end;
  644. end;
  646. procedure TbsSkinPageControl.ShowSkinUpDown;
  647. begin
  648.   FSkinUpDown := TbsSkinUpDown.Create(Self);
  649.   FSkinUpDown.Parent := Self;
  650.   FSkinUpDown.Width := FDefaultItemHeight * 2;
  651.   FSkinUpDown.Height := FDefaultItemHeight;
  652.   FSkinUpDown.Min := 0;
  653.   FSkinUpDown.Max := GetInVisibleItemCount;
  654.   FSkinUpDown.Position := GetPosition;
  655.   FSkinUpDown.Increment := 1;
  656.   FSkinUpDown.OnChange := OnUpDownChange;
  657.   FSkinUpDown.Left := Width - FSkinUpDown.Width;
  658.   if TabPosition = tpTop
  659.   then
  660.     FSkinUpDown.Top := 0
  661.   else
  662.     FSkinUpDown.Top := Height - FSkinUpDown.Height;
  663.   FSkinUpDown.SkinDataName := UpDown;
  664.   FSkinUpDown.SkinData := SkinData;
  665.   FSkinUpDown.Visible := True;
  666. end;
  668. procedure TbsSkinPageControl.HideSkinUpDown;
  669. begin
  670.   FSkinUpDown.Free;
  671.   FSkinUpDown := nil;
  672. end;
  674. procedure TbsSkinPageControl.WMHSCROLL;
  675. begin
  676.   inherited;
  677.   RePaint;
  678. end;
  680. procedure TbsSkinPageControl.WMSize;
  681. begin
  682.   GetSkinData;
  683.   inherited;
  684. end;
  686. procedure TbsSkinPageControl.Change;
  687. begin
  688.   if FSkinUpDown <> nil
  689.   then FSkinUpDown.Position := GetPosition;
  690.   inherited;
  691.   Invalidate;
  692. end;
  694. procedure TbsSkinPageControl.GetSkinData;
  695. begin
  696.   BGPictureIndex := -1;
  697.   if FSD = nil
  698.   then
  699.     begin
  700.       FIndex := -1;
  701.       Exit;
  702.     end;
  703.   if FSD.Empty
  704.   then
  705.     FIndex := -1
  706.   else
  707.     FIndex := FSD.GetControlIndex(FSkinDataName);
  708.   //
  709.   if FIndex <> -1
  710.   then
  711.     if TbsDataSkinControl(FSD.CtrlList.Items[FIndex]) is TbsDataSkinTabControl
  712.     then
  713.       with TbsDataSkinTabControl(FSD.CtrlList.Items[FIndex]) do
  714.       begin
  715.         if (PictureIndex <> -1) and (PictureIndex < FSD.FActivePictures.Count)
  716.         then
  717.           Picture := TBitMap(FSD.FActivePictures.Items[PictureIndex])
  718.         else
  719.           Picture := nil;
  720.         Self.SkinRect := SkinRect;
  721.         Self.ClRect := ClRect;
  722.         Self.TabRect := TabRect;
  723.         if IsNullRect(ActiveTabRect)
  724.         then
  725.           Self.ActiveTabRect := TabRect
  726.         else
  727.           Self.ActiveTabRect := ActiveTabRect;
  728.         if IsNullRect(FocusTabRect)
  729.         then
  730.           Self.FocusTabRect := ActiveTabRect
  731.         else
  732.           Self.FocusTabRect := FocusTabRect;
  733.         //
  734.         Self.TabsBGRect := TabsBGRect;
  735.         Self.LTPoint := LTPoint;
  736.         Self.RTPoint := RTPoint;
  737.         Self.LBPoint := LBPoint;
  738.         Self.RBPoint := RBPoint;
  739.         Self.TabLeftOffset := TabLeftOffset;
  740.         Self.TabRightOffset := TabRightOffset;
  741.         //
  742.         Self.FontName := FontName;
  743.         Self.FontColor := FontColor;
  744.         Self.ActiveFontColor := ActiveFontColor;
  745.         Self.FocusFontColor := FocusFontColor;
  746.         Self.FontStyle := FontStyle;
  747.         Self.FontHeight := FontHeight;
  748.         Self.UpDown := UpDown;
  749.         Self.BGPictureIndex := BGPictureIndex;
  750.         Self.MouseInTabRect := MouseInTabRect;
  751.         Self.MouseInFontColor := MouseInFontColor;
  752.       end;
  753. end;
  755. procedure TbsSkinPageControl.ChangeSkinData;
  756. begin
  757.   GetSkinData;
  758.   //
  759.   if FIndex <> -1
  760.   then
  761.     begin
  762.       if FUseSkinFont
  763.       then
  764.         begin
  765.           Font.Name := FontName;
  766.           Font.Height := FontHeight;
  767.           Font.Style := FontStyle;
  768.         end
  769.       else
  770.         Font.Assign(FDefaultFont);
  772.       if (SkinData <> nil) and (SkinData.ResourceStrData <> nil)
  773.       then
  774.         Font.Charset := SkinData.ResourceStrData.CharSet
  775.        else
  776.         Font.CharSet := DefaultFont.CharSet;
  778.       Font.Color := FontColor;
  779.       if TabHeight <= 0
  780.       then
  781.         SetItemSize(TabWidth, RectHeight(TabRect))
  782.       else
  783.         SetItemSize(TabWidth, TabHeight);
  784.     end
  785.   else
  786.     begin
  787.       Font.Assign(FDefaultFont);
  788.       if (SkinData <> nil) and (SkinData.ResourceStrData <> nil)
  789.       then
  790.         Font.Charset := SkinData.ResourceStrData.CharSet;
  792.       if TabHeight <= 0
  793.       then
  794.         SetItemSize(TabWidth, FDefaultItemHeight)
  795.       else
  796.         SetItemSize(TabWidth, TabHeight);
  797.     end;
  798.   //
  799.   Change;
  800.   ReAlign;
  801.   if FSkinUpDown <> nil
  802.   then
  803.     begin
  804.       HideSkinUpDown;
  805.       CheckScroll;
  806.     end;
  807.   if ActivePage <> nil then ActivePage.RePaint;
  808. end;
  810. procedure TbsSkinPageControl.SetSkinData;
  811. begin
  812.   FSD := Value;
  813.   if (FSD <> nil) then
  814.   if not FSD.Empty and not (csDesigning in ComponentState)
  815.   then
  816.     ChangeSkinData;
  817. end;
  819. procedure TbsSkinPageControl.Notification;
  820. begin
  821.   inherited Notification(AComponent, Operation);
  822.   if (Operation = opRemove) and (AComponent = FSD) then FSD := nil;
  823. end;
  825. procedure TbsSkinPageControl.PaintDefaultWindow;
  826. var
  827.   R: TRect;
  828. begin
  829.   with Cnvs do
  830.   begin
  831.     Brush.Color := clBtnFace;
  832.     FillRect(ClientRect);
  833.     R := Self.DisplayRect;
  834.     InflateRect(R, 1, 1);
  835.     Frame3D(Cnvs, R, clBtnShadow, clBtnShadow, 1);
  836.   end;
  837. end;
  839. procedure TbsSkinPageControl.PaintSkinWindow;
  840. var
  841.   TOff, LOff, Roff, BOff: Integer;
  842.   DR, R: TRect;
  843.   TBGOffX, TBGOffY, X, Y, XCnt, YCnt, w, h, rw, rh, XO, YO: Integer;
  844.   NewLTPoint, NewRTPoint, NewLBPoint, NewRBPoint: TPoint;
  845. begin
  846.   TOff := ClRect.Top;
  847.   LOff := ClRect.Left;
  848.   ROff := RectWidth(SkinRect) - ClRect.Right;
  849.   BOff := RectHeight(SkinRect) - ClRect.Bottom;
  850.   DR := DisplayRect;
  851.   R := Rect(DR.Left - LOff, DR.Top - TOff, DR.Right + ROff, DR.Bottom + BOff);
  852.   XO := RectWidth(R) - RectWidth(SkinRect);
  853.   YO := RectHeight(R) - RectHeight(SkinRect);
  854.   NewLTPoint := LTPoint;
  855.   NewRTPoint := Point(RTPoint.X + XO, RTPoint.Y);
  856.   NewLBPoint := Point(LBPoint.X, LBPoint.Y + YO);
  857.   NewRBPoint := Point(RBPoint.X + XO, RBPoint.Y + YO);
  858.   // Draw tabs BG
  859.   if not IsNullRect(TabsBGRect)
  860.   then
  861.     begin
  862.       if TabPosition = tpLeft
  863.       then
  864.         begin
  865.           TBGOffY := 0;
  866.           TBGOffX := 0;
  867.           rw := R.Left;
  868.           rh := Height;
  869.         end
  870.       else
  871.       if TabPosition = tpRight
  872.       then
  873.         begin
  874.           TBGOffY := 0;
  875.           TBGOffX := R.Right;
  876.           rw := Width - R.Right;
  877.           rh := Height;
  878.         end
  879.       else
  880.       if TabPosition = tpTop
  881.       then
  882.         begin
  883.           TBGOffX := 0;
  884.           TBGOffY := 0;
  885.           rh := R.Top;
  886.           rw := Width;
  887.         end
  888.       else
  889.         begin
  890.           TBGOffX := 0;
  891.           TBGOffY := R.Bottom;
  892.           rh := Height - R.Bottom;
  893.           rw := Width;
  894.         end;
  895.       w := RectWidth(TabsBGRect);
  896.       h := RectHeight(TabsBGRect);
  897.       XCnt := rw div w;
  898.       YCnt := rh div h;
  899.       for X := 0 to XCnt do
  900.       for Y := 0 to YCnt do
  901.       begin
  902.         if X * w + w > rw then XO := X * w + w - rw else XO := 0;
  903.         if Y * h + h > rh then YO := Y * h + h - rh else YO := 0;
  904.         Cnvs.CopyRect(Rect(TBGOffX + X * w, TBGOffY + Y * h,
  905.                            TBGOffX + X * w + w - XO, TBGOffY + Y * h + h - YO),
  906.                       Picture.Canvas,
  907.                       Rect(TabsBGRect.Left, TabsBGRect.Top,
  908.                            TabsBGRect.Right - XO, TabsBGRect.Bottom - YO));
  909.       end;
  910.     end;  
  911.   // Draw frame around displayrect
  912.     // draw lines
  913.   w := RTPoint.X - LTPoint.X;
  914.   XCnt := (NewRTPoint.X - NewLTPoint.X) div w;
  915.   for X := 0 to XCnt do
  916.   begin
  917.     if NewLTPoint.X + X * w + w > NewRTPoint.X
  918.     then XO := NewLTPoint.X + X * w + w - NewRTPoint.X else XO := 0;
  919.     Cnvs.CopyRect(Rect(R.Left + NewLTPoint.X + X * w, R.Top,
  920.                   R.Left + NewLTPoint.X + X * w + w - XO, R.Top + TOff),
  921.              Picture.Canvas,
  922.              Rect(SkinRect.Left + LTPoint.X, SkinRect.Top,
  923.                   SkinRect.Left + RTPoint.X - XO, SkinRect.Top + TOff));
  924.   end;
  926.   w := RBPoint.X - LBPoint.X;
  927.   XCnt := (NewRBPoint.X - NewLBPoint.X) div w;
  928.   for X := 0 to XCnt do
  929.   begin
  930.     if NewLBPoint.X + X * w + w > NewRBPoint.X
  931.     then XO := NewLBPoint.X + X * w + w - NewRBPoint.X else XO := 0;
  932.     Cnvs.CopyRect(Rect(R.Left + NewLBPoint.X + X * w, R.Bottom - BOff,
  933.                   R.Left + NewLBPoint.X + X * w + w - XO, R.Bottom),
  934.              Picture.Canvas,
  935.              Rect(SkinRect.Left + LBPoint.X, SkinRect.Bottom - BOff,
  936.                   SkinRect.Left + RBPoint.X - XO, SkinRect.Bottom));
  937.   end;
  939.   w := LOff;
  940.   h := LBPoint.Y - LTPoint.Y;
  941.   YCnt := (NewLBPoint.Y - NewLTPoint.Y) div h;
  942.   for Y := 0 to YCnt do
  943.   begin
  944.     if NewLTPoint.Y + Y * h + h > NewLBPoint.Y
  945.     then YO := NewLTPoint.Y + Y * h + h - NewLBPoint.Y else YO := 0;
  946.     Cnvs.CopyRect(Rect(R.Left, R.Top + NewLTPoint.Y + Y * h,
  947.                        R.Left + w, R.Top + NewLTPoint.Y + Y * h + h - YO),
  948.                   Picture.Canvas,
  949.                   Rect(SkinRect.Left, SkinRect.Top + LTPoint.Y,
  950.                        SkinRect.Left + w, SkinRect.Top + LBPoint.Y - YO));
  951.   end;
  952.   w := ROff;
  953.   h := RBPoint.Y - RTPoint.Y;
  954.   YCnt := (NewRBPoint.Y - NewRTPoint.Y) div h;
  955.   for Y := 0 to YCnt do
  956.   begin
  957.     if NewRTPoint.Y + Y * h + h > NewRBPoint.Y
  958.     then YO := NewRTPoint.Y + Y * h + h - NewRBPoint.Y else YO := 0;
  959.     Cnvs.CopyRect(Rect(R.Right - w, R.Top + NewRTPoint.Y + Y * h,
  960.                        R.Right, R.Top + NewRTPoint.Y + Y * h + h - YO),
  961.                   Picture.Canvas,
  962.                   Rect(SkinRect.Right - w, SkinRect.Top + RTPoint.Y,
  963.                        SkinRect.Right, SkinRect.Top + RBPoint.Y - YO));
  964.   end;
  965.     // draw corners
  966.   Cnvs.CopyRect(Rect(R.Left, R.Top, R.Left + LTPoint.X, R.Top + LTPoint.Y),
  967.                 Picture.Canvas,
  968.                 Rect(SkinRect.Left, SkinRect.Top,
  969.                      SkinRect.Left + NewLTPoint.X, SkinRect.Top + NewLTPoint.Y));
  970.   Cnvs.CopyRect(Rect(R.Left + NewRTPoint.X, R.Top,
  971.                      R.Right, R.Top + NewRTPoint.Y),
  972.                 Picture.Canvas,
  973.                 Rect(SkinRect.Left + RTPoint.X, SkinRect.Top,
  974.                      SkinRect.Right, SkinRect.Top + RTPoint.Y));
  975.   Cnvs.CopyRect(Rect(R.Left, R.Top + NewLBPoint.Y,
  976.                      R.Left + NewLBPoint.X, R.Bottom),
  977.                 Picture.Canvas,
  978.                 Rect(SkinRect.Left, SkinRect.Top + LBPoint.Y,
  979.                      SkinRect.Left + LBPoint.X, SkinRect.Bottom));
  980.   Cnvs.CopyRect(Rect(R.Left + NewRBPoint.X, R.Top + NewRBPoint.Y,
  981.                      R.Right, R.Bottom),
  982.                 Picture.Canvas,
  983.                 Rect(SkinRect.Left + RBPoint.X, SkinRect.Top + RBPoint.Y,
  984.                      SkinRect.Right, SkinRect.Bottom));
  985. end;
  987. procedure TbsSkinPageControl.Loaded;
  988. begin
  989.   inherited Loaded;
  990.   if FIndex = -1
  991.   then
  992.     begin
  993.       if TabHeight <= 0
  994.       then
  995.         SetItemSize(TabWidth, FDefaultItemHeight)
  996.       else
  997.         SetItemSize(TabWidth, TabHeight);
  998.       Change;
  999.       ReAlign;
  1000.     end;
  1001. end;
  1003. procedure TbsSkinPageControl.WMEraseBkGnd(var Msg: TWMEraseBkGnd);
  1004. begin
  1005.   if Self.PageCount = 0
  1006.   then
  1007.     inherited
  1008.   else
  1009.     Msg.Result := 1;
  1010. end;
  1012. procedure TbsSkinPageControl.WndProc(var Message:TMessage);
  1013. var
  1014.   TOff, LOff, Roff, BOff: Integer;
  1015. begin
  1016.   if Message.Msg = TCM_ADJUSTRECT
  1017.   then
  1018.     begin
  1019.       inherited WndProc(Message);
  1020.       if FIndex <> -1
  1021.       then
  1022.         begin
  1023.           TOff := ClRect.Top;
  1024.           LOff := ClRect.Left;
  1025.           ROff := RectWidth(SkinRect) - ClRect.Right;
  1026.           BOff := RectHeight(SkinRect) - ClRect.Bottom;
  1027.         end;
  1028.       case TabPosition of
  1029.         tpLeft:
  1030.            if FIndex <> -1
  1031.            then
  1032.              begin
  1033.                PRect(Message.LParam)^.Left := PRect(Message.LParam)^.Left + LOff - 4;
  1034.                PRect(Message.LParam)^.Right := ClientWidth - ROff;
  1035.                PRect(Message.LParam)^.Top := PRect(Message.LParam)^.Top - 6 + TOff;
  1036.                PRect(Message.LParam)^.Bottom := ClientHeight - BOff;
  1037.              end
  1038.            else
  1039.              begin
  1040.                PRect(Message.LParam)^.Left := PRect(Message.LParam)^.Left - 3;
  1041.                PRect(Message.LParam)^.Right := ClientWidth - 1;
  1042.                PRect(Message.LParam)^.Top := PRect(Message.LParam)^.Top - 5;
  1043.                PRect(Message.LParam)^.Bottom := ClientHeight - 1;
  1044.              end;
  1045.         tpRight:
  1046.            if FIndex <> -1
  1047.            then
  1048.              begin
  1049.                PRect(Message.LParam)^.Left := LOff;
  1050.                PRect(Message.LParam)^.Right := PRect(Message.LParam)^.Right - ROff + 4;
  1051.                PRect(Message.LParam)^.Top := PRect(Message.LParam)^.Top - 6 + TOff;
  1052.                PRect(Message.LParam)^.Bottom := ClientHeight - BOff;
  1053.              end
  1054.            else
  1055.              begin
  1056.                PRect(Message.LParam)^.Left := PRect(Message.LParam)^.Left - 3;
  1057.                PRect(Message.LParam)^.Right := PRect(Message.LParam)^.Right + 3;
  1058.                PRect(Message.LParam)^.Top := PRect(Message.LParam)^.Top - 5;
  1059.                PRect(Message.LParam)^.Bottom := ClientHeight - 1;
  1060.              end;
  1061.         tpTop:
  1062.            if FIndex <> -1
  1063.            then
  1064.              begin
  1065.                PRect(Message.LParam)^.Left := LOff;
  1066.                PRect(Message.LParam)^.Right := ClientWidth - ROff;
  1067.                PRect(Message.LParam)^.Top := PRect(Message.LParam)^.Top - 6 + TOff;
  1068.                PRect(Message.LParam)^.Bottom := ClientHeight - BOff;
  1069.              end
  1070.            else
  1071.              begin
  1072.                PRect(Message.LParam)^.Left := 1;
  1073.                PRect(Message.LParam)^.Right := ClientWidth - 1;
  1074.                PRect(Message.LParam)^.Top := PRect(Message.LParam)^.Top - 5;
  1075.                PRect(Message.LParam)^.Bottom := ClientHeight - 1;
  1076.              end;
  1077.         tpBottom:
  1078.           if FIndex <> -1
  1079.           then
  1080.             begin
  1081.               PRect(Message.LParam)^.Left := LOff;
  1082.               PRect(Message.LParam)^.Right := ClientWidth - ROff;
  1083.               PRect(Message.LParam)^.Top := PRect(Message.LParam)^.Top - 6 + TOff;
  1084.               PRect(Message.LParam)^.Bottom := PRect(Message.LParam)^.Bottom + 4 - BOff;
  1085.             end
  1086.           else
  1087.             begin
  1088.               PRect(Message.LParam)^.Left := 1;
  1089.               PRect(Message.LParam)^.Right := ClientWidth - 1;
  1090.               PRect(Message.LParam)^.Top := 1;
  1091.               PRect(Message.LParam)^.Bottom := PRect(Message.LParam)^.Bottom + 3;
  1092.             end;
  1094.       end;
  1095.     end
  1096.   else
  1097.     if Message.Msg = TCM_GETITEMRECT
  1098.     then
  1099.       begin
  1100.         inherited WndProc(Message);
  1101.         if Style = tsTabs
  1102.         then
  1103.           case TabPosition of
  1104.             tpLeft:
  1105.                 begin
  1106.                   PRect(Message.LParam)^.Left := PRect(Message.LParam)^.Left - 2;
  1107.                   PRect(Message.LParam)^.Right := PRect(Message.LParam)^.Right - 2;
  1108.                 end;
  1109.             tpRight:
  1110.                 begin
  1111.                   PRect(Message.LParam)^.Left := PRect(Message.LParam)^.Left + 2;
  1112.                   PRect(Message.LParam)^.Right := PRect(Message.LParam)^.Right + 2;
  1113.                 end;
  1115.             tpTop:
  1116.                 begin
  1117.                   if not MultiLine
  1118.                   then
  1119.                     begin
  1120.                       PRect(Message.LParam)^.Left := PRect(Message.LParam)^.Left - 2;
  1121.                       PRect(Message.LParam)^.Right := PRect(Message.LParam)^.Right - 2;
  1122.                     end;
  1123.                   PRect(Message.LParam)^.Top := PRect(Message.LParam)^.Top - 2;
  1124.                   PRect(Message.LParam)^.Bottom := PRect(Message.LParam)^.Bottom - 2;
  1125.                 end;
  1126.             tpBottom:
  1127.                 begin
  1128.                   if not MultiLine
  1129.                   then
  1130.                     begin
  1131.                       PRect(Message.LParam)^.Left := PRect(Message.LParam)^.Left - 2;
  1132.                       PRect(Message.LParam)^.Right := PRect(Message.LParam)^.Right - 2;
  1133.                     end;
  1134.                   PRect(Message.LParam)^.Top := PRect(Message.LParam)^.Top + 2;
  1135.                   PRect(Message.LParam)^.Bottom := PRect(Message.LParam)^.Bottom + 2;
  1136.                 end;
  1137.           end;
  1138.       end
  1139.   else
  1140.   inherited WndProc(Message);
  1141.   if (Message.Msg = WM_SIZE) and (not MultiLine) and
  1142.      not (csDesigning in ComponentState)
  1143.   then
  1144.     begin
  1145.       CheckScroll;
  1146.     end;
  1147. end;
  1149. function TbsSkinPageControl.GetItemRect(index: integer): TRect;
  1150. var
  1151.   R: TRect;
  1152. begin
  1153.   SendMessage(Handle, TCM_GETITEMRECT, index, Integer(@R));
  1154.   Result := R;
  1155. end;
  1157. procedure TbsSkinPageControl.SetItemSize;
  1158. begin
  1159.   SendMessage(Handle, TCM_SETITEMSIZE, 0, MakeLParam(AWidth, AHeight));
  1160. end;
  1162. procedure TbsSkinPageControl.PaintWindow(DC: HDC);
  1163. var
  1164.   SaveIndex: Integer;
  1165.   B: TBitMap;
  1166. begin
  1167.   if (Width <= 0) or (Height <=0) then Exit;
  1168.   GetSkinData;
  1169.   SaveIndex := SaveDC(DC);
  1170.   try
  1171.     Canvas.Handle := DC;
  1172.     B := TBitMap.Create;
  1173.     B.Width := Width;
  1174.     B.Height := Height;
  1175.     if FIndex = -1
  1176.     then
  1177.       PaintDefaultWindow(B.Canvas)
  1178.     else
  1179.       PaintSkinWindow(B.Canvas);
  1180.     DrawTabs(B.Canvas);
  1181.     Canvas.Draw(0, 0, B);
  1182.     B.Free;
  1183.     Canvas.Handle := 0;
  1184.   finally
  1185.     RestoreDC(DC, SaveIndex);
  1186.   end;
  1187. end;
  1189. procedure TbsSkinPageControl.TestActive(X, Y: Integer);
  1190. var
  1191.   i, j, k: Integer;
  1192.   R: TRect;
  1193. begin
  1194.   FOldActiveTab := FActiveTab;
  1195.   FOldActiveTabIndex := FActiveTabIndex;
  1196.   k := -1;
  1197.   j := -1;
  1198.   for i := 0 to PageCount - 1 do
  1199.   if Pages[i].TabVisible then
  1200.   begin
  1201.     Inc(k);
  1202.     R := GetItemRect(k);
  1203.     if PtInRect(R, Point(X, Y))
  1204.     then
  1205.       begin
  1206.         j := k;
  1207.         Break;
  1208.       end;
  1209.   end;
  1211.   FActiveTab := i;
  1212.   FActiveTabIndex := j;
  1214.   if (FOldActiveTabIndex <> FActiveTabIndex)
  1215.   then
  1216.     begin
  1217.       if (FOldActiveTabIndex <> - 1) and (FOldActiveTabIndex <> TabIndex) and
  1218.          (FOldActiveTabIndex < PageCount)
  1219.       then
  1220.         begin
  1221.           R := GetItemRect(FOldActiveTabIndex);
  1222.           DrawTab(FOldActiveTab, R, False, False, Canvas);
  1223.         end;
  1224.       if (FActiveTabIndex <> -1) and (FActiveTabIndex <> TabIndex) and
  1225.          (FActiveTabIndex < PageCount)
  1226.       then
  1227.         begin
  1228.           R := GetItemRect(FActiveTabIndex);
  1229.           DrawTab(FActiveTab, R, False, True, Canvas );
  1230.         end;
  1231.     end;
  1232. end;
  1234. procedure TbsSkinPageControl.DrawTabs;
  1235. var
  1236.   i, j: integer;
  1237.   R: TRect;
  1238. begin
  1239.   j := -1;
  1240.   for i := 0 to PageCount-1 do
  1241.   if Pages[i].TabVisible then
  1242.   begin
  1243.     inc(j);
  1244.     R := GetItemRect(j);
  1245.     DrawTab(i, R, (j = TabIndex), j = FActiveTabIndex, Cnvs);
  1246.   end;
  1247. end;
  1249. procedure TbsSkinPageControl.DrawTab;
  1250. var
  1251.   R: TRect;
  1252.   S: String;
  1253.   TB, BufferTB: TBitMap;
  1254.   DrawGlyph: Boolean;
  1255.   W, H: Integer;
  1256. begin
  1257.   DrawGlyph := (Images <> nil) and (TI < Images.Count);
  1258.   S := Pages[TI].Caption;
  1259.   TB := TBitMap.Create;
  1260.   if (TabPosition = tpTop) or (TabPosition = tpBottom)
  1261.   then
  1262.     begin
  1263.       W := RectWidth(Rct);
  1264.       H := RectHeight(Rct);
  1265.     end
  1266.   else
  1267.     begin
  1268.       H := RectWidth(Rct);
  1269.       W := RectHeight(Rct);
  1270.     end;
  1271.   R := Rect(0, 0, W, H);  
  1272.   if FIndex <> -1
  1273.   then
  1274.     begin
  1275.       if TabHeight <= 0
  1276.       then
  1277.         begin
  1278.           if MouseIn and not Active and not IsNullRect(MouseInTabRect)
  1279.           then
  1280.             CreateHSkinImage(TabLeftOffset, TabRightOffset,
  1281.              TB, Picture, MouseInTabRect, W, H)
  1282.           else
  1283.             if Active and Focused
  1284.           then
  1285.            CreateHSkinImage(TabLeftOffset, TabRightOffset,
  1286.             TB, Picture, FocusTabRect, W, H)
  1287.           else
  1288.           if Active
  1289.           then
  1290.             CreateHSkinImage(TabLeftOffset, TabRightOffset,
  1291.               TB, Picture, ActiveTabRect, W, H)
  1292.           else
  1293.             CreateHSkinImage(TabLeftOffset, TabRightOffset,
  1294.              TB, Picture, TabRect, W, H);
  1295.        end
  1296.      else
  1297.        begin
  1298.          BufferTB := TBitMap.Create;
  1299.          BufferTB.Width := W;
  1300.          BufferTB.Height := RectHeight(TabRect);
  1301.          if MouseIn and not Active and not IsNullRect(MouseInTabRect)
  1302.           then
  1303.             CreateHSkinImage(TabLeftOffset, TabRightOffset,
  1304.              BufferTB, Picture, MouseInTabRect, W, H)
  1305.           else
  1306.             if Active and Focused
  1307.           then
  1308.            CreateHSkinImage(TabLeftOffset, TabRightOffset,
  1309.             BufferTB, Picture, FocusTabRect, W, H)
  1310.           else
  1311.           if Active
  1312.           then
  1313.             CreateHSkinImage(TabLeftOffset, TabRightOffset,
  1314.               BufferTB, Picture, ActiveTabRect, W, H)
  1315.           else
  1316.             CreateHSkinImage(TabLeftOffset, TabRightOffset,
  1317.              BufferTB, Picture, TabRect, W, H);
  1318.          TB.Width := W;
  1319.          TB.Height := H;
  1320.          TB.Canvas.StretchDraw(R, BufferTB);
  1321.          BufferTB.Free;
  1322.        end;
  1323.       if TabPosition = tpBottom then DrawFlipVert(TB);
  1324.       with TB.Canvas do
  1325.       begin
  1326.         Brush.Style := bsClear;
  1327.         if FUseSkinFont
  1328.         then
  1329.           begin
  1330.             Font.Name := FontName;
  1331.             Font.Style := FontStyle;
  1332.             Font.Height := FontHeight;
  1333.           end
  1334.         else
  1335.            Font.Assign(Self.Font);
  1336.         if (SkinData <> nil) and (SkinData.ResourceStrData <> nil)
  1337.         then
  1338.           Font.Charset := SkinData.ResourceStrData.CharSet
  1339.         else
  1340.           Font.CharSet := Self.Font.CharSet;
  1341.         if MouseIn and not Active
  1342.         then
  1343.           Font.Color := MouseInFontColor
  1344.         else
  1345.         if Active and Focused
  1346.         then
  1347.           Font.Color := FocusFontColor
  1348.         else
  1349.           if Active
  1350.           then Font.Color := ActiveFontColor
  1351.           else Font.Color := FontColor;
  1352.       end;
  1353.     end
  1354.   else
  1355.     begin
  1356.       TB.Width := W;
  1357.       TB.Height := H;
  1358.       if MouseIn and not Active
  1359.       then
  1360.         begin
  1361.           TB.Canvas.Brush.Color := BS_XP_BTNACTIVECOLOR;
  1362.           TB.Canvas.FillRect(R);
  1363.         end
  1364.       else
  1365.       if Active and Focused
  1366.       then
  1367.         begin
  1368.           Frame3D(TB.Canvas, R, BS_XP_BTNFRAMECOLOR, BS_XP_BTNFRAMECOLOR, 1);
  1369.           TB.Canvas.Brush.Color := BS_XP_BTNDOWNCOLOR;
  1370.           TB.Canvas.FillRect(R);
  1371.         end
  1372.       else
  1373.       if Active
  1374.       then
  1375.         begin
  1376.           Frame3D(TB.Canvas, R, BS_XP_BTNFRAMECOLOR, BS_XP_BTNFRAMECOLOR, 1);
  1377.           TB.Canvas.Brush.Color := BS_XP_BTNACTIVECOLOR;
  1378.           TB.Canvas.FillRect(R);
  1379.         end
  1380.       else
  1381.         begin
  1382.           TB.Canvas.Brush.Color := clBtnFace;
  1383.           TB.Canvas.FillRect(R);
  1384.         end;
  1385.       with TB.Canvas do
  1386.       begin
  1387.         Brush.Style := bsClear;
  1388.         Font.Assign(Self.Font);
  1389.         if (SkinData <> nil) and (SkinData.ResourceStrData <> nil)
  1390.         then
  1391.           Font.Charset := SkinData.ResourceStrData.CharSet;
  1392.       end;
  1393.     end;
  1394.   //
  1395.   if DrawGlyph
  1396.   then
  1397.     DrawTabGlyphAndText(TB.Canvas, TB.Width, TB.Height, S,
  1398.                         Images, Pages[TI].ImageIndex, Pages[TI].Enabled)
  1399.   else
  1400.     DrawText(TB.Canvas.Handle, PChar(S), Length(S), R, DT_CENTER or DT_SINGLELINE or DT_VCENTER);
  1401.   if TabPosition = tpLeft
  1402.   then
  1403.     DrawRotate90_1(Cnvs, TB, Rct.Left, Rct.Top)
  1404.   else
  1405.   if TabPosition = tpRight
  1406.   then
  1407.     DrawRotate90_2(Cnvs, TB, Rct.Left, Rct.Top)
  1408.   else
  1409.     Cnvs.Draw(Rct.Left, Rct.Top, TB);
  1410.   TB.Free;
  1411. end;
  1414. { TbsSkinTabControl }
  1416. constructor TbsSkinTabControl.Create(AOwner: TComponent);
  1417. begin
  1418.   inherited Create(AOwner);
  1419.   Ctl3D := False;
  1420.   FIndex := -1;
  1421.   Picture := nil;
  1422.   Font.Name := 'Arial';
  1423.   Font.Style := [];
  1424.   Font.Color := clBtnText;
  1425.   Font.Height := 14;
  1426.   FOldTop := 0;
  1427.   FOldBottom := 0;
  1428.   FSkinUpDown := nil;
  1429.   FSkinDataName := 'tab';
  1430.   FDefaultFont := TFont.Create;
  1431.   FDefaultFont.Name := 'Arial';
  1432.   FDefaultFont.Style := [];
  1433.   FDefaultFont.Color := clBtnText;
  1434.   FDefaultFont.Height := 14;
  1435.   FDefaultItemHeight := 20;
  1436.   FUseSkinFont := True;
  1437. end;
  1439. procedure TbsSkinTabControl.MouseMove;
  1440. begin
  1441.  inherited;
  1442.  if not (csDesigning in ComponentState)
  1443.  then
  1444.    TestActive(X, Y);
  1445. end;
  1447. procedure TbsSkinTabControl.MouseDown;
  1448. begin
  1449.   inherited;
  1450.   if (Button = mbLeft) and not (csDesigning in ComponentState)
  1451.   then
  1452.     TestActive(X, Y);
  1453. end;
  1455. procedure TbsSkinTabControl.CMMouseLeave;
  1456. var
  1457.   R: TRect;
  1458. begin
  1459.   if (FOldActiveTab <> - 1) and (FOldActiveTab <> TabIndex) and
  1460.      (FOldActiveTab < Self.Tabs.Count)
  1461.   then
  1462.     begin
  1463.       R := GetItemRect(FOldActiveTab);
  1464.       DrawTab(FOldActiveTab, R, False, False, Canvas);
  1465.       FOldActiveTab := -1;
  1466.     end;
  1468.   if (FActiveTab <> - 1) and (FActiveTab <> TabIndex) and
  1469.      (FActiveTab < Self.Tabs.Count)
  1470.   then
  1471.     begin
  1472.       R := GetItemRect(FActiveTab);
  1473.       DrawTab(FActiveTab, R, False, False, Canvas);
  1474.       FActiveTab := -1;
  1475.     end;
  1476. end;
  1478. procedure TbsSkinTabControl.TestActive(X, Y: Integer);
  1479. var
  1480.   i, j: Integer;
  1481.   R: TRect;
  1482. begin
  1483.   FOldActiveTab := FActiveTab;
  1484.   j := -1;
  1485.   for i := 0 to Tabs.Count-1 do
  1486.   begin
  1487.     R := GetItemRect(i);
  1488.     if PtInRect(R, Point(X, Y))
  1489.     then
  1490.       begin
  1491.         j := i;
  1492.         Break;
  1493.       end;
  1494.   end;
  1496.   FActiveTab := j;
  1498.   if (FOldActiveTab <> FActiveTab)
  1499.   then
  1500.     begin
  1501.       if (FOldActiveTab <> - 1) and (FOldActiveTab <> TabIndex) and
  1502.          (FOldActiveTab < Self.Tabs.Count)
  1503.       then
  1504.         begin
  1505.           R := GetItemRect(FOldActiveTab);
  1506.           DrawTab(FOldActiveTab, R, False, False, Canvas);
  1507.         end;
  1508.       if (FActiveTab <> -1) and (FActiveTab <> TabIndex) and
  1509.          (FActiveTab < Self.Tabs.Count)
  1510.       then
  1511.         begin
  1512.           R := GetItemRect(FActiveTab);
  1513.           DrawTab(FActiveTab, R, False, True, Canvas );
  1514.         end;
  1515.     end;
  1516. end;
  1518. procedure TbsSkinTabControl.SetDefaultItemHeight;
  1519. begin
  1520.   FDefaultItemHeight := Value;
  1521.   if FIndex = -1
  1522.   then
  1523.     begin
  1524.       SetitemSize(TabWidth, FDefaultItemHeight);
  1525.       Change;
  1526.       ReAlign;
  1527.     end;
  1528. end;
  1531. procedure TbsSkinTabControl.SetDefaultFont;
  1532. begin
  1533.   FDefaultFont.Assign(Value);
  1534. end;
  1536. procedure TbsSkinTabControl.OnUpDownChange(Sender: TObject);
  1537. begin
  1538.   FSkinUpDown.Max := GetInVisibleItemCount;
  1539.   SendMessage(Handle, WM_HSCROLL,
  1540.     MakeWParam(SB_THUMBPOSITION, FSkinUpDown.Position), 0);
  1541. end;
  1543. function TbsSkinTabControl.GetPosition: Integer;
  1544. var
  1545.   i, j: Integer;
  1546.   R: TRect;
  1547. begin
  1548.   j := 0;
  1549.   for i := 0 to Tabs.Count - 1 do
  1550.   begin
  1551.     R := GetItemRect(i);
  1552.     if R.Right <= 0 then inc(j);
  1553.   end;
  1554.   Result := j;
  1555. end;
  1557. function TbsSkinTabControl.GetInVisibleItemCount;
  1558. var
  1559.   i, j: Integer;
  1560.   R: TRect;
  1561.   Limit: Integer;
  1562. begin
  1563.   if FSkinUpDown = nil
  1564.   then
  1565.     Limit := Width - 3
  1566.   else
  1567.     Limit := Width - FSkinUpDown.Width - 3;
  1568.   j := 0;
  1569.   for i := 0 to Tabs.Count - 1 do
  1570.   begin
  1571.     R := GetItemRect(i);
  1572.     if (R.Right > Limit) or (R.Right <= 0)
  1573.     then inc(j);
  1574.   end;
  1575.   Result := j;
  1576. end;
  1578. procedure TbsSkinTabControl.CheckScroll;
  1579. var
  1580.   Wnd: HWND;
  1581.   InVCount: Integer;
  1582. begin
  1583.   Wnd := FindWindowEx(Handle, 0, 'msctls_updown32', nil);
  1584.   if Wnd <> 0 then DestroyWindow(Wnd);
  1585.   InVCount := GetInVisibleItemCount;
  1586.   if (InVCount = 0) and (FSkinUpDown <> nil)
  1587.   then
  1588.     HideSkinUpDown
  1589.   else
  1590.   if (InVCount > 0) and (FSkinUpDown = nil)
  1591.   then
  1592.     ShowSkinUpDown;
  1593.   if FSkinUpDown <> nil
  1594.   then
  1595.     begin
  1596.       FSkinUpDown.Max := InVCount;
  1597.       FSkinUpDown.Left := Width - FSkinUpDown.Width;
  1598.       if TabPosition = tpTop
  1599.       then
  1600.         FSkinUpDown.Top := 0
  1601.       else
  1602.        FSkinUpDown.Top := Height - FSkinUpDown.Height;
  1603.     end;
  1604. end;
  1606. procedure TbsSkinTabControl.ShowSkinUpDown;
  1607. begin
  1608.   FSkinUpDown := TbsSkinUpDown.Create(Self);
  1609.   FSkinUpDown.Parent := Self;
  1610.   FSkinUpDown.Width := 36;
  1611.   FSkinUpDown.Height := 18;
  1612.   FSkinUpDown.Min := 0;
  1613.   FSkinUpDown.Max := GetInVisibleItemCount;
  1614.   FSkinUpDown.Position := GetPosition;
  1615.   FSkinUpDown.Increment := 1;
  1616.   FSkinUpDown.OnChange := OnUpDownChange;
  1617.   FSkinUpDown.Left := Width - FSkinUpDown.Width;
  1618.   if TabPosition = tpTop
  1619.   then
  1620.     FSkinUpDown.Top := 0
  1621.   else
  1622.     FSkinUpDown.Top := Height - FSkinUpDown.Height;
  1623.   FSkinUpDown.SkinDataName := UpDown;
  1624.   FSkinUpDown.SkinData := SkinData;
  1625.   FSkinUpDown.Visible := True;
  1626. end;
  1628. procedure TbsSkinTabControl.HideSkinUpDown;
  1629. begin
  1630.   FSkinUpDown.Free;
  1631.   FSkinUpDown := nil;
  1632. end;
  1634. procedure TbsSkinTabControl.WMPaint;
  1635. begin
  1636.   if ControlCount = 0
  1637.   then
  1638.     PaintHandler(Msg)
  1639.   else
  1640.     inherited;
  1641. end;
  1643. procedure TbsSkinTabControl.WMHSCROLL;
  1644. begin
  1645.   inherited;
  1646.   RePaint;
  1647. end;
  1649. procedure TbsSkinTabControl.WMSize;
  1650. begin
  1651.   inherited;
  1652. end;
  1654. destructor TbsSkinTabControl.Destroy;
  1655. begin
  1656.   FDefaultFont.Free;
  1657.   inherited Destroy;
  1658. end;
  1660. procedure TbsSkinTabControl.Change;
  1661. begin
  1662.   if FSkinUpDown <> nil
  1663.   then FSkinUpDown.Position := GetPosition;
  1664.   inherited;
  1665.   Invalidate;
  1666. end;
  1668. procedure TbsSkinTabControl.GetSkinData;
  1669. begin
  1670.   BGPictureIndex := -1;
  1671.   if FSD = nil
  1672.   then
  1673.     begin
  1674.       FIndex := -1;
  1675.       Exit;
  1676.     end;
  1677.   if FSD.Empty
  1678.   then
  1679.     FIndex := -1
  1680.   else
  1681.     FIndex := FSD.GetControlIndex(FSkinDataName);
  1682.   //
  1683.   if FIndex <> -1
  1684.   then
  1685.     if TbsDataSkinControl(FSD.CtrlList.Items[FIndex]) is TbsDataSkinTabControl
  1686.     then
  1687.       with TbsDataSkinTabControl(FSD.CtrlList.Items[FIndex]) do
  1688.       begin
  1689.         if (PictureIndex <> -1) and (PictureIndex < FSD.FActivePictures.Count)
  1690.         then
  1691.           Picture := TBitMap(FSD.FActivePictures.Items[PictureIndex])
  1692.         else
  1693.           Picture := nil;
  1694.         Self.SkinRect := SkinRect;
  1695.         Self.ClRect := ClRect;
  1696.         Self.TabRect := TabRect;
  1697.         if IsNullRect(ActiveTabRect)
  1698.         then
  1699.           Self.ActiveTabRect := TabRect
  1700.         else
  1701.           Self.ActiveTabRect := ActiveTabRect;
  1702.         if IsNullRect(FocusTabRect)
  1703.         then
  1704.           Self.FocusTabRect := ActiveTabRect
  1705.         else
  1706.           Self.FocusTabRect := FocusTabRect;
  1707.         //
  1708.         Self.TabsBGRect := TabsBGRect; 
  1709.         Self.LTPoint := LTPoint;
  1710.         Self.RTPoint := RTPoint;
  1711.         Self.LBPoint := LBPoint;
  1712.         Self.RBPoint := RBPoint;
  1713.         Self.TabLeftOffset := TabLeftOffset;
  1714.         Self.TabRightOffset := TabRightOffset;
  1715.         //
  1716.         Self.FontName := FontName;
  1717.         Self.FontColor := FontColor;
  1718.         Self.ActiveFontColor := ActiveFontColor;
  1719.         Self.FocusFontColor := FocusFontColor;
  1720.         Self.FontStyle := FontStyle;
  1721.         Self.FontHeight := FontHeight;
  1722.         Self.UpDown := UpDown;
  1723.         Self.BGPictureIndex := BGPictureIndex;
  1724.         Self.MouseInFontColor := MouseInFontColor;
  1725.         Self.MouseInTabRect := MouseInTabRect;
  1726.       end;
  1727. end;
  1729. procedure TbsSkinTabControl.ChangeSkinData;
  1730. begin
  1731.   GetSkinData;
  1732.   //
  1733.   if FIndex <> -1
  1734.   then
  1735.     begin
  1736.       Font.Color := FontColor;
  1737.       if FUseSkinFont
  1738.       then
  1739.         begin
  1740.           Font.Name := FontName;
  1741.           Font.Height := FontHeight;
  1742.           Font.Style := FontStyle;
  1743.         end
  1744.       else
  1745.         Font.Assign(FDefaultFont);
  1747.       if (SkinData <> nil) and (SkinData.ResourceStrData <> nil)
  1748.       then
  1749.         Font.Charset := SkinData.ResourceStrData.CharSet
  1750.       else
  1751.         Font.CharSet := DefaultFont.CharSet;
  1753.       if TabHeight <= 0
  1754.       then
  1755.         SetItemSize(TabWidth, RectHeight(TabRect))
  1756.       else
  1757.         SetItemSize(TabWidth, TabHeight);
  1758.     end
  1759.   else
  1760.     begin
  1761.       Font.Assign(FDefaultFont);
  1762.       if (SkinData <> nil) and (SkinData.ResourceStrData <> nil)
  1763.       then
  1764.         Font.Charset := SkinData.ResourceStrData.CharSet;
  1765.       if TabHeight <= 0
  1766.       then
  1767.         SetItemSize(TabWidth, FDefaultItemHeight)
  1768.       else
  1769.         SetItemSize(TabWidth, TabHeight);
  1770.     end;
  1771.   //
  1772.   Change;
  1773.   ReAlign;
  1774.   RePaint;
  1775.   if FSkinUpDown <> nil
  1776.   then
  1777.     begin
  1778.       HideSkinUpDown;
  1779.       CheckScroll;
  1780.     end;
  1781. end;
  1783. procedure TbsSkinTabControl.SetSkinData;
  1784. begin
  1785.   FSD := Value;
  1786.   if (FSD <> nil) then
  1787.   if not FSD.Empty and not (csDesigning in ComponentState)
  1788.   then
  1789.     ChangeSkinData;
  1790. end;
  1792. procedure TbsSkinTabControl.Notification;
  1793. begin
  1794.   inherited Notification(AComponent, Operation);
  1795.   if (Operation = opRemove) and (AComponent = FSD) then FSD := nil;
  1796. end;
  1798. procedure TbsSkinTabControl.PaintDefaultWindow;
  1799. var
  1800.   R: TRect;
  1801. begin
  1802.   with Cnvs do
  1803.   begin
  1804.     Brush.Color := clBtnFace;
  1805.     FillRect(ClientRect);
  1806.     R := Self.DisplayRect;
  1807.     InflateRect(R, 1, 1);
  1808.     Frame3D(Cnvs, R, clBtnShadow, clBtnShadow, 1);
  1809.   end;
  1810. end;
  1812. procedure TbsSkinTabControl.PaintSkinWindow;
  1813. var
  1814.   TOff, LOff, Roff, BOff: Integer;
  1815.   DR, R: TRect;
  1816.   TBGOffX, TBGOffY, X, Y, XCnt, YCnt, w, h, w1, h1, rw, rh, XO, YO: Integer;
  1817.   NewLTPoint, NewRTPoint, NewLBPoint, NewRBPoint: TPoint;
  1818.   B: TBitMap;
  1819. begin
  1820.   TOff := ClRect.Top;
  1821.   LOff := ClRect.Left;
  1822.   ROff := RectWidth(SkinRect) - ClRect.Right;
  1823.   BOff := RectHeight(SkinRect) - ClRect.Bottom;
  1824.   DR := DisplayRect;
  1825.   R := Rect(DR.Left - LOff, DR.Top - TOff, DR.Right + ROff, DR.Bottom + BOff);
  1826.   XO := RectWidth(R) - RectWidth(SkinRect);
  1827.   YO := RectHeight(R) - RectHeight(SkinRect);
  1828.   NewLTPoint := LTPoint;
  1829.   NewRTPoint := Point(RTPoint.X + XO, RTPoint.Y);
  1830.   NewLBPoint := Point(LBPoint.X, LBPoint.Y + YO);
  1831.   NewRBPoint := Point(RBPoint.X + XO, RBPoint.Y + YO);
  1832.   // DrawBG
  1834.   if BGPictureIndex <> -1
  1835.   then
  1836.     begin
  1837.       B := TBitMap(FSD.FActivePictures.Items[BGPictureIndex]);
  1838.       if (Width > 0) and (Height > 0)
  1839.       then
  1840.         begin
  1841.           XCnt := Width div B.Width;
  1842.           YCnt := Height div B.Height;
  1843.           for X := 0 to XCnt do
  1844.           for Y := 0 to YCnt do
  1845.           Cnvs.Draw(X * B.Width, Y * B.Height, B);
  1846.         end;
  1847.       Exit;
  1848.     end;
  1850.   w := RectWidth(ClRect);
  1851.   h := RectHeight(ClRect);
  1852.   w1 := RectWidth(R);
  1853.   h1 := RectHeight(R);
  1854.   XCnt := w1 div w;
  1855.   YCnt := h1 div h;
  1856.   for X := 0 to XCnt do
  1857.   for Y := 0 to YCnt do
  1858.   begin
  1859.     if X * w + w > w1 then XO := X * w + w - w1 else XO := 0;
  1860.     if Y * h + h > h1 then YO := Y * h + h - h1 else YO := 0;
  1861.      Cnvs.CopyRect(Rect(R.Left + X * w, R.Top + Y * h,
  1862.                         R.Left + X * w + w - XO, R.Top + Y * h + h - YO),
  1863.               Picture.Canvas,
  1864.               Rect(SkinRect.Left + ClRect.Left, SkinRect.Top + ClRect.Top,
  1865.                    SkinRect.Left + ClRect.Right - XO,
  1866.                    SkinRect.Top + ClRect.Bottom - YO));
  1867.   end;            
  1868.   // Draw tabs BG
  1869.   if not IsNullRect(TabsBGRect)
  1870.   then
  1871.     begin
  1872.       if TabPosition = tpLeft
  1873.       then
  1874.         begin
  1875.           TBGOffY := 0;
  1876.           TBGOffX := 0;
  1877.           rw := R.Left;
  1878.           rh := Height;
  1879.         end
  1880.       else
  1881.       if TabPosition = tpRight
  1882.       then
  1883.         begin
  1884.           TBGOffY := 0;
  1885.           TBGOffX := R.Right;
  1886.           rw := Width - R.Right;
  1887.           rh := Height;
  1888.         end
  1889.       else
  1890.       if TabPosition = tpTop
  1891.       then
  1892.         begin
  1893.           TBGOffX := 0;
  1894.           TBGOffY := 0;
  1895.           rh := R.Top;
  1896.           rw := Width;
  1897.         end
  1898.       else
  1899.         begin
  1900.           TBGOffX := 0;
  1901.           TBGOffY := R.Bottom;
  1902.           rh := Height - R.Bottom;
  1903.           rw := Width;
  1904.         end;
  1905.       w := RectWidth(TabsBGRect);
  1906.       h := RectHeight(TabsBGRect);
  1907.       XCnt := rw div w;
  1908.       YCnt := rh div h;
  1909.       for X := 0 to XCnt do
  1910.       for Y := 0 to YCnt do
  1911.       begin
  1912.         if X * w + w > rw then XO := X * w + w - rw else XO := 0;
  1913.         if Y * h + h > rh then YO := Y * h + h - rh else YO := 0;
  1914.         Cnvs.CopyRect(Rect(TBGOffX + X * w, TBGOffY + Y * h,
  1915.                            TBGOffX + X * w + w - XO, TBGOffY + Y * h + h - YO),
  1916.                       Picture.Canvas,
  1917.                       Rect(TabsBGRect.Left, TabsBGRect.Top,
  1918.                            TabsBGRect.Right - XO, TabsBGRect.Bottom - YO));
  1919.       end;
  1920.     end;
  1921.   // Draw frame around displayrect
  1922.     // draw lines
  1923.   w := RTPoint.X - LTPoint.X;
  1924.   XCnt := (NewRTPoint.X - NewLTPoint.X) div w;
  1925.   for X := 0 to XCnt do
  1926.   begin
  1927.     if NewLTPoint.X + X * w + w > NewRTPoint.X
  1928.     then XO := NewLTPoint.X + X * w + w - NewRTPoint.X else XO := 0;
  1929.     Cnvs.CopyRect(Rect(R.Left + NewLTPoint.X + X * w, R.Top,
  1930.                   R.Left + NewLTPoint.X + X * w + w - XO, R.Top + TOff),
  1931.              Picture.Canvas,
  1932.              Rect(SkinRect.Left + LTPoint.X, SkinRect.Top,
  1933.                   SkinRect.Left + RTPoint.X - XO, SkinRect.Top + TOff));
  1934.   end;
  1936.   w := RBPoint.X - LBPoint.X;
  1937.   XCnt := (NewRBPoint.X - NewLBPoint.X) div w;
  1938.   for X := 0 to XCnt do
  1939.   begin
  1940.     if NewLBPoint.X + X * w + w > NewRBPoint.X
  1941.     then XO := NewLBPoint.X + X * w + w - NewRBPoint.X else XO := 0;
  1942.     Cnvs.CopyRect(Rect(R.Left + NewLBPoint.X + X * w, R.Bottom - BOff,
  1943.                   R.Left + NewLBPoint.X + X * w + w - XO, R.Bottom),
  1944.              Picture.Canvas,
  1945.              Rect(SkinRect.Left + LBPoint.X, SkinRect.Bottom - BOff,
  1946.                   SkinRect.Left + RBPoint.X - XO, SkinRect.Bottom));
  1947.   end;
  1949.   w := LOff;
  1950.   h := LBPoint.Y - LTPoint.Y;
  1951.   YCnt := (NewLBPoint.Y - NewLTPoint.Y) div h;
  1952.   for Y := 0 to YCnt do
  1953.   begin
  1954.     if NewLTPoint.Y + Y * h + h > NewLBPoint.Y
  1955.     then YO := NewLTPoint.Y + Y * h + h - NewLBPoint.Y else YO := 0;
  1956.     Cnvs.CopyRect(Rect(R.Left, R.Top + NewLTPoint.Y + Y * h,
  1957.                        R.Left + w, R.Top + NewLTPoint.Y + Y * h + h - YO),
  1958.                   Picture.Canvas,
  1959.                   Rect(SkinRect.Left, SkinRect.Top + LTPoint.Y,
  1960.                        SkinRect.Left + w, SkinRect.Top + LBPoint.Y - YO));
  1961.   end;
  1962.   w := ROff;
  1963.   h := RBPoint.Y - RTPoint.Y;
  1964.   YCnt := (NewRBPoint.Y - NewRTPoint.Y) div h;
  1965.   for Y := 0 to YCnt do
  1966.   begin
  1967.     if NewRTPoint.Y + Y * h + h > NewRBPoint.Y
  1968.     then YO := NewRTPoint.Y + Y * h + h - NewRBPoint.Y else YO := 0;
  1969.     Cnvs.CopyRect(Rect(R.Right - w, R.Top + NewRTPoint.Y + Y * h,
  1970.                        R.Right, R.Top + NewRTPoint.Y + Y * h + h - YO),
  1971.                   Picture.Canvas,
  1972.                   Rect(SkinRect.Right - w, SkinRect.Top + RTPoint.Y,
  1973.                        SkinRect.Right, SkinRect.Top + RBPoint.Y - YO));
  1974.   end;
  1975.     // draw corners
  1976.   Cnvs.CopyRect(Rect(R.Left, R.Top, R.Left + LTPoint.X, R.Top + LTPoint.Y),
  1977.                 Picture.Canvas,
  1978.                 Rect(SkinRect.Left, SkinRect.Top,
  1979.                      SkinRect.Left + NewLTPoint.X, SkinRect.Top + NewLTPoint.Y));
  1980.   Cnvs.CopyRect(Rect(R.Left + NewRTPoint.X, R.Top,
  1981.                      R.Right, R.Top + NewRTPoint.Y),
  1982.                 Picture.Canvas,
  1983.                 Rect(SkinRect.Left + RTPoint.X, SkinRect.Top,
  1984.                      SkinRect.Right, SkinRect.Top + RTPoint.Y));
  1985.   Cnvs.CopyRect(Rect(R.Left, R.Top + NewLBPoint.Y,
  1986.                      R.Left + NewLBPoint.X, R.Bottom),
  1987.                 Picture.Canvas,
  1988.                 Rect(SkinRect.Left, SkinRect.Top + LBPoint.Y,
  1989.                      SkinRect.Left + LBPoint.X, SkinRect.Bottom));
  1990.   Cnvs.CopyRect(Rect(R.Left + NewRBPoint.X, R.Top + NewRBPoint.Y,
  1991.                      R.Right, R.Bottom),
  1992.                 Picture.Canvas,
  1993.                 Rect(SkinRect.Left + RBPoint.X, SkinRect.Top + RBPoint.Y,
  1994.                      SkinRect.Right, SkinRect.Bottom));
  1995. end;
  1997. procedure TbsSkinTabControl.Loaded;
  1998. begin
  1999.   inherited Loaded;
  2000.   if FIndex = -1
  2001.   then
  2002.     begin
  2003.       if TabHeight <= 0
  2004.       then
  2005.         SetItemSize(TabWidth, FDefaultItemHeight)
  2006.       else
  2007.         SetItemSize(TabWidth, TabHeight);
  2008.       Change;
  2009.       ReAlign;
  2010.     end;
  2011. end;
  2013. procedure TbsSkinTabControl.WMEraseBkGnd(var Msg: TWMEraseBkGnd);
  2014. begin
  2015.   Msg.Result := 1;
  2016. end;
  2018. procedure TbsSkinTabControl.WndProc(var Message:TMessage);
  2019. var
  2020.   TOff, LOff, Roff, BOff: Integer;
  2021. begin
  2022.   if Message.Msg = TCM_ADJUSTRECT
  2023.   then
  2024.     begin
  2025.       inherited WndProc(Message);
  2026.       TOff := 0;
  2027.       LOff := 0;
  2028.       ROff := 0;
  2029.       BOff := 0;
  2030.       if (FIndex <> -1) and (BGPictureIndex = -1)
  2031.       then
  2032.         begin
  2033.           TOff := ClRect.Top;
  2034.           LOff := ClRect.Left;
  2035.           ROff := RectWidth(SkinRect) - ClRect.Right;
  2036.           BOff := RectHeight(SkinRect) - ClRect.Bottom;
  2037.         end;
  2038.       case TabPosition of
  2039.         tpLeft:
  2040.            if FIndex <> -1
  2041.            then
  2042.              begin
  2043.                PRect(Message.LParam)^.Left := PRect(Message.LParam)^.Left + LOff - 4;
  2044.                PRect(Message.LParam)^.Right := ClientWidth - ROff;
  2045.                PRect(Message.LParam)^.Top := PRect(Message.LParam)^.Top - 6 + TOff;
  2046.                PRect(Message.LParam)^.Bottom := ClientHeight - BOff;
  2047.              end
  2048.            else
  2049.              begin
  2050.                PRect(Message.LParam)^.Left := PRect(Message.LParam)^.Left - 3;
  2051.                PRect(Message.LParam)^.Right := ClientWidth - 1;
  2052.                PRect(Message.LParam)^.Top := PRect(Message.LParam)^.Top - 5;
  2053.                PRect(Message.LParam)^.Bottom := ClientHeight - 1;
  2054.              end;
  2055.         tpRight:
  2056.            if FIndex <> -1
  2057.            then
  2058.              begin
  2059.                PRect(Message.LParam)^.Left := LOff;
  2060.                PRect(Message.LParam)^.Right := PRect(Message.LParam)^.Right - ROff + 4;
  2061.                PRect(Message.LParam)^.Top := PRect(Message.LParam)^.Top - 6 + TOff;
  2062.                PRect(Message.LParam)^.Bottom := ClientHeight - BOff;
  2063.              end
  2064.            else
  2065.              begin
  2066.                PRect(Message.LParam)^.Left := PRect(Message.LParam)^.Left - 3;
  2067.                PRect(Message.LParam)^.Right := PRect(Message.LParam)^.Right + 3;
  2068.                PRect(Message.LParam)^.Top := PRect(Message.LParam)^.Top - 5;
  2069.                PRect(Message.LParam)^.Bottom := ClientHeight - 1;
  2070.              end;
  2071.         tpTop:
  2072.            if FIndex <> -1
  2073.            then
  2074.              begin
  2075.                PRect(Message.LParam)^.Left := LOff;
  2076.                PRect(Message.LParam)^.Right := ClientWidth - ROff;
  2077.                PRect(Message.LParam)^.Top := PRect(Message.LParam)^.Top - 6 + TOff;
  2078.                PRect(Message.LParam)^.Bottom := ClientHeight - BOff;
  2079.              end
  2080.            else
  2081.              begin
  2082.                PRect(Message.LParam)^.Left := 1;
  2083.                PRect(Message.LParam)^.Right := ClientWidth - 1;
  2084.                PRect(Message.LParam)^.Top := PRect(Message.LParam)^.Top - 5;
  2085.                PRect(Message.LParam)^.Bottom := ClientHeight - 1;
  2086.              end;
  2087.         tpBottom:
  2088.           if FIndex <> -1
  2089.           then
  2090.             begin
  2091.               PRect(Message.LParam)^.Left := LOff;
  2092.               PRect(Message.LParam)^.Right := ClientWidth - ROff;
  2093.               PRect(Message.LParam)^.Top := PRect(Message.LParam)^.Top - 6 + TOff;
  2094.               PRect(Message.LParam)^.Bottom := PRect(Message.LParam)^.Bottom + 4 - BOff;
  2095.             end
  2096.           else
  2097.             begin
  2098.               PRect(Message.LParam)^.Left := 1;
  2099.               PRect(Message.LParam)^.Right := ClientWidth - 1;
  2100.               PRect(Message.LParam)^.Top := 1;
  2101.               PRect(Message.LParam)^.Bottom := PRect(Message.LParam)^.Bottom + 3;
  2102.             end;
  2104.       end;
  2105.     end
  2106.   else
  2107.     if Message.Msg = TCM_GETITEMRECT
  2108.     then
  2109.       begin
  2110.         inherited WndProc(Message);
  2111.         if Style = tsTabs
  2112.         then
  2113.           case TabPosition of
  2114.             tpLeft:
  2115.                 begin
  2116.                   PRect(Message.LParam)^.Left := PRect(Message.LParam)^.Left - 2;
  2117.                   PRect(Message.LParam)^.Right := PRect(Message.LParam)^.Right - 2;
  2118.                 end;
  2119.             tpRight:
  2120.                 begin
  2121.                   PRect(Message.LParam)^.Left := PRect(Message.LParam)^.Left + 2;
  2122.                   PRect(Message.LParam)^.Right := PRect(Message.LParam)^.Right + 2;
  2123.                 end;
  2125.             tpTop:
  2126.                 begin
  2127.                   if not MultiLine
  2128.                   then
  2129.                     begin
  2130.                       PRect(Message.LParam)^.Left := PRect(Message.LParam)^.Left - 2;
  2131.                       PRect(Message.LParam)^.Right := PRect(Message.LParam)^.Right - 2;
  2132.                     end;
  2133.                   PRect(Message.LParam)^.Top := PRect(Message.LParam)^.Top - 2;
  2134.                   PRect(Message.LParam)^.Bottom := PRect(Message.LParam)^.Bottom - 2;
  2135.                 end;
  2136.             tpBottom:
  2137.                 begin
  2138.                   if not MultiLine
  2139.                   then
  2140.                     begin
  2141.                       PRect(Message.LParam)^.Left := PRect(Message.LParam)^.Left - 2;
  2142.                       PRect(Message.LParam)^.Right := PRect(Message.LParam)^.Right - 2;
  2143.                     end;
  2144.                   PRect(Message.LParam)^.Top := PRect(Message.LParam)^.Top + 2;
  2145.                   PRect(Message.LParam)^.Bottom := PRect(Message.LParam)^.Bottom + 2;
  2146.                 end;
  2147.           end;
  2148.       end
  2149.   else
  2150.   inherited WndProc(Message);
  2151.   if (Message.Msg = WM_SIZE) and (not MultiLine)
  2152.   then
  2153.     begin
  2154.       CheckScroll;
  2155.     end;
  2156. end;
  2158. function TbsSkinTabControl.GetItemRect(index: integer): TRect;
  2159. var
  2160.   R: TRect;
  2161. begin
  2162.   SendMessage(Handle, TCM_GETITEMRECT, index, Integer(@R));
  2163.   Result := R;
  2164. end;
  2166. procedure TbsSkinTabControl.SetItemSize;
  2167. begin
  2168.   SendMessage(Handle, TCM_SETITEMSIZE, 0, MakeLParam(AWidth, AHeight));
  2169. end;
  2171. procedure TbsSkinTabControl.PaintWindow(DC: HDC);
  2172. var
  2173.   SaveIndex: Integer;
  2174.   RealPicture: TBitMap;
  2175. begin
  2176.   GetSkinData;
  2177.   SaveIndex := SaveDC(DC);
  2178.   try
  2179.     RealPicture := TBitMap.Create;
  2180.     Canvas.Handle := DC;
  2181.     RealPicture.Width := Width;
  2182.     RealPicture.Height := Height;
  2183.     if FIndex = -1
  2184.     then
  2185.       PaintDefaultWindow(RealPicture.Canvas)
  2186.     else
  2187.       PaintSkinWindow(RealPicture.Canvas);
  2188.     DrawTabs(RealPicture.Canvas);
  2189.     Canvas.Draw(0, 0, RealPicture);
  2190.     Canvas.Handle := 0;
  2191.     RealPicture.Free;
  2192.   finally
  2193.     RestoreDC(DC, SaveIndex);
  2194.   end;
  2195. end;
  2197. procedure TbsSkinTabControl.DrawTabs;
  2198. var
  2199.   i: integer;
  2200.   R: TRect;
  2201. begin
  2202.   for i := 0 to Tabs.Count-1 do
  2203.   begin
  2204.     R := GetItemRect(i);
  2205.     DrawTab(i, R, i = TabIndex, i = FActiveTab, Cnvs);
  2206.   end;
  2207. end;
  2209. procedure TbsSkinTabControl.UpDateTabs;
  2210. begin
  2211.   if FIndex <> -1
  2212.   then
  2213.     begin
  2214.       if TabHeight <= 0
  2215.       then
  2216.         SetItemSize(TabWidth, RectHeight(TabRect))
  2217.       else
  2218.         SetItemSize(TabWidth, TabHeight);
  2219.     end
  2220.   else
  2221.     begin
  2222.       if TabHeight <= 0
  2223.       then
  2224.         SetItemSize(TabWidth, FDefaultItemHeight)
  2225.       else
  2226.         SetItemSize(TabWidth, TabHeight);
  2227.     end;
  2228.   if MultiLine and (FSkinUpDown <> nil)
  2229.   then
  2230.     HideSkinUpDown;
  2231.   ReAlign;
  2232. end;
  2234. procedure TbsSkinTabControl.DrawTab;
  2235. var
  2236.   R: TRect;
  2237.   S: String;
  2238.   TB, BufferTB: TBitMap;
  2239.   DrawGlyph: Boolean;
  2240.   W, H: Integer;
  2241. begin
  2242.   DrawGlyph := (Images <> nil) and (TI < Images.Count);
  2243.   S := Tabs[TI];
  2244.   TB := TBitMap.Create;
  2245.   if (TabPosition = tpTop) or (TabPosition = tpBottom)
  2246.   then
  2247.     begin
  2248.       W := RectWidth(Rct);
  2249.       H := RectHeight(Rct);
  2250.     end
  2251.   else
  2252.     begin
  2253.       H := RectWidth(Rct);
  2254.       W := RectHeight(Rct);
  2255.     end;
  2256.   R := Rect(0, 0, W, H);  
  2257.   if FIndex <> -1
  2258.   then
  2259.     begin
  2260.       if TabHeight <= 0
  2261.       then
  2262.         begin
  2263.           if MouseIn and not Active and not IsNullRect(MouseInTabRect)
  2264.           then
  2265.             CreateHSkinImage(TabLeftOffset, TabRightOffset,
  2266.              TB, Picture, MouseInTabRect, W, H)
  2267.           else
  2268.             if Active and Focused
  2269.           then
  2270.            CreateHSkinImage(TabLeftOffset, TabRightOffset,
  2271.             TB, Picture, FocusTabRect, W, H)
  2272.           else
  2273.           if Active
  2274.           then
  2275.             CreateHSkinImage(TabLeftOffset, TabRightOffset,
  2276.               TB, Picture, ActiveTabRect, W, H)
  2277.           else
  2278.             CreateHSkinImage(TabLeftOffset, TabRightOffset,
  2279.              TB, Picture, TabRect, W, H);
  2280.        end
  2281.      else
  2282.        begin
  2283.          BufferTB := TBitMap.Create;
  2284.          BufferTB.Width := W;
  2285.          BufferTB.Height := RectHeight(TabRect);
  2286.          if MouseIn and not Active and not IsNullRect(MouseInTabRect)
  2287.           then
  2288.             CreateHSkinImage(TabLeftOffset, TabRightOffset,
  2289.              BufferTB, Picture, MouseInTabRect, W, H)
  2290.           else
  2291.             if Active and Focused
  2292.           then
  2293.            CreateHSkinImage(TabLeftOffset, TabRightOffset,
  2294.             BufferTB, Picture, FocusTabRect, W, H)
  2295.           else
  2296.           if Active
  2297.           then
  2298.             CreateHSkinImage(TabLeftOffset, TabRightOffset,
  2299.               BufferTB, Picture, ActiveTabRect, W, H)
  2300.           else
  2301.             CreateHSkinImage(TabLeftOffset, TabRightOffset,
  2302.              BufferTB, Picture, TabRect, W, H);
  2303.          TB.Width := W;
  2304.          TB.Height := H;
  2305.          TB.Canvas.StretchDraw(R, BufferTB);
  2306.          BufferTB.Free;
  2307.        end;
  2308.       if TabPosition = tpBottom then DrawFlipVert(TB);
  2309.       with TB.Canvas do
  2310.       begin
  2311.         Brush.Style := bsClear;
  2312.         if FUseSkinFont
  2313.         then
  2314.           begin
  2315.             Font.Name := FontName;
  2316.             Font.Style := FontStyle;
  2317.             Font.Height := FontHeight;
  2318.           end
  2319.         else
  2320.            Font.Assign(Self.Font);
  2321.         if (SkinData <> nil) and (SkinData.ResourceStrData <> nil)
  2322.         then
  2323.           Font.Charset := SkinData.ResourceStrData.CharSet
  2324.         else
  2325.           Font.CharSet := Self.Font.CharSet;
  2326.         if MouseIn and not Active
  2327.         then
  2328.           Font.Color := MouseInFontColor
  2329.         else
  2330.         if Active and Focused
  2331.         then
  2332.           Font.Color := FocusFontColor
  2333.         else
  2334.           if Active
  2335.           then Font.Color := ActiveFontColor
  2336.           else Font.Color := FontColor;
  2337.       end;
  2338.     end
  2339.   else
  2340.     begin
  2341.       TB.Width := W;
  2342.       TB.Height := H;
  2343.       if MouseIn and not Active
  2344.       then
  2345.         begin
  2346.           TB.Canvas.Brush.Color := BS_XP_BTNACTIVECOLOR;
  2347.           TB.Canvas.FillRect(R);
  2348.         end
  2349.       else
  2350.       if Active and Focused
  2351.       then
  2352.         begin
  2353.           Frame3D(TB.Canvas, R, BS_XP_BTNFRAMECOLOR, BS_XP_BTNFRAMECOLOR, 1);
  2354.           TB.Canvas.Brush.Color := BS_XP_BTNDOWNCOLOR;
  2355.           TB.Canvas.FillRect(R);
  2356.         end
  2357.       else
  2358.       if Active
  2359.       then
  2360.         begin
  2361.           Frame3D(TB.Canvas, R, BS_XP_BTNFRAMECOLOR, BS_XP_BTNFRAMECOLOR, 1);
  2362.           TB.Canvas.Brush.Color := BS_XP_BTNACTIVECOLOR;
  2363.           TB.Canvas.FillRect(R);
  2364.         end
  2365.       else
  2366.         begin
  2367.           TB.Canvas.Brush.Color := clBtnFace;
  2368.           TB.Canvas.FillRect(R);
  2369.         end;
  2370.       with TB.Canvas do
  2371.       begin
  2372.         Brush.Style := bsClear;
  2373.         Font.Assign(Self.Font);
  2374.         if (SkinData <> nil) and (SkinData.ResourceStrData <> nil)
  2375.         then
  2376.           Font.Charset := SkinData.ResourceStrData.CharSet
  2377.       end;
  2378.     end;
  2379.   //
  2380.   if DrawGlyph
  2381.   then
  2382.     DrawTabGlyphAndText(TB.Canvas, TB.Width, TB.Height, S,
  2383.                         Images, TI, True)
  2384.   else
  2385.     DrawText(TB.Canvas.Handle, PChar(S), Length(S), R, DT_CENTER or DT_SINGLELINE or DT_VCENTER);
  2386.   if TabPosition = tpLeft
  2387.   then
  2388.     DrawRotate90_1(Cnvs, TB, Rct.Left, Rct.Top)
  2389.   else
  2390.   if TabPosition = tpRight
  2391.   then
  2392.     DrawRotate90_2(Cnvs, TB, Rct.Left, Rct.Top)
  2393.   else
  2394.     Cnvs.Draw(Rct.Left, Rct.Top, TB);
  2395.   TB.Free;
  2396. end;
  2399. end.