Autor Beitrag
penelope
Hält's aus hier
Beiträge: 4



BeitragVerfasst: Di 09.11.04 15:05 
Hallo Jungs, meine Frage:
Wie kann ich Ereignisse (z.B. OnKeyDown) abfangen bzw. bemerken, ohne
sie im Objektinspektor einzutragen, sozusagen von Hand ? Danke.


Moderiert von user profile iconTino: Topic aus Sonstiges verschoben am Do 11.11.2004 um 16:52
.Chef
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starofftopic star
Beiträge: 1112



BeitragVerfasst: Di 09.11.04 15:19 
Mal abgesehen davon, dass du den Code selbst schreiben musst, der beim Doppelklick im OI erzeugt wird, musst du die Routine noch zuweisen, z.B. im OnCreate:
ausblenden Delphi-Quelltext
1:
OnKeyDown:=Form1OnKeyDown;					

Wieder weg geht es dann mit:
ausblenden Delphi-Quelltext
1:
OnKeyDown:=nil;					


Gruß,
Jörg

_________________
Die Antworten auf die 5 häufigsten Fragen:
1. Copy(), Pos(), Length() --- 2. DoubleBuffered:=True; --- 3. Application.ProcessMessages bzw. TThread --- 4. ShellExecute() --- 5. Keine Vergleiche von Real-Typen mit "="!
mrjeremaja
Hält's aus hier
Beiträge: 9

Win XP, Linux
D7 Prof.
BeitragVerfasst: Di 09.11.04 17:19 
Oh.. ..schön. So eine ähnliche Frage habe ich auch:

Kann ich einem Ereignis auch mehrere Ereignisroutinen zuweisen??

Ich habe ein Objekt geschrieben, welches weitere Unterobjekte enthällt. Mein Hauptptobjekt fängt nun einige Ereignisse der Unterobjeke auf. Wenn aber ein User (im schlimmsten Fall ich selbst), der das Hauptobjekt nutzen will, selbst ein Unterobjekt-Ereignis abfangen will, so überschreibt er den Eventhandler und mein Hauptobjekt kriegt wieder nix mit.
.Chef
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starofftopic star
Beiträge: 1112



BeitragVerfasst: Di 09.11.04 19:10 
Beliebtes Problem bei der Komponentenerstellung. Umgehst du damit, dass du vor der Zuweisung die übergeordnete Routine in einer Variable ablegst, und dann in deiner Routine aufrufst. Am Beispiel von Application.OnMessage sieht das so aus:
ausblenden Delphi-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
type
  TOnMessage = procedure(var msg: tagMsg; var Handled: Boolean) of object;

  TKlasse = class(TComponent)
  private
    OldOnMessage: TOnMessage;
    procedure KlasseOnMessage(var msg: tagMsg; var Handled: Boolean);
  public
    procedure AfterConstruction;override;

//...

procedure TKlasse.AfterConstruction;
begin
  OldOnMessage:=Application.OnMessage;
  Application.OnMessage:=KlasseOnMessage;
end;

procedure TKlasse.KlasseOnMessage(var msg: tagMsg; var Handled: Boolean);
begin
  //...
  //Dein Code
  //...
  if Assigned(OldOnMessage) then OldOnMessage(msg,Handled);
end;

_________________
Die Antworten auf die 5 häufigsten Fragen:
1. Copy(), Pos(), Length() --- 2. DoubleBuffered:=True; --- 3. Application.ProcessMessages bzw. TThread --- 4. ShellExecute() --- 5. Keine Vergleiche von Real-Typen mit "="!
penelope Threadstarter
Hält's aus hier
Beiträge: 4



BeitragVerfasst: Do 11.11.04 12:53 
@.chef
danke, die Zuweisung war das Problem,
Gruss, penelope
mrjeremaja
Hält's aus hier
Beiträge: 9

Win XP, Linux
D7 Prof.
BeitragVerfasst: Do 11.11.04 15:22 
Danke .Chef! (konnte letzten Tage leider nicht)

Zitat:
Umgehst du damit, dass du vor der Zuweisung die übergeordnete Routine in einer Variable ablegst, und dann in deiner Routine aufrufst.


Du meinst nicht in der Komponente, sondern beim benutzen der Kompenente im Hauptptojekt, oder? Dann wäre es Vergleichbar mit einem Hook (Subclassing). An so eine Löung habe ich auch gedacht, finde sie aber nicht so schön.

Gibt es denn auch eine Möglichkeit dem Benutzer meiner Komponente den gewohnten Umgang mit Ereignissen zu erlauben?
.Chef
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starofftopic star
Beiträge: 1112



BeitragVerfasst: Do 11.11.04 16:21 
Doch, ich meine in der Komponente, wie man auch im Beispiel sehen kann. Wenn im Hauptprogramm z.B. schon eine Zuweisung auf Application.OnMessage gemacht wurde, wird die entsprechende Routine (bzw. der Zeiger drauf) in der Komponente zwischengespeichert und am Ende des komponenteneigenen Eventhandlers ausgeführt. In meinen Augen ist das top sauberer, allerfeinster Stil. ;-)

