Ereignisprogrammierung in Delphi

[mytar]

Jeder von uns kennt die ganz normalen Ereignisse im Objektinspektor (onClick, onExecute).

Aber wie werden diese Ereignisse eigentlich abgefangen?


Ich hab in meinem Programm eine einfache Datenstruktur (Array), ich möchte nun wissen,
wie ich ein Ereignisse schreibe, welches ausgelöst wird, wenn sich etwas im Array ändert.

So wie OnChange (z.B. bei TEdit, u.a), halt nur auf ein Array.

mytar

[mytar]

Kann mir hier niemand weiterhelfen?

mytar

[BluesKid]

Moin moin

Wie funktioniert Windows

und

Einführung in die Grundlagen der Win32API Programmierung

Sind glaub ich das was du suchst :-) allerdings denke ich nicht das (ok ich weiß nicht ob) es möglich ist zu überprüfen ob ein Array verändert wurde/wird...


schönen Gruß

Sam

[Albi]

Ich weiß jetzt nicht ob es genau das ist was du suchst aber such mal hier im DP nach Tastatureingabe abfangen usw. vielleicht hilft das weiter.

[mytar]

Hat das hier nicht irgendwie mit Ereignissen zu tun?

Delphi-Quellcode:

TMausAnzeige = procedure(Sender: TObject; Shift: TShiftState; X, Y: Integer) of Object;

mytar

[Steve]

Da ein Array keine Klasse ist, kannst Du einem Array nicht direkt ein Event zuweisen:

Zitat:

Zitat von Delphi OH

Der beim Eintritt eines Ereignisses ausgeführte Code ist eine Objektmethode

Als Eigenschaft einer Klasse bzw. eines Objekts könntest Du es in etwa so lösen:

Delphi-Quellcode:

type
  TMyArray = ARRAY[0..5] OF Byte;

  { Array bspw. als Eigenschaft von TForm1 }
  TForm1 = class(TForm)
    { ... }
    PROCEDURE ChangeArray(Sender: TObject);  // Beispiel für Ereignisbehandlung
  private
    FMyArray       : TMyArray;      // Hier das Array selbst
    FOnChangeArray : TNotifyEvent;  // Event
  public
    PROCEDURE SetMyArray(Value: TMyArray);    OVERLOAD;  // Routinen zum 
    PROCEDURE SetMyArray(index, Value: Byte); OVERLOAD;  // Schreiben und 
    FUNCTION  GetMyArray : TMyArray;                     // Lesen des Arrays 
    PROPERTY OnChangeArray : TNotifyEvent READ FOnChangeArray WRITE FOnChangeArray;  // Event
  end;

{...}

{ ************ Array besetzen ************  }
PROCEDURE TForm1.SetMyArray(Value: TMyArray);
BEGIN
  FMyArray := Value;
  IF Assigned(FOnChangeArray) THEN FOnChangeArray(NIL);  //  <<--- HIER wird Event "ausgelöst"
END;
{ ----------------------}
PROCEDURE TForm1.SetMyArray(index, Value: Byte);
BEGIN
  FMyArray[index] := Value;
  IF Assigned(FOnChangeArray) THEN FOnChangeArray(NIL);  //  <<--- HIER wird Event "ausgelöst"
END;

{ ************ Array auslesen ************  }
FUNCTION TForm1.GetMyArray : TMyArray;
BEGIN
  result := FMyArray;
END;

{ ********** Beispielanwendung ***********  }
procedure TForm1.Button1Click(Sender: TObject);
VAR
  arr : TMyArray;
  i   : Byte;
