Delphi-PRAXiS - Delphi proceduren (Events) aus Interface

Seite 1 von 5

Delphi-PRAXiS (https://www.delphipraxis.net/forum.php)

- Programmieren allgemein (https://www.delphipraxis.net/40-programmieren-allgemein/)

- - Delphi proceduren (Events) aus Interface (https://www.delphipraxis.net/190149-proceduren-events-aus-interface.html)

proceduren (Events) aus Interface

Um nicht raten zu müssen welche Events für ein Fenster verwendet werden müssen
möchte ich die Proceduren für die Events über mein Interface veröffentlichen.

Geht das?

Das funktioniert nicht.
Nur als Beispiel..

Delphi-Quellcode:

			  ISkinBrowseForFile = interface

    // Ctrl + Shift + G

    ['{5CED6197-09C2-4A83-B679-A97430C670BD}']

    function GetHandle: HWND;

    function GetUseVistaBlur: BOOL;

    function GetUseVistaCrystal: BOOL;

    procedure WMEnterSizeMove(var Msg: TMessage); message WM_ENTERSIZEMOVE;     

    procedure WMSizing(var Msg: TMessage); message WM_SIZING;                   

    procedure WMMoving(var Msg: TMessage); message WM_MOVING;

Sagen wir das Interface wurde erstellt.
Dann möchte ich in meiner Proc bei WM_MOVING: die Message verarbeiten können.

Delphi-Quellcode:

procedure WMMoving(var Msg: TMessage); message WM_MOVING;

Ist ja eigentlich für VCL oder?

Hoffe hab das jetzt nicht zu blöd erfragt\erklärt..

EDIT:
Ok vielleicht noch etwas anders erklärt.
In der Beschreibung der Komponente wird mir mitgeteilt das ich 1 Event in meiner Form erstellen muss damit die Events aus der Komponente weitergeleitet werden können.
VCL!

Delphi-Quellcode:

			type

  TfrmChild2 = class(TForm)

public

  procedure WMMoving(var Msg: TMessage); message WM_MOVING;

end;

Delphi-Quellcode:

			procedure TfrmChild2.WMMoving(var Msg: TMessage);

begin

  // Hier werden jetzt die Messagen verarbeitet.

end;

1. Wenn ich jetzt keine Beschreibung der Komponente habe weiß ich auch nicht das ich das Event erstellen muss.
2. Leite ich WMMoving über mein Interface weiter und möchte dieses unter NONVCL verwenden dann funktioniert das nicht.

Beispiel:

Delphi-Quellcode:

			SkinBrowseForFile := TSkinBrowseForFile.create; // Interface erstellen

procedure SkinBrowseForFile.WMMoving(var Msg: TMessage); message WM_MOVING;

begin

end;

message WM_MOVING; ist unbekannt usw...

Würde nicht funktionieren.
Welche Lösung gäbe es dafür?

gruss

AW: proceduren (Events) aus Interface

Hmm irgend wie will das mal wieder nicht.

Delphi-Quellcode:

			  TSubClass_Proc = function(lng_hWnd: HWND; uMsg: Integer;

                            var Msg: Uint; var bHandled: Boolean) : boolean; stdcall;

 type

  ISkinMagnetic = interface

    ['{A00CB8B3-8433-4C58-9115-1845B29B3FF0}']

    function  GetSnapWidth: Integer;

    procedure SetSnapWidth(const Value: Integer);

    function  AddWindow(Handle: HWND; hWndParent: HWND; var FuncPointer : TSubClass_Proc): Boolean;

    property  SnapWidth: Integer read GetSnapWidth write SetSnapWidth;

    function  RemoveWindow(Handle: HWND): Boolean;

    function  SetFullWindowDrag(hwnd: DWORD; ShowFullWindow: Boolean): Boolean;

    procedure MagneticWindowDestroy;

    procedure zSubclass_Proc(var lng_hWnd: HWND;

                             var uMsg: Integer;

                             var wParam: Integer;

                             var lParam: Integer;

                             var lReturn: Integer;

                             var bHandled: Boolean);

  end;

Wie kann ich jetzt TSubClass_Proc über das Interface weiterleiten ohne in meiner externen Anwendung
TSubClass_Proc wieder zu definieren. ?

Ich bin mir nicht sicher ob ich dann mit der Funktion in Konflikt gerate.
Wenn sie nochmals außerhalb definiert wird.

gruss

AW: proceduren (Events) aus Interface

Erstens benutzt du ja die gleiche Unit (hoffentlich) in der externen DLL, insofern definierst du das ja nicht doppelt. Es wird aber in dem externen Speichermanager der DLL ein zweites Mal in den Speicher geladen, aber da beide kompatibel sind, ist das bei Funktionszeigern und Records kein Problem.

Zweitens wegen dem message Schlüsselwort, das musst du im Interface weglassen, da der Compiler damit nur etwas bei Klassen anfangen kann. Interfaces können nicht automatisch Messages abfangen.

Zu überlegen wäre, ob du nur bestimmer Messages erlauben willst, denn ansonsten könntest du auch einfach die WndProc durchleiten. Das wäre natürlich etwas langsamer.

AW: proceduren (Events) aus Interface

Zitat:

Zu überlegen wäre, ob du nur bestimmer Messages erlauben willst, denn ansonsten könntest du auch einfach die WndProc durchleiten. Das wäre natürlich etwas langsamer.

Jo nur bestimmte..

Mein Problem ist ein anderes.

Delphi-Quellcode:

			procedure WMMoving(var Msg: TMessage); //ohne  message WM_MOVING; aufgenommen in meinem Interface.
		

Delphi-Quellcode:

			var

  SkinBrowseForFile : ISkinBrowseForFile;

//--------------------------

SkinBrowseForFile := TSkinBrowseForFile.create; // Interface erstellen

procedure SkinBrowseForFile.WMMoving(var Msg: TMessage);

begin

end;

Bezeichner redefiniert.
Geht also nicht.
Hmm....

Zitat:

denn ansonsten könntest du auch einfach die WndProc durchleiten.

Das habe ich bisher gemacht aber dabei friert meine Anwendung ein.
Ich vermute bald mal das es einfach nicht geht. (Aufgeben.. LOL)

gruss

AW: proceduren (Events) aus Interface

Zitat:

Zitat von EWeiss (Beitrag 1346754)

Delphi-Quellcode:

			var

  SkinBrowseForFile : ISkinBrowseForFile;

//--------------------------

SkinBrowseForFile := TSkinBrowseForFile.create; // Interface erstellen

procedure SkinBrowseForFile.WMMoving(var Msg: TMessage);

begin

end;

Das ist eine Mischung zwischen Deklaration und Aufruf. Der Aufruf muss aber auf ein Interface erfolgen, das aus der DLL bereitgestellt wird. Deshalb verstehe ich gerade nicht was du an der Stelle versuchst.

Ich bin unterwegs und am Handy lässt sich Quelltext schlecht schreiben, deshalb einmal nur kurz die beiden Varianten...

Delphi-Quellcode:

			// Aufruf

procedure TfrmChild2.WMMoving(var Msg: TMessage);

var

  SkinBrowseForFile: ISkinBrowseForFile;

begin

  SkinBrowseForFile := TSkinBrowseForFile.Create;

  SkinBrowseForFile.WMMoving(Msg);

end;

Delphi-Quellcode:

			// Implementierung (in der DLL soweit ich verstanden habe)

Type

  TSkinBrowseForFile = class(TInterfacedObject, ISkinBrowseForFile)

  public

    procedure WMMoving(var Msg: TMessage);

  end;

procedure TSkinBrowseForFile.WMMoving(var Msg: TMessage);

begin

end;

AW: proceduren (Events) aus Interface

Danke dir werde es mal versuchen.. ;)

Zitat:

// Implementierung (in der DLL soweit ich verstanden habe)

Nein.. In der Anwendung.

Ich poste mal den richtigen Code..
Macht sonst keinen sinn.

Mein Interface in der DLL.

Delphi-Quellcode:

			  ISkinMagnetic = interface

    ['{A00CB8B3-8433-4C58-9115-1845B29B3FF0}']

    function  GetSnapWidth: Integer;

    procedure SetSnapWidth(const Value: Integer);

    function  AddWindow(Handle: HWND; hWndParent: HWND; var FuncPointer : TSubClass_Proc): Boolean;

    property  SnapWidth: Integer read GetSnapWidth write SetSnapWidth;

    function  RemoveWindow(Handle: HWND): Boolean;

    function  SetFullWindowDrag(hwnd: DWORD; ShowFullWindow: Boolean): Boolean;

    procedure MagneticWindowDestroy;

    procedure WMEnterSizeMove(var Msg: TMessage);

    procedure WMSizing(var Msg: TMessage);

    procedure WMMoving(var Msg: TMessage);

    procedure WMExitSizeMove(var Msg: TMessage);

    procedure WMSysCommand(var Msg: TMessage);

    procedure WMCommand(var Msg: TMessage);

    procedure zSubclass_Proc(lng_hWnd: HWND;

                             uMsg, wParam, lParam: Integer;

                             var lReturn: Integer;

                             var bHandled: Boolean);

  end;

  TMagnetic = class(TInterfacedPersistent, ISkinMagnetic)

    constructor Create;

    Destructor Destroy; Override;

   private

    FSnapWidth    : integer;

    m_uWndInfo    : array of TWND_INFO;

    m_rcWnd       : array of TRECT;

    m_lWndCount   : Integer;

    m_ptAnchor    : TPOINT;

    m_ptOffset    : TPOINT;

    m_ptCurr      : TPOINT;

    m_ptLast      : TPOINT;

    lOldSetting   : integer;

    function  GetSnapWidth: Integer;

    procedure SetSnapWidth(const Value: Integer);

    procedure pvSizeRect(Handle: HWND; var rcWnd: TRECT; lfEdge: Integer);

    procedure pvMoveRect(Handle: HWND; var rcWnd: TRECT);

    procedure pvCheckGlueing;

    function  pvWndsConnected(rcWnd1: TRECT; rcWnd2: TRECT): Boolean;

    function  pvWndGetInfoIndex(Handle: HWND): Integer;

    function  pvWndParentGetInfoIndex(hWndParent: HWND): Integer;

    procedure WMEnterSizeMove(var Msg: TMessage);

    procedure WMSizing(var Msg: TMessage);

    procedure WMMoving(var Msg: TMessage);

    procedure WMExitSizeMove(var Msg: TMessage);

    procedure WMSysCommand(var Msg: TMessage);

    procedure WMCommand(var Msg: TMessage);

   public

    function  AddWindow(Handle: HWND; hWndParent: HWND; var FuncPointer : TSubClass_Proc): Boolean;

    function  RemoveWindow(Handle: HWND): Boolean;

    procedure CheckGlueing;

    property  SnapWidth: Integer read GetSnapWidth write SetSnapWidth;

    function  SetFullWindowDrag(hwnd: DWORD; ShowFullWindow: Boolean): Boolean;

    procedure MagneticWindowDestroy;

    procedure zSubclass_Proc(lng_hWnd: HWND;

                             uMsg, wParam, lParam: Integer;

                             var lReturn: Integer;

                             var bHandled: Boolean);

  end;

Das Interface in der Anwendung.

Delphi-Quellcode:

			  ISkinMagnetic = interface

    ['{A00CB8B3-8433-4C58-9115-1845B29B3FF0}']

    function  GetSnapWidth: Integer;

    procedure SetSnapWidth(const Value: Integer);

    function  AddWindow(Handle: HWND; hWndParent: HWND; var FuncPointer : TSubClass_Proc): Boolean;

    property  SnapWidth: Integer read GetSnapWidth write SetSnapWidth;

    function  RemoveWindow(Handle: HWND): Boolean;

    function  SetFullWindowDrag(hwnd: DWORD; ShowFullWindow: Boolean): Boolean;

    procedure MagneticWindowDestroy;

    procedure WMEnterSizeMove(var Msg: TMessage);

    procedure WMSizing(var Msg: TMessage);

    procedure WMMoving(var Msg: TMessage);

    procedure WMExitSizeMove(var Msg: TMessage);

    procedure WMSysCommand(var Msg: TMessage);

    procedure WMCommand(var Msg: TMessage);

    procedure zSubclass_Proc(lng_hWnd: HWND;

                             uMsg, wParam, lParam: Integer;

                             var lReturn: Integer;

                             var bHandled: Boolean);

  end;

Diese proceduren kann ich dann in der Anwendung nicht erstellen.

Delphi-Quellcode:

			    procedure WMEnterSizeMove(var Msg: TMessage);

    procedure WMSizing(var Msg: TMessage);

    procedure WMMoving(var Msg: TMessage);

    procedure WMExitSizeMove(var Msg: TMessage);

    procedure WMSysCommand(var Msg: TMessage);

    procedure WMCommand(var Msg: TMessage);

Und ich glaube langsam das es auch nicht geht.

Zitat:

// Aufruf

Delphi-Quellcode:

			procedure TfrmChild2.WMMoving(var Msg: TMessage);

var

   SkinBrowseForFile: ISkinBrowseForFile;

begin

   SkinBrowseForFile := TSkinBrowseForFile.Create;

   SkinBrowseForFile.WMMoving(Msg);

end;

Das kann ich nicht da meine Anwendung NonVcL ist.
Sonst wäre es einfach. ;) und richtig so wie du es gepostet hast.
Das ist wieder so ein Spezial Fall.. LOL

Die Klasse TMagnetic funktioniert ja richtig mit VCL.
Ich möchte sie aber in meine DLL integrieren damit ich diese nicht bei jeden Projekt mit einbinden muss (als Datei).

Mich nerven schon die ganzen Proceduren in der "TMagnetic = class"
procedure WMSizing(var Msg: TMessage); usw. Aber ich muss sie einbinden (Obwohl ich sie in der TMagnetic eigentlich gar nicht benötige)
Nur wenn ich sie nicht einbinde kann ich sie auch nicht veröffentlichen.
Was für ein Kram ;)

