unit Vcl.StyledTaskDialogFormUnit;

Winapi.Windows,

Winapi.Messages,

System.SysUtils,

System.Variants,

System.Classes,

Vcl.Graphics,

Vcl.Controls,

Vcl.ComCtrls,

Vcl.Forms,

Vcl.Dialogs,

Vcl.StdCtrls,

Vcl.ExtCtrls,

Vcl.ImgList,

System.UITypes,

Vcl.StyledButton,

Vcl.StyledTaskDialog,

Vcl.StandardButtonStyles,

Vcl.BootstrapButtonStyles,

Vcl.AngularButtonStyles,

Vcl.ButtonStylesAttributes,

Vcl.ColorButtonStyles,

Vcl.ButtonGroup;

/// <summary>Default implementation of ITaskDialogLauncher interface</summary>

/// <remarks>Handles the execution and display of styled task dialogs</remarks>

TTaskDialogLauncherHandler = class(TInterfacedObject, ITaskDialogLauncher)

/// <summary>Executes and displays the task dialog</summary>

/// <param name="ParentWnd">Handle to the parent window</param>

/// <param name="ADialogType">The type of dialog to display</param>

/// <param name="ATaskDialog">The TStyledTaskDialog instance</param>

/// <param name="ADialogBtnFamily">The button style family</param>

/// <returns>True if dialog was executed successfully</returns>

function DoExecute(ParentWnd: HWND;

const ADialogType: TMsgDlgType;

const ATaskDialog: TStyledTaskDialog;

const ADialogBtnFamily: TStyledButtonFamily): Boolean;

end;

/// <summary>Base form class for styled task dialogs</summary>

/// <remarks>

/// TStyledTaskDialogForm is the visual form that displays styled task dialogs.

/// It contains all the UI elements including buttons, icons, text labels,

/// progress bars, radio buttons, and more. Inherit from this class to create

/// custom dialog forms with different visual appearances.

/// </remarks>

TStyledTaskDialogForm = class(TForm)

FooterPanel: TPanel;

ButtonsPanel: TPanel;

ExpandedPanel: TPanel;

VerificationPanel: TPanel;

CommandLinksPanel: TPanel;

CenterPanel: TPanel;

ImagePanel: TPanel;

FooterIconPanel: TPanel;

IconContainer: TPanel;

RadioGroupPanel: TPanel;

MessageScrollBox: TScrollBox;

TitleLabel: TLabel;

TextLabel: TLinkLabel;

AutoSizeLabel: TLabel;

YesButton: TStyledButton;

NoButton: TStyledButton;

OKButton: TStyledButton;

CancelButton: TStyledButton;

AbortButton: TStyledButton;

RetryButton: TStyledButton;

IgnoreButton: TStyledButton;

AllButton: TStyledButton;

NoToAllButton: TStyledButton;

YesToAllButton: TStyledButton;

HelpButton: TStyledButton;

CloseButton: TStyledButton;

FooterTextLabel: TLinkLabel;

VerificationCheckBox: TCheckBox;

ExpandButton: TStyledButton;

ExpandLabel: TLabel;

ProgressBarPanel: TPanel;

InternalProgressBar: TProgressBar;

procedure FormCreate(Sender: TObject);

procedure ButtonClick(Sender: TObject);

procedure FormKeyDown(Sender: TObject; var Key: Word; Shift: TShiftState);

procedure FormShow(Sender: TObject);

procedure TextLabelLinkClick(Sender: TObject; const Link: string;

LinkType: TSysLinkType);

procedure FormDestroy(Sender: TObject);

procedure HelpButtonClick(Sender: TObject);

procedure FormClose(Sender: TObject; var Action: TCloseAction);

procedure VerificationCheckBoxClick(Sender: TObject);

procedure RadioButtonClick(Sender: TObject);

procedure ExpandButtonClick(Sender: TObject);

private

FFocusedButton: TStyledButton;

FCustomIcons: TStyledDialogIcons;

FTaskDialog: TCustomTaskDialog;

FDialogType: TMsgDlgType;

FButtonsWidth: Integer;

FButtonsHeight: Integer;

FDialogBtnFamily: TStyledButtonFamily;

FDialogBtnDrawType: TStyledButtonDrawType;

FDialogBtnRadius: Integer;

FDialogBtnRoundedCorners: TRoundedCorners;

FCommonButtons: TTaskDialogCommonButtons;

FDefaultButton: TTaskDialogCommonButton;

FUseMessageDefaultButton: Boolean;

FMessageDefaultButton: TMsgDlgBtn;

