jvdockvsnetstyle.pas

East make Tray Icon in delphi

  public
    constructor Create(AOwner: TComponent); override;
  end;

  TJvDockVSNETTabPageControl = class(TJvDockVIDTabPageControl)
  protected
    procedure ShowControl(AControl: TControl); override;
  public
    constructor Create(AOwner: TComponent); override;
  end;

  TJvDockVSNETDragDockObject = class(TJvDockVIDDragDockObject);

  TJvDockVSPopupPanelSplitter = class(TCustomControl)
  private
    FVSPopupPanel: TJvDockVSPopupPanel;
    FSplitWidth: Integer;
    FActiveControl: TWinControl;
    FAutoSnap: Boolean;
    FBeveled: Boolean;
    FBrush: TBrush;
    FControl: TControl;
    FDownPos: TPoint;
    FLineDC: HDC;
    FLineVisible: Boolean;
    FMinSize: NaturalNumber;
    FMaxSize: Integer;
    FNewSize: Integer;
    FOldKeyDown: TKeyEvent;
    FOldSize: Integer;
    FPrevBrush: HBRUSH;
    FResizeStyle: TResizeStyle;
    FSplit: Integer;
    FOnCanResize: TCanResizeEvent;
    FOnMoved: TNotifyEvent;
    FOnPaint: TNotifyEvent;
    procedure AllocateLineDC;
    procedure CalcSplitSize(X, Y: Integer; var NewSize, Split: Integer);
    procedure DrawLine;
    function FindControl: TControl;
    procedure FocusKeyDown(Sender: TObject; var Key: Word; Shift: TShiftState);
    procedure ReleaseLineDC;
    procedure SetBeveled(Value: Boolean);
    procedure UpdateControlSize;
    procedure UpdateSize(X, Y: Integer);
    procedure SetVSPopupPanel(Value: TJvDockVSPopupPanel);
    function GetVSChannelAlign: TAlign;
    procedure SetSplitWidth(const Value: Integer);
  protected
    procedure Notification(AComponent: TComponent;
      Operation: TOperation); override;
    function CanResize(var NewSize: Integer): Boolean; reintroduce; virtual;
    function DoCanResize(var NewSize: Integer): Boolean; virtual;
    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 Paint; override;
    procedure RequestAlign; override;
    procedure StopSizing; dynamic;
  public
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;
    property Canvas;
    { Owner of the Owner }
    property VSPopupPanel: TJvDockVSPopupPanel read FVSPopupPanel write SetVSPopupPanel;
    property SplitWidth: Integer read FSplitWidth write SetSplitWidth;
  published
    property Align default alLeft;
    property VSChannelAlign: TAlign read GetVSChannelAlign;
    property AutoSnap: Boolean read FAutoSnap write FAutoSnap default True;
    property Beveled: Boolean read FBeveled write SetBeveled default False;
    property Color;
    property Constraints;
    property MinSize: NaturalNumber read FMinSize write FMinSize default 30;
    property ParentColor;
    property ResizeStyle: TResizeStyle read FResizeStyle write FResizeStyle default rsPattern;
    property Visible;
    property OnCanResize: TCanResizeEvent read FOnCanResize write FOnCanResize;
    property OnMoved: TNotifyEvent read FOnMoved write FOnMoved;
    property OnPaint: TNotifyEvent read FOnPaint write FOnPaint;
  end;

procedure HideAllPopupPanel(ExcludeChannel: TJvDockVSChannel);
{ Disables auto-hide for ADockWindow. If ADockWindow is not auto-hidden then
  the procedures works the same as JvDockControlForm.ShowDockForm }
procedure UnAutoHideDockForm(ADockWindow: TWinControl);

var
  DefaultVSChannelClass: TJvDockVSChannelClass = nil;

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

implementation

uses
  SysUtils, Math, {AppEvnts,}
  JvDockSupportProc, JvDockGlobals;

type
  TAnimateState = (asPopup, asHide);

  TPopupPanelAnimate = class(TTimer)
  private
    FMaxWidth: Integer;
    FCurrentWidth: Integer;
    FVSChannel: TJvDockVSChannel;
    FState: TAnimateState;
  protected
    procedure Timer; override;
    procedure OnCustomTimer(Sender: TObject);
  public
    constructor Create(AOwner: TComponent); override;
    { Animates the popup of the form }
    procedure PopupForm(AVSChannel: TJvDockVSChannel; MaxWidth: Integer); virtual;
    { Animates the hiding of the form }
    procedure HideForm(AVSChannel: TJvDockVSChannel; MaxWidth: Integer); virtual;
  end;

  { (ahuser) not used:
  TJvDockAppEvents = class(TApplicationEvents)
  private
    FOldOnMessage: TMessageEvent;
    procedure NewOnMessage(var Msg: TMsg; var Handled: Boolean);
  public
    constructor Create(AOwner: TComponent); override;
  end;}

  TWinControlAccessProtected = class(TWinControl);

