Code completion suggestions #180

andrewd207 · 2026-04-14T00:10:59Z

andrewd207
Apr 14, 2026

Hi,

I've had some free time lately and started writing a couple things and thought I would write here before I write much more code in case I'm duplicating something you are already working on.

I started working on a suggestion widget. It's split into three parts.

TfpgSuggestionBox - a popup window
TfpgSuggestionAdapterBase- data backend
IfpgSuggestionRenderer - renderer currently just uses a canvas with rect information.

I'm making it as generic as possible so that it can be used with any program, but with Maximus primarily in mind.

I have planned, but not implemented yet, a description window that can accompany the suggestion window to give more details on the current suggestion candidate. (Some HTML widget would be awesome)

I'm working on a TStrings based adapter and renderer at the moment to iron out the process to see how it can work. It's currently drawing ugly rows that aren't sorted from a static list of strings. Typing doesn't filter the remaining items yet etc.

There's lots of things I haven't implemented yet. It's like the facade of a proof of concept at the moment.

Also, I've done some work on loading ppu files into objects to lookup symbols via ppudump as json. Thinking to combine that with suggestions within the scope. It's not searchable yet. Just objects that can be loaded automatically using jsonrtti.

Anyway, that's the story. Let me know if I should continue.

Regards,

Andrew Haines

andrewd207 · 2026-04-15T07:24:47Z

andrewd207
Apr 15, 2026
Author

Screencast.from.2026-04-15.03-11-17.mp4

Well it's too late/early to think too much but here's what I have so far. A diff(at the end) of the changes needed to fpgui and a new unit.
I added a couple words statically to the suggestions.

I have some plans with the "host" interface but maybe it's not needed.

{
    This unit is part of the fpGUI Toolkit project.

    Copyright (c) 2006 by Graeme Geldenhuys.

    See the file COPYING.modifiedLGPL, included in this distribution,
    for details about redistributing fpGUI.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

    Author - Andrew Haines 2026

    Description:
      Defines a basic Popupbox that allows hooks to set the content
}
unit fpg_suggestionbox;

{$mode objfpc}{$H+}

interface

uses
  Classes, SysUtils,
  RtlConsts,
  fpg_base,
  fpg_main,
  fpg_widget,
  fpg_popupwindow,
  fpg_style,
  fpg_stylemanager,
  fgl;

