jvdockvcstyle.pas

East make Tray Icon in delphi

{-----------------------------------------------------------------------------
The contents of this file are subject to the Mozilla Public License
Version 1.1 (the "License"); you may not use this file except in compliance
with the License. You may obtain a copy of the License at
http://www.mozilla.org/MPL/MPL-1.1.html

Software distributed under the License is distributed on an "AS IS" basis,
WITHOUT WARRANTY OF ANY KIND, either expressed or implied. See the License for
the specific language governing rights and limitations under the License.

The Original Code is: JvDockVCStyle.pas, released on 2003-12-31.

The Initial Developer of the Original Code is luxiaoban.
Portions created by luxiaoban are Copyright (C) 2002,2003 luxiaoban.
All Rights Reserved.

Contributor(s):

You may retrieve the latest version of this file at the Project JEDI's JVCL home page,
located at http://jvcl.sourceforge.net

Known Issues:
-----------------------------------------------------------------------------}
// $Id: JvDockVCStyle.pas,v 1.28 2005/02/17 10:20:25 marquardt Exp $

unit JvDockVCStyle;

{$I jvcl.inc}

interface

uses
  {$IFDEF USEJVCL}
  {$IFDEF UNITVERSIONING}
  JclUnitVersioning,
  {$ENDIF UNITVERSIONING}
  {$ENDIF USEJVCL}
  Windows, Messages, Classes, Graphics, Controls,
  JvDockControlForm, JvDockSupportControl, JvDockTree, JvDockAdvTree;

