unit OTAUtils;


interface


uses ToolsAPI, Classes, SysUtils;

type
  TUnitInfo = class(TObject)
  private
    FFormName: string;
    FUnitName: string;
    FFileName: string;
  public
    property UnitName: string read FUnitName write FUnitName;
    property FormName: string read FFormName write FFormName;
    property FileName: string read FFileName write FFileName;
  end;


function OtaGetCurrentModule: IOTAModule;
function OtaGetCurrentProjectName: string;
function OtaGetCurrentProject: IOTAProject;
function OtaGetProjectGroup: IOTAProjectGroup;
function OtaGetActiveEditorTextAsString(var Text: string; UseSelection: Boolean): Boolean;
function OtaGetActiveEditorText(Stream: TStream; UseSelection: Boolean): Boolean;
function OtaGetSourceEditorFromModule(Module: IOTAModule; const FileName: string = ''): IOTASourceEditor;
function OtaGetFileEditorForModule(Module: IOTAModule; Index: Integer): IOTAEditor;
function OtaGetTopMostEditView(SourceEditor: IOTASourceEditor): IOTAEditView;
function OtaGetCurrentSourceEditor: IOTASourceEditor;
procedure OtaSaveReaderToStream(EditReader: IOTAEditReader; Stream: TStream);
procedure OtaInsertTextIntoEditorAtPos(const Text: string; Position: Longint;
  SourceEditor: IOTASourceEditor);
function OtaGetEditWriterForSourceEditor(SourceEditor: IOTASourceEditor = nil): IOTAEditWriter;
procedure OtaAssertSourceEditorNotReadOnly(SourceEditor: IOTASourceEditor);
function OtaGetTopMostEditBuffer: IOTAEditBuffer;
procedure OtaFillUnitInfoListForCurrentProject(const List: TList);
procedure ClearUnitInfoList(const List: TList);
function OtaOpenFile(const FileName: string): Boolean;
function OtaIsFileOpen(const AFileName: string): Boolean;
function OtaGetCurrentSourceFile: string;
procedure OtaDeleteTextFromPos(StartPos, Count: Longint; SourceEditor: IOTASourceEditor = nil);
procedure OtaSettringAsActiveEditorText(Text: string);
procedure OtaInsertTextIntoEditor(const Text: string);

implementation

procedure ClearUnitInfoList(const List: TList);
var
  i: Integer;
begin
  if Assigned(List) then
    begin
      for i := 0 to List.Count - 1 do
        TObject(List[i]).Free;
      List.Clear;
    end;
end;

function OtaGetCurrentSourceFile: string;
var
  Module: IOTAModule;
  Editor: IOTAEditor;
begin
  Result := '';
  Module := OtaGetCurrentModule;
  if Module <> nil then
    begin
      Editor := Module.GetCurrentEditor;
      if Editor <> nil then
        Result := Editor.FileName
      else // C++Builder 6 returns nil for some old-style modules without DFMs
        Result := Module.FileName;
    end;
end;

function OtaIsFileOpen(const AFileName: string): Boolean;
var
  ModuleServices: IOTAModuleServices;
  Module: IOTAModule;
  FileEditor: IOTAEditor;
  i: Integer;
  FileName: string;
begin
  Result := False;

  ModuleServices := BorlandIDEServices as IOTAModuleServices;
  Assert(Assigned(ModuleServices));
  FileName := AFileName;

  Module := ModuleServices.FindModule(FileName);
  if Assigned(Module) then
    begin
      for i := 0 to Module.GetModuleFileCount - 1 do
        begin
          FileEditor := OtaGetFileEditorForModule(Module, i);
          Assert(Assigned(FileEditor));

          Result := SameFileName(FileName, FileEditor.FileName);
          if Result then
            Exit;
        end;
    end;
end;

function OtaOpenFile(const FileName: string): Boolean;
var
  ActionServices: IOTAActionServices;
begin
  ActionServices := BorlandIDEServices as IOTAActionServices;
  Assert(Assigned(ActionServices));

  Result := ActionServices.OpenFile(FileName);
end;

procedure OtaFillUnitInfoListForCurrentProject(const List: TList);
var
  i: Integer;
  CurrentProject: IOTAProject;
  ModuleInfo: IOTAModuleInfo;
  UnitInfo: TUnitInfo;
begin
  Assert(Assigned(List));
  ClearUnitInfoList(List);

  CurrentProject := OtaGetCurrentProject;
  if not Assigned(CurrentProject) then
    Exit;

  for i := 0 to CurrentProject.GetModuleCount - 1 do
    begin
      ModuleInfo := CurrentProject.GetModule(i);
      Assert(Assigned(ModuleInfo));

      if ModuleInfo.FileName <> '' then
        begin
          UnitInfo := TUnitInfo.Create;
          List.Add(UnitInfo);

          UnitInfo.FileName := ModuleInfo.FileName;
          UnitInfo.FormName := ModuleInfo.FormName;
          UnitInfo.UnitName := ModuleInfo.Name;
        end;
    end;
end;