type
{
  To use this you need three things.

  1. TfpgSuggestionBox - the main widget/window
  2. An adapter that inherits TfpgSuggestionAdapterBase
     See TfpgSuggestionStringsAdapter for TStrings
  3. An object that implements IfpgSuggestionRenderer
     See TfpgSuggestionStringsRenderer.

  4. Optional. Context

  The control using this widget MUST implement IfpgSuggestionHost - not actually true

}


  TfpgSuggestionBox = class;

  // to find the end classes more easily
  TfpgSuggestionAdapterBase = class;
  //TfpgSuggestionStringsAdapter = class;

  // a generic adapter
  // TMyAdapter = specialize TfpgSuggestionAdapter<T: TfpgSuggestionItem>
  //TfpgSuggestionAdapter = class;


  type
  TfpgSuggestionApplyMode = (
    samInsert,
    samReplace
  );

  TfpgSuggestionWordinfo = record
    CaretPosition: TfpgPoint;
    CaretPixelPosition: TfpgPoint;
    Text: string; // if we are typing Strings and we have "Str|ings" this will be "Str"
  end;

  IfpgSuggestionHost = interface
    ['{BA7D4CF8-F7FF-4119-96DA-5B9FFE7156B8}']
    { caret / geometry }
    function GetSuggestionInfo(out AInfo: TfpgSuggestionWordInfo): Boolean;

    { apply accepted completion }
    procedure ApplySuggestion(const AText: string; AMode: TfpgSuggestionApplyMode);
  end;


  type
  TfpgSuggestionAdapterChangeKind = (
    sacReset,
    sacDataChanged,
    sacItemsInserted,
    sacItemsRemoved,
    sacItemsUpdated,
    sacContextChanged,
    sacLayoutChanged
  );

  TfpgSuggestionAdapterOption = (
    saoOwnsObservedSources,
    saoAutoRefreshOnObservedChange,
    saoAutoDetachOnObservedFree
  );

  TfpgSuggestionAdapterOptions = set of TfpgSuggestionAdapterOption;

  TfpgSuggestionAcceptResult = (
    sarNone,
    sarAccepted,
    sarCancelled
  );

  // set internally when the adapter is assigned
  TfpgSuggestionAdapterChangedEvent =
    procedure(Sender: TObject; AKind: TfpgSuggestionAdapterChangeKind) of object;

  { TfpgSuggestionAdapterBase }

  TfpgSuggestionAdapterBase = class(TInterfacedObject, IFPObserver, IFPObserved)
  public type
    TState = (sasNormal, sasUpdating);
  private
    FFilter: String;
    FOwnerBox: TfpgSuggestionBox;
    FOnChanged: TfpgSuggestionAdapterChangedEvent;
    FOptions: TfpgSuggestionAdapterOptions;
    FUpdateLock: Integer;
    FNeedsRefresh: Boolean;
    FObservers: TFPList;
  protected
    { lifecycle }
    procedure DoBeginUpdate; virtual;
    procedure DoEndUpdate; virtual;

    function GetUpdating: Boolean; virtual;

    { item access }
    function DoGetCount: Integer; virtual; abstract;
    function DoGetItem(AIndex: Integer): TObject; virtual; abstract;

    { item text and metadata }
    function DoGetDisplayText(AItem: TObject): string; virtual; abstract;
    function DoGetDetailText(AItem: TObject): string; virtual;
    function DoGetFilterText(AItem: TObject): string; virtual;
    function DoGetSortText(AItem: TObject): string; virtual;
    function DoGetDocumentationText(AItem: TObject): string; virtual;
    function DoGetItemHint(AItem: TObject): string; virtual;
    function DoGetItemImageIndex(AItem: TObject): Integer; virtual;
    function DoGetItemData(AItem: TObject): Pointer; virtual;

    { item capabilities }
    function DoItemMatches(AItem: TObject; const AFilter: string): Boolean; virtual;
    function DoCompareItems(AItem1, AItem2: TObject): Integer; virtual;
    function DoHasDetails(AItem: TObject): Boolean; virtual;
    procedure DoSwapFilteredItems(AItem1Index, AItem2Index: Integer); virtual; abstract;
    procedure QuickSortFiltered(L, R: Integer);

    procedure SetFilter(AValue: String); virtual;
    procedure SortFilteredItems; virtual;

    { ownership hooks }
    procedure Notification(AComponent: TComponent; Operation: TOperation); virtual;
  public
    constructor Create; virtual;
    destructor Destroy; override;

    { observer plumbing, if the backing list supports it}
    procedure FPOObservedChanged(ASender: TObject; Operation: TFPObservedOperation; Data: Pointer); virtual;

    { observerable plumbing }
    Procedure FPOAttachObserver(AObserver : TObject); virtual;
    Procedure FPODetachObserver(AObserver : TObject); virtual;
    Procedure FPONotifyObservers(ASender : TObject; AOperation : TFPObservedOperation; Data : Pointer); virtual;


    { batching }
    procedure BeginUpdate; virtual;
    procedure EndUpdate; virtual;

    { main API used by the suggestion box }
    function GetCount: Integer; virtual;
    function GetItem(AIndex: Integer): TObject; virtual;

    function GetDisplayText(AItem: TObject): string; virtual;
    function GetDetailText(AItem: TObject): string; virtual;
    function GetFilterText(AItem: TObject): string; virtual;
    function GetSortText(AItem: TObject): string; virtual;
    function GetDocumentationText(AItem: TObject): string; virtual;
    function GetItemHint(AItem: TObject): string; virtual;
    function GetItemImageIndex(AItem: TObject): Integer; virtual;
    function GetItemData(AItem: TObject): Pointer; virtual;

    function ItemMatches(AItem: TObject; const AFilter: string): Boolean; virtual;
    function CompareItems(AItem1, AItem2: TObject): Integer; virtual;
    function HasDetails(AItem: TObject): Boolean; virtual;

    procedure Reset; virtual;
    procedure SuggestionBoxAttached(ASuggestionBox: TfpgSuggestionBox); virtual;
    procedure SuggestionBoxDetached(ASuggestionBox: TfpgSuggestionBox); virtual;

    property OwnerBox: TfpgSuggestionBox read FOwnerBox;
    property Updating: Boolean read GetUpdating;
    property Filter: String read FFilter write SetFilter;
    property Options: TfpgSuggestionAdapterOptions read FOptions write FOptions;
    property OnChanged: TfpgSuggestionAdapterChangedEvent read FOnChanged write FOnChanged;
  end;

  { TfpgSuggestionItem }

  TfpgSuggestionItem = class
  protected
    FDocumentation: String;
    FDetailText: String;
    FImageIndex: Integer;
    FItemData: Pointer;
    FItemHint: String;
    FDisplayText: String;
    FFilterText: String;
    FSortText: String;
    procedure SetDisplayText(AValue: String); virtual;
    procedure SetDetailText(AValue: String); virtual;
    procedure SetFilterText(AValue: String); virtual;
    procedure SetSortText(AValue: String); virtual;
    procedure SetDocumentation(AValue: String); virtual;
    procedure SetImageIndex(AValue: Integer); virtual;
    procedure SetItemData(AValue: Pointer); virtual;
    procedure SetItemHint(AValue: String); virtual;
    function GetFilterText: String; virtual;
    function GetSortText: String; virtual;
  public
    property DisplayText: String read FDisplayText write SetDisplayText;
    property DetailText: String read FDetailText write SetDetailText;
    property FilterText: String read GetFilterText write SetFilterText;
    property SortText: String read GetSortText write SetSortText;
    property Documentation: String read FDocumentation write SetDocumentation;
    property ItemHint: String read FItemHint write SetItemHint;
    property ImageIndex: Integer read FImageIndex write SetImageIndex;
    property ItemData: Pointer read FItemData write SetItemData;
  end;


  generic TfpgSuggestionAdapterGeneric<T: TfpgSuggestionItem> = class(TfpgSuggestionAdapterBase)
  private type
    TItemList = specialize TFPGObjectList<T>;
  private
    FList: TItemList;
    FFilteredList: TItemList;
  protected
    function NewItem: T;
    { typed item access }
    function DoGetCount: Integer; override;
    function DoGetItem(AIndex: Integer): TObject; override;

    { bridge overrides from TObject-based base class }
    function DoGetDisplayText(AItem: TObject): string; override;
    function DoGetDetailText(AItem: TObject): string; override;
    function DoGetFilterText(AItem: TObject): string; override;
    function DoGetSortText(AItem: TObject): string; override;
    function DoGetDocumentationText(AItem: TObject): string; override;
    function DoGetItemHint(AItem: TObject): string; override;
    function DoGetItemImageIndex(AItem: TObject): Integer; override;
    function DoGetItemData(AItem: TObject): Pointer; override;

    function DoItemMatches(AItem: TObject; const AFilter: string): Boolean; override;
    procedure DoSwapFilteredItems(AItem1Index, AItem2Index: Integer); override;

    function DoHasDetails(AItem: TObject): Boolean; override;

    { typed cast helper }
    function CastItem(AItem: TObject): T; virtual;
  public
    { typed public API }
    function GetTypedItem(AIndex: Integer): T; virtual;

    constructor Create; override;
    destructor Destroy; override;
  end;

  // convienience class in case the items are already sufficient
  TfpgSuggestionAdapter = specialize TfpgSuggestionAdapterGeneric<TfpgSuggestionItem>;


  TfpgSuggestionStringItem = class(TfpgSuggestionItem)
    Obj: TObject;
  end;

  { TfpgSuggestionStringsAdapter }

  TfpgSuggestionStringsAdapter = class(specialize TfpgSuggestionAdapterGeneric<TfpgSuggestionStringItem>, IFPObserver)
  private
    FOwnsStrings: Boolean;
    FStrings: TStrings;
    procedure SetStrings(AValue: TStrings);
  protected
    procedure UpdateCache; virtual;
    procedure FPOObservedChanged(ASender : TObject; Operation : TFPObservedOperation; Data : Pointer);
    procedure SetFilter(AValue: String); override;
  public
    property Strings: TStrings read FStrings write SetStrings;
    property OwnsStrings: Boolean read FOwnsStrings write FOwnsStrings;

  end;


  TfpgSuggestionRendererOption = (
    sroVariableRowHeight,
    sroShowIcons,
    sroShowDetailsInline,
    sroSupportsDetailsWindow,
    sroOwnerDrawSelection,
    sroOwnerDrawBackground,
    sroMeasureWidthFromVisibleItems
  );

  TfpgSuggestionRendererOptions = set of TfpgSuggestionRendererOption;

  TfpgSuggestionItemState = (
    sisSelected,
    sisFocused,
    sisHot,
    sisDisabled,
    sisFiltered,
    sisHasDetails
  );

  TfpgSuggestionItemStates = set of TfpgSuggestionItemState;

  TfpgSuggestionDetailsPlacement = (
    sdpRight,
    sdpBelow
  );

  TfpgSuggestionRenderElement = (
    sreNone,
    sreBackground,
    sreRow,
    sreSelection,
    sreText,
    sreDetailText,
    sreIcon,
    sreBorder,
    sreDetailsBackground,
    sreDetailsText
  );

  TfpgSuggestionTextKind = (
    stkDisplay,
    stkDetail,
    stkDocumentation,
    stkHint
  );

  TfpgSuggestionRendererMetrics = record
    RowHeight: Integer;
    IconSize: Integer;
    TextLeft: Integer;
    TextTop: Integer;
    DetailGap: Integer;
    RowPaddingLeft: Integer;
    RowPaddingTop: Integer;
    RowPaddingRight: Integer;
    RowPaddingBottom: Integer;
    BorderSize: Integer;
  end;

  TfpgSuggestionRowLayout = record
    RowRect: TfpgRect;
    IconRect: TfpgRect;
    TextRect: TfpgRect;
    DetailRect: TfpgRect;
    RightTextRect: TfpgRect;
  end;

  TfpgSuggestionDetailsLayout = record
    Bounds: TfpgRect;
    TitleRect: TfpgRect;
    TypeRect: TfpgRect;
    UnitRect: TfpgRect;
    DocsRect: TfpgRect;
    FooterRect: TfpgRect;
  end;

  IfpgSuggestionRenderer = interface
    ['{12B56572-F7DF-4730-BD74-9FF0AAD99816}']
    { lifecycle }
    procedure RendererAttached(ASuggestionBox: TfpgSuggestionBox);
    procedure RendererDetached(ASuggestionBox: TfpgSuggestionBox);

    { capabilities }
    function GetOptions: TfpgSuggestionRendererOptions;
    function SupportsDetailsWindow: Boolean;
    function UsesVariableRowHeight: Boolean;

    { metrics / measuring }
    function GetMetrics(ASuggestionBox: TfpgSuggestionBox): TfpgSuggestionRendererMetrics;
    function MeasureDefaultRowHeight(ASuggestionBox: TfpgSuggestionBox): Integer;
    function MeasureRowHeight(ASuggestionBox: TfpgSuggestionBox; AItem: TObject): Integer;
    function MeasureRowWidth(ASuggestionBox: TfpgSuggestionBox; AItem: TObject): Integer;
    function MeasureContentWidth(ASuggestionBox: TfpgSuggestionBox; AMaxItems: Integer = -1): Integer;
    function MeasureDetailsWidth(ASuggestionBox: TfpgSuggestionBox; AItem: TObject): Integer;
    function MeasureDetailsHeight(ASuggestionBox: TfpgSuggestionBox; AItem: TObject; AWidth: Integer): Integer;

    { layout }
    procedure LayoutRow(ASuggestionBox: TfpgSuggestionBox; AItem: TObject;
      const ARowRect: TfpgRect; AStates: TfpgSuggestionItemStates;
      out ALayout: TfpgSuggestionRowLayout);

    procedure LayoutDetails(ASuggestionBox: TfpgSuggestionBox; AItem: TObject;
      const ABounds: TfpgRect; out ALayout: TfpgSuggestionDetailsLayout);

    function GetPreferredDetailsPlacement(ASuggestionBox: TfpgSuggestionBox;
      AItem: TObject): TfpgSuggestionDetailsPlacement;

    { hit testing }
    function ItemAtPos(ASuggestionBox: TfpgSuggestionBox; X, Y: Integer): Integer;
    function ItemPartAtPos(ASuggestionBox: TfpgSuggestionBox; AItem: TObject;
      X, Y: Integer): TfpgSuggestionRenderElement;

    { painting }
    procedure PaintBackground(ASuggestionBox: TfpgSuggestionBox;
      ACanvas: TfpgCanvas; const ARect: TfpgRect);
    procedure PaintRow(ASuggestionBox: TfpgSuggestionBox; ACanvas: TfpgCanvas;
      AItem: TObject; AIndex: Integer; const ARowRect: TfpgRect;
      AStates: TfpgSuggestionItemStates);
    procedure PaintItemSelection(ASuggestionBox: TfpgSuggestionBox;
      ACanvas: TfpgCanvas; const ARowRect: TfpgRect;
      AStates: TfpgSuggestionItemStates);
    procedure PaintDetails(ASuggestionBox: TfpgSuggestionBox; ACanvas: TfpgCanvas;
      AItem: TObject; const ARect: TfpgRect);
    procedure PaintBorder(ASuggestionBox: TfpgSuggestionBox;
      ACanvas: TfpgCanvas; const ARect: TfpgRect);

    { text / hint helpers }
    function GetItemText(ASuggestionBox: TfpgSuggestionBox;
      AItem: TObject; AKind: TfpgSuggestionTextKind): string;
    function GetItemTextWidth(ASuggestionBox: TfpgSuggestionBox;
      ACanvas: TfpgCanvas; AItem: TObject; AKind: TfpgSuggestionTextKind): Integer;
    function GetItemHint(ASuggestionBox: TfpgSuggestionBox;
      AItem: TObject): string;

    { invalidation hints }
    function NeedsFullRepaintOnSelectionChange: Boolean;
    function NeedsLayoutOnDataChange: Boolean;
  end;

  { TfpgSuggestionStringsRenderer }

  TfpgSuggestionStringsRenderer = class(TInterfacedObject, IfpgSuggestionRenderer)
  private
    FSuggestionBox: TfpgSuggestionBox;
    FMetrics: TfpgSuggestionRendererMetrics;
    FShowObjectsAsDetail: Boolean;
    FDetailSeparator: string;
  protected
    function GetAdapter: TfpgSuggestionAdapterBase;
    { internal helpers }
    function GetItemString(AItem: TObject): string; virtual;
    function GetItemDetail(AItem: TObject): string; virtual;
    function GetItemObject(AItem: TObject): TObject; virtual;
    function BuildRowStates(ASuggestionBox: TfpgSuggestionBox;
      AItem: TObject; AIndex: Integer): TfpgSuggestionItemStates; virtual;

    function MeasureStringWidth(ACanvas: TfpgCanvas;
      const AText: string): Integer; virtual;
    function MeasureDetailWidth(ACanvas: TfpgCanvas;
      const AText: string): Integer; virtual;

    procedure InitDefaultMetrics; virtual;
    procedure UpdateMetrics(ASuggestionBox: TfpgSuggestionBox); virtual;

    procedure PaintRowBackground(ASuggestionBox: TfpgSuggestionBox;
      ACanvas: TfpgCanvas; const ARowRect: TfpgRect;
      AStates: TfpgSuggestionItemStates); virtual;
    procedure PaintRowText(ASuggestionBox: TfpgSuggestionBox;
      ACanvas: TfpgCanvas; const ATextRect: TfpgRect;
      const AText: string; AStates: TfpgSuggestionItemStates); virtual;
    procedure PaintRowDetail(ASuggestionBox: TfpgSuggestionBox;
      ACanvas: TfpgCanvas; const ADetailRect: TfpgRect;
      const ADetail: string; AStates: TfpgSuggestionItemStates); virtual;
    procedure PaintRowIcon(ASuggestionBox: TfpgSuggestionBox;
      ACanvas: TfpgCanvas; const AIconRect: TfpgRect;
      AItem: TObject; AStates: TfpgSuggestionItemStates); virtual;

  public
    constructor Create; virtual;

    property ShowObjectsAsDetail: Boolean
      read FShowObjectsAsDetail write FShowObjectsAsDetail;
    property DetailSeparator: string
      read FDetailSeparator write FDetailSeparator;

    { IfpgSuggestionRenderer }
    procedure RendererAttached(ASuggestionBox: TfpgSuggestionBox);
    procedure RendererDetached(ASuggestionBox: TfpgSuggestionBox);

    function GetOptions: TfpgSuggestionRendererOptions;
    function SupportsDetailsWindow: Boolean;
    function UsesVariableRowHeight: Boolean;

    function GetMetrics(ASuggestionBox: TfpgSuggestionBox): TfpgSuggestionRendererMetrics;
    function MeasureDefaultRowHeight(ASuggestionBox: TfpgSuggestionBox): Integer;
    function MeasureRowHeight(ASuggestionBox: TfpgSuggestionBox;
                              AItem: TObject): Integer;
    function MeasureRowWidth(ASuggestionBox: TfpgSuggestionBox;
                             AItem: TObject): Integer;
    function MeasureContentWidth(ASuggestionBox: TfpgSuggestionBox;
                             AMaxItems: Integer = -1): Integer;
    function MeasureDetailsWidth(ASuggestionBox: TfpgSuggestionBox;
                             AItem: TObject): Integer;
    function MeasureDetailsHeight(ASuggestionBox: TfpgSuggestionBox;
                             AItem: TObject; AWidth: Integer): Integer;
    procedure LayoutRow(ASuggestionBox: TfpgSuggestionBox; AItem: TObject;
                        const ARowRect: TfpgRect;
                        AStates: TfpgSuggestionItemStates;
                        out ALayout: TfpgSuggestionRowLayout);
    procedure LayoutDetails(ASuggestionBox: TfpgSuggestionBox; AItem: TObject;
                        const ABounds: TfpgRect; out ALayout: TfpgSuggestionDetailsLayout);
    function GetPreferredDetailsPlacement(ASuggestionBox: TfpgSuggestionBox;
      AItem: TObject): TfpgSuggestionDetailsPlacement;

    function ItemAtPos(ASuggestionBox: TfpgSuggestionBox; X, Y: Integer): Integer;
    function ItemPartAtPos(ASuggestionBox: TfpgSuggestionBox; AItem: TObject;
               X, Y: Integer): TfpgSuggestionRenderElement;

    procedure PaintBackground(ASuggestionBox: TfpgSuggestionBox; ACanvas: TfpgCanvas; const ARect: TfpgRect);
    procedure PaintRow(ASuggestionBox: TfpgSuggestionBox; ACanvas: TfpgCanvas;
                AItem: TObject; AIndex: Integer; const ARowRect: TfpgRect;
                AStates: TfpgSuggestionItemStates);
    procedure PaintItemSelection(ASuggestionBox: TfpgSuggestionBox;
                ACanvas: TfpgCanvas; const ARowRect: TfpgRect;
                AStates: TfpgSuggestionItemStates);
    procedure PaintDetails(ASuggestionBox: TfpgSuggestionBox; ACanvas: TfpgCanvas;
                AItem: TObject; const ARect: TfpgRect);
    procedure PaintBorder(ASuggestionBox: TfpgSuggestionBox;
                ACanvas: TfpgCanvas; const ARect: TfpgRect);

    function GetItemText(ASuggestionBox: TfpgSuggestionBox;
                AItem: TObject; AKind: TfpgSuggestionTextKind): string;
    function GetItemTextWidth(ASuggestionBox: TfpgSuggestionBox;
                ACanvas: TfpgCanvas; AItem: TObject; AKind: TfpgSuggestionTextKind): Integer;
    function GetItemHint(ASuggestionBox: TfpgSuggestionBox;
                AItem: TObject): string;

    function NeedsFullRepaintOnSelectionChange: Boolean;
    function NeedsLayoutOnDataChange: Boolean;
  end;

  TfpgSuggestionOption = (soForwardKeyEvents, soForwardNavigationChars);
  TfpgSuggestionOptions = set of TfpgSuggestionOption;


  // See TfpgSuggestionBox.CDefaultOptions
  TfpgSuggestionBoxOption = (
    sboForwardUnhandledKeys,
    sboForwardCharacterKeys,
    sboForwardNavigationKeys,
    sboCloseOnEscape,
    //sboCloseOnFocusLoss, popup window already does this
    sboCloseOnCaretContextChange,
    //sboAutoSelectFirstItem,
    sboConsumeAcceptKeys,
    sboConsumeNavigationKeys,
    sboAllowMouseSelection,
    sboCaseInsensitive,
    sboShowDetailsWindow
  );



  TfpgSuggestionBoxOptions = set of TfpgSuggestionBoxOption;

  TfpgSuggestionAcceptKey = (
    sakReturn,
    sakTab,
    sakDoubleClick
  );

  TfpgSuggestionAcceptKeys = set of TfpgSuggestionAcceptKey;

  TfpgSuggestionCommitMode = (
    scmInsert,
    scmReplace
  );

  TfpgSuggestionCloseReason = (
    scrUnknown,
    scrCancelled,
    scrAccepted,
    scrFocusLost,
    scrCaretContextChanged,
    scrSourceInvalidated,
    scrWidgetHidden,
    scrNoMatch
  );

  TfpgSuggestionNavigationKey = (
    snkUp,
    snkDown,
    snkPageUp,
    snkPageDown,
    snkHome,
    snkEnd
  );

  TfpgSuggestionNavigationKeys = set of TfpgSuggestionNavigationKey;

  TfpgSuggestionTriggerKind = (
    stkManual,
    stkAuto,
    stkTyping
  );

  TfpgSuggestionAnchorMode = (
    samCaret,
    samWidget,
    samCustomRect
  );

  TfpgSuggestionKeyHandling = (
    skhConsume,
    skhForwardToTarget,
    skhConsumeAndForward
  );

  TfpgSuggestionContext = record
    TriggerKind: TfpgSuggestionTriggerKind;
    PixelX,PixelY: Integer;
    StartX: Integer;
    StartY: Integer;
    StartCaretPos: Integer;
    StartLine: Integer;
    StartColumn: Integer;
    Prefix: string;
    AnchorRect: TfpgRect;
  end;

  TfpgSuggestionBeforeAcceptEvent =
    procedure(Sender: TObject; AItem: TObject; AKey: TfpgSuggestionAcceptKey;
      ACommitMode: TfpgSuggestionCommitMode; var AAllow: Boolean) of object;

  TfpgSuggestionAcceptedEvent =
    procedure(Sender: TObject; AItem: TObject; AKey: TfpgSuggestionAcceptKey;
      ACommitMode: TfpgSuggestionCommitMode) of object;

  TfpgSuggestionCloseEvent =
    procedure(Sender: TObject; AReason: TfpgSuggestionCloseReason) of object;

  TfpgSuggestionSelectionChangedEvent =
    procedure(Sender: TObject; AOldIndex, ANewIndex: Integer) of object;

  TfpgSuggestionContextValidEvent =
    procedure(Sender: TObject; const AContext: TfpgSuggestionContext;
      var AIsValid: Boolean) of object;

  TfpgSuggestionContextUpdateEvent =
    procedure(Sender: TObject; const AContext: TfpgSuggestionContext;
      out AInfo: TfpgSuggestionWordInfo) of object;

  TfpgSuggestionForwardKeyEvent =
    procedure(var AKeyCode: Word; var AShiftState: TShiftState;
      var AHandled: Boolean) of object;

  TfpgSuggestionForwardCharEvent =
    procedure(var AChar: TfpgChar; var AShiftState: TShiftState;
      var AHandled: Boolean) of object;
  TfpgSuggestionCheckCompletionCharEvent =
    function (AChar: TfpgChar; AShiftState: TShiftState): TfpgSuggestionAcceptKeys of object;

  { TfpgSuggestionBox }

  TfpgSuggestionBox = class(TfpgPopupWindow)
  public const
    CDefaultOptions: TfpgSuggestionBoxOptions =
    [
      sboForwardUnhandledKeys
     ,sboForwardCharacterKeys
     ,sboForwardNavigationKeys
     ,sboCloseOnEscape
     //,sboCloseOnCaretContextChange
     ,sboConsumeAcceptKeys
     ,sboConsumeNavigationKeys
     ,sboAllowMouseSelection
     ,sboShowDetailsWindow
     ,sboCaseInsensitive
    ];
  private
    FAdapter: TfpgSuggestionAdapterBase;
    FDefaultCommitMode: TfpgSuggestionCommitMode;
    FOnCheckCompletionChar: TfpgSuggestionCheckCompletionCharEvent;
    FOnContextUpdate: TfpgSuggestionContextUpdateEvent;
    FOnForwardChar: TfpgSuggestionForwardCharEvent;
    FOnForwardKeyRelease: TfpgSuggestionForwardKeyEvent;
    FRenderer: IfpgSuggestionRenderer;
    FTargetWidget: TfpgWidget;
    FOptions: TfpgSuggestionBoxOptions;
    FAcceptKeys: TfpgSuggestionAcceptKeys;
    FNavigationKeys: TfpgSuggestionNavigationKeys;
    FEnterCommitMode: TfpgSuggestionCommitMode;
    FTabCommitMode: TfpgSuggestionCommitMode;
    FSelectionIndex: Integer;
    FTopIndex: Integer;
    FVisibleRowCount: Integer;
    FRowHeight: Integer;
    FAnchorMode: TfpgSuggestionAnchorMode;
    FContext: TfpgSuggestionContext;
    FOnBeforeAccept: TfpgSuggestionBeforeAcceptEvent;
    FOnAccepted: TfpgSuggestionAcceptedEvent;
    FOnClosed: TfpgSuggestionCloseEvent;
    FOnSelectionChanged: TfpgSuggestionSelectionChangedEvent;
    FOnContextValid: TfpgSuggestionContextValidEvent;
    FOnForwardKeyPress: TfpgSuggestionForwardKeyEvent;
    function GetSelectionIndex: Integer;
    procedure SetAdapter(const AValue: TfpgSuggestionAdapterBase);
    procedure SetRenderer(const AValue: IfpgSuggestionRenderer);
    procedure SetTargetWidget(const AValue: TfpgWidget);
    procedure SetSelectionIndex(const AValue: Integer);
  protected
    { adapter / model hookup }
    procedure AdapterChanged(Sender: TObject; AKind: TfpgSuggestionAdapterChangeKind); virtual;

    { popup lifecycle }
    procedure DoClose(AReason: TfpgSuggestionCloseReason); virtual;
    procedure DoAccepted(AItem: TObject; AKey: TfpgSuggestionAcceptKey;
      ACommitMode: TfpgSuggestionCommitMode); virtual;
    function DoBeforeAccept(AItem: TObject; AKey: TfpgSuggestionAcceptKey;
      ACommitMode: TfpgSuggestionCommitMode): Boolean; virtual;

    { selection / scrolling }
    function GetItemCount: Integer; virtual;
    function GetSelectedItem: TObject; virtual;
    procedure SetTopIndex(AValue: Integer); virtual;
    procedure EnsureSelectionVisible; virtual;
    procedure MoveSelectionUp; virtual;
    procedure MoveSelectionDown; virtual;
    procedure MoveSelectionPageUp; virtual;
    procedure MoveSelectionPageDown; virtual;
    procedure MoveSelectionHome; virtual;
    procedure MoveSelectionEnd; virtual;
    procedure ChangeSelection(ANewIndex: Integer); virtual;

    { context and closing rules }
    procedure InitContext; virtual;
    procedure UpdateContextFromTarget; virtual;
    function IsContextStillValid: Boolean; virtual;
    function IsCaretStillAtCompletionContext: Boolean; virtual;
    procedure CheckAutoClose; virtual;

    { key handling }
    function GetKeyHandling(AKeyCode: Word; AShiftState: TShiftState): TfpgSuggestionKeyHandling; virtual;
    function IsAcceptKey(AKeyCode: Word; AShiftState: TShiftState; out AAcceptKey: TfpgSuggestionAcceptKey): Boolean; virtual;
    function IsNavigationKey(AKeyCode: Word; AShiftState: TShiftState; out ANavKey: TfpgSuggestionNavigationKey): Boolean; virtual;
    function GetCommitModeForKey(AAcceptKey: TfpgSuggestionAcceptKey) : TfpgSuggestionCommitMode; virtual;
    function HandleAcceptKey(AKeyCode: Word; AShiftState: TShiftState): Boolean; virtual;
    function HandleNavigationKey(AKeyCode: Word; AShiftState: TShiftState): Boolean; virtual;
    function HandleForwardKeyPress(var AKeyCode: Word;  var AShiftState: TShiftState; AConsumed: Boolean): Boolean; virtual;


    { rendering and layout }
    function MeasureRowHeight: Integer; virtual;
    function MeasureVisibleRowCount: Integer; virtual;
    function GetPreferredPopupHeight: Integer; virtual;
    function GetPreferredPopupWidth: Integer; virtual;
    procedure UpdatePopupBounds; virtual;
    procedure UpdateDetailsWindow; virtual;

    { widget overrides }
    procedure HandleKeyPress(var keycode: word; var shiftstate: TShiftState;  var consumed: boolean); override;
    procedure HandleKeyChar(var AText: TfpgChar; var shiftstate: TShiftState; var consumed: boolean); override;
    procedure HandleShow; override;
    procedure HandleHide; override;
    procedure HandleResize(AWidth, AHeight: TfpgCoord); override;
    procedure HandlePaint; override;
    procedure HandleLMouseDown(x, y: integer; shiftstate: TShiftState); override;
    procedure HandleMouseMove(x, y: integer; btnstate: word; shiftstate: TShiftState); override;
    procedure HandleDoubleClick(x, y: integer; button: word; shiftstate: TShiftState); override;
    procedure HandleKillFocus; override;
  public
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;

    procedure PopupFor(ATargetWidget: TfpgWidget;
      const AContext: TfpgSuggestionContext); overload; virtual;

    procedure CloseSuggestion(AReason: TfpgSuggestionCloseReason = scrUnknown); virtual;
    procedure AcceptSelection(AKey: TfpgSuggestionAcceptKey); virtual;
    procedure CancelSuggestion; virtual;
    procedure RefreshSuggestions; virtual;

    property Adapter: TfpgSuggestionAdapterBase read FAdapter write SetAdapter;
    property Renderer: IfpgSuggestionRenderer read FRenderer write SetRenderer;
    property TargetWidget: TfpgWidget read FTargetWidget write SetTargetWidget;

    property Options: TfpgSuggestionBoxOptions read FOptions write FOptions;
    property AcceptKeys: TfpgSuggestionAcceptKeys read FAcceptKeys write FAcceptKeys;
    property NavigationKeys: TfpgSuggestionNavigationKeys
      read FNavigationKeys write FNavigationKeys;

    property EnterCommitMode: TfpgSuggestionCommitMode read FEnterCommitMode write FEnterCommitMode;
    property TabCommitMode: TfpgSuggestionCommitMode read FTabCommitMode write FTabCommitMode;
    property DefaultCommitMode: TfpgSuggestionCommitMode read FDefaultCommitMode write FDefaultCommitMode;

    property SelectionIndex: Integer read GetSelectionIndex write SetSelectionIndex;
    property SelectedItem: TObject read GetSelectedItem;
    property TopIndex: Integer read FTopIndex write SetTopIndex;
    property ItemCount: Integer read GetItemCount;
    property VisibleRowCount: Integer read FVisibleRowCount;
    property RowHeight: Integer read FRowHeight;
    property AnchorMode: TfpgSuggestionAnchorMode read FAnchorMode write FAnchorMode;
    property Context: TfpgSuggestionContext read FContext write FContext;

    property OnBeforeAccept: TfpgSuggestionBeforeAcceptEvent read FOnBeforeAccept write FOnBeforeAccept;
    property OnAccepted: TfpgSuggestionAcceptedEvent read FOnAccepted write FOnAccepted;
    property OnClosed: TfpgSuggestionCloseEvent read FOnClosed write FOnClosed;
    property OnSelectionChanged: TfpgSuggestionSelectionChangedEvent read FOnSelectionChanged write FOnSelectionChanged;
    property OnContextValid: TfpgSuggestionContextValidEvent read FOnContextValid write FOnContextValid;
    property OnContextUpdate: TfpgSuggestionContextUpdateEvent read FOnContextUpdate write FOnContextUpdate;
    property OnForwardKeyPress: TfpgSuggestionForwardKeyEvent read FOnForwardKeyPress write FOnForwardKeyPress;
    property OnForwardChar: TfpgSuggestionForwardCharEvent read FOnForwardChar write FOnForwardChar;
    // for accepting suggestions on various other chars. .';:
    property OnCheckCompletionChar: TfpgSuggestionCheckCompletionCharEvent read FOnCheckCompletionChar write FOnCheckCompletionChar;
    //property OnForwardKeyRelease: TfpgSuggestionForwardKeyEvent read FOnForwardKeyRelease write FOnForwardKeyRelease;
  end;

