IOTA-Frage zur Callbarkeit von Procs unterschiedlicher Notifier untereinander

[r29d43]

Hallo!

Bei normalen Delphi-Programmen ist das ja so extrem einfach von einer Proc des einen Formulars eine Proc eines anderen Formulars zu callen. Man setzt einfach die Variable von Formular B dessen Proc C man aufrufen möchte vor den Proc-Namen (= B.C(bla); ) und schon hat man diese Proc aus einer Form A heraus gecallt. Noch einfacher kann es nicht mehr gehen!

Nur - wie macht man das Gleiche eigentlich zwischen den Procs von unterschiedlichen Notifiern innerhalb eines IOTA-Packages, in welchem ich diese unterschiedlichen Notifier natürlich immer in einer jeweils nächsten Unit separat deklariert habe? Denn hier steht unter dem jeweilig einzelnen Notifier doch gar keine diesbezügliche Notifier-Variable!

?

Thx im Voraus

[himitsu]

Du nimmst dir das andere Notifier-Interface und rufst die gewünschte Callback-Methode auf.

Aber wozu?
In der IOTA sind es MultiCaller, also man kann mehrere Notifier-Interfaces registrieren und die werden (vermutlich in Reihenfolge der Registrierung) nacheinander aufgerufen.

[r29d43]

Vermutlich habe ich meine Situation zu ungenau beschrieben. Es geht einfach um alle Procedures und Functions und ebenso alle Variablen, die in einer Notifier-Ableitung jeweils „Public“ deklariert sind, und auf die ich von anderen Teilen meines Packages, also aus z.B. auch anderen Notifiers (die in anderen Units deklariert sind) zugreifen können möchte.

Beispiel: Ein von mir deklarierter Notifier sieht ungefähr so aus

Delphi-Quellcode:

unit readEditorCode_Unit; 

interface

uses ToolsAPI, Winapi.Windows, Winapi.Messages, Registry, vcl.ExtCtrls, vcl.Controls, system.Rtti,

