Auf Komponente aus Komponente zugreifen

[MaBuSE]

Zitat von MarcRB1975:

...
Was mich persönlich noch interessieren würde ist, wie kann man eigentlich, wenn man eine Komponente entwickelt, auf andere Zugreifen.

Also.. zum Beispiel:
Ich habe 5 Editfelder. In jedem Edit steht als Text etwas drin.

Mit einer erstellten Komponente möchte ich nun eine Listbox erzeugen, in der alle Texte der Edit´s drin stehen. In meiner Komponente, also (OI) möchte ich dann aus dieser erzeugten Listbox einen Text daraus auswählen können.
Aber irgendwie komm ich da nicht drauf.
Muss ich property als String? Edit? Listbox? festlegen? Irgendwie schaff ichs nicht.
Muss die Listbox (Createt) werden? mhhh...

Hallo Marc,

Du kannst in einer Componente eine andere Komponente als Property definieren.

Delphi-Quellcode:

...
  myComp = class(TComponent)
...
    FmyListBox : TListBox;
...
  published
    property myListBox:TListBox read FmyListBox write FmyListBox;
...
  end;
...

...
  // Zugriff auf Listbox:
  if assigned(FmyListBox) then
  begin
    FmyListBox.Items.Add('Bla');
  end;
...

Es erscheint dann im Objektinspektor eine Eigenschaft myListBox. Wenn auf dem Formular nun eine Listbox liegt, kann diese diekt im Objektinspector zugewiesen werden. In FmyListBox steht dann eine Referenz auf die Listbox auf dem Form.
Beim Zugriff sollte man mit assigned prüfen, ob überhaupt eine Listbox zugewiesen ist.

Das wars eigentlich schon.

ps: Ich habe den Quelltext nicht in Delphi getestet, Syntaxfehler also nicht ausgeschlossen

[Flocke]

Kleiner Zusatz: solche Komponenten nutzen oft auch die Methode Notify, um sich über ein Löschen der referenzierten Komponente(n) informieren zu lassen.

Delphi-Quellcode:

//...
interface

type
  myComp = class(TComponent)
  //...
  protected
    procedure Notification(AComponent: TComponent; Operation: TOperation); override;
  //...
  end;

//...
implementation
//...

procedure myComp.Notification(AComponent: TComponent; Operation: TOperation);
begin
  inherited;

  if Operation = opRemove then
    if AComponent = FmyListBox then
      myListBox := nil;
end;

//...

[SirThornberry]

Und noch sinnvoller ist es anstelle von Notify sich eigene Komponenten abzuleiten welche im Destroy der anderen Komponente bescheid geben das Sie weg sind. Denn Notify klappt nur wenn der Owner bzw. Parent richtig gesetzt wurde. Wenn als Owner "nil" übergeben wurde klappt das ganze Notifysystem nicht mehr.

[Flocke]

Zitat von SirThornberry:

Und noch sinnvoller ist es anstelle von Notify sich eigene Komponenten abzuleiten welche im Destroy der anderen Komponente bescheid geben das Sie weg sind.

Dann willst du das also nie mit Standardkomponentenklassen machen? Und warum macht Borland das dann überall so?

Zitat von SirThornberry:

Denn Notify klappt nur wenn der Owner bzw. Parent richtig gesetzt wurde. Wenn als Owner "nil" übergeben wurde klappt das ganze Notifysystem nicht mehr.

Wenn du Owner als nil übergibst, dann willst du ja auch genau das: eine "unmanaged component", bei der du dich um alles selbst kümmern willst. Ansonsten verbietet dir keiner, einfach "Application" als Owner zu übergeben (dann werden die Komponenten nämlich beim Programmende automatisch freigegeben).

[Hawkeye219]

Ansonsten gibt es noch die Methode TComponent.FreeNotification...

Gruß Hawkeye

[MarcRB1975]

Hallo Mabuse!
Danke, dass du gleich aus meiner Frager heraus ein neues Thema erstellt hast.

Nun... ich wollte das eigentlich ganz anders machen.

Ich möchte nicht die Listbox(en) auswählen können, sondern die Edit´s.
Wie das geht, weiss ich ja schon. Das hab ich schon herausgefunden.
Das mit der Listbox war nur soo ne Idee.

Nun... ich möchte 2 Eigenschaften erzeugen.
Die 1. sollte sein, dass ich eines der Edits, die sich auf dem Form befinden, auswählen kann.
(das klappt ja schon sehr gut bei mir).
Die 2. Eigenschaft soll es mir ermöglichen, dass ich den Text, aller vorhandenen Edits auswählen kann.