_________________
Die Antworten auf die 5 häufigsten Fragen:
1. Copy(), Pos(), Length() --- 2. DoubleBuffered:=True; --- 3. Application.ProcessMessages bzw. TThread --- 4. ShellExecute() --- 5. Keine Vergleiche von Real-Typen mit "="!
mrjeremaja
Hält's aus hier
Beiträge: 9

Win XP, Linux
D7 Prof.
BeitragVerfasst: Do 11.11.04 19:04 
Zitat:
In meinen Augen ist das top sauberer, allerfeinster Stil.


Jo! Jetzt sehe ich das auch, wie dein Code funktioniert. Und das, was er tut, tut er "top sauberer", im "allerfeinsten Stil!" :wink:

Ich hab' den Code nur zunächst falsch verstanden. Dein Code fängt ein Ereignis des Hauptprogramms ab, das nix mit dem Control selbst zu tun hat.

Mein Problem ist nur das ich ein Objekt im Objekt habe. Beide Objekte sollen für den User der Komponente zu sehen sein und z.B. mit Objekt1.Objekt2 erreichbar sein (Objekt1 ist die Komponente). Mein Objekt1 soll nun Ereignisse von Objekt2 abfangen und verarbeiten.

Allerdings kann genau hier der User zwischenfunken: Da er verschachtelt Zugriff auf Objekt2 hat, kann er einfach ein Ereignis von Objekt2 überschreiben und mein Objekt1 kriegt wieder nix mit! :cry:

Ich hoffe ich habe das Problem endlich eindeutig und verständlich formuliert. Damit hab ich - so mein ich - immer wieder schwierigkeiten... :)
Motzi
ontopic starontopic starontopic starontopic starontopic starontopic starontopic starhalf ontopic star
Beiträge: 2931

XP Prof, Vista Business
D6, D2k5-D2k7 je Prof
BeitragVerfasst: Do 11.11.04 19:47 
Naja, das kommt jetzt ganz darauf an um was für Objekte bzw um was für Events es sich handelt und ob es für die Events Do*-Methoden gibt über die diese Events ausgelöst werden. Sind diese vorhanden vereinfacht es die Sache, aber auch wenn es diese nicht gibt lässt sich das über einen Trick machen indem man einfach ein neues Event mit demselben Namen einführt und das alte damit verdeckt. Innerhalb der Komponente kann man aber dennoch per inherited auf das geerbte Event zurückgreifen.

Falls du damit jetzt überfordert bist post doch einfach mal ein bisschen Code deiner Klassen..! ;)

_________________
gringo pussy cats - eef i see you i will pull your tail out by eets roots!
mrjeremaja
Hält's aus hier
Beiträge: 9

Win XP, Linux
D7 Prof.
BeitragVerfasst: Fr 12.11.04 19:50 
Ich nehm mir deinen Tipp zu Herzen und rücke mit meinem Code raus! :D

Ich habe eine Enigma-Klasse geschrieben, die zwei Unterobjekt-Typen hat: Den Reflektor und die Walze(n) (Ich habe versucht den Code auf das wichtigste zu reduzieren, damit ihr/du nicht suchen müsst):

ausblenden volle Höhe Delphi-Quelltext
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
184:
185:
186:
187:
188:
189:
190:
191:
192:
193:
194:
195:
196:
197:
198:
199:
200:
201:
202:
203:
204:
205:
206:
unit Enigma;

interface

  uses
    //[...]

  type

    //
    //Ereignis - Typen
    //
    Event_RotationComplete = procedure of object; //Walzenrotation komplett
    Event_WantBeRedrawed = procedure of object;   //Objekt muss neu gezeichnet werden

    //==============
    //Klasse: CWalze
    //==============
    CWalze = class(TObject)
      private
        //[...]

        //Ereignise
        FOnRotationComplete : Event_RotationComplete;
        FOnWantBeRedrawed : Event_WantBeRedrawed;

        //[...]

      public

        //
        //Prozedur-Definitionen
        //
        constructor Create;
        procedure Rotate;

        //[...]

        //
        //Ereignise
        //
        property OnRotationComplete : Event_RotationComplete
              read FOnRotationComplete
              write FOnRotationComplete;
        property OnWantBeRedrawed : Event_WantBeRedrawed
              read FOnWantBeRedrawed
              write FOnWantBeRedrawed;
    end;

    //==================
    //Klasse: CReflektor
    //==================
    CReflektor = class(TObject)
      private
        //[...]

        //Ereignisse
        FOnWantBeRedrawed : Event_WantBeRedrawed;

        //[...]
      public
        //
        //Prozedur-Definitionen
        //
        constructor Create;

        //[...]

        //
        //Ereignisse
        //
        property OnWantBeRedrawed : Event_WantBeRedrawed
              read FOnWantBeRedrawed
              write FOnWantBeRedrawed;
    end;

    //==================
    //Klasse: CEnigma
    //==================
    CEnigma = class(TObject)
      private
        //Variablen
        _Walzen : array[0..2] of CWalze;
        _Reflektor : CReflektor;

        //[...]

        //Ereignisse
        FOnWantBeRedrawed : Event_WantBeRedrawed;

        //[...]

        //Ereignisprozeduren
        procedure Walze0_RotationComplete;
        procedure Walze1_RotationComplete;
        procedure Something_WantBeRedrawed;

        //[...]
      public
        //
        //Prozedur-Definitionen
        //
        constructor Create;
        destructor Free;

        //[...]

        property Reflektor : CReflektor
                read _Reflektor;
        property Walze[i: Byte] : CWalze
                read Get_Walze;

        //Ereignisse
        property OnWantBeRedrawed : Event_WantBeRedrawed
                read FOnWantBeRedrawed
                write FOnWantBeRedrawed;

    end;

