ttoolsapihelperunit.pas

CVS IDE plugin for Borland Delphi this is a good program,i like this kind of practise

(* $Id: TToolsApiHelperunit.pas,v 1.8 2003/01/08 19:42:37 turbo Exp $
 *
 * Hides the OpenToolsAPI from the rest of the wizard
 * enapsulates all functions that are needed
 *
 * Copyright 2001 by Thomas Bleier
 * For license details see LICENSE.txt
 *)

unit TToolsApiHelperunit;
{$I BORCVS.inc}
interface
//---------------------------------------------------------------------------
uses toolsapi,
  classes;

//---------------------------------------------------------------------------
type
  TToolsApiHelper = class(TObject)
  private
    function FixXMLextension(const s: string): string;
  protected
//    FCurrentProject: IOTAProject;
//    FCurrentProjectGroup: IOTAProjectGroup;
//    FCurrentProjectGroupFile: string;
//    FMainFile: string;
    function GetModuleForFile(filename: string): IOTAModule;
  public
    constructor create;
    destructor destroy; override;

    function HasProjectGroup: boolean;
    function GetCurrentProjectGroup: IOTAProjectGroup;
    function GetCurrentProjectGroupFile: string;
    function GetCurrentProjectGroupFiles(filelist: TStrings; fLowerCase: boolean = false): boolean;

    function GetCurrentProject: IOTAProject;
    function GetCurrentProjectFile: string;
    function GetCurrentProjectFiles(filelist: TStrings; fLowerCase: boolean = false): boolean;
    function GetProjectFiles(aProject: IOTAProject; filelist: TStrings; fLowerCase: boolean = false): boolean;

    function GetCurrentModule: IOTAModule;
    function GetCurrentModuleFile: string;
    function GetCurrentModuleFiles(files: TStrings; fLowerCase: boolean =
      false): boolean;

    function CloseAll: boolean;
    function SaveAll: boolean;
    function OpenProject(projectfile: string): boolean;
    function OpenFile(filename: string): boolean;
    function CloseFile(filename: string): boolean;
    function OpenFileInEditor(filename: string; lineno: integer): boolean;
    function ReloadFile(filename: string): boolean;
    procedure InitMessages;
    procedure AddMessage(filename: string; msg: string; prefix: string; line:
      integer);
    procedure FlushCache;
    function GetMainFile: string;

  end;
//---------------------------------------------------------------------------
var
  ToolsApiHelper: TToolsApiHelper;
//---------------------------------------------------------------------------
(* $Id: TToolsApiHelperunit.pas,v 1.8 2003/01/08 19:42:37 turbo Exp $
 *
 * Copyright 2001 by Thomas Bleier
 * For license details see LICENSE.txt
 *)

implementation
uses
  windows,
  Forms,
  SysUtils,
  ActnList,
  Utilityunit,
  PELDebugit;
//---------------------------------------------------------------------------

procedure AddToFileList(filelist: TStrings; fLowerCase: boolean;
  item: string);
begin
//  DebugStrF('AddToFileList(%s)', [item]);

  if (FileExists(item)) then
  begin
    if (fLowerCase) then
      item := LowerCase(item);
    if (filelist.IndexOf(item) < 0) then
      filelist.Add(item);
  end
end;

procedure ShellExec(cmdline: string);
var
  si: TSTARTUPINFO;
  pi: PROCESS_INFORMATION;
begin
  ZeroMemory(@si, sizeof(si));
  ZeroMemory(@pi, sizeof(pi));
  si.cb := sizeof(si);
  si.dwFlags := 0;
  if (CreateProcess(nil, pchar(cmdline), nil, nil, true, 0, nil, nil, si,
    pi)) then
  begin
    CloseHandle(pi.hThread);
    CloseHandle(pi.hProcess);
  end
  else
  begin
    RaiseLastOSError;
  end;
end;

{ TToolsApiHelper }

procedure TToolsApiHelper.AddMessage(filename, msg, prefix: string;
  line: integer);
var
  msgserv: IOTAMessageServices;
begin
  msgserv := BorlandIDEServices as IOTAMessageServices;
  if assigned(msgserv) then
  begin
    msgserv.AddToolMessage(filename, msg, prefix, line, 1);
  end;
end;

function TToolsApiHelper.CloseAll: boolean;
var
  modserv: IOTAModuleServices;
