Komponente vor dem Platzieren umbenennen / OpenTools API

[CG2003]

Hallo liebe DP,

ich versuche mich gerade an einem kleinen IDE-Experten, mit dem ich Komponenten umbenennen kann, während ich sie auf die Form ziehe. Sowas gibt es ja schon: CNA - Component Naming Assistant,
aber ich will mein eigenes schreiben!

Dazu habe ich folgenden Code im Internet gefunden:

Delphi-Quellcode:

unit ComponentPrefixExpert;

interface 

procedure Register; 

implementation 

uses Windows, SysUtils, Controls, Classes, ToolsAPI, Dialogs; 

type 
  TPPWIdeNotifier = class( TNotifierObject, IOTANotifier, IOTAIDENotifier) 
  public 
    constructor Create; 
    destructor Destroy; override; 
    { IOTAIDENotifier } 
    procedure FileNotification(NotifyCode: TOTAFileNotification; 
      const FileName: string; var Cancel: Boolean); 
    procedure BeforeCompile(const Project: IOTAProject; var Cancel: Boolean); overload; 
    procedure AfterCompile(Succeeded: Boolean); //overload; 
  end; 

  TPPWFormNotifier = class( TNotifierObject, IOTANotifier, IOTAFormNotifier ) 
  private 
    FFileName : String; 
  public 
    constructor Create( FileName : String ); 
    destructor Destroy; override; 
    procedure FormActivated; 
    procedure FormSaving; 
    procedure ComponentRenamed(ComponentHandle: TOTAHandle; 
      const OldName, NewName: string); 
    { IOTAModuleNotifier } 
  end; 

  TPPWModuleNotifier = class( TNotifierObject, IOTANotifier, IOTAModuleNotifier ) 
  private 
    FOldFileName : String; 
    FFileName    : String; 
  public 
    constructor Create (Const FileName : String); 
    destructor destroy; override; 
    { IOTAModuleNotifier } 
    function CheckOverwrite : Boolean; 
    procedure ModuleRenamed(const NewName: string); 
  end; 

var 
  Index : Integer; 
  NotifierList : TStringList; 

procedure Register; 
begin 
  Index := (BorlandIDEServices as IOTAServices).AddNotifier(TPPWIdeNotifier.Create); 
end; 


{ TPPWIdeNotifier } 

procedure TPPWIdeNotifier.AfterCompile(Succeeded: Boolean); 
begin 
end; 

procedure TPPWIdeNotifier.BeforeCompile(const Project: IOTAProject; 
  var Cancel: Boolean); 
begin 
end; 

constructor TPPWIdeNotifier.Create; 
begin 
  Inherited Create;
  ShowMessage ('TPPWIdeNotifier created');
end;

destructor TPPWIdeNotifier.Destroy;
begin
  ShowMessage (' Destroying TPPWIdeNotifier ');
  ShowMessage (' Notifiers Left : ' + inttostr(NotifierList.Count));
  inherited Destroy; 
end; 

procedure TPPWIdeNotifier.FileNotification( 
  NotifyCode: TOTAFileNotification; const FileName: string; 
  var Cancel: Boolean); 
var 
  Module         : IOTAModule; 
  Editor         : IOTAEditor; 
  FormEditor     : IOTAFormEditor; 
  ModuleNotifier : TPPWModuleNotifier; 
  FormNotifier   : TPPWFormNotifier; 

  IModuleNotifier : Integer; 
  FormNotifierI, ListI, I : Integer; 
begin 
  Case NotifyCode of 
    ofnFileOpened : 
    begin 
      { Get the IOTAModule associated to this File } 
      Module := ( BorlandIDEServices as IOTAModuleServices ).FindModule(FileName); 
      { Loop over the number of associated File } 
      for i := 0 to Module.GetModuleFileCount - 1 do 
      begin 
        { Get the FileEditor } 
        Editor := Module.GetModuleFileEditor(i); 
        if Editor.QueryInterface( IOTAFormEditor, FormEditor ) = S_OK then 
        begin 
          { If the File Editor is a FormEditor then Add Our Notifier } 
          FormNotifier := TPPWFormNotifier.Create( FileName ); 
          FormNotifierI := FormEditor.AddNotifier ( FormNotifier ); 
          if FormNotifierI < 0 then 
          begin 
            FormNotifier.Free; 
          end 
          else 
          begin 
            ShowMessage( 'Notifier Index' + inttostr( FormNotifierI )); 
            NotifierList.AddObject(FileName, Pointer(FormNotifierI)); 
          end; 
          { Also Add a module Notifier } 
          ModuleNotifier := TPPWModuleNotifier.Create( FileName ); 
          IModuleNotifier := Module.AddNotifier( ModuleNotifier ); 
          if IModuleNotifier < 0 then 
          begin 
            ModuleNotifier.Free; 
          end; 
        end 
      end; 
    end; 
    ofnFileClosing : 
    begin 
      if NotifierList.Find(FileName, ListI) then 
      begin 
        Module := ( BorlandIDEServices as IOTAModuleServices ).FindModule(FileName); 
        FormNotifierI := Integer(NotifierList.Objects[ListI]); 
        for i := 0 to Module.GetModuleFileCount - 1 do 
        begin 
          Editor := Module.GetModuleFileEditor(i); 
          if Editor.QueryInterface( IOTAFormEditor, FormEditor ) = S_OK then 
          begin 
            FormEditor.RemoveNotifier ( FormNotifierI ); 
            NotifierList.Delete(ListI); 
          end; 
        end; 
      end; 
    end; 
  end; 