//==============================================================
implementation

  /////////////////////////////////////////////////////////////////
  //PROZEDUREN VON CWalze
  /////////////////////////////////////////////////////////////////

  //BEISPIEL, wie das Ereignis ausgelöst wird:
  procedure CWalze.Alphabet_Changed;
  begin
    //Alphabet hat sich geändert, also muss das Objekt neu gezeichnet werden
    //Ereignis auslösen: Objekt muss neu gezeichnet werden!
    if Assigned(OnWantBeRedrawed) then OnWantBeRedrawed;
  end;

  //[...]

  /////////////////////////////////////////////////////////////////
  //PROZEDUREN VON CReflektor
  /////////////////////////////////////////////////////////////////

  //BEISPIEL, wie das Ereignis ausgelöst wird: siehe Walze!

  //[...]

  /////////////////////////////////////////////////////////////////
  //PROZEDUREN VON CEnigma
  /////////////////////////////////////////////////////////////////

  constructor CEnigma.Create;
  begin
    //Walzen initialisieren
    self._Walzen[0] := CWalze.Create;
    self._Walzen[1] := CWalze.Create;
    self._Walzen[2] := CWalze.Create;

    //Ereignisse abfangen
    self._Walzen[0].OnRotationComplete := self.Walze0_RotationComplete;
    self._Walzen[1].OnRotationComplete := self.Walze1_RotationComplete;

    self._Walzen[0].OnWantBeRedrawed := self.Something_WantBeRedrawed;
    self._Walzen[1].OnWantBeRedrawed := self.Something_WantBeRedrawed;
    self._Walzen[2].OnWantBeRedrawed := self.Something_WantBeRedrawed;

    //Reflektor initialsieren
    self._Reflektor := CReflektor.Create;

    //Ereigniss abfangen
    self._Reflektor.OnWantBeRedrawed := self.Something_WantBeRedrawed;

    //[...]
  end;

  destructor CEnigma.Free;
  begin
    //Walzen lösen
    self._Walzen[0].Free;
    self._Walzen[1].Free;
    self._Walzen[2].Free;

    //Reflektor lösen
    self._Reflektor.Free;
  end;

  procedure CEnigma.Walze0_RotationComplete;
  begin
    //Nach einer kompletten Drehung von Walze 0 jetzt auch
    //Walze 1 drehen
    self._Walzen[1].Rotate;
  end;

  procedure CEnigma.Walze1_RotationComplete;
  begin
    //Nach einer kompletten Drehung von Walze 0 jetzt auch
    //Walze 1 drehen
    self._Walzen[2].Rotate;
  end;

  procedure CEnigma.Something_WantBeRedrawed;
  begin
    //Ereignis weitergeben (selbst auslösen)
    if Assigned(OnWantBeRedrawed) then OnWantBeRedrawed;
  end;

  //[...]

end.


So! Und nun folgendes Problem: Wenn jemand diese Unit in sein Projekt einbindet und ein Enigma-Objekt erzeugt, so kann er, darf aber nicht, folgendes:

ausblenden Delphi-Quelltext
1:
2:
3:
4:
5:
var DieEnigma : CEnigma;

//[...]

DieEnigma.Walze[0].OnRotationComplete := self.EineProcedur;


Wenn der User das macht, so bekommt die Klasse CEnigma keine Ereignisse mehr von der ersten Walze mit und funktioniert nicht mehr (kodiert falsch). :(

Die Unit "Enigma" ist bis auf diesem Fehler komplett fertig! Wenn es Interessierte gibt, so kann ich gerne den kompletten Enigma Code veröffentlichen! :D

@Motzi:
1. Was bringen mir Do*-Methoden?
2. Lösung kann ruhig knallharter OOP-Code mit Vererbung und Polymorphie sein. Das sollte kein Problem für mich darstellen, da ich OOP liebe!! :D :D :D

Danke für die tolle Hilfsbereitschaft!!