Beispiel:
Meine neue Komponente nenn ich jetzt mal ganz einfach AuswahlEdit.
Ich platziere auf dem Form während der Designzeit 5 Edit-Komponenten. Die Eigenschaft Text der 5 Edits ändere ich ab auf z.B.:

Edit1 hat den Text: aaaa
Edit2 hat den Text: bbbb
Edit3 hat den Text: cccc
Edit4 hat den Text: dddd
Edit5 hat den Text: eeee

Jetzt möchte die in meiner neuen Komponente (AuswahlEdit) aus allen vorhandenen Edits ein Edit auswählen können. Z.B. ich wähle das 1. Edit aus. Das klappt.

Dann möchte ich in meiner 2. Eigenschaft aus allen vorhandenen vorliegenden "Edit-Texten" einen Text auswählen können. Wenn ich also auf die 2. Eigenschaft klicke, sollen mir alle Text (s.o.) aus den Editfeldern (aaaa,bbbb,cccc usw) angezeigt werden. Einen Text davon wähle ich aus und weise somit automatisch meinem 1. Edit diesen "neuen" Text zu.


Jetzt hab ich eben gedacht, um die Texte irgendwie anzeigen zu können, müsste ich vielleicht eine Listbox sozusagen beim erstellen der Komponente "miterzeugen".

Sobald ich bei der 1. Eigenschaft mir ein Edit aussuche, in das später der Text kommen soll, werden automatisch in diese Listbox alle vorhandenen Edit-Text übernommen.
Wenn ich jetzt auf meine 2. Eigenschaft klicke, sollen mir alle Texte aus meiner "erzeugen" Listbox angezeigt werden. Naja... ich dachte zumindest, das man das vielleicht so machen könnte.

Aber vielleicht geht das ja so gar nicht.

Mhh... mein Problem ist halt u.a. auf die Eigenschaft und deren "Inhalt" anderer Komponenten, zugreifen zu können.

Verstehst du vielleicht, was ich meine? Gehts sowas?

[MaBuSE]

Zitat von MarcRB1975:

Nun... ich wollte das eigentlich ganz anders machen.

Hilft Dir das vieleicht weiter?

Mit Form1.Components[i] kann jedes Edit aufgespührt werden

Einfach mal ein paar Edit Felder und eine ListBox auf ein leeres Form und dann AuswahlText drauflegen.
In AuswahlText ist sofort der Text aller Edit Felder zu sehen.
Dann ListBox zuweisen und alles ist in der ListBox.
Wenn dann Edit Felder vom Form gelöscht werden, wird die ListBox automatisch aktualisiert.

Ist als kleine Anregung gedacht

Delphi-Quellcode:

unit AuswahlEdit;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls;

type
  TAuswahlEdit = class(TComponent)
  private
    { Private-Deklarationen }
    FmyListBox: TListBox;
    FAuswahlText: string;
    function GetAuswahlText: string;
    procedure SetAuswahlText(const Value: string);
    procedure SetmyListBox(const Value: TListBox);
  protected
    { Protected-Deklarationen }
    procedure Notification(AComponent: TComponent; Operation: TOperation); override; 
  public
    { Public-Deklarationen }
    procedure GetAuswahl;
  published
    { Published-Deklarationen }
    property AuswahlText: string read GetAuswahlText write SetAuswahlText stored False;
    property myListBox: TListBox read FmyListBox write SetmyListBox;
  end;

procedure Register;

implementation

procedure Register;
begin
  RegisterComponents('Beispiele', [TAuswahlEdit]);
end;

{ TAuswahlEdit }

// Füllt die ListBox ;-)
procedure TAuswahlEdit.GetAuswahl;
var
  i: Integer;
begin
  if (Owner is TForm) and assigned(FmyListBox) then
  begin
    // nur wenn Owner ein Formular ist und auch die ListBox zugewiesen wurde
    FmyListBox.Items.Clear;
    for i := 0 to Owner.ComponentCount - 1 do
    begin
      if Owner.Components[i] is TEdit then  // ist es ein TEdit ?
      begin
        // Über TypeCasting kommt man an alle Eigenschaften 
        FmyListBox.Items.Add(
          (Owner.Components[i] as TEdit).Name + ' = ' + 
          (Owner.Components[i] as TEdit).Text
          );
      end;
    end;
  end;
end;

// Ermittelt den string mit allen Werten
function TAuswahlEdit.GetAuswahlText: string;
var
  i: Integer;