implementation

{ TfpgSuggestionBox }

procedure TfpgSuggestionBox.SetAdapter(const AValue: TfpgSuggestionAdapterBase);
begin
  if AValue = FAdapter then
    Exit;

  // possibly dangerous if it's already been freed.
  //if Assigned(FAdapter) then
  //  FAdapter.OnChanged:=nil;

  FAdapter := AValue;

  if Assigned(FAdapter) then
  begin
    FAdapter.SuggestionBoxAttached(Self);
    FAdapter.OnChanged:=@AdapterChanged;
  end;
end;

function TfpgSuggestionBox.GetSelectionIndex: Integer;
begin
  Result := FSelectionIndex;
  if FSelectionIndex > Adapter.GetCount-1 then
    Result := Adapter.GetCount-1;
end;

procedure TfpgSuggestionBox.SetRenderer(const AValue: IfpgSuggestionRenderer);
begin
  if AValue = FRenderer then
    Exit;

  if Assigned(FRenderer) then
    FRenderer.RendererDetached(Self);

  FRenderer := nil; // if refcounted
  FRenderer := AValue;

  if Assigned(FRenderer) then
    FRenderer.RendererAttached(Self);
end;

procedure TfpgSuggestionBox.SetTargetWidget(const AValue: TfpgWidget);
begin
  FTargetWidget := AValue;
end;

procedure TfpgSuggestionBox.SetSelectionIndex(const AValue: Integer);
begin
  if FSelectionIndex = AValue then
    Exit;
  FSelectionIndex:=AValue;
  Invalidate;
end;

procedure TfpgSuggestionBox.AdapterChanged(Sender: TObject; AKind: TfpgSuggestionAdapterChangeKind);
begin
  // called by the adapter
  if Sender <> FAdapter then
    raise Exception.Create('detached adapter event is still connected. fix your code');
  Invalidate;
end;

procedure TfpgSuggestionBox.DoClose(AReason: TfpgSuggestionCloseReason);
begin
  Close;
  // not sure the reason is useful
end;

procedure TfpgSuggestionBox.DoAccepted(AItem: TObject;
  AKey: TfpgSuggestionAcceptKey; ACommitMode: TfpgSuggestionCommitMode);
var
  lHost: IfpgSuggestionHost;
  lApplyMode: TfpgSuggestionApplyMode;
begin
  if Assigned(AItem) then
  begin
    if Assigned(PopupWidget) and (PopupWidget Is IfpgSuggestionHost) then
    begin
      lHost := PopupWidget as IfpgSuggestionHost;
      if AKey in [sakReturn, sakDoubleClick] then
        lApplyMode := samReplace
      else
        lApplyMode := samInsert;
      lHost.ApplySuggestion(Adapter.GetDisplayText(AItem), lApplyMode);
    end;

    if Assigned(FOnAccepted) then
      OnAccepted(Self, AItem, AKey, ACommitMode);
    CloseSuggestion(scrAccepted);
  end
  else
    CloseSuggestion(scrNoMatch); // no matching item but accept was pressed
end;

function TfpgSuggestionBox.DoBeforeAccept(AItem: TObject; AKey: TfpgSuggestionAcceptKey; ACommitMode: TfpgSuggestionCommitMode): Boolean;
var
  lAllow: Boolean = True;
begin
  if Assigned(FOnBeforeAccept) then
    FOnBeforeAccept(Self, AItem, AKey, ACommitMode, lAllow);

  if lAllow then
    DoAccepted(AItem, AKey, ACommitMode);
end;

function TfpgSuggestionBox.GetItemCount: Integer;
begin
  Result := 0;
  if Assigned(FAdapter) then
    Result := Adapter.GetCount;
end;

function TfpgSuggestionBox.GetSelectedItem: TObject;
begin
  Result := nil;
  if Assigned(Adapter) and (SelectionIndex > -1) then
  begin
    Result := Adapter.GetItem(SelectionIndex);
  end;
end;

procedure TfpgSuggestionBox.SetTopIndex(AValue: Integer);
begin

end;

procedure TfpgSuggestionBox.EnsureSelectionVisible;
begin

end;