FButtons: TTaskDialogButtons;

FFooterIcon: TTaskDialogIcon;

FCustomMainIcon: TIcon;

FCustomFooterIcon: TIcon;

FMainIcon: TTaskDialogIcon;

FOnTimer: TTaskDlgTimerEvent;

FRadioButtons: TTaskDialogButtons;

FAutoClick: Boolean;

FAutoClickDelay: Integer;

FRadioButton: TTaskDialogRadioButtonItem;

FProgressBar: TTaskDialogProgressBar;

FFlags: TTaskDialogFlags;

FExpandButtonCaption: string;

FText: string;

FExpandedText: string;

FTaskDialogExpanded: TNotifyEvent;

FTimer: TTimer;

FTickCount: Cardinal;

FMainIconSize: Integer;

FAnimationLoop: Boolean;

FAnimationInverse: Boolean;

//procedure GetIconNameAndIndex(ATaskDialog: TMsgDlgType;

// out AImageName: string; out AImageIndex: Integer); overload;

procedure TaskDialogExpanded(Sender: TObject);

procedure GetIconNameAndIndex(ATaskDialogIcon: TTaskDialogIcon;

out AImageName: string; out AImageIndex: Integer); overload;

procedure ShowDialogForm;

procedure SetHelpContext(const AValue: Integer);

function GetHelpContext: Integer;

function GetText: string;

function GetTitle: string;

procedure SetText(const AValue: string);

procedure SetTitle(const AValue: string);

procedure AdjustHeight;

procedure AdjustWidth;

procedure AdjustControlsTopPos;

procedure AdjustButtonsCaption;

procedure SetButtons(const AValue: TTaskDialogButtons);

procedure PlayMessageDlgSound;

procedure FocusDefaultButton;

procedure LoadDialogImage;

procedure SetFooterText(const AValue: string);

function GetFooterText: string;

procedure SetVerificationText(const AValue: string);

procedure SetExpandedText(const AValue: string);

function GetVerificationText: string;

function GetFocusedButton: TStyledButton;

procedure InitDlgButtonsWithFamily(const AFamily: TStyledButtonFamily);

procedure UpdateButtonsVisibility;

procedure UpdateButtonsSize;

procedure SetFooterIcon(const AValue: TTaskDialogIcon);

procedure SetCustomMainIcon(const AValue: TIcon);

procedure SetCustomFooterIcon(const AValue: TIcon);

procedure SetMainIcon(const AValue: TTaskDialogIcon);

procedure AddCustomButtons(const AButtons: TTaskDialogButtons);

procedure SetMainIconSize(const AValue: Integer);

procedure SetRadioButtons(const AValue: TTaskDialogButtons);

function UsingCommandLinks: Boolean;

procedure SetFlags(const AValue: TTaskDialogFlags);

procedure SetExpandButtonCaption(const Value: string);

function GetExpanded: Boolean;

procedure CalcMessageText(const AExpanded: Boolean);

procedure SetProgressBar(const AValue: TTaskDialogProgressBar);

protected

procedure WndProc(var Message: TMessage); override;

procedure TimerEvent(Sender: TObject);

function GetScaleFactor: Single; virtual;

class function CanUseAnimations: Boolean; virtual; abstract;

function GetButtonsHeight: Integer; virtual;

function GetButtonsWidth: Integer; virtual;

procedure SetButtonsHeight(const AValue: Integer); virtual;

procedure SetButtonsWidth(const AValue: Integer); virtual;

function TaskDialogIconToImageIndex(const ATaskDialogIcon: TTaskDialogIcon): Integer;

function TaskDialogIconToImageName(const ATaskDialogIcon: TTaskDialogIcon): string;

procedure Loaded; override;

procedure LoadImage(const AImageIndex: TImageIndex;

AImageName: string); virtual; abstract;

procedure LoadCustomMainIcon(const AIcon: TIcon;

const ATaskDialogIcon: TTaskDialogIcon); virtual;

procedure LoadCustomFooterIcon(const AIcon: TIcon;

const ATaskDialogIcon: TTaskDialogIcon); virtual;

procedure DefaultDialogSize(out AClientWidth, AClientHeight, AImageSize: Integer); virtual;

function GetDefaultButton(const ADefaultButton: TTaskDialogCommonButton): TStyledButton; virtual;

property TaskDialog: TCustomTaskDialog read FTaskDialog;

public

/// <summary>Converts a modal result to a task dialog common button</summary>

/// <param name="AModalResult">The modal result to convert</param>