TIDENotifier = class(TNotifierObject, IOTANotifier, IOTAIDENotifier)
    Timer1 : TTimer;
    procedure Timer1Timer(Sender: TObject);
  private
    ...
  public
    // IOTAIDENotifier
    VarXYZ : integer;           // <--------
    procedure FileNotification(NotifyCode: TOTAFileNotification; const FileName: string; var Cancel: Boolean);
    procedure BeforeCompile(const Project: IOTAProject; var Cancel: Boolean); overload;
    procedure AfterCompile(Succeeded: Boolean); overload;
    constructor Create;
    destructor Destroy; override;
    procedure ProcABC;           // <--------
  end; { of "TIDENotifier = class() }

var
  NotifierIndex: Integer = -1;

procedure Register;

implementation

uses vcl.Dialogs, system.SysUtils, shellapi, EditServiceNotifer;

procedure Register;
var
  Services: IOTAServices;
begin
  if not Supports(BorlandIDEServices, IOTAServices, Services) then Exit;
  NotifierIndex := Services.AddNotifier(TIDENotifier.Create);
end;

usw. usf..

Wäre dieses TIDENotifier jetzt eine TForm in einem normalen Delphi-Programm, dann würde in der obigen Var-Deklaration direkt unter der TIDENotifier-Deklaration auch noch sowas stehen wie

var
IdeNotifier : TIDENotifier;
NotifierIndex: Integer = -1;

und man könnte aus anderen Units leicht auf diese obige Public-Var "VarXYZ" zugreifen, ala

andereVar := IdeNotifier.VarXYZ;

oder die Public-Proc "ProcABC" callen per

IdeNotifier.ProcABC;

Diese Procs müssen jetzt noch nichtmal irgendwelche normalen Event-Handler sein, die angesprungen werden, wenn bestimmte Ereignisse eingetreten sind. Sondern das sollen auch ganz normale Procs sein dürfen, die einfach mal aus irgendeinem anderen Notifier callbar sein sollen.

Was aber aufgrund der in IOTA-Packages fehlenden <IdeNotifer : TIDENotifer> -Zeile da jetzt leider nicht geht.

Oder wie geht das doch?

[himitsu]

Dann speicher dir die Interface-Referenz deines Notifiers.
Gib deiner Notifier-Klasse auch noch ein eigenes Interface (für den Zugriff auf das was du sonst noch willst)
und schon kann man das ebenfalls ausführen.

[Uwe Raabe]

Zitat:

Zitat von r29d43 (Beitrag 1490124)

Was aber aufgrund der in IOTA-Packages fehlenden <IdeNotifer : TIDENotifer> -Zeile da jetzt leider nicht geht.

Würde es das geben, wie sollte man dann mit mehreren Notifier-Instanzen des gleichen Typs umgehen?

(Das gilt übrigens analog auch für mehrere Form-Instanzen, weshalb diese globalen Variablen für viele Entwickler sogar tabu sind und gezielt gelöscht werden.)

[r29d43]

@himitsu. Kannst du das vllt. noch etwas genauer erklären? Thx.


@Uwe Raabe. Genauso wie ich auch mit mehreren Form-Instanzen eines gleichen Form-Typs umgehen würde? Die ich dann nämlich gleich dynamisch erzeugen würde. Und dann wäre auch der Rest meines Progs schon darauf eingestellt und könnte damit auch umgehen.

[Uwe Raabe]

Zitat:

Zitat von r29d43 (Beitrag 1490134)

Genauso wie ich auch mit mehreren Form-Instanzen eines gleichen Form-Typs umgehen würde? Die ich dann nämlich gleich dynamisch erzeugen würde. Und dann wäre auch der Rest meines Progs schon darauf eingestellt und könnte damit auch umgehen.

Aber erzeugst du die Notifier nicht auch dynamisch?

[r29d43]

Zitat:

Zitat von Uwe Raabe (Beitrag 1490136)

Aber erzeugst du die Notifier nicht auch dynamisch?

Besten Dank für den Tipp, hat funktioniert.

Ich habe das obige Beispiel jetzt in der Register-Proc dementsprechend umgebaut, so dass ich nun faktisch die gleichen Bedingungen habe, wie in einem normalen Delphi-Prog bzgl. der dort jeweils deklarierten Formularen:

Delphi-Quellcode:

unit readEditorCode_Unit; 

interface

uses ToolsAPI, Winapi.Windows, Winapi.Messages, Registry, vcl.ExtCtrls, vcl.Controls, system.Rtti,

TIDENotifier = class(TNotifierObject, IOTANotifier, IOTAIDENotifier)
    Timer1 : TTimer;
    procedure Timer1Timer(Sender: TObject);
  private
    ...
  public
    // IOTAIDENotifier
    VarXYZ : integer;           // <--------
    procedure FileNotification(NotifyCode: TOTAFileNotification; const FileName: string; var Cancel: Boolean);
    procedure BeforeCompile(const Project: IOTAProject; var Cancel: Boolean); overload;
    procedure AfterCompile(Succeeded: Boolean); overload;
    constructor Create;
    destructor Destroy; override;
    procedure ProcABC;           // <--------
  end; { of "TIDENotifier = class() }

var
  IDENotifier1 : TIDENotifier;
  NotifierIndex: Integer = -1;

procedure Register;

implementation

uses vcl.Dialogs, system.SysUtils, shellapi, EditServiceNotifer;

procedure Register;
var
  Services: IOTAServices;
begin
  if not Supports(BorlandIDEServices, IOTAServices, Services) then Exit;
  IDENotifier1 := TIDENotifier.Create;
  NotifierIndex := Services.AddNotifier(IDENotifier1);
end;

usw. usf..

[himitsu]

Nein, niemals Objekt-Referenzen und Interfaces mischen.

Gib deinen Klassen zusätzlich ein "eigenes" Interface, und speichere dir davon die Referenz in einer Variable.

Delphi-Quellcode:

type
  IMyIDENotifier = interface
    function GetXYZ: Integer;
    procedure SetXYZ(Value: Integer);

    procedure ProcABC;
    property XYZ: Integer read GetXYZ write SetXYZ;
  end;

  TMyIDENotifier = class(TNotifierObject, IOTANotifier, IOTAIDENotifier, IMyIDENotifier)
    Timer1 : TTimer;
    procedure Timer1Timer(Sender: TObject);
  private
    FXYZ : integer;
    function GetXYZ: Integer;
    procedure SetXYZ(Value: Integer);
  protected
    // 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;
  public
    constructor Create;
    destructor Destroy; override;
    // IMyIDENotifier
    procedure ProcABC;
    property XYZ: Integer read GetXYZ write SetXYZ;
  end; { of "TIDENotifier = class() }

var
  MyIDENotifier: IMyIDENotifier;
  NotifierIndex: Integer = -1;

procedure Register;

implementation

procedure Register;
var
  Services: IOTAServices;
begin
  if not Supports(BorlandIDEServices, IOTAServices, Services) then Exit;
  MyIDENotifier := TIDENotifier.Create;
  NotifierIndex := Services.AddNotifier(MyIDENotifier as IOTANotifier);

Im Interface ist alles Public,
aber was wo in der Klasse ist, ist dem Objekt egal. Hauptsache die Methoden existieren irgendwo und sind von der Position aus zugreifbar,
was auch in einem Vorfahren sein kann, wie z.B. die Methoden für IOTANotifier und IInterface.


Und nicht zu vergessen:

Delphi-Quellcode:

finalization  // oder "class destructor TMyIDENotifier.Destroy;"
  ...
  MyIDENotifier := nil;
  Services.RemoveNotifier(NotifierIndex);

[r29d43]

Dank auch dafür.

Zitat:

Zitat von himitsu (Beitrag 1490143)

Nein, niemals Objekt-Referenzen und Interfaces mischen.

Gib deinen Klassen zusätzlich ein "eigenes" Interface, und speichere dir davon die Referenz in einer Variable.

Allerdings solltest du jetzt event. auch noch genau erklären warum. (Weil meine Lösung sieht dagegen ja eigentlich viel naheliegender und einfacher aus).