procedure TfpgSuggestionBox.MoveSelectionUp;
begin
  if SelectionIndex > 0 then
    SelectionIndex:=SelectionIndex-1;
  Invalidate;
end;

procedure TfpgSuggestionBox.MoveSelectionDown;
begin
  if SelectionIndex < GetItemCount-1 then
    SelectionIndex:=SelectionIndex+1;
  Invalidate;
end;

procedure TfpgSuggestionBox.MoveSelectionPageUp;
begin

end;

procedure TfpgSuggestionBox.MoveSelectionPageDown;
begin

end;

procedure TfpgSuggestionBox.MoveSelectionHome;
begin
  SelectionIndex:=0;
  Invalidate;
end;

procedure TfpgSuggestionBox.MoveSelectionEnd;
begin
  SelectionIndex:=GetItemCount-1;
  Invalidate;
end;

procedure TfpgSuggestionBox.ChangeSelection(ANewIndex: Integer);
begin

end;

procedure TfpgSuggestionBox.InitContext;
begin
  Adapter.Filter := '';
  Adapter.Filter:=FContext.Prefix;
  SelectionIndex:=0; // reading returns -1 of no matches
end;

procedure TfpgSuggestionBox.UpdateContextFromTarget;
var
  lInfo: TfpgSuggestionWordInfo;
begin
  // first try the interface
  // fallback to the event handler

  if (PopupWidget is IfpgSuggestionHost)
  and (PopupWidget as IfpgSuggestionHost).GetSuggestionInfo(lInfo)
  then
  begin
    Adapter.Filter := lInfo.Text;
  end
  else if Assigned(FOnContextUpdate) then
  begin
    FOnContextUpdate(Self, FContext, lInfo);
    Adapter.Filter:=lInfo.Text;
    Invalidate;
  end;
end;

function TfpgSuggestionBox.IsContextStillValid: Boolean;
begin
  Result := True;
  if Assigned(OnContextValid) then
  begin
    OnContextValid(Self, FContext, Result);
  end;
end;

function TfpgSuggestionBox.IsCaretStillAtCompletionContext: Boolean;
begin

end;

procedure TfpgSuggestionBox.CheckAutoClose;
begin

end;

function TfpgSuggestionBox.GetKeyHandling(AKeyCode: Word;
  AShiftState: TShiftState): TfpgSuggestionKeyHandling;
var
  lNavKey: TfpgSuggestionNavigationKey;
  lAcceptKey: TfpgSuggestionAcceptKey;

begin
  if IsAcceptKey(AKeyCode, AShiftState, lAcceptKey)
  and HandleAcceptKey(AKeyCode, AShiftState) then
  begin
    if sboConsumeAcceptKeys in Options then
      Result := skhConsume
    else
      Result := skhConsumeAndForward;
    Exit;
  end;

  if IsNavigationKey(AKeyCode, AShiftState, lNavKey)
  and HandleNavigationKey(AKeyCode, AShiftState) then
  begin
    if sboConsumeNavigationKeys in Options then
      Result := skhConsume
    else
      Result := skhConsumeAndForward;
    Exit;
  end;

  if (AKeyCode = keyEscape) and (sboCloseOnEscape in Options) then
  begin
    CloseSuggestion(scrCancelled);
  end;

  if sboForwardUnhandledKeys in Options then
    Result := TfpgSuggestionKeyHandling.skhForwardToTarget
  else
    Result := skhConsume;
end;

function TfpgSuggestionBox.IsAcceptKey(AKeyCode: Word;
  AShiftState: TShiftState; out AAcceptKey: TfpgSuggestionAcceptKey): Boolean;
begin
  //if AShiftState - [ssCaps] <> [] then Exit(False);

  Result := True;
  case AKeyCode of
    keyEnter: AAcceptKey:= sakReturn;
    keyTab: AAcceptKey:=sakTab;
  else
    Result := False;
  end;
end;

function TfpgSuggestionBox.IsNavigationKey(AKeyCode: Word;
  AShiftState: TShiftState; out ANavKey: TfpgSuggestionNavigationKey): Boolean;
begin
  Result :=  True;
  //if AShiftState - [ssCaps] <> [] then Exit(False);

  case AKeyCode of
    keyUp: ANavKey:=snkUp;
    keyDown: ANavKey:=snkDown;
    keyPageUp: ANavKey:=snkPageUp;
    keyPageDown: ANavKey:=snkPageDown;
    keyHome: ANavKey:=snkHome;
    keyEnd: ANavKey:=snkEnd;
  else
    Result := False;
  end;
end;

function TfpgSuggestionBox.GetCommitModeForKey(
  AAcceptKey: TfpgSuggestionAcceptKey): TfpgSuggestionCommitMode;
begin
  case AAcceptKey of
    sakTab        : Result := scmInsert;
    sakReturn     : Result := scmReplace;
    sakDoubleClick: Result := scmReplace;
  end;
end;

function TfpgSuggestionBox.HandleAcceptKey(AKeyCode: Word;
  AShiftState: TShiftState): Boolean;
var
  lAcceptKey: TfpgSuggestionAcceptKey;
begin
  //if AShiftState - [ssCaps] <> [] then Exit(False);

  Result := IsAcceptKey(AKeyCode, AShiftState, lAcceptKey);

  if Result then
    DoAccepted(SelectedItem, lAcceptKey, GetCommitModeForKey(lAcceptKey));
end;

function TfpgSuggestionBox.HandleNavigationKey(AKeyCode: Word;
  AShiftState: TShiftState): Boolean;
var
  lNavKey: TfpgSuggestionNavigationKey;
begin
  //if AShiftState - [ssCaps] <> [] then Exit(False);

  Result := IsNavigationKey(AKeyCode, AShiftState, lNavKey);
  if Result then
  case lNavKey of
    snkUp       : MoveSelectionUp;
    snkDown     : MoveSelectionDown;
    snkPageDown : MoveSelectionPageDown;
    snkPageUp   : MoveSelectionPageUp;
    snkHome     : MoveSelectionHome;
    snkEnd      : MoveSelectionEnd;
  end;
end;

function TfpgSuggestionBox.HandleForwardKeyPress(var AKeyCode: Word;
  var AShiftState: TShiftState; AConsumed: Boolean): Boolean;
begin
  Result := AConsumed;
  if Assigned(FOnForwardKeyPress) then
    FOnForwardKeyPress(AKeyCode, AShiftState, Result);
end;

function TfpgSuggestionBox.MeasureRowHeight: Integer;
begin
  if Canvas.Font = nil then
    Canvas.SetFontDefinition(fpgStyleManager.Style.FixedFontDef);
  Result := Renderer.MeasureDefaultRowHeight(Self);
end;

function TfpgSuggestionBox.MeasureVisibleRowCount: Integer;
begin
  // TODO make smarter
  Result := 10;
end;

function TfpgSuggestionBox.GetPreferredPopupHeight: Integer;
begin
  Result := MeasureRowHeight*MeasureVisibleRowCount;
end;

function TfpgSuggestionBox.GetPreferredPopupWidth: Integer;
begin
  Result := Renderer.MeasureContentWidth(Self);
end;

procedure TfpgSuggestionBox.UpdatePopupBounds;
begin

  HandleResize(GetPreferredPopupWidth, GetPreferredPopupHeight);
  //Invalidate;
  {
  TfpgSuggestionBox.UpdatePopupBounds is responsible for recalculating and
  adjusting the on‑screen position and size of the suggestion‑popup window
  (the dropdown list) so that it stays correctly aligned with the owner edit
  field and does not clip off the screen.

  if the main windo is moved?
  }

end;

procedure TfpgSuggestionBox.UpdateDetailsWindow;
begin
  if not Adapter.HasDetails(SelectedItem) then  ;

end;


procedure TfpgSuggestionBox.HandleKeyPress(var keycode: word;
  var shiftstate: TShiftState; var consumed: boolean);
var
  lUpdate: Boolean;
begin
  case GetKeyHandling(keycode, shiftstate) of
    skhConsume: consumed := True;
    skhConsumeAndForward:
      begin
        HandleForwardKeyPress(KeyCode, shiftstate, consumed);
        consumed := True;
      end;
    skhForwardToTarget:
      begin
        lUpdate := (keycode = keyBackSpace) or (keycode = keyLeft) or (keycode = keyRight);
        consumed := HandleForwardKeyPress(KeyCode, shiftstate, consumed);
        if lUpdate then
        begin
          if IsContextStillValid then
            UpdateContextFromTarget
          else
            CloseSuggestion(scrCaretContextChanged);

        end;
      end;
  end;
end;

procedure TfpgSuggestionBox.HandleKeyChar(var AText: TfpgChar;
  var shiftstate: TShiftState; var consumed: boolean);
var
  lDoAccept: TfpgSuggestionAcceptKeys;
begin
  if (sboForwardCharacterKeys in Options) and Assigned(FOnForwardChar) then
  begin
    if Assigned(FOnCheckCompletionChar) then
    begin
      lDoAccept := FOnCheckCompletionChar(AText, ShiftState);
      if sakReturn in lDoAccept then
        AcceptSelection(sakReturn)
      else if sakTab in lDoAccept then
        AcceptSelection(sakTab);
    end;

    FOnForwardChar(AText, shiftstate, consumed);
    UpdateContextFromTarget;
  end
  else
    inherited HandleKeyChar(AText, shiftstate, consumed);
end;

procedure TfpgSuggestionBox.HandleShow;
begin
  inherited HandleShow;
end;

procedure TfpgSuggestionBox.HandleHide;
begin
  inherited HandleHide;
end;

procedure TfpgSuggestionBox.HandleResize(AWidth, AHeight: TfpgCoord);
begin
  inherited HandleResize(AWidth, AHeight);
  Width := AWidth;
  Height := AHeight;
end;

procedure TfpgSuggestionBox.HandlePaint;
var
  i, lHeight: Integer;
  lState: TfpgSuggestionItemStates;
begin
  Canvas.BeginDraw;
  Canvas.SetFont(fpgApplication.FontManager.GetFont(FontDesc));

  Renderer.PaintBackground(Self, Self.Canvas, GetClientRect);

  for i := 0 to Adapter.GetCount-1 do
  begin
    lState := [];
    if i = SelectionIndex then
      Include(lState, sisSelected);
    lHeight := Renderer.MeasureDefaultRowHeight(Self);
    Renderer.PaintRow(Self, Self.Canvas, Adapter.GetItem(i), i, fpgRect(0, lHeight*i, 300, lHeight), lState );
  end;
  Canvas.EndDraw;
end;

procedure TfpgSuggestionBox.HandleLMouseDown(x, y: integer;
  shiftstate: TShiftState);
begin
  inherited HandleLMouseDown(x, y, shiftstate);
  SelectionIndex := Renderer.ItemAtPos(Self, x, y);
  Invalidate;
end;

procedure TfpgSuggestionBox.HandleMouseMove(x, y: integer; btnstate: word;
  shiftstate: TShiftState);
begin
  inherited HandleMouseMove(x, y, btnstate, shiftstate);
end;

procedure TfpgSuggestionBox.HandleDoubleClick(x, y: integer; button: word;
  shiftstate: TShiftState);
begin
  inherited HandleDoubleClick(x, y, button, shiftstate);
end;

procedure TfpgSuggestionBox.HandleKillFocus;
begin
  inherited HandleKillFocus;
end;

constructor TfpgSuggestionBox.Create(AOwner: TComponent);
begin
  inherited Create(AOwner);
  Options:=CDefaultOptions;
  SetFontDesc(fpgStyleManager.Style.FixedFontDef.FontDesc);
  Canvas.SetFontDefinition(fpgStyleManager.Style.FixedFontDef);
end;

destructor TfpgSuggestionBox.Destroy;
begin
  inherited Destroy;
end;

procedure TfpgSuggestionBox.PopupFor(ATargetWidget: TfpgWidget;
  const AContext: TfpgSuggestionContext);
begin
  Context := AContext;
  InitContext;

  if (Adapter = nil) or (Renderer = nil) then
  begin
    CloseSuggestion(scrUnknown);
    Exit;
  end;

  Visible := False;

  case AnchorMode of
    samCaret: ShowAt(ATargetWidget, Context.PixelX, Context.PixelY);
  end;
  HandleResize(GetPreferredPopupWidth, GetPreferredPopupHeight);
  Visible := True;
  Invalidate;
end;

procedure TfpgSuggestionBox.CloseSuggestion(AReason: TfpgSuggestionCloseReason);
begin
  Close;
end;

procedure TfpgSuggestionBox.AcceptSelection(AKey: TfpgSuggestionAcceptKey);
begin
  DoAccepted(SelectedItem, AKey, GetCommitModeForKey(AKey));
end;

procedure TfpgSuggestionBox.CancelSuggestion;
begin
  Close;
end;

procedure TfpgSuggestionBox.RefreshSuggestions;
begin
end;

{ TfpgSuggestionAdapterBase }

procedure TfpgSuggestionAdapterBase.SetFilter(AValue: String);
begin
  if FFilter=AValue then Exit;
  FFilter:=AValue;
end;

procedure TfpgSuggestionAdapterBase.DoBeginUpdate;
begin
  Inc(FUpdateLock);
end;

procedure TfpgSuggestionAdapterBase.DoEndUpdate;
begin
  Dec(FUpdateLock);
  if FUpdateLock < 0 then
    FUpdateLock:=0;

  if FUpdateLock = 0 then
    FPONotifyObservers(Self, ooChange, nil);
end;

function TfpgSuggestionAdapterBase.GetUpdating: Boolean;
begin
  Result := FUpdateLock > 0;
end;

function TfpgSuggestionAdapterBase.DoGetDetailText(AItem: TObject): string;
begin
  Result := '';
end;

function TfpgSuggestionAdapterBase.DoGetFilterText(AItem: TObject): string;
begin
  Result := GetDisplayText(AItem);
end;

