{
* UCompileResultsLBMgr.pas
*
* Defines classes that manages display, editing and interaction with a list box
* that displays compiler results.
*
* $Rev$
* $Date$
*
* ***** 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 UCompileResultsLBMgr.pas
*
* The Initial Developer of the Original Code is Peter Johnson
* (http://www.delphidabbler.com/).
*
* Portions created by the Initial Developer are Copyright (C) 2009-2010 Peter
* Johnson. All Rights Reserved.
*
* Contributor(s)
* NONE
*
* ***** END LICENSE BLOCK *****
}
unit UCompileResultsLBMgr;
interface
uses
// Delphi
Classes, Controls, StdCtrls, Types,
// Project
Compilers.UGlobals, UDropDownButtons, ULEDImageList, UStructs;
type
{
TCompileResultsLBMgr:
Class that manages display and interaction with a list box that displays
compiler results. Provides a means of editing the results for individual
compilers.
}
TCompileResultsLBMgr = class(TObject)
strict private
type
{
TCompilerInfo:
Class that records information about a snippet's compilation results.
Resulting objects are stored in list box items Objects[] array.
}
TCompilerInfo = class(TObject)
strict private
fCompilerID: TCompilerID; // Value of Compiler property
fCompileResult: TCompileResult; // Value of CompileResult property
public
constructor Create(const CompilerID: TCompilerID;
const CompileResult: TCompileResult);
{Class constructor. Sets up and initialises object.
@param CompilerID [in] Id of compiler that result applies to.
@param CompileResult [in] Compiler result for compiler.
}
property CompilerID: TCompilerID read fCompilerID;
{Id of compiler to which CompileResult applies}
property CompileResult: TCompileResult
read fCompileResult write fCompileResult;
{Result of compilation with associated compiler}
end;
var
fLB: TListBox; // Managed list box
fCompilers: ICompilers; // Compilers to be displayed in list box
fLEDImages: TLEDImageList; // Image list containing LEDs
fLastHotDropDown: TRectEx; // Bounds of last drop down highlighted
fDropDownBtns: TDropDownButtons; // Provides drop down button glyphs
procedure PopulateListBox;
{Adds details of each compiler to list box with unknown compile results.
}
function IndexOf(const CompID: TCompilerID): Integer;
{Finds index of list item corresponding to a compiler.
@param CompID [in] ID of compiler.
@return Index of corresponding list item or -1 if compiler not found.
}
procedure SetCompileResult(const Index: Integer; const Res: TCompileResult);
{Sets compile result of a list item.
@param Index [in] Index of list item.
@param Res [in] Required compiler result.
}
function GetCompilerInfo(const Index: Integer): TCompilerInfo;
overload;
{Retrieves the compiler info associated with a specified list item.
@param Index [in] Index of list item.
@return Required compiler info.
}
function GetCompilerInfo(const CompID: TCompilerID): TCompilerInfo;
overload;
{Retrieves the compiler info associated with a specified compiler ID.
@param CompID [in] Compiler ID.
@return Required compiler info.
}
procedure MenuSelectHandler(Sender: TObject);
{Handles menu selection on popup menu activated from drop down button.
Sets compile result of selected list item per menu selection.
@param Sender [in] Menu item that was clicked.
}
procedure DrawItem(Control: TWinControl; Index: Integer; Rect: TRect;
State: TOwnerDrawState);
{OnDrawItem event handler for managed list box. Custom draws compiler list
item to show compiler glyph, name of compiler, current compile result
"LED" and a drop-down button.
@param Control [in] Reference to list box that triggered event. Must be
the managed control.
@param Index [in] Index of list item being drawn.
@param Rect [in] Rectangle in list box canvas where item being drawn.
@param State [in] State of list item.
}
procedure MouseDown(Sender: TObject; Button: TMouseButton; Shift:
TShiftState; X, Y: Integer);
{Handles list box's OnMouseDown event. Displays compile result menu if
user left clicked on drop down button with no modifier keys pressed.
@param Sender [in] Not used.
@param Button [in] Mouse button pressed.
@param Shift [in] Modifier keys etc.
@param X [in] X coordinate of mouse pointer in list box.
@param Y [in] Y coordinate of mouse pointer in list box.
}
procedure MouseMove(Sender: TObject; Shift: TShiftState; X, Y: Integer);
{Handles list box's OnMouseMove event. Updates display of hot and normal
drop down buttons depending on whether mouse is over such a button.
@param Sender [in] List box that triggered event. Not used.
@param Shift [in] State of shift keys. Not used.
@param X [in] X coordinate of mouse pointer in list box.
@param Y [in] Y coordinate of mouse pointer in list box.
}
procedure MouseLeave(Sender: TObject);
{Handles list box's OnMouseLeave event. Redisplays any drop down button
that was displayed as hot.
@param Sender [in] Not used.
}
procedure KeyUp(Sender: TObject; var Key: Word; Shift: TShiftState);
{Handles list box's OnKeyUp event. Displays popup menu over any currently
selected list item if user pressed space bar with no modifier keys.
@param Sender [in] Not used.
@param Key [in/out] Code of key pressed. Left unchanged.
@param Shift [in] State of modifier keys.
}
function GetLEDBounds(const ItemRect: TRect): TRect;
{Gets bounds of a LED glyph within an item rectangle in list box.
@param ItemRect [in] Rectangle containing LED glyph.
@return Bounding rectangle of glyph.
}
function GetDropDownBmpBounds(const ItemRect: TRect): TRectEx;
{Gets bounds of a drop down button glyph within an item rectangle in list
box.
@param ItemRect [in] Rectangle containing drop down button glyph.
@return Bounding rectangle of glyph.
}
procedure InvalidateLBRect(const R: TRect);
{Invalidates a specified rectangle in list box for redrawing.
@param R [in] Rectangle to be invalidated.
}
function IsMouseInRect(const Rect: TRectEx): Boolean;
{Checks if the mouse pointer is within a specified rectangle in list box.
@param Rect [in] Rectangle to be queried.
@return True if mouse pointer in rectangle, False if not.
}
procedure ShowPopupMenu(const ItemIdx: Integer);
{Displays popup menu over a list item that is used to select a compile
result.
@param ItemIdx [in] Index of list item for which menu is required.
}
procedure ThemesChangeHandler(Sender: TObject);
{Handles themes change event. Redisplays list box to use new themes.
@param Sender [in] Not used.
}
public
constructor Create(LB: TListBox; const Compilers: ICompilers);
{Class constructor. Sets up manager for a list box.
@param LB [in] Listbox to be managed.
@param Compilers [in] Compilers to be displayed in listbox.
}
destructor Destroy; override;
{Class destructor. Tears down object.
}
procedure SetCompileResults(const Res: TCompileResults); overload;
{Sets the compile results displayed by the list box. All items are set.
Each may have different value.
@param Res [in] Array of compiler results addressed by compiler ID.
}
procedure SetCompileResults(const Res: TCompileResult); overload;
{Sets all the compile results displayed by the list box to same value.
@param Res [in] Required compiler result.
}
procedure SetCurrentCompileResult(const Res: TCompileResult);
{Sets compile result of currently selected compiler.
@param Res [in] Required compile result.
}
function GetCompileResults: TCompileResults;
{Retrieves an array of all compile results per list box.
@return Results array, indexed by compiler ID.
}
function GetCurrentCompileResult: TCompileResult;
{Retrieves the compile result for the currently selected list item.
@return Require compile result.
}
end;
implementation
uses
// Delphi
SysUtils, Menus, Windows, Graphics,
// Project
UKeysHelper;
type
{
TCompResMenuItem:
Enhanced menu item that stores a compile result along with menu item.
Displayed as part of menu that is popped up from compile results list box.
Selecting the menu item updates current list box item to display the stored
compile result.
}
TCompResMenuItem = class(TMenuItem)
strict private
var fCompileResult: TCompileResult; // Value of CompileResult property
public
constructor Create(AOwner: TComponent; const ACompRes: TCompileResult;
const AClickEventHandler: TNotifyEvent); reintroduce;
{Class constructor. Creates menu item for a compile result.
@param AOwner [in] Component that owns this menu item.
@param ACompRes [in] Associated compile result. Determines caption and
displayed image.
@param AClickEventHandler [in] Event handler trigerred when menu item
clicked.
}
property CompileResult: TCompileResult read fCompileResult;
{Compile result associated with menu item}
end;
{
TCompResSelectMenu:
Special popup menu that is displayed by the compile results list box that
enables the compile result associated with a menu item to be edited.
}
TCompResSelectMenu = class(TPopupMenu)
strict private
var
fCompileResult: TCompileResult; // Value of CompileResult property
fOnSelect: TNotifyEvent; // OnSelect event handler
procedure MenuItemClickHandler(Sender: TObject);
{Handles clicks on all menu items. Records compile result associated with
selected menu item in CompileResult property and triggers OnSelect event.
@param Sender [in] Menu item that triggered event.
}
public
constructor Create(AOwner: TComponent); override;
{Class constructor. Creates menu and populates it with items for all
possible compile results.
@param AOwner [in] Component that owns the menu.
}
property CompileResult: TCompileResult read fCompileResult default crQuery;
{Last selected compiler result}
property OnSelect: TNotifyEvent read fOnSelect write fOnSelect;
{Event triggered when user selects a compile result}
end;
{ TCompileResultsLBMgr }
constructor TCompileResultsLBMgr.Create(LB: TListBox;
const Compilers: ICompilers);
{Class constructor. Sets up manager for a list box.
@param LB [in] Listbox to be managed.
@param Compilers [in] Compilers to be displayed in listbox.
}
begin
Assert(Assigned(LB), ClassName + '.Create: LB is nil');
Assert(Assigned(Compilers), ClassName + '.Create: Compilers is nil');
inherited Create;
// record compilers
fCompilers := Compilers;
// customise list box
fLB := LB;
fLB.Style := lbOwnerDrawFixed;
fLB.PopupMenu := TCompResSelectMenu.Create(fLB);
(fLB.PopupMenu as TCompResSelectMenu).OnSelect := MenuSelectHandler;
fLB.PopupMenu.Alignment := paRight;
// assign event handlers
fLB.OnDrawItem := DrawItem;
fLB.OnMouseDown := MouseDown;
fLB.OnMouseMove := MouseMove;
fLB.OnMouseLeave := MouseLeave;
fLB.OnKeyUp := KeyUp;
// create list box items and select first one
PopulateListBox;
fLB.ItemIndex := 0; // select first item
// create owned objects
fDropDownBtns := TDropDownButtons.Create(LB);
fDropDownBtns.OnChange := ThemesChangeHandler;
fLEDImages := TLEDImageList.Create(LB);
// record that no drop down button is under mouse
fLastHotDropDown.MakeEmpty;
end;
destructor TCompileResultsLBMgr.Destroy;
{Class destructor. Tears down object.
}
var
Idx: Integer; // loops through all list items
Tmp: TPopupMenu; // temporary menu reference used for thread safe freeing
begin
FreeAndNil(fDropDownBtns);
for Idx := Pred(fLB.Items.Count) downto 0 do
fLB.Items.Objects[Idx].Free; // free all compiler info records
// free list box's popup menu in thread safe way
Tmp := fLB.PopupMenu;
fLB.PopupMenu := nil;
FreeAndNil(Tmp);
inherited;
end;
procedure TCompileResultsLBMgr.DrawItem(Control: TWinControl; Index: Integer;
Rect: TRect; State: TOwnerDrawState);
{OnDrawItem event handler for managed list box. Custom draws compiler list
item to show compiler glyph, name of compiler, current compile result "LED"
and a drop-down button.
@param Control [in] Reference to list box that triggered event. Must be the
managed control.
@param Index [in] Index of list item being drawn.
@param Rect [in] Rectangle in list box canvas where item being drawn.
@param State [in] State of list item.
}
var
Cvs: TCanvas; // list box's canvas
CompInfo: TCompilerInfo; // info about compile result associated with item
Text: string; // text to be displayed
TextRect: TRect; // rectangle in which to display text
CompGlyph: TBitmap; // gylph associated with compiler
GlyphRect: TRect; // rectangle in which to display compiler glyph
DropDownRect: TRect; // rectangle in which to display drop-down "button"
LEDRect: TRectEx; // rectangle in which to display LED glyph
begin
Assert(Control = fLB, ClassName + '.DrawItem: Control <> fLB');
// Store canvas and associated compiler info
Cvs := fLB.Canvas;
CompInfo := GetCompilerInfo(Index);
// Clear item's rectangle
Cvs.FillRect(Rect);
// Display text
Text := fLB.Items[Index];
TextRect := TRectEx.Create(
Rect.Left + 24,
(Rect.Bottom + Rect.Top - Cvs.TextHeight(Text)) div 2,
Rect.Right - 24,
Rect.Bottom
);
if odDisabled in State then
Cvs.Font.Color := clGrayText
else
Cvs.Font.Color := fLB.Font.Color;
Cvs.TextRect(TextRect, Text, [tfLeft, tfNoPrefix, tfEndEllipsis, tfTop]);
// Display any compiler glyph
CompGlyph := fCompilers[CompInfo.CompilerID].GetGlyph;
if Assigned(CompGlyph) then
begin
GlyphRect := TRectEx.CreateBounds(
Rect.Left + 2,
(Rect.Bottom + Rect.Top - CompGlyph.Height) div 2,
CompGlyph.Width,
CompGlyph.Height
);
Cvs.BrushCopy(
GlyphRect,
CompGlyph,
TRectEx.Create(0, 0, CompGlyph.Width, CompGlyph.Height),
clFuchsia
);
end;
// Display compile result "LED": assumes image index = Ord(CompileResult)
LEDRect := GetLEDBounds(Rect);
fLEDImages.Draw(Cvs, LEDRect.TopLeft, CompInfo.CompileResult);
// Display drop-down glyph
DropDownRect := GetDropDownBmpBounds(Rect);
fDropDownBtns.Draw(
Cvs,
DropDownRect.TopLeft,
IsMouseInRect(DropDownRect), // hot
(odSelected in State) and (odFocused in State) // focussed
);
end;
function TCompileResultsLBMgr.GetCompileResults: TCompileResults;
{Retrieves an array of all compile results per list box.
@return Results array, indexed by compiler ID.
}
var
CompID: TCompilerID; // loops through all elements of result array
begin
for CompID := Low(Result) to High(Result) do
Result[CompID] := GetCompilerInfo(CompID).CompileResult;
end;
function TCompileResultsLBMgr.GetCompilerInfo(
const Index: Integer): TCompilerInfo;
{Retrieves the compiler info associated with a specified list item.
@param Index [in] Index of list item.
@return Required compiler info.
}
begin
Result := fLB.Items.Objects[Index] as TCompilerInfo;
end;
function TCompileResultsLBMgr.GetCompilerInfo(
const CompID: TCompilerID): TCompilerInfo;
{Retrieves the compiler info associated with a specified compiler ID.
@param CompID [in] Compiler ID.
@return Required compiler info.
}
begin
Result := GetCompilerInfo(IndexOf(CompID));
end;
function TCompileResultsLBMgr.GetCurrentCompileResult: TCompileResult;
{Retrieves the compile result for the currently selected list item.
@return Require compile result.
}
begin
Result := GetCompilerInfo(fLB.ItemIndex).CompileResult;
end;
function TCompileResultsLBMgr.GetDropDownBmpBounds(
const ItemRect: TRect): TRectEx;
{Gets bounds of a drop down button glyph within an item rectangle in list box.
@param ItemRect [in] Rectangle containing drop down button glyph.
@return Bounding rectangle of glyph.
}
begin
Result := TRectEx.CreateBounds(
ItemRect.Right - 2 - fDropDownBtns.Images.Width,
(ItemRect.Bottom + ItemRect.Top - fDropDownBtns.Images.Height) div 2,
fDropDownBtns.Images.Width,
fDropDownBtns.Images.Height
);
end;
function TCompileResultsLBMgr.GetLEDBounds(const ItemRect: TRect): TRect;
{Gets bounds of a LED glyph within an item rectangle in list box.
@param ItemRect [in] Rectangle containing LED glyph.
@return Bounding rectangle of glyph.
}
begin
Result := TRectEx.CreateBounds(
ItemRect.Right - 2 - fLEDImages.Width - 2 - fDropDownBtns.Images.Width,
(ItemRect.Bottom + ItemRect.Top - fLEDImages.Height) div 2,
fLEDImages.Width,
fLEDImages.Height
);
end;
function TCompileResultsLBMgr.IndexOf(const CompID: TCompilerID): Integer;
{Finds index of list item corresponding to a compiler.
@param CompID [in] ID of compiler.
@return Index of corresponding list item or -1 if compiler not found.
}
var
Idx: Integer; // loops thru list box items
begin
Result := -1;
for Idx := 0 to Pred(fLB.Items.Count) do
if GetCompilerInfo(Idx).CompilerID = CompID then
begin
Result := Idx;
Break;
end;
Assert(Result >= 0, ClassName + '.IndexOf: CompID not found');
end;
procedure TCompileResultsLBMgr.InvalidateLBRect(const R: TRect);
{Invalidates a specified rectangle in list box for redrawing.
@param R [in] Rectangle to be invalidated.
}
begin
Windows.InvalidateRect(fLB.Handle, @R, False);
end;
function TCompileResultsLBMgr.IsMouseInRect(const Rect: TRectEx): Boolean;
{Checks if the mouse pointer is within a specified rectangle in list box.
@param Rect [in] Rectangle to be queried.
@return True if mouse pointer in rectangle, False if not.
}
begin
Result := Rect.ContainsPoint(fLB.ScreenToClient(Mouse.CursorPos));
end;
procedure TCompileResultsLBMgr.KeyUp(Sender: TObject; var Key: Word;
Shift: TShiftState);
{Handles list box's OnKeyUp event. Displays popup menu over any currently
selected list item if user pressed space bar with no modifier keys.
@param Sender [in] Not used.
@param Key [in/out] Code of key pressed. Left unchanged.
@param Shift [in] State of modifier keys.
}
begin
if fLB.ItemIndex = -1 then
Exit;
// only space with no shift keys is processed
if HasShiftKeys(Shift) or (Key <> VK_SPACE) then
Exit;
// space key pressed: display menu
ShowPopupMenu(fLB.ItemIndex);
end;
procedure TCompileResultsLBMgr.MenuSelectHandler(Sender: TObject);
{Handles menu selection on popup menu activated from drop down button. Sets
compile result of selected list item per menu selection.
@param Sender [in] Menu item that was clicked.
}
begin
SetCurrentCompileResult((Sender as TCompResSelectMenu).CompileResult);
end;
procedure TCompileResultsLBMgr.MouseDown(Sender: TObject; Button: TMouseButton;
Shift: TShiftState; X, Y: Integer);
{Handles list box's OnMouseDown event. Displays compile result menu if user
left clicked on drop down button with no modifier keys pressed.
@param Sender [in] Not used.
@param Button [in] Mouse button pressed.
@param Shift [in] Modifier keys etc.
@param X [in] X coordinate of mouse pointer in list box.
@param Y [in] Y coordinate of mouse pointer in list box.
}
var
ItemIdx: Integer; // list item under mouse (-1 if mouse not on list item)
MousePos: TPoint; // position of mouse
DDBounds: TRectEx; // bounds of drop down button
begin
// left mouse button must have been pressed with no modifier keys
if HasShiftKeys(Shift) or (Button <> mbLeft) then
Exit;
// find list item from modifier keys
MousePos := Point(X, Y);
ItemIdx := fLB.ItemAtPos(MousePos, True);
if ItemIdx = -1 then
Exit;
// find if drop down button pressed in list item and display menu if so
DDBounds := GetDropDownBmpBounds(fLB.ItemRect(ItemIdx));
if not DDBounds.ContainsPoint(MousePos) then
Exit;
ShowPopupMenu(ItemIdx);
end;
procedure TCompileResultsLBMgr.MouseLeave(Sender: TObject);
{Handles list box's OnMouseLeave event. Redisplays any drop down button that
was displayed as hot.
@param Sender [in] Not used.
}
begin
if not fLastHotDropDown.IsEmpty then
begin
InvalidateLBRect(fLastHotDropDown);
fLastHotDropDown.MakeEmpty;
end;
end;
procedure TCompileResultsLBMgr.MouseMove(Sender: TObject; Shift: TShiftState; X,
Y: Integer);
{Handles list box's OnMouseMove event. Updates display of hot and normal drop
down buttons depending on whether mouse is over such a button.
@param Sender [in] List box that triggered event. Not used.
@param Shift [in] State of shift keys. Not used.
@param X [in] X coordinate of mouse pointer in list box.
@param Y [in] Y coordinate of mouse pointer in list box.
}
var
ItemIdx: Integer; // index of list item under mouse (-1 if none)
DropDownRect: TRectEx; // bounds list item's drop down button
begin
// find list item under mouse, if any
ItemIdx := fLB.ItemAtPos(Point(X, Y), True);
if ItemIdx >= 0 then
begin
// there is a list item under mouse: find bounds of item's drop down button
DropDownRect := GetDropDownBmpBounds(fLB.ItemRect(ItemIdx));
if DropDownRect.ContainsPoint(Point(X, Y)) then
begin
// we are inside drop down button
if DropDownRect <> fLastHotDropDown then
begin
// button has changed: need to redraw
if not fLastHotDropDown.IsEmpty then
begin
// redraw old drop down: no longer hot
InvalidateLBRect(fLastHotDropDown);
end;
// redraw new drop down: now hot
InvalidateLBRect(DropDownRect);
// record current drop down
fLastHotDropDown := DropDownRect;
end;
end
else
begin
// not inside drop down button
if not fLastHotDropDown.IsEmpty then
begin
// redraw old drop down: no longer hot
InvalidateLBRect(fLastHotDropDown);
fLastHotDropDown.MakeEmpty;
end;
end;
end
else
begin
// not inside any item
if not fLastHotDropDown.IsEmpty then
begin
// redraw old drop down: no longer hot
InvalidateLBRect(fLastHotDropDown);
fLastHotDropDown.MakeEmpty;
end;
end;
end;
procedure TCompileResultsLBMgr.PopulateListBox;
{Adds details of each compiler to list box with unknown compile results.
}
var
Compiler: ICompiler; // each supported compiler
begin
// Display all compilers
for Compiler in fCompilers do
fLB.Items.AddObject(
Compiler.GetName,
TCompilerInfo.Create(Compiler.GetID, crQuery)
);
end;
procedure TCompileResultsLBMgr.SetCompileResult(const Index: Integer;
const Res: TCompileResult);
{Sets compile result of a list item.
@param Index [in] Index of list item.
@param Res [in] Required compiler result.
}
begin
GetCompilerInfo(Index).CompileResult := Res;
InvalidateLBRect(GetLEDBounds(fLB.ItemRect(Index)));
end;
procedure TCompileResultsLBMgr.SetCompileResults(const Res: TCompileResult);
{Sets all the compile results displayed by the list box to same value.
@param Res [in] Required compiler result.
}
var
Idx: Integer; // loops through all list items
begin
for Idx := 0 to Pred(fLB.Items.Count) do
SetCompileResult(Idx, Res);
end;
procedure TCompileResultsLBMgr.SetCompileResults(const Res: TCompileResults);
{Sets the compile results displayed by the list box. All items are set. Each
may have different value.
@param Res [in] Array of compiler results addressed by compiler ID.
}
var
CompID: TCompilerID; // loops through all compiler ids
begin
for CompID := Low(Res) to High(Res) do
SetCompileResult(IndexOf(CompID), Res[CompID]);
end;
procedure TCompileResultsLBMgr.SetCurrentCompileResult(
const Res: TCompileResult);
{Sets compile result of currently selected compiler.
@param Res [in] Required compile result.
}
begin
SetCompileResult(fLB.ItemIndex, Res);
end;
procedure TCompileResultsLBMgr.ShowPopupMenu(const ItemIdx: Integer);
{Displays popup menu over a list item that is used to select a compile result.
@param ItemIdx [in] Index of list item for which menu is required.
}
var
DropDownBmpBounds: TRectEx; // bounds of list item's drop down button
PopupPos: TPoint; // point on screen where menu is popup
begin
// display right aligned menu below drop down button
DropDownBmpBounds := GetDropDownBmpBounds(fLB.ItemRect(ItemIdx));
PopupPos := fLB.ClientToScreen(DropDownBmpBounds.BottomRight);
fLB.PopupMenu.Popup(PopupPos.X, PopupPos.Y);
end;
procedure TCompileResultsLBMgr.ThemesChangeHandler(Sender: TObject);
{Handles themes change event. Redisplays list box to use new themes.
@param Sender [in] Not used.
}
begin
fLB.Invalidate;
end;
{ TCompileResultsLBMgr.TCompilerInfo }
constructor TCompileResultsLBMgr.TCompilerInfo.Create(
const CompilerID: TCompilerID; const CompileResult: TCompileResult);
{Class constructor. Sets up and initialises object.
@param CompilerID [in] Id of compiler that result applies to.
@param CompileResult [in] Compiler result for compiler.
}
begin
inherited Create;
fCompilerID := CompilerID;
fCompileResult := CompileResult;
end;
{ TCompResMenuItem }
constructor TCompResMenuItem.Create(AOwner: TComponent;
const ACompRes: TCompileResult; const AClickEventHandler: TNotifyEvent);
{Class constructor. Creates menu item for a compile result.
@param AOwner [in] Component that owns this menu item.
@param ACompRes [in] Associated compile result. Determines caption and
displayed image.
@param AClickEventHandler [in] Event handler trigerred when menu item
clicked.
}
resourcestring
// Text for list items in Compiler Result list box
sSuccess = 'Success';
sWarning = 'Warning';
sError = 'Error';
sQuery = 'Unknown';
const
// Map of compiler results onto descriptions
cCompResCaptions: array[TCompileResult] of string = (
sSuccess, sWarning, sError, sQuery
);
begin
Assert(Assigned(AClickEventHandler),
ClassName + '.Create: AClickEventHandler not assigned');
inherited Create(AOwner);
Caption := cCompResCaptions[ACompRes];
fCompileResult := ACompRes;
ImageIndex := Ord(ACompRes); // image list index must map to compile result
OnClick := AClickEventHandler;
end;
{ TCompResSelectMenu }
constructor TCompResSelectMenu.Create(AOwner: TComponent);
{Class constructor. Creates menu and populates it with items for all possible
compile results.
@param AOwner [in] Component that owns the menu.
}
var
CompRes: TCompileResult; // loops thru all possible compile results
begin
inherited;
AutoPopup := False;
// Create image list containing compiler result LEDs
Images := TLEDImageList.Create(AOwner);
// Populate menu
for CompRes := Low(TCompileResult) to High(TCompileResult) do
Items.Add(TCompResMenuItem.Create(Self, CompRes, MenuItemClickHandler));
// Set default "unknown" compiler result
fCompileResult := crQuery;
end;
procedure TCompResSelectMenu.MenuItemClickHandler(Sender: TObject);
{Handles clicks on all menu items. Records compile result associated with
selected menu item in CompileResult property and triggers OnSelect event.
@param Sender [in] Menu item that triggered event.
}
begin
fCompileResult := (Sender as TCompResMenuItem).CompileResult;
if Assigned(fOnSelect) then
fOnSelect(Self);
end;
end.