/// <param name="ACommonButton">Output: the corresponding common button</param>

/// <returns>True if conversion was successful</returns>

function ModalResultToCommonButton(const AModalResult: TModalResult;

out ACommonButton: TTaskDialogCommonButton): Boolean;

/// <summary>Finds a button by its modal result value</summary>

/// <param name="AModalResult">The modal result to search for</param>

/// <returns>The TStyledButton with the specified modal result, or nil</returns>

function FindButton(const AModalResult: TModalResult): TStyledButton;

/// <summary>Sets the font for all dialog elements</summary>

/// <param name="AFont">The font to apply</param>

procedure SetDialogFont(const AFont: TFont); virtual;

/// <summary>Creates a new instance of the dialog form</summary>

/// <param name="AOwner">The component owner</param>

constructor Create(AOwner: TComponent); override;

/// <summary>Destroys the dialog form instance</summary>

destructor Destroy; override;

/// <summary>Sets the screen position of the dialog</summary>

/// <param name="X">X coordinate in screen pixels</param>

/// <param name="Y">Y coordinate in screen pixels</param>

procedure SetPosition(const X, Y: Integer); virtual;

/// <summary>Enables automatic button click after a delay</summary>

property AutoClick: Boolean read FAutoClick write FAutoClick default False;

/// <summary>Delay in milliseconds before auto-clicking the default button</summary>

property AutoClickDelay: Integer read FAutoClickDelay write FAutoClickDelay default DEFAULT_AUTOCLICK_DELAY;

/// <summary>Width of dialog buttons in pixels</summary>

property ButtonsWidth: Integer read GetButtonsWidth write SetButtonsWidth;

/// <summary>Height of dialog buttons in pixels</summary>

property ButtonsHeight: Integer read GetButtonsHeight write SetButtonsHeight;

/// <summary>Collection of custom buttons for the dialog</summary>

property Buttons: TTaskDialogButtons read FButtons write SetButtons;

/// <summary>Collection of radio buttons for the dialog</summary>

property RadioButtons: TTaskDialogButtons read FRadioButtons write SetRadioButtons;

/// <summary>Standard common buttons to display (Ok, Cancel, Yes, No, etc.)</summary>

property CommonButtons: TTaskDialogCommonButtons read FCommonButtons write FCommonButtons default [tcbOk, tcbCancel];

/// <summary>The default button that receives focus</summary>

property DefaultButton: TTaskDialogCommonButton read FDefaultButton write FDefaultButton default TTaskDialogCommonButton.tcbOk;

/// <summary>Default button when using message dialog style</summary>

property MessageDefaultButton: TMsgDlgBtn read FMessageDefaultButton write FMessageDefaultButton default TMsgDlgBtn.mbOK;

/// <summary>Caption for the expand/collapse button</summary>

property ExpandButtonCaption: string read FExpandButtonCaption write SetExpandButtonCaption;

/// <summary>Returns True if the expandable content is currently shown</summary>

property Expanded: Boolean read GetExpanded;

/// <summary>Additional text shown when dialog is expanded</summary>

property ExpandedText: string read FExpandedText write SetExpandedText;

/// <summary>Progress bar settings for the dialog</summary>

property ProgressBar: TTaskDialogProgressBar read FProgressBar write SetProgressBar;

/// <summary>Dialog behavior flags</summary>

property Flags: TTaskDialogFlags read FFlags write SetFlags default [tfAllowDialogCancellation];

/// <summary>Main icon displayed in the dialog (tdiWarning, tdiError, tdiInformation, etc.)</summary>

property MainIcon: TTaskDialogIcon read FMainIcon write SetMainIcon default tdiInformation;

/// <summary>Custom icon to display instead of standard icons</summary>

property CustomMainIcon: TIcon read FCustomMainIcon write SetCustomMainIcon;

/// <summary>Size of the main icon in pixels</summary>

property MainIconSize: Integer read FMainIconSize write SetMainIconSize default DEFAULT_MAIN_ICON_SIZE;

/// <summary>Custom icon for the footer area</summary>

property CustomFooterIcon: TIcon read FCustomFooterIcon write SetCustomFooterIcon;

/// <summary>Standard icon displayed in the footer</summary>

property FooterIcon: TTaskDialogIcon read FFooterIcon write SetFooterIcon default tdiNone;

/// <summary>Text displayed in the footer area</summary>

property FooterText: string read GetFooterText write SetFooterText;

/// <summary>Text for the verification checkbox</summary>

property VerificationText: string read GetVerificationText write SetVerificationText;