function TfpgSuggestionAdapterBase.DoGetSortText(AItem: TObject): string;
begin
  Result := GetDisplayText(AItem);
end;

function TfpgSuggestionAdapterBase.DoGetDocumentationText(AItem: TObject
  ): string;
begin
  Result := '';
end;

function TfpgSuggestionAdapterBase.DoGetItemHint(AItem: TObject): string;
begin
  Result := '';
end;

function TfpgSuggestionAdapterBase.DoGetItemImageIndex(AItem: TObject): Integer;
begin
  Result := -1;
end;

function TfpgSuggestionAdapterBase.DoGetItemData(AItem: TObject): Pointer;
begin
  Result := nil;
end;

function TfpgSuggestionAdapterBase.DoItemMatches(AItem: TObject;
  const AFilter: string): Boolean;
begin
  Result := False;
end;

function TfpgSuggestionAdapterBase.DoCompareItems(AItem1, AItem2: TObject): Integer;
var
  lText1, lText2: String;
  Pos1, Pos2: SizeInt;
begin
  lText1 := DoGetSortText(AItem1);
  lText2 := DoGetSortText(AItem2);
  Pos1 := Pos(Filter, lText1);
  Pos2 := Pos(Filter, lText2);

  if Pos1 < Pos2 then
    Exit(-1)
  else if Pos1 > Pos2 then
    Exit(1)
  else
    if sboCaseInsensitive in FOwnerBox.Options then
      Result := CompareText(DoGetSortText(AItem1), DoGetSortText(AItem2))
    else
      Result := CompareStr(DoGetSortText(AItem1), DoGetSortText(AItem2));
end;

function TfpgSuggestionAdapterBase.DoHasDetails(AItem: TObject): Boolean;
begin
  Result := False;
end;

procedure TfpgSuggestionAdapterBase.QuickSortFiltered(L, R: Integer);
var
  I, J: Integer;
  Pivot, Temp: TObject;
begin
  I := L;
  J := R;
  Pivot := GetItem((L + R) div 2);

  repeat
    while DoCompareItems(GetItem(I), Pivot) < 0 do
      Inc(I);

    while DoCompareItems(GetItem(J), Pivot) > 0 do
      Dec(J);

    if I <= J then
    begin
      DoSwapFilteredItems(I, J);
      Inc(I);
      Dec(J);
    end;
  until I > J;

  if L < J then
    QuickSortFiltered(L, J);
  if I < R then
    QuickSortFiltered(I, R);
end;

procedure TfpgSuggestionAdapterBase.SortFilteredItems;
begin
  BeginUpdate;
  if GetCount > 0 then
    QuickSortFiltered(0, GetCount-1);
  EndUpdate;
end;

procedure TfpgSuggestionAdapterBase.Notification(AComponent: TComponent;
  Operation: TOperation);
begin

end;

constructor TfpgSuggestionAdapterBase.Create;
begin

end;

destructor TfpgSuggestionAdapterBase.Destroy;
begin
  if Assigned(FObservers) then
  begin
    FPONotifyObservers(Self, ooFree, nil);
    FreeAndNil(FObservers);
  end;
  inherited Destroy;
end;

procedure TfpgSuggestionAdapterBase.FPOObservedChanged(ASender: TObject;
  Operation: TFPObservedOperation; Data: Pointer);
begin

end;

procedure TfpgSuggestionAdapterBase.FPOAttachObserver(AObserver: TObject);
var
  I: IFPObserver;
begin
  if Not AObserver.GetInterface(SGUIDObserver,I) then
    raise EObserver.CreateFmt(SErrNotObserver,[AObserver.ClassName]);
  if not Assigned(FObservers) then
    FObservers:=TFPList.Create;
  FObservers.Add(I);
end;

procedure TfpgSuggestionAdapterBase.FPODetachObserver(AObserver: TObject);
var
  I: IFPObserver;
begin
  if not AObserver.GetInterface(SGUIDObserver,I) then
    raise EObserver.CreateFmt(SErrNotObserver,[AObserver.ClassName]);
  if Assigned(FObservers) then
  begin
    FObservers.Remove(I);
    if (FObservers.Count=0) then
      FreeAndNil(FObservers);
  end;
end;

procedure TfpgSuggestionAdapterBase.FPONotifyObservers(ASender: TObject;
  AOperation: TFPObservedOperation; Data: Pointer);
Var
  i : Integer;
  Obs : IFPObserver;
begin
  if Assigned(FObservers) then
    for i:=FObservers.Count-1 downto 0 do
    begin
      Obs := IFPObserver(FObservers[i]);
      Obs.FPOObservedChanged(ASender, AOperation, Data);
    end;
end;

procedure TfpgSuggestionAdapterBase.BeginUpdate;
begin
  Inc(FUpdateLock);
end;

procedure TfpgSuggestionAdapterBase.EndUpdate;
begin
  Dec(FUpdateLock);
  if FUpdateLock = 0 then
    FPONotifyObservers(Self, ooChange, nil);
end;

function TfpgSuggestionAdapterBase.GetCount: Integer;
begin
  Result := DoGetCount;
end;

function TfpgSuggestionAdapterBase.GetItem(AIndex: Integer): TObject;
begin
  Result := DoGetItem(AIndex);
end;

function TfpgSuggestionAdapterBase.GetDisplayText(AItem: TObject): string;
begin
  Result := DoGetDisplayText(AItem);
end;

function TfpgSuggestionAdapterBase.GetDetailText(AItem: TObject): string;
begin
  Result := DoGetDetailText(AItem);
end;

function TfpgSuggestionAdapterBase.GetFilterText(AItem: TObject): string;
begin
  Result := DoGetFilterText(AItem);
end;

function TfpgSuggestionAdapterBase.GetSortText(AItem: TObject): string;
begin
  // this is an internal text value used to sort it. it can be the same as
  // Display text or it could have a difference that changes how the list is
  // ordered. such as a recently used item "___0_My Item" for "My Item"
  Result := DoGetSortText(AItem);
end;

function TfpgSuggestionAdapterBase.GetDocumentationText(AItem: TObject): string;
begin
  Result := DoGetDocumentationText(AItem);
end;

function TfpgSuggestionAdapterBase.GetItemHint(AItem: TObject): string;
begin
  Result := DoGetItemHint(AItem);
end;

function TfpgSuggestionAdapterBase.GetItemImageIndex(AItem: TObject): Integer;
begin
  Result := DoGetItemImageIndex(AItem);
end;

function TfpgSuggestionAdapterBase.GetItemData(AItem: TObject): Pointer;
begin
  Result := DoGetItemData(AItem);
end;

function TfpgSuggestionAdapterBase.ItemMatches(AItem: TObject;
  const AFilter: string): Boolean;
begin
  Result := False;
end;

function TfpgSuggestionAdapterBase.CompareItems(AItem1, AItem2: TObject): Integer;
begin
  if (AItem1 = AItem2) or (True) then
    Result := 0;
end;

function TfpgSuggestionAdapterBase.HasDetails(AItem: TObject): Boolean;
begin
  // to keep compiler hints down use the params
  Result := False;
  if not Assigned(AItem) then
    Result := False;
end;

procedure TfpgSuggestionAdapterBase.Reset;
begin
end;

procedure TfpgSuggestionAdapterBase.SuggestionBoxAttached(
  ASuggestionBox: TfpgSuggestionBox);
begin
  FOwnerBox := ASuggestionBox;
end;

procedure TfpgSuggestionAdapterBase.SuggestionBoxDetached(
  ASuggestionBox: TfpgSuggestionBox);
begin
  FOwnerBox := nil;
  OnChanged:=nil;
end;

{ TfpgSuggestionItem }

procedure TfpgSuggestionItem.SetDocumentation(AValue: String);
begin
  if FDocumentation=AValue then Exit;
  FDocumentation:=AValue;
end;

procedure TfpgSuggestionItem.SetImageIndex(AValue: Integer);
begin
  if FImageIndex=AValue then Exit;
  FImageIndex:=AValue;
end;

procedure TfpgSuggestionItem.SetItemData(AValue: Pointer);
begin
  if FItemData=AValue then Exit;
  FItemData:=AValue;
end;

procedure TfpgSuggestionItem.SetItemHint(AValue: String);
begin
  if FItemHint=AValue then Exit;
  FItemHint:=AValue;
end;

procedure TfpgSuggestionItem.SetDetailText(AValue: String);
begin
  if FDetailText=AValue then Exit;
  FDetailText:=AValue;
end;

function TfpgSuggestionItem.GetFilterText: String;
begin
  Result := FFilterText;
  if Result = '' then
    Result := DisplayText;
end;

function TfpgSuggestionItem.GetSortText: String;
begin
  Result := FSortText;
  if Result = '' then Result := GetFilterText;
end;

procedure TfpgSuggestionItem.SetDisplayText(AValue: String);
begin
  FDisplayText:=AValue;
end;

procedure TfpgSuggestionItem.SetFilterText(AValue: String);
begin
  FFilterText:=AValue;
end;

procedure TfpgSuggestionItem.SetSortText(AValue: String);
begin
  FSortText:=AValue;
end;

function TfpgSuggestionAdapterGeneric.NewItem: T;
begin
  Result := T.Create;
end;

function TfpgSuggestionAdapterGeneric.DoGetCount: Integer;
begin
  Result := FFilteredList.Count;
end;

function TfpgSuggestionAdapterGeneric.DoGetItem(AIndex: Integer): TObject;
begin
  Result := FFilteredList[AIndex];
end;

function TfpgSuggestionAdapterGeneric.DoGetDisplayText(AItem: TObject): string;
begin
  Result := TfpgSuggestionItem(AItem).DisplayText;
end;

function TfpgSuggestionAdapterGeneric.DoGetDetailText(AItem: TObject): string;
begin
  Result := TfpgSuggestionItem(AItem).DetailText;
end;

function TfpgSuggestionAdapterGeneric.DoGetFilterText(AItem: TObject): string;
begin
  Result := TfpgSuggestionItem(AItem).FilterText;
end;

function TfpgSuggestionAdapterGeneric.DoGetSortText(AItem: TObject): string;
begin
  Result := TfpgSuggestionItem(AItem).SortText;
  if Result = '' then
    Result := DoGetDisplayText(AItem);
end;

function TfpgSuggestionAdapterGeneric.DoGetDocumentationText(AItem: TObject): string;
begin
  Result := TfpgSuggestionItem(AItem).Documentation;
end;

function TfpgSuggestionAdapterGeneric.DoGetItemHint(AItem: TObject): string;
begin
  Result := TfpgSuggestionItem(AItem).ItemHint;
end;

function TfpgSuggestionAdapterGeneric.DoGetItemImageIndex(AItem: TObject): Integer;
begin
  Result := TfpgSuggestionItem(AItem).ImageIndex;
end;

function TfpgSuggestionAdapterGeneric.DoGetItemData(AItem: TObject): Pointer;
begin
  Result := TfpgSuggestionItem(AItem).ItemData;
end;

function TfpgSuggestionAdapterGeneric.DoItemMatches(AItem: TObject; const AFilter: string): Boolean;
begin
  Result := Pos(AFilter, TfpgSuggestionItem(AItem).FilterText) > 0;
end;

procedure TfpgSuggestionAdapterGeneric.DoSwapFilteredItems(AItem1Index,
  AItem2Index: Integer);
var
  Tmp: T;
begin
  Tmp := FFilteredList[AItem1Index];
  FFilteredList[AItem1Index] := FFilteredList[AItem2Index];
  FFilteredList[AItem2Index] := Tmp;
end;

function TfpgSuggestionAdapterGeneric.DoHasDetails(AItem: TObject): Boolean;
begin
  Result := TfpgSuggestionItem(AItem).DetailText <> '';
end;

function TfpgSuggestionAdapterGeneric.CastItem(AItem: TObject): T;
begin
  Result := AItem as T;
end;

function TfpgSuggestionAdapterGeneric.GetTypedItem(AIndex: Integer): T;
begin
  Result := T(FList.Items[AIndex]);
end;

constructor TfpgSuggestionAdapterGeneric.Create;
begin
  inherited Create;
  FList:=TItemList.Create(True);
  FFilteredList:=TItemList.Create(False);
end;

destructor TfpgSuggestionAdapterGeneric.Destroy;
begin
  FList.Free;
  FFilteredList.Free;
  inherited Destroy;
end;

{ TfpgSuggestionStringsAdapter }

procedure TfpgSuggestionStringsAdapter.SetStrings(AValue: TStrings);
begin
  if FStrings=AValue then Exit;
  FStrings:=AValue;
  UpdateCache;
end;

procedure TfpgSuggestionStringsAdapter.UpdateCache;
var
  lItem : TfpgSuggestionStringItem;
  i, FLongestLine: Integer;
  lNoCase: Boolean;
  lStr, lFilter: String;
begin
  try
    BeginUpdate;
    FFilteredList.Clear;
    FLongestLine:=0;
    if not Assigned(FStrings) then
      Exit;

    FFilteredList.Capacity:=FStrings.Count;

    lNoCase := Assigned(FOwnerBox) and (sboCaseInsensitive in FOwnerBox.Options);
    case lNoCase of
      True : lFilter := Lowercase(Filter);
      False: lFilter := Filter;
    end;

    for i := 0 to FStrings.Count-1 do
    begin
      case lNoCase of
        True : lStr := Lowercase(FStrings[i]);
        False: lStr := FStrings[i];
      end;
      if (Filter = '') or (Pos(lFilter, lStr) > 0) then
      begin
        lItem := NewItem;
        lItem.DisplayText:=FStrings[i];
        lItem.Obj := FStrings.Objects[i];
        if Length(lItem.DisplayText) > FLongestLine then
          FLongestLine:=Length(lItem.DisplayText);
        FFilteredList.Add(lItem);
      end;
    end;
  finally
    EndUpdate;
  end;
