Feststellen ob Komponente zur Laufzeit erstellt wurde

[APP]

Hallo,

ich möchte im Create Ereignis meiner (visuellen) Komponente feststellen,
ob diese erst zur Laufzeit oder schon beim Design erstellt wurde.

(Ich versuchte es schon mal mit GetChildParent u.ä. aber irgendwie funkte das nicht so recht...)

Hat jemand eine Idee?


Armin

[APP]

Habe die Lösung gefunden!

Delphi-Quellcode:

CONSTRUCTOR TFlappError.Create(Owner: TComponent);
BEGIN
  INHERITED Create(Owner);                        
  ...
  IF ComponentState = [csInline] THEN
    BEGIN

    END
  ELSE
    BEGIN
      IF FIniFileName = '' THEN FIniFileName := ChangeFileExt(Application.ExeName, '.INI');
      SetFlappErrorProp(Self);                  
    END;
END;

p.s. Wie sagte schon ein Freund zu mir: "Wer das Help-File lesen kann, hat mehr vom Leben!"
:mrgreen: :mrgreen: :mrgreen: :mrgreen: :mrgreen: :mrgreen:

[janjan]

Du kannst ja deine Signatur ergänzen:

Code:

BEGIN
  real programmers are using C/C++ - smart developers Delphi;
  the smartest of them are reading the fu***** manual;
END;

;)

[edit=Daniel B]Habe mal ein Wort Zensiert. Man könnte auch "Read the fine manual" sagen. ;) MfG Daniel B.[/edit]

[APP]

Tja, das mit der Signatur ist gut,
aber leider langt es bei mir scheinbar mit dem Lesen nicht, da meine Kompo nicht Funktioniert!

Delphi-Quellcode:

  IF ComponentState = [csInline] THEN        // Komponente ist zur Designtime erstellt worden
    BEGIN
      IF FIniFileName <> '' THEN SetFlappErrorProp(Self); // Wenn Inidatei vorhanden ist, dann lesen
    END
  ELSE                                            // Komponente ist zur Runtime erstellt worden
    BEGIN
      Application.OnException := onFlappException;
//      FActive := TRUE;
      IF FIniFileName = '' THEN FIniFileName := ChangeFileExt(Application.ExeName, '.INI');
      SetFlappErrorProp(Self);                    // InI Lesen
    END;

ComponentState bleibt leer, ich habe keinen blassen Schimmer was ich machen muß damit ComponentState korrekt funktioniert?!

Hilfe! :bounce1:

[janjan]

Ich glaube es müsste heißen:

Delphi-Quellcode:

if csInline in ComponentState then        // Komponente ist zur Designtime erstellt worden
  begin
    if FIniFileName <> '' then SetFlappErrorProp(Self); // Wenn Inidatei vorhanden ist, dann lesen
  end
else                                            // Komponente ist zur Runtime erstellt worden
  begin
    Application.OnException := onFlappException;
//      FActive := true;
    if FIniFileName = '' then FIniFileName := ChangeFileExt(Application.ExeName, '.INI');
      SetFlappErrorProp(Self);                    // InI Lesen
  end;

ComponentState ist eine Menge, kuck dir die handhabung in der Hilfe mal genauer an.

[APP]

@JanJan :oops: da hast Du natürlich Recht :oops:

ABER: wenn ich meinen Source durch-debugge, sehe ich, dass ComponentState leer ist!

Ich denke, ich muß ComponentState in meiner Komponenten-Deklaration irgendwie (als Property?) mit einbinden (Ist meine 1. Kompo, daher bin ich unsicher).

Ich 'bestehe' auch nicht auf ComponentState, es kann auch eine andere Lösung sein um festzustellen ob die Kompo zur Laufzeit erstellt wurde oder nicht.

[janjan]

Es kann sein das csInline nicht das ist, wofür du es benutzen willst.

Aus der Hilfe:

Zitat:

csInline
Wird gesetzt, wenn die Komponente eine Komponente der obersten Ebene darstellt, die zur Laufzeit geändert und in ein Formular eingebettet werden kann. Dieses Flag wird zur Identifizierung von verschachtelten Frames während des Ladens und Speicherns verwendet.

Der letzte Satz läßt darauf schließen das das was sehr spezielles ist. Auch Google hilft da nicht viel weiter...


Das ComponentState bei dir leer ist kann gut sein, kuck dir mal die Flags genauer an. Normalerweise sollte da keiner gesetzt sein...

[sakura]

Hier der Code

Delphi-Quellcode:

...
if csDesigning in ComponentState then
begin
  // Design-Time Aktion!
end else begin
  // Run-Time Aktion!
end;
// All-Time Aktionen :)

...:cat:...

[janjan]

@APP
Hm, ich glaub ich hab dich falsch verstanden, :oops: ich dachte du wolltest wissen wie man feststellen kann ob eine Komponente per Drag and Drop oder dynamisch per TKomponente.Create erzeugt wurde...

Wenn du nur wissen wolltest ob sich die Komponente im Design-Modus befindet oder nicht, dann musst du es natürlich so machen wie Sakura es vorgeschlagen hat.

[APP]

@janjan

Zitat:

