Konuyu Oyla:
  • Derecelendirme: 0/5 - 0 oy
  • 1
  • 2
  • 3
  • 4
  • 5
componenti fmx e çevirme
#1
aşağıdaki komponenti fmx e çeviremedim yapabilecek bilgili arkadaşlar varmı acaba?

unit OMultiPanel;

{
   OMultiPanel

   Version 1.3

   Copyright © 2012 Ondrej Pokorny
     http://www.kluug.net


 *** BEGIN LICENSE BLOCK *****

 OMultiPanel is licensed under MPL 1.1/GPL 3/LGPL 3 tri-license.

 MPL: http://www.mozilla.org/MPL/1.1/
 GPL: http://www.gnu.org/licenses/gpl-3.0.html
 LGPL: http://www.gnu.org/licenses/lgpl-3.0.de.html

 ***** END LICENSE BLOCK *****

}

interface

{$IFNDEF FPC}
 {$IF CompilerVersion < 18.0}
   {$DEFINE OMP_DELPHI7_DOWN}
 {$IFEND}
 {$IF CompilerVersion >= 15}
   {$DEFINE OMP_DELPHI7_UP}
 {$IFEND}
 {$IF CompilerVersion < 15}
   {$DEFINE OMP_DELPHI6_DOWN}
 {$IFEND}
 {$IF CompilerVersion >= 18.0}
   {$DEFINE OMP_DELPHI2006_UP}
 {$IFEND}
{$ENDIF}

{$IFNDEF OMP_DELPHI6_DOWN}
 {$DEFINE OMP_THEMES}
{$ENDIF}


uses
 {$IFNDEF FPC}Windows, {$ENDIF}
 Messages, SysUtils, Variants, Classes, Graphics, Controls,
 Dialogs, ExtCtrls, Types, Registry, IniFiles, Contnrs
 {$IFNDEF FPC}, StdCtrls{$ENDIF}
 {$IFDEF FPC}, lmessages, lcltype, lclintf{$ENDIF}
 ;