end;

procedure TfpgSuggestionStringsAdapter.FPOObservedChanged(ASender: TObject;
  Operation: TFPObservedOperation; Data: Pointer);
begin
  if Operation = ooFree then
    FStrings := nil;
  UpdateCache;
end;

procedure TfpgSuggestionStringsAdapter.SetFilter(AValue: String);
begin
  BeginUpdate;
    inherited SetFilter(AValue);
    UpdateCache;
    SortFilteredItems;
  EndUpdate;
end;

{ TfpgSuggestionStringsRenderer }

function TfpgSuggestionStringsRenderer.GetAdapter: TfpgSuggestionAdapterBase;
begin
  Result := nil;
  if Assigned(FSuggestionBox) then
    Result := FSuggestionBox.Adapter;
end;

function TfpgSuggestionStringsRenderer.GetItemString(AItem: TObject): string;
begin
  Result := GetAdapter.DoGetDisplayText(AItem);
end;

function TfpgSuggestionStringsRenderer.GetItemDetail(AItem: TObject): string;
begin
end;

function TfpgSuggestionStringsRenderer.GetItemObject(AItem: TObject): TObject;
begin
end;

function TfpgSuggestionStringsRenderer.BuildRowStates(
  ASuggestionBox: TfpgSuggestionBox; AItem: TObject; AIndex: Integer
  ): TfpgSuggestionItemStates;
begin

end;

function TfpgSuggestionStringsRenderer.MeasureStringWidth(ACanvas: TfpgCanvas;
  const AText: string): Integer;
begin

end;

function TfpgSuggestionStringsRenderer.MeasureDetailWidth(ACanvas: TfpgCanvas;
  const AText: string): Integer;
begin

end;

procedure TfpgSuggestionStringsRenderer.InitDefaultMetrics;
begin

end;

procedure TfpgSuggestionStringsRenderer.UpdateMetrics(
  ASuggestionBox: TfpgSuggestionBox);
begin

end;

procedure TfpgSuggestionStringsRenderer.PaintRowBackground(
  ASuggestionBox: TfpgSuggestionBox; ACanvas: TfpgCanvas;
  const ARowRect: TfpgRect; AStates: TfpgSuggestionItemStates);
begin

end;

procedure TfpgSuggestionStringsRenderer.PaintRowText(
  ASuggestionBox: TfpgSuggestionBox; ACanvas: TfpgCanvas;
  const ATextRect: TfpgRect; const AText: string;
  AStates: TfpgSuggestionItemStates);
begin

end;

procedure TfpgSuggestionStringsRenderer.PaintRowDetail(
  ASuggestionBox: TfpgSuggestionBox; ACanvas: TfpgCanvas;
  const ADetailRect: TfpgRect; const ADetail: string;
  AStates: TfpgSuggestionItemStates);
begin

end;

procedure TfpgSuggestionStringsRenderer.PaintRowIcon(
  ASuggestionBox: TfpgSuggestionBox; ACanvas: TfpgCanvas;
  const AIconRect: TfpgRect; AItem: TObject; AStates: TfpgSuggestionItemStates);
begin

end;

constructor TfpgSuggestionStringsRenderer.Create;
begin
  Inherited Create;
end;

procedure TfpgSuggestionStringsRenderer.RendererAttached(
  ASuggestionBox: TfpgSuggestionBox);
begin
  FSuggestionBox := ASuggestionBox;
end;

procedure TfpgSuggestionStringsRenderer.RendererDetached(
  ASuggestionBox: TfpgSuggestionBox);
begin
  FSuggestionBox := nil;
end;

function TfpgSuggestionStringsRenderer.GetOptions: TfpgSuggestionRendererOptions;
begin
  Result := [];
end;

function TfpgSuggestionStringsRenderer.SupportsDetailsWindow: Boolean;
begin
  Result := False;
end;

function TfpgSuggestionStringsRenderer.UsesVariableRowHeight: Boolean;
begin
  Result := False;
end;

function TfpgSuggestionStringsRenderer.GetMetrics(
  ASuggestionBox: TfpgSuggestionBox): TfpgSuggestionRendererMetrics;
begin
  Result := Default(TfpgSuggestionRendererMetrics);
  with Result do
  begin
    RowHeight := MeasureDefaultRowHeight(ASuggestionBox)
    {IconSize := 0;
    TextLeft := 0;
    TextTop := 0;
    DetailGap := 0;
    RowPaddingLeft := 0
    RowPaddingTop: Integer;
    RowPaddingRight: Integer;
    RowPaddingBottom: Integer;
    BorderSize: Integer;}
  end;
end;

function TfpgSuggestionStringsRenderer.MeasureDefaultRowHeight(
  ASuggestionBox: TfpgSuggestionBox): Integer;
var
  lFont: TfpgFontResourceBase;

begin
  lFont := ASuggestionBox.Canvas.Font;
  Result := ASuggestionBox.Canvas.Font.GetHeight + 2;
end;

function TfpgSuggestionStringsRenderer.MeasureRowHeight(
  ASuggestionBox: TfpgSuggestionBox; AItem: TObject): Integer;
begin
  Result := ASuggestionBox.Canvas.Font.GetHeight + 2;

end;

function TfpgSuggestionStringsRenderer.MeasureRowWidth(
  ASuggestionBox: TfpgSuggestionBox; AItem: TObject): Integer;
var
  lStr: String;
begin
  lStr := FSuggestionBox.Adapter.GetDisplayText(AItem);
  Result := ASuggestionBox.Canvas.Font.GetTextWidth(lStr);
end;

function TfpgSuggestionStringsRenderer.MeasureContentWidth(
  ASuggestionBox: TfpgSuggestionBox; AMaxItems: Integer): Integer;
var
  lMax, lLongestLine, i: Integer;
  lLength: SizeInt;
begin
  Result := ASuggestionBox.Canvas.Font.GetTextWidth('Supercalifragilisticexpialidocious');

  exit;

  lLongestLine := 0;

  lMax := AMaxItems;
  if lMax = -1 then lMax := FSuggestionBox.GetItemCount;

  for i := 0 to lMax -1 do
  begin
    lLength := Length(FSuggestionBox.Adapter.DoGetDisplayText(FSuggestionBox.Adapter.GetItem(i)));
    if lLength > lLongestLine then
      lLongestLine:=lLength;
  end;

  Result := ASuggestionBox.Canvas.Font.GetTextWidth('W') * lLongestLine;

  if Result < 50 then
    Result := 50;
end;

function TfpgSuggestionStringsRenderer.MeasureDetailsWidth(
  ASuggestionBox: TfpgSuggestionBox; AItem: TObject): Integer;
begin
  Result := 0
end;

function TfpgSuggestionStringsRenderer.MeasureDetailsHeight(ASuggestionBox: TfpgSuggestionBox; AItem: TObject; AWidth: Integer): Integer;
begin
  Result := 0;
end;

procedure TfpgSuggestionStringsRenderer.LayoutRow(
  ASuggestionBox: TfpgSuggestionBox; AItem: TObject; const ARowRect: TfpgRect;
  AStates: TfpgSuggestionItemStates; out ALayout: TfpgSuggestionRowLayout);
begin
end;

procedure TfpgSuggestionStringsRenderer.LayoutDetails(
  ASuggestionBox: TfpgSuggestionBox; AItem: TObject; const ABounds: TfpgRect;
  out ALayout: TfpgSuggestionDetailsLayout);
begin

end;

function TfpgSuggestionStringsRenderer.GetPreferredDetailsPlacement(
  ASuggestionBox: TfpgSuggestionBox; AItem: TObject
  ): TfpgSuggestionDetailsPlacement;
begin

end;

function TfpgSuggestionStringsRenderer.ItemAtPos(
  ASuggestionBox: TfpgSuggestionBox; X, Y: Integer): Integer;
begin

end;

function TfpgSuggestionStringsRenderer.ItemPartAtPos(
  ASuggestionBox: TfpgSuggestionBox; AItem: TObject; X, Y: Integer
  ): TfpgSuggestionRenderElement;
begin

end;

procedure TfpgSuggestionStringsRenderer.PaintBackground(
  ASuggestionBox: TfpgSuggestionBox; ACanvas: TfpgCanvas; const ARect: TfpgRect);
begin
  //ACan
  ACanvas.Color:=FSuggestionBox.BackgroundColor;
  ACanvas.FillRectangle(ARect);
end;

procedure TfpgSuggestionStringsRenderer.PaintRow(
  ASuggestionBox: TfpgSuggestionBox; ACanvas: TfpgCanvas; AItem: TObject;
  AIndex: Integer; const ARowRect: TfpgRect; AStates: TfpgSuggestionItemStates);
var
  lText, lDraw, lDesc: String;
  style: TfpgStyle;
  lPos: Integer = 0;
  lLen: SizeInt = 0;
  lWidth: Integer = 0;
  lRect : TfpgRect;
  lOriginal: TfpgFontResourceBase;
  lBoldFont: TfpgFontResourceBase;
begin
  lRect := ARowRect;
  style := fpgStyleManager.Style;

  if sisSelected in AStates then
  begin
    ACanvas.Color:=clSelection;
    ACanvas.FillRectangle(ARowRect);
    ACanvas.SetTextColor(clSelectionText);
  end
  else
  begin
    ACanvas.Color:=FSuggestionBox.BackgroundColor;
    ACanvas.SetTextColor(clText1);
  end;


  lText := GetAdapter.DoGetDisplayText(AItem);

  if GetAdapter.Filter <> '' then
  begin
    lPos := Pos(lowercase(GetAdapter.Filter), lowercase(lText));
    if lPos > 0 then
      lLen := Length(GetAdapter.Filter);
  end;

  if lPos > 0 then
  begin
    // before our filter match
    lDraw := Copy(lText, 1, lPos-1);
    if lDraw <> '' then
    begin
      lWidth := ACanvas.Font.GetTextWidth (lDraw);
      ACanvas.DrawText(lRect, lDraw, [txtLeft, txtVCenter]);
      lRect.Left:=lRect.Left+lWidth;
      lRect.Width:=lRect.Width-lWidth;
    end;

    // our filter match
    lDraw := Copy(lText, lPos, lLen);
    if lDraw <> '' then
    begin
      lDesc := ACanvas.Font.FontDesc;
      lOriginal := fpgApplication.FontManager.GetFont(lDesc);
      lBoldFont := fpgApplication.FontManager.GetFont(lDesc+':bold');
      ACanvas.SetFont(lBoldFont);
      lWidth := ACanvas.Font.GetTextWidth (lDraw);
      ACanvas.DrawText(lRect, lDraw, [txtLeft, txtVCenter]);
      lRect.Left:=lRect.Left+lWidth;
      lRect.Width:=lRect.Width-lWidth;
      ACanvas.SetFont(lOriginal);
    end;
  end;

  // all remaining text
  lDraw := Copy(lText, lPos+lLen, MaxInt);
  ACanvas.DrawText(lRect, lDraw, [txtLeft, txtVCenter]);

end;

procedure TfpgSuggestionStringsRenderer.PaintItemSelection(
  ASuggestionBox: TfpgSuggestionBox; ACanvas: TfpgCanvas;
  const ARowRect: TfpgRect; AStates: TfpgSuggestionItemStates);
begin
  //PaintRow(ASuggestionBox, ACanvas, Selected);

end;

procedure TfpgSuggestionStringsRenderer.PaintDetails(
  ASuggestionBox: TfpgSuggestionBox; ACanvas: TfpgCanvas; AItem: TObject;
  const ARect: TfpgRect);
begin
end;

procedure TfpgSuggestionStringsRenderer.PaintBorder(
  ASuggestionBox: TfpgSuggestionBox; ACanvas: TfpgCanvas; const ARect: TfpgRect);
begin

end;

function TfpgSuggestionStringsRenderer.GetItemText(
  ASuggestionBox: TfpgSuggestionBox; AItem: TObject;
  AKind: TfpgSuggestionTextKind): string;
begin
  if AKind = stkDisplay then
    Result := FSuggestionBox.Adapter.GetDisplayText(AItem)
  else
    Result := '';
end;

function TfpgSuggestionStringsRenderer.GetItemTextWidth(
  ASuggestionBox: TfpgSuggestionBox; ACanvas: TfpgCanvas; AItem: TObject;
  AKind: TfpgSuggestionTextKind): Integer;
begin
  if AKind = stkDisplay then
    Result := ASuggestionBox.Canvas.Font.GetTextWidth(GetItemText(ASuggestionBox, AItem, AKind))
  else
    Result := 0;
end;

function TfpgSuggestionStringsRenderer.GetItemHint(
  ASuggestionBox: TfpgSuggestionBox; AItem: TObject): string;
begin
  Result := '';
end;

function TfpgSuggestionStringsRenderer.NeedsFullRepaintOnSelectionChange: Boolean;
begin
  Result := True;
end;

function TfpgSuggestionStringsRenderer.NeedsLayoutOnDataChange: Boolean;
begin
  Result := False;
end;

end.

diff --git a/ide/src/main/pascal/fpg_textedit.pas b/ide/src/main/pascal/fpg_textedit.pas
index 5c9aec36..d777a531 100644
--- a/ide/src/main/pascal/fpg_textedit.pas
+++ b/ide/src/main/pascal/fpg_textedit.pas
@@ -254,8 +254,10 @@   TfpgBaseTextEdit = class(TfpgWidget)
     destructor  Destroy; override;
     procedure   UpdateScrollBars;
     function    GetClientRect: TfpgRect; override;
-    function    GetWordAtPos(const X, Y: Integer; out XBegin: Integer): TfpgString;
+    function    GetWordAtPos(const X, Y: Integer; out XBegin: Integer; ASearchIfNotInWord: Boolean = True): TfpgString;
     procedure   GetRowColAtPos(const X, Y: Integer; out Row, Col: Integer);