type
  TJvDockVCConjoinServerOption = class(TJvDockBasicConjoinServerOption)
  private
    FBorderWidth: Integer;
    procedure SetBorderWidth(const Value: Integer);
  protected
    procedure ResetDockControlOption; override;
  public
    constructor Create(ADockStyle: TJvDockBasicStyle); override;
    procedure Assign(Source: TPersistent); override;
  published
    property BorderWidth: Integer read FBorderWidth write SetBorderWidth default 4;
  end;

  TJvDockVCTabServerOption = class(TJvDockBasicTabServerOption);

  TJvDockVCStyle = class(TJvDockAdvStyle)
  private
    FOldEachOtherDock: Boolean;
  protected
    procedure FormGetDockEdge(DockClient: TJvDockClient; Source: TJvDockDragDockObject;
      MousePos: TPoint; var DropAlign: TAlign); override;
    procedure FormStartDock(DockClient: TJvDockClient;
      var Source: TJvDockDragDockObject); override;
    procedure AssignConjoinServerOption(APanel: TJvDockCustomPanel); override;
    procedure CreateConjoinServerOption(var Option: TJvDockBasicConjoinServerOption); override;
    procedure CreateTabServerOption(var Option: TJvDockBasicTabServerOption); override;
  public
    constructor Create(AOwner: TComponent); override;
    function CanSetEachOtherDocked(ADockBaseControl: TJvDockBaseControl): Boolean; override;
    {$IFNDEF USEJVCL}
    function GetControlName: string; override;
    {$ENDIF !USEJVCL}
    procedure SetDockBaseControl(IsCreate: Boolean;
      DockBaseControl: TJvDockBaseControl); override;
  published
    property ConjoinServerOption;
    property TabServerOption;
  end;

  TJvDockVCSplitter = class(TJvDockSplitter)
  private
    FOldSize: Integer;
  protected
    function DoCanResize(var NewSize: Integer): Boolean; override;
    procedure Paint; override;
    procedure MouseUp(Button: TMouseButton; Shift: TShiftState;
      X, Y: Integer); override;
  public
    constructor Create(AOwner: TComponent); override;
  end;

  TJvDockVCPanel = class(TJvDockAdvPanel)
  protected
    procedure CustomGetSiteInfo(Source: TJvDockDragDockObject; Client: TControl;
      var InfluenceRect: TRect; MousePos: TPoint; var CanDock: Boolean); override;
    procedure CustomPositionDockRect(Source: TJvDockDragDockObject; X, Y: Integer); override;
    procedure CustomDockOver(Source: TJvDockDragDockObject; X, Y: Integer;
      State: TDragState; var Accept: Boolean); override;
    function CustomUnDock(Source: TJvDockDragDockObject; NewTarget: TWinControl; Client: TControl): Boolean; override;
    function GetDockEdge(MousePos: TPoint): TAlign; override;
    procedure CustomDockDrop(Source: TJvDockDragDockObject; X, Y: Integer); override;
    procedure CustomGetDockEdge(Source: TJvDockDragDockObject; MousePos: TPoint; var DropAlign: TAlign); override;
  end;

  TJvDockVCConjoinPanel = class(TJvDockConjoinPanel);
  TJvDockVCTabPageControl = class(TJvDockAdvTabPageControl);

  TJvDockZoneSizeStyle = (zssMinimum, zssNormal, zssMaximum);

  TJvDockVCZone = class(TJvDockAdvZone)
  private
    FZoneSizeStyle: TJvDockZoneSizeStyle;
    FExpandButtonDown: Boolean;
    procedure DoSetChildSizeStyle(ZoneSizeStyle: TJvDockZoneSizeStyle);
  public
    constructor Create(Tree: TJvDockTree); override;
    procedure Insert(DockSize: Integer; Hide: Boolean); override;
    procedure Remove(DockSize: Integer; Hide: Boolean); override;
    procedure InsertOrRemove(DockSize: Integer; Insert: Boolean; Hide: Boolean); override;
    procedure SetZoneSize(Size: Integer; Show: Boolean); override;
    property ZoneSizeStyle: TJvDockZoneSizeStyle read FZoneSizeStyle write FZoneSizeStyle;
    property ExpandButtonDown: Boolean read FExpandButtonDown write FExpandButtonDown;
  end;

  TJvDockVCTree = class(TJvDockAdvTree)
  private
    FExpandBtnZone: TJvDockVCZone;
  protected
    procedure WindowProc(var Msg: TMessage); override;
    procedure BeginDrag(Control: TControl;
      Immediate: Boolean; Threshold: Integer = -1); override;
    procedure ControlVisibilityChanged(Control: TControl; Visible: Boolean); override;
    function GetDockAlign(Client: TControl; var DropCtl: TControl): TAlign; override;
    function DoLButtonDown(var Msg: TWMMouse;
      var Zone: TJvDockZone; out HTFlag: Integer): Boolean; override;
    procedure DoLButtonUp(var Msg: TWMMouse;
      var Zone: TJvDockZone; out HTFlag: Integer); override;
    procedure DoMouseMove(var Msg: TWMMouse;
      var Zone: TJvDockZone; out HTFlag: Integer); override;
    procedure DoOtherHint(Zone: TJvDockZone;
      HTFlag: Integer; var HintStr: string); override;
    procedure CustomSaveZone(Stream: TStream; Zone: TJvDockZone); override;
    procedure CustomLoadZone(Stream: TStream; var Zone: TJvDockZone); override;
    procedure CalcSplitterPos; override;
    function GetDropOnZone(Orient: TDockOrientation; DockRect: TRect; var DropAlign: TAlign): TJvDockZone; virtual;
    function GetDropOnControl(Orient: TDockOrientation; Zone: TJvDockZone; DockRect: TRect;
      var DropAlign: TAlign; Control: TControl): TControl; virtual;
    function GetDockEdge(DockRect: TRect; MousePos: TPoint;
      var DropAlign: TAlign; Control: TControl): TControl; override;
    function GetLeftGrabbersHTFlag(const MousePos: TPoint;
      out HTFlag: Integer; Zone: TJvDockZone): TJvDockZone; override;
    function GetTopGrabbersHTFlag(const MousePos: TPoint;
      out HTFlag: Integer; Zone: TJvDockZone): TJvDockZone; override;
    procedure InsertControl(Control: TControl; InsertAt: TAlign; DropCtl: TControl); override;
    procedure InsertNewParent(NewZone, SiblingZone: TJvDockZone;
      ParentOrientation: TDockOrientation; InsertLast, Update: Boolean); override;
    procedure InsertSibling(NewZone, SiblingZone: TJvDockZone;
      InsertLast, Update: Boolean); override;
    procedure DrawDockGrabber(Control: TControl; const ARect: TRect); override;
    procedure DrawDockSiteRect; override;
    procedure DrawSplitterRect(const ARect: TRect); override;
    procedure GetCaptionRect(var Rect: TRect); override;
    procedure RemoveControl(Control: TControl); override;
    procedure RemoveZone(Zone: TJvDockZone; Hide: Boolean = True); override;
    procedure ResetBounds(Force: Boolean); override;
    procedure ResetDockZoneSizeStyle(Parent: TJvDockZone;
      ZoneSizeStyle: TJvDockZoneSizeStyle; Exclude: TJvDockZone);
    procedure ScaleZone(Zone: TJvDockZone); override;
    procedure ScaleChildZone(Zone: TJvDockZone); override;
    procedure ScaleSiblingZone(Zone: TJvDockZone); override;
    procedure ShiftZone(Zone: TJvDockZone); override;
    procedure SplitterMouseUp; override;
  public
    constructor Create(DockSite: TWinControl; DockZoneClass: TJvDockZoneClass; ADockStyle: TComponent); override;
  end;

  TJvDockVCDragDockObject = class(TJvDockDragDockObject)
  private
    FDockOverBrush: TBrush;
    FDockOverFrameWidth: Integer;
    FCurrentState: TDragState;
    FPreviousState: TDragState;
    FPreviousTarget: Pointer;
    procedure SetPreviousState(const Value: TDragState);
    procedure SetCurrentState(const Value: TDragState);
  protected
    procedure GetBrush_PenSize_DrawRect(
      var ABrush: TBrush; var PenSize: Integer; var DrawRect: TRect; Erase: Boolean); override;
    procedure SetDefaultBrushStyle; virtual;
  public
    constructor Create(AControl: TControl); override;
    destructor Destroy; override;
    function DragFindWindow(const Pos: TPoint): HWND; override;
    function GetDropCtl: TControl; override;
    property CurrentState: TDragState read FCurrentState write SetCurrentState;
    property PreviousState: TDragState read FPreviousState write SetPreviousState;
    property PreviousTarget: Pointer read FPreviousTarget write FPreviousTarget;
    property DockOverFrameWidth: Integer read FDockOverFrameWidth write FDockOverFrameWidth;
    property DockOverBrush: TBrush read FDockOverBrush;
  end;

