// **************************************************************************************************
//
// Unit Vcl.Styles.NC
// unit for the VCL Styles Utils
// https://github.com/RRUZ/vcl-styles-utils/
//
// 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/
//
// Software distributed under the License is distributed on an "AS IS" basis, WITHOUT WARRANTY OF
// ANY KIND, either express or implied. See the License for the specific language governing rights
// and limitations under the License.
//
// The Original Code is Vcl.Styles.NC.pas.
//
// The Initial Developer of the Original Code is Rodrigo Ruz V.
// Portions created by Rodrigo Ruz V. are Copyright (C) 2014-2020 Rodrigo Ruz V.
// All Rights Reserved.
//
// **************************************************************************************************
unit Vcl.Styles.NC;
interface
{$IF RTLVersion>=24}
{$LEGACYIFEND ON}
{$IFEND}
uses
System.Classes,
System.Generics.Collections,
System.Types,
Winapi.Windows,
Winapi.Messages,
Vcl.ImgList,
System.UITypes,
Vcl.Graphics,
Vcl.Themes,
Vcl.Styles,
Vcl.Controls,
Vcl.Menus,
Vcl.StdCtrls,
Vcl.GraphUtil,
Vcl.Forms,
Vcl.Styles.Utils.Misc;
type
TNCControl = class;
// TListNCButtons = TObjectList<TNCButton>;
TNCControls = class;
TListNCControls = class(TCollection)
private
FOwner: TNCControls;
function GetItem(Index: Integer): TNCControl;
procedure SetItem(Index: Integer; Value: TNCControl);
function Add: TNCControl;
protected
function GetOwner: TPersistent; override;
public
constructor Create(AOwner: TPersistent);
destructor Destroy; override;
function AddEx<T: TCollectionItem>: T;
function Insert(Index: Integer): TNCControl;
property Items[Index: Integer]: TNCControl read GetItem write SetItem; default;
end;
TNCControls = class(TComponent)
private
FControls: TListNCControls;
FStyleServices: TCustomStyleServices;
FVisible: Boolean;
FForm: TCustomForm;
FShowSystemMenu: Boolean;
FFormBorderSize: TRect;
FImages: TCustomImageList;
FShowCaption: Boolean;
FLastPoint: TPoint;
FActiveTabControlIndex, FHotControlIndex, FPressedControlIndex, FControlUpIndex: Integer;
function GetStyleServices: TCustomStyleServices;
procedure SetStyleServices(const Value: TCustomStyleServices);
procedure SetVisible(const Value: Boolean);
function GetControl(Index: Integer): TNCControl;
function GetCount: Integer;
procedure SetImages(const Value: TCustomImageList);
procedure SetShowSystemMenu(const Value: Boolean);
procedure SetShowCaption(const Value: Boolean);
function GetActiveTabButtonIndex: Integer;
procedure SetActiveTabButtonIndex(const Value: Integer);
property FormBorderSize: TRect read FFormBorderSize write FFormBorderSize;
property Form: TCustomForm read FForm;
protected
function GetNCControlIndex(P: TPoint): Integer;
function PointInNCControl(P: TPoint): Boolean;
property LastPoint: TPoint read FLastPoint;
public
property Controls: TListNCControls read FControls;
property ControlsList[index: Integer]: TNCControl read GetControl; default;
property ControlsCount: Integer read GetCount;
property StyleServices: TCustomStyleServices read GetStyleServices write SetStyleServices;
procedure Invalidate;
constructor Create(AOwner: TComponent); override;
destructor Destroy; override;
published
property ActiveTabButtonIndex: Integer read GetActiveTabButtonIndex write SetActiveTabButtonIndex;
property LNCControl: TListNCControls read FControls;
property Visible: Boolean read FVisible write SetVisible default True;
property Images: TCustomImageList read FImages write SetImages;
property ShowSystemMenu: Boolean read FShowSystemMenu write SetShowSystemMenu default True;
property ShowCaption: Boolean read FShowCaption write SetShowCaption default True;
end;
TNCControl = class(TCollectionItem)
private
FFont: TFont;
FEnabled: Boolean;
FWidth: Integer;
FVisible: Boolean;
FTop: Integer;
FHeight: Integer;
FLeft: Integer;
FNCControls: TNCControls;
FCaption: string;
FHint: string;
FShowHint: Boolean;
FName: TComponentName;
FTag: NativeInt;
FCaptionAligmentFlags: Cardinal;
function GetEnabled: Boolean;
procedure SetEnabled(const Value: Boolean);
function GetBoundsRect: TRect;
procedure SetBoundsRect(const Value: TRect);
procedure SetHeight(const Value: Integer);
procedure SetLeft(const Value: Integer);
procedure SetTop(const Value: Integer);
procedure SetWidth(const Value: Integer);
procedure SetVisible(const Value: Boolean);
procedure SetFont(const Value: TFont);
procedure SetShowHint(const Value: Boolean);
procedure SetName(const Value: TComponentName);
procedure DrawControl(ACanvas: TCanvas; AMouseInControl, Pressed: Boolean); virtual;
protected
procedure Handle_WMNCLButtonDown(var Message: TWMNCHitMessage); virtual;
procedure Handle_WMNCLButtonUp(var Message: TWMNCHitMessage); virtual;
procedure Handle_WMNCMouseMove(var Message: TWMNCHitMessage); virtual;
published
procedure SetBounds(ALeft, ATop, AWidth, AHeight: Integer); virtual;
property Left: Integer read FLeft write SetLeft;
property Top: Integer read FTop write SetTop;
property Width: Integer read FWidth write SetWidth;
property Height: Integer read FHeight write SetHeight;
property Font: TFont read FFont write SetFont;
property Enabled: Boolean read GetEnabled write SetEnabled default True;
property Visible: Boolean read FVisible write SetVisible default True;
property Hint: string read FHint write FHint;
property ShowHint: Boolean read FShowHint write SetShowHint;
property Name: TComponentName read FName write SetName stored False;
property Tag: NativeInt read FTag write FTag default 0;
property CaptionAligmentFlags: Cardinal read FCaptionAligmentFlags write FCaptionAligmentFlags;
property Caption: string read FCaption write FCaption;
function GetAs<T>: T;
public
constructor Create(Collection: TCollection); override;
destructor Destroy; override;
property NCControls: TNCControls read FNCControls;
property BoundsRect: TRect read GetBoundsRect write SetBoundsRect;
end;
TNCButton = class(TNCControl)
public type
TNCButtonStyle = (nsPushButton, nsTranparent, nsSplitButton, nsSplitTrans, nsAlpha, nsGradient, nsTab, nsEdge, nsFrame);
TNCImageStyle = (isNormal, isGray, isGrayHot);
private
FDropDown: Boolean;
FStyle: TNCButtonStyle;
FImageAlignment: TImageAlignment;
FPressedImageIndex: TImageIndex;
FDropDownMenu: TPopupMenu;
FOnDropDownClick: TNotifyEvent;
FDisabledImageIndex: TImageIndex;
FImageMargins: TImageMargins;
FImageIndex: TImageIndex;
FHotImageIndex: TImageIndex;
FImageStyle: TNCImageStyle;
FOnClick: TNotifyEvent;
FHintWindow: THintWindow;
FAlphaColor: TColor;
FAlphaHotColor: TColor;
FFontColor: TColor;
FHotFontColor: TColor;
FStartColor: TColor;
FEndColor: TColor;
FDirection: TGradientDirection;
FDefaultFontAwesomeSize: Integer;
FUseFontAwesome: Boolean;
FAwesomeHotFontColor: TColor;
FAwesomeFontColor: TColor;
FOnClose: TNotifyEvent;
procedure DrawControl(ACanvas: TCanvas; AMouseInControl, Pressed: Boolean); override;
procedure SetStyle(const Value: TNCButtonStyle);
procedure SetDisabledImageIndex(const Value: TImageIndex);
procedure SetDropDownMenu(const Value: TPopupMenu);
procedure SetHotImageIndex(const Value: TImageIndex);
procedure SetImageAlignment(const Value: TImageAlignment);
procedure SetImageIndex(const Value: TImageIndex);
procedure SetImageMargins(const Value: TImageMargins);
procedure SetPressedImageIndex(const Value: TImageIndex);
procedure DrawControlText(Canvas: TCanvas; Details: TThemedElementDetails; const S: string; var R: TRect;
Flags: Cardinal; AColor: TColor = clNone);
procedure SetImageStyle(const Value: TNCImageStyle);
procedure ShowHintWindow(X, Y: Integer);
procedure HideHintWindow;
function GetTabIndex: Integer;
procedure SetUseFontAwesome(const Value: Boolean);
protected
procedure Handle_WMNCLButtonDown(var Message: TWMNCHitMessage); override;
procedure Handle_WMNCLButtonUp(var Message: TWMNCHitMessage); override;
procedure Handle_WMNCMouseMove(var Message: TWMNCHitMessage); override;
public
constructor Create(Collection: TCollection); override;
destructor Destroy; override;
property TabIndex: Integer read GetTabIndex;
published
property Style: TNCButtonStyle read FStyle write SetStyle;
property ImageStyle: TNCImageStyle read FImageStyle write SetImageStyle;
property DisabledImageIndex: TImageIndex read FDisabledImageIndex write SetDisabledImageIndex;
property DropDownMenu: TPopupMenu read FDropDownMenu write SetDropDownMenu;
property HotImageIndex: TImageIndex read FHotImageIndex write SetHotImageIndex;
property ImageAlignment: TImageAlignment read FImageAlignment write SetImageAlignment;
property ImageIndex: TImageIndex read FImageIndex write SetImageIndex;
property ImageMargins: TImageMargins read FImageMargins write SetImageMargins;
property PressedImageIndex: TImageIndex read FPressedImageIndex write SetPressedImageIndex;
property AlphaColor: TColor read FAlphaColor write FAlphaColor;
property AlphaHotColor: TColor read FAlphaHotColor write FAlphaHotColor;
property FontColor: TColor read FFontColor write FFontColor;
property HotFontColor: TColor read FHotFontColor write FHotFontColor;
property StartColor: TColor read FStartColor write FStartColor;
property EndColor: TColor read FEndColor write FEndColor;
property Direction: TGradientDirection read FDirection write FDirection;
property UseFontAwesome: Boolean read FUseFontAwesome write SetUseFontAwesome;
property DefaultFontAwesomeSize: Integer read FDefaultFontAwesomeSize write FDefaultFontAwesomeSize;
property AwesomeFontColor: TColor read FAwesomeFontColor write FAwesomeFontColor;
property AwesomeHotFontColor: TColor read FAwesomeHotFontColor write FAwesomeHotFontColor;
property OnDropDownClick: TNotifyEvent read FOnDropDownClick write FOnDropDownClick;
property OnClick: TNotifyEvent read FOnClick write FOnClick;
property OnClose: TNotifyEvent read FOnClose write FOnClose;
end;
TFormStyleNCControls = class(TFormStyleHook)
strict private
FNCControls: TNCControls;
private
function GetNCControls: TNCControls;
protected
procedure WMNCMouseMove(var Message: TWMNCHitMessage); message WM_NCMOUSEMOVE;
procedure WMNCLButtonDown(var Message: TWMNCHitMessage); message WM_NCLBUTTONDOWN;
procedure WMNCLButtonUp(var Message: TWMNCHitMessage); message WM_NCLBUTTONUP;
procedure WMNCLButtonDblClk(var Message: TWMNCHitMessage); message WM_NCLBUTTONDBLCLK;
procedure WMNCHitTest(var Message: TWMNCHitTest); message WM_NCHITTEST;
procedure PaintNCControls(Canvas: TCanvas; ARect: TRect);
procedure PaintNC(Canvas: TCanvas); override;
strict protected
procedure MouseLeave; override;
procedure MouseEnter; override;
procedure Restore; override;
procedure Maximize; override;
procedure Minimize; override;
public
property NCControls: TNCControls read GetNCControls;
constructor Create(AControl: TWinControl); override;
destructor Destroy; override;
end;
TFormStyleNCSettings = class
private
class var FUseThinBorder: Boolean;
public
class property UseThinBorder: Boolean read FUseThinBorder write FUseThinBorder;
end;
{
TODO
Add more buttons styles (colors, gradient, glow, link)
Add hot effects (glow, menu sel)
Add support for TAction
}
implementation
uses
DDetours,
Winapi.CommCtrl,
System.SysUtils,
System.Rtti,
Winapi.UxTheme,
Vcl.Styles.Utils.Graphics,
Vcl.Styles.FontAwesome,
Vcl.Styles.FormStyleHooks;
type
THintWindowClass = class(THintWindow);
TCustomFormClass = class(TCustomForm);
TFormStyleHookClass = class(TFormStyleHook);
TStyleHookList = TList<TStyleHookClass>;
TStyleHookDictionary = TDictionary<TClass, TStyleHookList>;
TCustomStyleEngineHelper = Class Helper for TCustomStyleEngine
public
class function GetRegisteredStyleHooks: TStyleHookDictionary;
end;
var
Trampoline_TFormStyleHook_GetBorderSize: function(Self: TFormStyleHook): TRect;
Trampoline_TFormStyleHook_GetRegion: function(Self: TFormStyleHook): HRgn;
class function TCustomStyleEngineHelper.GetRegisteredStyleHooks: TStyleHookDictionary;
begin
with Self do
Result := FRegisteredStyleHooks;
end;
function IsStyleHookRegistered(ControlClass: TClass; StyleHookClass: TStyleHookClass): Boolean;
var
List: TStyleHookList;
begin
Result := False;
if TCustomStyleEngine.GetRegisteredStyleHooks.ContainsKey(ControlClass) then
begin
List := TCustomStyleEngine.GetRegisteredStyleHooks[ControlClass];
Result := List.IndexOf(StyleHookClass) <> -1;
end;
end;
function GetRegisteredStylesHooks(ControlClass: TClass): TStyleHookList;
begin
Result := nil;
if TCustomStyleEngine.GetRegisteredStyleHooks.ContainsKey(ControlClass) then
Result := TCustomStyleEngine.GetRegisteredStyleHooks[ControlClass];
end;
{ TNCControls }
constructor TNCControls.Create(AOwner: TComponent);
begin
if not(AOwner is TCustomForm) then
Raise EAbort.Create('TNCControls only must be created in forms');
inherited Create(AOwner);
FForm := TCustomForm(AOwner);
FControls := TListNCControls.Create(Self);
FHotControlIndex := -1;
FControlUpIndex := -1;
FPressedControlIndex := -1;
FStyleServices := nil;
FImages := nil;
FVisible := True;
FShowCaption := True;
FShowSystemMenu := True;
if not IsStyleHookRegistered(AOwner.ClassType, TFormStyleNCControls) then
TStyleManager.Engine.RegisterStyleHook(AOwner.ClassType, TFormStyleNCControls);
FForm.Perform(CM_RECREATEWND, 0, 0);
FActiveTabControlIndex := 0;
end;
destructor TNCControls.Destroy;
begin
FControls.Free;
inherited;
end;
function TNCControls.GetActiveTabButtonIndex: Integer;
begin
Result := FActiveTabControlIndex;
end;
function TNCControls.GetControl(Index: Integer): TNCControl;
begin
Result := FControls[Index];
end;
function TNCControls.GetCount: Integer;
begin
Result := FControls.Count;
end;
function TNCControls.GetStyleServices: TCustomStyleServices;
begin
Result := FStyleServices;
if (Result = nil) then
Result := Vcl.Themes.StyleServices;
end;
procedure TNCControls.Invalidate;
begin
if FForm.HandleAllocated then
SendMessage(FForm.Handle, WM_NCPAINT, 0, 0);
end;
procedure TNCControls.SetActiveTabButtonIndex(const Value: Integer);
// Refactor This -> TNCButton can't be called from here
function GetMaxTabIndex: Integer;
var
i: Integer;
begin
Result := -1;
For i := 0 to (FControls.Count - 1) do
if (FControls[i] is TNCButton) and (FControls[i].GetAs<TNCButton>.Style = nsTab) then
Inc(Result);
end;
var
lmax: Integer;
begin
lmax := GetMaxTabIndex;
if (Value <> FActiveTabControlIndex) and (Value >= 0) and (lmax >= 0) and (Value <= lmax) then
begin
FActiveTabControlIndex := Value;
Invalidate;
end;
end;
procedure TNCControls.SetImages(const Value: TCustomImageList);
begin
FImages := Value;
end;
procedure TNCControls.SetShowCaption(const Value: Boolean);
begin
if Value <> FShowCaption then
begin
FShowCaption := Value;
Invalidate;
end;
end;
procedure TNCControls.SetShowSystemMenu(const Value: Boolean);
begin
if Value <> FShowSystemMenu then
begin
FShowSystemMenu := Value;
Invalidate;
end;
end;
procedure TNCControls.SetStyleServices(const Value: TCustomStyleServices);
begin
if Value <> FStyleServices then
begin
FStyleServices := Value;
if IsWindowVisible(TCustomFormClass(FForm).Handle) then
PostMessage(TCustomFormClass(FForm).Handle, CM_CUSTOMSTYLECHANGED, 0, 0)
else
SendMessage(TCustomFormClass(FForm).Handle, CM_CUSTOMSTYLECHANGED, 0, 0);
end;
end;
procedure TNCControls.SetVisible(const Value: Boolean);
begin
if Value <> FVisible then
begin
FVisible := Value;
Invalidate;
end;
end;
function TNCControls.GetNCControlIndex(P: TPoint): Integer;
var
i: Integer;
begin
Result := -1;
for i := 0 to FControls.Count - 1 do
if FControls[i].Visible and PtInRect(FControls[i].BoundsRect, P) then
Exit(i);
end;
function TNCControls.PointInNCControl(P: TPoint): Boolean;
begin
Result := GetNCControlIndex(P) >= 0;
end;
{ TNCButton }
constructor TNCButton.Create(Collection: TCollection);
begin
inherited Create(Collection);
FDropDown := False;
FImageMargins := TImageMargins.Create;
FDisabledImageIndex := -1;
FPressedImageIndex := -1;
FImageIndex := -1;
FUseFontAwesome := False;
FDefaultFontAwesomeSize := 16; // 16
FHotImageIndex := -1;
FImageAlignment := iaLeft;
FStyle := nsPushButton;
FImageStyle := isNormal;
FDropDownMenu := nil;
FOnDropDownClick := nil;
FOnClick := nil;
FOnClose := nil;
FHintWindow := THintWindow.Create(nil);
FAlphaColor := FNCControls.StyleServices.GetSystemColor(clBtnFace);
FDirection := TGradientDirection.gdHorizontal;
FFontColor := StyleServices.GetSystemColor(clBtnText);
FHotFontColor := StyleServices.GetSystemColor(clHighlight);
FAwesomeFontColor := StyleServices.GetSystemColor(clBtnText);
FAwesomeHotFontColor := StyleServices.GetSystemColor(clHighlight);
end;
destructor TNCButton.Destroy;
begin
FreeAndNil(FHintWindow);
FreeAndNil(FImageMargins);
inherited;
end;
procedure TNCButton.DrawControlText(Canvas: TCanvas; Details: TThemedElementDetails; const S: string; var R: TRect;
Flags: Cardinal; AColor: TColor = clNone);
var
ThemeTextColor: TColor;
TextFormat: TTextFormatFlags;
LStyleServices: TCustomStyleServices;
begin
Canvas.Font := Font;
LStyleServices := NCControls.StyleServices;
TextFormat := TTextFormatFlags(Flags);
if LStyleServices.GetElementColor(Details, ecTextColor, ThemeTextColor) then
begin
if AColor <> clNone then
Canvas.Font.Color := AColor
else
Canvas.Font.Color := ThemeTextColor;
LStyleServices.DrawText(Canvas.Handle, Details, S, R, TextFormat, Canvas.Font.Color);
end
else
begin
Canvas.Refresh;
LStyleServices.DrawText(Canvas.Handle, Details, S, R, TextFormat);
end;
end;
function TNCButton.GetTabIndex: Integer;
var
i: Integer;
begin
Result := -1;
for i := 0 to NCControls.ControlsCount - 1 do
if NCControls.LNCControl[i] is TNCButton then
begin
if NCControls.LNCControl[i].GetAs<TNCButton>.Style = nsTab then
Inc(Result);
if NCControls[i] = Self then
Break;
end;
end;
procedure DoDrawGrayImage(hdcDst: HDC; himl: HIMAGELIST; ImageIndex, X, Y: Integer);
var
pimldp: TImageListDrawParams;
begin
FillChar(pimldp, SizeOf(pimldp), #0);
pimldp.fState := ILS_SATURATE;
pimldp.cbSize := SizeOf(pimldp);
pimldp.hdcDst := hdcDst;
pimldp.himl := himl;
pimldp.i := ImageIndex;
pimldp.X := X;
pimldp.Y := Y;
ImageList_DrawIndirect(@pimldp);
end;
procedure FrameRect(ACanvas: TCanvas; const R: TRect; Color1, Color2: TColor);
begin
with ACanvas do
begin
Pen.Color := Color1;
PolyLine([Point(R.Left, R.Bottom), Point(R.Left, R.Top), Point(R.Right, R.Top)]);
Pen.Color := Color2;
PolyLine([Point(R.Right, R.Top), Point(R.Right, R.Bottom), Point(R.Left, R.Bottom)]);
end;
end;
procedure TNCButton.Handle_WMNCLButtonDown(var Message: TWMNCHitMessage);
var
i: Integer;
begin
// process click on buttton with the nstab style
if (FNCControls.FPressedControlIndex >= 0) and (FNCControls[FNCControls.FPressedControlIndex] is TNCButton) and
(FNCControls[FNCControls.FPressedControlIndex].GetAs<TNCButton>.Style = nsTab) then
begin
FNCControls.FActiveTabControlIndex := -1;
For i := 0 to FNCControls.FPressedControlIndex do
if (FNCControls[i] is TNCButton) and (FNCControls[i].GetAs<TNCButton>.Style = nsTab) then
Inc(FNCControls.FActiveTabControlIndex);
end;
end;
procedure TNCButton.Handle_WMNCLButtonUp(var Message: TWMNCHitMessage);
var
LNCButtton: TNCButton;
LRect: TRect;
P: TPoint;
i, X, Y: Integer;
begin
i := FNCControls.FControlUpIndex;
if ((Message.HitTest = HTTOP) or (Message.HitTest = HTCAPTION)) and (i >= 0) and
(NCControls.LNCControl[i] is TNCButton) then
begin
LRect := Rect(0, 0, 0, 0);
if (NCControls <> nil) then
begin
LRect := NCControls.LNCControl[i].BoundsRect;
LRect.Left := LRect.Right - 15;
end;
P := NCControls.LastPoint;
LNCButtton := NCControls.LNCControl[i].GetAs<TNCButton>;
if (LNCButtton.Enabled) and Assigned(LNCButtton.FOnDropDownClick) and
(LNCButtton.Style in [nsSplitButton, nsSplitTrans]) and PtInRect(LRect, P) then
LNCButtton.FOnDropDownClick(LNCButtton)
else if (LNCButtton.Enabled) and Assigned(LNCButtton.FDropDownMenu) and PtInRect(LRect, P) then
begin
X := NCControls.Form.Left + LNCButtton.BoundsRect.Left;
if NCControls.Form.BiDiMode = TBiDiMode.bdRightToLeft then
Inc(X, 250);
Y := NCControls.Form.Top + LNCButtton.BoundsRect.Bottom;
// OutputDebugString(PChar(Format('Popup X %d Y %d', [X, Y])));
LNCButtton.FDropDownMenu.Popup(X, Y);
// if LNCButtton.FDropDownMenu.BiDiMode = bdLeftToRight then
// LNCButtton.FDropDownMenu.Popup(X, Y)
// else
// begin
// LPoint := Point(X, Y);
// TrackPopupMenu(LNCButtton.FDropDownMenu.Handle, TPM_RIGHTALIGN or TPM_TOPALIGN, LPoint.X, LPoint.Y, 0, PopupList.Window, nil);
// end;
end
else if (LNCButtton.Style = nsTab) and Assigned(LNCButtton.FOnClose) and PtInRect(LRect, P) then
begin
if LNCButtton.ShowHint then
LNCButtton.HideHintWindow();
if not IsIconic(TCustomFormClass(NCControls.Form).Handle) then
LNCButtton.FOnClose(LNCButtton);
end
else if (LNCButtton.Enabled) and Assigned(LNCButtton.FOnClick) then
begin
if LNCButtton.ShowHint then
LNCButtton.HideHintWindow();
if not IsIconic(TCustomFormClass(NCControls.Form).Handle) then
LNCButtton.FOnClick(LNCButtton);
end;
end;
end;
procedure TNCButton.Handle_WMNCMouseMove(var Message: TWMNCHitMessage);
var
P: TPoint;
i: Integer;
begin
P := NCControls.LastPoint;
if ((Message.HitTest = HTTOP) or (Message.HitTest = HTCAPTION) or (not NCControls.ShowSystemMenu and
(Message.HitTest = HTSYSMENU))) and NCControls.PointInNCControl(P) then
begin
if NCControls.FHotControlIndex <> NCControls.GetNCControlIndex(P) then
begin
NCControls.FHotControlIndex := NCControls.GetNCControlIndex(P);
for i := 0 to NCControls.ControlsCount - 1 do
if (NCControls.FHotControlIndex <> i) and NCControls.LNCControl[i].ShowHint and
(NCControls.LNCControl[i] is TNCButton) then
NCControls.LNCControl[i].GetAs<TNCButton>.HideHintWindow();
if not IsIconic(TCustomFormClass(NCControls.Form).Handle) then
if NCControls.LNCControl[NCControls.FHotControlIndex].ShowHint and
(NCControls.LNCControl[NCControls.FHotControlIndex] is TNCButton) then
NCControls.LNCControl[NCControls.FHotControlIndex].GetAs<TNCButton>.ShowHintWindow(Message.XCursor,
Message.YCursor);
NCControls.Invalidate();
end;
end
else
// if NCControls.FHotControlIndex <> -1 then
begin
for i := 0 to NCControls.ControlsCount - 1 do
if NCControls.LNCControl[i].ShowHint and (NCControls.LNCControl[i] is TNCButton) then
NCControls.LNCControl[i].GetAs<TNCButton>.HideHintWindow();
NCControls.FHotControlIndex := -1;
NCControls.Invalidate();
// OutputDebugString(PChar('Ping '+FormatDateTime('hh:nn:ss.zzz', Now)));
end;
end;
procedure TNCButton.DrawControl(ACanvas: TCanvas; AMouseInControl, Pressed: Boolean);
var
Details, Details2: TThemedElementDetails;
ButtonRect, DrawRect, LRect, LRectAwesome: TRect;
IW, IH, IX, IY: Integer;
SaveIndex: Integer;
X, Y, i, LImgIndex: Integer;
BCaption: String;
LStyleServices: TCustomStyleServices;
LColor, LColor1, LColor2, ThemeTextColor: TColor;
FButtonState: TThemedWindow;
function GetBorderSize: TRect;
var
Size: TSize;
Details: TThemedElementDetails;
Detail: TThemedWindow;
begin
Result := Rect(0, 0, 0, 0);
if NCControls.Form.BorderStyle = bsNone then
Exit;
if not LStyleServices.Available then
Exit;
{ caption height }
if (NCControls.Form.BorderStyle <> bsToolWindow) and (NCControls.Form.BorderStyle <> bsSizeToolWin) then
Detail := twCaptionActive
else
Detail := twSmallCaptionActive;
Details := LStyleServices.GetElementDetails(Detail);
LStyleServices.GetElementSize(0, Details, esActual, Size);
Result.Top := Size.cy;
{ left border width }
if (NCControls.Form.BorderStyle <> bsToolWindow) and (NCControls.Form.BorderStyle <> bsSizeToolWin) then
Detail := twFrameLeftActive
else
Detail := twSmallFrameLeftActive;
Details := LStyleServices.GetElementDetails(Detail);
LStyleServices.GetElementSize(0, Details, esActual, Size);
Result.Left := Size.cx;
{ right border width }
if (NCControls.Form.BorderStyle <> bsToolWindow) and (NCControls.Form.BorderStyle <> bsSizeToolWin) then
Detail := twFrameRightActive
else
Detail := twSmallFrameRightActive;
Details := LStyleServices.GetElementDetails(Detail);
LStyleServices.GetElementSize(0, Details, esActual, Size);
Result.Right := Size.cx;
{ bottom border height }
if (FNCControls.Form.BorderStyle <> bsToolWindow) and (NCControls.Form.BorderStyle <> bsSizeToolWin) then
Detail := twFrameBottomActive
else
Detail := twSmallFrameBottomActive;
Details := LStyleServices.GetElementDetails(Detail);
LStyleServices.GetElementSize(0, Details, esActual, Size);
Result.Bottom := Size.cy;
end;
function GetTopOffset: Integer;
var
P: TPoint;
begin
P.X := NCControls.Form.Left + NCControls.Form.Width div 2;
P.Y := NCControls.Form.Top + NCControls.Form.Height div 2;
Result := Screen.MonitorFromPoint(P).WorkareaRect.Top;
if NCControls.Form.Top < Result then
Result := Result - NCControls.Form.Top
else
Result := 0;
end;
procedure CorrectRightButtonRect(var AButtonRect: TRect);
var
TopOffset, RightOffset: Integer;
BS: TRect;
begin
if (NCControls.Form.WindowState = wsMaximized) and (TCustomFormClass(NCControls.Form).FormStyle <> fsMDIChild) and
(ButtonRect.Width > 0) then
begin
BS := GetBorderSize;
TopOffset := GetTopOffset;
RightOffset := -BS.Right;
if ButtonRect.Top < TopOffset then
begin
TopOffset := TopOffset - ButtonRect.Top;
OffsetRect(ButtonRect, RightOffset, TopOffset);
TopOffset := ButtonRect.Bottom - BS.Top;
if TopOffset > 0 then
OffsetRect(ButtonRect, 0, -TopOffset);
end;
end;
end;
procedure CorrectLeftButtonRect(var AButtonRect: TRect);
var
TopOffset, LeftOffset: Integer;
BS: TRect;
begin
if (NCControls.Form.WindowState = wsMaximized) and (TCustomFormClass(NCControls.Form).FormStyle <> fsMDIChild) and
(ButtonRect.Width > 0) then
begin
BS := GetBorderSize;
TopOffset := GetTopOffset;
LeftOffset := BS.Left;
if ButtonRect.Top < TopOffset then
begin
TopOffset := TopOffset - ButtonRect.Top;
OffsetRect(ButtonRect, LeftOffset, TopOffset);
TopOffset := ButtonRect.Bottom - BS.Top;
if TopOffset > 0 then
OffsetRect(ButtonRect, 0, -TopOffset);
end;
end;
end;
function GetButtonCloseRect(Index: Integer): TRect;
var
Details: TThemedElementDetails;
R, ButtonR: TRect;
begin
R := BoundsRect;
if R.Left < 0 then
Exit;
if Index = TabIndex then
InflateRect(R, 0, 2);
Result := R;
Details := LStyleServices.GetElementDetails(twSmallCloseButtonNormal);
if not LStyleServices.GetElementContentRect(0, Details, Result, ButtonR) then
ButtonR := Rect(0, 0, 0, 0);
Result.Left := Result.Right - (ButtonR.Width) - 3;
Result.Width := ButtonR.Width;
Result.Top := Result.Top + 3;
end;
begin
LStyleServices := NCControls.StyleServices;
BCaption := FCaption;
LImgIndex := FImageIndex;
if not Enabled then
begin
Details := LStyleServices.GetElementDetails(tbPushButtonDisabled);
if DisabledImageIndex <> -1 then
LImgIndex := FDisabledImageIndex;
end
else if Pressed then
begin
Details := LStyleServices.GetElementDetails(tbPushButtonPressed);
if PressedImageIndex <> -1 then
LImgIndex := FPressedImageIndex;
end
else if AMouseInControl then
begin
Details := LStyleServices.GetElementDetails(tbPushButtonHot);
if HotImageIndex <> -1 then
LImgIndex := FHotImageIndex;
end
else if Enabled then
Details := LStyleServices.GetElementDetails(tbPushButtonNormal);
DrawRect := BoundsRect; // ClientRect;
if FStyle = nsTab then
if (NCControls.Form.WindowState = wsMaximized) and (TCustomFormClass(NCControls.Form).FormStyle <> fsMDIChild) then
else
DrawRect.Height := NCControls.FormBorderSize.Top - DrawRect.Top;
if FStyle = nsAlpha then
begin
LColor := ACanvas.Pen.Color;
try
ButtonRect := DrawRect;
{$IF CompilerVersion > 23}
if not StyleServices.HasElementFixedPosition(Details) then
{$IFEND}
CorrectLeftButtonRect(ButtonRect);
DrawRect := ButtonRect;
ACanvas.Pen.Color := clNone;
if (AMouseInControl) and (FAlphaHotColor <> clNone) then
begin
LRect := DrawRect;
InflateRect(LRect, -1, -1);
AlphaBlendFillCanvas(ACanvas.Handle, FAlphaHotColor, LRect, 96);
ACanvas.Pen.Color := FAlphaHotColor;
end
else if FAlphaColor <> clNone then
begin
LRect := DrawRect;
InflateRect(LRect, -1, -1);
AlphaBlendFillCanvas(ACanvas.Handle, FAlphaColor, LRect, 96);
ACanvas.Pen.Color := FAlphaColor;
end;
if ACanvas.Pen.Color <> clNone then
begin
LRect := DrawRect;
ACanvas.Brush.Style := bsSolid;
ACanvas.Rectangle(LRect.Left, LRect.Top, LRect.Left + LRect.Width, LRect.Top + LRect.Height);
end;
finally
ACanvas.Pen.Color := LColor;
end;
end
else if FStyle = nsGradient then
begin
LColor := ACanvas.Pen.Color;
try
ButtonRect := DrawRect;
{$IF CompilerVersion > 23} if not StyleServices.HasElementFixedPosition(Details) then {$IFEND}
CorrectLeftButtonRect(ButtonRect);
DrawRect := ButtonRect;
if AMouseInControl then
GradientFillCanvas(ACanvas, FEndColor, FStartColor, DrawRect, FDirection)
else
GradientFillCanvas(ACanvas, FStartColor, FEndColor, DrawRect, FDirection);
if AMouseInControl then
ACanvas.Pen.Color := FEndColor
else
ACanvas.Pen.Color := FStartColor;
ACanvas.Brush.Style := bsClear;
LRect := DrawRect;
ACanvas.Rectangle(LRect.Left, LRect.Top, LRect.Left + LRect.Width, LRect.Top + LRect.Height);
finally
ACanvas.Pen.Color := LColor;
end;
end
else if FStyle = nsTab then
begin
// if AMouseInControl then
// Details := LStyleServices.GetElementDetails(ttTabItemHot)
// else
if Pressed or (NCControls.FActiveTabControlIndex = TabIndex) then
Details := LStyleServices.GetElementDetails(ttTabItemSelected)
else if not Enabled then
Details := LStyleServices.GetElementDetails(ttTabItemDisabled)
else
Details := LStyleServices.GetElementDetails(ttTabItemNormal);
ButtonRect := DrawRect;
{$IF CompilerVersion > 23} if not StyleServices.HasElementFixedPosition(Details) then {$IFEND}
CorrectLeftButtonRect(ButtonRect);
DrawRect := ButtonRect;
LStyleServices.DrawElement(ACanvas.Handle, Details, DrawRect);
if @FOnClose <> nil then
begin
if AMouseInControl then
FButtonState := twSmallCloseButtonHot
else if Index = TabIndex then
FButtonState := twSmallCloseButtonNormal
else
FButtonState := twSmallCloseButtonDisabled;
Details2 := LStyleServices.GetElementDetails(FButtonState);
LRect := GetButtonCloseRect(Index);
if LRect.Bottom - LRect.Top > 0 then
LStyleServices.DrawElement(ACanvas.Handle, Details2, LRect);
end;
end
else if FStyle = nsEdge then
begin
ButtonRect := DrawRect;
{$IF CompilerVersion > 23} if not StyleServices.HasElementFixedPosition(Details) then {$IFEND}
CorrectLeftButtonRect(ButtonRect);
DrawRect := ButtonRect;
LStyleServices.DrawElement(ACanvas.Handle, LStyleServices.GetElementDetails(tbGroupBoxNormal), DrawRect);
end
else if FStyle = nsFrame then
begin
ButtonRect := DrawRect;
{$IF CompilerVersion > 23} if not StyleServices.HasElementFixedPosition(Details) then {$IFEND}
CorrectLeftButtonRect(ButtonRect);
DrawRect := ButtonRect;
LColor1 := LStyleServices.GetSystemColor(clBtnShadow);
LColor2 := LStyleServices.GetSystemColor(clBtnHighlight);
LColor := LColor1;
LColor1 := LColor2;
with DrawRect do
FrameRect(ACanvas, Rect(Left + 1, Top + 1, Left + Width - 1, Top + Height - 1), LColor1, LColor2);
LColor2 := LColor;
LColor1 := LColor;
with DrawRect do
FrameRect(ACanvas, Rect(Left + 0, Top + 0, Left + Width - 2, Top + Height - 2), LColor1, LColor2);
end
else if Enabled and (FStyle in [ { nsTranparent, } nsSplitTrans]) and AMouseInControl then
begin
ButtonRect := DrawRect;
{$IF CompilerVersion > 23} if not StyleServices.HasElementFixedPosition(Details) then {$IFEND}
CorrectLeftButtonRect(ButtonRect);
DrawRect := ButtonRect;
Details := LStyleServices.GetElementDetails(tmMenuBarItemHot);
LStyleServices.DrawElement(ACanvas.Handle, Details, DrawRect);
end
else if (FStyle <> nsTranparent) and (FStyle <> nsSplitTrans) then
begin
ButtonRect := DrawRect;
{$IF CompilerVersion > 23} if not StyleServices.HasElementFixedPosition(Details) then {$IFEND}
CorrectLeftButtonRect(ButtonRect);
DrawRect := ButtonRect;
LStyleServices.DrawElement(ACanvas.Handle, Details, DrawRect);
end;
if FUseFontAwesome and (LImgIndex >= 0) then
begin
IW := FDefaultFontAwesomeSize;
IH := FDefaultFontAwesomeSize;
ButtonRect := DrawRect;
{$IF CompilerVersion > 23} if not StyleServices.HasElementFixedPosition(Details) then {$IFEND}
CorrectLeftButtonRect(ButtonRect);
DrawRect := ButtonRect;
if FStyle = nsSplitButton then
IX := DrawRect.Left + ((DrawRect.Width - 15) - IW) div 2
else
IX := DrawRect.Left + (DrawRect.Width - IW) div 2;
IY := DrawRect.Top + (DrawRect.Height - IH) div 2;
case FImageAlignment of
iaLeft:
begin
IX := DrawRect.Left + 2;
Inc(IX, ImageMargins.Left);
Inc(IY, ImageMargins.Top);
Dec(IY, ImageMargins.Bottom);
Inc(DrawRect.Left, { IX + } IW + ImageMargins.Right);
end;
iaRight:
begin
IX := DrawRect.Right - IW - 2;
Dec(IX, ImageMargins.Right);
Dec(IX, ImageMargins.Left);
Inc(IY, ImageMargins.Top);
Dec(IY, ImageMargins.Bottom);
DrawRect.Right := IX;
end;
iaTop:
begin
IX := { DrawRect.Left + } ( { DrawRect.Width - } IW) div 2;
Inc(IX, ImageMargins.Left);
Dec(IX, ImageMargins.Right);
IY := DrawRect.Top + 2;
Inc(IY, ImageMargins.Top);
Inc(DrawRect.Top, IY + IH + ImageMargins.Bottom);
end;
iaBottom:
begin
IX := { DrawRect.Left + } ( { DrawRect.Width - } IW) div 2;
Inc(IX, ImageMargins.Left);
Dec(IX, ImageMargins.Right);
IY := DrawRect.Bottom - IH - 2;
Dec(IY, ImageMargins.Bottom);
Dec(IY, ImageMargins.Top);
DrawRect.Bottom := IY;
end;
end;
// if AMouseInControl then
// Dec(IY);
LRectAwesome := Rect(IX, IY, IX + IW + 2, IY + IH + 2);
end
else if (LImgIndex >= 0) and (NCControls.FImages <> nil) and (NCControls.FImages.Handle <> 0) and
ImageList_GetIconSize(NCControls.FImages.Handle, IW, IH) then
begin
ButtonRect := DrawRect;
{$IF CompilerVersion > 23} if not StyleServices.HasElementFixedPosition(Details) then {$IFEND}
CorrectLeftButtonRect(ButtonRect);
DrawRect := ButtonRect;
IX := DrawRect.Left + (DrawRect.Width - IW) div 2;
IY := DrawRect.Top + (DrawRect.Height - IH) div 2;
case FImageAlignment of
iaLeft:
begin
IX := DrawRect.Left + 2;
Inc(IX, ImageMargins.Left);
Inc(IY, ImageMargins.Top);
Dec(IY, ImageMargins.Bottom);
Inc(DrawRect.Left, { IX + } IW + ImageMargins.Right);
end;
iaRight:
begin
IX := DrawRect.Right - IW - 2;
Dec(IX, ImageMargins.Right);
Dec(IX, ImageMargins.Left);
Inc(IY, ImageMargins.Top);
Dec(IY, ImageMargins.Bottom);
DrawRect.Right := IX;
end;
iaTop:
begin
IX := { DrawRect.Left + } ( { DrawRect.Width - } IW) div 2;
Inc(IX, ImageMargins.Left);
Dec(IX, ImageMargins.Right);
IY := DrawRect.Top + 2;
Inc(IY, ImageMargins.Top);
Inc(DrawRect.Top, IY + IH + ImageMargins.Bottom);
end;
iaBottom:
begin
IX := { DrawRect.Left + } ( { DrawRect.Width - } IW) div 2;
Inc(IX, ImageMargins.Left);
Dec(IX, ImageMargins.Right);
IY := DrawRect.Bottom - IH - 2;
Dec(IY, ImageMargins.Bottom);
Dec(IY, ImageMargins.Top);
DrawRect.Bottom := IY;
end;
end;
// if AMouseInControl then
// Dec(IY);
if Enabled and ((FImageStyle = isNormal) or ((FImageStyle = isGrayHot) and AMouseInControl)) then
ImageList_Draw(NCControls.FImages.Handle, LImgIndex, ACanvas.Handle, IX, IY, ILD_NORMAL)
else
DoDrawGrayImage(ACanvas.Handle, NCControls.FImages.Handle, LImgIndex, IX, IY);
end;
if (FStyle in [nsSplitButton, nsSplitTrans]) then
begin
LRect := DrawRect;
Dec(DrawRect.Right, 15);
if AMouseInControl then
ThemeTextColor := FHotFontColor
else
ThemeTextColor := FFontColor;
if Length(BCaption) > 0 then
begin
ButtonRect := DrawRect;
{$IF CompilerVersion > 23} if not StyleServices.HasElementFixedPosition(Details) then {$IFEND}
CorrectLeftButtonRect(ButtonRect);
DrawRect := ButtonRect;
DrawControlText(ACanvas, Details, BCaption, DrawRect, DT_VCENTER or DT_CENTER, ThemeTextColor);
end;
if FUseFontAwesome and (FImageIndex >= 0) then
begin
if AMouseInControl then
ThemeTextColor := FAwesomeHotFontColor
else
ThemeTextColor := FAwesomeFontColor;
FontAwesome.DrawChar(ACanvas.Handle, LImgIndex, LRectAwesome, FDefaultFontAwesomeSize, ThemeTextColor, 0,
FImageAlignment);
end;
if FDropDown then
begin
Details := LStyleServices.GetElementDetails(tbPushButtonPressed);
SaveIndex := SaveDC(ACanvas.Handle);
try
IntersectClipRect(ACanvas.Handle, Width - 15, 0, Width, Height);
DrawRect := Rect(Width - 30, 0, Width, Height);
ButtonRect := DrawRect;
{$IF CompilerVersion > 23} if not StyleServices.HasElementFixedPosition(Details) then {$IFEND}
CorrectLeftButtonRect(ButtonRect);
DrawRect := ButtonRect;
LStyleServices.DrawElement(ACanvas.Handle, Details, DrawRect);
finally
RestoreDC(ACanvas.Handle, SaveIndex);
end;
end;
with ACanvas do
begin
LColor := Pen.Color;
// draw split line
if FStyle <> nsSplitTrans then
begin
Pen.Color := LStyleServices.GetSystemColor(clBtnShadow);
MoveTo(LRect.Right - 15, LRect.Top + 3);
LineTo(LRect.Right - 15, LRect.Bottom - 3);
if Enabled then
Pen.Color := LStyleServices.GetSystemColor(clBtnHighlight)
else
Pen.Color := Font.Color;
MoveTo(LRect.Right - 14, LRect.Top + 3);
LineTo(LRect.Right - 14, LRect.Bottom - 3);
end;
// draw arrow
if (FStyle = nsSplitTrans) and (not AMouseInControl) then
Pen.Color := FFontColor
else
Pen.Color := FHotFontColor;
X := LRect.Right - 8;
Y := LRect.Top + (Height div 2) + 1;
for i := 3 downto 0 do
begin
MoveTo(X - i, Y - i);
LineTo(X + i + 1, Y - i);
end;
Pen.Color := LColor;
end;
end
else
begin
if AMouseInControl then
ThemeTextColor := FHotFontColor
else
ThemeTextColor := FFontColor;
// ButtonRect := DrawRect;
// if not StyleServices.HasElementFixedPosition(Details) then
// CorrectLeftButtonRect(ButtonRect);
// DrawRect := ButtonRect;
if (FCaptionAligmentFlags and DT_CENTER) <> DT_CENTER then
DrawRect.Left := DrawRect.Left + 5;
DrawControlText(ACanvas, Details, BCaption, DrawRect, FCaptionAligmentFlags, ThemeTextColor);
if FUseFontAwesome and (FImageIndex >= 0) then
begin
if AMouseInControl then
ThemeTextColor := FAwesomeHotFontColor
else
ThemeTextColor := FAwesomeFontColor;
// InflateRect(LRectAwesome, 2, 2);
FontAwesome.DrawChar(ACanvas.Handle, LImgIndex, LRectAwesome, FDefaultFontAwesomeSize, ThemeTextColor, 0,
FImageAlignment);
end;
end;
end;
procedure TNCButton.SetDisabledImageIndex(const Value: TImageIndex);
begin
FDisabledImageIndex := Value;
end;
procedure TNCButton.SetDropDownMenu(const Value: TPopupMenu);
begin
FDropDownMenu := Value;
end;
procedure TNCButton.SetHotImageIndex(const Value: TImageIndex);
begin
FHotImageIndex := Value;
end;
procedure TNCButton.SetImageAlignment(const Value: TImageAlignment);
begin
FImageAlignment := Value;
end;
procedure TNCButton.SetImageIndex(const Value: TImageIndex);
begin
FImageIndex := Value;
end;
procedure TNCButton.SetImageMargins(const Value: TImageMargins);
begin
FImageMargins := Value;
end;
procedure TNCButton.SetImageStyle(const Value: TNCImageStyle);
begin
FImageStyle := Value;
end;
procedure TNCButton.SetPressedImageIndex(const Value: TImageIndex);
begin
FPressedImageIndex := Value;
end;
procedure TNCButton.SetStyle(const Value: TNCButtonStyle);
begin
FStyle := Value;
end;
procedure TNCButton.SetUseFontAwesome(const Value: Boolean);
begin
FUseFontAwesome := Value;
end;
procedure TNCButton.ShowHintWindow(X, Y: Integer);
begin
if (THintWindowClass(FHintWindow).WindowHandle = 0) then
begin
FHintWindow.Visible := False;
FHintWindow.Color := NCControls.StyleServices.GetSystemColor(clInfoBk);
FHintWindow.Font.Color := NCControls.StyleServices.GetSystemColor(clInfoText);
FHintWindow.Caption := Hint;
FHintWindow.ParentWindow := Application.Handle;
FHintWindow.Left := NCControls.FForm.Left + BoundsRect.Left;
FHintWindow.Top := NCControls.FForm.Top + BoundsRect.Bottom + 5;
FHintWindow.Show;
end;
end;
procedure TNCButton.HideHintWindow;
begin
if THintWindowClass(FHintWindow).WindowHandle <> 0 then
FHintWindow.ReleaseHandle;
end;
{ TFormStyleNCControls }
constructor TFormStyleNCControls.Create(AControl: TWinControl);
begin
inherited;
FNCControls := nil;
end;
destructor TFormStyleNCControls.Destroy;
begin
inherited;
end;
function TFormStyleNCControls.GetNCControls: TNCControls;
var
i: Integer;
begin
Result := FNCControls;
if Result = nil then
for i := 0 to Form.ComponentCount - 1 do
if Form.Components[i] is TNCControls then
begin
FNCControls := TNCControls(Form.Components[i]);
Exit(FNCControls);
end;
end;
procedure TFormStyleNCControls.Maximize;
begin
if Handle <> 0 then
begin
FNCControls.FPressedControlIndex := -1;
FNCControls.FHotControlIndex := -1;
end;
inherited;
end;
procedure TFormStyleNCControls.Minimize;
begin
if Handle <> 0 then
begin
FNCControls.FPressedControlIndex := -1;
FNCControls.FHotControlIndex := -1;
end;
inherited;
end;
procedure TFormStyleNCControls.MouseEnter;
begin
inherited;
FNCControls.FPressedControlIndex := -1;
end;
procedure TFormStyleNCControls.MouseLeave;
begin
inherited;
if FNCControls.FHotControlIndex <> -1 then
begin
FNCControls.FHotControlIndex := -1;
FNCControls.FPressedControlIndex := -1;
if Form.BorderStyle <> bsNone then
InvalidateNC;
end;
end;
procedure TFormStyleNCControls.Restore;
begin
FNCControls.FPressedControlIndex := -1;
FNCControls.FHotControlIndex := -1;
inherited;
end;
procedure TFormStyleNCControls.PaintNCControls(Canvas: TCanvas; ARect: TRect);
var
LCurrent: Integer;
LNCControl: TNCControl;
begin
if (NCControls <> nil) and (NCControls.ControlsCount > 0) and (NCControls.Visible)
{ and (NCControls.Form.Visible) } and (NCControls.FControls.UpdateCount = 0) then
for LCurrent := 0 to NCControls.ControlsCount - 1 do
begin
LNCControl := NCControls.Controls[LCurrent];
if LNCControl.Visible and (LNCControl.BoundsRect.Right <= ARect.Right) then
LNCControl.DrawControl(Canvas, FNCControls.FHotControlIndex = LCurrent,
FNCControls.FPressedControlIndex = LCurrent);
end
else;
end;
procedure TFormStyleNCControls.WMNCHitTest(var Message: TWMNCHitTest);
var
P: TPoint;
LHitTest: Integer;
begin
if (NCControls <> nil) and (NCControls.Visible) then
begin
{$IF CompilerVersion>23}
if (TStyleManager.FormBorderStyle = fbsCurrentStyle) and (seBorder in Form.StyleElements) then
{$IFEND}
begin
P := _NormalizePoint(Point(Message.XPos, Message.YPos));
LHitTest := _GetHitTest(P);
if (LHitTest <> HTSYSMENU) or ((LHitTest = HTSYSMENU) and NCControls.ShowSystemMenu) then
begin
Message.Result := LHitTest;
Handled := True;
end
else
begin
Message.Result := WM_NULL;
Handled := True;
end;
end;
end
else
inherited;
end;
// Avoid maximize or restore on DblClk
procedure TFormStyleNCControls.WMNCLButtonDblClk(var Message: TWMNCHitMessage);
var
P: TPoint;
begin
if (NCControls <> nil) and (NCControls.Visible) then
begin
P := _NormalizePoint(Point(Message.XCursor, Message.YCursor));
if ((Message.HitTest = HTTOP) or (Message.HitTest = HTCAPTION)) and NCControls.PointInNCControl(P) then
begin
Message.Result := 0;
Message.Msg := WM_NULL;
Handled := True;
Exit;
end;
end;
inherited;
end;
procedure TFormStyleNCControls.WMNCLButtonDown(var Message: TWMNCHitMessage);
var
P: TPoint;
begin
inherited;
{$IF CompilerVersion>23}
if not((TStyleManager.FormBorderStyle = fbsCurrentStyle) and (seBorder in Form.StyleElements)) then
begin
Handled := False;
Exit;
end;
{$IFEND}
if (NCControls <> nil) and (NCControls.Visible) then
begin
P := _NormalizePoint(Point(Message.XCursor, Message.YCursor));
if ((Message.HitTest = HTTOP) or (Message.HitTest = HTCAPTION)) and FNCControls.PointInNCControl(P) then
begin
FNCControls.FPressedControlIndex := FNCControls.GetNCControlIndex(P);
if (FNCControls.FPressedControlIndex >= 0) then
FNCControls[FNCControls.FPressedControlIndex].Handle_WMNCLButtonDown(Message);
InvalidateNC;
Message.Result := 0;
Message.Msg := WM_NULL;
Handled := True;
end;
end;
end;
procedure TFormStyleNCControls.WMNCLButtonUp(var Message: TWMNCHitMessage);
var
OldIndex: Integer;
P: TPoint;
LNCControl: TNCControl;
begin
inherited;
if (NCControls <> nil) and (NCControls.Visible) then
begin
{$IF CompilerVersion>23}
if not((TStyleManager.FormBorderStyle = fbsCurrentStyle) and (seBorder in Form.StyleElements)) then
begin
Handled := False;
Exit;
end;
{$IFEND}
OldIndex := FNCControls.FPressedControlIndex;
if FNCControls.FPressedControlIndex <> -1 then
begin
FNCControls.FPressedControlIndex := -1;
InvalidateNC;
end;
if OldIndex = FNCControls.FHotControlIndex then
begin
P := _NormalizePoint(Point(Message.XCursor, Message.YCursor));
NCControls.FLastPoint := P;
NCControls.FControlUpIndex := NCControls.GetNCControlIndex(P);
if NCControls.FControlUpIndex > -1 then
begin
LNCControl := NCControls.Controls[NCControls.FControlUpIndex];
LNCControl.Handle_WMNCLButtonUp(Message);
end;
end;
Message.Result := 0;
Message.Msg := WM_NULL;
Handled := True;
end;
end;
procedure TFormStyleNCControls.WMNCMouseMove(var Message: TWMNCHitMessage);
var
i: Integer;
LNCControl: TNCControl;
begin
inherited;
if (NCControls <> nil) and (NCControls.Visible) then
begin
NCControls.FLastPoint := _NormalizePoint(Point(Message.XCursor, Message.YCursor));
// OutputDebugString(PChar(Format('Message.HitTest %d XCursor %d YCursor %d P.X %d P.Y %d',[Message.HitTest, Message.XCursor, Message.YCursor, P.X, P.Y])));
{$IF CompilerVersion>23}
if not((TStyleManager.FormBorderStyle = fbsCurrentStyle) and (seBorder in Form.StyleElements)) then
begin
Handled := False;
Exit;
end;
{$IFEND}
i := NCControls.GetNCControlIndex(NCControls.LastPoint);
if (i >= 0) then
begin
LNCControl := NCControls[i];
LNCControl.Handle_WMNCMouseMove(Message);
end
else
// notify to the controls the mouse leave.
if NCControls.ControlsCount > 0 then
begin
LNCControl := NCControls[0];
LNCControl.Handle_WMNCMouseMove(Message);
end;
end;
end;
procedure TFormStyleNCControls.PaintNC(Canvas: TCanvas);
var
Details, CaptionDetails, IconDetails: TThemedElementDetails;
Detail: TThemedWindow;
R, R1, R2, DrawRect, ButtonRect, TextRect: TRect;
CaptionBuffer: TBitmap;
FButtonState: TThemedWindow;
TextFormat: TTextFormat;
LText: string;
LStyleServices: TCustomStyleServices;
TextTopOffset: Integer;
function GetTopOffset: Integer;
var
P: TPoint;
begin
P.X := Form.Left + Form.Width div 2;
P.Y := Form.Top + Form.Height div 2;
Result := Screen.MonitorFromPoint(P).WorkareaRect.Top;
if Form.Top < Result then
Result := Result - Form.Top
else
Result := 0;
end;
procedure CorrectRightButtonRect(var AButtonRect: TRect);
var
TopOffset, RightOffset: Integer;
BS: TRect;
begin
if (Form.WindowState = wsMaximized) and (TCustomFormClass(Form).FormStyle <> fsMDIChild) and (ButtonRect.Width > 0)
then
begin
BS := _GetBorderSize;
TopOffset := GetTopOffset;
RightOffset := -BS.Right;
if ButtonRect.Top < TopOffset then
begin
TopOffset := TopOffset - ButtonRect.Top;
OffsetRect(ButtonRect, RightOffset, TopOffset);
TopOffset := ButtonRect.Bottom - BS.Top;
if TopOffset > 0 then
OffsetRect(ButtonRect, 0, -TopOffset);
end;
end;
end;
procedure CorrectLeftButtonRect(var AButtonRect: TRect);
var
TopOffset, LeftOffset: Integer;
BS: TRect;
begin
if (Form.WindowState = wsMaximized) and (TCustomFormClass(Form).FormStyle <> fsMDIChild) and (ButtonRect.Width > 0)
then
begin
BS := _GetBorderSize;
TopOffset := GetTopOffset;
LeftOffset := BS.Left;
if ButtonRect.Top < TopOffset then
begin
TopOffset := TopOffset - ButtonRect.Top;
OffsetRect(ButtonRect, LeftOffset, TopOffset);
TopOffset := ButtonRect.Bottom - BS.Top;
if TopOffset > 0 then
OffsetRect(ButtonRect, 0, -TopOffset);
end;
end;
end;
begin
if Form.BorderStyle = bsNone then
begin
MainMenuBarHookPaint(Canvas);
Exit;
end;
if NCControls <> nil then
LStyleServices := NCControls.StyleServices
else
LStyleServices := StyleServices;
_FCloseButtonRect := Rect(0, 0, 0, 0);
_FMaxButtonRect := Rect(0, 0, 0, 0);
_FMinButtonRect := Rect(0, 0, 0, 0);
_FHelpButtonRect := Rect(0, 0, 0, 0);
_FSysMenuButtonRect := Rect(0, 0, 0, 0);
_FCaptionRect := Rect(0, 0, 0, 0);
if not LStyleServices.Available then
Exit;
R := _GetBorderSize;
if (NCControls <> nil) then
NCControls.FormBorderSize := R;
if (Form.BorderStyle <> bsToolWindow) and (Form.BorderStyle <> bsSizeToolWin) then
begin
if _FFormActive then
Detail := twCaptionActive
else
Detail := twCaptionInActive
end
else
begin
if _FFormActive then
Detail := twSmallCaptionActive
else
Detail := twSmallCaptionInActive
end;
CaptionBuffer := TBitmap.Create;
try
CaptionBuffer.SetSize(_FWidth, R.Top);
// caption
DrawRect := Rect(0, 0, CaptionBuffer.Width, CaptionBuffer.Height);
Details := LStyleServices.GetElementDetails(Detail);
LStyleServices.DrawElement(CaptionBuffer.Canvas.Handle, Details, DrawRect);
TextRect := DrawRect;
CaptionDetails := Details;
TextTopOffset := 3;
// icon
if ((NCControls <> nil) and NCControls.ShowSystemMenu) and (biSystemMenu in TCustomFormClass(Form).BorderIcons) and
(Form.BorderStyle <> bsDialog) and (Form.BorderStyle <> bsToolWindow) and (Form.BorderStyle <> bsSizeToolWin) then
begin
IconDetails := LStyleServices.GetElementDetails(twSysButtonNormal);
if not LStyleServices.GetElementContentRect(0, IconDetails, DrawRect, ButtonRect) then
ButtonRect := Rect(0, 0, 0, 0);
R1 := ButtonRect;
{$IF CompilerVersion > 23}
if not StyleServices.HasElementFixedPosition(Details) then
begin
{$IFEND}
CorrectLeftButtonRect(ButtonRect);
TextTopOffset := Abs(R1.Top - ButtonRect.Top);
if TextTopOffset > R.Top then
TextTopOffset := 3;
{$IF CompilerVersion > 23}
end
else
TextTopOffset := 0;
{$IFEND}
R1 := Rect(0, 0, GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON));
RectVCenter(R1, ButtonRect);
if ButtonRect.Width > 0 then
DrawIconEx(CaptionBuffer.Canvas.Handle, R1.Left, R1.Top, _GetIconFast.Handle, 0, 0, 0, 0, DI_NORMAL);
Inc(TextRect.Left, ButtonRect.Width + 5);
_FSysMenuButtonRect := ButtonRect;
end
else
Inc(TextRect.Left, R.Left);
// buttons
if (biSystemMenu in TCustomFormClass(Form).BorderIcons) then
begin
if (Form.BorderStyle <> bsToolWindow) and (Form.BorderStyle <> bsSizeToolWin) then
begin
if (_FPressedButton = HTCLOSE) and (_FHotButton = HTCLOSE) then
FButtonState := twCloseButtonPushed
else if _FHotButton = HTCLOSE then
FButtonState := twCloseButtonHot
else if _FFormActive then
FButtonState := twCloseButtonNormal
else
FButtonState := twCloseButtonDisabled;
end
else
begin
if (_FPressedButton = HTCLOSE) and (_FHotButton = HTCLOSE) then
FButtonState := twSmallCloseButtonPushed
else if _FHotButton = HTCLOSE then
FButtonState := twSmallCloseButtonHot
else if _FFormActive then
FButtonState := twSmallCloseButtonNormal
else
FButtonState := twSmallCloseButtonDisabled;
end;
Details := LStyleServices.GetElementDetails(FButtonState);
if not LStyleServices.GetElementContentRect(0, Details, DrawRect, ButtonRect) then
ButtonRect := Rect(0, 0, 0, 0);
{$IF CompilerVersion > 23} if not StyleServices.HasElementFixedPosition(Details) then {$IFEND}
CorrectRightButtonRect(ButtonRect);
LStyleServices.DrawElement(CaptionBuffer.Canvas.Handle, Details, ButtonRect);
if ButtonRect.Left > 0 then
TextRect.Right := ButtonRect.Left;
_FCloseButtonRect := ButtonRect;
end;
if (biMaximize in TCustomFormClass(Form).BorderIcons) and (biSystemMenu in TCustomFormClass(Form).BorderIcons) and
(Form.BorderStyle <> bsDialog) and (Form.BorderStyle <> bsToolWindow) and (Form.BorderStyle <> bsSizeToolWin) then
begin
if Form.WindowState = wsMaximized then
begin
if (_FPressedButton = HTMAXBUTTON) and (_FHotButton = HTMAXBUTTON) then
FButtonState := twRestoreButtonPushed
else if _FHotButton = HTMAXBUTTON then
FButtonState := twRestoreButtonHot
else if _FFormActive then
FButtonState := twRestoreButtonNormal
else
FButtonState := twRestoreButtonDisabled;
end
else
begin
if (_FPressedButton = HTMAXBUTTON) and (_FHotButton = HTMAXBUTTON) then
FButtonState := twMaxButtonPushed
else if _FHotButton = HTMAXBUTTON then
FButtonState := twMaxButtonHot
else if _FFormActive then
FButtonState := twMaxButtonNormal
else
FButtonState := twMaxButtonDisabled;
end;
Details := LStyleServices.GetElementDetails(FButtonState);
if not LStyleServices.GetElementContentRect(0, Details, DrawRect, ButtonRect) then
ButtonRect := Rect(0, 0, 0, 0);
{$IF CompilerVersion > 23} if not StyleServices.HasElementFixedPosition(Details) then {$IFEND}
CorrectRightButtonRect(ButtonRect);
if ButtonRect.Width > 0 then
LStyleServices.DrawElement(CaptionBuffer.Canvas.Handle, Details, ButtonRect);
if ButtonRect.Left > 0 then
TextRect.Right := ButtonRect.Left;
_FMaxButtonRect := ButtonRect;
end;
if (biMinimize in TCustomFormClass(Form).BorderIcons) and (biSystemMenu in TCustomFormClass(Form).BorderIcons) and
(Form.BorderStyle <> bsDialog) and (Form.BorderStyle <> bsToolWindow) and (Form.BorderStyle <> bsSizeToolWin) then
begin
if (_FPressedButton = HTMINBUTTON) and (_FHotButton = HTMINBUTTON) then
FButtonState := twMinButtonPushed
else if _FHotButton = HTMINBUTTON then
FButtonState := twMinButtonHot
else if _FFormActive then
FButtonState := twMinButtonNormal
else
FButtonState := twMinButtonDisabled;
Details := LStyleServices.GetElementDetails(FButtonState);
if not LStyleServices.GetElementContentRect(0, Details, DrawRect, ButtonRect) then
ButtonRect := Rect(0, 0, 0, 0);
{$IF CompilerVersion > 23} if not StyleServices.HasElementFixedPosition(Details) then {$IFEND}
CorrectRightButtonRect(ButtonRect);
if ButtonRect.Width > 0 then
LStyleServices.DrawElement(CaptionBuffer.Canvas.Handle, Details, ButtonRect);
if ButtonRect.Left > 0 then
TextRect.Right := ButtonRect.Left;
_FMinButtonRect := ButtonRect;
end;
if (biHelp in TCustomFormClass(Form).BorderIcons) and (biSystemMenu in TCustomFormClass(Form).BorderIcons) and
((not(biMaximize in TCustomFormClass(Form).BorderIcons) and not(biMinimize in TCustomFormClass(Form).BorderIcons))
or (Form.BorderStyle = bsDialog)) then
begin
if (_FPressedButton = HTHELP) and (_FHotButton = HTHELP) then
FButtonState := twHelpButtonPushed
else if _FHotButton = HTHELP then
FButtonState := twHelpButtonHot
else if _FFormActive then
FButtonState := twHelpButtonNormal
else
FButtonState := twHelpButtonDisabled;
Details := LStyleServices.GetElementDetails(FButtonState);
if not LStyleServices.GetElementContentRect(0, Details, DrawRect, ButtonRect) then
ButtonRect := Rect(0, 0, 0, 0);
{$IF CompilerVersion > 23} if not StyleServices.HasElementFixedPosition(Details) then {$IFEND}
CorrectRightButtonRect(ButtonRect);
if ButtonRect.Width > 0 then
LStyleServices.DrawElement(CaptionBuffer.Canvas.Handle, Details, ButtonRect);
if ButtonRect.Left > 0 then
TextRect.Right := ButtonRect.Left;
_FHelpButtonRect := ButtonRect;
end;
R2 := TextRect;
if (NCControls <> nil) and (NCControls.ControlsCount > 0) and (NCControls.Visible) then
Inc(TextRect.Left, NCControls.Controls[NCControls.ControlsCount - 1].BoundsRect.Right - NCControls.Controls[0]
.BoundsRect.Left + 10);
// text
if (NCControls <> nil) and (IsIconic(TCustomFormClass(Form).Handle) or (NCControls.ShowCaption)) then
begin
TextFormat := [tfLeft, tfSingleLine, tfVerticalCenter];
if Control.UseRightToLeftReading then
Include(TextFormat, tfRtlReading);
LText := Text;
if (TCustomFormClass(Form).WindowState = wsMaximized) and (TCustomFormClass(Form).FormStyle <> fsMDIChild) and
(TextTopOffset <> 0) and (biSystemMenu in TCustomFormClass(Form).BorderIcons) then
begin
Inc(TextRect.Left, R.Left);
MoveWindowOrg(CaptionBuffer.Canvas.Handle, 0, TextTopOffset);
LStyleServices.DrawText(CaptionBuffer.Canvas.Handle, CaptionDetails, LText, TextRect, TextFormat);
MoveWindowOrg(CaptionBuffer.Canvas.Handle, 0, -TextTopOffset);
end
else
LStyleServices.DrawText(CaptionBuffer.Canvas.Handle, CaptionDetails, LText, TextRect, TextFormat);
end;
if (NCControls <> nil) and (NCControls.ControlsCount > 0) and (NCControls.Visible) then
Dec(TextRect.Left, NCControls.Controls[NCControls.ControlsCount - 1].BoundsRect.Right - NCControls.Controls[0]
.BoundsRect.Left + 10);
_FCaptionRect := TextRect;
if not IsIconic(TCustomFormClass(Form).Handle) then
PaintNCControls(CaptionBuffer.Canvas, R2);
// caption
Canvas.Draw(0, 0, CaptionBuffer);
finally
CaptionBuffer.Free;
end;
// menubar
MainMenuBarHookPaint(Canvas);
// left
if (Form.BorderStyle <> bsToolWindow) and (Form.BorderStyle <> bsSizeToolWin) then
begin
if _FFormActive then
Detail := twFrameLeftActive
else
Detail := twFrameLeftInActive
end
else
begin
if _FFormActive then
Detail := twSmallFrameLeftActive
else
Detail := twSmallFrameLeftInActive
end;
DrawRect := Rect(0, R.Top, R.Left, _FHeight - R.Bottom);
Details := LStyleServices.GetElementDetails(Detail);
if DrawRect.Bottom - DrawRect.Top > 0 then
LStyleServices.DrawElement(Canvas.Handle, Details, DrawRect);
// right
if (Form.BorderStyle <> bsToolWindow) and (Form.BorderStyle <> bsSizeToolWin) then
begin
if _FFormActive then
Detail := twFrameRightActive
else
Detail := twFrameRightInActive
end
else
begin
if _FFormActive then
Detail := twSmallFrameRightActive
else
Detail := twSmallFrameRightInActive
end;
DrawRect := Rect(_FWidth - R.Right, R.Top, _FWidth, _FHeight - R.Bottom);
Details := LStyleServices.GetElementDetails(Detail);
if DrawRect.Bottom - DrawRect.Top > 0 then
LStyleServices.DrawElement(Canvas.Handle, Details, DrawRect);
// Bottom
if (Form.BorderStyle <> bsToolWindow) and (Form.BorderStyle <> bsSizeToolWin) then
begin
if _FFormActive then
Detail := twFrameBottomActive
else
Detail := twFrameBottomInActive
end
else
begin
if _FFormActive then
Detail := twSmallFrameBottomActive
else
Detail := twSmallFrameBottomInActive
end;
DrawRect := Rect(0, _FHeight - R.Bottom, _FWidth, _FHeight);
Details := LStyleServices.GetElementDetails(Detail);
if DrawRect.Bottom - DrawRect.Top > 0 then
LStyleServices.DrawElement(Canvas.Handle, Details, DrawRect);
end;
// This custom GetBorderSize method is necessary to allow to the NC controls use a custom Style in the title and border area.
function Detour_TFormStyleHook_GetBorderSize(Self: TFormStyleHook): TRect;
var
Size: TSize;
Details: TThemedElementDetails;
Detail: TThemedWindow;
LStylesServices: TCustomStyleServices;
LForm: TCustomForm;
begin
if not(ExecutingInMainThread) then
Exit(Trampoline_TFormStyleHook_GetBorderSize(Self));
if (Self is TFormStyleNCControls) and (TFormStyleNCControls(Self).NCControls <> nil) then
begin
LStylesServices := TFormStyleNCControls(Self).NCControls.StyleServices;
LForm := TFormStyleHookClass(Self)._Form;
Result := Rect(0, 0, 0, 0);
if LForm.BorderStyle = bsNone then
Exit;
if not LStylesServices.Available then
Exit;
{ caption height }
if (LForm.BorderStyle <> bsToolWindow) and (LForm.BorderStyle <> bsSizeToolWin) then
Detail := twCaptionActive
else
Detail := twSmallCaptionActive;
Details := LStylesServices.GetElementDetails(Detail);
LStylesServices.GetElementSize(0, Details, esActual, Size);
Result.Top := Size.cy;
{ left border width }
if (LForm.BorderStyle <> bsToolWindow) and (LForm.BorderStyle <> bsSizeToolWin) then
Detail := twFrameLeftActive
else
Detail := twSmallFrameLeftActive;
Details := LStylesServices.GetElementDetails(Detail);
LStylesServices.GetElementSize(0, Details, esActual, Size);
Result.Left := Size.cx;
{ right border width }
if (LForm.BorderStyle <> bsToolWindow) and (LForm.BorderStyle <> bsSizeToolWin) then
Detail := twFrameRightActive
else
Detail := twSmallFrameRightActive;
Details := LStylesServices.GetElementDetails(Detail);
LStylesServices.GetElementSize(0, Details, esActual, Size);
Result.Right := Size.cx;
{ bottom border height }
if (LForm.BorderStyle <> bsToolWindow) and (LForm.BorderStyle <> bsSizeToolWin) then
Detail := twFrameBottomActive
else
Detail := twSmallFrameBottomActive;
Details := LStylesServices.GetElementDetails(Detail);
LStylesServices.GetElementSize(0, Details, esActual, Size);
Result.Bottom := Size.cy;
// //Result.Top := Result.Top + 5;
// Result.Left := 0;
// Result.Right := 0;
// Result.Bottom := 0;
if TFormStyleNCSettings.UseThinBorder then
begin
// Don't use 0, because the native resize feature is lost if the border is 0.
Result.Left := 1;
Result.Right := 1;
Result.Bottom := 1;
end;
end
else
Exit(Trampoline_TFormStyleHook_GetBorderSize(Self));
end;
// This custom GetRegion method is necessary to allow to the NC controls use a custom Style in the title and border area.
function Detour_TFormStyleHook_GetRegion(Self: TFormStyleHook): HRgn;
var
R: TRect;
Details: TThemedElementDetails;
Detail: TThemedWindow;
LStylesServices: TCustomStyleServices;
LForm: TCustomForm;
begin
if not(ExecutingInMainThread) then
Exit(Trampoline_TFormStyleHook_GetRegion(Self));
if (Self is TFormStyleNCControls) and (TFormStyleNCControls(Self).NCControls <> nil) then
begin
LStylesServices := TFormStyleNCControls(Self).NCControls.StyleServices;
LForm := TFormStyleHookClass(Self)._Form;
Result := 0;
if not LStylesServices.Available then
Exit;
R := Rect(0, 0, TFormStyleHookClass(Self)._FWidth, TFormStyleHookClass(Self)._FHeight);
if (LForm.BorderStyle <> bsToolWindow) and (LForm.BorderStyle <> bsSizeToolWin) then
Detail := twCaptionActive
else
Detail := twSmallCaptionActive;
Details := LStylesServices.GetElementDetails(Detail);
LStylesServices.GetElementRegion(Details, R, Result);
end
else
Exit(Trampoline_TFormStyleHook_GetRegion(Self));
end;
{ TListNCButtons }
function TListNCControls.Add: TNCControl;
begin
Result := TNCControl(inherited Add);
end;
function RttiMethodInvokeEx(const MethodName: string; RttiType: TRttiType; Instance: TValue;
const Args: array of TValue): TValue;
var
Found: Boolean;
LMethod: TRttiMethod;
LIndex: Integer;
LParams: TArray<TRttiParameter>;
begin
Result := nil;
LMethod := nil;
Found := False;
for LMethod in RttiType.GetMethods do
if SameText(LMethod.Name, MethodName) then
begin
LParams := LMethod.GetParameters;
if Length(Args) = Length(LParams) then
begin
Found := True;
for LIndex := 0 to Length(LParams) - 1 do
if LParams[LIndex].ParamType.Handle <> Args[LIndex].TypeInfo then
begin
Found := False;
Break;
end;
end;
if Found then
Break;
end;
if (LMethod <> nil) and Found then
Result := LMethod.Invoke(Instance, Args)
else
raise Exception.CreateFmt('method %s not found', [MethodName]);
end;
function TListNCControls.AddEx<T>: T;
var
LRttiContext: TRttiContext;
LRttiType: TRttiType;
LRttiInstanceType: TRttiInstanceType;
LValue: TValue;
begin
LRttiContext := TRttiContext.Create;
LRttiType := LRttiContext.GetType(TypeInfo(T));
if (LRttiType <> nil) then
begin
LRttiInstanceType := LRttiType.AsInstance;
LValue := LRttiInstanceType.GetMethod('Create').Invoke(LRttiInstanceType.MetaclassType, [Self]);
// LValue := RttiMethodInvokeEx('Create', LRttiInstanceType, LRttiInstanceType.MetaclassType, [Self]);
end;
Result := LValue.AsType<T>;
end;
constructor TListNCControls.Create(AOwner: TPersistent);
begin
FOwner := TNCControls(AOwner);
inherited Create(TNCControl);
end;
destructor TListNCControls.Destroy;
begin
inherited;
end;
function TListNCControls.GetItem(Index: Integer): TNCControl;
begin
Result := TNCControl(inherited GetItem(Index));
end;
function TListNCControls.GetOwner: TPersistent;
begin
Result := FOwner;
end;
function TListNCControls.Insert(Index: Integer): TNCControl;
begin
Result := TNCControl(inherited Insert(Index));
end;
procedure TListNCControls.SetItem(Index: Integer; Value: TNCControl);
begin
inherited SetItem(Index, Value);
end;
{ TNCControl }
constructor TNCControl.Create(Collection: TCollection);
begin
inherited Create(Collection);
FNCControls := TNCControls(Collection.Owner);
FEnabled := True;
FVisible := True;
FFont := TFont.Create;
FWidth := 80;
FTop := 5;
FCaptionAligmentFlags := DT_VCENTER or DT_CENTER or DT_WORDBREAK;
end;
destructor TNCControl.Destroy;
begin
FFont.Free;
inherited;
end;
function TNCControl.GetAs<T>: T;
var
LValue: TValue;
begin
LValue := TValue.From(Self);
Result := LValue.AsType<T>;
end;
function TNCControl.GetBoundsRect: TRect;
begin
Result.Left := Left;
Result.Top := Top;
Result.Right := Left + Width;
Result.Bottom := Top + Height;
end;
function TNCControl.GetEnabled: Boolean;
begin
Result := FEnabled;
end;
procedure TNCControl.SetBounds(ALeft, ATop, AWidth, AHeight: Integer);
begin
FLeft := ALeft;
FTop := ATop;
FWidth := AWidth;
FHeight := AHeight;
end;
procedure TNCControl.SetBoundsRect(const Value: TRect);
begin
with Value do
SetBounds(Left, Top, Right - Left, Bottom - Top);
end;
procedure TNCControl.SetEnabled(const Value: Boolean);
begin
if Value <> FEnabled then
FEnabled := Value;
end;
procedure TNCControl.SetFont(const Value: TFont);
begin
FFont := Value;
end;
procedure TNCControl.SetHeight(const Value: Integer);
begin
FHeight := Value;
end;
procedure TNCControl.SetLeft(const Value: Integer);
begin
FLeft := Value;
end;
procedure TNCControl.SetName(const Value: TComponentName);
begin
FName := Value;
end;
procedure TNCControl.SetShowHint(const Value: Boolean);
begin
FShowHint := Value;
end;
procedure TNCControl.SetTop(const Value: Integer);
begin
FTop := Value;
end;
procedure TNCControl.SetVisible(const Value: Boolean);
begin
if FVisible <> Value then
FVisible := Value;
// TODO : Add parent notification
end;
procedure TNCControl.SetWidth(const Value: Integer);
begin
FWidth := Value;
end;
procedure TNCControl.DrawControl(ACanvas: TCanvas; AMouseInControl, Pressed: Boolean);
begin
end;
procedure TNCControl.Handle_WMNCLButtonDown(var Message: TWMNCHitMessage);
begin
end;
procedure TNCControl.Handle_WMNCLButtonUp(var Message: TWMNCHitMessage);
begin
end;
procedure TNCControl.Handle_WMNCMouseMove(var Message: TWMNCHitMessage);
begin
end;
initialization
TFormStyleNCSettings.UseThinBorder := False;
{$IFDEF CPUX86}
Trampoline_TFormStyleHook_GetBorderSize := InterceptCreate(TFormStyleHookClass(nil)._GetBorderSizeAddr,
@Detour_TFormStyleHook_GetBorderSize);
{$ENDIF}
Trampoline_TFormStyleHook_GetRegion := InterceptCreate(TFormStyleHookClass(nil)._GetRegionAddr,
@Detour_TFormStyleHook_GetRegion);
finalization
{$IFDEF CPUX86}
InterceptRemove(@Trampoline_TFormStyleHook_GetBorderSize);
{$ENDIF}
InterceptRemove(@Trampoline_TFormStyleHook_GetRegion);
end.