+    procedure   SetSelectedRange(const AStart: TfpgPoint; const AEnd: TfpgPoint);
+    function    TextPosToPixelPos(const X, Y: Integer): TfpgPoint;
     procedure   Clear;
     procedure   InsertTextAtPos(S: TfpgString; Col, Row: Integer);
     procedure   ScrollTo(X, Y: Integer);
@@ -335,6 +337,8 @@   TfpgTextEdit = class(TfpgBaseTextEdit)
     property    OnSearchEnd;
     property    OnReplaceText;
     property    OnCtrlClick;
+    property    OnKeyPress;
+    property    OnKeyChar;
   end;
 
 
@@ -2316,7 +2320,9 @@ procedure TfpgBaseTextEdit.HandleKeyPress(var keycode: word; var shiftstate: TSh
   end;
 
   if not consumed then
-    inherited HandleKeyPress(keycode, shiftstate, consumed);
+    inherited HandleKeyPress(keycode, shiftstate, consumed)
+  else if Assigned(OnKeyPress) then
+    OnKeyPress(Self, keycode, shiftstate, consumed);
 
   if consumed then
     Invalidate;
@@ -2373,7 +2379,11 @@ procedure TfpgBaseTextEdit.HandleKeyChar(var AText: TfpgChar; var shiftstate: TS
   end;
 
   if consumed then
-    Repaint
+  begin
+    Repaint;
+    if Assigned(OnKeyChar) then
+      OnKeyChar(Self, AText, consumed);
+  end
   else
     inherited HandleKeyChar(AText, shiftstate, consumed);
   CheckCaretChanged;
@@ -2387,6 +2397,15 @@ function TfpgBaseTextEdit.GetDefaultDropHandler: TfpgDropHandler;
   Result := FDefaultDropHandler;
 end;
 
+function TfpgBaseTextEdit.TextPosToPixelPos(const X, Y: Integer): TfpgPoint;
+begin
+  Result.Y := ((Y - FTopLine) * FChrH) + 1;
+  Result.X := ((X - HPos) * FChrW) + GetClientRect.Left;
+
+  if FGutterPan.Visible then
+    Result.X := Result.X + FGutterPan.Width;
+end;
+
 procedure TfpgBaseTextEdit.DrawVisible;
 var
   I, Y, cntVis: Integer;
@@ -2776,7 +2795,8 @@ function TfpgBaseTextEdit.GetClientRect: TfpgRect;
     Result.Height := Result.Height - FHScrollBar.Height;
 end;
 
-function TfpgBaseTextEdit.GetWordAtPos(const X, Y: Integer; out XBegin: Integer): TfpgString;
+function TfpgBaseTextEdit.GetWordAtPos(const X, Y: Integer; out
+  XBegin: Integer; ASearchIfNotInWord: Boolean): TfpgString;
 { todo: This needs to be made UTF8 compliant! It currently is not. }
 const
   ValidChars = ['a'..'z', 'A'..'Z', '0'..'9', '#'];
@@ -2796,7 +2816,7 @@ function TfpgBaseTextEdit.GetWordAtPos(const X, Y: Integer; out XBegin: Integer)
   if S = '' then Exit;  //==>
   if lX > UTF8Length(S) - 1 then
     lX := UTF8Length(S) - 1;
-  if not (S[lX + 1] in ValidChars) then
+  if not (S[lX + 1] in ValidChars) and (ASearchIfNotInWord) then
   begin
     CrX := lX - 1;
     for I := CrX downto 1 do
@@ -2855,6 +2875,17 @@ procedure TfpgBaseTextEdit.GetRowColAtPos(const X, Y: Integer; out Row, Col: Int
     Col := Col + 1;
 end;
 
+procedure TfpgBaseTextEdit.SetSelectedRange(const AStart: TfpgPoint;
+  const AEnd: TfpgPoint);
+begin
+  FSelected:=AStart<>AEnd;
+  if FSelected then
+  begin
+    FSelection.SetStartPos(AStart);
+    FSelection.SetEndPos(AEnd);
+  end;
+end;
+
 procedure TfpgBaseTextEdit.Clear;
 begin
   CaretPos.x := 0;
diff --git a/ide/src/main/pascal/ide.form.main.pas b/ide/src/main/pascal/ide.form.main.pas
index 4f436f41..179346c3 100644
--- a/ide/src/main/pascal/ide.form.main.pas
+++ b/ide/src/main/pascal/ide.form.main.pas
@@ -27,6 +27,7 @@ interface
   fpg_button, fpg_splitter, fpg_tab, fpg_memo, fpg_label, fpg_grid,
   fpg_tree, fpg_textedit, fpg_imagelist, fpg_mru,
   fpg_miglayout, fpg_mig_lc, fpg_mig_cc,
+  fpg_suggestionbox,
   ide.filemonitor, ide.highlighter, ide.editor.theme, ide.bracketmatch,
   ide.highlight.renderer, ide.build.dispatch, ide.projecttree,
   ide.editor.tabs, ide.profiles, ide.project.pasbuild,
@@ -36,7 +37,7 @@ interface
 
 type
 
-  TMainForm = class(TfpgForm)
+ TMainForm = class(TfpgForm)
   private
     {@VFD_HEAD_BEGIN: MainForm}
     mainmenu: TfpgMenuBar;
@@ -98,6 +99,17 @@   TMainForm = class(TfpgForm)
     FLastFindBackward: Boolean;
     FLastFileDir: TfpgString;
     FQuickDocHint: TQuickDocHintWindow;
+    FSuggestionBox: TfpgSuggestionBox;
+    { suggestion related event handlers }
+    procedure   HandleSuggestionAccepted(Sender: TObject; AItem: TObject; AKey: TfpgSuggestionAcceptKey; ACommitMode: TfpgSuggestionCommitMode);
+    procedure   HandleSuggestionChar(var AChar: TfpgChar; var AShiftState: TShiftState; var AHandled: Boolean);
+    function    HandleSuggestionCompletionChar(AChar: TfpgChar; AShiftState: TShiftState): TfpgSuggestionAcceptKeys;
+    procedure   HandleSuggestionContextValid(Sender: TObject; const AContext: TfpgSuggestionContext; var AIsValid: Boolean);
+    procedure   HandleSuggestionKeyPress(var AKeyCode: Word; var AShiftState: TShiftState; var AHandled: Boolean);
+    procedure   HandleSuggestionUpdateContext(Sender: TObject; const AContext: TfpgSuggestionContext; out AInfo: TfpgSuggestionWordInfo);
+    procedure   TextEditChar(Sender: TObject; AChar: TfpgChar; var Consumed: boolean);
+    procedure   TextEditKeyPress(Sender: TObject; var KeyCode: word; var ShiftState: TShiftState; var Consumed: boolean);
+
     procedure   MonitoredFileChanged(Sender: TObject; AData: TFileMonitorEventData);
     procedure   FormShow(Sender: TObject);
     procedure   FormClose(Sender: TObject; var CloseAction: TCloseAction);
@@ -190,6 +202,8 @@   TMainForm = class(TfpgForm)
     procedure   HighlightPatch(Sender: TObject; ALineText: TfpgString; ALineIndex: Integer; ACanvas: TfpgCanvas; ATextRect: TfpgRect; var AllowSelfDraw: Boolean);
     procedure   LoadThemeByName(const AName: string);
     procedure   SetupEditorPreference;
+    procedure   ConnectEditEvents(edt: TfpgTextEdit);
+    procedure   ConnectSuggestionEvents;
     procedure   miJumpToInterface(Sender: TObject);
     procedure   miJumpToImplementation(Sender: TObject);
     procedure   miJumpToggleIntfImpl(Sender: TObject);
@@ -208,6 +222,7 @@   TMainForm = class(TfpgForm)
     procedure   uiCreateStatusBar;
     procedure   uiCreateClientArea;
     procedure   uiCreateMenus;
+    procedure   ShowSuggestionBox(AEdit: TfpgTextEdit; ATrigger: TfpgSuggestionTriggerKind);
   protected
     procedure   HandleKeyPress(var keycode: word; var shiftstate: TShiftState; var consumed: boolean); override;
   public
@@ -882,7 +897,7 @@ procedure TMainForm.AddUnitToProject(const AUnitName: TfpgString);
   u: TUnit;
   s: TfpgString;
   r: TfpgTreeNode;
-  n: TfpgTreeNode;
+  n: TfpgTreeNode = nil; // Hey this isn't initialized
 begin
   u := GProject.UnitList.AddFilename(AUnitName);
   if Assigned(n) then
@@ -911,6 +926,22 @@ procedure TMainForm.miProjectAddUnitToProject(Sender: TObject);
   AddUnitToProject(s);
 end;
 
+procedure TMainForm.TextEditChar(Sender: TObject; AChar: TfpgChar; var Consumed: boolean);
+begin
+  if AChar = '.' then
+  begin
+    // maybe delay a moment?
+    ShowSuggestionBox(TfpgTextEdit(Sender), stkTyping);
+  end;
+end;
+
+procedure TMainForm.TextEditKeyPress(Sender: TObject; var KeyCode: word;
+  var ShiftState: TShiftState; var Consumed: boolean);
+begin
+  if (KeyCode = keySpace) and (ssCtrl in ShiftState) then
+    ShowSuggestionBox(TfpgTextEdit(Sender), stkManual);
+end;
+
 procedure TMainForm.tvProjectDoubleClick(Sender: TObject; AButton: TMouseButton; AShift: TShiftState; const AMousePos: TPoint);
 var
   n: TfpgTreeNode;
@@ -1198,6 +1229,7 @@ procedure TMainForm.EditorTabChanged(Sender: TObject; ATabSheet: TfpgTabSheet);
   if Assigned(ATabSheet) and (ATabSheet.ComponentCount > 0) then
   begin
     edt := ATabSheet.Components[0] as TfpgTextEdit;
+    ConnectSuggestionEvents;
     FHighlightCache.EnsurePascalTokenised(edt, edt.Lines);
     UpdateStatus(ATabSheet.Hint);
     UpdateCursorPos(edt.CaretPos_V, edt.CaretPos_H);
@@ -1652,6 +1684,8 @@ function TMainForm.CreateNewEditorTab(const ATitle: TfpgString): TfpgTabSheet;
 begin
   Result := pcEditor.AppendTabSheet(ATitle);
   m := TfpgTextEdit.Create(Result);
+  ConnectEditEvents(m);
+  ConnectSuggestionEvents;
   m.Left := 1;
   m.Top := 1;
   m.Width := pcEditor.ActualWidth;
@@ -2660,11 +2694,123 @@ procedure TMainForm.SetupEditorPreference;
   end;
 end;
 
+procedure TMainForm.ConnectEditEvents(edt: TfpgTextEdit);
+begin
+  edt.OnKeyPress := @TextEditKeyPress;
+  edt.OnKeyChar  := @TextEditChar;
+end;
+
+procedure TMainForm.ConnectSuggestionEvents;
+begin
+  FSuggestionBox.OnForwardKeyPress:=@HandleSuggestionKeyPress;
+  FSuggestionBox.OnForwardChar:=@HandleSuggestionChar;
+  FSuggestionBox.OnCheckCompletionChar:=@HandleSuggestionCompletionChar;
+  FSuggestionBox.OnAccepted:=@HandleSuggestionAccepted;
+  FSuggestionBox.OnContextUpdate:=@HandleSuggestionUpdateContext;
+  FSuggestionBox.OnContextValid:=@HandleSuggestionContextValid;
+end;
+
 procedure TMainForm.MonitoredFileChanged(Sender: TObject; AData: TFileMonitorEventData);
 begin
   OpenEditorPage(AData.FileName);
 end;
 
+type
+ TProtected = class(TfpgTextEdit);
+
+procedure TMainForm.HandleSuggestionKeyPress(var AKeyCode: Word;
+  var AShiftState: TShiftState; var AHandled: Boolean);
+var
+  edt: TfpgTextEdit;
+begin
+  edt := pcEditor.ActivePage.Components[0] as TfpgTextEdit;
+  TProtected(edt).HandleKeyPress(AKeyCode, AShiftState, AHandled);
+end;
+
+procedure TMainForm.HandleSuggestionUpdateContext(Sender: TObject;
+  const AContext: TfpgSuggestionContext; out AInfo: TfpgSuggestionWordInfo);
+var
+  edt: TfpgTextEdit;
+  lBegin: Integer;
+begin
+  edt := pcEditor.ActivePage.Components[0] as TfpgTextEdit;
+  AInfo.Text := edt.GetWordAtPos(edt.CaretPos_H, edt.CaretPos_V, lBegin, False);
+  AInfo.Text:=Copy(AInfo.Text, 1, edt.CaretPos_H-lBegin);
+  AInfo.CaretPosition := fpgPoint(edt.CaretPos_H-1, edt.CaretPos_V);
+  AInfo.CaretPixelPosition := edt.TextPosToPixelPos(edt.CaretPos_H, edt.CaretPos_V);
+end;
+
+procedure TMainForm.HandleSuggestionChar(var AChar: TfpgChar;
+  var AShiftState: TShiftState; var AHandled: Boolean);
+var
+  edt: TfpgTextEdit;
+begin
+  edt := pcEditor.ActivePage.Components[0] as TfpgTextEdit;
+  TProtected(edt).HandleKeyChar(AChar, AShiftState, AHandled);
+end;
+
+procedure TMainForm.HandleSuggestionAccepted(Sender: TObject; AItem: TObject;
+  AKey: TfpgSuggestionAcceptKey; ACommitMode: TfpgSuggestionCommitMode);
+var
+  lWord: TfpgString;
+  lStart, lBegin: Integer;
+  lEnd: SizeInt;
+  edt: TfpgTextEdit;
+begin
+  edt := pcEditor.ActivePage.Components[0] as TfpgTextEdit;
+  lStart := FSuggestionBox.Context.StartX+1;
+  case ACommitMode of
+    scmInsert: lEnd := edt.CaretPos_H;
+    scmReplace:
+      begin
+        lWord := edt.GetWordAtPos(edt.CaretPos_H, edt.CaretPos_V, lBegin);
+        lEnd := lStart+ Length(lWord);
+      end;
+  end;
+  edt.SetSelectedRange(fpgPoint(lStart, edt.CaretPos_v), fpgPoint(lEnd, edt.CaretPos_V));
+  edt.DeleteSelection;
+  edt.InsertTextAtPos(FSuggestionBox.Adapter.GetDisplayText(FSuggestionBox.SelectedItem),
+    lStart, edt.CaretPos_V);
+  edt.SetSelectedRange(fpgPoint(lEnd, edt.CaretPos_V), fpgPoint(lEnd, edt.CaretPos_V));
+end;
+
+function TMainForm.HandleSuggestionCompletionChar(AChar: TfpgChar;
+  AShiftState: TShiftState): TfpgSuggestionAcceptKeys;
+var
+  lChar: Char;
+begin
+  // this one responds to regular symbo keys. do completion?
+  Result := [];
+  if Length(AChar) = 1 then
+  begin
+    lChar := AChar[1];
+    // this is too basic. We need something like IfNotText(AChar) then...
+    if not (lChar in ['A'..'Z', 'a'..'z', '0'..'9', '_'])
+       and (lChar <> char(keyBackSpace))
+       and (lChar <> char(keyDelete))
+    then
+      Result := [sakReturn]; // return key
+  end;
+end;
+
+procedure TMainForm.HandleSuggestionContextValid(Sender: TObject;
+  const AContext: TfpgSuggestionContext; var AIsValid: Boolean);
+var
+  edt: TfpgTextEdit;
+  lBegin: Integer;
+  lWord: TfpgString;
+begin
+  edt := pcEditor.ActivePage.Components[0] as TfpgTextEdit;
+  lWord := edt.GetWordAtPos(edt.CaretPos_H, edt.CaretPos_V, lBegin, False);
+  if lBegin < 0 then
+    lBegin:=0;
+
+  AIsValid:=((lBegin-1 = AContext.StartX) or (edt.CaretPos_H-1>=AContext.StartX))
+    and (edt.CaretPos_V = AContext.StartY-1) // -1 because we displayed a row below
+    and ((edt.CaretPos_H <= lBegin + Length(lWord)) or (Length(lWord)= 0));
+
+end;
+
 procedure TMainForm.FormShow(Sender: TObject);
 var
   lErrPos: integer;
@@ -2727,6 +2873,17 @@ constructor TMainForm.Create(AOwner: TComponent);
     CreateImage_BMP(@cCheckboxChecked, SizeOf(cCheckboxChecked)), 1);
   FProfileStateImages.Items[1].Image.CreateMaskFromSample(0, 0);
   FProfileStateImages.Items[1].Image.UpdateImage;
+  FSuggestionBox := TfpgSuggestionBox.Create(Self);
+  FSuggestionBox.Adapter := TfpgSuggestionStringsAdapter.Create;
+  FSuggestionBox.Renderer := TfpgSuggestionStringsRenderer.Create;
+  TfpgSuggestionStringsAdapter(FSuggestionBox.Adapter).Strings := TStringList.Create;
+  TfpgSuggestionStringsAdapter(FSuggestionBox.Adapter).OwnsStrings:=True;
+  with TfpgSuggestionStringsAdapter(FSuggestionBox.Adapter).Strings do
+  begin
+    Add('TComponent');
+    Add('begin');
+    Add('end');
+  end;
 end;
 
 destructor TMainForm.Destroy;
@@ -3086,6 +3243,9 @@ procedure TMainForm.uiCreateClientArea;
   lm.AddLayoutComponent(pcEditor, TfpgMigCC.Create.GrowX.GrowY.Push.Wrap);
   lm.AddLayoutComponent(SplitterH, TfpgMigCC.Create.GrowX.Height('3lp!').Wrap);
   lm.AddLayoutComponent(pnlWindow, TfpgMigCC.Create.GrowX.MinHeight('60lp'));
+
+  ConnectEditEvents(TextEditor);
+  ConnectSuggestionEvents;
 end;
 
 procedure TMainForm.uiCreateMenus;
@@ -3249,6 +3409,35 @@ procedure TMainForm.uiCreateMenus;
   FRecentFiles.LoadMRU;
 end;
 
+procedure TMainForm.ShowSuggestionBox(AEdit: TfpgTextEdit; ATrigger: TfpgSuggestionTriggerKind);
+var
+  lContext: TfpgSuggestionContext;
+  XBegin: Integer;
+  lPixelPos: TfpgPoint;
+begin
+  lContext := Default(TfpgSuggestionContext);
+  lContext.StartY:=AEdit.CaretPos_V+1; // display below
+  case ATrigger of
+    stkManual:
+      begin
+        lContext.Prefix := AEdit.GetWordAtPos(AEdit.CaretPos_H,AEdit.CaretPos_V, XBegin, False);
+        if lContext.Prefix = '' then
+          lContext.StartX:=AEdit.CaretPos_H-1
+        else
+          lContext.StartX:=XBegin-1;
+      end;
+    stkTyping:
+      lContext.StartX:=AEdit.CaretPos_H-1;
+    stkAuto:  ;// delay?
+  end;
+
+  lPixelPos := AEdit.TextPosToPixelPos(lContext.StartX+1, lContext.StartY);
+  lContext.PixelX:=lPixelPos.X;
+  lContext.PixelY:=lPixelPos.Y;
+
+  FSuggestionBox.PopupFor(AEdit, lContext);
+end;
+
 procedure TMainForm.AfterCreate;
 var
   mig: TfpgMigLayoutManager;

0 replies

andrewd207 · 2026-04-15T08:05:40Z

andrewd207
Apr 15, 2026
Author

For extra fun, I added some keywords and TObject stuff to the list of words. Obviously this is incorrect, but for testing it already makes a difference.

  with TfpgSuggestionStringsAdapter(FSuggestionBox.Adapter).Strings do
  begin
    AddStrings([
  'absolute', 'and', 'array', 'asm', 'begin', 'case', 'const',
  'constructor', 'destructor', 'div', 'do', 'downto', 'else',
  'end', 'file', 'for', 'forward', 'function', 'goto', 'if',
  'implementation', 'in', 'inherited', 'inline', 'interface',
  'label', 'mod', 'nil', 'not', 'object', 'of', 'on', 'operator',
  'or', 'packed', 'procedure', 'program', 'record', 'reintroduce',
  'repeat', 'self', 'set', 'shl', 'shr', 'string', 'then', 'to',
  'type', 'unit', 'until', 'uses', 'var', 'while', 'with', 'xor',
  'as', 'class', 'except', 'exports', 'finalization', 'finally',
  'initialization', 'is', 'library', 'property', 'raise', 'threadvar',
  'try', 'dispose', 'exit', 'false', 'true'
]);
    AddStrings([
  'TObject', 'TPersistent', 'TComponent', 'TThread', 'TStream',
  'TMemoryStream', 'TFileStream', 'TStringStream', 'TResourceStream',
  'THandleStream', 'TCustomMemoryStream', 'TCollection', 'TCollectionItem',
  'TList', 'TObjectList', 'TThreadList', 'TBits',
  'TStrings', 'TStringList', 'TParser', 'TComponentList',
  'TComponentClass', 'TComponentFactory', 'TComponentFactoryClass',
  'TReader', 'TWriter', 'TAbstractObjectReader', 'TAbstractObjectWriter',
  'TComponentStreaming', 'TComponentStreamingClass', 'TComponentVolume',
  'TComponentReference', 'TComponentReferenceList',
  'TNotifyEvent', 'TThreadProcedure', 'TThreadEvent',
  'TCollectionNotifyEvent', 'TTextWriter', 'TTextReader',
  'TComponentState', 'TComponentStyle', 'TComponentOptions',
  'TComponentInstantiation', 'TComponentFactoryKind',
  'TObserver', 'IObserver', 'IObservable', 'IInterfaceList'
]);
    AddStrings([
  'Create',
  'Destroy',
  'NewInstance',
  'CleanupInstance',
  'FreeInstance',
  'Free',
  'SafeCallException',
  'DefaultHandler',
  'DefaultHandlerStr',
  'Dispatch',
  'DispatchStr',
  'GetInterface',
  'GetInterfaceRaw',
  'GetInterfaceEntry',
  'GetInterfaceEntryStr',
  'GetInterfaceTable',
  'UnitName',
  'ClassName',
  'ClassNameIs',
  'ClassParent',
  'InstanceSize',
  'InheritsFrom',
  'StringMessageTable',
  'MethodAddress',
  'MethodName',
  'FieldAddress',
  'AfterConstruction',
  'BeforeDestruction',
  'Equals',
  'GetHashCode',
  'ToString'
]);
  end;

0 replies

graemeg · 2026-04-15T10:22:50Z

graemeg
Apr 15, 2026
Maintainer

Hi Andrew,

Sorry for the late reply—it's been a bit crazy around the house. Anyway, that sounds amazing.

The IDE work (along with other fpGUI improvements) is still very much in flux. I have an MVP (Minimum Viable Product) plan for the IDE and have been ticking off items as I go. I never shared it publicly because it was still early days, but if it helps, I've just made it public in my opdf integration branch (ide/docs/ide_mvp_plan.adoc).

Without those MVP topics in place, I don't consider the IDE usable for development yet, though it's definitely getting closer. As I notice things that bug me, I add them to the "Spit & Polish" section. These don't strictly form part of the MVP, so they will be implemented once the core features are in place.

I'm very glad you're interested in contributing! My only concern is that since the IDE isn't at the MVP stage yet, I might break things you depend on for your contributions. But if you’re happy to take that risk, go for it! :-)

Progress Updates

Regarding the features at hand, here is what I’ve done so far (mostly initial concepts):

Quick Documentation (Ctrl+F1): This grabs the code comment preceding the symbol, function, or class. In the future, this will be extended for prettier rendering and a user-resisable window.

Find Usages (Alt+F7) / Navigate to File (Ctrl+Shift+N) / Navigate to Symbol (Ctrl+Shift+O): These share a similar design—a popup with a search area that supports fuzzy search and can be pre-populated with search terms.

I have planned, but not implemented yet, a description window that can accompany the suggestion window to give more details on the current suggestion candidate. (Some HTML widget would be awesome)

Are you referring to something like what Eclipse IDE does, say during refactoring suggestions or completion suggestions? If so, this is definitely something I was considering after the MVP is in place.

TIP: For viewing the AsciiDoc files, I recommend installing Asciidoctor to render a cleaner version of the .adoc files. Alternatively (and better), use the asciidoctor.js plugin (Chrome or Firefox) for a live preview when opening the .adoc files. Then you never have stale versions of the rendered view.

Regards,
Graeme

1 reply

andrewd207 Apr 15, 2026
Author

Yes similar to this Eclipse feature. I don't know how difficult it is to add. I'm just going to chip away at things. The TfpgSuggestionStringsRender can render any Adapter. it just needs to access DisplayText.

graemeg · 2026-04-15T10:23:27Z

graemeg
Apr 15, 2026
Maintainer

I haven't looked at the code you supplied in your second post yet. I'll do so tonight.

0 replies

andrewd207 · 2026-04-19T20:36:27Z

andrewd207
Apr 19, 2026
Author

Also, I've done some work on loading ppu files into objects to lookup symbols via ppudump as json. Thinking to combine that with suggestions within the scope. It's not searchable yet. Just objects that can be loaded automatically using jsonrtti.

I haven't looked much at your code either yet 🤣 I'm curious now to see how your pasrc code works. I've been working on parsing ppudump output and looking up types with it and followed many rabbit holes myself. I think I spent like 4 days fixing bugs. I've created a monster.

2 replies

graemeg Apr 20, 2026
Maintainer

I'll make some time this week, now that I finally got Haiku Vector Image Format (HVIF) out the door. 🎉
Announcement: #182

andrewd207 Apr 20, 2026
Author

Congratulations 🎉 No problem 😃 Very nice work!

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

Code completion suggestions #180

Uh oh!

{{title}}

Uh oh!

Replies: 5 comments 3 replies

Uh oh!

{{title}}

Uh oh!

Uh oh!

{{title}}

Uh oh!

Uh oh!

{{title}}

Uh oh!

Uh oh!

{{editor}}'s edit

{{editor}}'s edit

Uh oh!

Uh oh!

{{title}}

Uh oh!

Uh oh!

{{title}}

Uh oh!

Uh oh!

{{title}}

Uh oh!

Uh oh!

{{title}}

Uh oh!

Uh oh!

{{title}}

Uh oh!

Select a reply

Uh oh!

Uh oh!

Code completion suggestions #180

Uh oh!

andrewd207 Apr 14, 2026

Replies: 5 comments · 3 replies

Uh oh!

andrewd207 Apr 15, 2026 Author

Uh oh!

andrewd207 Apr 15, 2026 Author

Uh oh!

Uh oh!

graemeg Apr 15, 2026 Maintainer

Uh oh!

andrewd207 Apr 15, 2026 Author

Uh oh!

graemeg Apr 15, 2026 Maintainer

Uh oh!

andrewd207 Apr 19, 2026 Author

Uh oh!

graemeg Apr 20, 2026 Maintainer

Uh oh!

andrewd207 Apr 20, 2026 Author

andrewd207
Apr 14, 2026

Replies: 5 comments 3 replies

andrewd207
Apr 15, 2026
Author

andrewd207
Apr 15, 2026
Author

graemeg
Apr 15, 2026
Maintainer

andrewd207 Apr 15, 2026
Author

graemeg
Apr 15, 2026
Maintainer

andrewd207
Apr 19, 2026
Author

graemeg Apr 20, 2026
Maintainer

andrewd207 Apr 20, 2026
Author