gruss

AW: proceduren (Events) aus Interface

Als Ergänzung: Ich hätte jetzt so etwas erwartet...

Delphi-Quellcode:

			// in der DLL

unit DllPlugin;

uses

  PluginInterface;

type

  TPlugin = class(TInterfacedObject, IPlugin)

  private

    FSkinBrowseForFile: ISkinBrowseForFile;

    function GetSkinBrowseForFile: ISkinBrowseForFile;

  public

    property SkinBrowseForFile: ISkinBrowseForFile read GetSkinBrowseForFile;

  end;

// veröffentlichen als DLL Funktion

function InitPlugin: IPlugin;

begin

  Result := TPlugin.Create;

end;

exports

  InitPlugin

end.

Analog könntest du natürlich auch das hier genannte Interface so veröffentlichen, aber ich vermute das ist nicht das einzige.

Und dann in der Anwendung:

Delphi-Quellcode:

			uses

  PluginInterface;

var

  Plugin: IPlugin;

begin

  ...LoadLibrary...

  DllInitPlugin := GetProcAddress(...);

  Plugin := DllInitPlugin;

//...

  SkinBrowseForFile := Plugin.SkinBrowseForFile;

  SkinBrowseForFile.WMMoving(Msg);

AW: proceduren (Events) aus Interface