/// <summary>Help context ID for F1 help</summary>

property HelpContext: Integer read GetHelpContext write SetHelpContext default 0;

/// <summary>The currently selected radio button item</summary>

property RadioButton: TTaskDialogRadioButtonItem read FRadioButton;

/// <summary>The main message text displayed in the dialog</summary>

property TextMessage: string read GetText write SetText;

/// <summary>The title/instruction text displayed at the top</summary>

property TitleMessage: string read GetTitle write SetTitle;

/// <summary>Timer event fired periodically while dialog is shown</summary>

property OnTimer: TTaskDlgTimerEvent read FOnTimer write FOnTimer;

/// <summary>When True, loops the icon animation continuously (requires Skia4Delphi)</summary>

property AnimationLoop: Boolean read FAnimationLoop write FAnimationLoop;

/// <summary>When True, plays the icon animation in reverse (requires Skia4Delphi)</summary>

property AnimationInverse: Boolean read FAnimationInverse write FAnimationInverse;

end;

/// <summary>Class reference type for TStyledTaskDialogForm descendants</summary>

TStyledTaskDialogFormClass = class of TStyledTaskDialogForm;

procedure UseStyledDialogForm(const AActivate: Boolean);

procedure RegisterTaskDialogFormClass(AFormClass: TStyledTaskDialogFormClass);

procedure UnRegisterTaskDialogFormClass(AFormClass: TStyledTaskDialogFormClass);

function AnimatedTaskDialogFormRegistered: Boolean;

System.Math

, Vcl.Themes

, System.HelpIntfs

, Winapi.ShellAPI

, Winapi.CommCtrl

, Winapi.MultiMon

, Vcl.StyledCmpMessages

, System.Typinfo

;

_DialogLauncher: ITaskDialogLauncher;

_AnimatedTaskDialogFormClass: TStyledTaskDialogFormClass;

_TaskDialogFormClass: TStyledTaskDialogFormClass;

_DlgButtonClasses: TButtonClasses;

_DialogPosition: Vcl.Forms.TPosition;

function AnimatedTaskDialogFormRegistered: Boolean;

Result := Assigned(_AnimatedTaskDialogFormClass);

end;

procedure UnRegisterTaskDialogFormClass(

AFormClass: TStyledTaskDialogFormClass);

//Unregister handle

_DialogLauncher := nil;

if AFormClass = _AnimatedTaskDialogFormClass then

_AnimatedTaskDialogFormClass := nil;

if AFormClass = _TaskDialogFormClass then

_TaskDialogFormClass := nil;

end;

procedure RegisterTaskDialogFormClass(

AFormClass: TStyledTaskDialogFormClass);

//Create handler for execute custom TaskDialog Form

_DialogLauncher := TTaskDialogLauncherHandler.Create;

if AFormClass.CanUseAnimations then

_AnimatedTaskDialogFormClass := AFormClass

else

_TaskDialogFormClass := AFormClass;

UseStyledDialogForm(True);

end;

procedure UseStyledDialogForm(const AActivate: Boolean);

if AActivate then

RegisterCustomExecute(_DialogLauncher)

else

UnregisterCustomExecute;

end;

procedure TStyledTaskDialogForm.SetRadioButtons(const AValue: TTaskDialogButtons);

I: Integer;

LTaskDialogRadioButtonItem: TTaskDialogRadioButtonItem;

LRadioButton, LLastButton, LFirstButton: TRadioButton;

LHeight: Integer;

LDefaultAssigned: Boolean;

LHeight := RadioGroupPanel.Height;

FRadioButtons := AValue;

LLastButton := nil;

LFirstButton := nil;

LDefaultAssigned := False;

for I := 0 to FRadioButtons.Count -1 do

begin

LTaskDialogRadioButtonItem := FRadioButtons[I] as TTaskDialogRadioButtonItem;

LRadioButton := TRadioButton.Create(Self);

if I = 0 then

LFirstButton := LRadioButton;

LRadioButton.Tag := 100+I;

LRadioButton.Caption := LTaskDialogRadioButtonItem.Caption;

LRadioButton.Parent := RadioGroupPanel;

LRadioButton.Align := alTop;

LRadioButton.Height := LHeight;

if Assigned(LLastButton) then

LRadioButton.Top := LLastButton.Top + LLastButton.Height;

LRadioButton.OnClick := RadioButtonClick;

if LTaskDialogRadioButtonItem.Default then

begin

LRadioButton.Checked := True;

LDefaultAssigned := True;

end;

RadioGroupPanel.Visible := True;