type

 TPanelType = (ptHorizontal, ptVertical);

 TOCustomMultiPanel = class;

 TOnPaintSizingBar = procedure(Sender: TOCustomMultiPanel; aCanvas: TCanvas; aBarRect: TRect; aHover: Boolean) of Object;
 TOnPaintSizingBarMethod = procedure(Sender: TOCustomMultiPanel; aCanvas: TCanvas; aBarRect: TRect; aHover: Boolean);

 TSplitterListItem = class(TObject)
 private
   fPxPosition: Integer;
   fPanelIndex: Integer;
 public
   constructor CreateAdd(aAddToList: TList);
 public
   property PxPosition: Integer read fPxPosition;
   property PanelIndex: Integer read fPanelIndex;
 end;

 TOMultiPanelCollection = class;
 TOMultiPanelItem = class(TCollectionItem)
 private
   fPosition: Double;
   fControl: TControl;
   fVisible: Boolean;
   procedure SetControl(const Value: TControl);
   procedure SetPosition(const Value: Double);
   procedure SetPositionOnlyWithCheck(const Value: Double);
   procedure SetVisible(const Value: Boolean);
 protected
   procedure SetIndex(Value: Integer); override;
   procedure AssignTo(Dest: TPersistent); override;

   procedure CheckPosition(var Value: Double); virtual;
 public
   constructor Create(ACollection: TCollection); override;
 public
   function MPOwner: TOCustomMultiPanel;
   function MPCollection: TOMultiPanelCollection;
 published
   property Control: TControl read fControl write SetControl;
   property Position: Double read fPosition write SetPosition;
   property Visible: Boolean read fVisible write SetVisible;

   property Index;
 end;

 TOMultiPanelCollection = class(TOwnedCollection)
 protected
   function GetAttrCount: Integer; override;
   function GetItem(Index: Integer): TOMultiPanelItem;
   procedure SetItem(Index: Integer; Value: TOMultiPanelItem);

   procedure Notify(Item: TCollectionItem; Action: TCollectionNotification); override;
 public
   constructor Create(AOwner: TPersistent);
 public
   function MPOwner: TOCustomMultiPanel;

   function Add: TOMultiPanelItem;

   procedure AddControl(AControl: TControl; AIndex: Integer = -1);
   procedure RemoveControl(AControl: TControl);
   function IndexOf(AControl: TControl): Integer;

   procedure SetDefaultPositions;

   property Items[Index: Integer]: TOMultiPanelItem read GetItem write SetItem; default;
 end;

 {$IFNDEF FPC}
 TConstraintSize = Integer;
 {$ENDIF}

 TOCustomMultiPanel = class(TCustomPanel)
 private
   fOnSplitterMoved: TNotifyEvent;
   fOnPaintSizingBar: TOnPaintSizingBar;
   
   fSplitterColor: TColor;
   fSplitterHoverColor: TColor;

   fHover: Boolean;
   fHoverIndex: Integer;
   fSizing: Boolean;
   fSizingIndex: Integer;

   fLastSizingLinePx: Integer;
   fPrevBrush: HBrush;
   {$IFDEF FPC}
   fSplitterWindow: HWND;
   {$ELSE}
   fHitTest: TPoint;
   fLineDC: HDC;
   fBrush: TBrush;
   {$ENDIF}
   fInResizeControls: Boolean;
   fDoubleBufferedBitmap: TBitmap;

   fMinPosition: Double;
   fSplitterSize: Integer;

   fPanelCollection: TOMultiPanelCollection;
   fSplittersList: TObjectList;
   fPanelType: TPanelType;

   procedure SetPanelType(const Value: TPanelType);

   procedure SetMinPosition(const Value: Double);
   procedure SetSplitterSize(const Value: Integer);

   procedure AllocateLineDC;
   procedure ReleaseLineDC;

   procedure DrawSizingLine({%H-}X, {%H-}Y: Integer);
   {$IFNDEF FPC}
   procedure WMSetCursor(var Message: TWMSetCursor); message WM_SetCursor;
   procedure WMNCHitTest(var Msg: TWMNCHitTest); message WM_NCHITTEST;
   {$ENDIF}

   procedure SetPanelCollection(const Value: TOMultiPanelCollection);
   function GetSplitterColor: TColor;
   procedure SetSplitterColor(const Value: TColor);
   function GetSplitterHoverColor: TColor;
   procedure SetSplitterHoverColor(const Value: TColor);
   function GetSplitterPosition(Index: Integer): Integer;
   function MinPositionStored: Boolean;
 {$IFDEF FPC}
 protected
 {$ELSE}
 private
 {$ENDIF}
   procedure CMControlChange(var Message: TCMControlChange); message CM_CONTROLCHANGE;
   procedure CMMouseLeave(var Message: TMessage); message CM_MOUSELEAVE;
   procedure CMMouseEnter(var Message: TMessage); message CM_MOUSEENTER;
 protected
   function GetSettingsSection: String; virtual;
   function GetSettingsIdent: String; virtual;

   procedure CalcSizing(X, Y: Integer; var aSizing: Boolean; var aSizingIndex: Integer);
   function GetSizingRect(SplitterIndex: Integer): TRect;

   procedure Paint; override;
   procedure DoPaintSizingBar(aCanvas: TCanvas; aIndex: Integer; aRect: TRect); virtual;
   procedure InvalidateSplitter(aIndex: Integer);

   procedure MouseDown(Button: TMouseButton; Shift: TShiftState;
     X, Y: Integer); override;
   procedure MouseMove(Shift: TShiftState; X, Y: Integer); override;
   procedure MouseUp(Button: TMouseButton; Shift: TShiftState;
     X, Y: Integer); override;

   procedure AlignControls({%H-}AControl: TControl; var {%H-}Rect: TRect); override;
   procedure Loaded; override;
   procedure Resize; override;

   procedure ConstrainedResize(var MinWidth, MinHeight, MaxWidth, MaxHeight: TConstraintSize); override;
 public
   constructor Create(AOwner: TComponent); override;
   destructor Destroy; override;
 public
   procedure InvalidateSplitters;
   procedure ResizeControls; virtual;

   procedure LoadPositionsFromRegistry(aReg: TRegIniFile); overload;
   procedure SavePositionsToRegistry(aReg: TRegIniFile); overload;
   procedure LoadPositionsFromRegistry(aReg: TRegIniFile; const aSection, aIdent: String); overload; virtual;
   procedure SavePositionsToRegistry(aReg: TRegIniFile; const aSection, aIdent: String); overload; virtual;

   procedure LoadPositionsFromIniFile(aIni: TCustomIniFile); overload;
   procedure SavePositionsToIniFile(aIni: TCustomIniFile); overload;
   procedure LoadPositionsFromIniFile(aIni: TCustomIniFile; const aSection, aIdent: String); overload; virtual;
   procedure SavePositionsToIniFile(aIni: TCustomIniFile; const aSection, aIdent: String); overload; virtual;

   procedure DoSplitterMoved;

   function FindPanel(aControl: TControl): TOMultiPanelItem;

   property SplitterPosition[Index: Integer]: Integer read GetSplitterPosition;

   property PanelCollection: TOMultiPanelCollection read fPanelCollection write SetPanelCollection;
   property PanelType: TPanelType read fPanelType write SetPanelType default ptHorizontal;
   property MinPosition: Double read fMinPosition write SetMinPosition stored MinPositionStored;
   property SplitterSize: Integer read fSplitterSize write SetSplitterSize default 3;
   property SplitterColor: TColor read GetSplitterColor write SetSplitterColor default clNone;
   property SplitterHoverColor: TColor read GetSplitterHoverColor write SetSplitterHoverColor default clNone;

   property OnSplitterMoved: TNotifyEvent read fOnSplitterMoved write fOnSplitterMoved;
   property OnPaintSizingBar: TOnPaintSizingBar read fOnPaintSizingBar write fOnPaintSizingBar;

   property BevelOuter default bvNone;
   property BevelInner default bvNone;
   property ParentColor default True;
 end;

 TOMultiPanel = class(TOCustomMultiPanel)
 published
   property PanelType;
   property PanelCollection;
   property MinPosition;
   property SplitterSize;
   property SplitterColor;
   property SplitterHoverColor;

   property OnSplitterMoved;
   property OnPaintSizingBar;

   property Align;
   property Anchors;
   property AutoSize;
   {$IFNDEF FPC}
   property BevelEdges;
   property BevelKind;
   property Ctl3D;
   property ParentCtl3D;
   {$IFDEF OMP_DELPHI7_UP}
   property ParentBackground;
   {$ENDIF}
   {$IFDEF OMP_DELPHI2006_UP}
   property OnAlignInsertBefore;
   property OnAlignPosition;
   {$ENDIF}
   property OnCanResize;
   {$IFDEF OMP_DELPHI2006_UP}
   property OnMouseActivate;
   property OnMouseEnter;
   property OnMouseLeave;
   {$ENDIF}
   {$ENDIF}
   property BevelInner;
   property BevelOuter;
   property BevelWidth;
   property BiDiMode;
   property BorderWidth;
   property Constraints;
   property Color;
   property UseDockManager default True;
   property DockSite;
   property DragCursor;
   property DragKind;
   property DragMode;
   property Enabled;
   property Font;
   property ParentBiDiMode;
   property ParentFont;
   property ParentShowHint;
   property PopupMenu;
   property ShowHint;
   property TabOrder;
   property TabStop;
   property Visible;
   property OnClick;
   property OnConstrainedResize;
   property OnContextPopup;
   property OnDockDrop;
   property OnDockOver;
   property OnDblClick;
   property OnDragDrop;
   property OnDragOver;
   property OnEndDock;
   property OnEndDrag;
   property OnEnter;
   property OnExit;
   property OnGetSiteInfo;
   property OnMouseDown;
   property OnMouseMove;
   property OnMouseUp;
   property OnResize;
   property OnStartDock;
   property OnStartDrag;
   property OnUnDock;
 end;