begin
  // Beispielwerte 
  FOR i:=Low(arr) TO High(arr) DO arr[i] := i;
  // Array setzen
  SetMyArray(arr);
  // Einezelnes Feld im Array setzen
  SetMyArray(2,99);
  // Array zurückgeben lassen
  arr := GetMyArray;
  // Ergebnis anzeigen
  ShowMessage(IntToStr(arr[0]) + #10#13 +
              IntToStr(arr[1]) + #10#13 +
              IntToStr(arr[2]) + #10#13 +
              IntToStr(arr[3]) + #10#13 +
              IntToStr(arr[4]) + #10#13);
end;


{ ******* Eregnisbehandlung zuweisen ********  }
procedure TForm1.Button2Click(Sender: TObject);
begin
  OnChangeArray := ChangeArray;
end;

{ *********** Eregnisbehandlung *************  }
procedure TForm1.ChangeArray(Sender: TObject);
begin
  ShowMessage('Array geändert!');
end;

Nicht komplett getestet...
Geht evtl auch einfacher..? :gruebel:
Aber als Beispiel zur Verdeutlichung vielleicht ja ganz brauchbar :mrgreen:

Gruß
Stephan

[maximov]

Hi,

Ein ist klar: Mit nem normalen array ist nicht möglich, da es keinen code gibt, der reagieren könnte. Aber, wie Steve schon sagte, könntest du für dein array einen klassen-wrapper schreiben. Und das würde ich mit einer array-property machen, denn dort kannst du im setter dein 'Onchanged' event auslösen und es würde nach aussen genau wie ein array aussehen :wink:

[Steve]

Ja stimmt, hatte das zunächst probiert, aber da kam wegen des Arrays ein Fehler, kam aber wohl daher, dass ich diese Property auf published statt public gesetzt hatte..

Die Klasse müsste dann an diesen Stellen geändert werden:

Delphi-Quellcode:

  private
    FMyArray       : TMyArray;
    FOnChangeArray : TNotifyEvent;
    PROCEDURE SetMyArray(Value: TMyArray);
    FUNCTION  GetMyArray : TMyArray;
  public
    PROPERTY OnChangeArray : TNotifyEvent READ FOnChangeArray WRITE FOnChangeArray;
    PROPERTY MyArray       : TMyArray     READ GetMyArray     WRITE SetMyArray;
  end;

Müsste klappen :)

Gruß
Stephan

edit: Man kann so aber nicht auf die einzelnen Indizes zugreifen: MyArray[3] := 1; --> "Der linken Seite kann nichts zugewiesen werden"!

[maximov]

Ich meinte eigentlich array-properties, nicht properties eines array-typs :wink:

Ungefähr so:

Delphi-Quellcode:

    TArrayWrapper = class;
  TArr = array of integer;
  TOnChanged = procedure (sender:TArrayWrapper) of object;
  
  TArrayWrapper = class(TObject)
  private
    FArr:TArr;
    FOnChanged: TOnChanged;
    function getCount: integer;
    procedure SetCount(const Value: integer);
    function GetItems(Index: Integer): integer;
    procedure SetItems(Index: Integer; const Value: integer);
  public
    constructor Create(aOnChange:TOnChanged);
    destructor Destroy; override;
    property OnChange:TOnChanged read FOnChanged write FOnChanged;
    property Count:integer read getCount write SetCount;
    property Items[Index: Integer]: integer read Getitems write Setitems; default;
  end;
      


implementation



{ TArrayWrapper }

constructor TArrayWrapper.Create(aOnChange: TOnChanged);
begin
  FOnChanged := aOnChange;
end;

destructor TArrayWrapper.Destroy;
begin
  count := 0;
  inherited;
end;

function TArrayWrapper.getCount: integer;
begin
  result := length(FArr);
end;

procedure TArrayWrapper.SetCount(const Value: integer);
begin
  setLength(FArr,Value);
end;

function TArrayWrapper.Getitems(Index: Integer): integer;
begin
  result := FArr[Index];
end;

procedure TArrayWrapper.Setitems(Index: Integer; const Value: integer);
begin
  FArr[Index] := Value;
  if assigned(OnChange) then OnChange(self); // event aufrufen!!!
end;

Du musst dann nur noch eine instanz, mit eventhandler als parameter, erstellen und schon hast du den gewünschten effekt :-D

// edit: items als default-property definiert

[Steve]

Jooaaa... das is natürlich noch um einiges besser :thuimb: :-D

und gelernt hab ich auch noch was dabei :mrgreen:

Gruß
Stephan