{$IFDEF USEJVCL}
{$IFDEF UNITVERSIONING}
const
  UnitVersioning: TUnitVersionInfo = (
    RCSfile: '$RCSfile: JvDockVCStyle.pas,v $';
    Revision: '$Revision: 1.28 $';
    Date: '$Date: 2005/02/17 10:20:25 $';
    LogPath: 'JVCL\run'
  );
{$ENDIF UNITVERSIONING}
{$ENDIF USEJVCL}

implementation

uses
  {$IFDEF JVCLThemesEnabled}
  JvThemes,
  {$ENDIF JVCLThemesEnabled}
  Consts, SysUtils, ExtCtrls,
  JvDockSupportProc, JvDockGlobals;

type
  TWinControlAccessProtected = class(TWinControl);

const
  DefaultFrameWidth = 3;
  DefaultDockOverFrameWidth = 1;
  DefaultDockOverBrushStyle = bsSolid;

  ScaleMaximum = 9999;

  DropAlignArray: array [TDockOrientation, Boolean] of TAlign =
    ((alNone, alNone), (alTop, alBottom), (alLeft, alRight));

//=== { TJvDockVCConjoinServerOption } =======================================

constructor TJvDockVCConjoinServerOption.Create(ADockStyle: TJvDockBasicStyle);
begin
  inherited Create(ADockStyle);
  BorderWidth := 4;
end;

procedure TJvDockVCConjoinServerOption.Assign(Source: TPersistent);
begin
  if Source is TJvDockVCConjoinServerOption then
    FBorderWidth := TJvDockVCConjoinServerOption(Source).BorderWidth;
  inherited Assign(Source);
end;