Hm, ich glaub ich hab dich falsch verstanden, ich dachte du wolltest wissen wie man feststellen kann ob eine Komponente per Drag and Drop oder dynamisch per TKomponente.Create erzeugt wurde...

Du hast es erfasst, genau das ist mein Problem!

Ich möchte im Constructor Create feststellen wann/wie die Kompo erstellt wurde, da ich, wenn die Kompo zur RunTime erstellt wurde,
den ExceptionHandler automatisch zuweisen möchte (und bei Bedarf Daten aus einer Ini-Datei laden). Ist die Kompo schon zur Designzeit aktiv, wird (zumindest habe ich das mit dem Debugger festgestellt) Loaded durchlaufen, hier kann ich die Kompo über die Eigenschaft Active ein/ausschalten (hier benötige ich die Daten aus der INI-Datei NICHT).

Delphi-Quellcode:

CONSTRUCTOR TFlappError.Create(Owner: TComponent);
BEGIN
   INHERITED Create(Owner);  
   ...
   IF csDesigning IN ComponentState THEN          // Komponente ist zur Designtime (=DragDrop) erstellt worden
      BEGIN
         ...
      END
   ELSE                                           // Komponente ist zur Runtime (=dynamisch) erstellt worden
      BEGIN
         Application.OnException := onFlappException;
         ...
      END;
END;

Delphi-Quellcode:

PROCEDURE TFlappError.Loaded;
BEGIN
   INHERITED Loaded;
   IF Active THEN Application.OnException := onFlappException;
END;

Leider funktioniert ComponentState nicht. :(

[janjan]

Dann kannst du mit ComponentState nicht viel anfangen, da dir das nur den aktuellen Zustand anzeigt. Wenn da ein csDesigning drin ist, dann heißt das, das grade in diesem Moment die Komponente im Designmodus läuft. Während der normalen LaufZeit wird es nie ein csDesign geben.

[Touchdown]

Es überhaupt keinen Sinn wissen zu wollen ob ein Objekt während der Laufzeit erzeugt wurde oder nicht!

Ich würde mal nach anderen Lösungsmöglichkeiten suchen!

[sakura]

Jetzt ist klar was Du willst. Die Antwort ist: geht nicht :( Füge einfach ein Prozedur ein, welche Du im Code aufrufst, wenn Du die Komponente zur Laufzeit aufrufst, z.B.

Delphi-Quellcode:

APPKompo := TAPPKompo.Create(Self);
APPKompo.InitRunTimeSettings;

...:cat:...

[APP]

@Sakura
Du wirst lachen, das habe ich bis jetzt so gemacht, allerdings dachte ich, das diese Lösung nicht sehr elegant ist. :mrgreen:

@Touchdown
Nun ja, ich denke aus der Sicht eines Komponenten-Users ist es schon sinnvoll zu wissen "ob ein Objekt während der Laufzeit erzeugt wurde oder nicht", da ich versuchen möchte, es dem User so einfach wie möglich zu machen, dadurch kann er auch nichts vergessen.


Einen "zarten" Versuch möchte ich noch machen, bitte schaut Euch das mal an:

Delphi-Quellcode:

   IF (Self.GetOwner.ClassName = 'TApplication') THEN // Komponente ist zur Runtime erstellt worden
      BEGIN
         Application.OnException := onFlappException;
         IF FIniFileName = '' THEN FIniFileName := ChangeFileExt(Application.ExeName, '.INI');
         SetFlappErrorProp(Self);                    // Ini Lesen
      END
   ELSE                                           // Komponente ist zur Designtime erstellt worden
      BEGIN
         IF FIniFileName <> '' THEN SetFlappErrorProp(Self); // Wenn Inidatei vorhanden ist, dann lesen
         ...      
   END;

Ich dachte mir, wenn die Kompo während der Laufzeit erstellt wurde ist der Klassenname "TApplication" und dieser kann wohl nicht verändert werden (oder?!).

Delphi-Quellcode:

FError := TFlappError.Create(Application);

Wenn ich umgekehrt frage, ob der Klassenname eine Form ist (=Erstellung schon zur DesignTime) scheint mir das zu unsicher, da der User/Programmierer den Namen der Form ändern darf.


Was meint Ihr zu meiner Lösung?

:cat: Armin

[jbg]

Zitat:

Delphi-Quellcode:

IF (Self.GetOwner.ClassName = 'TApplication') THEN // Komponente ist zur Runtime erstellt worden

Und was ist, wenn ich folgendes mache:

Delphi-Quellcode:

MyComp := TMyComp.Create(Form1);

[APP]

Tja, grundsätzlich hast Du recht, aber meine Kompo soll ein globaler Exception Handler werden. In diesem Fall gibt es (für mich) nur einen Grund, die Komponente dynamisch zu erzeugen, nämlich wenn man auch Ereignisse vor FormMain.Create erfassen möchte, daher ist der Aufruf im Projektquelltext sinvoll.

Man könnte natürlich die Kompo trotzdem im Hauptformular erzeugen, anstatt im Projektquelltext (wie mir Christian unter Komponente vor der Erzeugung der 1. Form aktivieren? zeigte), aber mir scheint es im Projektquelltext sinvoller zu sein.