var
  GlobalPopupPanelAnimate: TPopupPanelAnimate = nil;
  // (ahuser) not used:
  // GlobalApplicationEvents: TJvDockAppEvents = nil;
  GlobalPopupPanelAnimateInterval: Integer = 20;
  GlobalPopupPanelAnimateMoveWidth: Integer = 20;
  GlobalPopupPanelStartAnimateInterval: Integer = 400;

//=== Local procedures =======================================================

// (p3) not used:
//  AnimateSleepTime: Integer = 500;

function PopupPanelAnimate: TPopupPanelAnimate;
begin
  if GlobalPopupPanelAnimate = nil then
    GlobalPopupPanelAnimate := TPopupPanelAnimate.Create(nil);
  Result := GlobalPopupPanelAnimate;
end;

procedure ResetChannelBlockStartOffset(Channel: TJvDockVSChannel);
var
  I: TAlign;
  LeftChannel: TJvDockVSChannel;
  CurrChannel: TJvDockVSChannel;
  OldOffset: Integer;
  LeftAlignArea: Integer;
begin
  LeftChannel := TJvDockVSNETPanel(Channel.DockServer.LeftDockPanel).VSChannel;
  if LeftChannel <> nil then
  begin
    LeftAlignArea := GetClientAlignControlArea(LeftChannel.Parent, alLeft);
    for I := alTop to alRight do
      if Assigned(Channel.DockServer.DockPanelWithAlign[I]) then
      begin
        CurrChannel := TJvDockVSNETPanel(Channel.DockServer.DockPanelWithAlign[I]).VSChannel;
        if CurrChannel.Align in [alTop, alBottom] then
        begin
          OldOffset := CurrChannel.BlockStartOffset;
          CurrChannel.BlockStartOffset := 2 + LeftAlignArea;
          if OldOffset <> CurrChannel.BlockStartOffset then
            CurrChannel.Invalidate;
        end;
      end;
  end;
end;

//=== Global procedures ======================================================

{ (ahuser) not used:
function ApplicationEvents: TJvDockAppEvents;
begin
  if GlobalApplicationEvents = nil then
    GlobalApplicationEvents := TJvDockAppEvents.Create(nil);
  Result := GlobalApplicationEvents;
end;

procedure DragControl(WinControl: TWinControl);
const
  SM = $F012;
begin
  ReleaseCapture;
  WinControl.Perform(WM_SYSCOMMAND, SM, 0);
end;
}

procedure HideAllPopupPanel(ExcludeChannel: TJvDockVSChannel);
var
  I: Integer;
  J: TAlign;
  Channel: TJvDockVSChannel;
  DockServer: TJvDockServer;
begin
  for I := 0 to JvGlobalDockManager.DockServersList.Count - 1 do
  begin
    DockServer := FindDockServer(JvGlobalDockManager.DockServersList[I]);
    if (DockServer <> nil) and (DockServer.TopDockPanel is TJvDockVSNETPanel) then
      for J := alTop to alRight do
        if Assigned(DockServer.DockPanelWithAlign[J]) then
        begin
          Channel := TJvDockVSNETPanel(DockServer.DockPanelWithAlign[J]).VSChannel;
          if (Channel <> nil) and (Channel <> ExcludeChannel) then
            Channel.HidePopupPanel(Channel.FActivePane);
        end;
  end;
end;