procedure OtaAssertSourceEditorNotReadOnly(SourceEditor: IOTASourceEditor);
begin
  Assert(Assigned(SourceEditor));
  if Supports(SourceEditor, IOTAEditBuffer) then
    if (SourceEditor as IOTAEditBuffer).IsReadOnly then
      raise Exception.CreateFmt('%s is read only', [ExtractFileName(SourceEditor.FileName)]);
end;

procedure OtaInsertTextIntoEditor(const Text: string);
var
  EditView: IOTAEditView;
  Position: Longint;
  CharPos: TOTACharPos;
  EditPos: TOTAEditPos;
begin
  EditView := OtaGetTopMostEditView(OtaGetCurrentSourceEditor);
  Assert(Assigned(EditView), 'No edit view found');
  EditPos := EditView.CursorPos;
  EditView.ConvertPos(True, EditPos, CharPos);
  Position := EditView.CharPosToPos(CharPos);
  OtaInsertTextIntoEditorAtPos(Text, Position, OtaGetCurrentSourceEditor);
  EditView.MoveViewToCursor;
  EditView.Paint;
end;

function OtaGetEditWriterForSourceEditor(SourceEditor: IOTASourceEditor = nil): IOTAEditWriter;
resourcestring
  SEditWriterNotAvail = 'Edit writer not available';
begin
  if not Assigned(SourceEditor) then
    SourceEditor := OtaGetCurrentSourceEditor;
  if Assigned(SourceEditor) then
    begin
      OtaAssertSourceEditorNotReadOnly(SourceEditor);
      Result := SourceEditor.CreateUndoableWriter;
    end;
  Assert(Assigned(Result), SEditWriterNotAvail);
end;

procedure OtaSettringAsActiveEditorText(Text: string);
var
  EditView: IOTAEditView;
  CharPos: TOTACharPos;
  EditPos: TOTAEditPos;
begin
  EditView := OtaGetTopMostEditView(OtaGetCurrentSourceEditor);
  Assert(Assigned(EditView), 'No edit view found');
  EditPos := EditView.CursorPos;
  EditView.ConvertPos(True, EditPos, CharPos);
  OtaDeleteTextFromPos(0, MaxInt, OtaGetCurrentSourceEditor);
  OtaInsertTextIntoEditorAtPos(Text, 0, OtaGetCurrentSourceEditor);
  EditView.CursorPos := EditPos;
  EditView.MoveViewToCursor;
  EditView.Paint;
end;

procedure OtaDeleteTextFromPos(StartPos, Count: Longint; SourceEditor: IOTASourceEditor = nil);
var
  EditWriter: IOTAEditWriter;
begin
  EditWriter := OtaGetEditWriterForSourceEditor(SourceEditor);
  EditWriter.CopyTo(StartPos);
  EditWriter.DeleteTo(StartPos + Count);
end;

procedure OtaInsertTextIntoEditorAtPos(const Text: string; Position: Longint;
  SourceEditor: IOTASourceEditor);
var
  EditWriter: IOTAEditWriter;
begin
  if Text = '' then
    Exit;
  EditWriter := OtaGetEditWriterForSourceEditor(SourceEditor);
  EditWriter.CopyTo(Position);
  EditWriter.Insert(PChar(Text));
end;

procedure OtaSaveReaderToStream(EditReader: IOTAEditReader; Stream: TStream);
const
  // Leave typed constant as is - needed for streaming code.
  TerminatingNulChar: Char = #0;
  BufferSize = 1024 * 24;
var
  Buffer: PChar;
  EditReaderPos: Integer;
  ReadDataSize: Integer;
begin
  Assert(EditReader <> nil);
  Assert(Stream <> nil);

  GetMem(Buffer, BufferSize);
  try
    EditReaderPos := 0;
    ReadDataSize := EditReader.GetText(EditReaderPos, Buffer, BufferSize);
    Inc(EditReaderPos, ReadDataSize);
    while ReadDataSize = BufferSize do
      begin
        Stream.Write(Buffer^, ReadDataSize);
        ReadDataSize := EditReader.GetText(EditReaderPos, Buffer, BufferSize);
        Inc(EditReaderPos, ReadDataSize);
      end;
    Stream.Write(Buffer^, ReadDataSize);
    Stream.Write(TerminatingNulChar, SizeOf(TerminatingNulChar));
  finally
    FreeMem(Buffer);
  end;
end;

function OtaGetTopMostEditView(SourceEditor: IOTASourceEditor): IOTAEditView;
begin
  if SourceEditor = nil then
    SourceEditor := OtaGetCurrentSourceEditor;
  if Assigned(SourceEditor) and (SourceEditor.EditViewCount > 0) then
    Result := SourceEditor.EditViews[0]
  else
    Result := nil;
end;

function OtaGetFileEditorForModule(Module: IOTAModule; Index: Integer): IOTAEditor;
begin
  Assert(Assigned(Module));
  Result := Module.GetModuleFileEditor(Index);
end;

function OtaGetSourceEditorFromModule(Module: IOTAModule; const FileName: string = ''): IOTASourceEditor;
var
  i: Integer;
  IEditor: IOTAEditor;
  ISourceEditor: IOTASourceEditor;
