{
* This Source Code Form is subject to the terms of the Mozilla Public License,
* v. 2.0. If a copy of the MPL was not distributed with this file, You can
* obtain one at http://mozilla.org/MPL/2.0/
*
* Copyright (C) 2010-2013, Peter Johnson (www.delphidabbler.com).
*
* $Rev$
* $Date$
*
* Implements a frame that allows user to set source code generation
* preferences.
* Designed for use as one of the tabs in the Preferences dialogue box.
}
unit FrCodeGenPrefs;
interface
uses
// Delphi
Classes, ActnList, StdCtrls, Controls, ComCtrls, Menus, Buttons,
// 3rd party
LVEx,
// Project
FrPrefsBase, UPreferences, UWarnings;
type
/// <summary>Frame that allows user to set source code generation
/// preferences.</summary>
/// <remarks>Designed for use in preferences dialog box.</remarks>
TCodeGenPrefsFrame = class(TPrefsBaseFrame)
chkWARNEnabled: TCheckBox;
lblSymbol: TLabel;
lblMinCompiler: TLabel;
edSymbol: TEdit;
btnAdd: TButton;
btnDelete: TButton;
btnUpdate: TButton;
alMain: TActionList;
actAdd: TAction;
actUpdate: TAction;
actDelete: TAction;
btnPreview: TButton;
actPreview: TAction;
btnPredefined: TBitBtn;
mnuPreDefCompilers: TPopupMenu;
lblState: TLabel;
edMinCompiler: TEdit;
rbStateOff: TRadioButton;
rbStateOn: TRadioButton;
btnRestoreDefaults: TButton;
actRestoreDefaults: TAction;
/// <summary>Creates new warning from data entered in controls and adds it
/// to warnings list.</summary>
procedure actAddExecute(Sender: TObject);
/// <summary>Enables or disables "Add" action depending on validity of data
/// entered in controls.</summary>
procedure actAddUpdate(Sender: TObject);
/// <summary>Deletes warning selected in list view from warnings list.
/// </summary>
procedure actDeleteExecute(Sender: TObject);
/// <summary>Enables "Delete" action only if an item is selected in list
/// view.</summary>
procedure actDeleteUpdate(Sender: TObject);
/// <summary>Displays a preview of $WARN compiler directives that will be
/// emitted by code generator.</summary>
procedure actPreviewExecute(Sender: TObject);
/// <summary>Enables "Preview" action only if user has specified that $WARN
/// directives will be emitted.</summary>
procedure actPreviewUpdate(Sender: TObject);
/// <summary>Restores default $WARN directives, replacing all directives
/// shown in list view.</summary>
procedure actRestoreDefaultsExecute(Sender: TObject);
/// <summary>Updates warning selected in list view with data entered in
/// controls.</summary>
procedure actUpdateExecute(Sender: TObject);
/// <summary>Enables or disables "Update" action depending on validity of
/// data enterend in controls.</summary>
procedure actUpdateUpdate(Sender: TObject);
/// <summary>Displays menu of predefined compiler versions when
/// "pre-defined" button is clicked.</summary>
procedure btnPredefinedClick(Sender: TObject);
/// <summary>Handles clicks on check box that enables or disables warnings
/// and updates warnings object with state.</summary>
procedure chkWARNEnabledClick(Sender: TObject);
/// <summary>Inhibits non-numerical key presses in Min Compiler edit box.
/// </summary>
procedure edMinCompilerKeyPress(Sender: TObject; var Key: Char);
strict private
var
/// <summary>Stores details of warnings.</summary>
fWarnings: IWarnings;
/// <summary>References dynamically created list view control.</summary>
fLVWarnings: TListViewEx;
/// <summary>Handles clicks on pre-defined compiler menu items. Stores
/// version number of selected compiler in associated edit control.
/// </summary>
procedure PreDefCompilerMenuClick(Sender: TObject);
/// <summary>Handles selection of an item in warnings list view. Copies
/// details of selected warning into controls, ready for editing.</summary>
procedure LVWarningsSelected(Sender: TObject; Item: TListItem;
Selected: Boolean);
/// <summary>Specifies that TWarningListItem is to be used to create new
/// list view items.</summary>
procedure LVWarningsCreateItemClass(Sender: TCustomListView;
var ItemClass: TListItemClass);
/// <summary>Compares two list items, Item1 and Item2, using text contained
/// in row specified Data parameter, recording result of comparison in
/// Compare parameter.</summary>
procedure LVWarningsCompare(Sender: TObject; Item1, Item2: TListItem;
Data: Integer; var Compare: Integer);
/// <summary>Returns text of list item LI in column specified by Idx.
/// </summary>
/// <remarks>Idx = 0 returns list item's caption while Idx > 0 returns text
/// of SubItem[Idx-1].</remarks>
function LVColumnText(const LI: TListItem; const Idx: Integer): string;
/// <summary>Dynamically creates list view control and sets required
/// properties.</summary>
procedure CreateLV;
/// <summary>Populates list view with details of warnings.</summary>
procedure PopulateLV;
/// <summary>Adds details of given warning to list view.</summary>
procedure AddWarningToLV(const Warning: TWarning);
/// <summary>Sets given list view item to display and record details of
/// given warning.</summary>
procedure SetLVItem(const LI: TListItem; const Warning: TWarning);
/// <summary>Sorts list view using current sort column and direction.
/// </summary>
/// <remarks>Does nothing if list view hasn't already been sorted.
/// </remarks>
procedure ReSortLV;
/// <summary>Returns given version number formatted as a string.</summary>
function FormatCompilerVer(const Ver: Single): string;
/// <summary>Returns index of list view item associated with warning with
/// given symbol.</summary>
/// <remarks>Returns -1 if warning is not in list.</remarks>
function IndexOfSymbolInLV(const Symbol: string): Integer;
/// <summary>Gets warning symbol entered in edit control.</summary>
/// <param name="Symbol">string [out] Required symbol, trimmed of white
/// space.</param>
/// <returns>Boolean. True if symbol is non-empty string, False if not.
/// </returns>
function GetSymbol(out Symbol: string): Boolean;
/// <summary>Checks if symbol entered in edit control is valid.</summary>
function IsValidSymbol: Boolean;
/// <summary>Gets compiler version entered in edit control.</summary>
/// <param name="Ver">Single [out] Required version number, undefined if
/// not valid.</param>
/// <returns>Boolean. True if version number is valid, False if not.
/// </returns>
function GetCompilerVersion(out Ver: Single): Boolean;
/// <summary>Checks if compiler version entered in edit control is
/// valid.</summary>
function IsValidCompilerVersion: Boolean;
/// <summary>Gets a warning state from radio buttons.</summary>
function GetState: Boolean;
/// <summary>Checks if a warning state has been specified.</summary>
function IsValidState: Boolean;
/// <summary>Populates pre-defined compiler version pop-up menu with menu
/// items.</summary>
procedure PopulatePreDefCompilerMenu;
/// <summary>Selects required switch state in radio buttons.</summary>
procedure SelectSwitchState(const State: Boolean);
/// <summary>Returns warning associated with selected list view item.
/// </summary>
function SelectedWarning: TWarning;
/// <summary>Updates edit controls to reflect properties of warning
/// selected in list view.</summary>
/// <remarks>Nulls edit controls if no warning selected.</remarks>
procedure UpdateControls;
public
/// <summary>Constructs and initiases frame.</summary>
constructor Create(AOwner: TComponent); override;
/// <summary>Records details of warnings from given preferences object and
/// updates controls accordingly.</summary>
/// <remarks>Called when page is activated.</remarks>
procedure Activate(const Prefs: IPreferences); override;
/// <summary>Updates given preferences object with details of warnings as
/// modified by user.</summary>
/// <remarks>Called when page is deactivated.</remarks>
procedure Deactivate(const Prefs: IPreferences); override;
/// <summary>Checks if preference changes require that main window UI is
/// updated.</summary>
/// <remarks>Called when dialog box containing frame is closing. Always
/// returns False because these preferences never affect UI.</remarks>
function UIUpdated: Boolean; override;
/// <summary>Arranges controls on frame.</summary>
/// <remarks>Called after frame has been sized.</remarks>
procedure ArrangeControls; override;
/// <summary>Returns a descriptive name for this frame.</summary>
/// <remarks>Used for display in the tab sheet that contains this frame
/// when displayed in the preferences dialog box.</remarks>
function DisplayName: string; override;
/// <summary>Returns an index number that determines this frame's position
/// in relation to other preferences frames.</summary>
/// <remarks>Used by preferences dialog box to determine ordering of tabs
/// that contain the different preferences frames.</remarks>
class function Index: Byte; override;
end;
implementation
uses
// Delphi
SysUtils, Types,
// Project
FmPreferencesDlg, FmPreviewDlg, IntfCommon, UConsts, UCtrlArranger,
UEncodings, UKeysHelper, UMessageBox, UStrUtils, UUtils;
{$R *.dfm}
type
/// <summary>Custom menu item with additional property to store a compiler
/// version.</summary>
TPreDefCompilerMenuItem = class(TMenuItem)
strict private
var
/// <summary>Value of CompilerVer property</summary>
fCompilerVer: Single;
public
/// <summary>Constructs a menu item will all required properties and event
/// handlers.</summary>
/// <param name="AOwner">TComponent [in] Menu item's owner.</param>
/// <param name="ACaption">string [in] Menu item's caption. Should be name
/// of a compiler.</param>
/// <param name="ACompilerVer">Single [in] Version of compiler named in
/// ACaption</param>
/// <param name="AClickHandler">TNotifyEvent [in] Reference to an event
/// handler for menu item's OnClick event.</param>
constructor Create(AOwner: TComponent; const ACaption: string;
const ACompilerVer: Single; const AClickHandler: TNotifyEvent);
reintroduce;
/// <summary>Version number of compiler whose name is displayed in menu
/// item's caption.</summary>
property CompilerVer: Single read fCompilerVer write fCompilerVer;
end;
type
/// <summary>Custom list item class that adds ability to store a TWarning
/// record with list item.</summary>
TWarningListItem = class(TListItem)
strict private
var
/// <summary>Value of Warning property.</summary>
fWarning: TWarning;
public
/// <summary>Warning associated with list item.</summary>
property Warning: TWarning read fWarning write fWarning;
end;
{ TCodeGenPrefsFrame }
procedure TCodeGenPrefsFrame.actAddExecute(Sender: TObject);
var
W: TWarning; // new warning
Symbol: string; // name of warning's symbol
CompilerVer: Single; // min compiler version that supports warning
begin
// Add new warning from edit controls to fWarnings and list view
GetSymbol(Symbol);
GetCompilerVersion(CompilerVer);
W := TWarning.Create(Symbol, CompilerVer, GetState);
fWarnings.Add(W);
AddWarningToLV(W);
ReSortLV;
// Select new list item and make it visible
fLVWarnings.Selected := fLVWarnings.Items[IndexOfSymbolInLV(Symbol)];
fLVWarnings.Selected.MakeVisible(False);
end;
procedure TCodeGenPrefsFrame.actAddUpdate(Sender: TObject);
var
CanAdd: Boolean; // flag that records whether a warning can be added to list
/// Checks if symbol entered in edit control is a duplicate of an existing
/// symbol in the list view.
function SymbolIsDuplicate: Boolean;
var
Symbol: string; // symbol from edit control
begin
GetSymbol(Symbol);
Result := IndexOfSymbolInLV(Symbol) >= 0;
end;
begin
CanAdd := True;
if not IsValidSymbol then
CanAdd := False
else if SymbolIsDuplicate then
CanAdd := False
else if not IsValidCompilerVersion then
CanAdd := False
else if not IsValidState then
CanAdd := False;
actAdd.Enabled := CanAdd;
end;
procedure TCodeGenPrefsFrame.actDeleteExecute(Sender: TObject);
var
Warning: TWarning; // selected warning
begin
Assert(Assigned(fLVWarnings.Selected),
ClassName + '.actDeleteExecute: No list view item selected');
// Delete selected warning
Warning := SelectedWarning;
fLVWarnings.Selected.Delete;
fWarnings.Delete(Warning);
// Ensure nothing selected in list view and clear edit controls
fLVWarnings.Selected := nil;
UpdateControls;
end;
procedure TCodeGenPrefsFrame.actDeleteUpdate(Sender: TObject);
begin
actDelete.Enabled := Assigned(fLVWarnings.Selected);
end;
procedure TCodeGenPrefsFrame.Activate(const Prefs: IPreferences);
begin
(fWarnings as IAssignable).Assign(Prefs.Warnings);
chkWARNEnabled.Checked := fWarnings.Enabled;
PopulateLV;
end;
procedure TCodeGenPrefsFrame.actPreviewExecute(Sender: TObject);
resourcestring
sCaption = 'Compiler Directives Preview';
begin
TPreviewDlg.Execute(
Self.Owner,
TEncodedData.Create(fWarnings.Render, etUnicode),
dtPlainText,
sCaption
);
end;
procedure TCodeGenPrefsFrame.actPreviewUpdate(Sender: TObject);
begin
actPreview.Enabled := (fLVWarnings.Items.Count > 0)
and chkWARNEnabled.Checked;
end;
procedure TCodeGenPrefsFrame.actRestoreDefaultsExecute(Sender: TObject);
resourcestring
// message displayed in confirmation dialogue box
sConfirmAction = 'Are you sure you want to restore the default directives? '
+ EOL2 + 'All existing custom directives will be lost.';
begin
if not TMessageBox.Confirm(Self, sConfirmAction) then
Exit;
fWarnings := TWarnings.Defaults;
fWarnings.Enabled := chkWARNEnabled.Checked;
PopulateLV;
end;
procedure TCodeGenPrefsFrame.actUpdateExecute(Sender: TObject);
var
NewSymbol: string; // new symbol from edit control
NewCompilerVer: Single; // new compiler version from edit control
NewState: Boolean; // new warning state from radio buttons
SelItem: TListItem; // reference to selected item in list view
OldWarning: TWarning; // warning associated with selected list view item
NewWarning: TWarning; // updated warning
begin
Assert(Assigned(fLVWarnings.Selected),
ClassName + '.actUpdateExecute: no item selected in lvWarnings');
GetSymbol(NewSymbol);
GetCompilerVersion(NewCompilerVer);
NewState := GetState;
SelItem := fLVWarnings.Selected;
OldWarning := SelectedWarning;
NewWarning := TWarning.Create(NewSymbol, NewCompilerVer, NewState);
SetLVItem(SelItem, NewWarning);
ReSortLV;
// we update warnings by deleting old one and adding updated version
fWarnings.Delete(OldWarning);
fWarnings.Add(NewWarning);
// Ensure updated item is still selected in list view and is visible
fLVWarnings.Selected := SelItem;
SelItem.MakeVisible(False);
end;
procedure TCodeGenPrefsFrame.actUpdateUpdate(Sender: TObject);
var
CanUpdate: Boolean; // flag that indicates if a warning can be updated
/// Checks if symbol entered in edit control is a duplicate of an existing
/// symbol in the list view, other than that of the selected warning.
function SymbolIsDuplicate: Boolean;
var
Symbol: string; // symbol entered in edit control
LIIdx: Integer; // index of list item with Symbol as caption
begin
GetSymbol(Symbol);
LIIdx := IndexOfSymbolInLV(Symbol);
Result := (LIIdx >= 0) and (LIIdx <> fLVWarnings.Selected.Index);
end;
begin
CanUpdate := True;
if fLVWarnings.Selected = nil then
CanUpdate := False
else if not IsValidSymbol then
CanUpdate := False
else if SymbolIsDuplicate then
CanUpdate := False
else if not IsValidCompilerVersion then
CanUpdate := False
else if not IsValidState then
CanUpdate := False;
actUpdate.Enabled := CanUpdate;
end;
procedure TCodeGenPrefsFrame.AddWarningToLV(const Warning: TWarning);
var
LI: TListItem; // new list item for warning
begin
LI := fLVWarnings.Items.Add;
SetLVItem(LI, Warning);
end;
procedure TCodeGenPrefsFrame.ArrangeControls;
begin
btnPreview.Left := Width - btnPreview.Width;
fLVWarnings.Width := Width;
TCtrlArranger.AlignVCentres(0, [chkWARNEnabled, btnPreview]);
fLVWarnings.Top := TCtrlArranger.BottomOf([chkWARNEnabled, btnPreview], 8);
TCtrlArranger.AlignVCentres(
TCtrlArranger.BottomOf(fLVWarnings, 8),
[lblSymbol, edSymbol]
);
TCtrlArranger.AlignVCentres(
TCtrlArranger.BottomOf([lblSymbol, edSymbol], 8),
[lblMinCompiler, edMinCompiler, btnPredefined]
);
TCtrlArranger.AlignVCentres(
TCtrlArranger.BottomOf([lblMinCompiler, edMinCompiler, btnPredefined], 8),
[lblState, rbStateOff, rbStateOn]
);
TCtrlArranger.AlignVCentres(
TCtrlArranger.BottomOf([lblState, rbStateOff, rbStateOn], 8),
[btnAdd, btnDelete, btnUpdate, btnRestoreDefaults]
);
btnRestoreDefaults.Left :=
fLVWarnings.Left + fLVWarnings.Width - btnRestoreDefaults.Width;
end;
procedure TCodeGenPrefsFrame.btnPredefinedClick(Sender: TObject);
var
PopupPos: TPoint; // place where menu pops up
begin
PopupPos := ClientToScreen(
Point(btnPredefined.Left, btnPredefined.Top + btnPredefined.Height)
);
mnuPreDefCompilers.Popup(PopupPos.X, PopupPos.Y);
end;
procedure TCodeGenPrefsFrame.chkWARNEnabledClick(Sender: TObject);
begin
fWarnings.Enabled := chkWARNEnabled.Checked;
end;
constructor TCodeGenPrefsFrame.Create(AOwner: TComponent);
begin
inherited;
HelpKeyword := 'CodeGenPrefs';
fWarnings := TWarnings.Create;
PopulatePreDefCompilerMenu;
CreateLV;
end;
procedure TCodeGenPrefsFrame.CreateLV;
resourcestring
// column header captions
sSymbolColCaption = 'Symbol';
sMinCompilerColCaption = 'Min. Compiler';
sStateColCaption = 'State';
begin
fLVWarnings := TListViewEx.Create(Self);
with fLVWarnings do
begin
Parent := Self;
Height := 150;
Left := 0;
HideSelection := False;
ReadOnly := True;
RowSelect := True;
TabOrder := 2;
ViewStyle := vsReport;
SortImmediately := False;
with Columns.Add do
begin
Caption := sSymbolColCaption;
Width := 240;
end;
with Columns.Add do
begin
Caption := sMinCompilerColCaption;
Width := 100;
end;
with Columns.Add do
begin
Caption := sStateColCaption;
Width := 50;
end;
OnSelectItem := LVWarningsSelected;
OnCompare := LVWarningsCompare;
OnCreateItemClass := LVWarningsCreateItemClass;
end;
end;
procedure TCodeGenPrefsFrame.Deactivate(const Prefs: IPreferences);
begin
fWarnings.Enabled := chkWARNEnabled.Checked;
Prefs.Warnings := fWarnings;
end;
function TCodeGenPrefsFrame.DisplayName: string;
resourcestring
sDisplayName = 'Code Generation';
begin
Result := sDisplayName;
end;
procedure TCodeGenPrefsFrame.edMinCompilerKeyPress(Sender: TObject;
var Key: Char);
begin
if not IsValidDecimalNumberKey((Sender as TEdit).Text, Key) then
KeyErrorBeep;
end;
function TCodeGenPrefsFrame.FormatCompilerVer(const Ver: Single): string;
begin
Result := Format('%.2f', [Ver]);
end;
function TCodeGenPrefsFrame.GetCompilerVersion(out Ver: Single): Boolean;
var
ExtVer: Extended; // version number as Extended float
begin
Result := TryStrToFloat(StrTrim(edMinCompiler.Text), ExtVer);
if Result then
Ver := ExtVer;
end;
function TCodeGenPrefsFrame.GetState: Boolean;
begin
// Only valid iff one radio button is checked
Result := rbStateOn.Checked;
end;
function TCodeGenPrefsFrame.GetSymbol(out Symbol: string): Boolean;
begin
Symbol := StrTrim(edSymbol.Text);
Result := Symbol <> '';
end;
class function TCodeGenPrefsFrame.Index: Byte;
begin
Result := 15;
end;
function TCodeGenPrefsFrame.IndexOfSymbolInLV(const Symbol: string): Integer;
var
LI: TListItem; // each list item in list view
begin
for LI in fLVWarnings.Items do
begin
if StrSameText(Symbol, LI.Caption) then
Exit(LI.Index);
end;
Result := -1;
end;
function TCodeGenPrefsFrame.IsValidCompilerVersion: Boolean;
var
Ver: Single; // compiler version from edit control
begin
Result := GetCompilerVersion(Ver);
if Result then
Result := Ver >= TWarning.MinSupportedCompiler;
end;
function TCodeGenPrefsFrame.IsValidState: Boolean;
begin
Result := rbStateOff.Checked <> rbStateOn.Checked;
end;
function TCodeGenPrefsFrame.IsValidSymbol: Boolean;
var
Symbol: string; // stores symbol: unused
begin
Result := GetSymbol(Symbol);
end;
function TCodeGenPrefsFrame.LVColumnText(const LI: TListItem;
const Idx: Integer): string;
begin
if Idx = 0 then
Result := LI.Caption
else
Result := LI.SubItems[Idx - 1];
end;
procedure TCodeGenPrefsFrame.LVWarningsCompare(Sender: TObject; Item1,
Item2: TListItem; Data: Integer; var Compare: Integer);
begin
Compare := StrCompareText(
LVColumnText(Item1, Data + 1), LVColumnText(Item2, Data + 1)
);
if fLVWarnings.SortOrder = soDown then
Compare := -Compare;
end;
procedure TCodeGenPrefsFrame.LVWarningsCreateItemClass(Sender: TCustomListView;
var ItemClass: TListItemClass);
begin
ItemClass := TWarningListItem;
end;
procedure TCodeGenPrefsFrame.LVWarningsSelected(Sender: TObject;
Item: TListItem; Selected: Boolean);
begin
if Selected and Assigned(fLVWarnings.Selected) then
UpdateControls;
end;
procedure TCodeGenPrefsFrame.PopulateLV;
var
W: TWarning; // references each warning
begin
fLVWarnings.Items.BeginUpdate;
try
fLVWarnings.Clear;
for W in fWarnings do
AddWarningToLV(W);
fLVWarnings.Selected := nil;
ReSortLV;
finally
fLVWarnings.Items.EndUpdate;
end;
UpdateControls;
end;
procedure TCodeGenPrefsFrame.PopulatePreDefCompilerMenu;
/// Adds a menu item for given compiler name and version to the pop-up menu.
procedure AddMenuItem(const Compiler: string; const Ver: Single);
begin
mnuPreDefCompilers.Items.Add(
TPreDefCompilerMenuItem.Create(
mnuPreDefCompilers, Compiler, Ver, PreDefCompilerMenuClick
)
);
end;
begin
AddMenuItem('Delphi 6', 14.0);
AddMenuItem('Delphi 7', 15.0);
AddMenuItem('Delphi 2005', 17.0);
AddMenuItem('Delphi 2006', 18.0);
AddMenuItem('Delphi 2007 (Win 32)', 18.5);
AddMenuItem('Delphi 2009', 20.0);
AddMenuItem('Delphi 2010', 21.0);
AddMenuItem('Delphi XE', 22.0);
AddMenuItem('Delphi XE2', 23.0);
AddMenuItem('Delphi XE3', 24.0);
AddMenuItem('Delphi XE4', 25.0);
AddMenuItem('Delphi XE5', 26.0);
end;
procedure TCodeGenPrefsFrame.PreDefCompilerMenuClick(Sender: TObject);
begin
edMinCompiler.Text := FormatCompilerVer(
(Sender as TPreDefCompilerMenuItem).CompilerVer
);
end;
procedure TCodeGenPrefsFrame.ReSortLV;
begin
if fLVWarnings.SortColumn <> -1 then
fLVWarnings.CustomSort(nil, fLVWarnings.SortColumn - 1);
end;
function TCodeGenPrefsFrame.SelectedWarning: TWarning;
begin
Assert(Assigned(fLVWarnings.Selected),
ClassName + '.SelectedWarning: No warning selected in list view');
Result := (fLVWarnings.Selected as TWarningListItem).Warning;
end;
procedure TCodeGenPrefsFrame.SelectSwitchState(const State: Boolean);
begin
if State then
rbStateOn.Checked := True
else
rbStateOff.Checked := True;
end;
procedure TCodeGenPrefsFrame.SetLVItem(const LI: TListItem;
const Warning: TWarning);
resourcestring
sOn = 'On';
sOff = 'Off';
const
// Map of warning state onto description
StateDescs: array[Boolean] of string = (sOff, sOn);
begin
LI.Caption := Warning.Symbol;
while LI.SubItems.Count < 2 do
LI.SubItems.Add('');
LI.SubItems[0] := FormatCompilerVer(Warning.MinCompiler);
LI.SubItems[1] := StateDescs[Warning.State];
(LI as TWarningListItem).Warning := Warning;
end;
function TCodeGenPrefsFrame.UIUpdated: Boolean;
begin
Result := False;
end;
procedure TCodeGenPrefsFrame.UpdateControls;
begin
if Assigned(fLVWarnings.Selected) then
begin
edSymbol.Text := SelectedWarning.Symbol;
edMinCompiler.Text := FormatCompilerVer(SelectedWarning.MinCompiler);
SelectSwitchState(SelectedWarning.State);
end
else
begin
edSymbol.Text := '';
edMinCompiler.Text := '';
rbStateOff.Checked := True;
end;
end;
{ TPreDefCompilerMenuItem }
constructor TPreDefCompilerMenuItem.Create(AOwner: TComponent;
const ACaption: string; const ACompilerVer: Single;
const AClickHandler: TNotifyEvent);
begin
inherited Create(AOwner);
Caption := ACaption;
CompilerVer := ACompilerVer;
OnClick := AClickHandler;
end;
initialization
// Register frame with preferences dialog box
TPreferencesDlg.RegisterPage(TCodeGenPrefsFrame);
end.