//DEFAULTS
var
 OMP_SplitterColor: TColor = clNone;
 OMP_SplitterHoverColor: TColor = clNone;
 OMP_SplitterSize: Integer = 3;
 OMP_OnPaintSizingBar: TOnPaintSizingBarMethod = nil;

implementation

uses Math
 {$IFDEF OMP_THEMES}, Themes{$ENDIF}
 {$IFNDEF FPC}, ShellAPI{$ENDIF};

{ TOCustomMultiPanel }

procedure TOCustomMultiPanel.AllocateLineDC;
begin
{$IFDEF FPC}
 fPrevBrush := GetStockObject(BLACK_BRUSH);//ThemeServices.DottedBrush;
 fSplitterWindow := CreateRubberband(Rect(0, 0, 0, 0), fPrevBrush);
{$ELSE}
 FLineDC := GetDCEx(Parent.Handle, 0, DCX_CACHE or DCX_CLIPSIBLINGS
   or DCX_LOCKWINDOWUPDATE);

 if FBrush = nil then
 begin
   FBrush := TBrush.Create;

   FBrush.Bitmap := AllocPatternBitmap(clBlack, clWhite);
 end;
 fPrevBrush := SelectObject(FLineDC, FBrush.Handle);
{$ENDIF}
end;

procedure TOCustomMultiPanel.CalcSizing(X, Y: Integer; var aSizing: Boolean;
 var aSizingIndex: Integer);

 function NextTo(Pos1, Pos2: Double): Boolean;
 begin
   result := (Abs(Pos1 - Pos2) < SplitterSize);
 end;

var
 I: Integer;
begin
 aSizing := False;
 aSizingIndex := -1;

 if csDesigning in ComponentState then
   Exit;

 for I := 0 to fSplittersList.Count-1 do
 if PtInRect(GetSizingRect(I), Point(X, Y)) then
 begin
   aSizing := true;
   aSizingIndex := TSplitterListItem(fSplittersList[I]).PanelIndex;
   Break;
 end;
end;

procedure TOCustomMultiPanel.CMControlChange(var Message: TCMControlChange);
begin
 inherited;
 if not (csLoading in ComponentState) then
   if Message.Inserting and (Message.Control.Parent = Self) then
   begin
     DisableAlign;
     try
       Message.Control.Anchors := [];
       fPanelCollection.AddControl(Message.Control);
     finally
       EnableAlign;
     end;
   end else
     fPanelCollection.RemoveControl(Message.Control);
end;

procedure TOCustomMultiPanel.CMMouseEnter(var Message: TMessage);
{$IF DEFINED(OMP_DELPHI7_DOWN) OR DEFINED(FPC)}
var
 xP: TPoint;
{$IFEND}
begin
 inherited;

 {$IF DEFINED(OMP_DELPHI7_DOWN) OR DEFINED(FPC)}
 //DELPHI 7
 xP := ScreenToClient(Mouse.CursorPos);
 MouseMove([], xP.X, xP.Y);
 {$IFEND}
end;

procedure TOCustomMultiPanel.CMMouseLeave(var Message: TMessage);
var
 xHover: Boolean;
 {$IFDEF FPC}
 xP: TPoint;
 {$ENDIF}
begin
 xHover := fHover;
 fHover := False;

 inherited;

 if (xHover <> fHover) and (fHoverIndex >= 0) then
   InvalidateSplitter(fHoverIndex);

 {$IFDEF FPC}
 xP := ScreenToClient(Mouse.CursorPos);
 MouseMove([], xP.X, xP.Y);
 {$ENDIF}
end;

type
 TMyControl = class(TControl);

procedure TOCustomMultiPanel.ConstrainedResize(var MinWidth, MinHeight, MaxWidth,
 MaxHeight: TConstraintSize);
 function GetControlsConstrainedHeight: Integer;
 var nW, nH, xW, xH: TConstraintSize;
   I: Integer;
 begin
   Result := 0;
   nW := 0; xW := 0; xH := 0;
   for I := 0 to ControlCount-1 do
   begin
     nH := Controls[I].Constraints.MinHeight;
     TMyControl(Controls[I]).ConstrainedResize(nW, nH, xW, xH);
     Inc(Result, nH);
   end;
 end;
begin
 inherited ConstrainedResize(MinWidth, MinHeight, MaxWidth, MaxHeight);

 if fPanelType = ptHorizontal then
 begin
   MinWidth := Max(MinWidth, fPanelCollection.Count*(fSplitterSize*2) + GetControlsConstrainedHeight);
 end else
 begin
   MinHeight := Max(MinHeight, fPanelCollection.Count*(fSplitterSize*2) + GetControlsConstrainedHeight);
 end;
end;

constructor TOCustomMultiPanel.Create(AOwner: TComponent);
begin
 fPanelCollection := TOMultiPanelCollection.Create(Self);
 fSplittersList := TObjectList.Create(True);
 fDoubleBufferedBitmap := TBitmap.Create;

 inherited;

 Caption := '';
 BevelOuter := bvNone;
 BevelInner := bvNone;
 ParentColor := True;

 fHover := true;
 fHoverIndex := -1;
 fSizing := False;
 fSizingIndex := -1;

 fPanelType := ptHorizontal;
 fMinPosition := 0.02;
 fOnSplitterMoved := nil;

 fSplitterColor := OMP_SplitterColor;
 fSplitterHoverColor := OMP_SplitterHoverColor;
 fSplitterSize := OMP_SplitterSize;
end;