Delphi-Quellcode:

Als Ergänzung: Ich hätte jetzt so etwas erwartet...

Genauso habe ich es ja auch.
Nur meine Namensgebung ist etwas anders.

Delphi-Quellcode:

			// MagneticWindow

function CTRL_MagneticWindowCreate(): ISkinMagnetic; stdcall;

Der Export ist dann logischerweise "CTRL_MagneticWindowCreate"

In der Anwendung dann einfach

Delphi-Quellcode:

			{$REGION 'WM_CREATE'}

  case Msg of

    WM_CREATE:

      begin

        if not SKAERO_INIT then

          Halt;

        MagneticWnd := CTRL_MagneticWindowCreate;

      end;

{$ENDREGION}

Aber wie gesagt die Messagen machen Probleme.

Delphi-Quellcode:

MagneticWnd.WMMoving(Msg);

Das macht keine sinn auf diese Weise..
Wenn ich meine Anwendung über WM_MOVING ( also verschiebe)
Dann muss diese Procedure WMMoving aufgerufen werden damit die Messagen an meine DLL weitergeleitet werden
und das geht so nicht.

Etwas verworren das ganze.

gruss

AW: proceduren (Events) aus Interface

Zitat:

Zitat von EWeiss (Beitrag 1346759)

Aber wie gesagt die Messagen machen Probleme.