RadioGroupPanel.Height := LHeight * (I+1);

LLastButton := LRadioButton;

end;

if (FRadioButtons.Count > 0) then

begin

RadioGroupPanel.Height := RadioGroupPanel.Height + (LHeight div 3);

if not LDefaultAssigned then

LFirstButton.Checked := True;

end;

end;

procedure TStyledTaskDialogForm.SetButtons(const AValue: TTaskDialogButtons);

I: Integer;

LTaskDialogButtonItem: TTaskDialogBaseButtonItem;

LStyledButton: TStyledButton;

FButtons := AValue;

for I := FButtons.Count -1 downto 0 do

begin

LTaskDialogButtonItem := FButtons[I];

if Assigned(LTaskDialogButtonItem) then

begin

case LTaskDialogButtonItem.ModalResult of

mrYes: LStyledButton := YesButton;

mrNo: LStyledButton := NoButton;

mrOk: LStyledButton := OKButton;

mrCancel: LStyledButton := CancelButton;

mrAbort: LStyledButton := AbortButton;

mrRetry: LStyledButton := RetryButton;

mrIgnore: LStyledButton := IgnoreButton;

mrAll: LStyledButton := AllButton;

mrNoToAll: LStyledButton := NoToAllButton;

mrYesToAll: LStyledButton := YesToAllButton;

mrClose: LStyledButton := CloseButton;

mrHelp: LStyledButton := HelpButton;

else

begin

LStyledButton := nil;

end;

end;

if Assigned(LStyledButton) then

begin

TabOrder := LStyledButton.TabOrder -1;

if LTaskDialogButtonItem.Default then

FFocusedButton := LStyledButton;

end;

end;

end;

end;

procedure TStyledTaskDialogForm.SetButtonsHeight(const AValue: Integer);

if FButtonsHeight <> AValue then

begin

FButtonsHeight := AValue;

UpdateButtonsSize;

end;

end;

procedure TStyledTaskDialogForm.SetButtonsWidth(const AValue: Integer);

if FButtonsHeight <> AValue then

begin

FButtonsHeight := AValue;

UpdateButtonsSize;

end;

end;

procedure TStyledTaskDialogForm.SetCustomMainIcon(const AValue: TIcon);

if FCustomMainIcon <> AValue then

begin

FCustomMainIcon := AValue;

LoadCustomMainIcon(FCustomMainIcon, FMainIcon);

end;

end;

procedure TStyledTaskDialogForm.SetCustomFooterIcon(const AValue: TIcon);

if FCustomFooterIcon <> AValue then

begin

FCustomMainIcon := AValue;

LoadCustomFooterIcon(FCustomFooterIcon, FfooterIcon);

end;

end;

procedure TStyledTaskDialogForm.SetFlags(const AValue: TTaskDialogFlags);

if FFlags <> AValue then

begin

FFlags := AValue;

FTaskDialog.Flags := AValue;

ProgressBarPanel.Visible := (tfShowProgressBar in Flags) or (tfShowMarqueeProgressBar in Flags);

if tfShowMarqueeProgressBar in Flags then

InternalProgressBar.Style := pbstMarquee;

end;

end;

procedure TStyledTaskDialogForm.SetMainIcon(const AValue: TTaskDialogIcon);

if FMainIcon <> AValue then

begin

FMainIcon := AValue;

LoadCustomMainIcon(FCustomMainIcon, FMainIcon);

end;

end;

procedure TStyledTaskDialogForm.SetMainIconSize(const AValue: Integer);

if AValue <> FMainIconSize then

FMainIconSize := AValue;

end;

procedure TStyledTaskDialogForm.SetProgressBar(

const AValue: TTaskDialogProgressBar);

FProgressBar := AValue;

InternalProgressBar.Min := FProgressBar.Min;

InternalProgressBar.Max := FProgressBar.Max;

InternalProgressBar.Position := FProgressBar.Position;

InternalProgressBar.MarqueeInterval := FProgressBar.MarqueeSpeed;

InternalProgressBar.State := FProgressBar.State;

end;

procedure TStyledTaskDialogForm.SetFooterIcon(const AValue: TTaskDialogIcon);

if FFooterIcon <> AValue then

begin

FFooterIcon := AValue;

LoadCustomFooterIcon(FCustomFooterIcon, FFooterIcon);

end;

end;

procedure TStyledTaskDialogForm.SetFooterText(const AValue: string);

LRows: TStringList;

if Trim(AValue) <> '' then

begin

LRows := TStringList.Create;

try