destructor TOCustomMultiPanel.Destroy;
begin
 fPanelCollection.Free;
 fSplittersList.Free;
 fDoubleBufferedBitmap.Free;

 inherited;
end;

procedure TOCustomMultiPanel.DoPaintSizingBar(aCanvas: TCanvas; aIndex: Integer; aRect: TRect);
var
 xColor: TColor;
begin
 if Assigned(fOnPaintSizingBar) then
 begin
   fOnPaintSizingBar(Self, aCanvas, aRect, fHover and (fHoverIndex = aIndex));
 end else
 if Assigned(OMP_OnPaintSizingBar) then
 begin
   OMP_OnPaintSizingBar(Self, aCanvas, aRect, fHover and (fHoverIndex = aIndex));
 end else
 begin
   aCanvas.Brush.Style := bsSolid;
   if fHover and (fHoverIndex = aIndex) then
     xColor := SplitterHoverColor
   else
     xColor := SplitterColor;
   if xColor <> clNone then
   begin
     aCanvas.Brush.Color := xColor;
     aCanvas.FillRect(aRect);
   end;
 end;
end;

procedure TOCustomMultiPanel.DoSplitterMoved;
begin
 if Assigned(fOnSplitterMoved) then
   fOnSplitterMoved(Self);

end;

procedure TOCustomMultiPanel.DrawSizingLine(X, Y: Integer);
var
 xRect: TRect;
begin
 if fSizing and (fPanelType = ptHorizontal) then
 begin
   xRect := Rect(Left + X-fSplitterSize div 2, Top, fSplitterSize, Height);
   fLastSizingLinePx := X;
 end else
 if fSizing and (fPanelType = ptVertical) then
 begin
   xRect := Rect(Left, Top + Y-fSplitterSize div 2, Width, fSplitterSize);
   fLastSizingLinePx := Y;
 end;
 {$IFDEF FPC}
 xRect.TopLeft := Parent.ClientToScreen(xRect.TopLeft);
 xRect.Right:=xRect.Left+xRect.Right;
 xRect.Bottom:=xRect.Top+xRect.Bottom;
 SetRubberBandRect(fSplitterWindow, xRect);
 {$ELSE}
 PatBlt(FLineDC, xRect.Left, xRect.Top, xRect.Right, xRect.Bottom, PATINVERT);
 {$ENDIF}
end;

function TOCustomMultiPanel.FindPanel(aControl: TControl): TOMultiPanelItem;
var
 I: Integer;
begin
 for I := 0 to fPanelCollection.Count-1 do
 if fPanelCollection[I].Control = aControl then
 begin
   Result := fPanelCollection[I];
   Exit;
 end;
 Result := nil;
end;

function TOCustomMultiPanel.GetSplitterHoverColor: TColor;
begin
 Result := fSplitterHoverColor;
end;

function TOCustomMultiPanel.GetSettingsIdent: String;
var
 xControl: TWinControl;
begin
 Result := Self.Name;
 xControl := Self.Parent;
 while Assigned(xControl) do
 begin
   Result := xControl.Name+'.'+Result;
   xControl := xControl.Parent;
 end;
end;

function TOCustomMultiPanel.GetSettingsSection: String;
begin
 Result := 'OMultiPanel';
end;

function TOCustomMultiPanel.GetSizingRect(SplitterIndex: Integer): TRect;
var Px: Integer;
begin
 Px := TSplitterListItem(fSplittersList[SplitterIndex]).PxPosition;
 if fPanelType = ptHorizontal then
   Result := Rect(Px, 0, Px+fSplitterSize, ClientHeight)
 else
   Result := Rect(0, Px, ClientWidth, Px+fSplitterSize);
end;

function TOCustomMultiPanel.GetSplitterColor: TColor;
begin
 Result := fSplitterColor;
end;

function TOCustomMultiPanel.GetSplitterPosition(Index: Integer): Integer;
begin
 if Index < fSplittersList.Count then
 begin
   Result := TSplitterListItem(fSplittersList[Index]).PxPosition;
 end else
 begin
   Result := 0;
 end;
end;

{$IFNDEF FPC}
type
 TAccessWinControl = class(TWinControl);
{$ENDIF}

procedure TOCustomMultiPanel.InvalidateSplitter(aIndex: Integer);
 procedure InvalidateWithParent(bControl: TWinControl; bRect: TRect);
 begin
   if not bControl.HandleAllocated then
     Exit;

   if {$IF NOT DEFINED(FPC) AND NOT DEFINED(OMP_DELPHI6_DOWN)}TAccessWinControl(bControl).ParentBackground and{$IFEND}
      (bControl.Parent <> nil)
   then begin
     OffsetRect(bRect, bControl.Left, bControl.Top);
     InvalidateWithParent(bControl.Parent, bRect);
     OffsetRect(bRect, -bControl.Left, -bControl.Top);
   end;
   {$IFDEF MSWINDOWS}
   InvalidateRect(bControl.Handle, @bRect, True);
   {$ELSE}
   bControl.Invalidate;
   {$ENDIF}
 end;
var xR: TRect;
begin
 if aIndex < 0 then
   Exit;

 {$WARNINGS OFF}
 if HandleAllocated then
 begin
   xR := GetSizingRect(aIndex);
   {$IFDEF OMP_THEMES}
   if ThemeServices.ThemesEnabled then
   {$ENDIF}
   begin
     //Repaint parent under splitter if splitter is hidden (clNone etc)!!!
     InvalidateWithParent(Self, xR);
   {$IFDEF OMP_THEMES}
   end else
   begin
     {$IFDEF MSWINDOWS}
     InvalidateRect(Handle, @xR, False);
     {$ELSE}
     Self.Invalidate;
     {$ENDIF}
   {$ENDIF}
   end;
 end;
 {$WARNINGS ON}
end;

procedure TOCustomMultiPanel.InvalidateSplitters;
var
 I: Integer;
