GDK.ToolsAPI.Helper.Interfaces.pas

unit GDK.ToolsAPI.Helper.Interfaces;

interface

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

type
  IToolsApiHelper = interface;
  IToolsApiLogger = interface;
  IToolsApiProject = interface;
  IToolsApiModule = interface;
  IToolsApiEditView = interface;
  IToolsApiSourceEditor = interface;
  IToolsApiEditReader = interface;
  IToolsApiEditWriter = interface;
  IToolsApiBuildConfigurations = interface;
  IToolsApiBuildConfiguration = interface;
  IToolsApiEnvironmentOptions = interface;
  IToolsApiFormEditor = interface;
  IToolsApiProjectContextMenu = interface;
  IToolsApiProjectContextMenuItem = interface;

  EToolsApiNoProjectFound = class(Exception);
  EToolsApiNoModuleFound = class(Exception);
  EToolsApiNoEditorFound = class(Exception);
  EToolsApiNoEditViewFound = class(Exception);
  EToolsApiNoCustomLogGroupUsed = class(Exception);
  EToolsApiComponentNotFound = class(Exception);
  EToolsApiComponentNotCreated = class(Exception);
  EToolsApiPropertyNotSupported = class(Exception);
  EToolsApiModuleOutOfSync = class(Exception);

  IToolsApiHelper = interface
    ['{3D85AEBD-3FE0-43A0-9C30-F30F0A820C45}']

    function Logger: IToolsApiLogger; overload;
    function Logger(const GroupName: string): IToolsApiLogger; overload;

    function ProjectGroup: IOTAProjectGroup;

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

    // Locates a project in the active project group by name, base name or path
    // fragment (see GDK.ToolsAPI.ProjectMatch); returns nil when not found or
    // when a substring query is ambiguous.
    function FindProject(const NameOrPath: string): IToolsApiProject;
    // Makes Project the active project of the group (IOTAProjectGroup.ActiveProject).
    procedure SetActiveProject(const Project: IOTAProject);
    // Opens a project file (.dproj/.dpr/.groupproj) from disk into the current
    // project group and returns it; nil when the file is missing or cannot open.
    function OpenProject(const FileName: string): IToolsApiProject;

    function ProjectContextMenu: IToolsApiProjectContextMenu;

    function ModuleCount: Integer;
    function Module: IToolsApiModule; overload;
    function Module(const Module: IOTAModule): IToolsApiModule; overload;
    function Module(const Index: Integer): IToolsApiModule; overload;

    function SourceEditor: IToolsApiSourceEditor;
    function EditorReader: IToolsApiEditReader;
    function EditorWriter: IToolsApiEditWriter;

    procedure EditorInsertText(const Text: TArray<string>; const Position: TOTAEditPos); overload;
    procedure EditorInsertText(const Text: TArray<string>; const AtLine: Integer); overload;
    function  EditorPosition: TOTAEditPos;
    function  EditorContent: string;

    function BuildConfigurations: IToolsApiBuildConfigurations;
    function EnvironmentOptions: IToolsApiEnvironmentOptions;
    function Debugger: IToolsApiDebugger;

    function EditView: IToolsApiEditView;
  end;

  IToolsApiLogger = interface
    ['{D8FF6783-45A9-4D15-A239-7D5B3EC19D7C}']

    function UsesCustomGroup: Boolean;
    function GetGroup: IOTAMessageGroup;

    procedure Clear;

    procedure Log(const Text: string); overload;
    procedure Log(const Text: string; const Params: array of const); overload;

    function Custom: TCustomMessage;
  end;

  IToolsApiProject = interface
    ['{F78C515E-354A-4341-8073-E45B091847B2}']

    function Get: IOTAProject;
    function ProjectConfigurations: IOTAProjectOptionsConfigurations;

    function BuildConfigurations: IToolsApiBuildConfigurations;

    function Build(const HideProgressDialog: Boolean = False): Boolean;

    // Creates a new form unit through the IDE (default form template), adds it
    // to the project and opens the designer. AncestorName without the leading
    // "T" (empty means TForm).
    function CreateFormUnit(const UnitFileName: string;
                            const FormName: string;
                            const AncestorName: string = ''): IOTAModule;
  end;

  IToolsApiModule = interface
    ['{6370BA7A-2A5C-468F-BA8F-93B090837B90}']

    function Get: IOTAModule;
    function FileCount: Integer;
    function FileName: string;
    procedure Refresh(const ForceRefresh: Boolean);

    function IsDirty: Boolean;
    function MatchesDisk: Boolean;

    // Reloads the module from disk when the buffer is unmodified; raises
    // EToolsApiModuleOutOfSync when the buffer has unsaved changes AND the
    // file on disk differs (both sides changed).
    procedure SyncWithDisk;

    function Editor(const Predicate: TFunc<IOTAEditor, Boolean>): IOTAEditor;
    function SourceEditor(const Predicate: TFunc<IOTASourceEditor, Boolean> = nil): IToolsApiSourceEditor;
    function FormEditor(const Predicate: TFunc<IOTAFormEditor, Boolean> = nil): IOTAFormEditor;
    function FormDesigner: IToolsApiFormEditor;
  end;

  IToolsApiEditView = interface
    ['{5E080CEF-0D18-453E-8AF4-F7CF9BBCE45C}']

    function TopView: IOTAEditView;
    function CursorPosition: TOTAEditPos;

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

  IToolsApiSourceEditor = interface
    ['{1A2D29C0-A6B2-4B21-B17D-781F89A54A14}']

    function Get: IOTASourceEditor;
    function Reader: IToolsApiEditReader;
    function Writer: IToolsApiEditWriter;
    function UndoableWriter: IToolsApiEditWriter;

    procedure AddToInterfaceUses(const UnitName: string); overload;
    procedure AddToInterfaceUses(const UnitNames: TArray<string>); overload;
    procedure AddToImplementationUses(const UnitName: string); overload;
    procedure AddToImplementationUses(const UnitNames: TArray<string>); overload;
  end;

  IToolsApiEditReader = interface
    ['{81675E71-2231-4165-B5CF-EC898D204DEC}']

    function Get: IOTAEditReader;
    function Content: string;
  end;

  IToolsApiEditWriter = interface
    ['{27079628-B140-4E0E-959C-40879C213D52}']

    function Get: IOTAEditWriter;

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

  IToolsApiBuildConfigurations = interface
    ['{CF2A696D-B493-491F-9E2F-C82D7B69CEFE}']

    function Base: IToolsApiBuildConfiguration;
    function Active: IToolsApiBuildConfiguration;
  end;

  IToolsApiBuildConfiguration = interface
    ['{B1FF2C33-0F59-4FD1-822E-327FA78216D2}']
    function  GetSearchPaths: TArray<string>;
    procedure SetSearchPaths(const Paths: TArray<string>);

    function Get: IOTABuildConfiguration;

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

  // Component-level access to an open form designer. Native TComponent
  // references are only valid while the designer stays open; do not hold on
  // to them.
  IToolsApiFormEditor = interface
    ['{2D75892D-2B7F-422B-A8E4-278C92AEC6F0}']

    function Get: IOTAFormEditor;

    function Root: TComponent;
    function Find(const ComponentName: string): TComponent;
    function Components: TArray<TComponent>;

    // Assigned event handlers as 'OnClick=Button1Click' pairs.
    function AssignedEvents(const Component: TComponent): TArray<string>;

    function AddComponent(const TypeName: string;
                          const ContainerName: string;
                          const Left: Integer;
                          const Top: Integer;
                          const Width: Integer;
                          const Height: Integer): TComponent;
    procedure SetComponentProperty(const ComponentName: string;
                                   const PropertyPath: string;
                                   const Value: string);

    // Renders the designed form to a PNG (TCustomForm.GetFormImage).
    function CaptureImage: TBytes;

    procedure ShowDesigner;
    procedure MarkModified;
  end;

  IToolsApiEnvironmentOptions = interface
    ['{E258D39A-DA61-4D55-B1FF-DBEB3FE156BC}']

    function Get: IOTAEnvironmentOptions;

    function TryFindOptionName(const OptionName: string; out ExactName: string): Boolean;
    function GetOption(const OptionName: string): Variant;
    procedure SetOption(const OptionName: string; const Value: Variant);
  end;

  IToolsApiProjectContextMenu = interface
    ['{B8BBB29F-A521-4ED1-9443-8BFA3DEE6E29}']

    procedure Remove(const NotifierIndex: Integer);
  end;

  IToolsApiProjectContextMenuItem = interface(IOTAProjectManagerMenu)
    ['{32307ABE-6BFD-41D7-A47C-DEBC11F9B217}']
    procedure SetOnPostExecute(const Value: TFunc<IOTAProject, Boolean>);
    procedure SetOnExecute(const Value: TProc<IOTAProject>);
    procedure SetOnPreExecute(const Value: TFunc<IOTAProject, Boolean>);

    function NotifierIndex: Integer;

    property OnPreExecute: TFunc<IOTAProject, Boolean> write SetOnPreExecute;
    property OnExecute: TProc<IOTAProject> write SetOnExecute;
    property OnPostExecute: TFunc<IOTAProject, Boolean> write SetOnPostExecute;
  end;

implementation

end.