end; 

{ TPPWFormNotifier } 

procedure TPPWFormNotifier.ComponentRenamed(ComponentHandle: TOTAHandle;
  const OldName, NewName: string);
var
  Module         : IOTAModule;
  Editor         : IOTAEditor;
  FormEditor     : IOTAFormEditor;
  OTAComponent: IOTAComponent;
  Component: IComponent;
  I: Integer;
  
begin
  if not FRenaming then
  try
    FRenaming := True;
    Module := ( BorlandIDEServices as IOTAModuleServices ).FindModule(FFileName);
    for i := 0 to Module.GetModuleFileCount - 1 do
    begin
      Editor := Module.GetModuleFileEditor(i);
      if Editor.QueryInterface( IOTAFormEditor, FormEditor ) = S_OK then
      begin
        OTAComponent := FormEditor.FindComponent(OldName);
        if OTAComponent = nil then ShowMessage('OTAComponent not found.')
                              else
        begin
          Component := OTAComponent.GetIComponent;
          if Component = nil then ShowMessage('IComponent not found')
                             else Component.Name := 'Test' + NewName;
        end;
      end
    end;
  finally
    FRenaming := False;
  end;
end;
constructor TPPWFormNotifier.Create( FileName : String ); 
begin 
  inherited Create; 
  FFileName := FileName; 
  ShowMessage ('Form Notifier Created for File : ' + FileName ); 
end; 

destructor TPPWFormNotifier.destroy; 
begin 
  ShowMessage ('Form Notifier Destroyed for File : ' + FFileName ); 
  inherited Destroy; 
end; 

procedure TPPWFormNotifier.FormActivated; 
begin 
{} 
end; 

procedure TPPWFormNotifier.FormSaving; 
begin 
{} 
end; 

{ TPPWModuleNotifier } 

function TPPWModuleNotifier.CheckOverwrite: Boolean; 
begin 
  Result := True; 
end; 

constructor TPPWModuleNotifier.Create(const FileName: String); 
begin 
  inherited Create; 
  FOldFileName := FileName; 
  FFileName := FileName; 
  ShowMessage ('Module Notifier Created for file : ' + FOldFileName); 
end; 

destructor TPPWModuleNotifier.destroy; 
begin 
  ShowMessage ('Module Notifier Destroyed for file : ' + FFileName); 
  inherited; 
end; 

procedure TPPWModuleNotifier.ModuleRenamed(const NewName: string); 
var 
  ListI         : Integer; 
  FormNotifierI : Integer; 
begin 
  if NotifierList.Find(FOldFileName, ListI) then 
  begin 
    FormNotifierI := Integer(NotifierList.Objects[ListI]); 
    NotifierList.Delete(ListI); 
    NotifierList.AddObject(NewName, Pointer(FormNotifierI)); 
  end; 
  FOldFileName := NewName; 
  FFileName := NewName; 
  inherited ; 
end; 

initialization 
  NotifierList := TStringList.Create;
  NotifierList.Sorted := True;

finalization
  (BorlandIDEServices as IOTAServices).RemoveNotifier(Index);
  NotifierList.Free;
end.

Das Problem ist nur, das er weder "FRenaming" noch "IComponent" findet/kennt.
Oder gibt es eine einfachere Variante eine Art "on the fly Komponenten-Umbenenner" zu entwickeln?

Bin für jeden Hinweis/Tip dankbar!

[CG2003]

*push*

[mkinzler]

Wird ja auch von anderen Extensions gemacht, da diese teilweise OS sind (JVCL, CnExperts ) kannst du dir ja mal die Quellcodes anschauen.