procedure UnAutoHideDockForm(ADockWindow: TWinControl);
var
  TmpDockWindow: TWinControl;

  procedure ShowClient(Client, DockParent: TWinControl);
  var
    ADockClient: TJvDockClient;
    I: Integer;
  begin
    if (DockParent is TJvDockableForm) and (Client <> nil) then
    begin
      with TJvDockableForm(DockParent).DockableControl do
        for I := 0 to DockClientCount - 1 do
          if DockClients[I] <> Client then
            MakeDockClientEvent(DockClients[I], True);
      if Client.HostDockSite is TJvDockCustomControl then
        TJvDockCustomControl(Client.HostDockSite).UpdateCaption(nil);
    end
    else
    begin
      ADockClient := FindDockClient(DockParent);
      if (ADockClient <> nil) and (ADockClient.DockStyle <> nil) then
      begin
        ADockClient.DockStyle.ShowDockForm(ADockClient);
        if DockParent.CanFocus then
          DockParent.SetFocus;
      end;
    end;
    if DockParent.Parent = nil then
      SetForegroundWindow(DockParent.Handle);
  end;

  function ShowDockPanel(Client: TWinControl): TWinControl;
  begin
    Result := Client;
    if Client <> nil then
      if Client.HostDockSite is TJvDockPanel then
      begin
        TJvDockPanel(Client.HostDockSite).ShowDockPanel(True, Client, sdfDockPanel);
        Result := nil;
      end;
  end;

  function ShowTabDockHost(Client: TWinControl): TWinControl;
  var
    I: Integer;
  begin
    Result := Client;
    if Client <> nil then
    begin
      ShowClient(nil, Client);
      if Client.HostDockSite is TJvDockTabPageControl then
      begin
        with TJvDockTabPageControl(Client.HostDockSite) do
          for I := 0 to Count - 1 do
            if Pages[I].Controls[0] = Client then
            begin
              Pages[I].Show;
              Break;
            end;
        if (Client.HostDockSite <> nil) and not (Client.HostDockSite is TJvDockPanel) then
        begin
          Result := Client.HostDockSite.Parent;
          ShowClient(Client, Result);
          if (Result <> nil) and (Result.HostDockSite is TJvDockTabPageControl) then
            Result := ShowTabDockHost(Result);
        end;
      end;
    end;
  end;

  function ShowConjoinDockHost(Client: TWinControl): TWinControl;
  begin
    Result := Client;
    if Client <> nil then
    begin
      ShowClient(nil, Client);
      if (Client.HostDockSite <> nil) and not (Client.HostDockSite is TJvDockPanel) then
      begin
        if Client.HostDockSite.Parent <> nil then
        begin
          Result := Client.HostDockSite.Parent;
          ShowClient(Client, Result);
          if (Result <> nil) and (Result.HostDockSite is TJvDockConjoinPanel) then
            Result := ShowConjoinDockHost(Result);
        end;
      end;
    end;
  end;

  procedure ShowPopupPanel(Client: TWinControl);
  begin
    if Client.HostDockSite is TJvDockVSPopupPanel then
      TJvDockVSPopupPanel(Client.HostDockSite).VSChannel.ShowPopupPanel(Client)
    else
    if (Client.HostDockSite <> nil) and (Client.HostDockSite.Parent <> nil) then
    begin
      if (Client.HostDockSite.Parent.HostDockSite is TJvDockVSPopupPanel) then
        TJvDockVSPopupPanel(Client.HostDockSite.Parent.HostDockSite).VSChannel.ShowPopupPanel(Client)
      else
      if Client.HostDockSite.Parent.HostDockSite is TJvDockPanel then
        Client.HostDockSite.Parent.HostDockSite.Invalidate;
    end;
  end;

begin
  TmpDockWindow := ADockWindow;
  repeat
    ADockWindow := ShowTabDockHost(ADockWindow);
    ADockWindow := ShowConjoinDockHost(ADockWindow);
    ADockWindow := ShowDockPanel(ADockWindow);
  until (ADockWindow = nil) or (ADockWindow.Parent = nil);
  ShowPopupPanel(TmpDockWindow);
end;

//=== { TJvDockAppEvents } ===================================================

{ (ahuser) not used:

constructor TJvDockAppEvents.Create(AOwner: TComponent);
begin
  inherited Create(AOwner);
  FOldOnMessage := OnMessage;
  OnMessage := NewOnMessage;
end;

procedure TJvDockAppEvents.NewOnMessage(var Msg: TMsg; var Handled: Boolean);
var
  CurrControl: TWinControl;
  DockServer: TJvDockServer;
  VSChannel: TJvDockVSChannel;
  I: Integer;
  J: TAlign;

  function CanHide: Boolean;
  begin
    Result := False;
    CurrControl := FindControl(Msg.hwnd);
    if CurrControl = nil then
      Exit;
    repeat
      if csDesigning in CurrControl.ComponentState then
      begin
        Result := False;
        Exit;
      end;
      Result := not ((CurrControl is TJvDockVSChannel) or (CurrControl is TJvDockVSPopupPanel) or (CurrControl is
        TJvDockVSPopupPanelSplitter));
      CurrControl := CurrControl.Parent;
    until (CurrControl = nil) or not Result;
  end;

begin
  if Assigned(FOldOnMessage) then
    FOldOnMessage(Msg, Handled);
  if Msg.message = WM_LBUTTONDOWN then
    if CanHide then
      for I := 0 to Screen.CustomFormCount - 1 do
      begin
        DockServer := FindDockServer(Screen.CustomForms[I]);
        if (DockServer <> nil) and (DockServer.DockStyle is TJvDockVSNetStyle) then
        begin
          if DockServer.DockPanel[0] = nil then
            Exit;
          for J := alTop to alRight do
          begin
            VSChannel := TJvDockVSNETPanel(DockServer.DockPanelWithAlign[J]).VSChannel;
            VSChannel.HidePopupPanelWithAnimate;
          end;
        end;
      end;
end;
}