LRows.Text := AValue;

FooterTextLabel.Caption := AValue;

if LRows.Count > 1 then

FooterPanel.Height := FooterPanel.Height * LRows.Count

else

FooterPanel.Height := 32;

FooterPanel.Visible := True;

finally

LRows.Free;

end;

end

else

FooterPanel.Visible := False;

end;

function TStyledTaskDialogForm.GetButtonsHeight: Integer;

//Assuming all buttons have the same Height

Result := YesButton.Height;

end;

function TStyledTaskDialogForm.GetButtonsWidth: Integer;

//Assuming all buttons have the same Width

Result := YesButton.Width;

end;

function TStyledTaskDialogForm.GetDefaultButton(

const ADefaultButton :TTaskDialogCommonButton): TStyledButton;

if FUseMessageDefaultButton then

begin

case FMessageDefaultButton of

mbYes: Result := YesButton;

mbNo: Result := NoButton;

mbOK: Result := OKButton;

mbCancel: Result := CancelButton;

mbAbort: Result := AbortButton;

mbRetry: Result := RetryButton;

mbIgnore: Result := IgnoreButton;

mbAll: Result := AllButton;

mbNoToAll: Result := NoToAllButton;

mbYesToAll: Result := YesToAllButton;

mbHelp: Result := HelpButton;

mbClose: Result := CloseButton;

else

Result := nil;

end;

end

else

begin

case ADefaultButton of

tcbOk: Result := OKButton;

tcbYes: Result := YesButton;

tcbNo: Result := NoButton;

tcbCancel: Result := CancelButton;

tcbRetry: Result := RetryButton;

tcbClose: Result := CloseButton;

else

Result := nil;

end;

end;

end;

function TStyledTaskDialogForm.GetExpanded: Boolean;

Result := FTaskDialog.Expanded;

end;

procedure TStyledTaskDialogForm.FocusDefaultButton;

LButton: TStyledButton;

LButton := GetDefaultButton(DefaultButton);

if not Assigned(LButton) then

LButton := FFocusedButton;

if Assigned(LButton) then

begin

if LButton.CanFocus and Self.Visible then

begin

LButton.SetFocus;

LButton.AutoClick := FAutoClick;

LButton.AutoClickDelay := FAutoClickDelay;

end;

end;

end;

procedure TStyledTaskDialogForm.SetDialogFont(const AFont: TFont);

Self.Font.Assign(AFont);

TextLabel.Font.Name := Font.Name;

TextLabel.Font.Size := AFont.Size;

//TitleLabel font attributes

if not StyleServices.Enabled or StyleServices.IsSystemStyle then

TitleLabel.Font.Color := clHighlight

else

TextLabel.Font.Color := StyleServices.GetSystemColor(clHighlight);

TitleLabel.Font.Style := [TFontStyle.fsBold];

TitleLabel.Font.Name := Font.Name;

TitleLabel.Font.Height := Round(AFont.Height * 1.4);

end;

procedure TStyledTaskDialogForm.SetHelpContext(const AValue: Integer);

inherited HelpContext := AValue;

HelpButton.HelpContext := AValue;

end;

procedure TStyledTaskDialogForm.AdjustHeight;

LTitleHeight: Integer;

LRadioGroupPanelHeight: Integer;

LImagePanelHeight: Integer;

LCommandLinksPanelHeight: Integer;

LVerificationPanelHeight: Integer;

LProgressBarPanelHeight: Integer;

LExpandedPanelHeight: Integer;

LButtonsPanelHeight: Integer;

LFooterPanelHeight: Integer;

LMinHeight, LCalcHeight: Integer;

LImageSize, LMessageHeight, LWidth, LHeight, LMargins: Integer;

LMargins := CenterPanel.Margins.Top * 2;

DefaultDialogSize(LWidth, LHeight, LImageSize);

LImagePanelHeight := LImageSize +

IconContainer.Margins.Top + IconContainer.Margins.Bottom +

ImagePanel.Margins.Top + ImagePanel.Margins.Bottom;

//Height of Buttons

if FButtonsHeight <> DEFAULT_STYLEDDIALOG_BUTTONSHEIGHT then

ButtonsPanel.Height := FButtonsHeight;

//Calculate Height of Form, based on Visible Components

if TitleLabel.Caption <> '' then

begin

LTitleHeight := TitleLabel.Height +

TitleLabel.Margins.Top + TitleLabel.Margins.Bottom;

end

else

begin

LTitleHeight := 0;

TitleLabel.Visible := False;

end;

if RadioGroupPanel.Visible then

