{
* FmCompilersDlg.pas
*
* Implements a dialog box where the user can configure which Pascal compilers
* installed on the local system can be used by CodeSnip.
*
* v0.1 of 04 Mar 2005 - Original version.
* v0.2 of 20 Apr 2005 - Changed to use renamed IntfCompilers unit.
* v0.3 of 08 Jan 2006 - Fixed display bug where alignment of bold compiler
* names in list box was wrong.
* - Changed to use revised compiler auto detection
* mechanism.
* - Separated data entry into three tabs with compiler
* path on first, log filters on third and new command
* line switch set up on second tab.
* v0.4 of 10 Jan 2006 - Removed unsupported properties from form on reversion
* to Delphi 7.
* v1.0 of 30 May 2006 - Improved and corrected comments.
* - Relocated and rationalised $WARN directives.
* - Removed unused unit reference.
* - Changed Execute method to function that returns True
* if user OKd and False otherwise.
* - Changed name of Log Files tab to Output Log and
* changed some text on tab.
* v1.1 of 21 Nov 2006 - Changed selected compiler title to have a gradient
* filled background and to dim titles of unavailable
* compilers.
* - Also made compiler logos all same size.
* v1.2 of 08 Feb 2007 - Moved code that displays document from FormShow event
* handler to new overridden InitForm method and moved
* data initialisation code into FormCreate event
* handler. Deleted FormShow.
* v1.3 of 04 Nov 2007 - Removed the IAssignable cast from the parameter to
* IAssignable.Assign method calls.
* v1.4 of 10 Aug 2008 - Changed to use a dynamically created open file dialog
* box that can be aligned to over dialog and that
* behaves correctly with the Vista task bar.
* - Supplied help keyword to file open dialog box.
* - Current compiler executable files are selected in open
* file dialog when being edited.
* - Detection of non-existant files is now handled in this
* code rather automatically by file open dialog box.
* v1.5 of 11 Aug 2008 - Replaced calls to ThemeServices with ThemeServicesEx.
* v1.6 of 25 Aug 2008 - Added checks that compiler executable files exists and
* are valid executable files.
* - Added Clear button to Compiler tab that clears file
* name from edit box.
* - Fixed tab order problem.
* - Changed to use for..in loops to enumerate compilers.
* v1.7 of 15 Dec 2008 - Modified to use TRectEx record instead of TRect.
* - Made private and protected sections strict.
* - Fixed minor bug where open dialog could fail to detect
* a non-existant file.
* v1.8 of 09 Jan 2009 - Now accepts a compilers object as parameter to Execute
* method rather than operating on singletion object.
* v1.9 of 25 Jan 2009 - Revised to used renamed ICompilers.GetGlyph method.
* v1.10 of 19 Jul 2009 - Modified to accommodate the new Vista default font in
* controls.
* - Controls now dynamically arranged and column widths in
* value editor now depend on font size.
*
*
* ***** BEGIN LICENSE BLOCK *****
*
* Version: MPL 1.1
*
* 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 FmCompilersDlg.pas
*
* The Initial Developer of the Original Code is Peter Johnson
* (http://www.delphidabbler.com/).
*
* Portions created by the Initial Developer are Copyright (C) 2005-2009 Peter
* Johnson. All Rights Reserved.
*
* ***** END LICENSE BLOCK *****
}
unit FmCompilersDlg;
{$WARN UNSAFE_CODE OFF}
interface
uses
// Delphi
Grids, ValEdit, StdCtrls, ComCtrls, Controls, ExtCtrls, Classes, Windows,
// Project
FmGenericOKDlg, IntfCompilers;
type
{
TCompilersDlg:
Implements a dialog box where the user can configure which Pascal compilers
installed on the local system can be used by CodeSnip.
}
TCompilersDlg = class(TGenericOKDlg)
btnAdd: TButton;
btnBrowse: TButton;
btnClear: TButton;
btnDefSwitches: TButton;
btnDelete: TButton;
btnDetect: TButton;
btnReplace: TButton;
edCompilerPath: TEdit;
edSwitch: TEdit;
lbCompilers: TListBox;
lblExplainSwitches: TLabel;
lblCompilerPath: TLabel;
lblLogPrefixes: TLabel;
lblSwitch: TLabel;
lblSwitches: TLabel;
lbSwitches: TListBox;
pbCompiler: TPaintBox;
pcCompiler: TPageControl;
tsExecFile: TTabSheet;
tsOutputLog: TTabSheet;
tsSwitches: TTabSheet;
vleLogPrefixes: TValueListEditor;
procedure btnAddClick(Sender: TObject);
procedure btnBrowseClick(Sender: TObject);
procedure btnClearClick(Sender: TObject);
procedure btnDefSwitchesClick(Sender: TObject);
procedure btnDeleteClick(Sender: TObject);
procedure btnDetectClick(Sender: TObject);
procedure btnOKClick(Sender: TObject);
procedure btnReplaceClick(Sender: TObject);
procedure edCompilerPathExit(Sender: TObject);
procedure edSwitchChange(Sender: TObject);
procedure FormCreate(Sender: TObject);
procedure lbCompilersClick(Sender: TObject);
procedure lbCompilersDrawItem(Control: TWinControl; Index: Integer;
Rect: TRect; State: TOwnerDrawState);
procedure lbSwitchesClick(Sender: TObject);
procedure pbCompilerPaint(Sender: TObject);
procedure vleLogPrefixesDrawCell(Sender: TObject; ACol, ARow: Integer;
Rect: TRect; State: TGridDrawState);
procedure vleLogPrefixesSelectCell(Sender: TObject; ACol, ARow: Integer;
var CanSelect: Boolean);
strict private
fCurCompiler: ICompiler;
{Reference to currently selected compiler}
fLocalCompilers: ICompilers;
{Local copy of global Compilers that is edited in dialog box}
procedure SelectCompiler;
{Stores reference to currently selected local compiler and updates dialog
box controls with details of the compiler.
}
procedure UpdateCurrentCompiler;
{Updates local copy of currently selected compiler with entries in dialog
box.
}
procedure PopulateSwitchList(const Switches: string);
{Stores list of command line switches in list box.
@param Switches [in] Comma separated list of required switches.
}
procedure UpdateSwitchButtons;
{Updates state of buttons that manipulate command line switches depending
on state of switch edit and list boxes.
}
procedure CanOpenDialogClose(Sender: TObject; var CanClose: Boolean);
{Handles open dialog box's OnCanClose event. Prevents dialog from closing
if selected file does not exist or if it is not an executable file.
@param Sender [in] Reference to dialog box that triggered event. Must be
of type TOpenDialogEx.
@param CanClose [in/out] Flag that determines if dialog can close. Set
to False to prevent closure or True to permit it.
}
function CheckCompilerExes: Boolean;
{Checks that all paths assigned as executable files for compilers are
valid Windows 32 executables.
@return True if all compiler exes are valid, False if an error is found.
}
strict protected
procedure InitForm; override;
{Populates and initialises controls.
}
procedure ArrangeForm; override;
{Dynamically sizes and aligns controls to allow for Vista UI font. Also
adjusts position of "Auto Detect Compilers" button on bottom button line.
}
public
class function Execute(AOwner: TComponent;
const ACompilers: ICompilers): Boolean;
{Displays the dialog box. The dialog updates a compilers object if user
OKs
@param AOwner [in] Control that owns this dialog.
@param ACompilers [in] Compilers object to be updated.
@return True if user OKs and compiler information is updated or False
if user cancels and compiler information is unchanged.
}
end;
implementation
uses
// Delphi
SysUtils, Graphics, GraphUtil, Dialogs,
// Project
IntfCommon, UCompilers, UExeFileType, UGraphicUtils, UMessageBox,
UOpenDialogEx, UOpenDialogHelper, UStructs, UThemesEx, UUtils;
{$R *.dfm}
{ TCompilersDlg }
procedure TCompilersDlg.ArrangeForm;
{Dynamically sizes and aligns controls to allow for Vista UI font. Also
adjusts position of "Auto Detect Compilers" button on bottom button line.
}
// ---------------------------------------------------------------------------
procedure SetLabelHeight(const Lbl: TLabel);
{Sets height of a label to accommodate the text it contains in its font.
@param Lbl [in] Label whose height is to be set.
}
begin
Lbl.Height := StringExtent(Lbl.Caption, Lbl.Font, Lbl.Width).cy;
end;
function BottomOf(const Ctrl: TControl): Integer;
{Gets position of bottom of a control relative to its parent control in
pixels.
@param Ctr [in] Control to check.
@return Required position.
}
begin
Result := Ctrl.Top + Ctrl.Height;
end;
function VCentre(const ATop: Integer;
const Ctrls: array of TControl): Integer;
{Vertically centres a list of controls.
@param ATop [in] Top tallest control to be aligned.
@param Ctrls [in] Array of controls to be aligned.
@return Height occupied by controls (= height of tallest control).
}
var
I: Integer; // loops thru all controls to be aligned
begin
Result := 0;
for I := Low(Ctrls) to High(Ctrls) do
if Ctrls[I].Height > Result then
Result := Ctrls[I].Height;
for I := Low(Ctrls) to High(Ctrls) do
Ctrls[I].Top := ATop + (Result - Ctrls[I].Height) div 2;
end;
// ---------------------------------------------------------------------------
var
ATop: Integer; // top of a control
RowIdx: Integer; // loops through rows of vleLogPrefixes
CellSize: TSize; // size of left hand cell in vleLogPrefixes
begin
// Arrange controls on tabs
// tsExecFile
ATop := BottomOf(lblCompilerPath) + 4;
ATop := ATop + VCentre(ATop, [edCompilerPath, btnBrowse]) + 8;
btnClear.Top := ATop;
// tsSwitches
edSwitch.Top := BottomOf(lblSwitch) + 4;
lblSwitches.Top := BottomOf(edSwitch) + 8;
SetLabelHeight(lblExplainSwitches);
lblExplainSwitches.Top := BottomOf(btnDelete) + 8;
lbSwitches.Top := lblExplainSwitches.Top;
lblSwitches.Top := lbSwitches.Top - lblSwitches.Height - 4;
// tsOutputLog
vleLogPrefixes.Top := BottomOf(lblLogPrefixes) + 4;
// size rows and columns in value editor
for RowIdx := 0 to Pred(vleLogPrefixes.RowCount) do
begin
CellSize := StringExtent(vleLogPrefixes.Keys[RowIdx], vleLogPrefixes.Font);
if CellSize.cx > vleLogPrefixes.ColWidths[0] then
vleLogPrefixes.ColWidths[0] := CellSize.cx;
if CellSize.cy > vleLogPrefixes.RowHeights[RowIdx] then
vleLogPrefixes.RowHeights[RowIdx] := CellSize.cy;
end;
vleLogPrefixes.ColWidths[0] := vleLogPrefixes.ColWidths[0] + 16;
vleLogPrefixes.ColWidths[1] :=
vleLogPrefixes.Width - vleLogPrefixes.ColWidths[0];
// Size dialog and arrange inherited controls
inherited;
// Arrange Auto-detect button in bottom button line
btnDetect.Left := pnlBody.Left;
btnDetect.Top := btnHelp.Top;
end;
procedure TCompilersDlg.btnAddClick(Sender: TObject);
{Handles click on Add button on Command Line tab. Adds any new switch in edit
box to list.
@param Sender [in] Not used.
}
begin
lbSwitches.Items.Add(Trim(edSwitch.Text));
edSwitch.Text := '';
UpdateSwitchButtons;
end;
procedure TCompilersDlg.btnBrowseClick(Sender: TObject);
{Handles a click on the Browse button on Compiler tab. Displays open files
dialog and copies name of any selected file into the compiler path edit box.
@param Sender [in] Not used.
}
var
OpenDlg: TOpenDialogEx; // self-aligning enhanced open dialog box
DefFileName: string; // default file name passed to open dialog box
resourcestring
sFilter = 'Executable files (*.exe)|*.exe|' // file filter
+ 'All files (*.*)|*.*';
sTitle = 'Select Compiler'; // dialog box title
begin
// Create and initialise
OpenDlg := TOpenDialogEx.Create(Self);
try
OpenDlg.OnCanClose := CanOpenDialogClose;
OpenDlg.Filter := sFilter;
OpenDlg.FilterIndex := 1;
OpenDlg.InitialDir := '';
// we don't include ofFileMustExist in Options below since we handle
// non-existant files ourselves
// we don't include ofShowHelp since the dialog box automatically displays
// help if HelpKeyword property is set.
OpenDlg.Options := [ofHideReadOnly, ofEnableSizing];
OpenDlg.OptionsEx := [];
OpenDlg.Title := sTitle;
OpenDlg.HelpKeyword := 'SelectCompilerDlg';
// if we have a compiler path use it as default if it exists
DefFileName := edCompilerPath.Text;
if FileExists(DefFileName) then
OpenDlg.FileName := DefFileName;
if OpenDlg.Execute then
begin
// User OKd: use entered file name
edCompilerPath.Text := OpenDlg.FileName;
UpdateCurrentCompiler;
end;
finally
FreeAndNil(OpenDlg);
end;
end;
procedure TCompilersDlg.btnClearClick(Sender: TObject);
{Handles click on Clear button on Compiler tab. Clears file name.
@param Sender [in] Not used.
}
begin
edCompilerPath.Text := '';
end;
procedure TCompilersDlg.btnDefSwitchesClick(Sender: TObject);
{Handles click on Defaults button on Command Line tab. Restores command line
switches to default for compiler.
@param Sender [in] Not used.
}
begin
PopulateSwitchList(fCurCompiler.GetDefaultSwitches);
UpdateSwitchButtons;
end;
procedure TCompilersDlg.btnDeleteClick(Sender: TObject);
{Handles click on Delete button on Command Line tab. Deletes selected switch.
@param Sender [in] Not used.
}
begin
Assert(lbSwitches.ItemIndex >= 0);
lbSwitches.Items.Delete(lbSwitches.ItemIndex);
UpdateSwitchButtons;
end;
procedure TCompilersDlg.btnDetectClick(Sender: TObject);
{Handles click on Auto Detect Compilers button. Sets executbale program path
for each compiler present that can detect its own path.
@param Sender [in] Not used.
}
var
Compiler: ICompiler; // refers to each compiler
resourcestring
// Text displayed in confirmation box
sOKToDetect = 'Detected compiler file names will overwrite any existing '
+ 'paths. Do you wish to continue?';
begin
if not TMessageBox.Confirm(Self, sOKToDetect) then
Exit;
// Loop thru all compilers attempting to detect exe files
for Compiler in fLocalCompilers do
begin
if Supports(Compiler, ICompilerAutoDetect) then
begin
if (Compiler as ICompilerAutoDetect).DetectExeFile then
begin
// Display file name in edit box if compiler is displayed
if Compiler.GetID = fCurCompiler.GetID then
edCompilerPath.Text := Compiler.GetExecFile;
UpdateCurrentCompiler;
end;
end;
end;
// Redisplay compiler list and current compiler title to reflect any changes
lbCompilers.Invalidate;
pbCompiler.Refresh;
end;
procedure TCompilersDlg.btnOKClick(Sender: TObject);
{Handles OK button click. Update globals Compilers object and saves details to
persistent storage.
@param Sender [in] Not used.
}
begin
inherited;
// Ensure compiler object is up to date
UpdateCurrentCompiler;
// Check assigned exe files
if not CheckCompilerExes then
begin
ModalResult := mrNone;
Exit;
end;
ModalResult := mrOK;
end;
procedure TCompilersDlg.btnReplaceClick(Sender: TObject);
{Handles click on Replace button on Command Line tab. Replaces selected switch
with new value.
@param Sender [in] Not used.
}
begin
Assert(lbSwitches.ItemIndex >= 0);
lbSwitches.Items[lbSwitches.ItemIndex] := Trim(edSwitch.Text);
edSwitch.Text := '';
UpdateSwitchButtons;
end;
procedure TCompilersDlg.CanOpenDialogClose(Sender: TObject;
var CanClose: Boolean);
{Handles open dialog box's OnCanClose event. Prevents dialog from closing if
selected file does not exist.
@param Sender [in] Reference to dialog box that triggered event. Must be of
type TOpenDialogEx.
@param CanClose [in/out] Flag that determines if dialog can close. Set to
False to prevent closure or True to permit it.
}
var
Dlg: TOpenDialogEx; // dialog box instance triggering this event
FileSpec: string; // name of file entered or selected in dialog box
resourcestring
// Error messages
sFileDoesNotExist = '"%s" does not exist.';
sFileNotExe = '"%s" is not an executable file.';
begin
Dlg := Sender as TOpenDialogEx;
// Assume dialog can't close
CanClose := False;
// Get file name from dialog, allowing for users editing
FileSpec := FileOpenEditedFileName(Dlg);
// Check that file exists
if not FileExists(FileSpec) then
begin
TMessageBox.Error(Dlg, Format(sFileDoesNotExist, [FileSpec]));
Exit;
end;
// Check file is valid exe file
if ExeFileType(FileSpec) <> fkExe32 then
begin
TMessageBox.Error(Dlg, Format(sFileNotExe, [FileSpec]));
Exit;
end;
// Everything's OK: permit closure
CanClose := True;
end;
function TCompilersDlg.CheckCompilerExes: Boolean;
{Checks that all paths assigned as executable files for compilers are valid
Windows 32 executables.
@return True if all compiler exes are valid, False if an error is found.
}
var
Compiler: ICompiler; // refers to each compiler
resourcestring
// Error messages
sFileDoesNotExist = 'File specified for %s compiler doesn''t exist.';
sFileNotExe = 'File specified for %s compiler is not a valid executable file';
begin
Result := False;
// Scan through compilers to see if paths are valid
for Compiler in fLocalCompilers do
begin
if Compiler.GetExecFile = '' then
Continue;
if not FileExists(Compiler.GetExecFile) then
begin
TMessageBox.Error(Self, Format(sFileDoesNotExist, [Compiler.GetName]));
Exit;
end;
if ExeFileType(Compiler.GetExecFile) <> fkExe32 then
begin
TMessageBox.Error(Self, Format(sFileNotExe, [Compiler.GetName]));
Exit;
end;
end;
Result := True;
end;
procedure TCompilersDlg.edCompilerPathExit(Sender: TObject);
{Updates state of selected compiler when cursor leaves compiler edit control.
@param Sender [in] Not used.
}
begin
UpdateCurrentCompiler;
end;
procedure TCompilersDlg.edSwitchChange(Sender: TObject);
{Handles changes in switch edit box on Command Line tab. Updates tab's
controls.
@param Sender [in] Not used.
}
begin
UpdateSwitchButtons;
end;
class function TCompilersDlg.Execute(AOwner: TComponent;
const ACompilers: ICompilers): Boolean;
{Displays the dialog box. The dialog updates a compilers object if user OKs
@param AOwner [in] Control that owns this dialog.
@param ACompilers [in] Compilers object to be updated.
@return True if user OKs and compiler information is updated or False if
user cancels and compiler information is unchanged.
}
var
Persister: IPersistCompilers; // object used to save object to storage
begin
with TCompilersDlg.Create(AOwner) do
try
(fLocalCompilers as IAssignable).Assign(ACompilers);
Result := ShowModal = mrOK;
if Result then
begin
(ACompilers as IAssignable).Assign(fLocalCompilers);
Persister := TPersistCompilers.Create;
Persister.Save(ACompilers);
end;
finally
Free;
end;
end;
procedure TCompilersDlg.FormCreate(Sender: TObject);
{Initialises compiler information when form is created.
}
begin
inherited;
// Take a copy of global compilers object: stores updates until OK clicked
fLocalCompilers := TCompilersFactory.CreateCompilers;
end;
procedure TCompilersDlg.InitForm;
{Populates and initialises controls.
}
var
CompID: TCompilerID; // loops thru supported compilers
begin
inherited;
// Add empty list items: one per supported compiler
// (note we don't need item text since we handle drawing of dialog ourselves
// and get display details from compiler objects
for CompID := Low(TCompilerID) to High(TCompilerID) do
lbCompilers.Items.Add('');
// Select first compiler in list and display its details in dialog controls
lbCompilers.ItemIndex := 0;
SelectCompiler;
end;
procedure TCompilersDlg.lbCompilersClick(Sender: TObject);
{Handles a click on compilers list. Updates compiler that is being deselected
with details in dialog box controls then displays details of newly selected
compiler.
@param Sender [in] Not used.
}
begin
UpdateCurrentCompiler;
SelectCompiler;
end;
procedure TCompilersDlg.lbCompilersDrawItem(Control: TWinControl;
Index: Integer; Rect: TRect; State: TOwnerDrawState);
{Handles draw item event for compilers list box. We display compiler name and
any associated glyph. Compilers that a available for use by CodeSnip appear in
bold. A separator line appears between each list item.
@param Control [in] Reference to list box.
@param Index [in] Index of list item being drawn.
@param Rect [in] Bounding rectangle of list item being drawn.
@param State [in] State of control: focussed, selected etc.
}
var
LB: TListBox; // list box being drawn
TxtExtent: TSize; // extent of text to be displayed
ItemRect: TRectEx; // extended rectangle bounding the item being drawn
ImgRect: TRectEx; // bounding rectangle of any glyph
TxtRect: TRectEx; // bounding rectangle of text to be drawn
Bmp: TBitmap; // reference to bitmap to be displayed (or nil if none)
DrawHeight: Integer; // total height of drawing (text below bitmap)
Compiler: ICompiler; // reference to compiler associated with list item
begin
// Copy item rectangle as extended rect
ItemRect := Rect;
// Get reference to list box control
LB := Control as TListBox;
// Get reference to compiler object associated with list item and its bitmap
Compiler := fLocalCompilers[TCompilerID(Index)];
Bmp := Compiler.GetGlyph;
// Set font style: bold if compiler available
if Compiler.IsAvailable then
LB.Canvas.Font.Style := [fsBold]
else
LB.Canvas.Font.Style := [];
// Calculate display rectangles for text and any bitmap
TxtExtent := LB.Canvas.TextExtent(Compiler.GetName);
if Assigned(Bmp) then
begin
// Bitmap included: bitmap drawn above text and bounding box or both centred
// horizontally and vertically
DrawHeight := TxtExtent.cy + 2 + Bmp.Height;
ImgRect := TRectEx.CreateBounds(
(ItemRect.Left + ItemRect.Right - Bmp.Width) div 2,
(ItemRect.Top + ItemRect.Bottom - DrawHeight) div 2,
Bmp.Width,
Bmp.Height
);
TxtRect := TRectEx.CreateBounds(
(ItemRect.Left + ItemRect.Right - TxtExtent.cx) div 2,
ImgRect.Bottom + 2,
TxtExtent
);
end
else
begin
// No bitmap: text centred vertically and horizontally
TxtRect := TRectEx.CreateBounds(
(ItemRect.Left + ItemRect.Right - TxtExtent.cx) div 2,
(ItemRect.Top + ItemRect.Bottom - TxtExtent.cy) div 2,
TxtExtent
);
end;
// Erase background
LB.Canvas.Pen.Color := LB.Color;
LB.Canvas.Brush.Color := LB.Color;
LB.Canvas.FillRect(ItemRect);
// Draw any highlighting
if (odFocused in State) or (odSelected in State) then
begin
if ThemeServicesEx.ThemesEnabled then
begin
// themes are enabled
if (odFocused in State) then
begin
// focussed: draw highlight based on highlight colour and highlight text
LB.Canvas.Brush.Color := GetHighLightColor(clHighlight);
LB.Canvas.Pen.Color := GetShadowColor(LB.Canvas.Brush.Color);
LB.Canvas.Font.Color := clHighlightText;
end
else
begin
// not focussed: draw highlight in button face and standard text colour
LB.Canvas.Brush.Color := clBtnFace;
LB.Canvas.Pen.Color := GetShadowColor(clBtnFace);
LB.Canvas.Font.Color := LB.Font.Color;
end;
end
else
begin
// themes are not available: use a more classic style
if (odFocused in State) then
begin
// focussed: draw highlight in highlight colour
LB.Canvas.Brush.Color := clHighlight;
LB.Canvas.Pen.Color := GetShadowColor(LB.Canvas.Brush.Color);
LB.Canvas.Font.Color := clHighlightText;
end
else
begin
// not focussed: draw using button colour
LB.Canvas.Brush.Color := clBtnFace;
LB.Canvas.Pen.Color := GetShadowColor(clBtnFace);
LB.Canvas.Font.Color := LB.Font.Color;
end;
end;
// draw the highlight (smaller than item's rectangle)
LB.Canvas.Rectangle(ItemRect.Inflate(-4, -4));
end
else
// no highlighting: just ensure font colour correct
LB.Canvas.Font.Color := LB.Font.Color;
// Draw text and any bitamp
LB.Canvas.TextOut(TxtRect.Left, TxtRect.Top, Compiler.GetName);
if Assigned(Bmp) then
LB.Canvas.BrushCopy(ImgRect, Bmp, Bmp.Canvas.ClipRect, clFuchsia);
// Draw separator line if item not last one
if Index < Pred(LB.Count) then
begin
LB.Canvas.Pen.Color := clBtnShadow;
LB.Canvas.MoveTo(ItemRect.Left + 4, ItemRect.Bottom - 1);
LB.Canvas.LineTo(ItemRect.Right - 4, ItemRect.Bottom - 1);
end;
// Remove any focus rectangle
if odFocused in State then
LB.Canvas.DrawFocusRect(ItemRect);
end;
procedure TCompilersDlg.lbSwitchesClick(Sender: TObject);
{Handles click on switches list on Command Line tab. Copies selected switch to
edit box and updates tab's buttons.
@param Sender [in] Not used.
}
begin
edSwitch.Text := lbSwitches.Items[lbSwitches.ItemIndex];
UpdateSwitchButtons;
edSwitch.SetFocus;
end;
procedure TCompilersDlg.pbCompilerPaint(Sender: TObject);
{Handles paint event of paint box used to show name and glyph of selected
compiler.
@param Sender [in] Reference to paint box control.
}
// ---------------------------------------------------------------------------
procedure RenderCompilerTitle(const Canvas: TCanvas; const Rect: TRectEx);
{Displays compiler title on a gradient background.
@param Canvas [in] Canvas on which to display title.
@param Rect [in] Bounding rectangle of title.
}
const
cLeftMargin = 2; // margin between edge of canvas and logo or text
cLogoPadding = 6; // padding between logo and text
var
GradColor1: TColor; // primary gradient colour
GradColor2: TColor; // secondary gradient colour
CompilerLogo: TBitmap; // glyph of compiler logo or nil
CompilerName: string; // name of compiler to be displayed
XOffset: Integer; // X offset at which next left-aligned drawing done
begin
// Record name and glyph of compiler
CompilerName := fCurCompiler.GetName;
CompilerLogo := fCurCompiler.GetGlyph;
// Set up colors and font style to use in title: depends on compiler
// availability
if fCurCompiler.IsAvailable then
begin
GradColor1 := clActiveCaption;
GradColor2 := clGradientActiveCaption;
Canvas.Font.Style := [fsBold];
Canvas.Font.Color := clCaptionText;
end
else
begin
GradColor1 := clInactiveCaption;
GradColor2 := clGradientInactiveCaption;
Canvas.Font.Style := [fsBold];
Canvas.Font.Color := clInactiveCaptionText;
end;
// Draw gradient filled background rectangle
Canvas.Brush.Color := GradColor1; // required by GradientFill() below
UGraphicUtils.GradientFill(
Canvas,
Rect,
GradColor2,
gdHorizontal
);
// Ensure that all further drawing on background is transparent
Canvas.Brush.Style := bsClear;
// Draw compiler logo (if present)
XOffset := Rect.Left + cLeftMargin;
if Assigned(CompilerLogo) then
begin
// draw the bitmap
Canvas.BrushCopy(
TRectEx.CreateBounds(
XOffset,
(Rect.Height - CompilerLogo.Height) div 2,
CompilerLogo.Width,
CompilerLogo.Height
),
CompilerLogo,
CompilerLogo.Canvas.ClipRect,
clFuchsia // all logo glyphs have fuschia background
);
// we need to offset text to right of logo
XOffset := XOffset + CompilerLogo.Width + cLogoPadding;
end;
// Draw compiler name text, left aligned and vertically centred
Canvas.TextOut(
XOffset,
(Rect.Height - Canvas.TextHeight(CompilerName)) div 2,
CompilerName
);
end;
// ---------------------------------------------------------------------------
var
PB: TPaintBox; // reference to paint box control
BufferBmp: TBitmap; // background bitmap used for double-buffering drawing
begin
// Get reference to paint box
PB := Sender as TPaintBox;
// Render title onto buffer bitmap
BufferBmp := TBitmap.Create;
try
BufferBmp.Width := PB.Width;
BufferBmp.Height := PB.Height;
BufferBmp.Canvas.Font := PB.Canvas.Font;
RenderCompilerTitle(BufferBmp.Canvas, PB.ClientRect);
// Draw the offscreen bitmap in paintbox
PB.Canvas.Draw(0, 0, BufferBmp);
finally
FreeAndNil(BufferBmp);
end;
end;
procedure TCompilersDlg.PopulateSwitchList(const Switches: string);
{Stores list of command line switches in list box.
@param Switches [in] Comma separated list of required switches.
}
begin
ExplodeStr(Switches, ',', lbSwitches.Items, False);
end;
procedure TCompilersDlg.SelectCompiler;
{Stores reference to currently selected local compiler and updates dialog box
controls with details of the compiler.
}
var
Prefixes: TCompLogPrefixes; // log file prefixes for selected compiler
PrefixKind: TCompLogPrefixID; // loops thru log file prefixes
begin
// Store selected compiler
fCurCompiler := fLocalCompilers[TCompilerID(lbCompilers.ItemIndex)];
// Redraw compiler logo and name in paint box
pbCompiler.Refresh;
// Update controls
// edit box
edCompilerPath.Text := fCurCompiler.GetExecFile;
// store prefixes in value editor:
// note: code assumes that editor item index is ordinal value of prefix ID
Prefixes := fCurCompiler.GetLogFilePrefixes;
for PrefixKind := Low(TCompLogPrefixID) to High(TCompLogPrefixID) do
vleLogPrefixes.Cells[1, Ord(PrefixKind)] := Prefixes[PrefixKind];
// store switches in switch list
PopulateSwitchList(fCurCompiler.GetSwitches);
UpdateSwitchButtons;
end;
procedure TCompilersDlg.UpdateCurrentCompiler;
{Updates local copy of currently selected compiler with entries in dialog box.
}
var
Prefixes: TCompLogPrefixes; // log file prefixes for selected compiler
PrefixKind: TCompLogPrefixID; // loops thru log file prefixes
WasAvailable: Boolean; // whether compiler was available before update
InvalidRect: TRectEx; // area of list box to invalidate
begin
if Assigned(fCurCompiler) then
begin
// Record whether compiler was available before update
WasAvailable := fCurCompiler.IsAvailable;
// Record executable file as stored in edit control
fCurCompiler.SetExecFile(edCompilerPath.Text);
// Record log file prefixes from value editor:
// note: code assumes ordinal value of prefixes ids map to value edit index
for PrefixKind := Low(TCompLogPrefixID) to High(TCompLogPrefixID) do
Prefixes[PrefixKind] := vleLogPrefixes.Cells[1, Ord(PrefixKind)];
fCurCompiler.SetLogFilePrefixes(Prefixes);
// Store user defined prefixes
fCurCompiler.SetSwitches(JoinStr(lbSwitches.Items, ',', False));
// If availability has changed redraw selected list item and compiler title
// to give visual feedback of changed state
if WasAvailable <> fCurCompiler.IsAvailable then
begin
InvalidRect := lbCompilers.ItemRect(Ord(fCurCompiler.GetID));
InvalidateRect(lbCompilers.Handle, @InvalidRect, False);
pbCompiler.Refresh;
end;
end;
end;
procedure TCompilersDlg.UpdateSwitchButtons;
{Updates state of buttons that manipulate command line switches depending on
state of switch edit and list boxes.
}
begin
btnAdd.Enabled := (Trim(edSwitch.Text) <> '') and
(lbSwitches.Items.IndexOf(Trim(edSwitch.Text)) = -1);
btnReplace.Enabled := btnAdd.Enabled and
(lbSwitches.ItemIndex >= 0);
btnDelete.Enabled := lbSwitches.ItemIndex >= 0;
end;
procedure TCompilersDlg.vleLogPrefixesDrawCell(Sender: TObject;
ACol, ARow: Integer; Rect: TRect; State: TGridDrawState);
{Handles event triggered when cell is to be drawn in owner draw value editor
that displays compiler log prefix on on Log Files tab. This is owner drawn to
get required borders and to display an arrow that points to selected cell.
@param Sender [in] Reference to value edit control we are drawing.
@param ACol [in] Column number of cell being drawn.
@param ARow [in] Row number of cell being drawn.
@param Rect [in] Bounding rectangle of cell being drawn.
@param State [in] State of control: fixed cell, selected etc.
}
var
ValEd: TValueListEditor; // reference to value editor being displayed
begin
// Get reference to value editor
ValEd := Sender as TValueListEditor;
ValEd.Canvas.Font := ValEd.Font;
with ValEd.Canvas do
begin
if gdFixed in State then
begin
// Set colours for fixed cells (non-editable)
Brush.Color := clBtnFace;
Font.Color := ValEd.Font.Color;
end
else
begin
// Set colours for editable cell
Brush.Color := ValEd.Color;
Font.Color := ValEd.Font.Color;
end;
// Colour the current cell
FillRect(Rect);
if gdFixed in State then
begin
// draw vertical line at right edge of fixed cell to act as border
Pen.Color := clBtnShadow;
MoveTo(Rect.Right - 1, Rect.Top);
LineTo(Rect.Right - 1, Rect.Bottom);
end;
// Display required text
TextOut(
Rect.Left + 2 ,
Rect.Top + (ValEd.RowHeights[ARow] - TextHeight('X')) div 2,
ValEd.Cells[ACol, ARow]
);
if (ACol = 0) and (ValEd.Selection.Top = ARow) then
begin
// This is a fixed cell which has selected editable cell adjacent to it
// draw an arrow at the RHS of this cell that points to selected cell
Pen.Color := clHighlight;
GraphUtil.DrawArrow(
ValEd.Canvas,
sdRight,
Point(Rect.Right - 8, (Rect.Top + Rect.Bottom) div 2 - 4), 4
);
end;
end;
end;
procedure TCompilersDlg.vleLogPrefixesSelectCell(Sender: TObject; ACol,
ARow: Integer; var CanSelect: Boolean);
{Handles event triggered when cell selected in Log Files tab's value editor
changes: we need to change location of highlight arrow.
@param Sender [in] Reference to value editor (not used).
@param ACol [in] Column of selected cell (not used).
@param ARow [in] Row of selected cell (not used).
@param CanSelect [in/out] Left unchanged to enable selection change to go
ahead.
}
begin
// Redraw display to ensure indicator arrows updated
(Sender as TValueListEditor).Invalidate;
end;
end.