begin
 for I := 0 to fSplittersList.Count-1 do
   InvalidateSplitter(I);
end;

procedure TOCustomMultiPanel.Loaded;
begin
 inherited;

 ResizeControls;
end;

procedure TOCustomMultiPanel.LoadPositionsFromIniFile(aIni: TCustomIniFile;
 const aSection, aIdent: String);
var
 I: Integer;
begin
 for I := 0 to PanelCollection.Count-2 do
   PanelCollection[I].Position :=
     StrToFloatDef(
       aIni.ReadString(aSection, aIdent+'.Position'+IntToStr(I), ''),
       PanelCollection[I].Position);
end;

procedure TOCustomMultiPanel.LoadPositionsFromIniFile(aIni: TCustomIniFile);
begin
 LoadPositionsFromIniFile(aIni, GetSettingsSection, GetSettingsIdent);
end;

procedure TOCustomMultiPanel.LoadPositionsFromRegistry(aReg: TRegIniFile;
 const aSection, aIdent: String);
var I: Integer;
begin
 for I := 0 to PanelCollection.Count-2 do
   PanelCollection[I].Position :=
     StrToFloatDef(
       aReg.ReadString(aSection, aIdent+'.Position'+IntToStr(I), ''),
       PanelCollection[I].Position);
end;

procedure TOCustomMultiPanel.LoadPositionsFromRegistry(aReg: TRegIniFile);
begin
 LoadPositionsFromRegistry(aReg, GetSettingsSection, GetSettingsIdent);
end;

function TOCustomMultiPanel.MinPositionStored: Boolean;
begin
 Result := MinPosition <> 0.02;
end;

procedure TOCustomMultiPanel.MouseDown(Button: TMouseButton; Shift: TShiftState;
 X, Y: Integer);
begin
 if (Button = mbLeft) and not (ssDouble in Shift) then
 begin
   CalcSizing(X, Y, fSizing, fSizingIndex);

   if fSizing then
     AllocateLineDC;

   DrawSizingLine(X, Y);
 end else
   inherited;
end;

procedure TOCustomMultiPanel.MouseMove(Shift: TShiftState; X, Y: Integer);
var
 Pos: Double;
 xHover: Boolean;
 xHoverIndex: Integer;
begin
 inherited;

 if fSizing and (fSizingIndex >= 0) and (ClientWidth > 0) and (ClientHeight > 0) then
 begin
   DrawSizingLine(fLastSizingLinePx, fLastSizingLinePx);

   if PanelType = ptHorizontal then
     Pos := X/ClientWidth
   else
     Pos := Y/ClientHeight;

   PanelCollection[fSizingIndex].CheckPosition(Pos);

   if PanelType = ptHorizontal then
     Pos := Pos*ClientWidth
   else
     Pos := Pos*ClientHeight;

   DrawSizingLine(Round(Pos), Round(Pos));
 end else
 begin
   CalcSizing(X, Y, {%H-}xHover, {%H-}xHoverIndex);
   if (xHoverIndex <> fHoverIndex) or (xHover <> fHover) then
   begin
     fHover := xHover;
     if fHoverIndex <> xHoverIndex then
       InvalidateSplitter(fHoverIndex);
     fHoverIndex := xHoverIndex;
     InvalidateSplitter(fHoverIndex);
   end;
   {$IFDEF FPC}
   if fSizing or xHover then
   begin
     if (fPanelType = ptHorizontal) then
       Cursor := crSizeWE
     else if (fPanelType = ptVertical) then
       Cursor := crSizeNS;
   end else
     Cursor := crDefault;
   {$ENDIF}
 end;
end;

procedure TOCustomMultiPanel.MouseUp(Button: TMouseButton; Shift: TShiftState;
 X, Y: Integer);
begin
 inherited;

 try
   if (fSizing) and (fSizingIndex >= 0) and (ClientWidth > 0) and (ClientHeight > 0) then
   begin
     Dec(X, fSplitterSize div 2);
     Dec(Y, fSplitterSize div 2);

     DrawSizingLine(fLastSizingLinePx, fLastSizingLinePx);
     {$IFDEF MSWINDOWS}
     SendMessage(Handle, WM_SetRedraw, 0, 0);
     {$ENDIF}
     try

       if PanelType = ptHorizontal then
         PanelCollection[fSizingIndex].Position := X/ClientWidth
       else
         PanelCollection[fSizingIndex].Position := Y/ClientHeight;
     finally
       ReleaseLineDC;
       {$IFDEF MSWINDOWS}
       SendMessage(Handle, WM_SetRedraw, 1, 0);
       RedrawWindow(Handle, nil, 0,
         RDW_ERASE or RDW_FRAME or RDW_INVALIDATE or RDW_ALLCHILDREN);
       {$ELSE}
       Self.Invalidate;
       {$ENDIF}
     end;
   end;
 finally
   fSizing := False;
   CalcSizing(X, Y, fHover, fHoverIndex);
   InvalidateSplitter(fHoverIndex);
 end;
end;

procedure TOCustomMultiPanel.Paint;
var
 I: Integer;
 xR: TRect;
 xC: TCanvas;