begin
  result := false;
  modserv := BorlandIDEServices as IOTAModuleServices;
  if assigned(modserv) then
  begin
    FlushCache;
    result := modserv.CloseAll;
  end;
end;

function TToolsApiHelper.CloseFile(filename: string): boolean;
var
  module: IOTAModule;
begin
  result := false;
  module := GetModuleForFile(filename);
  if assigned(module) then
  begin
    FlushCache;
    result := module.CloseModule(true);
  end;
end;

constructor TToolsApiHelper.create;
begin
//  inherited create;
  FlushCache;
end;

destructor TToolsApiHelper.destroy;
begin
//  inherited free;
end;

procedure TToolsApiHelper.FlushCache;
begin
//  FCurrentProject := nil;
//  FCurrentProjectGroup := nil;
//  FCurrentProjectGroupFile := '';
//  FMainFile := '';
end;

function TToolsApiHelper.GetCurrentModuleFile: string;
var
  modserv: IOTAModuleServices;
  module: IOTAModule;
begin
  modserv := BorlandIDEServices as IOTAModuleServices;
  if assigned(modserv) then
  begin
    module := modserv.CurrentModule;
    if assigned(module) then
    begin
      result := module.GetFileName;
      result := FixXMLextension(result);
    end;
  end;
end;

function TToolsApiHelper.FixXMLextension(const s: string): string;
begin
      // when editing the project file, BCB returns XYZ.bpr.xml as the
      // filename, but the real file is XYZ.bpr.xml
  result := s;
  if LowerCase(ExtractFileExt(result)) = '.xml' then
  begin
    if LowerCase(copy(result, Length(result) - 7, 255)) =
      '.bpr.xml' then
      result := copy(result, 1, Length(result) - 4);
  end;
end;

function TToolsApiHelper.GetCurrentModuleFiles(files: TStrings;
  fLowerCase: boolean): boolean;
var
  module: IOTAModule;
  editor: IOTAEditor;
  filecount, i: integer;
  name: string;
begin
  module := GetCurrentModule;
  if assigned(module) then
  begin
    filecount := module.GetModuleFileCount;
    for i := 0 to filecount - 1 do
    begin
        // GetModuleFileEditor raises an exception when the module has just
        // .cpp and .h files and no .dfm file. In that case, GetModuleFileCount
        // is 2, GetModuleFileEditor(0) returns the .cpp file, GetModuleFileEditor(1)
        // raises the exception and GetModuleFileEditor(2)!!!! returns the .h file
        // so we loop until i<_=_ module.GetModuleFileCount
      try
        editor := module.GetModuleFileEditor(i);
        if assigned(editor) then
        begin
          name := editor.FileName;
            // when editing the project file, BCB returns XYZ.bpr.xml as the
            // filename, but the real file is XYZ.bpr.xml
          name := FixXMLextension(name);
          files.Add(name);
        end;
      except
      end;
    end;
  end;
  result := files.Count > 0;
end;

function TToolsApiHelper.GetCurrentProjectFile: string;
var
  project: IOTAProject;
begin
  result := '';
  project := GetCurrentProject;
  if assigned(project) then
  begin
    result := project.FileName;
  end;
end;

function TToolsApiHelper.GetCurrentProjectGroupFile: string;
var
  projgroup: IOTAProjectGroup;
begin
  result := '';
  projgroup := GetCurrentProjectGroup;
  if assigned(projgroup) then
  begin
    result := projgroup.FileName;
  end;
end;

function TToolsApiHelper.GetMainFile: string;
begin
  result := ToolsApiHelper.GetCurrentProjectGroupFile;
  if (result = '') or (not FileExists(result)) then
    result := ToolsApiHelper.GetCurrentProjectFile;
  if (not FileExists(result)) then
    result := '';
end;

function TToolsApiHelper.GetModuleForFile(filename: string): IOTAModule;
var
  modserv: IOTAModuleServices;
begin
  result := nil;
  modserv := BorlandIDEServices as IOTAModuleServices;
  if assigned(modserv) then
  begin
    result := modserv.FindModule(filename);
    if (result = nil) then
    begin
      //  this is not very elegant, search for a better solution
      if LowerCase(ExtractFileExt(filename)) = '.dfm' then
      begin
        filename := ChangeFileExt(filename, '.cpp');
        result := modserv.FindModule(filename);
        if (result = nil) then
        begin
          filename := ChangeFileExt(filename, '.pas');
          result := modserv.FindModule(filename);
        end;
      end;
    end;
  end;
end;