LRadioGroupPanelHeight := RadioGroupPanel.Height

else

LRadioGroupPanelHeight := 0;

if FooterPanel.Visible then

LFooterPanelHeight := FooterPanel.Height

else

LFooterPanelHeight := 0;

if VerificationPanel.Visible then

LVerificationPanelHeight := VerificationPanel.Height

else

LVerificationPanelHeight := 0;

if ProgressBarPanel.Visible then

LProgressBarPanelHeight := ProgressBarPanel.Height

else

LProgressBarPanelHeight := 0;

if ExpandedPanel.Visible then

LExpandedPanelHeight := ExpandedPanel.Height

else

LExpandedPanelHeight := 0;

if CommandLinksPanel.Visible then

LCommandLinksPanelHeight := CommandLinksPanel.Height + LMargins

else

LCommandLinksPanelHeight := 0;

if ButtonsPanel.Visible then

LButtonsPanelHeight := ButtonsPanel.Height

else

LButtonsPanelHeight := 0;

LMessageHeight := AutoSizeLabel.Height +

AutoSizeLabel.Margins.Top + AutoSizeLabel.Margins.Bottom +

MessageScrollBox.Margins.Top + MessageScrollBox.Margins.Bottom +

LMargins;

LMessageHeight := Max(LMessageHeight,

LImagePanelHeight - LTitleHeight);

//Actual Height based on size of Message

LCalcHeight :=

LTitleHeight +

LMessageHeight +

LExpandedPanelHeight +

LRadioGroupPanelHeight +

LFooterPanelHeight +

LVerificationPanelHeight +

LProgressBarPanelHeight +

LButtonsPanelHeight +

LCommandLinksPanelHeight;

//Minumum Height based on size of Image

LMinHeight := Max(

LImagePanelHeight +

LButtonsPanelHeight

,

LTitleHeight +

LExpandedPanelHeight +

LRadioGroupPanelHeight +

LFooterPanelHeight +

LVerificationPanelHeight +

LProgressBarPanelHeight +

LButtonsPanelHeight +

LCommandLinksPanelHeight);

LHeight := Min(Self.Monitor.Height - Round(150 * GetScaleFactor),

Max(LCalcHeight, LMinHeight));

ClientHeight := LHeight;

Constraints.MinHeight := LMinHeight +

Height - ClientHeight;

TextLabel.Font.Assign(AutoSizeLabel.Font);

TextLabel.Height := LMessageHeight;

if LCalcHeight > LHeight then

begin

MessageScrollBox.VertScrollBar.Visible := True;

{$IFDEF D11+}

//You need Delphi 11 Update 3 to compile this row or remove it!

MessageScrollBox.UseWheelForScrolling := True;

{$ENDIF}

MessageScrollBox.VertScrollBar.Range := LMessageHeight + LTitleHeight + 100;

TextLabel.Align := alClient;

end

else

begin

MessageScrollBox.VertScrollBar.Visible := False;

TextLabel.Margins.Top := Max(0,

(CenterPanel.Height - AutoSizeLabel.Height - LTitleHeight) div 2);

end;

AutoSizeLabel.Visible := False;

end;

procedure TStyledTaskDialogForm.AdjustWidth;

LFormWidth, I: Integer;

LStyledButton: TStyledButton;

LMargins: Integer;

LImageSize, LWidth, LHeight: Integer;

DefaultDialogSize(LWidth, LHeight, LImageSize);

ImagePanel.Width := Round(LImageSize * GetScaleFactor);

LMargins := ButtonsPanel.Margins.Left;

LFormWidth := LMargins;

if ButtonsPanel.Visible then

begin

for I := 0 to ComponentCount - 1 do

begin

if Components[I] is TStyledButton then

begin

LStyledButton := TStyledButton(Components[I]);

if LStyledButton.Visible and (LStyledButton.Align = alRight) then

LFormWidth := LFormWidth + LStyledButton.Width + LMargins + LMargins;

end;

end;

end;

LFormWidth := LFormWidth + LMargins;

ClientWidth := Max(LWidth, LFormWidth);

//Resize Image based on Scale Factor

ImagePanel.SetBounds(ImagePanel.Left, ImagePanel.Top,

LImageSize, LImageSize);

IconContainer.SetBounds(IconContainer.Left, IconContainer.Top,

LImageSize, LImageSize);

end;

procedure TStyledTaskDialogForm.CalcMessageText(const AExpanded: Boolean);

LMessage: string;

if not AExpanded then

begin

ExpandButton.Caption := '+';