begin
 {$WARNINGS OFF}
 if not Assigned(fDoubleBufferedBitmap) then
 begin
   inherited;
   Exit;
 end;

 {$IFDEF OMP_THEMES}
 if not ThemeServices.ThemesEnabled then
 {$ENDIF}
 begin
   {$IFDEF OMP_DELPHI2006_UP}
   //DELPHI 2007+
   fDoubleBufferedBitmap.SetSize(Width, Height);
   {$ELSE}
   //DELPHI 7
   fDoubleBufferedBitmap.Width := Width;
   fDoubleBufferedBitmap.Height := Height;
   {$ENDIF}

   xC := fDoubleBufferedBitmap.Canvas;
   if Color = clDefault then
     xC.Brush.Color := clBtnFace
   else
     xC.Brush.Color := Color;
   xC.FillRect(Rect(0, 0, Width, Height));
 {$IFDEF OMP_THEMES}
 end else
 begin
   xC := Canvas;
 {$ENDIF}
 end;

 xC.Lock;

 if (csDesigning in ComponentState) and (fPanelCollection.Count = 0) then
 begin
   xC.Pen.Color := clBlue;
   xC.Brush.Style := bsClear;
   xC.Rectangle(0, 0, ClientWidth, ClientHeight);
   xC.MoveTo(0, 0);
   xC.LineTo(ClientWidth, ClientHeight);
   xC.MoveTo(ClientWidth, 0);
   xC.LineTo(0, ClientHeight);
   if Name <> '' then
   begin
     xR := Rect(0, 0, xC.TextWidth(Name) + 4, xC.TextHeight(Name) + 2);
     OffsetRect(xR, (Width - xR.Right) div 2, (Height - xR.Bottom) div 2);
     xC.Brush.Color := clWindow;
     xC.Font.Color := clWindowText;
     xC.Rectangle(xR);
     xC.TextOut(xR.Left+2, xR.Top+1, Name);
   end;
 end;

 for I := 0 to fSplittersList.Count-1 do
 begin
   xR := GetSizingRect(I);
   DoPaintSizingBar(xC, I, xR);
 end;

 xC.Unlock;

 {$IFDEF OMP_THEMES}
 if not ThemeServices.ThemesEnabled then
 {$ENDIF}
 begin
   Canvas.Draw(0, 0, fDoubleBufferedBitmap);

   Brush.Style := bsClear;//Disable flicker
 end;
 {$WARNINGS ON}
end;

procedure TOCustomMultiPanel.AlignControls(AControl: TControl; var Rect: TRect);
begin
 ResizeControls;
end;

procedure TOCustomMultiPanel.ReleaseLineDC;
begin
 {$IFDEF FPC}
 DestroyRubberBand(fSplitterWindow);
 {$ELSE}
 if FPrevBrush <> 0 then
   SelectObject(FLineDC, FPrevBrush);
 ReleaseDC(Parent.Handle, FLineDC);
 if FBrush <> nil then
 begin
   FBrush.Free;
   FBrush := nil;
 end;
 {$ENDIF}
end;

procedure TOCustomMultiPanel.Resize;
begin
 inherited;

 DoSplitterMoved;
end;

procedure TOCustomMultiPanel.ResizeControls;
var
 I, L: Integer;
 xPanel: TOMultiPanelItem;
 xPosAbs, xDefaultSize: Integer;
 xSplitterItem: TSplitterListItem;
begin
 if fInResizeControls then
   Exit;

 fInResizeControls := True;
 try
   if not(
      not (csLoading in ComponentState) and
      not (csUpdating in ComponentState) and
      not (csDestroying in ComponentState))
   then
     Exit;

   fSplittersList.Clear;
   if csLoading in ComponentState then
     Exit;

   xPosAbs := 0;
   if (PanelCollection.Count > 0) then
     PanelCollection[PanelCollection.Count-1].FPosition := 1;//use fPosition => do not check!!

   for I := 0 to PanelCollection.Count-1 do
   begin
     xPanel := PanelCollection[I];
     if not Assigned(xPanel.Control) then
       Continue;
     if xPanel.Control.Parent <> Self then
     begin
       xPanel.Control := nil;
       Continue;
     end;

     //CHECK TAB STOP!!! -> BEFORE visible check
     if xPanel.Control is TWinControl then
       TWinControl(xPanel.Control).TabOrder := I;

     if (not xPanel.Visible and not (csDesigning in ComponentState)) then
     begin
       xPanel.Control.Visible := False;
       Continue;
     end;

     if PanelType = ptHorizontal then
     begin
       xDefaultSize := Round(xPanel.Position*ClientWidth)-xPosAbs;//MUST NOT BE CLIENT WIDTH!!!
       if not(csDesigning in ComponentState) then
       for L := I+1 to PanelCollection.Count-1 do
       begin
         if not PanelCollection[L].Visible then
           xDefaultSize := Round(PanelCollection[L].Position*ClientWidth)-xPosAbs
         else
           Break;
       end;

       xPanel.Control.SetBounds(xPosAbs, 0, xDefaultSize, ClientHeight);
       if xPanel.Control.Width <> xDefaultSize then
         xPanel.SetPositionOnlyWithCheck((xPosAbs+xPanel.Control.Width)/Max(ClientWidth, 1));//  <- Causes Stact Ovreflow when Position := ...; used

       Inc(xPosAbs, xPanel.Control.Width);
       if xPosAbs < ClientWidth then
       begin
         xSplitterItem := TSplitterListItem.CreateAdd(fSplittersList);
         xSplitterItem.fPxPosition := xPosAbs;
         xSplitterItem.fPanelIndex := I;
       end;
     end else
     begin
       xDefaultSize := Round(xPanel.Position*ClientHeight)-xPosAbs;
       if not(csDesigning in ComponentState) then
       for L := I+1 to PanelCollection.Count-1 do
       begin
         if not PanelCollection[L].Visible then
           xDefaultSize := Round(PanelCollection[L].Position*ClientHeight)-xPosAbs
         else
           Break;
       end;

       xPanel.Control.SetBounds(0, xPosAbs, ClientWidth, xDefaultSize);
       if xPanel.Control.Height <> xDefaultSize then
         xPanel.SetPositionOnlyWithCheck((xPosAbs+xPanel.Control.Height)/Max(ClientHeight, 1));//  <- Causes Stact Ovreflow when Position := ...; used

       Inc(xPosAbs, xPanel.Control.Height);
       if xPosAbs < ClientHeight then
       begin
         xSplitterItem := TSplitterListItem.CreateAdd(fSplittersList);
         xSplitterItem.fPxPosition := xPosAbs;
         xSplitterItem.fPanelIndex := I;
       end;
     end;
     Inc(xPosAbs, SplitterSize);
   end;
 finally
   fInResizeControls := False;
 end;