begin
  Result := '';
  if (Owner is TForm) then
  begin
    for i := 0 to Owner.ComponentCount - 1 do
    begin
      if Owner.Components[i] is TEdit then
      begin
        Result := Result + ', "' + (Owner.Components[i] as TEdit).Text + '"';
      end;
    end;
    // Wenn min. ein Edit Feld da sind die Ersten 2 Zeichen ', ' -> weg damit
    if Length(Result) > 2 then Result := copy(Result, 3, length(Result)); 
  end;
  FAuswahlText := Result; // Ermittelter String wird in FAuswahlText gemerkt ;-)
end;

// Benachitigungen sind immer gut ;-)
procedure TAuswahlEdit.Notification(AComponent: TComponent;
  Operation: TOperation);
begin
  inherited;

  // Wenn ListBox entfernt wird -> Property aud nil setzen
  if (Operation = opRemove) and (AComponent = FmyListBox) then
  begin
    myListBox := nil;
  end;

  // wenn Edit Feld entfernt wird, Listbox Refresh
  if (Operation = opRemove) and AComponent.ClassNameIs('TEdit') then
  begin
    Getauswahl;
  end;

end;

// Das Property kann auch gesetzt werden, dann werden alle Edit Felder 
// mit dem eingegebenen Wert überschrieben
procedure TAuswahlEdit.SetAuswahlText(const Value: string);
var
  i: Integer;
begin
  if FAuswahlText <> Value then // Aber nur wenn der Wert dem gemerkten Wert abweicht (s.o.)
  begin
    if (Owner is TForm) then
    begin
      for i := 0 to Owner.ComponentCount - 1 do
      begin
        if Owner.Components[i] is TEdit then
        begin
          (Owner.Components[i] as TEdit).Text := Value;
        end;
      end;
      GetAuswahl;
    end;
  end;
end;

// diese Methode gibts nur, damit auch Getauswahl aufgerufen wird
procedure TAuswahlEdit.SetmyListBox(const Value: TListBox);
begin
  if FmyListBox <> Value then
  begin
    FmyListBox := Value;
    GetAuswahl;
  end;
end;

end.

[edit]Kommentare im Quelltext eingefügt[/edit]

[MarcRB1975]

Guten Morgen "Dr." Mabuse!!

wow... ich möchte dir dafür danken, dass Du Dir da sooo große Mühe gegeben hast und auf meine Frage eingegangen bist.

Wenn ich heute von der Arbeit nach Hause komme, werde ich das gleich mal versuchen.

Eine kleine, allgemeine Frage hätte ich noch.

Sag mal... wie ist das eigentlich, kann ich z.B. eine Komponente erstellen möchte, die in der Design- UND in der Laufzeit auf bestimmte, zugewiesene Ereignisse reagiert bzw. ausführen soll?

Ich denke da jetzt besonders dann an das bestimmte Problem mit der DesignIntf, Designeditors.

Also... wenn ich nun meine Komponente programmiere, dachte ich eben daran, in der Designzeit bestimmte "Ereignisse" festzulegen. Nun, das geht ja auch schon recht gut.

Aaaaber... wie ist es nun, wenn ich u.a. für die Laufzeit AUCH noch bestimmte Ereignisse/Proceduren/Functionen ect. festlegen möchte. Und er dann z.B. auf ein Exit/Change ect. "Aktionen i.V.m. override" durchführen soll?
Kann man das sooo ohne weiteres in der gleichen "Unit" wie in der, in der ich vorher das Package in der Designzeit festgelegt habe?
Ich hab mal versucht, das Package in der Entwurfs-und Designzeit zu installieren. Aber dann, wenn ich die Komponente eben auf das Form setzte und auf "Run" Clicke, damit ich die Komponente zur Laufzeit sehe, kommt eine Fehlermeldung, dass er die DesignInft eben nicht findet. Wenn ich aber jetzt das Package NUR in der Entwurfszeit installiere, gibt es keine Fehlermeldung?

Muss ich vielleicht ein weiteres Package erstellen, dass ich dann in der "Laufzeit" installiere und die Unit in diesem Package dann auf das Entwurfszeitpackage bzw. auf dessen Unit verweist???

Mal eine persönliche Frage an Dich, wenn sie gestattet ist:
Bist Du Programmierer hauptberuflich oder hast Du das studiert, weil Du Dich da sooo gut auskennst und sehr gute Hilfen anbietest?

[MaBuSE]

Moin Moin,
Danke für die Blumen

Zitat von MarcRB1975:

Sag mal... wie ist das eigentlich, kann ich z.B. eine Komponente erstellen möchte, die in der Design- UND in der Laufzeit auf bestimmte, zugewiesene Ereignisse reagiert bzw. ausführen soll?
Ich denke da jetzt besonders dann an das bestimmte Problem mit der DesignIntf, Designeditors.

DesignIntf und DesignEditors gehören zur ToolsAPI.
Die ToolsAPI ist eine Schnittstelle zur Delphi IDE.
Das bedeutet, das Du mit der ToolsAPI das Verhalten der Komponenten in der Delphi IDE also zur Entwurfszeit ändern kannst.

Wenn dein Programm läuft, also keine Delphi IDE da ist. Dann brauchst du auch keine ToolsAPI.
KomponentenEditoren und PropertyEditoren machenen ja außerhalb von Delphi auch keinen Sinn.

Du brauchst die ToolsAPI also gar nicht zur Laufzeit.
Wenn Du das verstanden hast und Laufzeitpackages verwenden willst ist das eigentlich ganz einfach.

Der Trick besteht nun darin zwei Package zu bauen.

Ein Package mit der Komponente und allem was dazugehört, aber ohne ToolsAPI.
Alles was die ToolsAPI verwendet ist nur für in der IDE gedacht.

Dann machst Du ein weiteres Package, in dem Du nur das Laufzeitpackage einbinden mußt (requires)
Es sollte eine Unit geben, in der Du Deine Komponenten registrierst. Und eine in der Deine Property- / KomponentenEditoren programmiert sind.

Das ist dann das Entwurfszeitpackage.

In Delphi brauchst Du nur das Entwurfszeitpackage installieren, da es ja auch die Komponente registriert.
Das Laufzeitpackage steht nun zur Weitergabe zur Verfügung.

Ich bin kein Fan von Laufzeitpackages. Ich binde alles in meine Applikationen ein.
Aus diesem Grund mache ich nur ein Package. (Ein Entwurfszeitpackage)

Trotzdem muß ich darauf achten, das in den Units, die in die Applikation eingebunden werden, keine ToolsAPI enthalten ist.
Sprich Die Komponente und die IDE Erweiterung muß in min. zwei Units getrennt werden.

Das ist eigentlich schon alles.

Lies noch mal Deinen Tutorialthread, da habe ich das selbe noch mal mit Anderen Worten geschieben.
http://www.delphipraxis.net/internal...=597742#597742

Zitat von MarcRB1975:

Mal eine persönliche Frage an Dich, wenn sie gestattet ist:
Bist Du Programmierer hauptberuflich oder hast Du das studiert, weil Du Dich da sooo gut auskennst und sehr gute Hilfen anbietest?

Angefangen mit einem ZX81 (1 kByte Ram) mit Basic und ASM, in der Schule zut Turbo Pascal 2 gekommen, technischer Informatiker gelernt (Beruf) danach praktische Informatik studiert.
Weiteres kannst du hier nachlesen: http://www.delphipraxis.net/internal...=258494#258494

[MarcRB1975]

Hallo Doc!

Du bist also Informatiker. Cool! Deinen "Werdegang" find ich ja schon sehr interessant.

Ich hatte nur damals - so mit 12 - Basic gelernt.
Dann jahrelang nichts mehr dergleichen gemacht. Nun hat mich ein Kumpel auf Delphi so vor ca. 2 1/2 Jahren gebracht. Hab mir 3 Bücher von Delphi gekauft und jetzt beiß ich mich da durch. Jetzt bin ich auch schon mit Delphi und dem Programmieren "infiziert".
Ich hab halt irgendwelche Ideen und dann versuch ich diese zu verwirklichen. Schau halt, was in den Büchern soo steht, lese mir Source durch, propiere seehr viel und dann klapps - meistens - .
Naja... und jetzt bin ich halt auf einen Bereich gestoßen, der ja total neu für mich ist.
Die Komponentenentwicklung, aber für mich total interessant.



Dein Source ist ja echt der Hammer. Der Wahnsinn!!!

Genau das, was ich brauche!!!!
Ich kann somit vieles programmieren und verwirklichen, was ich mir so vorstelle. SUPER!!!!
Vielen Dank, für Deine Mühe und Deine Geduld!!!

Bekomm zwar noch einen Fehler, wenn ich ein Edit wieder vom Form wegnehme und DANN "RUN" clicke, aber ich denk mal, das bekomm ich auch noch hin, herauszufinden, an was das liegt.

DANKE!!!