[CG2003]

Zitat von mkinzler:

Wird ja auch von anderen Extensions gemacht, da diese teilweise OS sind (JVCL, CnExperts ) kannst du dir ja mal die Quellcodes anschauen.

ja, ich weiß, doch das Problem ist, das diese viel zu unübersichtlich und viel zu sehr ineinander verstrickt sind, so dass ich da ehrlich gesagt die o.g. gesuchte Funktionalität leider nicht nachvollziehen kann.

[CG2003]

So, habe jetzt meinen FormNotifier soweit geändert, das er erkennt, das eine Komponente umbenannt wird/werden soll, bzw. er erkennt auch, das eine Komponente auf das Formular gezogen wird.

Mit dem Aufruf

SetPropValue(Instance, 'Caption', 'Test'); will ich nun das Property "Name", also die Komponentenbezeichnung in "Test" ändern.
Er durchläuft zwar diesen Aufruf und führt Ihn aus, jedoch wird der Name nicht geändert.


Hier nochmal der FormNotifier:

Delphi-Quellcode:

procedure TPPWFormNotifier.ComponentRenamed(ComponentHandle: TOTAHandle;
  const OldName, NewName: string);
var
  Module         : IOTAModule;
  Editor         : IOTAEditor;
  FormEditor     : IOTAFormEditor;
  OTAComponent: IOTAComponent;
  Component: IOTAComponent;
  I: Integer;
  Instance : TComponent;
  C1, C2: TPersistentClass;
  Match: Boolean;
  begin
  if not FRenaming then
  try
    FRenaming := True;
    Module := ( BorlandIDEServices as IOTAModuleServices ).FindModule(FFileName);
        ShowMessage('Module FindModule OK');
    Instance := TComponent(ComponentHandle);
            ShowMessage('Instance = ComponentHandle');
  if not Assigned(ComponentHandle) then begin
    ShowMessage('ComponentHandle not assignes!');
    Exit;
      end;
  Instance := TComponent(ComponentHandle);
  begin
        SetPropValue(Instance, 'Name', 'Test');
        ShowMessage('SetPropValue OK');
//    end;
        end;
//      end
  finally
    FRenaming := False;
  end;
end;

Hoffe, es kann mir einer helfen!

[CG2003]

~push~

[chaosben]

Irgendwie hab ich Lust einfach nur "ooooooch" drunter zu schreiben.

Aber was solls: Wir erreichen das von dir gewünschte mit der Prozedur "SetPropByName(...)".

[CG2003]

Zitat von chaosben:

Irgendwie hab ich Lust einfach nur "ooooooch" drunter zu schreiben.

Aber was solls: Wir erreichen das von dir gewünschte mit der Prozedur "SetPropByName(...)".

Danke.
Aber hättest Du vielleicht ein kleines Codebeispiel für mich?
Ich weiß ja noch nicht einmal, ob der Notifier so richtig definiert ist und vielleicht nur durch Zufall funktioniert?!

[chaosben]

also ein Beispiel:

Delphi-Quellcode:

var
  Compo : IOTAComponent
begin
  Compo:=Editor.FindComponent(OldName); //Editor ist der IOTAFormEditor
  Compo.SetPropByName('Name','NewName');
end;

[CG2003]

Erstmal danke für Dein Beispiel. Mein Aufruf für "ComponentRenamed" sieht jetzt so aus:

Delphi-Quellcode:

procedure TPPWFormNotifier.ComponentRenamed(ComponentHandle: TOTAHandle; 
  const OldName, NewName: string); 
var 
  Module         : IOTAModule; 
  Editor         : IOTAEditor; 
  FormEditor     : IOTAFormEditor; 
  Compo: IOTAComponent;
  I: Integer;

begin
  if not FRenaming then
  try
    FRenaming := True;
    Module := ( BorlandIDEServices as IOTAModuleServices ).FindModule(FFileName);
    for i := 0 to Module.GetModuleFileCount - 1 do
    begin
      Editor := Module.GetModuleFileEditor(i);
      if Editor.QueryInterface( IOTAFormEditor, FormEditor ) = S_OK then begin
        Compo := FormEditor.FindComponent(OldName);
        Compo.SetPropByName('Name','Testname');
      end 
    end; 
  finally 
    FRenaming := False; 
  end; 
end;

Wenn ich das Ganze jetzt aber als Package installieren, und eine Komponente aufs Formular ziehe, bekomme ich eine Zugriffsverletzung.

Habe ich vielleicht was falsch gemacht?