end;

procedure TOCustomMultiPanel.SavePositionsToRegistry(aReg: TRegIniFile);
begin
 SavePositionsToRegistry(aReg, GetSettingsSection, GetSettingsIdent);
end;

procedure TOCustomMultiPanel.SavePositionsToIniFile(aIni: TCustomIniFile;
 const aSection, aIdent: String);
var I: Integer;
begin
 for I := 0 to PanelCollection.Count-2 do
   aIni.WriteString(aSection, aIdent+'.Position'+IntToStr(I), FloatToStr(PanelCollection[I].Position));
end;

procedure TOCustomMultiPanel.SavePositionsToIniFile(aIni: TCustomIniFile);
begin
 SavePositionsToIniFile(aIni, GetSettingsSection, GetSettingsIdent);
end;

procedure TOCustomMultiPanel.SavePositionsToRegistry(aReg: TRegIniFile;
 const aSection, aIdent: String);
var I: Integer;
begin
 for I := 0 to PanelCollection.Count-2 do
   aReg.WriteString(aSection, aIdent+'.Position'+IntToStr(I), FloatToStr(PanelCollection[I].Position));
end;

procedure TOCustomMultiPanel.SetSplitterHoverColor(const Value: TColor);
begin
 if fSplitterHoverColor <> Value then
 begin
   fSplitterHoverColor := Value;
   Repaint;
 end;
end;

procedure TOCustomMultiPanel.SetMinPosition(const Value: Double);
begin
 if fMinPosition <> Value then
 begin
   fMinPosition := Value;
   if (fMinPosition < 0) then
    fMinPosition := 0;
   if (fMinPosition > 0.4) then
     fMinPosition := 0.4;
 end;
end;

procedure TOCustomMultiPanel.SetPanelCollection(
 const Value: TOMultiPanelCollection);
begin
 fPanelCollection.Assign(Value);
end;

procedure TOCustomMultiPanel.SetPanelType(const Value: TPanelType);
begin
 if fPanelType <> Value then
 begin
   fPanelType := Value;
   ResizeControls;
 end;
end;

procedure TOCustomMultiPanel.SetSplitterColor(const Value: TColor);
begin
 if fSplitterColor <> Value then
 begin
   fSplitterColor := Value;
   Repaint;
 end;
end;

procedure TOCustomMultiPanel.SetSplitterSize(const Value: Integer);
begin
 if fSplitterSize <> Value then
 begin
   fSplitterSize := Value;
   ResizeControls;
 end;
end;

{$IFNDEF FPC}
procedure TOCustomMultiPanel.WMNCHitTest(var Msg: TWMNCHitTest);
begin
 DefaultHandler(Msg);
 FHitTest := ScreenToClient(SmallPointToPoint(Msg.Pos));
end;

procedure TOCustomMultiPanel.WMSetCursor(var Message: TWMSetCursor);
var
 Cur: HCURSOR;
 SizeState: Boolean;
 I: Integer;
begin
 Cur := 0;
 if (Message.CursorWnd = Handle) and not (csDesigning in ComponentState) and (Message.HitTest = HTCLIENT) then
 begin
   if not fSizing then
     CalcSizing(Self.FHitTest.X, Self.FHitTest.Y, {%H-}SizeState, {%H-}I);

   if fSizing or SizeState then
   begin
     {$WARNINGS OFF}
     if (fPanelType = ptHorizontal) then
       Cur := Windows.LoadCursor(0, IDC_SIZEWE)
     else
     if (fPanelType = ptVertical) then
       Cur := Windows.LoadCursor(0, IDC_SIZENS);
     {$WARNINGS ON}
   end;
 end;

 if Cur <> 0 then
 begin
   Windows.SetCursor(Cur);
   Message.Result := 1;
 end else
   inherited;
end;
{$ENDIF}

{ TOMultiPanelItem }

procedure TOMultiPanelItem.AssignTo(Dest: TPersistent);
var
 xDest: TOMultiPanelItem;
begin
 if Dest is TOMultiPanelItem then
 begin
   xDest := TOMultiPanelItem(Dest);
   xDest.fPosition := Self.fPosition;
   xDest.fControl := Self.fControl;
   xDest.fVisible := Self.Visible;
 end;
end;

procedure TOMultiPanelItem.CheckPosition(var Value: Double);
begin
 if not(
    not (csLoading in MPOwner.ComponentState) and
    not (csUpdating in MPOwner.ComponentState) and
    not (csDestroying in MPOwner.ComponentState))
 then
   Exit;

 if (MPOwner = nil) or (csLoading in MPOwner.ComponentState) then//Component is loading
   Exit;

 if (Index = Collection.Count-1) then
   Value := 1;

 if (Index = 0) and (Value < MPOwner.MinPosition) then
   Value := MPOwner.MinPosition;
 if (Index = Collection.Count-2) and (Value > 1-MPOwner.MinPosition) then
   Value := 1-MPOwner.MinPosition;

 if(Index > 0) and (MPCollection[Index-1].Position+MPOwner.MinPosition > Value) then
   Value := MPCollection[Index-1].Position + MPOwner.MinPosition;
 if(Index < Collection.Count-1) and (MPCollection[Index+1].Position-MPOwner.MinPosition < Value) then
   Value := MPCollection[Index+1].Position - MPOwner.MinPosition;
end;

constructor TOMultiPanelItem.Create(ACollection: TCollection);
begin
 inherited Create(ACollection);

 MPCollection.SetDefaultPositions;

 fControl := nil;
 fVisible := true;
end;

function TOMultiPanelItem.MPCollection: TOMultiPanelCollection;
begin
 if Collection is TOMultiPanelCollection then
   Result := TOMultiPanelCollection(Collection)
 else
   Result := nil;
