{
* This Source Code Form is subject to the terms of the Mozilla Public License,
* v. 2.0. If a copy of the MPL was not distributed with this file, You can
* obtain one at http://mozilla.org/MPL/2.0/
*
* Copyright (C) 2007-2013, Peter Johnson (www.delphidabbler.com).
*
* $Rev$
* $Date$
*
* Implements "static" classes that help to manipulate dialogue boxes:
* + TDlgHelper sets a dialogue box's parent window.
* + TDlgAligner aligns a dialogue box over a host window.
}
unit UDlgHelper;
interface
uses
// Delphi
Classes, Windows,
// Project
UBaseObjects, UStructs;
type
/// <summary>Static class that sets parent window of a dialogue box.
/// </summary>
TDlgHelper = class(TNoConstructObject)
public
/// <summary>Sets parent window of dialogue Dlg to the window associated
/// with Parent.</summary>
/// <remarks>If Parent is nil or is not recognised as a component that has
/// an associated window then either the active form or, failing that, the
/// application's main form are used.</remarks>
class procedure SetDlgParent(const Dlg, Parent: TComponent);
/// <summary>Makes the window associated with the owner of dialogue box Dlg
/// its parent window.</summary>
/// <remarks>If Dlg's owner is nil or is not recognised as a component that
/// has an associated window then either the active form or, failing that,
/// the application's main form are used.</remarks>
class procedure SetDlgParentToOwner(const Dlg: TComponent);
end;
type
/// <summary>Class that aligns dialogue boxes over host windows.</summary>
TDlgAligner = class(TNoPublicConstructObject)
strict private
var
/// <summary>Object representing window to be aligned.</summary>
fDialog: IInterface;
/// <summary>Object representing host window for alignment.</summary>
fHostWdw: IInterface;
/// <summary>Gets bounding rectangle of dialogue box to be aligned.
/// </summary>
procedure GetDialogBounds(out DlgBounds: TRectEx);
/// <summary>Offsets a dialogue's bounding rectangle relative to host
/// window.</summary>
/// <remarks>How rectangle is offset depends on whether host is a dialogue
/// box or not.</remarks>
procedure OffsetDialog(var DlgBounds: TRectEx);
/// <summary>Ensures that a bounding rectangle of a dialogue box fits
/// within screen work area.</summary>
procedure FitToWorkArea(var DlgBounds: TRectEx);
/// <summary>Adjusts position (and possibly size) of dialogue box being
/// aligned according to bounding rectangle.</summary>
procedure AdjustWindowPosition(const DlgBounds: TRectEx);
/// <summary>Aligns dialogue box relative to host.</summary>
procedure PerformAlignment;
strict protected
/// <summary>Parameterless constructor. Must not be called.</summary>
/// <remarks>Raises ENoConstructException if called.</remarks>
constructor InternalCreate; overload;
/// <summary>Constructs object for dialogue boxes and host windows that
/// both descend from TComponent.</summary>
/// <remarks>Creates appropriate window and aligner instances.</remarks>
constructor InternalCreate(const Dlg, Host: TComponent); overload;
/// <summary>Constructs object for dialogue boxes defined by window handle
/// and hosts that descend from TComponent.</summary>
/// <remarks>Creates appropriate window and aligner instances.</remarks>
constructor InternalCreate(const DlgHandle: THandle;
const Host: TComponent); overload;
public
/// <summary>Aligns a dialogue box over a host window.</summary>
/// <remarks>
/// <para>If host window is also a dialogue box then the dialogue box being
/// aligned is offset from top left corner of host. If host window is not
/// a dialogue box then dialogue box is centred over the host window.
/// </para>
/// <para>If Host is nil or does not have an associated window then the
/// dialogue box is aligned over the active form or, failing that the
/// application's main form.</para>
/// <para>Both dialogue box and host must descend from TComponent.</para>
/// </remarks>
class procedure Align(const Dlg, Host: TComponent); overload;
/// <summary>Aligns a dialogue box over a host window.</summary>
/// <remarks>
/// <para>If host window is also a dialogue box then the dialogue box being
/// aligned is offset from top left corner of host. If host window is not
/// a dialogue box then dialogue box is centred over the host window.
/// </para>
/// <para>If Host is nil or does not have an associated window then the
/// dialogue box is aligned over the active form or, failing that the
/// application's main form.</para>
/// <para>Dialogue box is identified by its window handle and host must be
/// a TComponent descendant.</para>
/// </remarks>
class procedure Align(const DlgHandle: THandle; const Host: TComponent);
overload;
/// <summary>Aligns a dialogue box window over the window associated with
/// the dialogue's Owner component.</summary>
/// <remarks>
/// <para>If owner window is also a dialogue box then the dialogue box
/// being aligned is offset from top left corner of owner window. If owner
/// window is not a dialogue box then dialogue box is centred over the
/// owner window.</para>
/// <para>If dialogue's Owner is nil or does not have an associated window
/// then the dialogue box is aligned over the active form or, failing that
/// the application's main form.</para>
/// </remarks>
class procedure AlignToOwner(const Dlg: TComponent);
end;
implementation
uses
// Delphi
SysUtils, Controls, Forms, Dialogs,
// Project
UExceptions;
type
/// <summary>Abstraction of a window that provides information about the
/// window.</summary>
IWindowInfo = interface(IInterface)
['{8E0F5AA6-88AC-4734-99C0-2253E7CF665A}']
/// <summary>Check if window is a dialogue box or not.</summary>
function IsDialog: Boolean;
/// <summary>Get window's bounding rectangle.</summary>
function BoundsRect: TRectEx;
/// <summary>Get window's handle.</summary>
function Handle: THandle;
end;
type
/// <summary>Abstraction of a window that can be aligned above another
/// window.</summary>
IAlignableWindow = interface(IInterface)
['{E65CAAEE-F782-4489-B2DF-2B8C4121825F}']
/// <summary>Get window's bounding rectangle.</summary>
function BoundsRect: TRectEx;
/// <summary>Adjust window's bounding rectangle to given value, in screen
/// co-ordinates.</summary>
/// <remarks>May ignore any change of size.</remarks>
procedure AdjustWindow(const Bounds: TRectEx);
end;
type
/// <summary>Factory class that creates IWindowInfo instances from
/// appropriate classes.</summary>
TWindowInfoFactory = class(TNoConstructObject)
public
/// <summary>Creates a suitable IWindowInfo instance for given host
/// component.</summary>
/// <remarks>If host is nil or not a TWinControl or TCommonDialog
/// descendant then active form or, failing that, application's main form
/// are substituted.</remarks>
class function Instance(const Host: TComponent): IWindowInfo;
end;
type
/// <summary>Factory class that creates IAlignableWindow instances from
/// appropriate classes.</summary>
TAlignableDialogFactory = class(TNoConstructObject)
public
/// <summary>Creates a suitable IAlignableWindow instance for a dialogue
/// box component.</summary>
/// <remarks>Dlg must be either a TCustomForm or TCommonDialog descendant.
/// </remarks>
class function Instance(const Dlg: TComponent): IAlignableWindow; overload;
/// <summary>Creates a suitable IAlignableWindow instance for a dialogue
/// box specified by its window handle.</summary>
/// <remarks>Handle must be a valid window handle.</remarks>
class function Instance(const Handle: THandle): IAlignableWindow; overload;
end;
type
/// <summary>Class that implements IAlignableWindow and IWindowInfo
/// interfaces for a form. Provides information about and positions the form.
/// </summary>
TFormWindow = class(TInterfacedObject,
IAlignableWindow, IWindowInfo
)
strict private
var
/// <summary>Reference to encapsulated form.</summary>
fForm: TCustomForm;
public
/// <summary>Sets up object for given form.</summary>
constructor Create(const Form: TCustomForm);
/// <summary>Gets form's bounding rectangle.</summary>
/// <remarks>Method of both IWindowInfo and IAlignableWindow.</remarks>
function BoundsRect: TRectEx;
/// <summary>Adjusts form to have a new bounding rectangle. If form is a
/// dialogue box then top left corner is moved to new position but size is
/// not changed.</summary>
/// <remarks>Method of IAlignableWindow.</remarks>
procedure AdjustWindow(const Bounds: TRectEx);
/// <summary>Checks if form is a dialogue box.</summary>
/// <remarks>Method of IWindowInfo.</remarks>
function IsDialog: Boolean;
/// <summary>Gets form's window handle.</summary>
/// <remarks>Method of IWindowInfo.</remarks>
function Handle: THandle;
end;
type
/// <summary>Class that implements IWindowInfo interface for a TWinControl
/// and descendants (except TCustomForm). Provides information about the
/// control.</summary>
TWinControlWindow = class(TInterfacedObject,
IWindowInfo
)
strict private
var
/// <summary>Reference to encapsulated control.</summary>
fWinCtrl: TWinControl;
public
/// <summary>Sets up object for given TWinControl.</summary>
constructor Create(const WinCtrl: TWinControl);
/// <summary>Checks if control is a dialogue box.</summary>
/// <remarks>
/// <para>Always returns False because a TWinControl is never a dialogue
/// box.</para>
/// <para>Method of IWindowInfo.</para>
/// </remarks>
function IsDialog: Boolean;
/// <summary>Gets bounding rectangle of control.</summary>
/// <remarks>Method of IWindowInfo.</remarks>
function BoundsRect: TRectEx;
/// <summary>Gets window handle associated with control.</summary>
/// <remarks>Method of IWindowInfo.</remarks>
function Handle: THandle;
end;
type
/// <summary>Class that implements IAlignableWindow and IWindowInfo
/// interfaces for a common dialogue box (except TOpenDialog). Provides
/// information about and positions the dialogue.</summary>
TCommonDialogWindow = class(TInterfacedObject,
IWindowInfo, IAlignableWindow
)
strict protected
var
/// <summary>Reference to common dialogue to be encapsulated.</summary>
fDlg: TCommonDialog;
public
/// <summary>Sets up object for given common dialogue component.</summary>
constructor Create(const Dlg: TCommonDialog);
/// <summary>Gets dialogue's bounding rectangle.</summary>
/// <remarks>Method of both IWindowInfo and IAlignableWindow.</remarks>
function BoundsRect: TRectEx;
/// <summary>Adjust common dialogue to have same top corner as bounding
/// rectangle. Any change of size is ignored.</summary>
/// <remarks>Method of IAlignableWindow.</remarks>
procedure AdjustWindow(const Bounds: TRectEx);
/// <summary>Checks if component is a dialogue box.</summary>
/// <remarks>
/// <para>Always returns True because a common dialogues are always
/// dialogues.</para>
/// <para>Method of IWindowInfo.</para>
/// </remarks>
function IsDialog: Boolean;
/// <summary>Gets dialogue box's window handle.</summary>
/// <remarks>Method of IWindowInfo.</remarks>
function Handle: THandle; virtual;
end;
type
/// <summary>Class that implements IAlignableWindow and IWindowInfo
/// interfaces for a TOpenDialog. Provides information about and positions
/// the dialogue.</summary>
TOpenDialogWindow = class(TCommonDialogWindow,
IWindowInfo, IAlignableWindow
)
public
/// <summary>Sets up object for given open dialogue component.</summary>
constructor Create(const Dlg: TOpenDialog);
/// <summary>Gets dialog box's window handle.</summary>
/// <remarks>
/// <para>Deals correctly with dialogues with explorer hooks and/or
/// customisation templates.</para>
/// <para>Method of IWindowInfo.</para>
/// </remarks>
function Handle: THandle; override;
end;
type
/// <summary>Class that implements IAlignableWindow for a window specified by
/// its window handle. Positions the dialogue.</summary>
THandleWindow = class(TInterfacedObject,
IAlignableWindow
)
strict private
var
/// <summary>Handle of dialogue box window.</summary>
fHandle: THandle;
public
/// <summary>Sets up object for given window handle.</summary>
/// <remarks>Handle must be a valid window handle.</remarks>
constructor Create(const Handle: THandle);
/// <summary>Gets window's bounding rectangle.</summary>
/// <remarks>Method of IAlignableWindow.</remarks>
function BoundsRect: TRectEx;
/// <summary>Offsets window to top left of given bouding rectangle. Size of
/// window is not changed.</summary>
/// <remarks>Method of IAlignableWindow.</remarks>
procedure AdjustWindow(const Bounds: TRectEx);
end;
type
/// <summary>Class that implements IWindowInfo for the Application object.
/// </summary>
TApplicationWindow = class(TInterfacedObject,
IWindowInfo
)
public
/// <summary>Checks if application window is a dialogue box or not.
/// </summary>
/// <remarks>
/// <para>Always returns False because application window can't be a
/// dialogue box.</para>
/// <para>Method of IWindowInfo.</para>
/// </remarks>
function IsDialog: Boolean;
/// <summary>Gets window's bounding rectangle.</summary>
/// <remarks>
/// <para>Returns bounds of work area of primary monitor.</para>
/// <para>Method of IWindowInfo.</para>
/// </remarks>
function BoundsRect: TRectEx;
/// <summary>Gets window's handle.</summary>
/// <remarks>
/// <para>Returns application window's handle.</para>
/// <para>Method of IWindowInfo.</para>
/// </remarks>
function Handle: THandle;
end;
{ TDlgHelper }
class procedure TDlgHelper.SetDlgParent(const Dlg, Parent: TComponent);
var
ParentWindow: IWindowInfo; // encapsulates parent window
DlgWindow: IWindowInfo; // encapsulates dialogue box window
begin
Assert(Assigned(Dlg), ClassName + '.SetDlgParent: Dlg is nil');
DlgWindow := TWindowInfoFactory.Instance(Dlg);
ParentWindow := TWindowInfoFactory.Instance(Parent);
SetWindowLongPtr(
DlgWindow.Handle, GWL_HWNDPARENT, LONG_PTR(ParentWindow.Handle)
);
end;
class procedure TDlgHelper.SetDlgParentToOwner(const Dlg: TComponent);
begin
SetDlgParent(Dlg, Dlg.Owner);
end;
{ TDlgAligner }
procedure TDlgAligner.AdjustWindowPosition(const DlgBounds: TRectEx);
begin
(fDialog as IAlignableWindow).AdjustWindow(DlgBounds);
end;
class procedure TDlgAligner.Align(const Dlg, Host: TComponent);
begin
Assert(Assigned(Dlg), ClassName + '.Align: Dlg is nil');
with InternalCreate(Dlg, Host) do
try
PerformAlignment;
finally
Free;
end;
end;
class procedure TDlgAligner.Align(const DlgHandle: THandle;
const Host: TComponent);
begin
Assert(IsWindow(DlgHandle), ClassName + '.Align: DlgHandle is not a window');
with InternalCreate(DlgHandle, Host) do
try
PerformAlignment;
finally
Free;
end;
end;
class procedure TDlgAligner.AlignToOwner(const Dlg: TComponent);
begin
Align(Dlg, Dlg.Owner);
end;
procedure TDlgAligner.FitToWorkArea(var DlgBounds: TRectEx);
var
WorkArea: TRectEx; // desktop work area
begin
WorkArea := Screen.MonitorFromRect(DlgBounds).WorkareaRect;
if DlgBounds.Right > WorkArea.Right then
DlgBounds.OffsetBy(WorkArea.Right - DlgBounds.Right, 0);
if DlgBounds.Left < WorkArea.Left then
DlgBounds.OffsetBy(WorkArea.Left - DlgBounds.Left, 0);
if DlgBounds.Bottom > WorkArea.Bottom then
DlgBounds.OffsetBy(0, WorkArea.Bottom - DlgBounds.Bottom);
if DlgBounds.Top < WorkArea.Top then
DlgBounds.OffsetBy(0, WorkArea.Top - DlgBounds.Top);
end;
procedure TDlgAligner.GetDialogBounds(out DlgBounds: TRectEx);
begin
DlgBounds := (fDialog as IAlignableWindow).BoundsRect;
end;
constructor TDlgAligner.InternalCreate;
begin
raise ENoConstructException.Create(
ClassName + '.InternalCreate: Constructor required parameters'
);
end;
constructor TDlgAligner.InternalCreate(const Dlg, Host: TComponent);
begin
inherited InternalCreate;
fDialog := TAlignableDialogFactory.Instance(Dlg);
fHostWdw := TWindowInfoFactory.Instance(Host);
end;
constructor TDlgAligner.InternalCreate(const DlgHandle: THandle;
const Host: TComponent);
begin
inherited InternalCreate;
fDialog := TAlignableDialogFactory.Instance(DlgHandle);
fHostWdw := TWindowInfoFactory.Instance(Host);
end;
procedure TDlgAligner.OffsetDialog(var DlgBounds: TRectEx);
const
// Offsets used when aligning over a dialogue box
cDlgOffset: TPoint = (X: 40; Y: 40);
var
HostBounds: TRectEx; // bounding rectangle of AlignCtrl in screen co-ords
begin
HostBounds := (fHostWdw as IWindowInfo).BoundsRect;
if (fHostWdw as IWindowInfo).IsDialog then
// Aligning over dialogue box: offset down and to left
DlgBounds.OffsetBy(
HostBounds.Left - DlgBounds.Left + cDlgOffset.X,
HostBounds.Top - DlgBounds.Top + cDlgOffset.Y
)
else
// Aligning over a main window: "centre" dialogue over window
DlgBounds.OffsetBy(
HostBounds.Left - DlgBounds.Left +
(HostBounds.Width - DlgBounds.Width) div 2,
HostBounds.Top - DlgBounds.Top +
(HostBounds.Height - DlgBounds.Height) div 3
)
end;
procedure TDlgAligner.PerformAlignment;
var
DlgBounds: TRectEx; // bounding rectangle of dialogue box
begin
GetDialogBounds(DlgBounds);
OffsetDialog(DlgBounds);
FitToWorkArea(DlgBounds);
AdjustWindowPosition(DlgBounds);
end;
{ TWindowInfoFactory }
class function TWindowInfoFactory.Instance(const Host: TComponent): IWindowInfo;
begin
Result := nil;
if Host is TCustomForm then
Result := TFormWindow.Create(Host as TCustomForm)
else if Host is TWinControl then
Result := TWinControlWindow.Create(Host as TWinControl)
else if Host is TOpenDialog then
Result := TOpenDialogWindow.Create(Host as TOpenDialog)
else if Host is TCommonDialog then
Result := TCommonDialogWindow.Create(Host as TCommonDialog);
if not Assigned(Result) then
begin
if Assigned(Screen.ActiveCustomForm) then
Result := TFormWindow.Create(Screen.ActiveCustomForm)
else if Assigned(Application.MainForm) then
Result := TFormWindow.Create(Application.MainForm)
else
Result := TApplicationWindow.Create;
end;
Assert(Assigned(Result), ClassName + '.Instance: Can''t create instance');
end;
{ TAlignableDialogFactory }
class function TAlignableDialogFactory.Instance(const Dlg: TComponent):
IAlignableWindow;
begin
Assert(Assigned(Dlg), ClassName + '.Instance: Dlg is nil');
if Dlg is TCustomForm then
Result := TFormWindow.Create(Dlg as TCustomForm)
else if Dlg is TOpenDialog then
Result := TOpenDialogWindow.Create(Dlg as TOpenDialog)
else if Dlg is TCommonDialog then
Result := TCommonDialogWindow.Create(Dlg as TCommonDialog)
else
raise EBug.CreateFmt(
'%0:s.Instance: Unsupported dialogue type: %1:s',
[ClassName, Dlg.ClassName]
);
end;
class function TAlignableDialogFactory.Instance(const Handle: THandle):
IAlignableWindow;
begin
Result := THandleWindow.Create(Handle);
end;
{ TFormWindow }
procedure TFormWindow.AdjustWindow(const Bounds: TRectEx);
begin
if IsDialog then
fForm.SetBounds(Bounds.Left, Bounds.Top, fForm.Width, fForm.Height)
else
fForm.BoundsRect := Bounds;
end;
function TFormWindow.BoundsRect: TRectEx;
begin
Result := fForm.BoundsRect;
end;
constructor TFormWindow.Create(const Form: TCustomForm);
begin
Assert(Assigned(Form), ClassName + '.Create: Form is nil');
inherited Create;
fForm := Form;
end;
function TFormWindow.Handle: THandle;
begin
Result := fForm.Handle;
end;
function TFormWindow.IsDialog: Boolean;
begin
Result := fForm.BorderStyle in [bsDialog, bsSizeToolWin, bsToolWindow];
end;
{ TCommonDialogWindow }
procedure TCommonDialogWindow.AdjustWindow(const Bounds: TRectEx);
begin
SetWindowPos(
Handle, // window to position
0, // only required if setting z-order
Bounds.Left, Bounds.Top, // X and Y co-ords of window
0, 0, // only required if setting size of window
SWP_NOACTIVATE or SWP_NOSIZE or SWP_NOZORDER // flags saying what to do
);
end;
function TCommonDialogWindow.BoundsRect: TRectEx;
var
Rect: TRect; // bounding rectangle
begin
GetWindowRect(Handle, Rect);
Result := Rect;
end;
constructor TCommonDialogWindow.Create(const Dlg: TCommonDialog);
begin
Assert(Assigned(Dlg), ClassName + '.Create: Dlg is nil');
Assert((ClassType <> TCommonDialogWindow) or not (Dlg is TOpenDialog),
ClassName + '.Create: Dlg cannot be a TOpenDialog');
inherited Create;
fDlg := Dlg;
end;
function TCommonDialogWindow.Handle: THandle;
begin
Result := fDlg.Handle;
end;
function TCommonDialogWindow.IsDialog: Boolean;
begin
Result := True;
end;
{ TOpenDialogWindow }
constructor TOpenDialogWindow.Create(const Dlg: TOpenDialog);
begin
inherited Create(Dlg);
end;
function TOpenDialogWindow.Handle: THandle;
begin
if NewStyleControls and
not (ofOldStyleDialog in (fDlg as TOpenDialog).Options) then
// For explorer style dialogues with explorer hooks and / or customisation
// templates the main window handle is the parent of the handle returned
// from dialogue's Handle property. Delphi always provides an explorer hook
// for new style dialogue boxes, so we can assume we need the parent handle
Result := GetParent(inherited Handle)
else
Result := inherited Handle;
end;
{ TWinControlWindow }
function TWinControlWindow.BoundsRect: TRectEx;
begin
Result.TopLeft := fWinCtrl.ClientToScreen(Point(0, 0));
Result.BottomRight := fWinCtrl.ClientToScreen(
Point(fWinCtrl.Width, fWinCtrl.Height)
);
end;
constructor TWinControlWindow.Create(const WinCtrl: TWinControl);
begin
Assert(Assigned(WinCtrl), ClassName + '.Create: WinCtrl is nil');
Assert(not (WinCtrl is TCustomForm),
ClassName + '.Create: WinCtrl cannot be a TCustomForm');
inherited Create;
fWinCtrl := WinCtrl;
end;
function TWinControlWindow.Handle: THandle;
begin
Result := fWinCtrl.Handle;
end;
function TWinControlWindow.IsDialog: Boolean;
begin
Result := False;
end;
{ THandleWindow }
procedure THandleWindow.AdjustWindow(const Bounds: TRectEx);
begin
SetWindowPos(
fHandle, // window to position
0, // only required if setting z-order
Bounds.Left, Bounds.Top, // X and Y co-ords of window
0, 0, // only required if setting size of window
SWP_NOACTIVATE or SWP_NOSIZE or SWP_NOZORDER // flags saying what to do
);
end;
function THandleWindow.BoundsRect: TRectEx;
var
Rect: TRect; // bounding rectangle
begin
GetWindowRect(fHandle, Rect);
Result := Rect;
end;
constructor THandleWindow.Create(const Handle: THandle);
begin
Assert(IsWindow(Handle), ClassName + '.Create: Handle is not a window.');
inherited Create;
fHandle := Handle;
end;
{ TApplicationWindow }
function TApplicationWindow.BoundsRect: TRectEx;
begin
Result := Screen.DesktopRect;
end;
function TApplicationWindow.Handle: THandle;
begin
Result := Application.Handle;
end;
function TApplicationWindow.IsDialog: Boolean;
begin
Result := False;
end;
end.