if ExpandButtonCaption = '' then

ExpandLabel.Caption := SShowDetails;

end

else

begin

ExpandButton.Caption := '-';

if ExpandButtonCaption = '' then

ExpandLabel.Caption := SHideDetails;

end;

LMessage := FText;

if AExpanded and (FExpandedText <> '') then

LMessage := LMessage + sLineBreak + sLineBreak + FExpandedText;

if TextLabel.Caption <> LMessage then

begin

AutoSizeLabel.Caption := ClearHRefs(LMessage);

TextLabel.Caption := LMessage;

end;

end;

procedure TStyledTaskDialogForm.SetText(const AValue: string);

if AValue <> FText then

begin

FText := AValue;

CalcMessageText(Expanded);

end;

end;

procedure TStyledTaskDialogForm.SetTitle(const AValue: string);

if TitleLabel.Caption <> AValue then

begin

TitleLabel.Caption := AValue;

end;

end;

procedure TStyledTaskDialogForm.SetVerificationText(const AValue: string);

LRows: TStringList;

if Trim(AValue) <> '' then

begin

LRows := TStringList.Create;

try

LRows.Text := AValue;

VerificationCheckBox.Caption := AValue;

if LRows.Count > 1 then

VerificationPanel.Height := VerificationPanel.Height * LRows.Count;

VerificationPanel.Visible := True;

finally

LRows.Free;

end;

end

else

VerificationPanel.Visible := False;

end;

procedure TStyledTaskDialogForm.SetExpandButtonCaption(const Value: string);

FExpandButtonCaption := Value;

end;

procedure TStyledTaskDialogForm.SetExpandedText(const AValue: string);

if Trim(AValue) <> FExpandedText then

begin

FExpandedText := AValue;

ExpandedPanel.Visible := FExpandedText <> '';

CalcMessageText(Expanded);

end;

end;

procedure TStyledTaskDialogForm.LoadCustomFooterIcon(const AIcon: TIcon;

const ATaskDialogIcon: TTaskDialogIcon);

//In descendand form implements this method

;

end;

procedure TStyledTaskDialogForm.LoadCustomMainIcon(const AIcon: TIcon;

const ATaskDialogIcon: TTaskDialogIcon);

//In descendand form implements this method

;

end;

procedure TStyledTaskDialogForm.LoadDialogImage;

LIconName: string;

LIconIndex: Integer;

LMargins: Integer;

if (tfUseHiconMain in FTaskDialog.Flags) and Assigned(FTaskDialog.CustomMainIcon) then

begin

LoadCustomMainIcon(FTaskDialog.CustomMainIcon, FTaskDialog.MainIcon);

end

else

begin

GetIconNameAndIndex(FMainIcon, LIconName, LIconIndex);

LoadImage(LIconIndex, LIconName);

end;

LMargins := CenterPanel.Margins.Left + CenterPanel.Margins.Right;

if ImagePanel.Visible then

Inc(LMargins, ImagePanel.Width);

RadioGroupPanel.Margins.Left := LMargins;

CommandLinksPanel.Margins.Left := LMargins;

ProgressBarPanel.Margins.Left := LMargins;

end;

function TStyledTaskDialogForm.FindButton(const AModalResult: TModalResult): TStyledButton;

I: Integer;

for I := 0 to Self.ComponentCount - 1 do

begin

if Components[I] is TStyledButton then

begin

Result := TStyledButton(Components[I]);

if Result.ModalResult = AModalResult then

Exit;

end;

end;

Result := nil;

end;

procedure TStyledTaskDialogForm.UpdateButtonsSize;

procedure UpdateButtonSize(const AButton: TStyledButton);

begin

AButton.Width := Round(FButtonsWidth * GetScaleFactor);

end;

UpdateButtonSize(YesButton);

UpdateButtonSize(NoButton);

UpdateButtonSize(OKButton);

UpdateButtonSize(CancelButton);

UpdateButtonSize(RetryButton);

UpdateButtonSize(CloseButton);

UpdateButtonSize(AbortButton);

UpdateButtonSize(IgnoreButton);

UpdateButtonSize(AllButton);

UpdateButtonSize(NoToAllButton);

UpdateButtonSize(YesToAllButton);

UpdateButtonSize(HelpButton);

end;

procedure TStyledTaskDialogForm.UpdateButtonsVisibility;

function IsButtonVisible(const AButton: TStyledButton): Boolean;

var

I: Integer;

LTaskDialogButtonItem: TTaskDialogBaseButtonItem;

begin

Result := False;