GDK.ToolsAPI.Helper.pas

unit GDK.ToolsAPI.Helper;

interface

uses
 ToolsAPI,
 GDK.ToolsAPI.Helper.Interfaces,
 GDK.ToolsAPI.Debugger.Interfaces,
 System.SysUtils,
 GDK.ToolsAPI.CustomMessage;

type
 TToolsApiHelper = class(TInterfacedObject, IToolsApiHelper)
private
 FEditView: IToolsApiEditView;
public
functionLogger: IToolsApiLogger; overload;
functionLogger(const GroupName: string): IToolsApiLogger; overload;

functionProjectGroup: IOTAProjectGroup;

functionProject: IToolsApiProject; overload;
functionProject(const Project: IOTAProject): IToolsApiProject; overload;

functionFindProject(const NameOrPath: string): IToolsApiProject;
procedureSetActiveProject(const Project: IOTAProject);
functionOpenProject(const FileName: string): IToolsApiProject;

functionProjectContextMenu: IToolsApiProjectContextMenu;

functionBuildConfigurations: IToolsApiBuildConfigurations;
functionEnvironmentOptions: IToolsApiEnvironmentOptions;
functionDebugger: IToolsApiDebugger;

functionModuleCount: Integer;
functionModule: IToolsApiModule; overload;
functionModule(constModule: IOTAModule): IToolsApiModule; overload;
functionModule(const Index: Integer): IToolsApiModule; overload;

functionSourceEditor: IToolsApiSourceEditor;
functionEditorReader: IToolsApiEditReader;
functionEditorWriter: IToolsApiEditWriter;

procedureEditorInsertText(const Text: TArray<string>; const Position: TOTAEditPos); overload;
procedureEditorInsertText(const Text: TArray<string>; const AtLine: Integer); overload;

functionEditorPosition: TOTAEditPos;
functionEditorContent: string;

functionEditView: IToolsApiEditView;
end;

 TToolsApiLogger = class(TInterfacedObject, IToolsApiLogger)
private
 FGroupName: string;
public
constructor Create(const GroupName: string);

functionUsesCustomGroup: Boolean;
functionGetGroup: IOTAMessageGroup;

procedureClear;

procedureLog(const Text: string); overload;
procedureLog(const Text: string; const Params: arrayofconst); overload;

functionCustom: TCustomMessage;
end;

 TToolsApiProject = class(TInterfacedObject, IToolsApiProject)
private
 FProject: IOTAProject;
procedureGuard;
public
constructor Create; overload;
constructor Create(const Project: IOTAProject); overload;

functionGet: IOTAProject;

functionProjectConfigurations: IOTAProjectOptionsConfigurations;
functionBuildConfigurations: IToolsApiBuildConfigurations;

functionBuild(const HideProgressDialog: Boolean = False): Boolean;

functionCreateFormUnit(const UnitFileName: string;
const FormName: string;
const AncestorName: string = ''): IOTAModule;
end;

 TToolsApiModule = class(TInterfacedObject, IToolsApiModule)
private
 FModule: IOTAModule;
procedureGuard;
functionReadSourceFromBuffer(out Source: string): Boolean;
public
constructor Create; overload;
constructor Create(constModule: IOTAModule); overload;
constructor Create(const Index: Integer); overload;

functionGet: IOTAModule;
functionFileCount: Integer;
functionFileName: string;
procedureRefresh(const ForceRefresh: Boolean);

functionIsDirty: Boolean;
functionMatchesDisk: Boolean;
procedureSyncWithDisk;

functionEditor(const Predicate: TFunc<IOTAEditor, Boolean>): IOTAEditor;
functionSourceEditor(const Predicate: TFunc<IOTASourceEditor, Boolean> = nil): IToolsApiSourceEditor;
functionFormEditor(const Predicate: TFunc<IOTAFormEditor, Boolean> = nil): IOTAFormEditor;
functionFormDesigner: IToolsApiFormEditor;
end;

 TToolsApiEditView = class(TInterfacedObject, IToolsApiEditView)
private
 FEditorServices: IOTAEditorServices;
public
constructor Create;

functionTopView: IOTAEditView;
functionCursorPosition: TOTAEditPos;

procedureInsertText(const Text: TArray<string>; const Position: TOTAEditPos);
end;

 TToolsApiSourceEditor = class(TInterfacedObject, IToolsApiSourceEditor)
private
 FEditor: IOTASourceEditor;
procedureAddToUses(const UnitNames: TArray<string>; const AddToImplementation: Boolean);
public
constructor Create(const Editor: IOTASourceEditor);

functionGet: IOTASourceEditor;
functionReader: IToolsApiEditReader;
functionWriter: IToolsApiEditWriter;
functionUndoableWriter: IToolsApiEditWriter;

procedureAddToInterfaceUses(const UnitName: string); overload;
procedureAddToInterfaceUses(const UnitNames: TArray<string>); overload;
procedureAddToImplementationUses(const UnitName: string); overload;
procedureAddToImplementationUses(const UnitNames: TArray<string>); overload;
end;

 TToolsApiEditReader = class(TInterfacedObject, IToolsApiEditReader)
private
 FReader: IOTAEditReader;
public
constructor Create(const Reader: IOTAEditReader);

functionGet: IOTAEditReader;
functionContent: string;
end;

 TToolsApiEditWriter = class(TInterfacedObject, IToolsApiEditWriter)
private
 FWriter: IOTAEditWriter;
public
constructor Create(const Writer: IOTAEditWriter);
functionGet: IOTAEditWriter;

procedureInsertText(const Text: string; const Position: Integer); overload;
procedureInsertText(const Text: string; const Position: TOTAEditPos); overload;
end;

 TToolsApiBuildConfigurations = class(TInterfacedObject, IToolsApiBuildConfigurations)
private
 FProject: IOTAProject;
 FConfigurations: IOTAProjectOptionsConfigurations;
public
constructor Create(const Project: IOTAProject);

functionBase: IToolsApiBuildConfiguration;
functionActive: IToolsApiBuildConfiguration;
end;

 TToolsApiEnvironmentOptions = class(TInterfacedObject, IToolsApiEnvironmentOptions)
private
 FOptions: IOTAEnvironmentOptions;
public
constructor Create;

functionGet: IOTAEnvironmentOptions;

functionTryFindOptionName(const OptionName: string; out ExactName: string): Boolean;
functionGetOption(const OptionName: string): Variant;
procedureSetOption(const OptionName: string; constValue: Variant);
end;

 TToolsApiBuildConfiguration = class(TInterfacedObject, IToolsApiBuildConfiguration)
private
 FConfiguration: IOTABuildConfiguration;

functionGetSearchPaths: TArray<string>;
procedureSetSearchPaths(const Paths: TArray<string>);
public
constructor Create(const Configuration: IOTABuildConfiguration);
functionGet: IOTABuildConfiguration;

property SearchPaths: TArray<string> read GetSearchPaths write SetSearchPaths;
end;

implementation

uses
 System.Classes,
 System.IOUtils,
 DCCStrs,
 GDK.ToolsAPI.Debugger,
 GDK.ToolsAPI.FormCreator,
 GDK.ToolsAPI.FormEditor,
 GDK.ToolsAPI.ProjectManagerContextMenu,
 GDK.ToolsAPI.ProjectMatch,
 GDK.ToolsAPI.UsesManager,
 GDK.ToolsAPI.UsesBuilder;

{ TToolsApiHelper }

functionTToolsApiHelper.Project: IToolsApiProject;
begin
 Result := TToolsApiProject.Create;
end;

functionTToolsApiHelper.Project(const Project: IOTAProject): IToolsApiProject;
begin
 Result := TToolsApiProject.Create(Project);
end;

functionTToolsApiHelper.ProjectContextMenu: IToolsApiProjectContextMenu;
begin
 Result := TToolsApiProjectContextMenu.Create;
end;

functionTToolsApiHelper.ProjectGroup: IOTAProjectGroup;
var
 ModuleServices: IOTAModuleServices;
Module: IOTAModule;
 ProjectGroup: IOTAProjectGroup;
 i: Integer;
Begin
 ProjectGroup := nil;

 ModuleServices := (BorlandIDEServices as IOTAModuleServices);
for i := 0to ModuleServices.ModuleCount - 1do
begin
Module := ModuleServices.Modules[i];
if (Module.QueryInterface(IOTAProjectGroup, ProjectGroup) = S_OK) Then
 Break;
end;

 Result := ProjectGroup;
end;

functionTToolsApiHelper.FindProject(const NameOrPath: string): IToolsApiProject;
begin
 Result := nil;

const Group = ProjectGroup;
ifnot Assigned(Group) then
 Exit;

var FileNames: TArray<string>;
 SetLength(FileNames, Group.ProjectCount);
forvar Index := 0to Group.ProjectCount - 1do
 FileNames[Index] := Group.Projects[Index].FileName;

const MatchIndex = TProjectMatch.IndexOf(FileNames, NameOrPath);
if MatchIndex < 0then
 Exit;

 Result := Project(Group.Projects[MatchIndex]);
end;

procedureTToolsApiHelper.SetActiveProject(const Project: IOTAProject);
begin
const Group = ProjectGroup;
if Assigned(Group) then
 Group.ActiveProject := Project;
end;

functionTToolsApiHelper.OpenProject(const FileName: string): IToolsApiProject;
begin
 Result := nil;

ifnot TFile.Exists(FileName) then
 Exit;

const ActionServices = BorlandIDEServices as IOTAActionServices;
const Opened = ActionServices.OpenProject(FileName, False);
ifnot Opened then
 Exit;

 Result := FindProject(FileName);
end;

functionTToolsApiHelper.Module: IToolsApiModule;
begin
 Result := TToolsApiModule.Create;
end;

functionTToolsApiHelper.Module(constModule: IOTAModule): IToolsApiModule;
begin
 Result := TToolsApiModule.Create(Module);
end;

functionTToolsApiHelper.Module(const Index: Integer): IToolsApiModule;
begin
 Result := TToolsApiModule.Create(Index);
end;

functionTToolsApiHelper.ModuleCount: Integer;
var
 ModuleServices: IOTAModuleServices;
begin
 ModuleServices := (BorlandIDEServices as IOTAModuleServices);
 Result := ModuleServices.ModuleCount;
end;

functionTToolsApiHelper.SourceEditor: IToolsApiSourceEditor;
begin
 Result := Self.Module.SourceEditor;
end;

functionTToolsApiHelper.BuildConfigurations: IToolsApiBuildConfigurations;
var
 ActiveProject: IOTAProject;
begin
 ActiveProject := Self.Project.Get;
 Result := TToolsApiBuildConfigurations.Create(ActiveProject);
end;

functionTToolsApiHelper.EnvironmentOptions: IToolsApiEnvironmentOptions;
begin
 Result := TToolsApiEnvironmentOptions.Create;
end;

functionTToolsApiHelper.Debugger: IToolsApiDebugger;
begin
 Result := TToolsApiDebugger.Create;
end;

functionTToolsApiHelper.EditorReader: IToolsApiEditReader;
begin
 Result := Self.SourceEditor.Reader;
end;

functionTToolsApiHelper.EditorWriter: IToolsApiEditWriter;
begin
 Self.SourceEditor.Writer;
end;

functionTToolsApiHelper.EditView: IToolsApiEditView;
begin
ifnot Assigned(FEditView) then
 FEditView := TToolsApiEditView.Create;

 Result := FEditView;
end;

functionTToolsApiHelper.Logger: IToolsApiLogger;
begin
 Result := Self.Logger('');
end;

functionTToolsApiHelper.Logger(const GroupName: string): IToolsApiLogger;
begin
 Result := TToolsApiLogger.Create(GroupName);
end;

procedureTToolsApiHelper.EditorInsertText(const Text: TArray<string>; const Position: TOTAEditPos);
begin
 Self.EditView.InsertText(Text, Position);
end;

procedureTToolsApiHelper.EditorInsertText(const Text: TArray<string>; const AtLine: Integer);
begin
var Lines := string.Join(sLineBreak, Text);
 Self.EditorWriter.InsertText(Lines, AtLine);
end;

functionTToolsApiHelper.EditorPosition: TOTAEditPos;
begin
 Result := Self.EditView.CursorPosition;
end;

functionTToolsApiHelper.EditorContent: string;
begin
 Result := EditorReader.Content;
end;

{ TToolsApiProject }

constructor TToolsApiProject.Create;
begin
inherited Create;
 FProject := GetActiveProject;
 Guard;
end;

constructor TToolsApiProject.Create(const Project: IOTAProject);
begin
inherited Create;
 FProject := Project;
 Guard;
end;

functionTToolsApiProject.Get: IOTAProject;
begin
 Result := FProject;
end;

functionTToolsApiProject.ProjectConfigurations: IOTAProjectOptionsConfigurations;
begin
 Result := FProject.ProjectOptions as IOTAProjectOptionsConfigurations;
end;

functionTToolsApiProject.BuildConfigurations: IToolsApiBuildConfigurations;
begin
 Result := TToolsApiBuildConfigurations.Create(FProject);
end;

functionTToolsApiProject.CreateFormUnit(const UnitFileName: string;
const FormName: string;
const AncestorName: string): IOTAModule;
begin
const Creator: IOTAModuleCreator = TToolsApiFormCreator.Create(FProject, UnitFileName, FormName, AncestorName);
 Result := (BorlandIDEServices as IOTAModuleServices).CreateModule(Creator);
end;

functionTToolsApiProject.Build(const HideProgressDialog: Boolean): Boolean;
const
 ShowCompilerProgressOption = 'ShowCompilerProgress';
var
 EnvironmentOptions: IToolsApiEnvironmentOptions;
 ExactName: string;
 SavedValue: Variant;
begin
ifnot HideProgressDialog then
 Exit(FProject.ProjectBuilder.BuildProject(cmOTABuild, False, True));

// When a build fails, the compile progress dialog stays open as a modal dialog until the
// user dismisses it, and BuildProject only returns after that. Temporarily disabling the
// "Show compiler progress" option keeps unattended builds from blocking.
 EnvironmentOptions := TToolsApiEnvironmentOptions.Create;
ifnot EnvironmentOptions.TryFindOptionName(ShowCompilerProgressOption, ExactName) then
 Exit(FProject.ProjectBuilder.BuildProject(cmOTABuild, False, True));

 SavedValue := EnvironmentOptions.GetOption(ExactName);
 EnvironmentOptions.SetOption(ExactName, False);
try
 Result := FProject.ProjectBuilder.BuildProject(cmOTABuild, False, True);
finally
 EnvironmentOptions.SetOption(ExactName, SavedValue);
end;
end;

procedureTToolsApiProject.Guard;
begin
ifnot Assigned(FProject) then
 raise EToolsApiNoProjectFound.Create('No active project found');
end;

{ TToolsApiModule }

constructor TToolsApiModule.Create;
begin
inherited Create;
 FModule := (BorlandIDEServices as IOTAModuleServices).CurrentModule;
 Guard;
end;

constructor TToolsApiModule.Create(constModule: IOTAModule);
begin
inherited Create;
 FModule := Module;
 Guard;
end;

constructor TToolsApiModule.Create(const Index: Integer);
begin
inherited Create;
 FModule := (BorlandIDEServices as IOTAModuleServices).Modules[Index];
 Guard;
end;

functionTToolsApiModule.Get: IOTAModule;
begin
 Result := FModule;
end;

functionTToolsApiModule.FileCount: Integer;
begin
 Result := FModule.GetModuleFileCount;
end;

functionTToolsApiModule.FileName: string;
begin
 Result := FModule.FileName;
end;

procedureTToolsApiModule.Refresh(const ForceRefresh: Boolean);
begin
 FModule.Refresh(ForceRefresh);
end;

functionTToolsApiModule.IsDirty: Boolean;
begin
 Result := False;

forvar Index := 0to FileCount - 1do
begin
const ModuleEditor = FModule.GetModuleFileEditor(Index);
if Assigned(ModuleEditor) and ModuleEditor.Modified then
 Exit(True);
end;
end;

functionTToolsApiModule.ReadSourceFromBuffer(out Source: string): Boolean;
const
 ChunkSize = 4096;
begin
 Source := '';

var Editor: IOTAEditor := nil;
forvar Index := 0to FileCount - 1do
begin
const Candidate = FModule.GetModuleFileEditor(Index);
if Supports(Candidate, IOTASourceEditor) then
begin
 Editor := Candidate;
 Break;
end;
end;

ifnot Assigned(Editor) then
 Exit(False);

const Reader = (Editor as IOTASourceEditor).CreateReader;

var Bytes: TBytes := nil;
var Position := 0;
var Chunk: TBytes;
 SetLength(Chunk, ChunkSize);

var BytesRead := Reader.GetText(Position, @Chunk[0], ChunkSize);
while BytesRead > 0do
begin
 Bytes := Bytes + Copy(Chunk, 0, BytesRead);
 Position := Position + BytesRead;

if BytesRead < ChunkSize then
 Break;

 BytesRead := Reader.GetText(Position, @Chunk[0], ChunkSize);
end;

 Source := TEncoding.UTF8.GetString(Bytes);
 Result := True;
end;

functionTToolsApiModule.MatchesDisk: Boolean;
begin
const FilePath = FModule.FileName;
if (FilePath = '') or (not FileExists(FilePath)) then
 Exit(True);

var BufferSource: string;
ifnot ReadSourceFromBuffer(BufferSource) then
 Exit(True);

