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

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

Delphi控件源码

开发平台：

Delphi

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