procedure TJvDockVCConjoinServerOption.ResetDockControlOption;
begin
  inherited ResetDockControlOption;
end;

procedure TJvDockVCConjoinServerOption.SetBorderWidth(const Value: Integer);
begin
  FBorderWidth := Value;
end;

//=== { TJvDockVCDragDockObject } ============================================

constructor TJvDockVCDragDockObject.Create(AControl: TControl);
begin
  inherited Create(AControl);
  FrameWidth := DefaultFrameWidth;

  FDockOverFrameWidth := DefaultDockOverFrameWidth;

  FDockOverBrush := TBrush.Create;
  SetDefaultBrushStyle;

  CurrentState := dsDragEnter;
  PreviousState := CurrentState;
end;

destructor TJvDockVCDragDockObject.Destroy;
begin
  FDockOverBrush.Free;
  inherited Destroy;
end;

function TJvDockVCDragDockObject.DragFindWindow(const Pos: TPoint): HWND;
begin
  Result := 0;
end;

procedure TJvDockVCDragDockObject.GetBrush_PenSize_DrawRect(var ABrush: TBrush;
  var PenSize: Integer; var DrawRect: TRect; Erase: Boolean);
var
  DockOver: Boolean;

  procedure GetBrushAndFrameWidth;
  begin
    if DockOver then
    begin
      PenSize := FDockOverFrameWidth;
      ABrush := FDockOverBrush;
    end
    else
    begin
      PenSize := FrameWidth;
      ABrush := Brush;
    end;
  end;

begin
  DockOver :=
    ((PreviousState = dsDragEnter) and (CurrentState = dsDragMove) and (not Erase or (PreviousTarget <> nil))) or
    ((PreviousState = dsDragMove) and (CurrentState = dsDragMove)) or
    ((PreviousState = dsDragMove) and (CurrentState = dsDragLeave) and Erase);

  GetBrushAndFrameWidth;

  if (PreviousState = dsDragMove) and (CurrentState = dsDragLeave) then
  begin
    PreviousState := dsDragEnter;
    PreviousTarget := nil;
  end
  else
    PreviousTarget := DragTarget;

  if Erase then
    DrawRect := EraseDockRect
  else
    DrawRect := DockRect;
end;

function TJvDockVCDragDockObject.GetDropCtl: TControl;
begin
  Result := DropOnControl;
end;

procedure TJvDockVCDragDockObject.SetCurrentState(const Value: TDragState);
begin
  FCurrentState := Value;
end;

procedure TJvDockVCDragDockObject.SetDefaultBrushStyle;
begin
  FDockOverBrush.Bitmap := AllocPatternBitmap(clBlack, clWhite);
  FDockOverBrush.Style := bsSolid;
end;

procedure TJvDockVCDragDockObject.SetPreviousState(const Value: TDragState);
begin
  FPreviousState := Value;
end;

//=== { TJvDockVCPanel } =====================================================

procedure TJvDockVCPanel.CustomDockDrop(Source: TJvDockDragDockObject; X, Y: Integer);
begin
  if Source is TJvDockVCDragDockObject then
  begin
    TJvDockVCDragDockObject(Source).CurrentState := dsDragEnter;
    TJvDockVCDragDockObject(Source).PreviousState := dsDragEnter;
  end;

  if Source.DropOnControl <> Source.Control then
    inherited CustomDockDrop(Source, X, Y);
end;

procedure TJvDockVCPanel.CustomDockOver(Source: TJvDockDragDockObject; X, Y: Integer;
  State: TDragState; var Accept: Boolean);
var
  DropAlign: TAlign;
  VCSource: TJvDockVCDragDockObject;
  SysCaptionHeight: Integer;
  PanelScreenRect: TRect;
  R: TRect;
begin
  inherited CustomDockOver(Source, X, Y, State, Accept);

  if Source is TJvDockVCDragDockObject then
  begin
    VCSource := TJvDockVCDragDockObject(Source);
    VCSource.PreviousState := VCSource.CurrentState;
    VCSource.CurrentState := State;
  end;

  if State = dsDragMove then
  begin
    DropAlign := Source.DropAlign;