end;

function TOMultiPanelItem.MPOwner: TOCustomMultiPanel;
begin
 Result := MPCollection.MPOwner;
end;

procedure TOMultiPanelItem.SetControl(const Value: TControl);
begin
 fControl := Value;
 
 if not (csLoading in MPOwner.ComponentState) and
    not (csUpdating in MPOwner.ComponentState) and
    not (csDestroying in MPOwner.ComponentState) then
 begin
   if Assigned(fControl) then
     fControl.Align := alNone;

   MPOwner.ResizeControls;
 end;
end;

procedure TOMultiPanelItem.SetIndex(Value: Integer);
begin
 inherited SetIndex(Value);

 if not (csLoading in MPOwner.ComponentState) and
    not (csUpdating in MPOwner.ComponentState) and
    not (csDestroying in MPOwner.ComponentState) then
 begin
   MPCollection.SetDefaultPositions;
   MPOwner.ResizeControls;
 end;
end;

procedure TOMultiPanelItem.SetPosition(const Value: Double);
begin
 if fPosition <> Value then
 begin
   fPosition  := Value;

   if not (csLoading in MPOwner.ComponentState) and
      not (csUpdating in MPOwner.ComponentState) and
      not (csDestroying in MPOwner.ComponentState) then
   begin
     CheckPosition(fPosition);

     MPOwner.ResizeControls;
     MPOwner.DoSplitterMoved;
   end;
 end;
end;

procedure TOMultiPanelItem.SetPositionOnlyWithCheck(const Value: Double);
begin
 if fPosition <> Value then
 begin
   fPosition  := Value;

   if not (csLoading in MPOwner.ComponentState) and
      not (csUpdating in MPOwner.ComponentState) and
      not (csDestroying in MPOwner.ComponentState) then
   begin
     CheckPosition(fPosition);
   end;
 end;
end;

procedure TOMultiPanelItem.SetVisible(const Value: Boolean);
begin
 if fVisible <> Value then
 begin
   fVisible := Value;

   if not (csLoading in MPOwner.ComponentState) and
      not (csUpdating in MPOwner.ComponentState) and
      not (csDestroying in MPOwner.ComponentState) then
   begin
     if Assigned(fControl) then
       fControl.Visible := fVisible;

     MPOwner.ResizeControls;
     MPOwner.DoSplitterMoved;
   end;
 end;
end;

{ TOMultiPanelCollection }

function TOMultiPanelCollection.Add: TOMultiPanelItem;
begin
 Result := TOMultiPanelItem(inherited Add);
end;

procedure TOMultiPanelCollection.AddControl(AControl: TControl; AIndex: Integer);
var I: Integer;
 Item: TOMultiPanelItem;
begin
 if IndexOf(AControl) >= 0 then
   Exit;

 if AIndex = -1 then
 for I := 0 to Count-1 do
 if not Assigned(Items[I].Control) then
 begin
   AIndex := I;
   Break;
 end;
 if AIndex = -1 then
   Item := Add
 else
   Item := Items[AIndex];

 Item.Control := AControl;
end;

constructor TOMultiPanelCollection.Create(AOwner: TPersistent);
begin
 inherited Create(AOwner, TOMultiPanelItem);
end;

function TOMultiPanelCollection.GetAttrCount: Integer;
begin
 Result := 0;
end;

function TOMultiPanelCollection.GetItem(Index: Integer): TOMultiPanelItem;
begin
 Result := TOMultiPanelItem(inherited GetItem(Index));
end;

function TOMultiPanelCollection.IndexOf(AControl: TControl): Integer;
begin
 for Result := 0 to Count - 1 do
   if Items[Result].Control = AControl then
     Exit;
 Result := -1;
end;

procedure TOMultiPanelCollection.Notify(Item: TCollectionItem;
 Action: TCollectionNotification);
begin
 inherited;

end;

procedure TOMultiPanelCollection.RemoveControl(AControl: TControl);
var
 I: Integer;
begin
 for I := Count - 1 downto 0 do
   if Items[I].Control = AControl then
   begin
     Items[I].Control := nil;
     Delete(I);
     Exit;
   end;
end;

function TOMultiPanelCollection.MPOwner: TOCustomMultiPanel;
begin
 Result := GetOwner as TOCustomMultiPanel;
end;

procedure TOMultiPanelCollection.SetDefaultPositions;
var I: Integer;
begin
 if (MPOwner <> nil) and not (csLoading in MPOwner.ComponentState) then
 for I := 0 to Count-1 do
   TOMultiPanelItem(Items[I]).FPosition := (I+1)/Count;
end;

procedure TOMultiPanelCollection.SetItem(Index: Integer; Value: TOMultiPanelItem);
begin
 inherited SetItem(Index, Value);
end;

{ TSplitterListItem }

constructor TSplitterListItem.CreateAdd(aAddToList: TList);
begin
 inherited Create;

 fPxPosition := -1;
 fPanelIndex := -1;

 aAddToList.Add(Self);
end;

end.
Cevapla


Konu ile Alakalı Benzer Konular
Konular Yazar Yorumlar Okunma Son Yorum
  delphi 10.4.1 desteği ile rtmp live camera componenti. fkork 2 2.264 16-12-2020, Saat: 09:16
Son Yorum: RAD Coder
  Style Book componenti tüm formlarda ortak kullanma 41linea41 3 4.087 05-05-2019, Saat: 17:31
Son Yorum: mcuyan
  Sayıyı paraya çevirme dilo 6 5.771 23-02-2018, Saat: 22:17
Son Yorum: dilo
  Sayfa Çevirme Efekti delphi-x 1 3.558 17-01-2017, Saat: 08:11
Son Yorum: Fesih ARSLAN



Konuyu Okuyanlar: 1 Ziyaretçi