begin
  Result := nil;
  if not Assigned(Module) then
    Exit;

  for i := 0 to Module.GetModuleFileCount - 1 do
    begin
      IEditor := OtaGetFileEditorForModule(Module, i);

      if Supports(IEditor, IOTASourceEditor, ISourceEditor) then
        begin
          if Assigned(ISourceEditor) then
            begin
              if (FileName = '') or SameFileName(ISourceEditor.FileName, FileName) then
                begin
                  Result := ISourceEditor;
                  Break;
                end;
            end;
        end;
    end;
end;


function OtaGetTopMostEditBuffer: IOTAEditBuffer;
var
  EditorServices: IOTAEditorServices;
begin
  EditorServices := (BorlandIDEServices as IOTAEditorServices);
  Assert(Assigned(EditorServices));
  Result := EditorServices.TopBuffer;
end;

function OtaGetCurrentSourceEditor: IOTASourceEditor;
var
  EditBuffer: IOTAEditBuffer;
begin
  Result := nil;
  EditBuffer := OtaGetTopMostEditBuffer;
  if Assigned(EditBuffer) and (EditBuffer.FileName <> '') then
    Result := OtaGetSourceEditorFromModule(OtaGetCurrentModule, EditBuffer.FileName);
  if Result = nil then
    Result := OtaGetSourceEditorFromModule(OtaGetCurrentModule);
end;

function OtaGetActiveEditorText(Stream: TStream; UseSelection: Boolean): Boolean;
var
  ISourceEditor: IOTASourceEditor;
  IEditView: IOTAEditView;
  IEditReader: IOTAEditReader;
  BlockSelText: string;
begin
  Assert(Stream <> nil);

  Result := False;

  ISourceEditor := OtaGetCurrentSourceEditor;
  if ISourceEditor = nil then
    Exit;

  if ISourceEditor.EditViewCount > 0 then
    begin
      IEditView := OtaGetTopMostEditView(ISourceEditor);
      Assert(IEditView <> nil);

      if (IEditView.Block.Size > 0) and UseSelection then
        begin
          BlockSelText := IEditView.Block.Text;
          Stream.WriteBuffer(PChar(BlockSelText)^, Length(BlockSelText) + SizeOf(#0));
          Result := True;
        end
      else
        begin
          IEditReader := ISourceEditor.CreateReader;
          OtaSaveReaderToStream(IEditReader, Stream);
          Result := False;
        end;
    end;
end;


function OtaGetActiveEditorTextAsString(var Text: string; UseSelection: Boolean): Boolean;
var
  StringStream: TStringStream;
begin
  StringStream := TStringStream.Create('');
  try
    Result := OtaGetActiveEditorText(StringStream, UseSelection);
    Text := StringStream.DataString;
  finally
    FreeAndNil(StringStream);
  end;
end;

function OtaGetCurrentModule: IOTAModule;
var
  ModuleServices: IOTAModuleServices;
begin
  ModuleServices := BorlandIDEServices as IOTAModuleServices;
  Assert(Assigned(ModuleServices));
  Result := ModuleServices.CurrentModule;
end;

function OtaGetProjectGroup: IOTAProjectGroup;
var
  IModuleServices: IOTAModuleServices;
  IModule: IOTAModule;
  i: Integer;
begin
  Assert(Assigned(BorlandIDEServices));

  IModuleServices := BorlandIDEServices as IOTAModuleServices;
  Assert(Assigned(IModuleServices));

  Result := nil;
  for i := 0 to IModuleServices.ModuleCount - 1 do
    begin
      IModule := IModuleServices.Modules[i];
      if Supports(IModule, IOTAProjectGroup, Result) then
        Break;
    end;
end;

function OtaGetCurrentProject: IOTAProject;
var
  IProjectGroup: IOTAProjectGroup;
  IModuleServices: IOTAModuleServices;
  IModule: IOTAModule;
  i: Integer;
begin
  Result := nil;

  IProjectGroup := OtaGetProjectGroup;
  if not Assigned(IProjectGroup) then
    begin
      Assert(Assigned(BorlandIDEServices));
      IModuleServices := BorlandIDEServices as IOTAModuleServices;
      Assert(Assigned(IModuleServices));

      for i := 0 to IModuleServices.ModuleCount - 1 do
        begin
          IModule := IModuleServices.Modules[i];
          if Supports(IModule, IOTAProject, Result) then
            Break;
        end;
    end;

  try
    // This raises exceptions in D5 with .bat projects active
    if Assigned(IProjectGroup) and (not Assigned(Result)) then
      Result := IProjectGroup.ActiveProject;
  except
    Result := nil;
  end;
end;

function OtaGetCurrentProjectName: string;
var
  IProject: IOTAProject;
begin
  Result := '';
  IProject := OtaGetCurrentProject;
  if Assigned(IProject) then
    begin
      Result := ExtractFileName(IProject.FileName);
      Result := ChangeFileExt(Result, '');
    end;
end;

end.