Delphi-Quellcode:

MagneticWnd.WMMoving(Msg);

Das macht keine sinn auf diese Weise..

// EDIT:
Weil du in der WndProc bist, das hatte ich überlesen. ;-)

Wie wäre es so:

Delphi-Quellcode:

			procedure TfrmChild2.WMMoving(var Msg: TMessage);

var

  MagneticWnd: IMagneticWnd;

begin

  MagneticWnd := CTRL_MagneticWindowCreate;

  MagneticWnd.WMMoving(Msg);

end;

Das ginge, allerdings sollte der Aufruf von CTRL_MagneticWindowCreate besser in das FormCreate und FMagneticWnd ein privates Feld sein. Dann kannst du direkt FMagneticWnd.WMMoving(Msg) aufrufen ohne vorher bei jeder Message das Interface aus der DLL neu zu holen (das wäre viel zu langsam, Messages sollten so schnell wie irgend möglich beantwortet werden).

AW: proceduren (Events) aus Interface

Delphi-Quellcode:

			procedure TfrmChild2.WMMoving(var Msg: TMessage);

var

   MagneticWnd: IMagneticWnd;

begin

   MagneticWnd := CTRL_MagneticWindowCreate;

   MagneticWnd.WMMoving(Msg);

end;

Wäre möglich aber nicht umsetzbar weil ich über keine Form verfüge.
Meine Form wird in NonVcl erstellt.

Delphi-Quellcode:

			    // Window erstellen

    MainHandle := CreateWindowEx(dwExStyle, myClass, myTitle, dwStyle, MainLeft, MainTop,

      MainWidth, MainHeight, 0, 0, wc.hInstance, nil);

gruss

Seite 1 von 5

Letzte »