const BufferNormalized = StringReplace(BufferSource, #13#10, #10, [rfReplaceAll]).TrimRight;

var DiskSource := '';
try
 DiskSource := TFile.ReadAllText(FilePath);
except
 Exit(True);
end;

const DiskNormalized = StringReplace(DiskSource, #13#10, #10, [rfReplaceAll]).TrimRight;
 Result := (BufferNormalized = DiskNormalized);
end;

procedureTToolsApiModule.SyncWithDisk;
begin
if MatchesDisk then
 Exit;

if IsDirty then
 raise EToolsApiModuleOutOfSync.CreateFmt(
'%s has unsaved changes in the IDE and a different version on disk', [FModule.FileName]);

 FModule.Refresh(True);
end;

functionTToolsApiModule.Editor(const Predicate: TFunc<IOTAEditor, Boolean>): IOTAEditor;
var
 i: Integer;
 Editor: IOTAEditor;
begin
 Result := nil;

for i := 0to FileCount - 1do
begin
 Editor := FModule.GetModuleFileEditor(i);
if Assigned(Predicate) andnot Predicate(Editor) then
 Continue;

 Result := Editor;
 Break;
end;

ifnot Assigned(Result) then
 raise EToolsApiNoEditorFound.Create('No editor found.');
end;

functionTToolsApiModule.SourceEditor(const Predicate: TFunc<IOTASourceEditor, Boolean>): IToolsApiSourceEditor;
var
 Found: IOTAEditor;
 SourceEditor: IOTASourceEditor;
begin
 Found := Editor(
 function(Editor: IOTAEditor): Boolean
begin
 Result := Supports(Editor, IOTASourceEditor);
end);

 SourceEditor := Found as IOTASourceEditor;
 Result := TToolsApiSourceEditor.Create(SourceEditor);
end;

functionTToolsApiModule.FormEditor(const Predicate: TFunc<IOTAFormEditor, Boolean>): IOTAFormEditor;
var
 Found: IOTAEditor;
begin
 Found := Editor(
 function(Editor: IOTAEditor): Boolean
begin
 Result := Supports(Editor, IOTAFormEditor);
end);

 Result := Found as IOTAFormEditor;
end;

functionTToolsApiModule.FormDesigner: IToolsApiFormEditor;
begin
 Result := TToolsApiFormEditor.Create(FormEditor(nil));
end;

procedureTToolsApiModule.Guard;
begin
ifnot Assigned(FModule) then
 raise EToolsApiNoModuleFound.Create('No active module found.');
end;

{ TToolsApiSourceEditor }

constructor TToolsApiSourceEditor.Create(const Editor: IOTASourceEditor);
begin
inherited Create;
 FEditor := Editor;
end;

functionTToolsApiSourceEditor.Get: IOTASourceEditor;
begin
 Result := FEditor;
end;

functionTToolsApiSourceEditor.Reader: IToolsApiEditReader;
var
 Reader: IOTAEditReader;
begin
 Reader := FEditor.CreateReader;
 Result := TToolsApiEditReader.Create(Reader);
end;

functionTToolsApiSourceEditor.Writer: IToolsApiEditWriter;
begin
var Writer := FEditor.CreateWriter;
 Result := TToolsApiEditWriter.Create(Writer);
end;

functionTToolsApiSourceEditor.UndoableWriter: IToolsApiEditWriter;
begin
var Writer := FEditor.CreateUndoableWriter;
 Result := TToolsApiEditWriter.Create(Writer);
end;

procedureTToolsApiSourceEditor.AddToInterfaceUses(const UnitName: string);
begin
 AddToUses([UnitName], False);
end;

procedureTToolsApiSourceEditor.AddToInterfaceUses(const UnitNames: TArray<string>);
begin
 AddToUses(UnitNames, False);
end;

procedureTToolsApiSourceEditor.AddToImplementationUses(const UnitName: string);
begin
 AddToUses([UnitName], True);
end;

procedureTToolsApiSourceEditor.AddToImplementationUses(const UnitNames: TArray<string>);
begin
 AddToUses(UnitNames, True);
end;

procedureTToolsApiSourceEditor.AddToUses(const UnitNames: TArray<string>; const AddToImplementation: Boolean);
begin
var UsesBuilder := TToolsAPIUsesBuilder.Use;

if AddToImplementation then
 UsesBuilder.InImplementation
else
 UsesBuilder.InInterface;

var EditorContent := Self.Reader.Content;

var UsesToWrite := UsesBuilder
 .WithSource(EditorContent)
 .Build(UnitNames);

if UsesToWrite.CanWrite then
 Self.UndoableWriter.InsertText(UsesToWrite.Text, UsesToWrite.Position);
end;

{ TToolsApiEditReader }

constructor TToolsApiEditReader.Create(const Reader: IOTAEditReader);
begin
inherited Create;
 FReader := Reader;
end;

functionTToolsApiEditReader.Get: IOTAEditReader;
begin
 Result := FReader;
end;

functionTToolsApiEditReader.Content: string;
const
 BufferSize: Integer = 1024;
var
 Read: Integer;
 Position: Integer;
 Buffer: AnsiString;
begin
 Result := '';

 Position := 0;
repeat
 SetLength(Buffer, BufferSize);

 Read := FReader.GetText(Position, PAnsiChar(Buffer), BufferSize);
 SetLength(Buffer, Read);

 Result := Result + string(Buffer);
 Inc(Position, Read);

until (Read < BufferSize);
end;

{ TToolsApiBuildConfiguration }

constructor TToolsApiBuildConfiguration.Create(const Configuration: IOTABuildConfiguration);
begin
inherited Create;
 FConfiguration := Configuration;
end;

functionTToolsApiBuildConfiguration.Get: IOTABuildConfiguration;
begin
 Result := FConfiguration;
end;

functionTToolsApiBuildConfiguration.GetSearchPaths: TArray<string>;
var
 Paths: TStringList;
begin
 Paths := TStringList.Create;
try
 FConfiguration.GetValues(DCCStrs.sUnitSearchPath, Paths, True);

 Result := Paths.ToStringArray;
finally
 Paths.Free;
end;
end;

procedureTToolsApiBuildConfiguration.SetSearchPaths(const Paths: TArray<string>);
var
 SearchPaths: TStringList;
begin
 SearchPaths := TStringList.Create;
try
 SearchPaths.AddStrings(Paths);
 FConfiguration.SetValues(sUnitSearchPath, SearchPaths);
finally
 SearchPaths.Free;
end;
end;

{ TToolsApiEnvironmentOptions }

constructor TToolsApiEnvironmentOptions.Create;
begin
inherited Create;
 FOptions := (BorlandIDEServices as IOTAServices).GetEnvironmentOptions;
end;

functionTToolsApiEnvironmentOptions.Get: IOTAEnvironmentOptions;
begin
 Result := FOptions;
end;

functionTToolsApiEnvironmentOptions.TryFindOptionName(const OptionName: string; out ExactName: string): Boolean;
var
 Names: TOTAOptionNameArray;
 Entry: TOTAOptionName;
begin
 Result := False;
 ExactName := '';

 Names := FOptions.GetOptionNames;
for Entry in Names do
begin
if SameText(Entry.Name, OptionName) then
begin
 ExactName := Entry.Name;
 Exit(True);
end;
end;
end;

functionTToolsApiEnvironmentOptions.GetOption(const OptionName: string): Variant;
begin
 Result := FOptions.Values[OptionName];
end;

procedureTToolsApiEnvironmentOptions.SetOption(const OptionName: string; constValue: Variant);
begin
 FOptions.Values[OptionName] := Value;
end;

{ TToolsApiEditWriter }

constructor TToolsApiEditWriter.Create(const Writer: IOTAEditWriter);
begin
inherited Create;
 FWriter := Writer;
end;

functionTToolsApiEditWriter.Get: IOTAEditWriter;
begin
 Result := FWriter;
end;

procedureTToolsApiEditWriter.InsertText(const Text: string; const Position: Integer);
begin
 FWriter.CopyTo(Position);
 FWriter.Insert(PAnsiChar(AnsiString(Text)));
end;

procedureTToolsApiEditWriter.InsertText(const Text: string; const Position: TOTAEditPos);
var
 EditView: IToolsApiEditView;
begin
 EditView := TToolsApiEditView.Create;
 EditView.InsertText([Text], Position);
end;

{ TToolsApiEditView }

constructor TToolsApiEditView.Create;
begin
inherited Create;
 FEditorServices := (BorlandIDEServices as IOTAEditorServices);
end;

functionTToolsApiEditView.TopView: IOTAEditView;
begin
 Result := FEditorServices.TopView;
ifnot Assigned(Result) then
 raise EToolsApiNoEditViewFound.Create('No edit view found.');
end;

functionTToolsApiEditView.CursorPosition: TOTAEditPos;
begin
 Result := TopView.CursorPos;
end;

procedureTToolsApiEditView.InsertText(const Text: TArray<string>; const Position: TOTAEditPos);
var
 Line: string;
 EditView: IOTAEditView;
 LineNumber, Col: Integer;
begin
 EditView := TopView;

 LineNumber := Position.Line;
 Col := Position.Col;

for Line in Text do
begin
 EditView.Buffer.EditPosition.Move(LineNumber, Col);
 EditView.Buffer.EditPosition.InsertText(Line + sLineBreak);

 Inc(LineNumber);
end;
end;

{ TToolsApiBuildConfigurations }

constructor TToolsApiBuildConfigurations.Create(const Project: IOTAProject);
begin
inherited Create;
 FProject := Project;
 FConfigurations := FProject.ProjectOptions as IOTAProjectOptionsConfigurations;
end;

functionTToolsApiBuildConfigurations.Active: IToolsApiBuildConfiguration;
var
 Config: IOTABuildConfiguration;
begin
 Config := FConfigurations.ActiveConfiguration;
 Result := TToolsApiBuildConfiguration.Create(Config);
end;

functionTToolsApiBuildConfigurations.Base: IToolsApiBuildConfiguration;
var
 Config: IOTABuildConfiguration;
begin
 Config := FConfigurations.BaseConfiguration;
 Result := TToolsApiBuildConfiguration.Create(Config);
end;

{ TToolsApiLogger }

constructor TToolsApiLogger.Create(const GroupName: string);
begin
inherited Create;
 FGroupName := GroupName;
end;

functionTToolsApiLogger.Custom: TCustomMessage;
var
 CustomGroup: IOTAMessageGroup;
begin
 CustomGroup := GetGroup;
 Result := TCustomMessage.Create(CustomGroup);
end;

functionTToolsApiLogger.UsesCustomGroup: Boolean;
begin
 Result := (not FGroupName.IsEmpty);
end;

functionTToolsApiLogger.GetGroup: IOTAMessageGroup;
begin
ifnot Self.UsesCustomGroup then
 raise EToolsApiNoCustomLogGroupUsed.Create('No custom logging group is used');

 Result := (BorlandIDEServices As IOTAMessageServices).AddMessageGroup(FGroupName);
end;

procedureTToolsApiLogger.Clear;
var
 CustomGroup: IOTAMessageGroup;
begin
ifnot Self.UsesCustomGroup then
 Exit;

 CustomGroup := (BorlandIDEServices As IOTAMessageServices).GetGroup(FGroupName);
 (BorlandIDEServices As IOTAMessageServices).ClearMessageGroup(CustomGroup);
end;

procedureTToolsApiLogger.Log(const Text: string; const Params: arrayofconst);
var
 FormattedText: string;
begin
 FormattedText := Format(Text, Params);
 Log(FormattedText);
end;

procedureTToolsApiLogger.Log(const Text: string);
var
 LineRef: Pointer;
 CustomGroup: IOTAMessageGroup;
begin
if Self.UsesCustomGroup then
 CustomGroup := GetGroup
else
 CustomGroup := nil;

 (BorlandIDEServices As IOTAMessageServices).AddToolMessage('', Text, '', 1, 1, nil, LineRef, CustomGroup);
end;

end.
unit GDK.ToolsAPI.Helper;

interface

uses
 ToolsAPI,
 GDK.ToolsAPI.Helper.Interfaces,
 GDK.ToolsAPI.Debugger.Interfaces,
 System.SysUtils,
 GDK.ToolsAPI.CustomMessage;

type
 TToolsApiHelper = class(TInterfacedObject, IToolsApiHelper)
private
 FEditView: IToolsApiEditView;
public
functionLogger: IToolsApiLogger; overload;
functionLogger(const GroupName: string): IToolsApiLogger; overload;

functionProjectGroup: IOTAProjectGroup;

functionProject: IToolsApiProject; overload;
functionProject(const Project: IOTAProject): IToolsApiProject; overload;

functionFindProject(const NameOrPath: string): IToolsApiProject;
procedureSetActiveProject(const Project: IOTAProject);
functionOpenProject(const FileName: string): IToolsApiProject;

functionProjectContextMenu: IToolsApiProjectContextMenu;

functionBuildConfigurations: IToolsApiBuildConfigurations;
functionEnvironmentOptions: IToolsApiEnvironmentOptions;
functionDebugger: IToolsApiDebugger;

functionModuleCount: Integer;
functionModule: IToolsApiModule; overload;
functionModule(constModule: IOTAModule): IToolsApiModule; overload;
functionModule(const Index: Integer): IToolsApiModule; overload;

functionSourceEditor: IToolsApiSourceEditor;
functionEditorReader: IToolsApiEditReader;
functionEditorWriter: IToolsApiEditWriter;

procedureEditorInsertText(const Text: TArray<string>; const Position: TOTAEditPos); overload;
procedureEditorInsertText(const Text: TArray<string>; const AtLine: Integer); overload;

functionEditorPosition: TOTAEditPos;
functionEditorContent: string;

functionEditView: IToolsApiEditView;
end;

 TToolsApiLogger = class(TInterfacedObject, IToolsApiLogger)
private
 FGroupName: string;
public
constructor Create(const GroupName: string);

functionUsesCustomGroup: Boolean;
functionGetGroup: IOTAMessageGroup;

procedureClear;

procedureLog(const Text: string); overload;
procedureLog(const Text: string; const Params: arrayofconst); overload;

functionCustom: TCustomMessage;
end;

 TToolsApiProject = class(TInterfacedObject, IToolsApiProject)
private
 FProject: IOTAProject;
procedureGuard;
public
constructor Create; overload;
constructor Create(const Project: IOTAProject); overload;

functionGet: IOTAProject;

functionProjectConfigurations: IOTAProjectOptionsConfigurations;
functionBuildConfigurations: IToolsApiBuildConfigurations;

functionBuild(const HideProgressDialog: Boolean = False): Boolean;

functionCreateFormUnit(const UnitFileName: string;
const FormName: string;
const AncestorName: string = ''): IOTAModule;
end;

 TToolsApiModule = class(TInterfacedObject, IToolsApiModule)
private
 FModule: IOTAModule;
procedureGuard;
functionReadSourceFromBuffer(out Source: string): Boolean;
public
constructor Create; overload;
constructor Create(constModule: IOTAModule); overload;
constructor Create(const Index: Integer); overload;

functionGet: IOTAModule;
functionFileCount: Integer;
functionFileName: string;
procedureRefresh(const ForceRefresh: Boolean);

functionIsDirty: Boolean;
functionMatchesDisk: Boolean;
procedureSyncWithDisk;

functionEditor(const Predicate: TFunc<IOTAEditor, Boolean>): IOTAEditor;
functionSourceEditor(const Predicate: TFunc<IOTASourceEditor, Boolean> = nil): IToolsApiSourceEditor;
functionFormEditor(const Predicate: TFunc<IOTAFormEditor, Boolean> = nil): IOTAFormEditor;
functionFormDesigner: IToolsApiFormEditor;
end;

 TToolsApiEditView = class(TInterfacedObject, IToolsApiEditView)
private
 FEditorServices: IOTAEditorServices;
public
constructor Create;

functionTopView: IOTAEditView;
functionCursorPosition: TOTAEditPos;

procedureInsertText(const Text: TArray<string>; const Position: TOTAEditPos);
end;

 TToolsApiSourceEditor = class(TInterfacedObject, IToolsApiSourceEditor)
private
 FEditor: IOTASourceEditor;
procedureAddToUses(const UnitNames: TArray<string>; const AddToImplementation: Boolean);
public
constructor Create(const Editor: IOTASourceEditor);

functionGet: IOTASourceEditor;
functionReader: IToolsApiEditReader;
functionWriter: IToolsApiEditWriter;
functionUndoableWriter: IToolsApiEditWriter;

procedureAddToInterfaceUses(const UnitName: string); overload;
procedureAddToInterfaceUses(const UnitNames: TArray<string>); overload;
procedureAddToImplementationUses(const UnitName: string); overload;
procedureAddToImplementationUses(const UnitNames: TArray<string>); overload;
end;

 TToolsApiEditReader = class(TInterfacedObject, IToolsApiEditReader)
private
 FReader: IOTAEditReader;
public
constructor Create(const Reader: IOTAEditReader);

functionGet: IOTAEditReader;
functionContent: string;
end;

 TToolsApiEditWriter = class(TInterfacedObject, IToolsApiEditWriter)
private
 FWriter: IOTAEditWriter;
public
constructor Create(const Writer: IOTAEditWriter);
functionGet: IOTAEditWriter;

procedureInsertText(const Text: string; const Position: Integer); overload;
procedureInsertText(const Text: string; const Position: TOTAEditPos); overload;
end;

 TToolsApiBuildConfigurations = class(TInterfacedObject, IToolsApiBuildConfigurations)
private
 FProject: IOTAProject;
 FConfigurations: IOTAProjectOptionsConfigurations;
public
constructor Create(const Project: IOTAProject);

functionBase: IToolsApiBuildConfiguration;
functionActive: IToolsApiBuildConfiguration;
end;

 TToolsApiEnvironmentOptions = class(TInterfacedObject, IToolsApiEnvironmentOptions)
private
 FOptions: IOTAEnvironmentOptions;
public
constructor Create;

functionGet: IOTAEnvironmentOptions;

functionTryFindOptionName(const OptionName: string; out ExactName: string): Boolean;
functionGetOption(const OptionName: string): Variant;
procedureSetOption(const OptionName: string; constValue: Variant);
end;

 TToolsApiBuildConfiguration = class(TInterfacedObject, IToolsApiBuildConfiguration)
private
 FConfiguration: IOTABuildConfiguration;

functionGetSearchPaths: TArray<string>;
procedureSetSearchPaths(const Paths: TArray<string>);
public
constructor Create(const Configuration: IOTABuildConfiguration);
functionGet: IOTABuildConfiguration;

property SearchPaths: TArray<string> read GetSearchPaths write SetSearchPaths;
end;

implementation

uses
 System.Classes,
 System.IOUtils,
 DCCStrs,
 GDK.ToolsAPI.Debugger,
 GDK.ToolsAPI.FormCreator,
 GDK.ToolsAPI.FormEditor,
 GDK.ToolsAPI.ProjectManagerContextMenu,
 GDK.ToolsAPI.ProjectMatch,
 GDK.ToolsAPI.UsesManager,
 GDK.ToolsAPI.UsesBuilder;

{ TToolsApiHelper }

functionTToolsApiHelper.Project: IToolsApiProject;
begin
 Result := TToolsApiProject.Create;
end;

functionTToolsApiHelper.Project(const Project: IOTAProject): IToolsApiProject;
begin
 Result := TToolsApiProject.Create(Project);
end;

functionTToolsApiHelper.ProjectContextMenu: IToolsApiProjectContextMenu;
begin
 Result := TToolsApiProjectContextMenu.Create;
end;

functionTToolsApiHelper.ProjectGroup: IOTAProjectGroup;
var
 ModuleServices: IOTAModuleServices;
Module: IOTAModule;
 ProjectGroup: IOTAProjectGroup;
 i: Integer;
Begin
 ProjectGroup := nil;

 ModuleServices := (BorlandIDEServices as IOTAModuleServices);
for i := 0to ModuleServices.ModuleCount - 1do
begin
Module := ModuleServices.Modules[i];
if (Module.QueryInterface(IOTAProjectGroup, ProjectGroup) = S_OK) Then
 Break;
end;

 Result := ProjectGroup;
end;

functionTToolsApiHelper.FindProject(const NameOrPath: string): IToolsApiProject;
begin
 Result := nil;

const Group = ProjectGroup;
ifnot Assigned(Group) then
 Exit;

var FileNames: TArray<string>;
 SetLength(FileNames, Group.ProjectCount);
forvar Index := 0to Group.ProjectCount - 1do
 FileNames[Index] := Group.Projects[Index].FileName;

const MatchIndex = TProjectMatch.IndexOf(FileNames, NameOrPath);
if MatchIndex < 0then
 Exit;

 Result := Project(Group.Projects[MatchIndex]);
end;

procedureTToolsApiHelper.SetActiveProject(const Project: IOTAProject);
begin
const Group = ProjectGroup;
if Assigned(Group) then
 Group.ActiveProject := Project;
end;

functionTToolsApiHelper.OpenProject(const FileName: string): IToolsApiProject;
begin
 Result := nil;

ifnot TFile.Exists(FileName) then
 Exit;

const ActionServices = BorlandIDEServices as IOTAActionServices;
const Opened = ActionServices.OpenProject(FileName, False);
ifnot Opened then
 Exit;

 Result := FindProject(FileName);
end;

functionTToolsApiHelper.Module: IToolsApiModule;
begin
 Result := TToolsApiModule.Create;
end;

functionTToolsApiHelper.Module(constModule: IOTAModule): IToolsApiModule;
begin
 Result := TToolsApiModule.Create(Module);
end;

functionTToolsApiHelper.Module(const Index: Integer): IToolsApiModule;
begin
 Result := TToolsApiModule.Create(Index);
end;

functionTToolsApiHelper.ModuleCount: Integer;
var
 ModuleServices: IOTAModuleServices;
begin
 ModuleServices := (BorlandIDEServices as IOTAModuleServices);
 Result := ModuleServices.ModuleCount;
end;

functionTToolsApiHelper.SourceEditor: IToolsApiSourceEditor;
begin
 Result := Self.Module.SourceEditor;
end;

functionTToolsApiHelper.BuildConfigurations: IToolsApiBuildConfigurations;
var
 ActiveProject: IOTAProject;
begin
 ActiveProject := Self.Project.Get;
 Result := TToolsApiBuildConfigurations.Create(ActiveProject);
end;

functionTToolsApiHelper.EnvironmentOptions: IToolsApiEnvironmentOptions;
begin
 Result := TToolsApiEnvironmentOptions.Create;
end;

functionTToolsApiHelper.Debugger: IToolsApiDebugger;
begin
 Result := TToolsApiDebugger.Create;
end;

functionTToolsApiHelper.EditorReader: IToolsApiEditReader;
begin
 Result := Self.SourceEditor.Reader;
end;

functionTToolsApiHelper.EditorWriter: IToolsApiEditWriter;
begin
 Self.SourceEditor.Writer;
end;

functionTToolsApiHelper.EditView: IToolsApiEditView;
begin
ifnot Assigned(FEditView) then
 FEditView := TToolsApiEditView.Create;

 Result := FEditView;
end;

functionTToolsApiHelper.Logger: IToolsApiLogger;
begin
 Result := Self.Logger('');
end;

functionTToolsApiHelper.Logger(const GroupName: string): IToolsApiLogger;
begin
 Result := TToolsApiLogger.Create(GroupName);
end;

procedureTToolsApiHelper.EditorInsertText(const Text: TArray<string>; const Position: TOTAEditPos);
begin
 Self.EditView.InsertText(Text, Position);
end;

procedureTToolsApiHelper.EditorInsertText(const Text: TArray<string>; const AtLine: Integer);
begin
var Lines := string.Join(sLineBreak, Text);
 Self.EditorWriter.InsertText(Lines, AtLine);
end;

functionTToolsApiHelper.EditorPosition: TOTAEditPos;
begin
 Result := Self.EditView.CursorPosition;
end;

functionTToolsApiHelper.EditorContent: string;
begin
 Result := EditorReader.Content;
end;

{ TToolsApiProject }

constructor TToolsApiProject.Create;
begin
inherited Create;
 FProject := GetActiveProject;
 Guard;
end;

constructor TToolsApiProject.Create(const Project: IOTAProject);
begin
inherited Create;
 FProject := Project;
 Guard;
end;

functionTToolsApiProject.Get: IOTAProject;
begin
 Result := FProject;
end;

functionTToolsApiProject.ProjectConfigurations: IOTAProjectOptionsConfigurations;
begin
 Result := FProject.ProjectOptions as IOTAProjectOptionsConfigurations;
end;

functionTToolsApiProject.BuildConfigurations: IToolsApiBuildConfigurations;
begin
 Result := TToolsApiBuildConfigurations.Create(FProject);
end;

functionTToolsApiProject.CreateFormUnit(const UnitFileName: string;
const FormName: string;
const AncestorName: string): IOTAModule;
begin
const Creator: IOTAModuleCreator = TToolsApiFormCreator.Create(FProject, UnitFileName, FormName, AncestorName);
 Result := (BorlandIDEServices as IOTAModuleServices).CreateModule(Creator);
end;

functionTToolsApiProject.Build(const HideProgressDialog: Boolean): Boolean;
const
 ShowCompilerProgressOption = 'ShowCompilerProgress';
var
 EnvironmentOptions: IToolsApiEnvironmentOptions;
 ExactName: string;
 SavedValue: Variant;
begin
ifnot HideProgressDialog then
 Exit(FProject.ProjectBuilder.BuildProject(cmOTABuild, False, True));

// When a build fails, the compile progress dialog stays open as a modal dialog until the
// user dismisses it, and BuildProject only returns after that. Temporarily disabling the
// "Show compiler progress" option keeps unattended builds from blocking.
 EnvironmentOptions := TToolsApiEnvironmentOptions.Create;
ifnot EnvironmentOptions.TryFindOptionName(ShowCompilerProgressOption, ExactName) then
 Exit(FProject.ProjectBuilder.BuildProject(cmOTABuild, False, True));

 SavedValue := EnvironmentOptions.GetOption(ExactName);
 EnvironmentOptions.SetOption(ExactName, False);
try
 Result := FProject.ProjectBuilder.BuildProject(cmOTABuild, False, True);
finally
 EnvironmentOptions.SetOption(ExactName, SavedValue);
end;
end;

procedureTToolsApiProject.Guard;
begin
ifnot Assigned(FProject) then
 raise EToolsApiNoProjectFound.Create('No active project found');
end;

{ TToolsApiModule }

constructor TToolsApiModule.Create;
begin
inherited Create;
 FModule := (BorlandIDEServices as IOTAModuleServices).CurrentModule;
 Guard;
end;

constructor TToolsApiModule.Create(constModule: IOTAModule);
begin
inherited Create;
 FModule := Module;
 Guard;
end;

constructor TToolsApiModule.Create(const Index: Integer);
begin
inherited Create;
 FModule := (BorlandIDEServices as IOTAModuleServices).Modules[Index];
 Guard;
end;

functionTToolsApiModule.Get: IOTAModule;
begin
 Result := FModule;
end;

functionTToolsApiModule.FileCount: Integer;
begin
 Result := FModule.GetModuleFileCount;
end;

functionTToolsApiModule.FileName: string;
begin
 Result := FModule.FileName;
end;

procedureTToolsApiModule.Refresh(const ForceRefresh: Boolean);
begin
 FModule.Refresh(ForceRefresh);
end;

functionTToolsApiModule.IsDirty: Boolean;
begin
 Result := False;

forvar Index := 0to FileCount - 1do
begin
const ModuleEditor = FModule.GetModuleFileEditor(Index);
if Assigned(ModuleEditor) and ModuleEditor.Modified then
 Exit(True);
end;
end;

functionTToolsApiModule.ReadSourceFromBuffer(out Source: string): Boolean;
const
 ChunkSize = 4096;
begin
 Source := '';

var Editor: IOTAEditor := nil;
forvar Index := 0to FileCount - 1do
begin
const Candidate = FModule.GetModuleFileEditor(Index);
if Supports(Candidate, IOTASourceEditor) then
begin
 Editor := Candidate;
 Break;
end;
end;

ifnot Assigned(Editor) then
 Exit(False);

const Reader = (Editor as IOTASourceEditor).CreateReader;

var Bytes: TBytes := nil;
var Position := 0;
var Chunk: TBytes;
 SetLength(Chunk, ChunkSize);

var BytesRead := Reader.GetText(Position, @Chunk[0], ChunkSize);
while BytesRead > 0do
begin
 Bytes := Bytes + Copy(Chunk, 0, BytesRead);
 Position := Position + BytesRead;

if BytesRead < ChunkSize then
 Break;

 BytesRead := Reader.GetText(Position, @Chunk[0], ChunkSize);
end;

 Source := TEncoding.UTF8.GetString(Bytes);
 Result := True;
end;

functionTToolsApiModule.MatchesDisk: Boolean;
begin
const FilePath = FModule.FileName;
if (FilePath = '') or (not FileExists(FilePath)) then
 Exit(True);

var BufferSource: string;
ifnot ReadSourceFromBuffer(BufferSource) then
 Exit(True);

const BufferNormalized = StringReplace(BufferSource, #13#10, #10, [rfReplaceAll]).TrimRight;

var DiskSource := '';
try
 DiskSource := TFile.ReadAllText(FilePath);
except
 Exit(True);
end;

const DiskNormalized = StringReplace(DiskSource, #13#10, #10, [rfReplaceAll]).TrimRight;
 Result := (BufferNormalized = DiskNormalized);
end;

procedureTToolsApiModule.SyncWithDisk;
begin
if MatchesDisk then
 Exit;

if IsDirty then
 raise EToolsApiModuleOutOfSync.CreateFmt(
'%s has unsaved changes in the IDE and a different version on disk', [FModule.FileName]);

 FModule.Refresh(True);
end;

functionTToolsApiModule.Editor(const Predicate: TFunc<IOTAEditor, Boolean>): IOTAEditor;
var
 i: Integer;
 Editor: IOTAEditor;
begin
 Result := nil;

for i := 0to FileCount - 1do
begin
 Editor := FModule.GetModuleFileEditor(i);
if Assigned(Predicate) andnot Predicate(Editor) then
 Continue;

 Result := Editor;
 Break;
end;

ifnot Assigned(Result) then
 raise EToolsApiNoEditorFound.Create('No editor found.');
end;

functionTToolsApiModule.SourceEditor(const Predicate: TFunc<IOTASourceEditor, Boolean>): IToolsApiSourceEditor;
var
 Found: IOTAEditor;
 SourceEditor: IOTASourceEditor;
begin
 Found := Editor(
 function(Editor: IOTAEditor): Boolean
begin
 Result := Supports(Editor, IOTASourceEditor);
end);

 SourceEditor := Found as IOTASourceEditor;
 Result := TToolsApiSourceEditor.Create(SourceEditor);
end;

functionTToolsApiModule.FormEditor(const Predicate: TFunc<IOTAFormEditor, Boolean>): IOTAFormEditor;
var
 Found: IOTAEditor;
begin
 Found := Editor(
 function(Editor: IOTAEditor): Boolean
begin
 Result := Supports(Editor, IOTAFormEditor);
end);

 Result := Found as IOTAFormEditor;
end;

functionTToolsApiModule.FormDesigner: IToolsApiFormEditor;
begin
 Result := TToolsApiFormEditor.Create(FormEditor(nil));
end;

procedureTToolsApiModule.Guard;
begin
ifnot Assigned(FModule) then
 raise EToolsApiNoModuleFound.Create('No active module found.');
end;

{ TToolsApiSourceEditor }

constructor TToolsApiSourceEditor.Create(const Editor: IOTASourceEditor);
begin
inherited Create;
 FEditor := Editor;
end;

functionTToolsApiSourceEditor.Get: IOTASourceEditor;
begin
 Result := FEditor;
end;

functionTToolsApiSourceEditor.Reader: IToolsApiEditReader;
var
 Reader: IOTAEditReader;
begin
 Reader := FEditor.CreateReader;
 Result := TToolsApiEditReader.Create(Reader);
end;

functionTToolsApiSourceEditor.Writer: IToolsApiEditWriter;
begin
var Writer := FEditor.CreateWriter;
 Result := TToolsApiEditWriter.Create(Writer);
end;

functionTToolsApiSourceEditor.UndoableWriter: IToolsApiEditWriter;
begin
var Writer := FEditor.CreateUndoableWriter;
 Result := TToolsApiEditWriter.Create(Writer);
end;

procedureTToolsApiSourceEditor.AddToInterfaceUses(const UnitName: string);
begin
 AddToUses([UnitName], False);
end;

procedureTToolsApiSourceEditor.AddToInterfaceUses(const UnitNames: TArray<string>);
begin
 AddToUses(UnitNames, False);
end;

procedureTToolsApiSourceEditor.AddToImplementationUses(const UnitName: string);
begin
 AddToUses([UnitName], True);
end;

procedureTToolsApiSourceEditor.AddToImplementationUses(const UnitNames: TArray<string>);
begin
 AddToUses(UnitNames, True);
end;

procedureTToolsApiSourceEditor.AddToUses(const UnitNames: TArray<string>; const AddToImplementation: Boolean);
begin
var UsesBuilder := TToolsAPIUsesBuilder.Use;

if AddToImplementation then
 UsesBuilder.InImplementation
else
 UsesBuilder.InInterface;

var EditorContent := Self.Reader.Content;

var UsesToWrite := UsesBuilder
 .WithSource(EditorContent)
 .Build(UnitNames);

if UsesToWrite.CanWrite then
 Self.UndoableWriter.InsertText(UsesToWrite.Text, UsesToWrite.Position);
end;

{ TToolsApiEditReader }

constructor TToolsApiEditReader.Create(const Reader: IOTAEditReader);
begin
inherited Create;
 FReader := Reader;
end;

functionTToolsApiEditReader.Get: IOTAEditReader;
begin
 Result := FReader;
end;

functionTToolsApiEditReader.Content: string;
const
 BufferSize: Integer = 1024;
var
 Read: Integer;
 Position: Integer;
 Buffer: AnsiString;
begin
 Result := '';

 Position := 0;
repeat
 SetLength(Buffer, BufferSize);

 Read := FReader.GetText(Position, PAnsiChar(Buffer), BufferSize);
 SetLength(Buffer, Read);

 Result := Result + string(Buffer);
 Inc(Position, Read);

until (Read < BufferSize);
end;

{ TToolsApiBuildConfiguration }

constructor TToolsApiBuildConfiguration.Create(const Configuration: IOTABuildConfiguration);
begin
inherited Create;
 FConfiguration := Configuration;
end;

functionTToolsApiBuildConfiguration.Get: IOTABuildConfiguration;
begin
 Result := FConfiguration;
end;

functionTToolsApiBuildConfiguration.GetSearchPaths: TArray<string>;
var
 Paths: TStringList;
begin
 Paths := TStringList.Create;
try
 FConfiguration.GetValues(DCCStrs.sUnitSearchPath, Paths, True);

 Result := Paths.ToStringArray;
finally
 Paths.Free;
end;
end;

procedureTToolsApiBuildConfiguration.SetSearchPaths(const Paths: TArray<string>);
var
 SearchPaths: TStringList;
begin
 SearchPaths := TStringList.Create;
try
 SearchPaths.AddStrings(Paths);
 FConfiguration.SetValues(sUnitSearchPath, SearchPaths);
finally
 SearchPaths.Free;
end;
end;

{ TToolsApiEnvironmentOptions }

constructor TToolsApiEnvironmentOptions.Create;
begin
inherited Create;
 FOptions := (BorlandIDEServices as IOTAServices).GetEnvironmentOptions;
end;

functionTToolsApiEnvironmentOptions.Get: IOTAEnvironmentOptions;
begin
 Result := FOptions;
end;

functionTToolsApiEnvironmentOptions.TryFindOptionName(const OptionName: string; out ExactName: string): Boolean;
var
 Names: TOTAOptionNameArray;
 Entry: TOTAOptionName;
begin
 Result := False;
 ExactName := '';

 Names := FOptions.GetOptionNames;
for Entry in Names do
begin
if SameText(Entry.Name, OptionName) then
begin
 ExactName := Entry.Name;
 Exit(True);
end;
end;
end;

functionTToolsApiEnvironmentOptions.GetOption(const OptionName: string): Variant;
begin
 Result := FOptions.Values[OptionName];
end;

procedureTToolsApiEnvironmentOptions.SetOption(const OptionName: string; constValue: Variant);
begin
 FOptions.Values[OptionName] := Value;
end;

{ TToolsApiEditWriter }

constructor TToolsApiEditWriter.Create(const Writer: IOTAEditWriter);
begin
inherited Create;
 FWriter := Writer;
end;

functionTToolsApiEditWriter.Get: IOTAEditWriter;
begin
 Result := FWriter;
end;

procedureTToolsApiEditWriter.InsertText(const Text: string; const Position: Integer);
begin
 FWriter.CopyTo(Position);
 FWriter.Insert(PAnsiChar(AnsiString(Text)));
end;

procedureTToolsApiEditWriter.InsertText(const Text: string; const Position: TOTAEditPos);
var
 EditView: IToolsApiEditView;
begin
 EditView := TToolsApiEditView.Create;
 EditView.InsertText([Text], Position);
end;

{ TToolsApiEditView }

constructor TToolsApiEditView.Create;
begin
inherited Create;
 FEditorServices := (BorlandIDEServices as IOTAEditorServices);
end;

functionTToolsApiEditView.TopView: IOTAEditView;
begin
 Result := FEditorServices.TopView;
ifnot Assigned(Result) then
 raise EToolsApiNoEditViewFound.Create('No edit view found.');
end;

functionTToolsApiEditView.CursorPosition: TOTAEditPos;
begin
 Result := TopView.CursorPos;
end;

procedureTToolsApiEditView.InsertText(const Text: TArray<string>; const Position: TOTAEditPos);
var
 Line: string;
 EditView: IOTAEditView;
 LineNumber, Col: Integer;
begin
 EditView := TopView;

 LineNumber := Position.Line;
 Col := Position.Col;

for Line in Text do
begin
 EditView.Buffer.EditPosition.Move(LineNumber, Col);
 EditView.Buffer.EditPosition.InsertText(Line + sLineBreak);

 Inc(LineNumber);
end;
end;

{ TToolsApiBuildConfigurations }

constructor TToolsApiBuildConfigurations.Create(const Project: IOTAProject);
begin
inherited Create;
 FProject := Project;
 FConfigurations := FProject.ProjectOptions as IOTAProjectOptionsConfigurations;
end;

functionTToolsApiBuildConfigurations.Active: IToolsApiBuildConfiguration;
var
 Config: IOTABuildConfiguration;
begin
 Config := FConfigurations.ActiveConfiguration;
 Result := TToolsApiBuildConfiguration.Create(Config);
end;

functionTToolsApiBuildConfigurations.Base: IToolsApiBuildConfiguration;
var
 Config: IOTABuildConfiguration;
begin
 Config := FConfigurations.BaseConfiguration;
 Result := TToolsApiBuildConfiguration.Create(Config);
end;

{ TToolsApiLogger }

constructor TToolsApiLogger.Create(const GroupName: string);
begin
inherited Create;
 FGroupName := GroupName;
end;

functionTToolsApiLogger.Custom: TCustomMessage;
var
 CustomGroup: IOTAMessageGroup;
begin
 CustomGroup := GetGroup;
 Result := TCustomMessage.Create(CustomGroup);
end;

functionTToolsApiLogger.UsesCustomGroup: Boolean;
begin
 Result := (not FGroupName.IsEmpty);
end;

functionTToolsApiLogger.GetGroup: IOTAMessageGroup;
begin
ifnot Self.UsesCustomGroup then
 raise EToolsApiNoCustomLogGroupUsed.Create('No custom logging group is used');

 Result := (BorlandIDEServices As IOTAMessageServices).AddMessageGroup(FGroupName);
end;

procedureTToolsApiLogger.Clear;
var
 CustomGroup: IOTAMessageGroup;
begin
ifnot Self.UsesCustomGroup then
 Exit;

 CustomGroup := (BorlandIDEServices As IOTAMessageServices).GetGroup(FGroupName);
 (BorlandIDEServices As IOTAMessageServices).ClearMessageGroup(CustomGroup);
end;

procedureTToolsApiLogger.Log(const Text: string; const Params: arrayofconst);
var
 FormattedText: string;
begin
 FormattedText := Format(Text, Params);
 Log(FormattedText);
end;

procedureTToolsApiLogger.Log(const Text: string);
var
 LineRef: Pointer;
 CustomGroup: IOTAMessageGroup;
begin
if Self.UsesCustomGroup then
 CustomGroup := GetGroup
else
 CustomGroup := nil;

 (BorlandIDEServices As IOTAMessageServices).AddToolMessage('', Text, '', 1, 1, nil, LineRef, CustomGroup);
end;

end.
unit GDK.ToolsAPI.Helper;

interface

uses
 ToolsAPI,
 GDK.ToolsAPI.Helper.Interfaces,
 GDK.ToolsAPI.Debugger.Interfaces,
 System.SysUtils,
 GDK.ToolsAPI.CustomMessage;

type
 TToolsApiHelper = class(TInterfacedObject, IToolsApiHelper)
private
 FEditView: IToolsApiEditView;
public
functionLogger: IToolsApiLogger; overload;
functionLogger(const GroupName: string): IToolsApiLogger; overload;

functionProjectGroup: IOTAProjectGroup;

functionProject: IToolsApiProject; overload;
functionProject(const Project: IOTAProject): IToolsApiProject; overload;

functionFindProject(const NameOrPath: string): IToolsApiProject;
procedureSetActiveProject(const Project: IOTAProject);
functionOpenProject(const FileName: string): IToolsApiProject;

functionProjectContextMenu: IToolsApiProjectContextMenu;

functionBuildConfigurations: IToolsApiBuildConfigurations;
functionEnvironmentOptions: IToolsApiEnvironmentOptions;
functionDebugger: IToolsApiDebugger;

functionModuleCount: Integer;
functionModule: IToolsApiModule; overload;
functionModule(constModule: IOTAModule): IToolsApiModule; overload;
functionModule(const Index: Integer): IToolsApiModule; overload;

functionSourceEditor: IToolsApiSourceEditor;
functionEditorReader: IToolsApiEditReader;
functionEditorWriter: IToolsApiEditWriter;

procedureEditorInsertText(const Text: TArray<string>; const Position: TOTAEditPos); overload;
procedureEditorInsertText(const Text: TArray<string>; const AtLine: Integer); overload;

functionEditorPosition: TOTAEditPos;
functionEditorContent: string;

functionEditView: IToolsApiEditView;
end;

 TToolsApiLogger = class(TInterfacedObject, IToolsApiLogger)
private
 FGroupName: string;
public
constructor Create(const GroupName: string);

functionUsesCustomGroup: Boolean;
functionGetGroup: IOTAMessageGroup;

procedureClear;

procedureLog(const Text: string); overload;
procedureLog(const Text: string; const Params: arrayofconst); overload;

functionCustom: TCustomMessage;
end;

 TToolsApiProject = class(TInterfacedObject, IToolsApiProject)
private
 FProject: IOTAProject;
procedureGuard;
public
constructor Create; overload;
constructor Create(const Project: IOTAProject); overload;

functionGet: IOTAProject;

functionProjectConfigurations: IOTAProjectOptionsConfigurations;
functionBuildConfigurations: IToolsApiBuildConfigurations;

functionBuild(const HideProgressDialog: Boolean = False): Boolean;

functionCreateFormUnit(const UnitFileName: string;
const FormName: string;
const AncestorName: string = ''): IOTAModule;
end;

 TToolsApiModule = class(TInterfacedObject, IToolsApiModule)
private
 FModule: IOTAModule;
procedureGuard;
functionReadSourceFromBuffer(out Source: string): Boolean;
public
constructor Create; overload;
constructor Create(constModule: IOTAModule); overload;
constructor Create(const Index: Integer); overload;

functionGet: IOTAModule;
functionFileCount: Integer;
functionFileName: string;
procedureRefresh(const ForceRefresh: Boolean);

functionIsDirty: Boolean;
functionMatchesDisk: Boolean;
procedureSyncWithDisk;

functionEditor(const Predicate: TFunc<IOTAEditor, Boolean>): IOTAEditor;
functionSourceEditor(const Predicate: TFunc<IOTASourceEditor, Boolean> = nil): IToolsApiSourceEditor;
functionFormEditor(const Predicate: TFunc<IOTAFormEditor, Boolean> = nil): IOTAFormEditor;
functionFormDesigner: IToolsApiFormEditor;
end;

 TToolsApiEditView = class(TInterfacedObject, IToolsApiEditView)
private
 FEditorServices: IOTAEditorServices;
public
constructor Create;

functionTopView: IOTAEditView;
functionCursorPosition: TOTAEditPos;

procedureInsertText(const Text: TArray<string>; const Position: TOTAEditPos);
end;

 TToolsApiSourceEditor = class(TInterfacedObject, IToolsApiSourceEditor)
private
 FEditor: IOTASourceEditor;
procedureAddToUses(const UnitNames: TArray<string>; const AddToImplementation: Boolean);
public
constructor Create(const Editor: IOTASourceEditor);

functionGet: IOTASourceEditor;
functionReader: IToolsApiEditReader;
functionWriter: IToolsApiEditWriter;
functionUndoableWriter: IToolsApiEditWriter;

procedureAddToInterfaceUses(const UnitName: string); overload;
procedureAddToInterfaceUses(const UnitNames: TArray<string>); overload;
procedureAddToImplementationUses(const UnitName: string); overload;
procedureAddToImplementationUses(const UnitNames: TArray<string>); overload;
end;

 TToolsApiEditReader = class(TInterfacedObject, IToolsApiEditReader)
private
 FReader: IOTAEditReader;
public
constructor Create(const Reader: IOTAEditReader);

functionGet: IOTAEditReader;
functionContent: string;
end;

 TToolsApiEditWriter = class(TInterfacedObject, IToolsApiEditWriter)
private
 FWriter: IOTAEditWriter;
public
constructor Create(const Writer: IOTAEditWriter);
functionGet: IOTAEditWriter;

procedureInsertText(const Text: string; const Position: Integer); overload;
procedureInsertText(const Text: string; const Position: TOTAEditPos); overload;
end;

 TToolsApiBuildConfigurations = class(TInterfacedObject, IToolsApiBuildConfigurations)
private
 FProject: IOTAProject;
 FConfigurations: IOTAProjectOptionsConfigurations;
public
constructor Create(const Project: IOTAProject);

functionBase: IToolsApiBuildConfiguration;
functionActive: IToolsApiBuildConfiguration;
end;

 TToolsApiEnvironmentOptions = class(TInterfacedObject, IToolsApiEnvironmentOptions)
private
 FOptions: IOTAEnvironmentOptions;
public
constructor Create;

functionGet: IOTAEnvironmentOptions;

functionTryFindOptionName(const OptionName: string; out ExactName: string): Boolean;
functionGetOption(const OptionName: string): Variant;
procedureSetOption(const OptionName: string; constValue: Variant);
end;

 TToolsApiBuildConfiguration = class(TInterfacedObject, IToolsApiBuildConfiguration)
private
 FConfiguration: IOTABuildConfiguration;

functionGetSearchPaths: TArray<string>;
procedureSetSearchPaths(const Paths: TArray<string>);
public
constructor Create(const Configuration: IOTABuildConfiguration);
functionGet: IOTABuildConfiguration;

property SearchPaths: TArray<string> read GetSearchPaths write SetSearchPaths;
end;

implementation

uses
 System.Classes,
 System.IOUtils,
 DCCStrs,
 GDK.ToolsAPI.Debugger,
 GDK.ToolsAPI.FormCreator,
 GDK.ToolsAPI.FormEditor,
 GDK.ToolsAPI.ProjectManagerContextMenu,
 GDK.ToolsAPI.ProjectMatch,
 GDK.ToolsAPI.UsesManager,
 GDK.ToolsAPI.UsesBuilder;

{ TToolsApiHelper }

functionTToolsApiHelper.Project: IToolsApiProject;
begin
 Result := TToolsApiProject.Create;
end;

functionTToolsApiHelper.Project(const Project: IOTAProject): IToolsApiProject;
begin
 Result := TToolsApiProject.Create(Project);
end;

functionTToolsApiHelper.ProjectContextMenu: IToolsApiProjectContextMenu;
begin
 Result := TToolsApiProjectContextMenu.Create;
end;

functionTToolsApiHelper.ProjectGroup: IOTAProjectGroup;
var
 ModuleServices: IOTAModuleServices;
Module: IOTAModule;
 ProjectGroup: IOTAProjectGroup;
 i: Integer;
Begin
 ProjectGroup := nil;

 ModuleServices := (BorlandIDEServices as IOTAModuleServices);
for i := 0to ModuleServices.ModuleCount - 1do
begin
Module := ModuleServices.Modules[i];
if (Module.QueryInterface(IOTAProjectGroup, ProjectGroup) = S_OK) Then
 Break;
end;

 Result := ProjectGroup;
end;

functionTToolsApiHelper.FindProject(const NameOrPath: string): IToolsApiProject;
begin
 Result := nil;

const Group = ProjectGroup;
ifnot Assigned(Group) then
 Exit;

var FileNames: TArray<string>;
 SetLength(FileNames, Group.ProjectCount);
forvar Index := 0to Group.ProjectCount - 1do
 FileNames[Index] := Group.Projects[Index].FileName;

const MatchIndex = TProjectMatch.IndexOf(FileNames, NameOrPath);
if MatchIndex < 0then
 Exit;

 Result := Project(Group.Projects[MatchIndex]);
end;

procedureTToolsApiHelper.SetActiveProject(const Project: IOTAProject);
begin
const Group = ProjectGroup;
if Assigned(Group) then
 Group.ActiveProject := Project;
end;

functionTToolsApiHelper.OpenProject(const FileName: string): IToolsApiProject;
begin
 Result := nil;

ifnot TFile.Exists(FileName) then
 Exit;

const ActionServices = BorlandIDEServices as IOTAActionServices;
const Opened = ActionServices.OpenProject(FileName, False);
ifnot Opened then
 Exit;

 Result := FindProject(FileName);
end;

functionTToolsApiHelper.Module: IToolsApiModule;
begin
 Result := TToolsApiModule.Create;
end;

functionTToolsApiHelper.Module(constModule: IOTAModule): IToolsApiModule;
begin
 Result := TToolsApiModule.Create(Module);
end;

functionTToolsApiHelper.Module(const Index: Integer): IToolsApiModule;
begin
 Result := TToolsApiModule.Create(Index);
end;

functionTToolsApiHelper.ModuleCount: Integer;
var
 ModuleServices: IOTAModuleServices;
begin
 ModuleServices := (BorlandIDEServices as IOTAModuleServices);
 Result := ModuleServices.ModuleCount;
end;

functionTToolsApiHelper.SourceEditor: IToolsApiSourceEditor;
begin
 Result := Self.Module.SourceEditor;
end;

functionTToolsApiHelper.BuildConfigurations: IToolsApiBuildConfigurations;
var
 ActiveProject: IOTAProject;
begin
 ActiveProject := Self.Project.Get;
 Result := TToolsApiBuildConfigurations.Create(ActiveProject);
end;

functionTToolsApiHelper.EnvironmentOptions: IToolsApiEnvironmentOptions;
begin
 Result := TToolsApiEnvironmentOptions.Create;
end;

functionTToolsApiHelper.Debugger: IToolsApiDebugger;
begin
 Result := TToolsApiDebugger.Create;
end;

functionTToolsApiHelper.EditorReader: IToolsApiEditReader;
begin
 Result := Self.SourceEditor.Reader;
end;

functionTToolsApiHelper.EditorWriter: IToolsApiEditWriter;
begin
 Self.SourceEditor.Writer;
end;

functionTToolsApiHelper.EditView: IToolsApiEditView;
begin
ifnot Assigned(FEditView) then
 FEditView := TToolsApiEditView.Create;

 Result := FEditView;
end;

functionTToolsApiHelper.Logger: IToolsApiLogger;
begin
 Result := Self.Logger('');
end;

functionTToolsApiHelper.Logger(const GroupName: string): IToolsApiLogger;
begin
 Result := TToolsApiLogger.Create(GroupName);
end;

procedureTToolsApiHelper.EditorInsertText(const Text: TArray<string>; const Position: TOTAEditPos);
begin
 Self.EditView.InsertText(Text, Position);
end;

procedureTToolsApiHelper.EditorInsertText(const Text: TArray<string>; const AtLine: Integer);
begin
var Lines := string.Join(sLineBreak, Text);
 Self.EditorWriter.InsertText(Lines, AtLine);
end;

functionTToolsApiHelper.EditorPosition: TOTAEditPos;
begin
 Result := Self.EditView.CursorPosition;
end;

functionTToolsApiHelper.EditorContent: string;
begin
 Result := EditorReader.Content;
end;

{ TToolsApiProject }

constructor TToolsApiProject.Create;
begin
inherited Create;
 FProject := GetActiveProject;
 Guard;
end;

constructor TToolsApiProject.Create(const Project: IOTAProject);
begin
inherited Create;
 FProject := Project;
 Guard;
end;

functionTToolsApiProject.Get: IOTAProject;
begin
 Result := FProject;
end;

functionTToolsApiProject.ProjectConfigurations: IOTAProjectOptionsConfigurations;
begin
 Result := FProject.ProjectOptions as IOTAProjectOptionsConfigurations;
end;

functionTToolsApiProject.BuildConfigurations: IToolsApiBuildConfigurations;
begin
 Result := TToolsApiBuildConfigurations.Create(FProject);
end;

functionTToolsApiProject.CreateFormUnit(const UnitFileName: string;
const FormName: string;
const AncestorName: string): IOTAModule;
begin
const Creator: IOTAModuleCreator = TToolsApiFormCreator.Create(FProject, UnitFileName, FormName, AncestorName);
 Result := (BorlandIDEServices as IOTAModuleServices).CreateModule(Creator);
end;

functionTToolsApiProject.Build(const HideProgressDialog: Boolean): Boolean;
const
 ShowCompilerProgressOption = 'ShowCompilerProgress';
var
 EnvironmentOptions: IToolsApiEnvironmentOptions;
 ExactName: string;
 SavedValue: Variant;
begin
ifnot HideProgressDialog then
 Exit(FProject.ProjectBuilder.BuildProject(cmOTABuild, False, True));

// When a build fails, the compile progress dialog stays open as a modal dialog until the
// user dismisses it, and BuildProject only returns after that. Temporarily disabling the
// "Show compiler progress" option keeps unattended builds from blocking.
 EnvironmentOptions := TToolsApiEnvironmentOptions.Create;
ifnot EnvironmentOptions.TryFindOptionName(ShowCompilerProgressOption, ExactName) then
 Exit(FProject.ProjectBuilder.BuildProject(cmOTABuild, False, True));

 SavedValue := EnvironmentOptions.GetOption(ExactName);
 EnvironmentOptions.SetOption(ExactName, False);
try
 Result := FProject.ProjectBuilder.BuildProject(cmOTABuild, False, True);
finally
 EnvironmentOptions.SetOption(ExactName, SavedValue);
end;
end;

procedureTToolsApiProject.Guard;
begin
ifnot Assigned(FProject) then
 raise EToolsApiNoProjectFound.Create('No active project found');
end;

{ TToolsApiModule }

constructor TToolsApiModule.Create;
begin
inherited Create;
 FModule := (BorlandIDEServices as IOTAModuleServices).CurrentModule;
 Guard;
end;

constructor TToolsApiModule.Create(constModule: IOTAModule);
begin
inherited Create;
 FModule := Module;
 Guard;
end;

constructor TToolsApiModule.Create(const Index: Integer);
begin
inherited Create;
 FModule := (BorlandIDEServices as IOTAModuleServices).Modules[Index];
 Guard;
end;

functionTToolsApiModule.Get: IOTAModule;
begin
 Result := FModule;
end;

functionTToolsApiModule.FileCount: Integer;
begin
 Result := FModule.GetModuleFileCount;
end;

functionTToolsApiModule.FileName: string;
begin
 Result := FModule.FileName;
end;

procedureTToolsApiModule.Refresh(const ForceRefresh: Boolean);
begin
 FModule.Refresh(ForceRefresh);
end;

functionTToolsApiModule.IsDirty: Boolean;
begin
 Result := False;

forvar Index := 0to FileCount - 1do
begin
const ModuleEditor = FModule.GetModuleFileEditor(Index);
if Assigned(ModuleEditor) and ModuleEditor.Modified then
 Exit(True);
end;
end;

functionTToolsApiModule.ReadSourceFromBuffer(out Source: string): Boolean;
const
 ChunkSize = 4096;
begin
 Source := '';

var Editor: IOTAEditor := nil;
forvar Index := 0to FileCount - 1do
begin
const Candidate = FModule.GetModuleFileEditor(Index);
if Supports(Candidate, IOTASourceEditor) then
begin
 Editor := Candidate;
 Break;
end;
end;

ifnot Assigned(Editor) then
 Exit(False);

const Reader = (Editor as IOTASourceEditor).CreateReader;

var Bytes: TBytes := nil;
var Position := 0;
var Chunk: TBytes;
 SetLength(Chunk, ChunkSize);

var BytesRead := Reader.GetText(Position, @Chunk[0], ChunkSize);
while BytesRead > 0do
begin
 Bytes := Bytes + Copy(Chunk, 0, BytesRead);
 Position := Position + BytesRead;

if BytesRead < ChunkSize then
 Break;

 BytesRead := Reader.GetText(Position, @Chunk[0], ChunkSize);
end;

 Source := TEncoding.UTF8.GetString(Bytes);
 Result := True;
end;

functionTToolsApiModule.MatchesDisk: Boolean;
begin
const FilePath = FModule.FileName;
if (FilePath = '') or (not FileExists(FilePath)) then
 Exit(True);

var BufferSource: string;
ifnot ReadSourceFromBuffer(BufferSource) then
 Exit(True);

const BufferNormalized = StringReplace(BufferSource, #13#10, #10, [rfReplaceAll]).TrimRight;

var DiskSource := '';
try
 DiskSource := TFile.ReadAllText(FilePath);
except
 Exit(True);
end;

const DiskNormalized = StringReplace(DiskSource, #13#10, #10, [rfReplaceAll]).TrimRight;
 Result := (BufferNormalized = DiskNormalized);
end;

procedureTToolsApiModule.SyncWithDisk;
begin
if MatchesDisk then
 Exit;

if IsDirty then
 raise EToolsApiModuleOutOfSync.CreateFmt(
'%s has unsaved changes in the IDE and a different version on disk', [FModule.FileName]);

 FModule.Refresh(True);
end;

functionTToolsApiModule.Editor(const Predicate: TFunc<IOTAEditor, Boolean>): IOTAEditor;
var
 i: Integer;
 Editor: IOTAEditor;
begin
 Result := nil;

for i := 0to FileCount - 1do
begin
 Editor := FModule.GetModuleFileEditor(i);
if Assigned(Predicate) andnot Predicate(Editor) then
 Continue;

 Result := Editor;
 Break;
end;

ifnot Assigned(Result) then
 raise EToolsApiNoEditorFound.Create('No editor found.');
end;

functionTToolsApiModule.SourceEditor(const Predicate: TFunc<IOTASourceEditor, Boolean>): IToolsApiSourceEditor;
var
 Found: IOTAEditor;
 SourceEditor: IOTASourceEditor;
begin
 Found := Editor(
 function(Editor: IOTAEditor): Boolean
begin
 Result := Supports(Editor, IOTASourceEditor);
end);

 SourceEditor := Found as IOTASourceEditor;
 Result := TToolsApiSourceEditor.Create(SourceEditor);
end;

functionTToolsApiModule.FormEditor(const Predicate: TFunc<IOTAFormEditor, Boolean>): IOTAFormEditor;
var
 Found: IOTAEditor;
begin
 Found := Editor(
 function(Editor: IOTAEditor): Boolean
begin
 Result := Supports(Editor, IOTAFormEditor);
end);

 Result := Found as IOTAFormEditor;
end;

functionTToolsApiModule.FormDesigner: IToolsApiFormEditor;
begin
 Result := TToolsApiFormEditor.Create(FormEditor(nil));
end;

procedureTToolsApiModule.Guard;
begin
ifnot Assigned(FModule) then
 raise EToolsApiNoModuleFound.Create('No active module found.');
end;

{ TToolsApiSourceEditor }

constructor TToolsApiSourceEditor.Create(const Editor: IOTASourceEditor);
begin
inherited Create;
 FEditor := Editor;
end;

functionTToolsApiSourceEditor.Get: IOTASourceEditor;
begin
 Result := FEditor;
end;

functionTToolsApiSourceEditor.Reader: IToolsApiEditReader;
var
 Reader: IOTAEditReader;
begin
 Reader := FEditor.CreateReader;
 Result := TToolsApiEditReader.Create(Reader);
end;

functionTToolsApiSourceEditor.Writer: IToolsApiEditWriter;
begin
var Writer := FEditor.CreateWriter;
 Result := TToolsApiEditWriter.Create(Writer);
end;

functionTToolsApiSourceEditor.UndoableWriter: IToolsApiEditWriter;
begin
var Writer := FEditor.CreateUndoableWriter;
 Result := TToolsApiEditWriter.Create(Writer);
end;

procedureTToolsApiSourceEditor.AddToInterfaceUses(const UnitName: string);
begin
 AddToUses([UnitName], False);
end;

procedureTToolsApiSourceEditor.AddToInterfaceUses(const UnitNames: TArray<string>);
begin
 AddToUses(UnitNames, False);
end;

procedureTToolsApiSourceEditor.AddToImplementationUses(const UnitName: string);
begin
 AddToUses([UnitName], True);
end;

procedureTToolsApiSourceEditor.AddToImplementationUses(const UnitNames: TArray<string>);
begin
 AddToUses(UnitNames, True);
end;

procedureTToolsApiSourceEditor.AddToUses(const UnitNames: TArray<string>; const AddToImplementation: Boolean);
begin
var UsesBuilder := TToolsAPIUsesBuilder.Use;

if AddToImplementation then
 UsesBuilder.InImplementation
else
 UsesBuilder.InInterface;

var EditorContent := Self.Reader.Content;

var UsesToWrite := UsesBuilder
 .WithSource(EditorContent)
 .Build(UnitNames);

if UsesToWrite.CanWrite then
 Self.UndoableWriter.InsertText(UsesToWrite.Text, UsesToWrite.Position);
end;

{ TToolsApiEditReader }

constructor TToolsApiEditReader.Create(const Reader: IOTAEditReader);
begin
inherited Create;
 FReader := Reader;
end;

functionTToolsApiEditReader.Get: IOTAEditReader;
begin
 Result := FReader;
end;

functionTToolsApiEditReader.Content: string;
const
 BufferSize: Integer = 1024;
var
 Read: Integer;
 Position: Integer;
 Buffer: AnsiString;
begin
 Result := '';

 Position := 0;
repeat
 SetLength(Buffer, BufferSize);

 Read := FReader.GetText(Position, PAnsiChar(Buffer), BufferSize);
 SetLength(Buffer, Read);

 Result := Result + string(Buffer);
 Inc(Position, Read);

until (Read < BufferSize);
end;

{ TToolsApiBuildConfiguration }

constructor TToolsApiBuildConfiguration.Create(const Configuration: IOTABuildConfiguration);
begin
inherited Create;
 FConfiguration := Configuration;
end;

functionTToolsApiBuildConfiguration.Get: IOTABuildConfiguration;
begin
 Result := FConfiguration;
end;

functionTToolsApiBuildConfiguration.GetSearchPaths: TArray<string>;
var
 Paths: TStringList;
begin
 Paths := TStringList.Create;
try
 FConfiguration.GetValues(DCCStrs.sUnitSearchPath, Paths, True);

 Result := Paths.ToStringArray;
finally
 Paths.Free;
end;
end;

procedureTToolsApiBuildConfiguration.SetSearchPaths(const Paths: TArray<string>);
var
 SearchPaths: TStringList;
begin
 SearchPaths := TStringList.Create;
try
 SearchPaths.AddStrings(Paths);
 FConfiguration.SetValues(sUnitSearchPath, SearchPaths);
finally
 SearchPaths.Free;
end;
end;

{ TToolsApiEnvironmentOptions }

constructor TToolsApiEnvironmentOptions.Create;
begin
inherited Create;
 FOptions := (BorlandIDEServices as IOTAServices).GetEnvironmentOptions;
end;

functionTToolsApiEnvironmentOptions.Get: IOTAEnvironmentOptions;
begin
 Result := FOptions;
end;

functionTToolsApiEnvironmentOptions.TryFindOptionName(const OptionName: string; out ExactName: string): Boolean;
var
 Names: TOTAOptionNameArray;
 Entry: TOTAOptionName;
begin
 Result := False;
 ExactName := '';

 Names := FOptions.GetOptionNames;
for Entry in Names do
begin
if SameText(Entry.Name, OptionName) then
begin
 ExactName := Entry.Name;
 Exit(True);
end;
end;
end;

functionTToolsApiEnvironmentOptions.GetOption(const OptionName: string): Variant;
begin
 Result := FOptions.Values[OptionName];
end;

procedureTToolsApiEnvironmentOptions.SetOption(const OptionName: string; constValue: Variant);
begin
 FOptions.Values[OptionName] := Value;
end;

{ TToolsApiEditWriter }

constructor TToolsApiEditWriter.Create(const Writer: IOTAEditWriter);
begin
inherited Create;
 FWriter := Writer;
end;

functionTToolsApiEditWriter.Get: IOTAEditWriter;
begin
 Result := FWriter;
end;

procedureTToolsApiEditWriter.InsertText(const Text: string; const Position: Integer);
begin
 FWriter.CopyTo(Position);
 FWriter.Insert(PAnsiChar(AnsiString(Text)));
end;

procedureTToolsApiEditWriter.InsertText(const Text: string; const Position: TOTAEditPos);
var
 EditView: IToolsApiEditView;
begin
 EditView := TToolsApiEditView.Create;
 EditView.InsertText([Text], Position);
end;

{ TToolsApiEditView }

constructor TToolsApiEditView.Create;
begin
inherited Create;
 FEditorServices := (BorlandIDEServices as IOTAEditorServices);
end;

functionTToolsApiEditView.TopView: IOTAEditView;
begin
 Result := FEditorServices.TopView;
ifnot Assigned(Result) then
 raise EToolsApiNoEditViewFound.Create('No edit view found.');
end;

functionTToolsApiEditView.CursorPosition: TOTAEditPos;
begin
 Result := TopView.CursorPos;
end;

procedureTToolsApiEditView.InsertText(const Text: TArray<string>; const Position: TOTAEditPos);
var
 Line: string;
 EditView: IOTAEditView;
 LineNumber, Col: Integer;
begin
 EditView := TopView;

 LineNumber := Position.Line;
 Col := Position.Col;

for Line in Text do
begin
 EditView.Buffer.EditPosition.Move(LineNumber, Col);
 EditView.Buffer.EditPosition.InsertText(Line + sLineBreak);

 Inc(LineNumber);
end;
end;

{ TToolsApiBuildConfigurations }

constructor TToolsApiBuildConfigurations.Create(const Project: IOTAProject);
begin
inherited Create;
 FProject := Project;
 FConfigurations := FProject.ProjectOptions as IOTAProjectOptionsConfigurations;
end;

functionTToolsApiBuildConfigurations.Active: IToolsApiBuildConfiguration;
var
 Config: IOTABuildConfiguration;
begin
 Config := FConfigurations.ActiveConfiguration;
 Result := TToolsApiBuildConfiguration.Create(Config);
end;

functionTToolsApiBuildConfigurations.Base: IToolsApiBuildConfiguration;
var
 Config: IOTABuildConfiguration;
begin
 Config := FConfigurations.BaseConfiguration;
 Result := TToolsApiBuildConfiguration.Create(Config);
end;

{ TToolsApiLogger }

constructor TToolsApiLogger.Create(const GroupName: string);
begin
inherited Create;
 FGroupName := GroupName;
end;

functionTToolsApiLogger.Custom: TCustomMessage;
var
 CustomGroup: IOTAMessageGroup;
begin
 CustomGroup := GetGroup;
 Result := TCustomMessage.Create(CustomGroup);
end;

functionTToolsApiLogger.UsesCustomGroup: Boolean;
begin
 Result := (not FGroupName.IsEmpty);
end;

functionTToolsApiLogger.GetGroup: IOTAMessageGroup;
begin
ifnot Self.UsesCustomGroup then
 raise EToolsApiNoCustomLogGroupUsed.Create('No custom logging group is used');

 Result := (BorlandIDEServices As IOTAMessageServices).AddMessageGroup(FGroupName);
end;

procedureTToolsApiLogger.Clear;
var
 CustomGroup: IOTAMessageGroup;
begin
ifnot Self.UsesCustomGroup then
 Exit;

 CustomGroup := (BorlandIDEServices As IOTAMessageServices).GetGroup(FGroupName);
 (BorlandIDEServices As IOTAMessageServices).ClearMessageGroup(CustomGroup);
end;

procedureTToolsApiLogger.Log(const Text: string; const Params: arrayofconst);
var
 FormattedText: string;
begin
 FormattedText := Format(Text, Params);
 Log(FormattedText);
end;

procedureTToolsApiLogger.Log(const Text: string);
var
 LineRef: Pointer;
 CustomGroup: IOTAMessageGroup;
begin
if Self.UsesCustomGroup then
 CustomGroup := GetGroup
else
 CustomGroup := nil;

 (BorlandIDEServices As IOTAMessageServices).AddToolMessage('', Text, '', 1, 1, nil, LineRef, CustomGroup);
end;

end.
unit GDK.ToolsAPI.Helper;

interface

uses
 ToolsAPI,
 GDK.ToolsAPI.Helper.Interfaces,
 GDK.ToolsAPI.Debugger.Interfaces,
 System.SysUtils,
 GDK.ToolsAPI.CustomMessage;

type
 TToolsApiHelper = class(TInterfacedObject, IToolsApiHelper)
private
 FEditView: IToolsApiEditView;
public
functionLogger: IToolsApiLogger; overload;
functionLogger(const GroupName: string): IToolsApiLogger; overload;

functionProjectGroup: IOTAProjectGroup;

functionProject: IToolsApiProject; overload;
functionProject(const Project: IOTAProject): IToolsApiProject; overload;

functionFindProject(const NameOrPath: string): IToolsApiProject;
procedureSetActiveProject(const Project: IOTAProject);
functionOpenProject(const FileName: string): IToolsApiProject;

functionProjectContextMenu: IToolsApiProjectContextMenu;

functionBuildConfigurations: IToolsApiBuildConfigurations;
functionEnvironmentOptions: IToolsApiEnvironmentOptions;
functionDebugger: IToolsApiDebugger;

functionModuleCount: Integer;
functionModule: IToolsApiModule; overload;
functionModule(constModule: IOTAModule): IToolsApiModule; overload;
functionModule(const Index: Integer): IToolsApiModule; overload;

functionSourceEditor: IToolsApiSourceEditor;
functionEditorReader: IToolsApiEditReader;
functionEditorWriter: IToolsApiEditWriter;

procedureEditorInsertText(const Text: TArray<string>; const Position: TOTAEditPos); overload;
procedureEditorInsertText(const Text: TArray<string>; const AtLine: Integer); overload;

functionEditorPosition: TOTAEditPos;
functionEditorContent: string;

functionEditView: IToolsApiEditView;
end;

 TToolsApiLogger = class(TInterfacedObject, IToolsApiLogger)
private
 FGroupName: string;
public
constructor Create(const GroupName: string);

functionUsesCustomGroup: Boolean;
functionGetGroup: IOTAMessageGroup;

procedureClear;

procedureLog(const Text: string); overload;
procedureLog(const Text: string; const Params: arrayofconst); overload;

functionCustom: TCustomMessage;
end;

 TToolsApiProject = class(TInterfacedObject, IToolsApiProject)
private
 FProject: IOTAProject;
procedureGuard;
public
constructor Create; overload;
constructor Create(const Project: IOTAProject); overload;

functionGet: IOTAProject;

functionProjectConfigurations: IOTAProjectOptionsConfigurations;
functionBuildConfigurations: IToolsApiBuildConfigurations;

functionBuild(const HideProgressDialog: Boolean = False): Boolean;

functionCreateFormUnit(const UnitFileName: string;
const FormName: string;
const AncestorName: string = ''): IOTAModule;
end;

 TToolsApiModule = class(TInterfacedObject, IToolsApiModule)
private
 FModule: IOTAModule;
procedureGuard;
functionReadSourceFromBuffer(out Source: string): Boolean;
public
constructor Create; overload;
constructor Create(constModule: IOTAModule); overload;
constructor Create(const Index: Integer); overload;

functionGet: IOTAModule;
functionFileCount: Integer;
functionFileName: string;
procedureRefresh(const ForceRefresh: Boolean);

functionIsDirty: Boolean;
functionMatchesDisk: Boolean;
procedureSyncWithDisk;

functionEditor(const Predicate: TFunc<IOTAEditor, Boolean>): IOTAEditor;
functionSourceEditor(const Predicate: TFunc<IOTASourceEditor, Boolean> = nil): IToolsApiSourceEditor;
functionFormEditor(const Predicate: TFunc<IOTAFormEditor, Boolean> = nil): IOTAFormEditor;
functionFormDesigner: IToolsApiFormEditor;
end;

 TToolsApiEditView = class(TInterfacedObject, IToolsApiEditView)
private
 FEditorServices: IOTAEditorServices;
public
constructor Create;

functionTopView: IOTAEditView;
functionCursorPosition: TOTAEditPos;

procedureInsertText(const Text: TArray<string>; const Position: TOTAEditPos);
end;

 TToolsApiSourceEditor = class(TInterfacedObject, IToolsApiSourceEditor)
private
 FEditor: IOTASourceEditor;
procedureAddToUses(const UnitNames: TArray<string>; const AddToImplementation: Boolean);
public
constructor Create(const Editor: IOTASourceEditor);

functionGet: IOTASourceEditor;
functionReader: IToolsApiEditReader;
functionWriter: IToolsApiEditWriter;
functionUndoableWriter: IToolsApiEditWriter;

procedureAddToInterfaceUses(const UnitName: string); overload;
procedureAddToInterfaceUses(const UnitNames: TArray<string>); overload;
procedureAddToImplementationUses(const UnitName: string); overload;
procedureAddToImplementationUses(const UnitNames: TArray<string>); overload;
end;

 TToolsApiEditReader = class(TInterfacedObject, IToolsApiEditReader)
private
 FReader: IOTAEditReader;
public
constructor Create(const Reader: IOTAEditReader);

functionGet: IOTAEditReader;
functionContent: string;
end;

 TToolsApiEditWriter = class(TInterfacedObject, IToolsApiEditWriter)
private
 FWriter: IOTAEditWriter;
public
constructor Create(const Writer: IOTAEditWriter);
functionGet: IOTAEditWriter;

procedureInsertText(const Text: string; const Position: Integer); overload;
procedureInsertText(const Text: string; const Position: TOTAEditPos); overload;
end;

 TToolsApiBuildConfigurations = class(TInterfacedObject, IToolsApiBuildConfigurations)
private
 FProject: IOTAProject;
 FConfigurations: IOTAProjectOptionsConfigurations;
public
constructor Create(const Project: IOTAProject);

functionBase: IToolsApiBuildConfiguration;
functionActive: IToolsApiBuildConfiguration;
end;

 TToolsApiEnvironmentOptions = class(TInterfacedObject, IToolsApiEnvironmentOptions)
private
 FOptions: IOTAEnvironmentOptions;
public
constructor Create;

functionGet: IOTAEnvironmentOptions;

functionTryFindOptionName(const OptionName: string; out ExactName: string): Boolean;
functionGetOption(const OptionName: string): Variant;
procedureSetOption(const OptionName: string; constValue: Variant);
end;

 TToolsApiBuildConfiguration = class(TInterfacedObject, IToolsApiBuildConfiguration)
private
 FConfiguration: IOTABuildConfiguration;

functionGetSearchPaths: TArray<string>;
procedureSetSearchPaths(const Paths: TArray<string>);
public
constructor Create(const Configuration: IOTABuildConfiguration);
functionGet: IOTABuildConfiguration;

property SearchPaths: TArray<string> read GetSearchPaths write SetSearchPaths;
end;

implementation

uses
 System.Classes,
 System.IOUtils,
 DCCStrs,
 GDK.ToolsAPI.Debugger,
 GDK.ToolsAPI.FormCreator,
 GDK.ToolsAPI.FormEditor,
 GDK.ToolsAPI.ProjectManagerContextMenu,
 GDK.ToolsAPI.ProjectMatch,
 GDK.ToolsAPI.UsesManager,
 GDK.ToolsAPI.UsesBuilder;

{ TToolsApiHelper }

functionTToolsApiHelper.Project: IToolsApiProject;
begin
 Result := TToolsApiProject.Create;
end;

functionTToolsApiHelper.Project(const Project: IOTAProject): IToolsApiProject;
begin
 Result := TToolsApiProject.Create(Project);
end;

functionTToolsApiHelper.ProjectContextMenu: IToolsApiProjectContextMenu;
begin
 Result := TToolsApiProjectContextMenu.Create;
end;

functionTToolsApiHelper.ProjectGroup: IOTAProjectGroup;
var
 ModuleServices: IOTAModuleServices;
Module: IOTAModule;
 ProjectGroup: IOTAProjectGroup;
 i: Integer;
Begin
 ProjectGroup := nil;

 ModuleServices := (BorlandIDEServices as IOTAModuleServices);
for i := 0to ModuleServices.ModuleCount - 1do
begin
Module := ModuleServices.Modules[i];
if (Module.QueryInterface(IOTAProjectGroup, ProjectGroup) = S_OK) Then
 Break;
end;

 Result := ProjectGroup;
end;

functionTToolsApiHelper.FindProject(const NameOrPath: string): IToolsApiProject;
begin
 Result := nil;

const Group = ProjectGroup;
ifnot Assigned(Group) then
 Exit;

var FileNames: TArray<string>;
 SetLength(FileNames, Group.ProjectCount);
forvar Index := 0to Group.ProjectCount - 1do
 FileNames[Index] := Group.Projects[Index].FileName;

const MatchIndex = TProjectMatch.IndexOf(FileNames, NameOrPath);
if MatchIndex < 0then
 Exit;

 Result := Project(Group.Projects[MatchIndex]);
end;

procedureTToolsApiHelper.SetActiveProject(const Project: IOTAProject);
begin
const Group = ProjectGroup;
if Assigned(Group) then
 Group.ActiveProject := Project;
end;

functionTToolsApiHelper.OpenProject(const FileName: string): IToolsApiProject;
begin
 Result := nil;

ifnot TFile.Exists(FileName) then
 Exit;

const ActionServices = BorlandIDEServices as IOTAActionServices;
const Opened = ActionServices.OpenProject(FileName, False);
ifnot Opened then
 Exit;

 Result := FindProject(FileName);
end;

functionTToolsApiHelper.Module: IToolsApiModule;
begin
 Result := TToolsApiModule.Create;
end;

functionTToolsApiHelper.Module(constModule: IOTAModule): IToolsApiModule;
begin
 Result := TToolsApiModule.Create(Module);
end;

functionTToolsApiHelper.Module(const Index: Integer): IToolsApiModule;
begin
 Result := TToolsApiModule.Create(Index);
end;

functionTToolsApiHelper.ModuleCount: Integer;
var
 ModuleServices: IOTAModuleServices;
begin
 ModuleServices := (BorlandIDEServices as IOTAModuleServices);
 Result := ModuleServices.ModuleCount;
end;

functionTToolsApiHelper.SourceEditor: IToolsApiSourceEditor;
begin
 Result := Self.Module.SourceEditor;
end;

functionTToolsApiHelper.BuildConfigurations: IToolsApiBuildConfigurations;
var
 ActiveProject: IOTAProject;
begin
 ActiveProject := Self.Project.Get;
 Result := TToolsApiBuildConfigurations.Create(ActiveProject);
end;

functionTToolsApiHelper.EnvironmentOptions: IToolsApiEnvironmentOptions;
begin
 Result := TToolsApiEnvironmentOptions.Create;
end;

functionTToolsApiHelper.Debugger: IToolsApiDebugger;
begin
 Result := TToolsApiDebugger.Create;
end;

functionTToolsApiHelper.EditorReader: IToolsApiEditReader;
begin
 Result := Self.SourceEditor.Reader;
end;

functionTToolsApiHelper.EditorWriter: IToolsApiEditWriter;
begin
 Self.SourceEditor.Writer;
end;

functionTToolsApiHelper.EditView: IToolsApiEditView;
begin
ifnot Assigned(FEditView) then
 FEditView := TToolsApiEditView.Create;

 Result := FEditView;
end;

functionTToolsApiHelper.Logger: IToolsApiLogger;
begin
 Result := Self.Logger('');
end;

functionTToolsApiHelper.Logger(const GroupName: string): IToolsApiLogger;
begin
 Result := TToolsApiLogger.Create(GroupName);
end;

procedureTToolsApiHelper.EditorInsertText(const Text: TArray<string>; const Position: TOTAEditPos);
begin
 Self.EditView.InsertText(Text, Position);
end;

procedureTToolsApiHelper.EditorInsertText(const Text: TArray<string>; const AtLine: Integer);
begin
var Lines := string.Join(sLineBreak, Text);
 Self.EditorWriter.InsertText(Lines, AtLine);
end;

functionTToolsApiHelper.EditorPosition: TOTAEditPos;
begin
 Result := Self.EditView.CursorPosition;
end;

functionTToolsApiHelper.EditorContent: string;
begin
 Result := EditorReader.Content;
end;

{ TToolsApiProject }

constructor TToolsApiProject.Create;
begin
inherited Create;
 FProject := GetActiveProject;
 Guard;
end;

constructor TToolsApiProject.Create(const Project: IOTAProject);
begin
inherited Create;
 FProject := Project;
 Guard;
end;

functionTToolsApiProject.Get: IOTAProject;
begin
 Result := FProject;
end;

functionTToolsApiProject.ProjectConfigurations: IOTAProjectOptionsConfigurations;
begin
 Result := FProject.ProjectOptions as IOTAProjectOptionsConfigurations;
end;

functionTToolsApiProject.BuildConfigurations: IToolsApiBuildConfigurations;
begin
 Result := TToolsApiBuildConfigurations.Create(FProject);
end;

functionTToolsApiProject.CreateFormUnit(const UnitFileName: string;
const FormName: string;
const AncestorName: string): IOTAModule;
begin
const Creator: IOTAModuleCreator = TToolsApiFormCreator.Create(FProject, UnitFileName, FormName, AncestorName);
 Result := (BorlandIDEServices as IOTAModuleServices).CreateModule(Creator);
end;

functionTToolsApiProject.Build(const HideProgressDialog: Boolean): Boolean;
const
 ShowCompilerProgressOption = 'ShowCompilerProgress';
var
 EnvironmentOptions: IToolsApiEnvironmentOptions;
 ExactName: string;
 SavedValue: Variant;
begin
ifnot HideProgressDialog then
 Exit(FProject.ProjectBuilder.BuildProject(cmOTABuild, False, True));

// When a build fails, the compile progress dialog stays open as a modal dialog until the
// user dismisses it, and BuildProject only returns after that. Temporarily disabling the
// "Show compiler progress" option keeps unattended builds from blocking.
 EnvironmentOptions := TToolsApiEnvironmentOptions.Create;
ifnot EnvironmentOptions.TryFindOptionName(ShowCompilerProgressOption, ExactName) then
 Exit(FProject.ProjectBuilder.BuildProject(cmOTABuild, False, True));

 SavedValue := EnvironmentOptions.GetOption(ExactName);
 EnvironmentOptions.SetOption(ExactName, False);
try
 Result := FProject.ProjectBuilder.BuildProject(cmOTABuild, False, True);
finally
 EnvironmentOptions.SetOption(ExactName, SavedValue);
end;
end;

procedureTToolsApiProject.Guard;
begin
ifnot Assigned(FProject) then
 raise EToolsApiNoProjectFound.Create('No active project found');
end;

{ TToolsApiModule }

constructor TToolsApiModule.Create;
begin
inherited Create;
 FModule := (BorlandIDEServices as IOTAModuleServices).CurrentModule;
 Guard;
end;

constructor TToolsApiModule.Create(constModule: IOTAModule);
begin
inherited Create;
 FModule := Module;
 Guard;
end;

constructor TToolsApiModule.Create(const Index: Integer);
begin
inherited Create;
 FModule := (BorlandIDEServices as IOTAModuleServices).Modules[Index];
 Guard;
end;

functionTToolsApiModule.Get: IOTAModule;
begin
 Result := FModule;
end;

functionTToolsApiModule.FileCount: Integer;
begin
 Result := FModule.GetModuleFileCount;
end;

functionTToolsApiModule.FileName: string;
begin
 Result := FModule.FileName;
end;

procedureTToolsApiModule.Refresh(const ForceRefresh: Boolean);
begin
 FModule.Refresh(ForceRefresh);
end;

functionTToolsApiModule.IsDirty: Boolean;
begin
 Result := False;

forvar Index := 0to FileCount - 1do
begin
const ModuleEditor = FModule.GetModuleFileEditor(Index);
if Assigned(ModuleEditor) and ModuleEditor.Modified then
 Exit(True);
end;
end;

functionTToolsApiModule.ReadSourceFromBuffer(out Source: string): Boolean;
const
 ChunkSize = 4096;
begin
 Source := '';

var Editor: IOTAEditor := nil;
forvar Index := 0to FileCount - 1do
begin
const Candidate = FModule.GetModuleFileEditor(Index);
if Supports(Candidate, IOTASourceEditor) then
begin
 Editor := Candidate;
 Break;
end;
end;

ifnot Assigned(Editor) then
 Exit(False);

const Reader = (Editor as IOTASourceEditor).CreateReader;

var Bytes: TBytes := nil;
var Position := 0;
var Chunk: TBytes;
 SetLength(Chunk, ChunkSize);

var BytesRead := Reader.GetText(Position, @Chunk[0], ChunkSize);
while BytesRead > 0do
begin
 Bytes := Bytes + Copy(Chunk, 0, BytesRead);
 Position := Position + BytesRead;

if BytesRead < ChunkSize then
 Break;

 BytesRead := Reader.GetText(Position, @Chunk[0], ChunkSize);
end;

 Source := TEncoding.UTF8.GetString(Bytes);
 Result := True;
end;

functionTToolsApiModule.MatchesDisk: Boolean;
begin
const FilePath = FModule.FileName;
if (FilePath = '') or (not FileExists(FilePath)) then
 Exit(True);

var BufferSource: string;
ifnot ReadSourceFromBuffer(BufferSource) then
 Exit(True);

const BufferNormalized = StringReplace(BufferSource, #13#10, #10, [rfReplaceAll]).TrimRight;

var DiskSource := '';
try
 DiskSource := TFile.ReadAllText(FilePath);
except
 Exit(True);
end;

const DiskNormalized = StringReplace(DiskSource, #13#10, #10, [rfReplaceAll]).TrimRight;
 Result := (BufferNormalized = DiskNormalized);
end;

procedureTToolsApiModule.SyncWithDisk;
begin
if MatchesDisk then
 Exit;

if IsDirty then
 raise EToolsApiModuleOutOfSync.CreateFmt(
'%s has unsaved changes in the IDE and a different version on disk', [FModule.FileName]);

 FModule.Refresh(True);
end;

functionTToolsApiModule.Editor(const Predicate: TFunc<IOTAEditor, Boolean>): IOTAEditor;
var
 i: Integer;
 Editor: IOTAEditor;
begin
 Result := nil;

for i := 0to FileCount - 1do
begin
 Editor := FModule.GetModuleFileEditor(i);
if Assigned(Predicate) andnot Predicate(Editor) then
 Continue;

 Result := Editor;
 Break;
end;

ifnot Assigned(Result) then
 raise EToolsApiNoEditorFound.Create('No editor found.');
end;

functionTToolsApiModule.SourceEditor(const Predicate: TFunc<IOTASourceEditor, Boolean>): IToolsApiSourceEditor;
var
 Found: IOTAEditor;
 SourceEditor: IOTASourceEditor;
begin
 Found := Editor(
 function(Editor: IOTAEditor): Boolean
begin
 Result := Supports(Editor, IOTASourceEditor);
end);

 SourceEditor := Found as IOTASourceEditor;
 Result := TToolsApiSourceEditor.Create(SourceEditor);
end;

functionTToolsApiModule.FormEditor(const Predicate: TFunc<IOTAFormEditor, Boolean>): IOTAFormEditor;
var
 Found: IOTAEditor;
begin
 Found := Editor(
 function(Editor: IOTAEditor): Boolean
begin
 Result := Supports(Editor, IOTAFormEditor);
end);

 Result := Found as IOTAFormEditor;
end;

functionTToolsApiModule.FormDesigner: IToolsApiFormEditor;
begin
 Result := TToolsApiFormEditor.Create(FormEditor(nil));
end;

procedureTToolsApiModule.Guard;
begin
ifnot Assigned(FModule) then
 raise EToolsApiNoModuleFound.Create('No active module found.');
end;

{ TToolsApiSourceEditor }

constructor TToolsApiSourceEditor.Create(const Editor: IOTASourceEditor);
begin
inherited Create;
 FEditor := Editor;
end;

functionTToolsApiSourceEditor.Get: IOTASourceEditor;
begin
 Result := FEditor;
end;

functionTToolsApiSourceEditor.Reader: IToolsApiEditReader;
var
 Reader: IOTAEditReader;
begin
 Reader := FEditor.CreateReader;
 Result := TToolsApiEditReader.Create(Reader);
end;

functionTToolsApiSourceEditor.Writer: IToolsApiEditWriter;
begin
var Writer := FEditor.CreateWriter;
 Result := TToolsApiEditWriter.Create(Writer);
end;

functionTToolsApiSourceEditor.UndoableWriter: IToolsApiEditWriter;
begin
var Writer := FEditor.CreateUndoableWriter;
 Result := TToolsApiEditWriter.Create(Writer);
end;

procedureTToolsApiSourceEditor.AddToInterfaceUses(const UnitName: string);
begin
 AddToUses([UnitName], False);
end;

procedureTToolsApiSourceEditor.AddToInterfaceUses(const UnitNames: TArray<string>);
begin
 AddToUses(UnitNames, False);
end;

procedureTToolsApiSourceEditor.AddToImplementationUses(const UnitName: string);
begin
 AddToUses([UnitName], True);
end;

procedureTToolsApiSourceEditor.AddToImplementationUses(const UnitNames: TArray<string>);
begin
 AddToUses(UnitNames, True);
end;

procedureTToolsApiSourceEditor.AddToUses(const UnitNames: TArray<string>; const AddToImplementation: Boolean);
begin
var UsesBuilder := TToolsAPIUsesBuilder.Use;

if AddToImplementation then
 UsesBuilder.InImplementation
else
 UsesBuilder.InInterface;

var EditorContent := Self.Reader.Content;

var UsesToWrite := UsesBuilder
 .WithSource(EditorContent)
 .Build(UnitNames);

if UsesToWrite.CanWrite then
 Self.UndoableWriter.InsertText(UsesToWrite.Text, UsesToWrite.Position);
end;

{ TToolsApiEditReader }

constructor TToolsApiEditReader.Create(const Reader: IOTAEditReader);
begin
inherited Create;
 FReader := Reader;
end;

functionTToolsApiEditReader.Get: IOTAEditReader;
begin
 Result := FReader;
end;

functionTToolsApiEditReader.Content: string;
const
 BufferSize: Integer = 1024;
var
 Read: Integer;
 Position: Integer;
 Buffer: AnsiString;
begin
 Result := '';

 Position := 0;
repeat
 SetLength(Buffer, BufferSize);

 Read := FReader.GetText(Position, PAnsiChar(Buffer), BufferSize);
 SetLength(Buffer, Read);

 Result := Result + string(Buffer);
 Inc(Position, Read);

until (Read < BufferSize);
end;

{ TToolsApiBuildConfiguration }

constructor TToolsApiBuildConfiguration.Create(const Configuration: IOTABuildConfiguration);
begin
inherited Create;
 FConfiguration := Configuration;
end;

functionTToolsApiBuildConfiguration.Get: IOTABuildConfiguration;
begin
 Result := FConfiguration;
end;

functionTToolsApiBuildConfiguration.GetSearchPaths: TArray<string>;
var
 Paths: TStringList;
begin
 Paths := TStringList.Create;
try
 FConfiguration.GetValues(DCCStrs.sUnitSearchPath, Paths, True);

 Result := Paths.ToStringArray;
finally
 Paths.Free;
end;
end;

procedureTToolsApiBuildConfiguration.SetSearchPaths(const Paths: TArray<string>);
var
 SearchPaths: TStringList;
begin
 SearchPaths := TStringList.Create;
try
 SearchPaths.AddStrings(Paths);
 FConfiguration.SetValues(sUnitSearchPath, SearchPaths);
finally
 SearchPaths.Free;
end;
end;

{ TToolsApiEnvironmentOptions }

constructor TToolsApiEnvironmentOptions.Create;
begin
inherited Create;
 FOptions := (BorlandIDEServices as IOTAServices).GetEnvironmentOptions;
end;

functionTToolsApiEnvironmentOptions.Get: IOTAEnvironmentOptions;
begin
 Result := FOptions;
end;

functionTToolsApiEnvironmentOptions.TryFindOptionName(const OptionName: string; out ExactName: string): Boolean;
var
 Names: TOTAOptionNameArray;
 Entry: TOTAOptionName;
begin
 Result := False;
 ExactName := '';

 Names := FOptions.GetOptionNames;
for Entry in Names do
begin
if SameText(Entry.Name, OptionName) then
begin
 ExactName := Entry.Name;
 Exit(True);
end;
end;
end;

functionTToolsApiEnvironmentOptions.GetOption(const OptionName: string): Variant;
begin
 Result := FOptions.Values[OptionName];
end;

procedureTToolsApiEnvironmentOptions.SetOption(const OptionName: string; constValue: Variant);
begin
 FOptions.Values[OptionName] := Value;
end;

{ TToolsApiEditWriter }

constructor TToolsApiEditWriter.Create(const Writer: IOTAEditWriter);
begin
inherited Create;
 FWriter := Writer;
end;

functionTToolsApiEditWriter.Get: IOTAEditWriter;
begin
 Result := FWriter;
end;

procedureTToolsApiEditWriter.InsertText(const Text: string; const Position: Integer);
begin
 FWriter.CopyTo(Position);
 FWriter.Insert(PAnsiChar(AnsiString(Text)));
end;

procedureTToolsApiEditWriter.InsertText(const Text: string; const Position: TOTAEditPos);
var
 EditView: IToolsApiEditView;
begin
 EditView := TToolsApiEditView.Create;
 EditView.InsertText([Text], Position);
end;

{ TToolsApiEditView }

constructor TToolsApiEditView.Create;
begin
inherited Create;
 FEditorServices := (BorlandIDEServices as IOTAEditorServices);
end;

functionTToolsApiEditView.TopView: IOTAEditView;
begin
 Result := FEditorServices.TopView;
ifnot Assigned(Result) then
 raise EToolsApiNoEditViewFound.Create('No edit view found.');
end;

functionTToolsApiEditView.CursorPosition: TOTAEditPos;
begin
 Result := TopView.CursorPos;
end;

procedureTToolsApiEditView.InsertText(const Text: TArray<string>; const Position: TOTAEditPos);
var
 Line: string;
 EditView: IOTAEditView;
 LineNumber, Col: Integer;
begin
 EditView := TopView;

 LineNumber := Position.Line;
 Col := Position.Col;

for Line in Text do
begin
 EditView.Buffer.EditPosition.Move(LineNumber, Col);
 EditView.Buffer.EditPosition.InsertText(Line + sLineBreak);

 Inc(LineNumber);
end;
end;

{ TToolsApiBuildConfigurations }

constructor TToolsApiBuildConfigurations.Create(const Project: IOTAProject);
begin
inherited Create;
 FProject := Project;
 FConfigurations := FProject.ProjectOptions as IOTAProjectOptionsConfigurations;
end;

functionTToolsApiBuildConfigurations.Active: IToolsApiBuildConfiguration;
var
 Config: IOTABuildConfiguration;
begin
 Config := FConfigurations.ActiveConfiguration;
 Result := TToolsApiBuildConfiguration.Create(Config);
end;

functionTToolsApiBuildConfigurations.Base: IToolsApiBuildConfiguration;
var
 Config: IOTABuildConfiguration;
begin
 Config := FConfigurations.BaseConfiguration;
 Result := TToolsApiBuildConfiguration.Create(Config);
end;

{ TToolsApiLogger }

constructor TToolsApiLogger.Create(const GroupName: string);
begin
inherited Create;
 FGroupName := GroupName;
end;

functionTToolsApiLogger.Custom: TCustomMessage;
var
 CustomGroup: IOTAMessageGroup;
begin
 CustomGroup := GetGroup;
 Result := TCustomMessage.Create(CustomGroup);
end;

functionTToolsApiLogger.UsesCustomGroup: Boolean;
begin
 Result := (not FGroupName.IsEmpty);
end;

functionTToolsApiLogger.GetGroup: IOTAMessageGroup;
begin
ifnot Self.UsesCustomGroup then
 raise EToolsApiNoCustomLogGroupUsed.Create('No custom logging group is used');

 Result := (BorlandIDEServices As IOTAMessageServices).AddMessageGroup(FGroupName);
end;

procedureTToolsApiLogger.Clear;
var
 CustomGroup: IOTAMessageGroup;
begin
ifnot Self.UsesCustomGroup then
 Exit;

 CustomGroup := (BorlandIDEServices As IOTAMessageServices).GetGroup(FGroupName);
 (BorlandIDEServices As IOTAMessageServices).ClearMessageGroup(CustomGroup);
end;

procedureTToolsApiLogger.Log(const Text: string; const Params: arrayofconst);
var
 FormattedText: string;
begin
 FormattedText := Format(Text, Params);
 Log(FormattedText);
end;

procedureTToolsApiLogger.Log(const Text: string);
var
 LineRef: Pointer;
 CustomGroup: IOTAMessageGroup;
begin
if Self.UsesCustomGroup then
 CustomGroup := GetGroup
else
 CustomGroup := nil;

 (BorlandIDEServices As IOTAMessageServices).AddToolMessage('', Text, '', 1, 1, nil, LineRef, CustomGroup);
end;

end.
unit GDK.ToolsAPI.Helper;

interface

uses
 ToolsAPI,
 GDK.ToolsAPI.Helper.Interfaces,
 GDK.ToolsAPI.Debugger.Interfaces,
 System.SysUtils,
 GDK.ToolsAPI.CustomMessage;

type
 TToolsApiHelper = class(TInterfacedObject, IToolsApiHelper)
private
 FEditView: IToolsApiEditView;
public
functionLogger: IToolsApiLogger; overload;
functionLogger(const GroupName: string): IToolsApiLogger; overload;

functionProjectGroup: IOTAProjectGroup;

functionProject: IToolsApiProject; overload;
functionProject(const Project: IOTAProject): IToolsApiProject; overload;

functionFindProject(const NameOrPath: string): IToolsApiProject;
procedureSetActiveProject(const Project: IOTAProject);
functionOpenProject(const FileName: string): IToolsApiProject;

functionProjectContextMenu: IToolsApiProjectContextMenu;

functionBuildConfigurations: IToolsApiBuildConfigurations;
functionEnvironmentOptions: IToolsApiEnvironmentOptions;
functionDebugger: IToolsApiDebugger;

functionModuleCount: Integer;
functionModule: IToolsApiModule; overload;
functionModule(constModule: IOTAModule): IToolsApiModule; overload;
functionModule(const Index: Integer): IToolsApiModule; overload;

functionSourceEditor: IToolsApiSourceEditor;
functionEditorReader: IToolsApiEditReader;
functionEditorWriter: IToolsApiEditWriter;

procedureEditorInsertText(const Text: TArray<string>; const Position: TOTAEditPos); overload;
procedureEditorInsertText(const Text: TArray<string>; const AtLine: Integer); overload;

functionEditorPosition: TOTAEditPos;
functionEditorContent: string;

functionEditView: IToolsApiEditView;
end;

 TToolsApiLogger = class(TInterfacedObject, IToolsApiLogger)
private
 FGroupName: string;
public
constructor Create(const GroupName: string);

functionUsesCustomGroup: Boolean;
functionGetGroup: IOTAMessageGroup;

procedureClear;

procedureLog(const Text: string); overload;
procedureLog(const Text: string; const Params: arrayofconst); overload;

functionCustom: TCustomMessage;
end;

 TToolsApiProject = class(TInterfacedObject, IToolsApiProject)
private
 FProject: IOTAProject;
procedureGuard;
public
constructor Create; overload;
constructor Create(const Project: IOTAProject); overload;

functionGet: IOTAProject;

functionProjectConfigurations: IOTAProjectOptionsConfigurations;
functionBuildConfigurations: IToolsApiBuildConfigurations;

functionBuild(const HideProgressDialog: Boolean = False): Boolean;

functionCreateFormUnit(const UnitFileName: string;
const FormName: string;
const AncestorName: string = ''): IOTAModule;
end;

 TToolsApiModule = class(TInterfacedObject, IToolsApiModule)
private
 FModule: IOTAModule;
procedureGuard;
functionReadSourceFromBuffer(out Source: string): Boolean;
public
constructor Create; overload;
constructor Create(constModule: IOTAModule); overload;
constructor Create(const Index: Integer); overload;

functionGet: IOTAModule;
functionFileCount: Integer;
functionFileName: string;
procedureRefresh(const ForceRefresh: Boolean);

functionIsDirty: Boolean;
functionMatchesDisk: Boolean;
procedureSyncWithDisk;

functionEditor(const Predicate: TFunc<IOTAEditor, Boolean>): IOTAEditor;
functionSourceEditor(const Predicate: TFunc<IOTASourceEditor, Boolean> = nil): IToolsApiSourceEditor;
functionFormEditor(const Predicate: TFunc<IOTAFormEditor, Boolean> = nil): IOTAFormEditor;
functionFormDesigner: IToolsApiFormEditor;
end;

 TToolsApiEditView = class(TInterfacedObject, IToolsApiEditView)
private
 FEditorServices: IOTAEditorServices;
public
constructor Create;

functionTopView: IOTAEditView;
functionCursorPosition: TOTAEditPos;

procedureInsertText(const Text: TArray<string>; const Position: TOTAEditPos);
end;

 TToolsApiSourceEditor = class(TInterfacedObject, IToolsApiSourceEditor)
private
 FEditor: IOTASourceEditor;
procedureAddToUses(const UnitNames: TArray<string>; const AddToImplementation: Boolean);
public
constructor Create(const Editor: IOTASourceEditor);

functionGet: IOTASourceEditor;
functionReader: IToolsApiEditReader;
functionWriter: IToolsApiEditWriter;
functionUndoableWriter: IToolsApiEditWriter;

procedureAddToInterfaceUses(const UnitName: string); overload;
procedureAddToInterfaceUses(const UnitNames: TArray<string>); overload;
procedureAddToImplementationUses(const UnitName: string); overload;
procedureAddToImplementationUses(const UnitNames: TArray<string>); overload;
end;

 TToolsApiEditReader = class(TInterfacedObject, IToolsApiEditReader)
private
 FReader: IOTAEditReader;
public
constructor Create(const Reader: IOTAEditReader);

functionGet: IOTAEditReader;
functionContent: string;
end;

 TToolsApiEditWriter = class(TInterfacedObject, IToolsApiEditWriter)
private
 FWriter: IOTAEditWriter;
public
constructor Create(const Writer: IOTAEditWriter);
functionGet: IOTAEditWriter;

procedureInsertText(const Text: string; const Position: Integer); overload;
procedureInsertText(const Text: string; const Position: TOTAEditPos); overload;
end;

 TToolsApiBuildConfigurations = class(TInterfacedObject, IToolsApiBuildConfigurations)
private
 FProject: IOTAProject;
 FConfigurations: IOTAProjectOptionsConfigurations;
public
constructor Create(const Project: IOTAProject);

functionBase: IToolsApiBuildConfiguration;
functionActive: IToolsApiBuildConfiguration;
end;

 TToolsApiEnvironmentOptions = class(TInterfacedObject, IToolsApiEnvironmentOptions)
private
 FOptions: IOTAEnvironmentOptions;
public
constructor Create;

functionGet: IOTAEnvironmentOptions;

functionTryFindOptionName(const OptionName: string; out ExactName: string): Boolean;
functionGetOption(const OptionName: string): Variant;
procedureSetOption(const OptionName: string; constValue: Variant);
end;

 TToolsApiBuildConfiguration = class(TInterfacedObject, IToolsApiBuildConfiguration)
private
 FConfiguration: IOTABuildConfiguration;

functionGetSearchPaths: TArray<string>;
procedureSetSearchPaths(const Paths: TArray<string>);
public
constructor Create(const Configuration: IOTABuildConfiguration);
functionGet: IOTABuildConfiguration;

property SearchPaths: TArray<string> read GetSearchPaths write SetSearchPaths;
end;

implementation

uses
 System.Classes,
 System.IOUtils,
 DCCStrs,
 GDK.ToolsAPI.Debugger,
 GDK.ToolsAPI.FormCreator,
 GDK.ToolsAPI.FormEditor,
 GDK.ToolsAPI.ProjectManagerContextMenu,
 GDK.ToolsAPI.ProjectMatch,
 GDK.ToolsAPI.UsesManager,
 GDK.ToolsAPI.UsesBuilder;

{ TToolsApiHelper }

functionTToolsApiHelper.Project: IToolsApiProject;
begin
 Result := TToolsApiProject.Create;
end;

functionTToolsApiHelper.Project(const Project: IOTAProject): IToolsApiProject;
begin
 Result := TToolsApiProject.Create(Project);
end;

functionTToolsApiHelper.ProjectContextMenu: IToolsApiProjectContextMenu;
begin
 Result := TToolsApiProjectContextMenu.Create;
end;

functionTToolsApiHelper.ProjectGroup: IOTAProjectGroup;
var
 ModuleServices: IOTAModuleServices;
Module: IOTAModule;
 ProjectGroup: IOTAProjectGroup;
 i: Integer;
Begin
 ProjectGroup := nil;

 ModuleServices := (BorlandIDEServices as IOTAModuleServices);
for i := 0to ModuleServices.ModuleCount - 1do
begin
Module := ModuleServices.Modules[i];
if (Module.QueryInterface(IOTAProjectGroup, ProjectGroup) = S_OK) Then
 Break;
end;

 Result := ProjectGroup;
end;

functionTToolsApiHelper.FindProject(const NameOrPath: string): IToolsApiProject;
begin
 Result := nil;

const Group = ProjectGroup;
ifnot Assigned(Group) then
 Exit;

var FileNames: TArray<string>;
 SetLength(FileNames, Group.ProjectCount);
forvar Index := 0to Group.ProjectCount - 1do
 FileNames[Index] := Group.Projects[Index].FileName;

const MatchIndex = TProjectMatch.IndexOf(FileNames, NameOrPath);
if MatchIndex < 0then
 Exit;

 Result := Project(Group.Projects[MatchIndex]);
end;

procedureTToolsApiHelper.SetActiveProject(const Project: IOTAProject);
begin
const Group = ProjectGroup;
if Assigned(Group) then
 Group.ActiveProject := Project;
end;

functionTToolsApiHelper.OpenProject(const FileName: string): IToolsApiProject;
begin
 Result := nil;

ifnot TFile.Exists(FileName) then
 Exit;

const ActionServices = BorlandIDEServices as IOTAActionServices;
const Opened = ActionServices.OpenProject(FileName, False);
ifnot Opened then
 Exit;

 Result := FindProject(FileName);
end;

functionTToolsApiHelper.Module: IToolsApiModule;
begin
 Result := TToolsApiModule.Create;
end;

functionTToolsApiHelper.Module(constModule: IOTAModule): IToolsApiModule;
begin
 Result := TToolsApiModule.Create(Module);
end;

functionTToolsApiHelper.Module(const Index: Integer): IToolsApiModule;
begin
 Result := TToolsApiModule.Create(Index);
end;

functionTToolsApiHelper.ModuleCount: Integer;
var
 ModuleServices: IOTAModuleServices;
begin
 ModuleServices := (BorlandIDEServices as IOTAModuleServices);
 Result := ModuleServices.ModuleCount;
end;

functionTToolsApiHelper.SourceEditor: IToolsApiSourceEditor;
begin
 Result := Self.Module.SourceEditor;
end;

functionTToolsApiHelper.BuildConfigurations: IToolsApiBuildConfigurations;
var
 ActiveProject: IOTAProject;
begin
 ActiveProject := Self.Project.Get;
 Result := TToolsApiBuildConfigurations.Create(ActiveProject);
end;

functionTToolsApiHelper.EnvironmentOptions: IToolsApiEnvironmentOptions;
begin
 Result := TToolsApiEnvironmentOptions.Create;
end;

functionTToolsApiHelper.Debugger: IToolsApiDebugger;
begin
 Result := TToolsApiDebugger.Create;
end;

functionTToolsApiHelper.EditorReader: IToolsApiEditReader;
begin
 Result := Self.SourceEditor.Reader;
end;

functionTToolsApiHelper.EditorWriter: IToolsApiEditWriter;
begin
 Self.SourceEditor.Writer;
end;

functionTToolsApiHelper.EditView: IToolsApiEditView;
begin
ifnot Assigned(FEditView) then
 FEditView := TToolsApiEditView.Create;

 Result := FEditView;
end;

functionTToolsApiHelper.Logger: IToolsApiLogger;
begin
 Result := Self.Logger('');
end;

functionTToolsApiHelper.Logger(const GroupName: string): IToolsApiLogger;
begin
 Result := TToolsApiLogger.Create(GroupName);
end;

procedureTToolsApiHelper.EditorInsertText(const Text: TArray<string>; const Position: TOTAEditPos);
begin
 Self.EditView.InsertText(Text, Position);
end;

procedureTToolsApiHelper.EditorInsertText(const Text: TArray<string>; const AtLine: Integer);
begin
var Lines := string.Join(sLineBreak, Text);
 Self.EditorWriter.InsertText(Lines, AtLine);
end;

functionTToolsApiHelper.EditorPosition: TOTAEditPos;
begin
 Result := Self.EditView.CursorPosition;
end;

functionTToolsApiHelper.EditorContent: string;
begin
 Result := EditorReader.Content;
end;

{ TToolsApiProject }

constructor TToolsApiProject.Create;
begin
inherited Create;
 FProject := GetActiveProject;
 Guard;
end;

constructor TToolsApiProject.Create(const Project: IOTAProject);
begin
inherited Create;
 FProject := Project;
 Guard;
end;

functionTToolsApiProject.Get: IOTAProject;
begin
 Result := FProject;
end;

functionTToolsApiProject.ProjectConfigurations: IOTAProjectOptionsConfigurations;
begin
 Result := FProject.ProjectOptions as IOTAProjectOptionsConfigurations;
end;

functionTToolsApiProject.BuildConfigurations: IToolsApiBuildConfigurations;
begin
 Result := TToolsApiBuildConfigurations.Create(FProject);
end;

functionTToolsApiProject.CreateFormUnit(const UnitFileName: string;
const FormName: string;
const AncestorName: string): IOTAModule;
begin
const Creator: IOTAModuleCreator = TToolsApiFormCreator.Create(FProject, UnitFileName, FormName, AncestorName);
 Result := (BorlandIDEServices as IOTAModuleServices).CreateModule(Creator);
end;

functionTToolsApiProject.Build(const HideProgressDialog: Boolean): Boolean;
const
 ShowCompilerProgressOption = 'ShowCompilerProgress';
var
 EnvironmentOptions: IToolsApiEnvironmentOptions;
 ExactName: string;
 SavedValue: Variant;
begin
ifnot HideProgressDialog then
 Exit(FProject.ProjectBuilder.BuildProject(cmOTABuild, False, True));

// When a build fails, the compile progress dialog stays open as a modal dialog until the
// user dismisses it, and BuildProject only returns after that. Temporarily disabling the
// "Show compiler progress" option keeps unattended builds from blocking.
 EnvironmentOptions := TToolsApiEnvironmentOptions.Create;
ifnot EnvironmentOptions.TryFindOptionName(ShowCompilerProgressOption, ExactName) then
 Exit(FProject.ProjectBuilder.BuildProject(cmOTABuild, False, True));

 SavedValue := EnvironmentOptions.GetOption(ExactName);
 EnvironmentOptions.SetOption(ExactName, False);
try
 Result := FProject.ProjectBuilder.BuildProject(cmOTABuild, False, True);
finally
 EnvironmentOptions.SetOption(ExactName, SavedValue);
end;
end;

procedureTToolsApiProject.Guard;
begin
ifnot Assigned(FProject) then
 raise EToolsApiNoProjectFound.Create('No active project found');
end;

{ TToolsApiModule }

constructor TToolsApiModule.Create;
begin
inherited Create;
 FModule := (BorlandIDEServices as IOTAModuleServices).CurrentModule;
 Guard;
end;

constructor TToolsApiModule.Create(constModule: IOTAModule);
begin
inherited Create;
 FModule := Module;
 Guard;
end;

constructor TToolsApiModule.Create(const Index: Integer);
begin
inherited Create;
 FModule := (BorlandIDEServices as IOTAModuleServices).Modules[Index];
 Guard;
end;

functionTToolsApiModule.Get: IOTAModule;
begin
 Result := FModule;
end;

functionTToolsApiModule.FileCount: Integer;
begin
 Result := FModule.GetModuleFileCount;
end;

functionTToolsApiModule.FileName: string;
begin
 Result := FModule.FileName;
end;

procedureTToolsApiModule.Refresh(const ForceRefresh: Boolean);
begin
 FModule.Refresh(ForceRefresh);
end;

functionTToolsApiModule.IsDirty: Boolean;
begin
 Result := False;

forvar Index := 0to FileCount - 1do
begin
const ModuleEditor = FModule.GetModuleFileEditor(Index);
if Assigned(ModuleEditor) and ModuleEditor.Modified then
 Exit(True);
end;
end;

functionTToolsApiModule.ReadSourceFromBuffer(out Source: string): Boolean;
const
 ChunkSize = 4096;
begin
 Source := '';

var Editor: IOTAEditor := nil;
forvar Index := 0to FileCount - 1do
begin
const Candidate = FModule.GetModuleFileEditor(Index);
if Supports(Candidate, IOTASourceEditor) then
begin
 Editor := Candidate;
 Break;
end;
end;

ifnot Assigned(Editor) then
 Exit(False);

const Reader = (Editor as IOTASourceEditor).CreateReader;

var Bytes: TBytes := nil;
var Position := 0;
var Chunk: TBytes;
 SetLength(Chunk, ChunkSize);

var BytesRead := Reader.GetText(Position, @Chunk[0], ChunkSize);
while BytesRead > 0do
begin
 Bytes := Bytes + Copy(Chunk, 0, BytesRead);
 Position := Position + BytesRead;

if BytesRead < ChunkSize then
 Break;

 BytesRead := Reader.GetText(Position, @Chunk[0], ChunkSize);
end;

 Source := TEncoding.UTF8.GetString(Bytes);
 Result := True;
end;

functionTToolsApiModule.MatchesDisk: Boolean;
begin
const FilePath = FModule.FileName;
if (FilePath = '') or (not FileExists(FilePath)) then
 Exit(True);

var BufferSource: string;
ifnot ReadSourceFromBuffer(BufferSource) then
 Exit(True);

const BufferNormalized = StringReplace(BufferSource, #13#10, #10, [rfReplaceAll]).TrimRight;

var DiskSource := '';
try
 DiskSource := TFile.ReadAllText(FilePath);
except
 Exit(True);
end;

const DiskNormalized = StringReplace(DiskSource, #13#10, #10, [rfReplaceAll]).TrimRight;
 Result := (BufferNormalized = DiskNormalized);
end;

procedureTToolsApiModule.SyncWithDisk;
begin
if MatchesDisk then
 Exit;

if IsDirty then
 raise EToolsApiModuleOutOfSync.CreateFmt(
'%s has unsaved changes in the IDE and a different version on disk', [FModule.FileName]);

 FModule.Refresh(True);
end;

functionTToolsApiModule.Editor(const Predicate: TFunc<IOTAEditor, Boolean>): IOTAEditor;
var
 i: Integer;
 Editor: IOTAEditor;
begin
 Result := nil;

for i := 0to FileCount - 1do
begin
 Editor := FModule.GetModuleFileEditor(i);
if Assigned(Predicate) andnot Predicate(Editor) then
 Continue;

 Result := Editor;
 Break;
end;

ifnot Assigned(Result) then
 raise EToolsApiNoEditorFound.Create('No editor found.');
end;

functionTToolsApiModule.SourceEditor(const Predicate: TFunc<IOTASourceEditor, Boolean>): IToolsApiSourceEditor;
var
 Found: IOTAEditor;
 SourceEditor: IOTASourceEditor;
begin
 Found := Editor(
 function(Editor: IOTAEditor): Boolean
begin
 Result := Supports(Editor, IOTASourceEditor);
end);

 SourceEditor := Found as IOTASourceEditor;
 Result := TToolsApiSourceEditor.Create(SourceEditor);
end;

functionTToolsApiModule.FormEditor(const Predicate: TFunc<IOTAFormEditor, Boolean>): IOTAFormEditor;
var
 Found: IOTAEditor;
begin
 Found := Editor(
 function(Editor: IOTAEditor): Boolean
begin
 Result := Supports(Editor, IOTAFormEditor);
end);

 Result := Found as IOTAFormEditor;
end;

functionTToolsApiModule.FormDesigner: IToolsApiFormEditor;
begin
 Result := TToolsApiFormEditor.Create(FormEditor(nil));
end;

procedureTToolsApiModule.Guard;
begin
ifnot Assigned(FModule) then
 raise EToolsApiNoModuleFound.Create('No active module found.');
end;

{ TToolsApiSourceEditor }

constructor TToolsApiSourceEditor.Create(const Editor: IOTASourceEditor);
begin
inherited Create;
 FEditor := Editor;
end;

functionTToolsApiSourceEditor.Get: IOTASourceEditor;
begin
 Result := FEditor;
end;

functionTToolsApiSourceEditor.Reader: IToolsApiEditReader;
var
 Reader: IOTAEditReader;
begin
 Reader := FEditor.CreateReader;
 Result := TToolsApiEditReader.Create(Reader);
end;

functionTToolsApiSourceEditor.Writer: IToolsApiEditWriter;
begin
var Writer := FEditor.CreateWriter;
 Result := TToolsApiEditWriter.Create(Writer);
end;

functionTToolsApiSourceEditor.UndoableWriter: IToolsApiEditWriter;
begin
var Writer := FEditor.CreateUndoableWriter;
 Result := TToolsApiEditWriter.Create(Writer);
end;

procedureTToolsApiSourceEditor.AddToInterfaceUses(const UnitName: string);
begin
 AddToUses([UnitName], False);
end;

procedureTToolsApiSourceEditor.AddToInterfaceUses(const UnitNames: TArray<string>);
begin
 AddToUses(UnitNames, False);
end;

procedureTToolsApiSourceEditor.AddToImplementationUses(const UnitName: string);
begin
 AddToUses([UnitName], True);
end;

procedureTToolsApiSourceEditor.AddToImplementationUses(const UnitNames: TArray<string>);
begin
 AddToUses(UnitNames, True);
end;

procedureTToolsApiSourceEditor.AddToUses(const UnitNames: TArray<string>; const AddToImplementation: Boolean);
begin
var UsesBuilder := TToolsAPIUsesBuilder.Use;

if AddToImplementation then
 UsesBuilder.InImplementation
else
 UsesBuilder.InInterface;

var EditorContent := Self.Reader.Content;

var UsesToWrite := UsesBuilder
 .WithSource(EditorContent)
 .Build(UnitNames);

if UsesToWrite.CanWrite then
 Self.UndoableWriter.InsertText(UsesToWrite.Text, UsesToWrite.Position);
end;

{ TToolsApiEditReader }

constructor TToolsApiEditReader.Create(const Reader: IOTAEditReader);
begin
inherited Create;
 FReader := Reader;
end;

functionTToolsApiEditReader.Get: IOTAEditReader;
begin
 Result := FReader;
end;

functionTToolsApiEditReader.Content: string;
const
 BufferSize: Integer = 1024;
var
 Read: Integer;
 Position: Integer;
 Buffer: AnsiString;
begin
 Result := '';

 Position := 0;
repeat
 SetLength(Buffer, BufferSize);

 Read := FReader.GetText(Position, PAnsiChar(Buffer), BufferSize);
 SetLength(Buffer, Read);

 Result := Result + string(Buffer);
 Inc(Position, Read);

until (Read < BufferSize);
end;

{ TToolsApiBuildConfiguration }

constructor TToolsApiBuildConfiguration.Create(const Configuration: IOTABuildConfiguration);
begin
inherited Create;
 FConfiguration := Configuration;
end;

functionTToolsApiBuildConfiguration.Get: IOTABuildConfiguration;
begin
 Result := FConfiguration;
end;

functionTToolsApiBuildConfiguration.GetSearchPaths: TArray<string>;
var
 Paths: TStringList;
begin
 Paths := TStringList.Create;
try
 FConfiguration.GetValues(DCCStrs.sUnitSearchPath, Paths, True);

 Result := Paths.ToStringArray;
finally
 Paths.Free;
end;
end;

procedureTToolsApiBuildConfiguration.SetSearchPaths(const Paths: TArray<string>);
var
 SearchPaths: TStringList;
begin
 SearchPaths := TStringList.Create;
try
 SearchPaths.AddStrings(Paths);
 FConfiguration.SetValues(sUnitSearchPath, SearchPaths);
finally
 SearchPaths.Free;
end;
end;

{ TToolsApiEnvironmentOptions }

constructor TToolsApiEnvironmentOptions.Create;
begin
inherited Create;
 FOptions := (BorlandIDEServices as IOTAServices).GetEnvironmentOptions;
end;

functionTToolsApiEnvironmentOptions.Get: IOTAEnvironmentOptions;
begin
 Result := FOptions;
end;

functionTToolsApiEnvironmentOptions.TryFindOptionName(const OptionName: string; out ExactName: string): Boolean;
var
 Names: TOTAOptionNameArray;
 Entry: TOTAOptionName;
begin
 Result := False;
 ExactName := '';

 Names := FOptions.GetOptionNames;
for Entry in Names do
begin
if SameText(Entry.Name, OptionName) then
begin
 ExactName := Entry.Name;
 Exit(True);
end;
end;
end;

functionTToolsApiEnvironmentOptions.GetOption(const OptionName: string): Variant;
begin
 Result := FOptions.Values[OptionName];
end;

procedureTToolsApiEnvironmentOptions.SetOption(const OptionName: string; constValue: Variant);
begin
 FOptions.Values[OptionName] := Value;
end;

{ TToolsApiEditWriter }

constructor TToolsApiEditWriter.Create(const Writer: IOTAEditWriter);
begin
inherited Create;
 FWriter := Writer;
end;

functionTToolsApiEditWriter.Get: IOTAEditWriter;
begin
 Result := FWriter;
end;

procedureTToolsApiEditWriter.InsertText(const Text: string; const Position: Integer);
begin
 FWriter.CopyTo(Position);
 FWriter.Insert(PAnsiChar(AnsiString(Text)));
end;

procedureTToolsApiEditWriter.InsertText(const Text: string; const Position: TOTAEditPos);
var
 EditView: IToolsApiEditView;
begin
 EditView := TToolsApiEditView.Create;
 EditView.InsertText([Text], Position);
end;

{ TToolsApiEditView }

constructor TToolsApiEditView.Create;
begin
inherited Create;
 FEditorServices := (BorlandIDEServices as IOTAEditorServices);
end;

functionTToolsApiEditView.TopView: IOTAEditView;
begin
 Result := FEditorServices.TopView;
ifnot Assigned(Result) then
 raise EToolsApiNoEditViewFound.Create('No edit view found.');
end;

functionTToolsApiEditView.CursorPosition: TOTAEditPos;
begin
 Result := TopView.CursorPos;
end;

procedureTToolsApiEditView.InsertText(const Text: TArray<string>; const Position: TOTAEditPos);
var
 Line: string;
 EditView: IOTAEditView;
 LineNumber, Col: Integer;
begin
 EditView := TopView;

 LineNumber := Position.Line;
 Col := Position.Col;

for Line in Text do
begin
 EditView.Buffer.EditPosition.Move(LineNumber, Col);
 EditView.Buffer.EditPosition.InsertText(Line + sLineBreak);

 Inc(LineNumber);
end;
end;

{ TToolsApiBuildConfigurations }

constructor TToolsApiBuildConfigurations.Create(const Project: IOTAProject);
begin
inherited Create;
 FProject := Project;
 FConfigurations := FProject.ProjectOptions as IOTAProjectOptionsConfigurations;
end;

functionTToolsApiBuildConfigurations.Active: IToolsApiBuildConfiguration;
var
 Config: IOTABuildConfiguration;
begin
 Config := FConfigurations.ActiveConfiguration;
 Result := TToolsApiBuildConfiguration.Create(Config);
end;

functionTToolsApiBuildConfigurations.Base: IToolsApiBuildConfiguration;
var
 Config: IOTABuildConfiguration;
begin
 Config := FConfigurations.BaseConfiguration;
 Result := TToolsApiBuildConfiguration.Create(Config);
end;

{ TToolsApiLogger }

constructor TToolsApiLogger.Create(const GroupName: string);
begin
inherited Create;
 FGroupName := GroupName;
end;

functionTToolsApiLogger.Custom: TCustomMessage;
var
 CustomGroup: IOTAMessageGroup;
begin
 CustomGroup := GetGroup;
 Result := TCustomMessage.Create(CustomGroup);
end;

functionTToolsApiLogger.UsesCustomGroup: Boolean;
begin
 Result := (not FGroupName.IsEmpty);
end;

functionTToolsApiLogger.GetGroup: IOTAMessageGroup;
begin
ifnot Self.UsesCustomGroup then
 raise EToolsApiNoCustomLogGroupUsed.Create('No custom logging group is used');

 Result := (BorlandIDEServices As IOTAMessageServices).AddMessageGroup(FGroupName);
end;

procedureTToolsApiLogger.Clear;
var
 CustomGroup: IOTAMessageGroup;
begin
ifnot Self.UsesCustomGroup then
 Exit;

 CustomGroup := (BorlandIDEServices As IOTAMessageServices).GetGroup(FGroupName);
 (BorlandIDEServices As IOTAMessageServices).ClearMessageGroup(CustomGroup);
end;

procedureTToolsApiLogger.Log(const Text: string; const Params: arrayofconst);
var
 FormattedText: string;
begin
 FormattedText := Format(Text, Params);
 Log(FormattedText);
end;

procedureTToolsApiLogger.Log(const Text: string);
var
 LineRef: Pointer;
 CustomGroup: IOTAMessageGroup;
begin
if Self.UsesCustomGroup then
 CustomGroup := GetGroup
else
 CustomGroup := nil;

 (BorlandIDEServices As IOTAMessageServices).AddToolMessage('', Text, '', 1, 1, nil, LineRef, CustomGroup);
end;

end.
unit GDK.ToolsAPI.Helper;

interface

uses
 ToolsAPI,
 GDK.ToolsAPI.Helper.Interfaces,
 GDK.ToolsAPI.Debugger.Interfaces,
 System.SysUtils,
 GDK.ToolsAPI.CustomMessage;

type
 TToolsApiHelper = class(TInterfacedObject, IToolsApiHelper)
private
 FEditView: IToolsApiEditView;
public
functionLogger: IToolsApiLogger; overload;
functionLogger(const GroupName: string): IToolsApiLogger; overload;

functionProjectGroup: IOTAProjectGroup;

functionProject: IToolsApiProject; overload;
functionProject(const Project: IOTAProject): IToolsApiProject; overload;

functionFindProject(const NameOrPath: string): IToolsApiProject;
procedureSetActiveProject(const Project: IOTAProject);
functionOpenProject(const FileName: string): IToolsApiProject;

functionProjectContextMenu: IToolsApiProjectContextMenu;

functionBuildConfigurations: IToolsApiBuildConfigurations;
functionEnvironmentOptions: IToolsApiEnvironmentOptions;
functionDebugger: IToolsApiDebugger;

functionModuleCount: Integer;
functionModule: IToolsApiModule; overload;
functionModule(constModule: IOTAModule): IToolsApiModule; overload;
functionModule(const Index: Integer): IToolsApiModule; overload;

functionSourceEditor: IToolsApiSourceEditor;
functionEditorReader: IToolsApiEditReader;
functionEditorWriter: IToolsApiEditWriter;

procedureEditorInsertText(const Text: TArray<string>; const Position: TOTAEditPos); overload;
procedureEditorInsertText(const Text: TArray<string>; const AtLine: Integer); overload;

functionEditorPosition: TOTAEditPos;
functionEditorContent: string;

functionEditView: IToolsApiEditView;
end;

 TToolsApiLogger = class(TInterfacedObject, IToolsApiLogger)
private
 FGroupName: string;
public
constructor Create(const GroupName: string);

functionUsesCustomGroup: Boolean;
functionGetGroup: IOTAMessageGroup;

procedureClear;

procedureLog(const Text: string); overload;
procedureLog(const Text: string; const Params: arrayofconst); overload;

functionCustom: TCustomMessage;
end;

 TToolsApiProject = class(TInterfacedObject, IToolsApiProject)
private
 FProject: IOTAProject;
procedureGuard;
public
constructor Create; overload;
constructor Create(const Project: IOTAProject); overload;

functionGet: IOTAProject;

functionProjectConfigurations: IOTAProjectOptionsConfigurations;
functionBuildConfigurations: IToolsApiBuildConfigurations;

functionBuild(const HideProgressDialog: Boolean = False): Boolean;

functionCreateFormUnit(const UnitFileName: string;
const FormName: string;
const AncestorName: string = ''): IOTAModule;
end;

 TToolsApiModule = class(TInterfacedObject, IToolsApiModule)
private
 FModule: IOTAModule;
procedureGuard;
functionReadSourceFromBuffer(out Source: string): Boolean;
public
constructor Create; overload;
constructor Create(constModule: IOTAModule); overload;
constructor Create(const Index: Integer); overload;

functionGet: IOTAModule;
functionFileCount: Integer;
functionFileName: string;
procedureRefresh(const ForceRefresh: Boolean);

functionIsDirty: Boolean;
functionMatchesDisk: Boolean;
procedureSyncWithDisk;

functionEditor(const Predicate: TFunc<IOTAEditor, Boolean>): IOTAEditor;
functionSourceEditor(const Predicate: TFunc<IOTASourceEditor, Boolean> = nil): IToolsApiSourceEditor;
functionFormEditor(const Predicate: TFunc<IOTAFormEditor, Boolean> = nil): IOTAFormEditor;
functionFormDesigner: IToolsApiFormEditor;
end;

 TToolsApiEditView = class(TInterfacedObject, IToolsApiEditView)
private
 FEditorServices: IOTAEditorServices;
public
constructor Create;

functionTopView: IOTAEditView;
functionCursorPosition: TOTAEditPos;

procedureInsertText(const Text: TArray<string>; const Position: TOTAEditPos);
end;

 TToolsApiSourceEditor = class(TInterfacedObject, IToolsApiSourceEditor)
private
 FEditor: IOTASourceEditor;
procedureAddToUses(const UnitNames: TArray<string>; const AddToImplementation: Boolean);
public
constructor Create(const Editor: IOTASourceEditor);

functionGet: IOTASourceEditor;
functionReader: IToolsApiEditReader;
functionWriter: IToolsApiEditWriter;
functionUndoableWriter: IToolsApiEditWriter;

procedureAddToInterfaceUses(const UnitName: string); overload;
procedureAddToInterfaceUses(const UnitNames: TArray<string>); overload;
procedureAddToImplementationUses(const UnitName: string); overload;
procedureAddToImplementationUses(const UnitNames: TArray<string>); overload;
end;

 TToolsApiEditReader = class(TInterfacedObject, IToolsApiEditReader)
private
 FReader: IOTAEditReader;
public
constructor Create(const Reader: IOTAEditReader);

functionGet: IOTAEditReader;
functionContent: string;
end;

 TToolsApiEditWriter = class(TInterfacedObject, IToolsApiEditWriter)
private
 FWriter: IOTAEditWriter;
public
constructor Create(const Writer: IOTAEditWriter);
functionGet: IOTAEditWriter;

procedureInsertText(const Text: string; const Position: Integer); overload;
procedureInsertText(const Text: string; const Position: TOTAEditPos); overload;
end;

 TToolsApiBuildConfigurations = class(TInterfacedObject, IToolsApiBuildConfigurations)
private
 FProject: IOTAProject;
 FConfigurations: IOTAProjectOptionsConfigurations;
public
constructor Create(const Project: IOTAProject);

functionBase: IToolsApiBuildConfiguration;
functionActive: IToolsApiBuildConfiguration;
end;

 TToolsApiEnvironmentOptions = class(TInterfacedObject, IToolsApiEnvironmentOptions)
private
 FOptions: IOTAEnvironmentOptions;
public
constructor Create;

functionGet: IOTAEnvironmentOptions;

functionTryFindOptionName(const OptionName: string; out ExactName: string): Boolean;
functionGetOption(const OptionName: string): Variant;
procedureSetOption(const OptionName: string; constValue: Variant);
end;

 TToolsApiBuildConfiguration = class(TInterfacedObject, IToolsApiBuildConfiguration)
private
 FConfiguration: IOTABuildConfiguration;

functionGetSearchPaths: TArray<string>;
procedureSetSearchPaths(const Paths: TArray<string>);
public
constructor Create(const Configuration: IOTABuildConfiguration);
functionGet: IOTABuildConfiguration;

property SearchPaths: TArray<string> read GetSearchPaths write SetSearchPaths;
end;

implementation

uses
 System.Classes,
 System.IOUtils,
 DCCStrs,
 GDK.ToolsAPI.Debugger,
 GDK.ToolsAPI.FormCreator,
 GDK.ToolsAPI.FormEditor,
 GDK.ToolsAPI.ProjectManagerContextMenu,
 GDK.ToolsAPI.ProjectMatch,
 GDK.ToolsAPI.UsesManager,
 GDK.ToolsAPI.UsesBuilder;

{ TToolsApiHelper }

functionTToolsApiHelper.Project: IToolsApiProject;
begin
 Result := TToolsApiProject.Create;
end;

functionTToolsApiHelper.Project(const Project: IOTAProject): IToolsApiProject;
begin
 Result := TToolsApiProject.Create(Project);
end;

functionTToolsApiHelper.ProjectContextMenu: IToolsApiProjectContextMenu;
begin
 Result := TToolsApiProjectContextMenu.Create;
end;

functionTToolsApiHelper.ProjectGroup: IOTAProjectGroup;
var
 ModuleServices: IOTAModuleServices;
Module: IOTAModule;
 ProjectGroup: IOTAProjectGroup;
 i: Integer;
Begin
 ProjectGroup := nil;

 ModuleServices := (BorlandIDEServices as IOTAModuleServices);
for i := 0to ModuleServices.ModuleCount - 1do
begin
Module := ModuleServices.Modules[i];
if (Module.QueryInterface(IOTAProjectGroup, ProjectGroup) = S_OK) Then
 Break;
end;

 Result := ProjectGroup;
end;

functionTToolsApiHelper.FindProject(const NameOrPath: string): IToolsApiProject;
begin
 Result := nil;

const Group = ProjectGroup;
ifnot Assigned(Group) then
 Exit;

var FileNames: TArray<string>;
 SetLength(FileNames, Group.ProjectCount);
forvar Index := 0to Group.ProjectCount - 1do
 FileNames[Index] := Group.Projects[Index].FileName;

const MatchIndex = TProjectMatch.IndexOf(FileNames, NameOrPath);
if MatchIndex < 0then
 Exit;

 Result := Project(Group.Projects[MatchIndex]);
end;

procedureTToolsApiHelper.SetActiveProject(const Project: IOTAProject);
begin
const Group = ProjectGroup;
if Assigned(Group) then
 Group.ActiveProject := Project;
end;

functionTToolsApiHelper.OpenProject(const FileName: string): IToolsApiProject;
begin
 Result := nil;

ifnot TFile.Exists(FileName) then
 Exit;

const ActionServices = BorlandIDEServices as IOTAActionServices;
const Opened = ActionServices.OpenProject(FileName, False);
ifnot Opened then
 Exit;

 Result := FindProject(FileName);
end;

functionTToolsApiHelper.Module: IToolsApiModule;
begin
 Result := TToolsApiModule.Create;
end;

functionTToolsApiHelper.Module(constModule: IOTAModule): IToolsApiModule;
begin
 Result := TToolsApiModule.Create(Module);
end;

functionTToolsApiHelper.Module(const Index: Integer): IToolsApiModule;
begin
 Result := TToolsApiModule.Create(Index);
end;

functionTToolsApiHelper.ModuleCount: Integer;
var
 ModuleServices: IOTAModuleServices;
begin
 ModuleServices := (BorlandIDEServices as IOTAModuleServices);
 Result := ModuleServices.ModuleCount;
end;

functionTToolsApiHelper.SourceEditor: IToolsApiSourceEditor;
begin
 Result := Self.Module.SourceEditor;
end;

functionTToolsApiHelper.BuildConfigurations: IToolsApiBuildConfigurations;
var
 ActiveProject: IOTAProject;
begin
 ActiveProject := Self.Project.Get;
 Result := TToolsApiBuildConfigurations.Create(ActiveProject);
end;

functionTToolsApiHelper.EnvironmentOptions: IToolsApiEnvironmentOptions;
begin
 Result := TToolsApiEnvironmentOptions.Create;
end;

functionTToolsApiHelper.Debugger: IToolsApiDebugger;
begin
 Result := TToolsApiDebugger.Create;
end;

functionTToolsApiHelper.EditorReader: IToolsApiEditReader;
begin
 Result := Self.SourceEditor.Reader;
end;

functionTToolsApiHelper.EditorWriter: IToolsApiEditWriter;
begin
 Self.SourceEditor.Writer;
end;

functionTToolsApiHelper.EditView: IToolsApiEditView;
begin
ifnot Assigned(FEditView) then
 FEditView := TToolsApiEditView.Create;

 Result := FEditView;
end;

functionTToolsApiHelper.Logger: IToolsApiLogger;
begin
 Result := Self.Logger('');
end;

functionTToolsApiHelper.Logger(const GroupName: string): IToolsApiLogger;
begin
 Result := TToolsApiLogger.Create(GroupName);
end;

procedureTToolsApiHelper.EditorInsertText(const Text: TArray<string>; const Position: TOTAEditPos);
begin
 Self.EditView.InsertText(Text, Position);
end;

procedureTToolsApiHelper.EditorInsertText(const Text: TArray<string>; const AtLine: Integer);
begin
var Lines := string.Join(sLineBreak, Text);
 Self.EditorWriter.InsertText(Lines, AtLine);
end;

functionTToolsApiHelper.EditorPosition: TOTAEditPos;
begin
 Result := Self.EditView.CursorPosition;
end;

functionTToolsApiHelper.EditorContent: string;
begin
 Result := EditorReader.Content;
end;

{ TToolsApiProject }

constructor TToolsApiProject.Create;
begin
inherited Create;
 FProject := GetActiveProject;
 Guard;
end;

constructor TToolsApiProject.Create(const Project: IOTAProject);
begin
inherited Create;
 FProject := Project;
 Guard;
end;

functionTToolsApiProject.Get: IOTAProject;
begin
 Result := FProject;
end;

functionTToolsApiProject.ProjectConfigurations: IOTAProjectOptionsConfigurations;
begin
 Result := FProject.ProjectOptions as IOTAProjectOptionsConfigurations;
end;

functionTToolsApiProject.BuildConfigurations: IToolsApiBuildConfigurations;
begin
 Result := TToolsApiBuildConfigurations.Create(FProject);
end;

functionTToolsApiProject.CreateFormUnit(const UnitFileName: string;
const FormName: string;
const AncestorName: string): IOTAModule;
begin
const Creator: IOTAModuleCreator = TToolsApiFormCreator.Create(FProject, UnitFileName, FormName, AncestorName);
 Result := (BorlandIDEServices as IOTAModuleServices).CreateModule(Creator);
end;

functionTToolsApiProject.Build(const HideProgressDialog: Boolean): Boolean;
const
 ShowCompilerProgressOption = 'ShowCompilerProgress';
var
 EnvironmentOptions: IToolsApiEnvironmentOptions;
 ExactName: string;
 SavedValue: Variant;
begin
ifnot HideProgressDialog then
 Exit(FProject.ProjectBuilder.BuildProject(cmOTABuild, False, True));

// When a build fails, the compile progress dialog stays open as a modal dialog until the
// user dismisses it, and BuildProject only returns after that. Temporarily disabling the
// "Show compiler progress" option keeps unattended builds from blocking.
 EnvironmentOptions := TToolsApiEnvironmentOptions.Create;
ifnot EnvironmentOptions.TryFindOptionName(ShowCompilerProgressOption, ExactName) then
 Exit(FProject.ProjectBuilder.BuildProject(cmOTABuild, False, True));

 SavedValue := EnvironmentOptions.GetOption(ExactName);
 EnvironmentOptions.SetOption(ExactName, False);
try
 Result := FProject.ProjectBuilder.BuildProject(cmOTABuild, False, True);
finally
 EnvironmentOptions.SetOption(ExactName, SavedValue);
end;
end;

procedureTToolsApiProject.Guard;
begin
ifnot Assigned(FProject) then
 raise EToolsApiNoProjectFound.Create('No active project found');
end;

{ TToolsApiModule }

constructor TToolsApiModule.Create;
begin
inherited Create;
 FModule := (BorlandIDEServices as IOTAModuleServices).CurrentModule;
 Guard;
end;

constructor TToolsApiModule.Create(constModule: IOTAModule);
begin
inherited Create;
 FModule := Module;
 Guard;
end;

constructor TToolsApiModule.Create(const Index: Integer);
begin
inherited Create;
 FModule := (BorlandIDEServices as IOTAModuleServices).Modules[Index];
 Guard;
end;

functionTToolsApiModule.Get: IOTAModule;
begin
 Result := FModule;
end;

functionTToolsApiModule.FileCount: Integer;
begin
 Result := FModule.GetModuleFileCount;
end;

functionTToolsApiModule.FileName: string;
begin
 Result := FModule.FileName;
end;

procedureTToolsApiModule.Refresh(const ForceRefresh: Boolean);
begin
 FModule.Refresh(ForceRefresh);
end;

functionTToolsApiModule.IsDirty: Boolean;
begin
 Result := False;

forvar Index := 0to FileCount - 1do
begin
const ModuleEditor = FModule.GetModuleFileEditor(Index);
if Assigned(ModuleEditor) and ModuleEditor.Modified then
 Exit(True);
end;
end;

functionTToolsApiModule.ReadSourceFromBuffer(out Source: string): Boolean;
const
 ChunkSize = 4096;
begin
 Source := '';

var Editor: IOTAEditor := nil;
forvar Index := 0to FileCount - 1do
begin
const Candidate = FModule.GetModuleFileEditor(Index);
if Supports(Candidate, IOTASourceEditor) then
begin
 Editor := Candidate;
 Break;
end;
end;

ifnot Assigned(Editor) then
 Exit(False);

const Reader = (Editor as IOTASourceEditor).CreateReader;

var Bytes: TBytes := nil;
var Position := 0;
var Chunk: TBytes;
 SetLength(Chunk, ChunkSize);

var BytesRead := Reader.GetText(Position, @Chunk[0], ChunkSize);
while BytesRead > 0do
begin
 Bytes := Bytes + Copy(Chunk, 0, BytesRead);
 Position := Position + BytesRead;

if BytesRead < ChunkSize then
 Break;

 BytesRead := Reader.GetText(Position, @Chunk[0], ChunkSize);
end;

 Source := TEncoding.UTF8.GetString(Bytes);
 Result := True;
end;

functionTToolsApiModule.MatchesDisk: Boolean;
begin
const FilePath = FModule.FileName;
if (FilePath = '') or (not FileExists(FilePath)) then
 Exit(True);

var BufferSource: string;
ifnot ReadSourceFromBuffer(BufferSource) then
 Exit(True);

const BufferNormalized = StringReplace(BufferSource, #13#10, #10, [rfReplaceAll]).TrimRight;

var DiskSource := '';
try
 DiskSource := TFile.ReadAllText(FilePath);
except
 Exit(True);
end;

const DiskNormalized = StringReplace(DiskSource, #13#10, #10, [rfReplaceAll]).TrimRight;
 Result := (BufferNormalized = DiskNormalized);
end;

procedureTToolsApiModule.SyncWithDisk;
begin
if MatchesDisk then
 Exit;

if IsDirty then
 raise EToolsApiModuleOutOfSync.CreateFmt(
'%s has unsaved changes in the IDE and a different version on disk', [FModule.FileName]);

 FModule.Refresh(True);
end;

functionTToolsApiModule.Editor(const Predicate: TFunc<IOTAEditor, Boolean>): IOTAEditor;
var
 i: Integer;
 Editor: IOTAEditor;
begin
 Result := nil;

for i := 0to FileCount - 1do
begin
 Editor := FModule.GetModuleFileEditor(i);
if Assigned(Predicate) andnot Predicate(Editor) then
 Continue;

 Result := Editor;
 Break;
end;

ifnot Assigned(Result) then
 raise EToolsApiNoEditorFound.Create('No editor found.');
end;

functionTToolsApiModule.SourceEditor(const Predicate: TFunc<IOTASourceEditor, Boolean>): IToolsApiSourceEditor;
var
 Found: IOTAEditor;
 SourceEditor: IOTASourceEditor;
begin
 Found := Editor(
 function(Editor: IOTAEditor): Boolean
begin
 Result := Supports(Editor, IOTASourceEditor);
end);

 SourceEditor := Found as IOTASourceEditor;
 Result := TToolsApiSourceEditor.Create(SourceEditor);
end;

functionTToolsApiModule.FormEditor(const Predicate: TFunc<IOTAFormEditor, Boolean>): IOTAFormEditor;
var
 Found: IOTAEditor;
begin
 Found := Editor(
 function(Editor: IOTAEditor): Boolean
begin
 Result := Supports(Editor, IOTAFormEditor);
end);

 Result := Found as IOTAFormEditor;
end;

functionTToolsApiModule.FormDesigner: IToolsApiFormEditor;
begin
 Result := TToolsApiFormEditor.Create(FormEditor(nil));
end;

procedureTToolsApiModule.Guard;
begin
ifnot Assigned(FModule) then
 raise EToolsApiNoModuleFound.Create('No active module found.');
end;

{ TToolsApiSourceEditor }

constructor TToolsApiSourceEditor.Create(const Editor: IOTASourceEditor);
begin
inherited Create;
 FEditor := Editor;
end;

functionTToolsApiSourceEditor.Get: IOTASourceEditor;
begin
 Result := FEditor;
end;

functionTToolsApiSourceEditor.Reader: IToolsApiEditReader;
var
 Reader: IOTAEditReader;
begin
 Reader := FEditor.CreateReader;
 Result := TToolsApiEditReader.Create(Reader);
end;

functionTToolsApiSourceEditor.Writer: IToolsApiEditWriter;
begin
var Writer := FEditor.CreateWriter;
 Result := TToolsApiEditWriter.Create(Writer);
end;

functionTToolsApiSourceEditor.UndoableWriter: IToolsApiEditWriter;
begin
var Writer := FEditor.CreateUndoableWriter;
 Result := TToolsApiEditWriter.Create(Writer);
end;

procedureTToolsApiSourceEditor.AddToInterfaceUses(const UnitName: string);
begin
 AddToUses([UnitName], False);
end;

procedureTToolsApiSourceEditor.AddToInterfaceUses(const UnitNames: TArray<string>);
begin
 AddToUses(UnitNames, False);
end;

procedureTToolsApiSourceEditor.AddToImplementationUses(const UnitName: string);
begin
 AddToUses([UnitName], True);
end;

procedureTToolsApiSourceEditor.AddToImplementationUses(const UnitNames: TArray<string>);
begin
 AddToUses(UnitNames, True);
end;

procedureTToolsApiSourceEditor.AddToUses(const UnitNames: TArray<string>; const AddToImplementation: Boolean);
begin
var UsesBuilder := TToolsAPIUsesBuilder.Use;

if AddToImplementation then
 UsesBuilder.InImplementation
else
 UsesBuilder.InInterface;

var EditorContent := Self.Reader.Content;

var UsesToWrite := UsesBuilder
 .WithSource(EditorContent)
 .Build(UnitNames);

if UsesToWrite.CanWrite then
 Self.UndoableWriter.InsertText(UsesToWrite.Text, UsesToWrite.Position);
end;

{ TToolsApiEditReader }

constructor TToolsApiEditReader.Create(const Reader: IOTAEditReader);
begin
inherited Create;
 FReader := Reader;
end;

functionTToolsApiEditReader.Get: IOTAEditReader;
begin
 Result := FReader;
end;

functionTToolsApiEditReader.Content: string;
const
 BufferSize: Integer = 1024;
var
 Read: Integer;
 Position: Integer;
 Buffer: AnsiString;
begin
 Result := '';

 Position := 0;
repeat
 SetLength(Buffer, BufferSize);

 Read := FReader.GetText(Position, PAnsiChar(Buffer), BufferSize);
 SetLength(Buffer, Read);

 Result := Result + string(Buffer);
 Inc(Position, Read);

until (Read < BufferSize);
end;

{ TToolsApiBuildConfiguration }

constructor TToolsApiBuildConfiguration.Create(const Configuration: IOTABuildConfiguration);
begin
inherited Create;
 FConfiguration := Configuration;
end;

functionTToolsApiBuildConfiguration.Get: IOTABuildConfiguration;
begin
 Result := FConfiguration;
end;

functionTToolsApiBuildConfiguration.GetSearchPaths: TArray<string>;
var
 Paths: TStringList;
begin
 Paths := TStringList.Create;
try
 FConfiguration.GetValues(DCCStrs.sUnitSearchPath, Paths, True);

 Result := Paths.ToStringArray;
finally
 Paths.Free;
end;
end;

procedureTToolsApiBuildConfiguration.SetSearchPaths(const Paths: TArray<string>);
var
 SearchPaths: TStringList;
begin
 SearchPaths := TStringList.Create;
try
 SearchPaths.AddStrings(Paths);
 FConfiguration.SetValues(sUnitSearchPath, SearchPaths);
finally
 SearchPaths.Free;
end;
end;

{ TToolsApiEnvironmentOptions }

constructor TToolsApiEnvironmentOptions.Create;
begin
inherited Create;
 FOptions := (BorlandIDEServices as IOTAServices).GetEnvironmentOptions;
end;

functionTToolsApiEnvironmentOptions.Get: IOTAEnvironmentOptions;
begin
 Result := FOptions;
end;

functionTToolsApiEnvironmentOptions.TryFindOptionName(const OptionName: string; out ExactName: string): Boolean;
var
 Names: TOTAOptionNameArray;
 Entry: TOTAOptionName;
begin
 Result := False;
 ExactName := '';

 Names := FOptions.GetOptionNames;
for Entry in Names do
begin
if SameText(Entry.Name, OptionName) then
begin
 ExactName := Entry.Name;
 Exit(True);
end;
end;
end;

functionTToolsApiEnvironmentOptions.GetOption(const OptionName: string): Variant;
begin
 Result := FOptions.Values[OptionName];
end;

procedureTToolsApiEnvironmentOptions.SetOption(const OptionName: string; constValue: Variant);
begin
 FOptions.Values[OptionName] := Value;
end;

{ TToolsApiEditWriter }

constructor TToolsApiEditWriter.Create(const Writer: IOTAEditWriter);
begin
inherited Create;
 FWriter := Writer;
end;

functionTToolsApiEditWriter.Get: IOTAEditWriter;
begin
 Result := FWriter;
end;

procedureTToolsApiEditWriter.InsertText(const Text: string; const Position: Integer);
begin
 FWriter.CopyTo(Position);
 FWriter.Insert(PAnsiChar(AnsiString(Text)));
end;

procedureTToolsApiEditWriter.InsertText(const Text: string; const Position: TOTAEditPos);
var
 EditView: IToolsApiEditView;
begin
 EditView := TToolsApiEditView.Create;
 EditView.InsertText([Text], Position);
end;

{ TToolsApiEditView }

constructor TToolsApiEditView.Create;
begin
inherited Create;
 FEditorServices := (BorlandIDEServices as IOTAEditorServices);
end;

functionTToolsApiEditView.TopView: IOTAEditView;
begin
 Result := FEditorServices.TopView;
ifnot Assigned(Result) then
 raise EToolsApiNoEditViewFound.Create('No edit view found.');
end;

functionTToolsApiEditView.CursorPosition: TOTAEditPos;
begin
 Result := TopView.CursorPos;
end;

procedureTToolsApiEditView.InsertText(const Text: TArray<string>; const Position: TOTAEditPos);
var
 Line: string;
 EditView: IOTAEditView;
 LineNumber, Col: Integer;
begin
 EditView := TopView;

 LineNumber := Position.Line;
 Col := Position.Col;

for Line in Text do
begin
 EditView.Buffer.EditPosition.Move(LineNumber, Col);
 EditView.Buffer.EditPosition.InsertText(Line + sLineBreak);

 Inc(LineNumber);
end;
end;

{ TToolsApiBuildConfigurations }

constructor TToolsApiBuildConfigurations.Create(const Project: IOTAProject);
begin
inherited Create;
 FProject := Project;
 FConfigurations := FProject.ProjectOptions as IOTAProjectOptionsConfigurations;
end;

functionTToolsApiBuildConfigurations.Active: IToolsApiBuildConfiguration;
var
 Config: IOTABuildConfiguration;
begin
 Config := FConfigurations.ActiveConfiguration;
 Result := TToolsApiBuildConfiguration.Create(Config);
end;

functionTToolsApiBuildConfigurations.Base: IToolsApiBuildConfiguration;
var
 Config: IOTABuildConfiguration;
begin
 Config := FConfigurations.BaseConfiguration;
 Result := TToolsApiBuildConfiguration.Create(Config);
end;

{ TToolsApiLogger }

constructor TToolsApiLogger.Create(const GroupName: string);
begin
inherited Create;
 FGroupName := GroupName;
end;

functionTToolsApiLogger.Custom: TCustomMessage;
var
 CustomGroup: IOTAMessageGroup;
begin
 CustomGroup := GetGroup;
 Result := TCustomMessage.Create(CustomGroup);
end;

functionTToolsApiLogger.UsesCustomGroup: Boolean;
begin
 Result := (not FGroupName.IsEmpty);
end;

functionTToolsApiLogger.GetGroup: IOTAMessageGroup;
begin
ifnot Self.UsesCustomGroup then
 raise EToolsApiNoCustomLogGroupUsed.Create('No custom logging group is used');

 Result := (BorlandIDEServices As IOTAMessageServices).AddMessageGroup(FGroupName);
end;

procedureTToolsApiLogger.Clear;
var
 CustomGroup: IOTAMessageGroup;
begin
ifnot Self.UsesCustomGroup then
 Exit;

 CustomGroup := (BorlandIDEServices As IOTAMessageServices).GetGroup(FGroupName);
 (BorlandIDEServices As IOTAMessageServices).ClearMessageGroup(CustomGroup);
end;

procedureTToolsApiLogger.Log(const Text: string; const Params: arrayofconst);
var
 FormattedText: string;
begin
 FormattedText := Format(Text, Params);
 Log(FormattedText);
end;

procedureTToolsApiLogger.Log(const Text: string);
var
 LineRef: Pointer;
 CustomGroup: IOTAMessageGroup;
begin
if Self.UsesCustomGroup then
 CustomGroup := GetGroup
else
 CustomGroup := nil;

 (BorlandIDEServices As IOTAMessageServices).AddToolMessage('', Text, '', 1, 1, nil, LineRef, CustomGroup);
end;

end.
unit GDK.ToolsAPI.Helper;

interface

uses
 ToolsAPI,
 GDK.ToolsAPI.Helper.Interfaces,
 GDK.ToolsAPI.Debugger.Interfaces,
 System.SysUtils,
 GDK.ToolsAPI.CustomMessage;

type
 TToolsApiHelper = class(TInterfacedObject, IToolsApiHelper)
private
 FEditView: IToolsApiEditView;
public
functionLogger: IToolsApiLogger; overload;
functionLogger(const GroupName: string): IToolsApiLogger; overload;

functionProjectGroup: IOTAProjectGroup;

functionProject: IToolsApiProject; overload;
functionProject(const Project: IOTAProject): IToolsApiProject; overload;

functionFindProject(const NameOrPath: string): IToolsApiProject;
procedureSetActiveProject(const Project: IOTAProject);
functionOpenProject(const FileName: string): IToolsApiProject;

functionProjectContextMenu: IToolsApiProjectContextMenu;

functionBuildConfigurations: IToolsApiBuildConfigurations;
functionEnvironmentOptions: IToolsApiEnvironmentOptions;
functionDebugger: IToolsApiDebugger;

functionModuleCount: Integer;
functionModule: IToolsApiModule; overload;
functionModule(constModule: IOTAModule): IToolsApiModule; overload;
functionModule(const Index: Integer): IToolsApiModule; overload;

functionSourceEditor: IToolsApiSourceEditor;
functionEditorReader: IToolsApiEditReader;
functionEditorWriter: IToolsApiEditWriter;

procedureEditorInsertText(const Text: TArray<string>; const Position: TOTAEditPos); overload;
procedureEditorInsertText(const Text: TArray<string>; const AtLine: Integer); overload;

functionEditorPosition: TOTAEditPos;
functionEditorContent: string;

functionEditView: IToolsApiEditView;
end;

 TToolsApiLogger = class(TInterfacedObject, IToolsApiLogger)
private
 FGroupName: string;
public
constructor Create(const GroupName: string);

functionUsesCustomGroup: Boolean;
functionGetGroup: IOTAMessageGroup;

procedureClear;

procedureLog(const Text: string); overload;
procedureLog(const Text: string; const Params: arrayofconst); overload;

functionCustom: TCustomMessage;
end;

 TToolsApiProject = class(TInterfacedObject, IToolsApiProject)
private
 FProject: IOTAProject;
procedureGuard;
public
constructor Create; overload;
constructor Create(const Project: IOTAProject); overload;

functionGet: IOTAProject;

functionProjectConfigurations: IOTAProjectOptionsConfigurations;
functionBuildConfigurations: IToolsApiBuildConfigurations;

functionBuild(const HideProgressDialog: Boolean = False): Boolean;

functionCreateFormUnit(const UnitFileName: string;
const FormName: string;
const AncestorName: string = ''): IOTAModule;
end;

 TToolsApiModule = class(TInterfacedObject, IToolsApiModule)
private
 FModule: IOTAModule;
procedureGuard;
functionReadSourceFromBuffer(out Source: string): Boolean;
public
constructor Create; overload;
constructor Create(constModule: IOTAModule); overload;
constructor Create(const Index: Integer); overload;

functionGet: IOTAModule;
functionFileCount: Integer;
functionFileName: string;
procedureRefresh(const ForceRefresh: Boolean);

functionIsDirty: Boolean;
functionMatchesDisk: Boolean;
procedureSyncWithDisk;

functionEditor(const Predicate: TFunc<IOTAEditor, Boolean>): IOTAEditor;
functionSourceEditor(const Predicate: TFunc<IOTASourceEditor, Boolean> = nil): IToolsApiSourceEditor;
functionFormEditor(const Predicate: TFunc<IOTAFormEditor, Boolean> = nil): IOTAFormEditor;
functionFormDesigner: IToolsApiFormEditor;
end;

 TToolsApiEditView = class(TInterfacedObject, IToolsApiEditView)
private
 FEditorServices: IOTAEditorServices;
public
constructor Create;

functionTopView: IOTAEditView;
functionCursorPosition: TOTAEditPos;

procedureInsertText(const Text: TArray<string>; const Position: TOTAEditPos);
end;

 TToolsApiSourceEditor = class(TInterfacedObject, IToolsApiSourceEditor)
private
 FEditor: IOTASourceEditor;
procedureAddToUses(const UnitNames: TArray<string>; const AddToImplementation: Boolean);
public
constructor Create(const Editor: IOTASourceEditor);

functionGet: IOTASourceEditor;
functionReader: IToolsApiEditReader;
functionWriter: IToolsApiEditWriter;
functionUndoableWriter: IToolsApiEditWriter;

procedureAddToInterfaceUses(const UnitName: string); overload;
procedureAddToInterfaceUses(const UnitNames: TArray<string>); overload;
procedureAddToImplementationUses(const UnitName: string); overload;
procedureAddToImplementationUses(const UnitNames: TArray<string>); overload;
end;

 TToolsApiEditReader = class(TInterfacedObject, IToolsApiEditReader)
private
 FReader: IOTAEditReader;
public
constructor Create(const Reader: IOTAEditReader);

functionGet: IOTAEditReader;
functionContent: string;
end;

 TToolsApiEditWriter = class(TInterfacedObject, IToolsApiEditWriter)
private
 FWriter: IOTAEditWriter;
public
constructor Create(const Writer: IOTAEditWriter);
functionGet: IOTAEditWriter;

procedureInsertText(const Text: string; const Position: Integer); overload;
procedureInsertText(const Text: string; const Position: TOTAEditPos); overload;
end;

 TToolsApiBuildConfigurations = class(TInterfacedObject, IToolsApiBuildConfigurations)
private
 FProject: IOTAProject;
 FConfigurations: IOTAProjectOptionsConfigurations;
public
constructor Create(const Project: IOTAProject);

functionBase: IToolsApiBuildConfiguration;
functionActive: IToolsApiBuildConfiguration;
end;

 TToolsApiEnvironmentOptions = class(TInterfacedObject, IToolsApiEnvironmentOptions)
private
 FOptions: IOTAEnvironmentOptions;
public
constructor Create;

functionGet: IOTAEnvironmentOptions;

functionTryFindOptionName(const OptionName: string; out ExactName: string): Boolean;
functionGetOption(const OptionName: string): Variant;
procedureSetOption(const OptionName: string; constValue: Variant);
end;

 TToolsApiBuildConfiguration = class(TInterfacedObject, IToolsApiBuildConfiguration)
private
 FConfiguration: IOTABuildConfiguration;

functionGetSearchPaths: TArray<string>;
procedureSetSearchPaths(const Paths: TArray<string>);
public
constructor Create(const Configuration: IOTABuildConfiguration);
functionGet: IOTABuildConfiguration;

property SearchPaths: TArray<string> read GetSearchPaths write SetSearchPaths;
end;

implementation

uses
 System.Classes,
 System.IOUtils,
 DCCStrs,
 GDK.ToolsAPI.Debugger,
 GDK.ToolsAPI.FormCreator,
 GDK.ToolsAPI.FormEditor,
 GDK.ToolsAPI.ProjectManagerContextMenu,
 GDK.ToolsAPI.ProjectMatch,
 GDK.ToolsAPI.UsesManager,
 GDK.ToolsAPI.UsesBuilder;

{ TToolsApiHelper }

functionTToolsApiHelper.Project: IToolsApiProject;
begin
 Result := TToolsApiProject.Create;
end;

functionTToolsApiHelper.Project(const Project: IOTAProject): IToolsApiProject;
begin
 Result := TToolsApiProject.Create(Project);
end;

functionTToolsApiHelper.ProjectContextMenu: IToolsApiProjectContextMenu;
begin
 Result := TToolsApiProjectContextMenu.Create;
end;

functionTToolsApiHelper.ProjectGroup: IOTAProjectGroup;
var
 ModuleServices: IOTAModuleServices;
Module: IOTAModule;
 ProjectGroup: IOTAProjectGroup;
 i: Integer;
Begin
 ProjectGroup := nil;

 ModuleServices := (BorlandIDEServices as IOTAModuleServices);
for i := 0to ModuleServices.ModuleCount - 1do
begin
Module := ModuleServices.Modules[i];
if (Module.QueryInterface(IOTAProjectGroup, ProjectGroup) = S_OK) Then
 Break;
end;

 Result := ProjectGroup;
end;

functionTToolsApiHelper.FindProject(const NameOrPath: string): IToolsApiProject;
begin
 Result := nil;

const Group = ProjectGroup;
ifnot Assigned(Group) then
 Exit;

var FileNames: TArray<string>;
 SetLength(FileNames, Group.ProjectCount);
forvar Index := 0to Group.ProjectCount - 1do
 FileNames[Index] := Group.Projects[Index].FileName;

const MatchIndex = TProjectMatch.IndexOf(FileNames, NameOrPath);
if MatchIndex < 0then
 Exit;

 Result := Project(Group.Projects[MatchIndex]);
end;

procedureTToolsApiHelper.SetActiveProject(const Project: IOTAProject);
begin
const Group = ProjectGroup;
if Assigned(Group) then
 Group.ActiveProject := Project;
end;

functionTToolsApiHelper.OpenProject(const FileName: string): IToolsApiProject;
begin
 Result := nil;

ifnot TFile.Exists(FileName) then
 Exit;

const ActionServices = BorlandIDEServices as IOTAActionServices;
const Opened = ActionServices.OpenProject(FileName, False);
ifnot Opened then
 Exit;

 Result := FindProject(FileName);
end;

functionTToolsApiHelper.Module: IToolsApiModule;
begin
 Result := TToolsApiModule.Create;
end;

functionTToolsApiHelper.Module(constModule: IOTAModule): IToolsApiModule;
begin
 Result := TToolsApiModule.Create(Module);
end;

functionTToolsApiHelper.Module(const Index: Integer): IToolsApiModule;
begin
 Result := TToolsApiModule.Create(Index);
end;

functionTToolsApiHelper.ModuleCount: Integer;
var
 ModuleServices: IOTAModuleServices;
begin
 ModuleServices := (BorlandIDEServices as IOTAModuleServices);
 Result := ModuleServices.ModuleCount;
end;

functionTToolsApiHelper.SourceEditor: IToolsApiSourceEditor;
begin
 Result := Self.Module.SourceEditor;
end;

functionTToolsApiHelper.BuildConfigurations: IToolsApiBuildConfigurations;
var
 ActiveProject: IOTAProject;
begin
 ActiveProject := Self.Project.Get;
 Result := TToolsApiBuildConfigurations.Create(ActiveProject);
end;

functionTToolsApiHelper.EnvironmentOptions: IToolsApiEnvironmentOptions;
begin
 Result := TToolsApiEnvironmentOptions.Create;
end;

functionTToolsApiHelper.Debugger: IToolsApiDebugger;
begin
 Result := TToolsApiDebugger.Create;
end;

functionTToolsApiHelper.EditorReader: IToolsApiEditReader;
begin
 Result := Self.SourceEditor.Reader;
end;

functionTToolsApiHelper.EditorWriter: IToolsApiEditWriter;
begin
 Self.SourceEditor.Writer;
end;

functionTToolsApiHelper.EditView: IToolsApiEditView;
begin
ifnot Assigned(FEditView) then
 FEditView := TToolsApiEditView.Create;

 Result := FEditView;
end;

functionTToolsApiHelper.Logger: IToolsApiLogger;
begin
 Result := Self.Logger('');
end;

functionTToolsApiHelper.Logger(const GroupName: string): IToolsApiLogger;
begin
 Result := TToolsApiLogger.Create(GroupName);
end;

procedureTToolsApiHelper.EditorInsertText(const Text: TArray<string>; const Position: TOTAEditPos);
begin
 Self.EditView.InsertText(Text, Position);
end;

procedureTToolsApiHelper.EditorInsertText(const Text: TArray<string>; const AtLine: Integer);
begin
var Lines := string.Join(sLineBreak, Text);
 Self.EditorWriter.InsertText(Lines, AtLine);
end;

functionTToolsApiHelper.EditorPosition: TOTAEditPos;
begin
 Result := Self.EditView.CursorPosition;
end;

functionTToolsApiHelper.EditorContent: string;
begin
 Result := EditorReader.Content;
end;

{ TToolsApiProject }

constructor TToolsApiProject.Create;
begin
inherited Create;
 FProject := GetActiveProject;
 Guard;
end;

constructor TToolsApiProject.Create(const Project: IOTAProject);
begin
inherited Create;
 FProject := Project;
 Guard;
end;

functionTToolsApiProject.Get: IOTAProject;
begin
 Result := FProject;
end;

functionTToolsApiProject.ProjectConfigurations: IOTAProjectOptionsConfigurations;
begin
 Result := FProject.ProjectOptions as IOTAProjectOptionsConfigurations;
end;

functionTToolsApiProject.BuildConfigurations: IToolsApiBuildConfigurations;
begin
 Result := TToolsApiBuildConfigurations.Create(FProject);
end;

functionTToolsApiProject.CreateFormUnit(const UnitFileName: string;
const FormName: string;
const AncestorName: string): IOTAModule;
begin
const Creator: IOTAModuleCreator = TToolsApiFormCreator.Create(FProject, UnitFileName, FormName, AncestorName);
 Result := (BorlandIDEServices as IOTAModuleServices).CreateModule(Creator);
end;

functionTToolsApiProject.Build(const HideProgressDialog: Boolean): Boolean;
const
 ShowCompilerProgressOption = 'ShowCompilerProgress';
var
 EnvironmentOptions: IToolsApiEnvironmentOptions;
 ExactName: string;
 SavedValue: Variant;
begin
ifnot HideProgressDialog then
 Exit(FProject.ProjectBuilder.BuildProject(cmOTABuild, False, True));

// When a build fails, the compile progress dialog stays open as a modal dialog until the
// user dismisses it, and BuildProject only returns after that. Temporarily disabling the
// "Show compiler progress" option keeps unattended builds from blocking.
 EnvironmentOptions := TToolsApiEnvironmentOptions.Create;
ifnot EnvironmentOptions.TryFindOptionName(ShowCompilerProgressOption, ExactName) then
 Exit(FProject.ProjectBuilder.BuildProject(cmOTABuild, False, True));

 SavedValue := EnvironmentOptions.GetOption(ExactName);
 EnvironmentOptions.SetOption(ExactName, False);
try
 Result := FProject.ProjectBuilder.BuildProject(cmOTABuild, False, True);
finally
 EnvironmentOptions.SetOption(ExactName, SavedValue);
end;
end;

procedureTToolsApiProject.Guard;
begin
ifnot Assigned(FProject) then
 raise EToolsApiNoProjectFound.Create('No active project found');
end;

{ TToolsApiModule }

constructor TToolsApiModule.Create;
begin
inherited Create;
 FModule := (BorlandIDEServices as IOTAModuleServices).CurrentModule;
 Guard;
end;

constructor TToolsApiModule.Create(constModule: IOTAModule);
begin
inherited Create;
 FModule := Module;
 Guard;
end;

constructor TToolsApiModule.Create(const Index: Integer);
begin
inherited Create;
 FModule := (BorlandIDEServices as IOTAModuleServices).Modules[Index];
 Guard;
end;

functionTToolsApiModule.Get: IOTAModule;
begin
 Result := FModule;
end;

functionTToolsApiModule.FileCount: Integer;
begin
 Result := FModule.GetModuleFileCount;
end;

functionTToolsApiModule.FileName: string;
begin
 Result := FModule.FileName;
end;

procedureTToolsApiModule.Refresh(const ForceRefresh: Boolean);
begin
 FModule.Refresh(ForceRefresh);
end;

functionTToolsApiModule.IsDirty: Boolean;
begin
 Result := False;

forvar Index := 0to FileCount - 1do
begin
const ModuleEditor = FModule.GetModuleFileEditor(Index);
if Assigned(ModuleEditor) and ModuleEditor.Modified then
 Exit(True);
end;
end;

functionTToolsApiModule.ReadSourceFromBuffer(out Source: string): Boolean;
const
 ChunkSize = 4096;
begin
 Source := '';

var Editor: IOTAEditor := nil;
forvar Index := 0to FileCount - 1do
begin
const Candidate = FModule.GetModuleFileEditor(Index);
if Supports(Candidate, IOTASourceEditor) then
begin
 Editor := Candidate;
 Break;
end;
end;

ifnot Assigned(Editor) then
 Exit(False);

const Reader = (Editor as IOTASourceEditor).CreateReader;

var Bytes: TBytes := nil;
var Position := 0;
var Chunk: TBytes;
 SetLength(Chunk, ChunkSize);

var BytesRead := Reader.GetText(Position, @Chunk[0], ChunkSize);
while BytesRead > 0do
begin
 Bytes := Bytes + Copy(Chunk, 0, BytesRead);
 Position := Position + BytesRead;

if BytesRead < ChunkSize then
 Break;

 BytesRead := Reader.GetText(Position, @Chunk[0], ChunkSize);
end;

 Source := TEncoding.UTF8.GetString(Bytes);
 Result := True;
end;

functionTToolsApiModule.MatchesDisk: Boolean;
begin
const FilePath = FModule.FileName;
if (FilePath = '') or (not FileExists(FilePath)) then
 Exit(True);

var BufferSource: string;
ifnot ReadSourceFromBuffer(BufferSource) then
 Exit(True);

const BufferNormalized = StringReplace(BufferSource, #13#10, #10, [rfReplaceAll]).TrimRight;

var DiskSource := '';
try
 DiskSource := TFile.ReadAllText(FilePath);
except
 Exit(True);
end;

const DiskNormalized = StringReplace(DiskSource, #13#10, #10, [rfReplaceAll]).TrimRight;
 Result := (BufferNormalized = DiskNormalized);
end;

procedureTToolsApiModule.SyncWithDisk;
begin
if MatchesDisk then
 Exit;

if IsDirty then
 raise EToolsApiModuleOutOfSync.CreateFmt(
'%s has unsaved changes in the IDE and a different version on disk', [FModule.FileName]);

 FModule.Refresh(True);
end;

functionTToolsApiModule.Editor(const Predicate: TFunc<IOTAEditor, Boolean>): IOTAEditor;
var
 i: Integer;
 Editor: IOTAEditor;
begin
 Result := nil;

for i := 0to FileCount - 1do
begin
 Editor := FModule.GetModuleFileEditor(i);
if Assigned(Predicate) andnot Predicate(Editor) then
 Continue;

 Result := Editor;
 Break;
end;

ifnot Assigned(Result) then
 raise EToolsApiNoEditorFound.Create('No editor found.');
end;

functionTToolsApiModule.SourceEditor(const Predicate: TFunc<IOTASourceEditor, Boolean>): IToolsApiSourceEditor;
var
 Found: IOTAEditor;
 SourceEditor: IOTASourceEditor;
begin
 Found := Editor(
 function(Editor: IOTAEditor): Boolean
begin
 Result := Supports(Editor, IOTASourceEditor);
end);

 SourceEditor := Found as IOTASourceEditor;
 Result := TToolsApiSourceEditor.Create(SourceEditor);
end;

functionTToolsApiModule.FormEditor(const Predicate: TFunc<IOTAFormEditor, Boolean>): IOTAFormEditor;
var
 Found: IOTAEditor;
begin
 Found := Editor(
 function(Editor: IOTAEditor): Boolean
begin
 Result := Supports(Editor, IOTAFormEditor);
end);

 Result := Found as IOTAFormEditor;
end;

functionTToolsApiModule.FormDesigner: IToolsApiFormEditor;
begin
 Result := TToolsApiFormEditor.Create(FormEditor(nil));
end;

procedureTToolsApiModule.Guard;
begin
ifnot Assigned(FModule) then
 raise EToolsApiNoModuleFound.Create('No active module found.');
end;

{ TToolsApiSourceEditor }

constructor TToolsApiSourceEditor.Create(const Editor: IOTASourceEditor);
begin
inherited Create;
 FEditor := Editor;
end;

functionTToolsApiSourceEditor.Get: IOTASourceEditor;
begin
 Result := FEditor;
end;

functionTToolsApiSourceEditor.Reader: IToolsApiEditReader;
var
 Reader: IOTAEditReader;
begin
 Reader := FEditor.CreateReader;
 Result := TToolsApiEditReader.Create(Reader);
end;

functionTToolsApiSourceEditor.Writer: IToolsApiEditWriter;
begin
var Writer := FEditor.CreateWriter;
 Result := TToolsApiEditWriter.Create(Writer);
end;

functionTToolsApiSourceEditor.UndoableWriter: IToolsApiEditWriter;
begin
var Writer := FEditor.CreateUndoableWriter;
 Result := TToolsApiEditWriter.Create(Writer);
end;

procedureTToolsApiSourceEditor.AddToInterfaceUses(const UnitName: string);
begin
 AddToUses([UnitName], False);
end;

procedureTToolsApiSourceEditor.AddToInterfaceUses(const UnitNames: TArray<string>);
begin
 AddToUses(UnitNames, False);
end;

procedureTToolsApiSourceEditor.AddToImplementationUses(const UnitName: string);
begin
 AddToUses([UnitName], True);
end;

procedureTToolsApiSourceEditor.AddToImplementationUses(const UnitNames: TArray<string>);
begin
 AddToUses(UnitNames, True);
end;

procedureTToolsApiSourceEditor.AddToUses(const UnitNames: TArray<string>; const AddToImplementation: Boolean);
begin
var UsesBuilder := TToolsAPIUsesBuilder.Use;

if AddToImplementation then
 UsesBuilder.InImplementation
else
 UsesBuilder.InInterface;

var EditorContent := Self.Reader.Content;

var UsesToWrite := UsesBuilder
 .WithSource(EditorContent)
 .Build(UnitNames);

if UsesToWrite.CanWrite then
 Self.UndoableWriter.InsertText(UsesToWrite.Text, UsesToWrite.Position);
end;

{ TToolsApiEditReader }

constructor TToolsApiEditReader.Create(const Reader: IOTAEditReader);
begin
inherited Create;
 FReader := Reader;
end;

functionTToolsApiEditReader.Get: IOTAEditReader;
begin
 Result := FReader;
end;

functionTToolsApiEditReader.Content: string;
const
 BufferSize: Integer = 1024;
var
 Read: Integer;
 Position: Integer;
 Buffer: AnsiString;
begin
 Result := '';

 Position := 0;
repeat
 SetLength(Buffer, BufferSize);

 Read := FReader.GetText(Position, PAnsiChar(Buffer), BufferSize);
 SetLength(Buffer, Read);

 Result := Result + string(Buffer);
 Inc(Position, Read);

until (Read < BufferSize);
end;

{ TToolsApiBuildConfiguration }

constructor TToolsApiBuildConfiguration.Create(const Configuration: IOTABuildConfiguration);
begin
inherited Create;
 FConfiguration := Configuration;
end;

functionTToolsApiBuildConfiguration.Get: IOTABuildConfiguration;
begin
 Result := FConfiguration;
end;

functionTToolsApiBuildConfiguration.GetSearchPaths: TArray<string>;
var
 Paths: TStringList;
begin
 Paths := TStringList.Create;
try
 FConfiguration.GetValues(DCCStrs.sUnitSearchPath, Paths, True);

 Result := Paths.ToStringArray;
finally
 Paths.Free;
end;
end;

procedureTToolsApiBuildConfiguration.SetSearchPaths(const Paths: TArray<string>);
var
 SearchPaths: TStringList;
begin
 SearchPaths := TStringList.Create;
try
 SearchPaths.AddStrings(Paths);
 FConfiguration.SetValues(sUnitSearchPath, SearchPaths);
finally
 SearchPaths.Free;
end;
end;

{ TToolsApiEnvironmentOptions }

constructor TToolsApiEnvironmentOptions.Create;
begin
inherited Create;
 FOptions := (BorlandIDEServices as IOTAServices).GetEnvironmentOptions;
end;

functionTToolsApiEnvironmentOptions.Get: IOTAEnvironmentOptions;
begin
 Result := FOptions;
end;

functionTToolsApiEnvironmentOptions.TryFindOptionName(const OptionName: string; out ExactName: string): Boolean;
var
 Names: TOTAOptionNameArray;
 Entry: TOTAOptionName;
begin
 Result := False;
 ExactName := '';

 Names := FOptions.GetOptionNames;
for Entry in Names do
begin
if SameText(Entry.Name, OptionName) then
begin
 ExactName := Entry.Name;
 Exit(True);
end;
end;
end;

functionTToolsApiEnvironmentOptions.GetOption(const OptionName: string): Variant;
begin
 Result := FOptions.Values[OptionName];
end;

procedureTToolsApiEnvironmentOptions.SetOption(const OptionName: string; constValue: Variant);
begin
 FOptions.Values[OptionName] := Value;
end;

{ TToolsApiEditWriter }

constructor TToolsApiEditWriter.Create(const Writer: IOTAEditWriter);
begin
inherited Create;
 FWriter := Writer;
end;

functionTToolsApiEditWriter.Get: IOTAEditWriter;
begin
 Result := FWriter;
end;

procedureTToolsApiEditWriter.InsertText(const Text: string; const Position: Integer);
begin
 FWriter.CopyTo(Position);
 FWriter.Insert(PAnsiChar(AnsiString(Text)));
end;

procedureTToolsApiEditWriter.InsertText(const Text: string; const Position: TOTAEditPos);
var
 EditView: IToolsApiEditView;
begin
 EditView := TToolsApiEditView.Create;
 EditView.InsertText([Text], Position);
end;

{ TToolsApiEditView }

constructor TToolsApiEditView.Create;
begin
inherited Create;
 FEditorServices := (BorlandIDEServices as IOTAEditorServices);
end;

functionTToolsApiEditView.TopView: IOTAEditView;
begin
 Result := FEditorServices.TopView;
ifnot Assigned(Result) then
 raise EToolsApiNoEditViewFound.Create('No edit view found.');
end;

functionTToolsApiEditView.CursorPosition: TOTAEditPos;
begin
 Result := TopView.CursorPos;
end;

procedureTToolsApiEditView.InsertText(const Text: TArray<string>; const Position: TOTAEditPos);
var
 Line: string;
 EditView: IOTAEditView;
 LineNumber, Col: Integer;
begin
 EditView := TopView;

 LineNumber := Position.Line;
 Col := Position.Col;

for Line in Text do
begin
 EditView.Buffer.EditPosition.Move(LineNumber, Col);
 EditView.Buffer.EditPosition.InsertText(Line + sLineBreak);

 Inc(LineNumber);
end;
end;

{ TToolsApiBuildConfigurations }

constructor TToolsApiBuildConfigurations.Create(const Project: IOTAProject);
begin
inherited Create;
 FProject := Project;
 FConfigurations := FProject.ProjectOptions as IOTAProjectOptionsConfigurations;
end;

functionTToolsApiBuildConfigurations.Active: IToolsApiBuildConfiguration;
var
 Config: IOTABuildConfiguration;
begin
 Config := FConfigurations.ActiveConfiguration;
 Result := TToolsApiBuildConfiguration.Create(Config);
end;

functionTToolsApiBuildConfigurations.Base: IToolsApiBuildConfiguration;
var
 Config: IOTABuildConfiguration;
begin
 Config := FConfigurations.BaseConfiguration;
 Result := TToolsApiBuildConfiguration.Create(Config);
end;

{ TToolsApiLogger }

constructor TToolsApiLogger.Create(const GroupName: string);
begin
inherited Create;
 FGroupName := GroupName;
end;

functionTToolsApiLogger.Custom: TCustomMessage;
var
 CustomGroup: IOTAMessageGroup;
begin
 CustomGroup := GetGroup;
 Result := TCustomMessage.Create(CustomGroup);
end;

functionTToolsApiLogger.UsesCustomGroup: Boolean;
begin
 Result := (not FGroupName.IsEmpty);
end;

functionTToolsApiLogger.GetGroup: IOTAMessageGroup;
begin
ifnot Self.UsesCustomGroup then
 raise EToolsApiNoCustomLogGroupUsed.Create('No custom logging group is used');

 Result := (BorlandIDEServices As IOTAMessageServices).AddMessageGroup(FGroupName);
end;

procedureTToolsApiLogger.Clear;
var
 CustomGroup: IOTAMessageGroup;
begin
ifnot Self.UsesCustomGroup then
 Exit;

 CustomGroup := (BorlandIDEServices As IOTAMessageServices).GetGroup(FGroupName);
 (BorlandIDEServices As IOTAMessageServices).ClearMessageGroup(CustomGroup);
end;

procedureTToolsApiLogger.Log(const Text: string; const Params: arrayofconst);
var
 FormattedText: string;
begin
 FormattedText := Format(Text, Params);
 Log(FormattedText);
end;

procedureTToolsApiLogger.Log(const Text: string);
var
 LineRef: Pointer;
 CustomGroup: IOTAMessageGroup;
begin
if Self.UsesCustomGroup then
 CustomGroup := GetGroup
else
 CustomGroup := nil;

 (BorlandIDEServices As IOTAMessageServices).AddToolMessage('', Text, '', 1, 1, nil, LineRef, CustomGroup);
end;

end.
unit GDK.ToolsAPI.Helper;

interface

uses
 ToolsAPI,
 GDK.ToolsAPI.Helper.Interfaces,
 GDK.ToolsAPI.Debugger.Interfaces,
 System.SysUtils,
 GDK.ToolsAPI.CustomMessage;

type
 TToolsApiHelper = class(TInterfacedObject, IToolsApiHelper)
private
 FEditView: IToolsApiEditView;
public
functionLogger: IToolsApiLogger; overload;
functionLogger(const GroupName: string): IToolsApiLogger; overload;

functionProjectGroup: IOTAProjectGroup;

functionProject: IToolsApiProject; overload;
functionProject(const Project: IOTAProject): IToolsApiProject; overload;

functionFindProject(const NameOrPath: string): IToolsApiProject;
procedureSetActiveProject(const Project: IOTAProject);
functionOpenProject(const FileName: string): IToolsApiProject;

functionProjectContextMenu: IToolsApiProjectContextMenu;

functionBuildConfigurations: IToolsApiBuildConfigurations;
functionEnvironmentOptions: IToolsApiEnvironmentOptions;
functionDebugger: IToolsApiDebugger;

functionModuleCount: Integer;
functionModule: IToolsApiModule; overload;
functionModule(constModule: IOTAModule): IToolsApiModule; overload;
functionModule(const Index: Integer): IToolsApiModule; overload;

functionSourceEditor: IToolsApiSourceEditor;
functionEditorReader: IToolsApiEditReader;
functionEditorWriter: IToolsApiEditWriter;

procedureEditorInsertText(const Text: TArray<string>; const Position: TOTAEditPos); overload;
procedureEditorInsertText(const Text: TArray<string>; const AtLine: Integer); overload;

functionEditorPosition: TOTAEditPos;
functionEditorContent: string;

functionEditView: IToolsApiEditView;
end;

 TToolsApiLogger = class(TInterfacedObject, IToolsApiLogger)
private
 FGroupName: string;
public
constructor Create(const GroupName: string);

functionUsesCustomGroup: Boolean;
functionGetGroup: IOTAMessageGroup;

procedureClear;

procedureLog(const Text: string); overload;
procedureLog(const Text: string; const Params: arrayofconst); overload;

functionCustom: TCustomMessage;
end;

 TToolsApiProject = class(TInterfacedObject, IToolsApiProject)
private
 FProject: IOTAProject;
procedureGuard;
public
constructor Create; overload;
constructor Create(const Project: IOTAProject); overload;

functionGet: IOTAProject;

functionProjectConfigurations: IOTAProjectOptionsConfigurations;
functionBuildConfigurations: IToolsApiBuildConfigurations;

functionBuild(const HideProgressDialog: Boolean = False): Boolean;

functionCreateFormUnit(const UnitFileName: string;
const FormName: string;
const AncestorName: string = ''): IOTAModule;
end;

 TToolsApiModule = class(TInterfacedObject, IToolsApiModule)
private
 FModule: IOTAModule;
procedureGuard;
functionReadSourceFromBuffer(out Source: string): Boolean;
public
constructor Create; overload;
constructor Create(constModule: IOTAModule); overload;
constructor Create(const Index: Integer); overload;

functionGet: IOTAModule;
functionFileCount: Integer;
functionFileName: string;
procedureRefresh(const ForceRefresh: Boolean);

functionIsDirty: Boolean;
functionMatchesDisk: Boolean;
procedureSyncWithDisk;

functionEditor(const Predicate: TFunc<IOTAEditor, Boolean>): IOTAEditor;
functionSourceEditor(const Predicate: TFunc<IOTASourceEditor, Boolean> = nil): IToolsApiSourceEditor;
functionFormEditor(const Predicate: TFunc<IOTAFormEditor, Boolean> = nil): IOTAFormEditor;
functionFormDesigner: IToolsApiFormEditor;
end;

 TToolsApiEditView = class(TInterfacedObject, IToolsApiEditView)
private
 FEditorServices: IOTAEditorServices;
public
constructor Create;

functionTopView: IOTAEditView;
functionCursorPosition: TOTAEditPos;

procedureInsertText(const Text: TArray<string>; const Position: TOTAEditPos);
end;

 TToolsApiSourceEditor = class(TInterfacedObject, IToolsApiSourceEditor)
private
 FEditor: IOTASourceEditor;
procedureAddToUses(const UnitNames: TArray<string>; const AddToImplementation: Boolean);
public
constructor Create(const Editor: IOTASourceEditor);

functionGet: IOTASourceEditor;
functionReader: IToolsApiEditReader;
functionWriter: IToolsApiEditWriter;
functionUndoableWriter: IToolsApiEditWriter;

procedureAddToInterfaceUses(const UnitName: string); overload;
procedureAddToInterfaceUses(const UnitNames: TArray<string>); overload;
procedureAddToImplementationUses(const UnitName: string); overload;
procedureAddToImplementationUses(const UnitNames: TArray<string>); overload;
end;

 TToolsApiEditReader = class(TInterfacedObject, IToolsApiEditReader)
private
 FReader: IOTAEditReader;
public
constructor Create(const Reader: IOTAEditReader);

functionGet: IOTAEditReader;
functionContent: string;
end;

 TToolsApiEditWriter = class(TInterfacedObject, IToolsApiEditWriter)
private
 FWriter: IOTAEditWriter;
public
constructor Create(const Writer: IOTAEditWriter);
functionGet: IOTAEditWriter;

procedureInsertText(const Text: string; const Position: Integer); overload;
procedureInsertText(const Text: string; const Position: TOTAEditPos); overload;
end;

 TToolsApiBuildConfigurations = class(TInterfacedObject, IToolsApiBuildConfigurations)
private
 FProject: IOTAProject;
 FConfigurations: IOTAProjectOptionsConfigurations;
public
constructor Create(const Project: IOTAProject);

functionBase: IToolsApiBuildConfiguration;
functionActive: IToolsApiBuildConfiguration;
end;

 TToolsApiEnvironmentOptions = class(TInterfacedObject, IToolsApiEnvironmentOptions)
private
 FOptions: IOTAEnvironmentOptions;
public
constructor Create;

functionGet: IOTAEnvironmentOptions;

functionTryFindOptionName(const OptionName: string; out ExactName: string): Boolean;
functionGetOption(const OptionName: string): Variant;
procedureSetOption(const OptionName: string; constValue: Variant);
end;

 TToolsApiBuildConfiguration = class(TInterfacedObject, IToolsApiBuildConfiguration)
private
 FConfiguration: IOTABuildConfiguration;

functionGetSearchPaths: TArray<string>;
procedureSetSearchPaths(const Paths: TArray<string>);
public
constructor Create(const Configuration: IOTABuildConfiguration);
functionGet: IOTABuildConfiguration;

property SearchPaths: TArray<string> read GetSearchPaths write SetSearchPaths;
end;

implementation

uses
 System.Classes,
 System.IOUtils,
 DCCStrs,
 GDK.ToolsAPI.Debugger,
 GDK.ToolsAPI.FormCreator,
 GDK.ToolsAPI.FormEditor,
 GDK.ToolsAPI.ProjectManagerContextMenu,
 GDK.ToolsAPI.ProjectMatch,
 GDK.ToolsAPI.UsesManager,
 GDK.ToolsAPI.UsesBuilder;

{ TToolsApiHelper }

functionTToolsApiHelper.Project: IToolsApiProject;
begin
 Result := TToolsApiProject.Create;
end;

functionTToolsApiHelper.Project(const Project: IOTAProject): IToolsApiProject;
begin
 Result := TToolsApiProject.Create(Project);
end;

functionTToolsApiHelper.ProjectContextMenu: IToolsApiProjectContextMenu;
begin
 Result := TToolsApiProjectContextMenu.Create;
end;

functionTToolsApiHelper.ProjectGroup: IOTAProjectGroup;
var
 ModuleServices: IOTAModuleServices;
Module: IOTAModule;
 ProjectGroup: IOTAProjectGroup;
 i: Integer;
Begin
 ProjectGroup := nil;

 ModuleServices := (BorlandIDEServices as IOTAModuleServices);
for i := 0to ModuleServices.ModuleCount - 1do
begin
Module := ModuleServices.Modules[i];
if (Module.QueryInterface(IOTAProjectGroup, ProjectGroup) = S_OK) Then
 Break;
end;

 Result := ProjectGroup;
end;

functionTToolsApiHelper.FindProject(const NameOrPath: string): IToolsApiProject;
begin
 Result := nil;

const Group = ProjectGroup;
ifnot Assigned(Group) then
 Exit;

var FileNames: TArray<string>;
 SetLength(FileNames, Group.ProjectCount);
forvar Index := 0to Group.ProjectCount - 1do
 FileNames[Index] := Group.Projects[Index].FileName;

const MatchIndex = TProjectMatch.IndexOf(FileNames, NameOrPath);
if MatchIndex < 0then
 Exit;

 Result := Project(Group.Projects[MatchIndex]);
end;

procedureTToolsApiHelper.SetActiveProject(const Project: IOTAProject);
begin
const Group = ProjectGroup;
if Assigned(Group) then
 Group.ActiveProject := Project;
end;

functionTToolsApiHelper.OpenProject(const FileName: string): IToolsApiProject;
begin
 Result := nil;

ifnot TFile.Exists(FileName) then
 Exit;

const ActionServices = BorlandIDEServices as IOTAActionServices;
const Opened = ActionServices.OpenProject(FileName, False);
ifnot Opened then
 Exit;

 Result := FindProject(FileName);
end;

functionTToolsApiHelper.Module: IToolsApiModule;
begin
 Result := TToolsApiModule.Create;
end;

functionTToolsApiHelper.Module(constModule: IOTAModule): IToolsApiModule;
begin
 Result := TToolsApiModule.Create(Module);
end;

functionTToolsApiHelper.Module(const Index: Integer): IToolsApiModule;
begin
 Result := TToolsApiModule.Create(Index);
end;

functionTToolsApiHelper.ModuleCount: Integer;
var
 ModuleServices: IOTAModuleServices;
begin
 ModuleServices := (BorlandIDEServices as IOTAModuleServices);
 Result := ModuleServices.ModuleCount;
end;

functionTToolsApiHelper.SourceEditor: IToolsApiSourceEditor;
begin
 Result := Self.Module.SourceEditor;
end;

functionTToolsApiHelper.BuildConfigurations: IToolsApiBuildConfigurations;
var
 ActiveProject: IOTAProject;
begin
 ActiveProject := Self.Project.Get;
 Result := TToolsApiBuildConfigurations.Create(ActiveProject);
end;

functionTToolsApiHelper.EnvironmentOptions: IToolsApiEnvironmentOptions;
begin
 Result := TToolsApiEnvironmentOptions.Create;
end;

functionTToolsApiHelper.Debugger: IToolsApiDebugger;
begin
 Result := TToolsApiDebugger.Create;
end;

functionTToolsApiHelper.EditorReader: IToolsApiEditReader;
begin
 Result := Self.SourceEditor.Reader;
end;

functionTToolsApiHelper.EditorWriter: IToolsApiEditWriter;
begin
 Self.SourceEditor.Writer;
end;

functionTToolsApiHelper.EditView: IToolsApiEditView;
begin
ifnot Assigned(FEditView) then
 FEditView := TToolsApiEditView.Create;

 Result := FEditView;
end;

functionTToolsApiHelper.Logger: IToolsApiLogger;
begin
 Result := Self.Logger('');
end;

functionTToolsApiHelper.Logger(const GroupName: string): IToolsApiLogger;
begin
 Result := TToolsApiLogger.Create(GroupName);
end;

procedureTToolsApiHelper.EditorInsertText(const Text: TArray<string>; const Position: TOTAEditPos);
begin
 Self.EditView.InsertText(Text, Position);
end;

procedureTToolsApiHelper.EditorInsertText(const Text: TArray<string>; const AtLine: Integer);
begin
var Lines := string.Join(sLineBreak, Text);
 Self.EditorWriter.InsertText(Lines, AtLine);
end;

functionTToolsApiHelper.EditorPosition: TOTAEditPos;
begin
 Result := Self.EditView.CursorPosition;
end;

functionTToolsApiHelper.EditorContent: string;
begin
 Result := EditorReader.Content;
end;

{ TToolsApiProject }

constructor TToolsApiProject.Create;
begin
inherited Create;
 FProject := GetActiveProject;
 Guard;
end;

constructor TToolsApiProject.Create(const Project: IOTAProject);
begin
inherited Create;
 FProject := Project;
 Guard;
end;

functionTToolsApiProject.Get: IOTAProject;
begin
 Result := FProject;
end;

functionTToolsApiProject.ProjectConfigurations: IOTAProjectOptionsConfigurations;
begin
 Result := FProject.ProjectOptions as IOTAProjectOptionsConfigurations;
end;

functionTToolsApiProject.BuildConfigurations: IToolsApiBuildConfigurations;
begin
 Result := TToolsApiBuildConfigurations.Create(FProject);
end;

functionTToolsApiProject.CreateFormUnit(const UnitFileName: string;
const FormName: string;
const AncestorName: string): IOTAModule;
begin
const Creator: IOTAModuleCreator = TToolsApiFormCreator.Create(FProject, UnitFileName, FormName, AncestorName);
 Result := (BorlandIDEServices as IOTAModuleServices).CreateModule(Creator);
end;

functionTToolsApiProject.Build(const HideProgressDialog: Boolean): Boolean;
const
 ShowCompilerProgressOption = 'ShowCompilerProgress';
var
 EnvironmentOptions: IToolsApiEnvironmentOptions;
 ExactName: string;
 SavedValue: Variant;
begin
ifnot HideProgressDialog then
 Exit(FProject.ProjectBuilder.BuildProject(cmOTABuild, False, True));

// When a build fails, the compile progress dialog stays open as a modal dialog until the
// user dismisses it, and BuildProject only returns after that. Temporarily disabling the
// "Show compiler progress" option keeps unattended builds from blocking.
 EnvironmentOptions := TToolsApiEnvironmentOptions.Create;
ifnot EnvironmentOptions.TryFindOptionName(ShowCompilerProgressOption, ExactName) then
 Exit(FProject.ProjectBuilder.BuildProject(cmOTABuild, False, True));

 SavedValue := EnvironmentOptions.GetOption(ExactName);
 EnvironmentOptions.SetOption(ExactName, False);
try
 Result := FProject.ProjectBuilder.BuildProject(cmOTABuild, False, True);
finally
 EnvironmentOptions.SetOption(ExactName, SavedValue);
end;
end;

procedureTToolsApiProject.Guard;
begin
ifnot Assigned(FProject) then
 raise EToolsApiNoProjectFound.Create('No active project found');
end;

{ TToolsApiModule }

constructor TToolsApiModule.Create;
begin
inherited Create;
 FModule := (BorlandIDEServices as IOTAModuleServices).CurrentModule;
 Guard;
end;

constructor TToolsApiModule.Create(constModule: IOTAModule);
begin
inherited Create;
 FModule := Module;
 Guard;
end;

constructor TToolsApiModule.Create(const Index: Integer);
begin
inherited Create;
 FModule := (BorlandIDEServices as IOTAModuleServices).Modules[Index];
 Guard;
end;

functionTToolsApiModule.Get: IOTAModule;
begin
 Result := FModule;
end;

functionTToolsApiModule.FileCount: Integer;
begin
 Result := FModule.GetModuleFileCount;
end;

functionTToolsApiModule.FileName: string;
begin
 Result := FModule.FileName;
end;

procedureTToolsApiModule.Refresh(const ForceRefresh: Boolean);
begin
 FModule.Refresh(ForceRefresh);
end;

functionTToolsApiModule.IsDirty: Boolean;
begin
 Result := False;

forvar Index := 0to FileCount - 1do
begin
const ModuleEditor = FModule.GetModuleFileEditor(Index);
if Assigned(ModuleEditor) and ModuleEditor.Modified then
 Exit(True);
end;
end;

functionTToolsApiModule.ReadSourceFromBuffer(out Source: string): Boolean;
const
 ChunkSize = 4096;
begin
 Source := '';

var Editor: IOTAEditor := nil;
forvar Index := 0to FileCount - 1do
begin
const Candidate = FModule.GetModuleFileEditor(Index);
if Supports(Candidate, IOTASourceEditor) then
begin
 Editor := Candidate;
 Break;
end;
end;

ifnot Assigned(Editor) then
 Exit(False);

const Reader = (Editor as IOTASourceEditor).CreateReader;

var Bytes: TBytes := nil;
var Position := 0;
var Chunk: TBytes;
 SetLength(Chunk, ChunkSize);

var BytesRead := Reader.GetText(Position, @Chunk[0], ChunkSize);
while BytesRead > 0do
begin
 Bytes := Bytes + Copy(Chunk, 0, BytesRead);
 Position := Position + BytesRead;

if BytesRead < ChunkSize then
 Break;

 BytesRead := Reader.GetText(Position, @Chunk[0], ChunkSize);
end;

 Source := TEncoding.UTF8.GetString(Bytes);
 Result := True;
end;

functionTToolsApiModule.MatchesDisk: Boolean;
begin
const FilePath = FModule.FileName;
if (FilePath = '') or (not FileExists(FilePath)) then
 Exit(True);

var BufferSource: string;
ifnot ReadSourceFromBuffer(BufferSource) then
 Exit(True);

const BufferNormalized = StringReplace(BufferSource, #13#10, #10, [rfReplaceAll]).TrimRight;

var DiskSource := '';
try
 DiskSource := TFile.ReadAllText(FilePath);
except
 Exit(True);
end;

const DiskNormalized = StringReplace(DiskSource, #13#10, #10, [rfReplaceAll]).TrimRight;
 Result := (BufferNormalized = DiskNormalized);
end;

procedureTToolsApiModule.SyncWithDisk;
begin
if MatchesDisk then
 Exit;

if IsDirty then
 raise EToolsApiModuleOutOfSync.CreateFmt(
'%s has unsaved changes in the IDE and a different version on disk', [FModule.FileName]);

 FModule.Refresh(True);
end;

functionTToolsApiModule.Editor(const Predicate: TFunc<IOTAEditor, Boolean>): IOTAEditor;
var
 i: Integer;
 Editor: IOTAEditor;
begin
 Result := nil;

for i := 0to FileCount - 1do
begin
 Editor := FModule.GetModuleFileEditor(i);
if Assigned(Predicate) andnot Predicate(Editor) then
 Continue;

 Result := Editor;
 Break;
end;

ifnot Assigned(Result) then
 raise EToolsApiNoEditorFound.Create('No editor found.');
end;

functionTToolsApiModule.SourceEditor(const Predicate: TFunc<IOTASourceEditor, Boolean>): IToolsApiSourceEditor;
var
 Found: IOTAEditor;
 SourceEditor: IOTASourceEditor;
begin
 Found := Editor(
 function(Editor: IOTAEditor): Boolean
begin
 Result := Supports(Editor, IOTASourceEditor);
end);

 SourceEditor := Found as IOTASourceEditor;
 Result := TToolsApiSourceEditor.Create(SourceEditor);
end;

functionTToolsApiModule.FormEditor(const Predicate: TFunc<IOTAFormEditor, Boolean>): IOTAFormEditor;
var
 Found: IOTAEditor;
begin
 Found := Editor(
 function(Editor: IOTAEditor): Boolean
begin
 Result := Supports(Editor, IOTAFormEditor);
end);

 Result := Found as IOTAFormEditor;
end;

functionTToolsApiModule.FormDesigner: IToolsApiFormEditor;
begin
 Result := TToolsApiFormEditor.Create(FormEditor(nil));
end;

procedureTToolsApiModule.Guard;
begin
ifnot Assigned(FModule) then
 raise EToolsApiNoModuleFound.Create('No active module found.');
end;

{ TToolsApiSourceEditor }

constructor TToolsApiSourceEditor.Create(const Editor: IOTASourceEditor);
begin
inherited Create;
 FEditor := Editor;
end;

functionTToolsApiSourceEditor.Get: IOTASourceEditor;
begin
 Result := FEditor;
end;

functionTToolsApiSourceEditor.Reader: IToolsApiEditReader;
var
 Reader: IOTAEditReader;
begin
 Reader := FEditor.CreateReader;
 Result := TToolsApiEditReader.Create(Reader);
end;

functionTToolsApiSourceEditor.Writer: IToolsApiEditWriter;
begin
var Writer := FEditor.CreateWriter;
 Result := TToolsApiEditWriter.Create(Writer);
end;

functionTToolsApiSourceEditor.UndoableWriter: IToolsApiEditWriter;
begin
var Writer := FEditor.CreateUndoableWriter;
 Result := TToolsApiEditWriter.Create(Writer);
end;

procedureTToolsApiSourceEditor.AddToInterfaceUses(const UnitName: string);
begin
 AddToUses([UnitName], False);
end;

procedureTToolsApiSourceEditor.AddToInterfaceUses(const UnitNames: TArray<string>);
begin
 AddToUses(UnitNames, False);
end;

procedureTToolsApiSourceEditor.AddToImplementationUses(const UnitName: string);
begin
 AddToUses([UnitName], True);
end;

procedureTToolsApiSourceEditor.AddToImplementationUses(const UnitNames: TArray<string>);
begin
 AddToUses(UnitNames, True);
end;

procedureTToolsApiSourceEditor.AddToUses(const UnitNames: TArray<string>; const AddToImplementation: Boolean);
begin
var UsesBuilder := TToolsAPIUsesBuilder.Use;

if AddToImplementation then
 UsesBuilder.InImplementation
else
 UsesBuilder.InInterface;

var EditorContent := Self.Reader.Content;

var UsesToWrite := UsesBuilder
 .WithSource(EditorContent)
 .Build(UnitNames);

if UsesToWrite.CanWrite then
 Self.UndoableWriter.InsertText(UsesToWrite.Text, UsesToWrite.Position);
end;

{ TToolsApiEditReader }

constructor TToolsApiEditReader.Create(const Reader: IOTAEditReader);
begin
inherited Create;
 FReader := Reader;
end;

functionTToolsApiEditReader.Get: IOTAEditReader;
begin
 Result := FReader;
end;

functionTToolsApiEditReader.Content: string;
const
 BufferSize: Integer = 1024;
var
 Read: Integer;
 Position: Integer;
 Buffer: AnsiString;
begin
 Result := '';

 Position := 0;
repeat
 SetLength(Buffer, BufferSize);

 Read := FReader.GetText(Position, PAnsiChar(Buffer), BufferSize);
 SetLength(Buffer, Read);

 Result := Result + string(Buffer);
 Inc(Position, Read);

until (Read < BufferSize);
end;

{ TToolsApiBuildConfiguration }

constructor TToolsApiBuildConfiguration.Create(const Configuration: IOTABuildConfiguration);
begin
inherited Create;
 FConfiguration := Configuration;
end;

functionTToolsApiBuildConfiguration.Get: IOTABuildConfiguration;
begin
 Result := FConfiguration;
end;

functionTToolsApiBuildConfiguration.GetSearchPaths: TArray<string>;
var
 Paths: TStringList;
begin
 Paths := TStringList.Create;
try
 FConfiguration.GetValues(DCCStrs.sUnitSearchPath, Paths, True);

 Result := Paths.ToStringArray;
finally
 Paths.Free;
end;
end;

procedureTToolsApiBuildConfiguration.SetSearchPaths(const Paths: TArray<string>);
var
 SearchPaths: TStringList;
begin
 SearchPaths := TStringList.Create;
try
 SearchPaths.AddStrings(Paths);
 FConfiguration.SetValues(sUnitSearchPath, SearchPaths);
finally
 SearchPaths.Free;
end;
end;

{ TToolsApiEnvironmentOptions }

constructor TToolsApiEnvironmentOptions.Create;
begin
inherited Create;
 FOptions := (BorlandIDEServices as IOTAServices).GetEnvironmentOptions;
end;

functionTToolsApiEnvironmentOptions.Get: IOTAEnvironmentOptions;
begin
 Result := FOptions;
end;

functionTToolsApiEnvironmentOptions.TryFindOptionName(const OptionName: string; out ExactName: string): Boolean;
var
 Names: TOTAOptionNameArray;
 Entry: TOTAOptionName;
begin
 Result := False;
 ExactName := '';

 Names := FOptions.GetOptionNames;
for Entry in Names do
begin
if SameText(Entry.Name, OptionName) then
begin
 ExactName := Entry.Name;
 Exit(True);
end;
end;
end;

functionTToolsApiEnvironmentOptions.GetOption(const OptionName: string): Variant;
begin
 Result := FOptions.Values[OptionName];
end;

procedureTToolsApiEnvironmentOptions.SetOption(const OptionName: string; constValue: Variant);
begin
 FOptions.Values[OptionName] := Value;
end;

{ TToolsApiEditWriter }

constructor TToolsApiEditWriter.Create(const Writer: IOTAEditWriter);
begin
inherited Create;
 FWriter := Writer;
end;

functionTToolsApiEditWriter.Get: IOTAEditWriter;
begin
 Result := FWriter;
end;

procedureTToolsApiEditWriter.InsertText(const Text: string; const Position: Integer);
begin
 FWriter.CopyTo(Position);
 FWriter.Insert(PAnsiChar(AnsiString(Text)));
end;

procedureTToolsApiEditWriter.InsertText(const Text: string; const Position: TOTAEditPos);
var
 EditView: IToolsApiEditView;
begin
 EditView := TToolsApiEditView.Create;
 EditView.InsertText([Text], Position);
end;

{ TToolsApiEditView }

constructor TToolsApiEditView.Create;
begin
inherited Create;
 FEditorServices := (BorlandIDEServices as IOTAEditorServices);
end;

functionTToolsApiEditView.TopView: IOTAEditView;
begin
 Result := FEditorServices.TopView;
ifnot Assigned(Result) then
 raise EToolsApiNoEditViewFound.Create('No edit view found.');
end;

functionTToolsApiEditView.CursorPosition: TOTAEditPos;
begin
 Result := TopView.CursorPos;
end;

procedureTToolsApiEditView.InsertText(const Text: TArray<string>; const Position: TOTAEditPos);
var
 Line: string;
 EditView: IOTAEditView;
 LineNumber, Col: Integer;
begin
 EditView := TopView;

 LineNumber := Position.Line;
 Col := Position.Col;

for Line in Text do
begin
 EditView.Buffer.EditPosition.Move(LineNumber, Col);
 EditView.Buffer.EditPosition.InsertText(Line + sLineBreak);

 Inc(LineNumber);
end;
end;

{ TToolsApiBuildConfigurations }

constructor TToolsApiBuildConfigurations.Create(const Project: IOTAProject);
begin
inherited Create;
 FProject := Project;
 FConfigurations := FProject.ProjectOptions as IOTAProjectOptionsConfigurations;
end;

functionTToolsApiBuildConfigurations.Active: IToolsApiBuildConfiguration;
var
 Config: IOTABuildConfiguration;
begin
 Config := FConfigurations.ActiveConfiguration;
 Result := TToolsApiBuildConfiguration.Create(Config);
end;

functionTToolsApiBuildConfigurations.Base: IToolsApiBuildConfiguration;
var
 Config: IOTABuildConfiguration;
begin
 Config := FConfigurations.BaseConfiguration;
 Result := TToolsApiBuildConfiguration.Create(Config);
end;

{ TToolsApiLogger }

constructor TToolsApiLogger.Create(const GroupName: string);
begin
inherited Create;
 FGroupName := GroupName;
end;

functionTToolsApiLogger.Custom: TCustomMessage;
var
 CustomGroup: IOTAMessageGroup;
begin
 CustomGroup := GetGroup;
 Result := TCustomMessage.Create(CustomGroup);
end;

functionTToolsApiLogger.UsesCustomGroup: Boolean;
begin
 Result := (not FGroupName.IsEmpty);
end;

functionTToolsApiLogger.GetGroup: IOTAMessageGroup;
begin
ifnot Self.UsesCustomGroup then
 raise EToolsApiNoCustomLogGroupUsed.Create('No custom logging group is used');

 Result := (BorlandIDEServices As IOTAMessageServices).AddMessageGroup(FGroupName);
end;

procedureTToolsApiLogger.Clear;
var
 CustomGroup: IOTAMessageGroup;
begin
ifnot Self.UsesCustomGroup then
 Exit;

 CustomGroup := (BorlandIDEServices As IOTAMessageServices).GetGroup(FGroupName);
 (BorlandIDEServices As IOTAMessageServices).ClearMessageGroup(CustomGroup);
end;

procedureTToolsApiLogger.Log(const Text: string; const Params: arrayofconst);
var
 FormattedText: string;
begin
 FormattedText := Format(Text, Params);
 Log(FormattedText);
end;

procedureTToolsApiLogger.Log(const Text: string);
var
 LineRef: Pointer;
 CustomGroup: IOTAMessageGroup;
begin
if Self.UsesCustomGroup then
 CustomGroup := GetGroup
else
 CustomGroup := nil;

 (BorlandIDEServices As IOTAMessageServices).AddToolMessage('', Text, '', 1, 1, nil, LineRef, CustomGroup);
end;

end.