accessing components of frame1 with frame2, with frame2 being on frame1, in delphi, frames are created dynamically

Question

Originally the question had to be how to access the components in the first place, however I somehow managed to figure it out. I am just learning Delphi so I am prone to dumb and obvious questions. I am also at a stage when I'm not actually writing anything useful, but just messing with random stuff to see how it works and maybe learn something.

Wall of text incoming, i want to explain what i am exploring at the moment...

Basically i have a form1 with a button1, pressing it creates a frame2, that frame2 has a button2, pressing button2 creates a frame3 within frame2 (it being frame3's parent and owner). Each frame has an another freeandnil-button. Upon pressing each button1/2/3, it gets disabled to prevent creating multiple instances. My original problem was that after using freeandnil-button, I couldnt access the button on the previous frame (it worked fine for forms, form1.button1.enabled:=true works fine from within frame2) that got disabled in order to re-enable it (frame2.button1.enabled:=true from within frame3 creates an access violation, I think).

Suppose I write something in the future that requires such communication? So I added an editbox to each frame, with a button on the other to change the editbox text, this is my current working solution:

procedure TFrame2.Button3Click(Sender: TObject);
var i,z:integer;
begin
for i := 0 to ComponentCount - 1 do
  if components[i] is tframe3 then
    for z := 0 to (components[i] as tframe3).ComponentCount - 1 do
      if (components[i] as tframe3).Components[z] is TEdit then
         ((components[i] as tframe3).Components[z] as TEdit).Text:='ping';
end;

and

procedure TFrame3.Button3Click(Sender: TObject);
var i:integer;
begin
for i := 0 to parent.ComponentCount-1 do
  if parent.components[i] is TEdit then
    (parent.Components[i] as TEdit).Text:='pong';
end;

If I have a bunch of editboxes or whatever the hell, I suppose I could use Tag property to identify them, however, this much component counting and passing something AS something doesn't really look right or efficient enough to me.

My questions at the moment are: can it be done in a better way? and can someone provide the reasoning why cant I access "parent-frame" components from a "child-frame" in a dumb way (ie: frame2.button1.enabled:=true from within frame3)?

Answer 1

A couple of points:

• Controls/Components are usually set to be owned by the form/frame that controls their lifetime and parented to the control that shows them. So when you create a TEdit to sit on a TPanel on a TForm, you would set TForm as the owner and TPanel as the parent of the TEdit. With frames you do the same: the frame is the owner of all controls on it, controls are parented to whatever container on the frame (can be the frame itself) is holding and and is thus reponsible for showing (painting) it.

• When you iterate over the children of a control, iterating over Components uses the Owner relation; iterating over Controls uses the Parent relation. So your code above would already do a lot less if it were to iterate over the Controls.

• Of course you can reference other controls in a "dumb" way, but you will have to provide for the access method. If you want others (not just child frames) you will at the very least have to declare a method to retrieve that control. Many ways to do this. One is to "ask" the form when you need it (using a method on the form), or have the form set a property on the frame when it is created...

• Avoid accessing form's and frame's published properties. They are mainly there for Delphi's streaming system. When you tie your application together using your approach described above it can very soon become one incredibly tangled mess...

Example coming up (sometime this evening), it will take me a bit of time to also explain and I have work to do...

---

The following example deals only with the ping-pong game between the frames. Freeing any form or frame from one of its own event handlers is not such a good idea. Use the Release method for that as it prevents the form/frame from processing messages after is was freed. (Plenty of questions about this on SO by the way). Also, when you do release a frame from one of its own buttons, you will need to take care that the frame that created it has a chance to nil the references it may have held to that frame otherwise you are setting yourself up for some interesting to debug mayhem. Look into "Notification" and "NotifyControls" and the automatic notification by forms and frames that is sent to their owner/parent so these can remove the control from their components/controls collection. In your example, if you were to release Frame3 from its own "FreeAndNil" button's OnClick event handler, you would have to make sure that the Frame2 responds to the deletion (I think) notification message and nil's any references it holds to Frame3 (besides the ones that will already be cleared automatically in the components/controls collections).

Now, the ping pong game. There are a couple of ways to go about this.

Method 1

The first way is what you already tried with a loop over the components of the other frame. While it certainly is a way to avoid having to "use" the other frame, it is cumbersome and not very concise. Plus when you get more controls on your forms/frames, you will have to add a check on the name to know that you have the correct TEdit. And then you might just as well use the name directly, especially as one frame already has the other frame in its uses clause because it is creating it.

// PingFrame (your Frame2)
uses
  ...
  Pong_fr;

type
  TPingFrame = class(TFrame)
    ...
    procedure CreateChildBtnClick(Sender: TObject);
    procedure PingPongBtnClick(Sender: TObject);
  private
    FPong: TPongFrame; // This is the "extra" reference you need to nil when
                       // freeing the TPongFrame from one of its own event handlers.
    ...
  end;

procedure TPingFrame.CreateChildBtnClick(Sender: TObject);
begin
  CreateChildBtn.Enabled := False;
  FPong := TPongFrame.Create(Self);
  FPong.Parent := ContainerPnl;
  FPong.Align := alClient;
end;

procedure TPingFrame.PingPongBtnClick(Sender: TObject);
begin
  if Assigned(FPong) then
    FPong.Edit1.Text := 'Ping';
end;

And on the other end:

// PongFrame (your Frame3)
type
  TPongFrame = class(TFrame)
    ...
    procedure PingPongBtnClick(Sender: TObject);
  end;

implementation

uses
  Ping_fr;

procedure TPongFrame.PingPong1BtnClick(Sender: TObject);
begin
  (Owner as TPingFrame).Edit1.Text := 'Pong called';
end;

This method seems all nice and dandy, but it has drawbacks:

• You need to use the unit that holds the TPingFrame (Ping_fr in this example). Not too bad I guess, but... as Ping_fr already uses Pong_fr (the unit holding TPongFrame), you can't have Ping_fr using Pong_fr in the interface section and have Pong_fr using Ping_fr in the interface section as well. Doing so would have Delphi throwing an error because of a circular references. This can be solved by moving one of the uses to the implementation section (as done in the example for the use of Ping_fr in the Pong_fr unit.
• A bigger drawback is that there is now a very tight coupling between the two frames. You cannot change the TEdit in either one to another type of control (unless that happens to have a Text property as well) without having to change the code in the other unit as well. Such tight coupling is a cause of major headaches and it is good practice to try and avoid it.

Method 2

One way to decrease the coupling between the frames and allow each frame to change it controls as it sees fit is not to use the controls of another form/frame directly. To do so you declare a method on each frame that the other can call. Each method updates its own controls. And from the OnClick event handlers you no longer access the other frame's controls directly, but you call that method

type
  TPingFrame = class(TFrame)
    ...
  public
    procedure Ping;
  end;

implementation

procedure TPingFrame.PingPongBtnClick(Sender: TObject);
begin
  if Assigned(FPong) then
    FPong.Ping;
end;

procedure TPingFrame.Ping;
begin
  Edit1.Text := 'Someone pinged me';
end;

And on the other end:

type
  TPongFrame = class(TFrame)
    ...
  public
    procedure Ping;
  end;

implementation

procedure TPongFrame.PingPongBtnClick(Sender: TObject);
begin
  (Owner as TPingFrame).Ping;
end;

procedure TPongFrame.Ping;
begin
  Edit1.Text := 'Someone pinged me';
end;

This is better than Method 1 as it allows both frames to change their controls without having to worryabout "outsiders" referencing them, but still has the drawback of the circular reference that can only be "solved" by moving one "use" to the implementation section.

It is a good practice to try and avoid circular references altogether instead of patching them by moving units to the implementation section's uses clause. A rule of thumb I use is:

Any form/frame may know and use the public interface of the forms/frames it instantiates (though it should avoid the controls in the "default visibility" part of that interface), but no form/frame should not have any knowledge of the specific form/frame that created it.

Method 3

One way of achieving this (there are many) it to use events just like the TButton's OnClick event.

On the TPongFrame side of things you can remove the use of Ping_fr. You no longer need it.

Then you need to declare a property and the field it references and declare a method to fire the event.

type
  TPongFrame = class(TFrame)
  private
    FOnPingPongClicked: TNotifyEvent;
  protected
    procedure DoPingPongClicked;
  public
    property OnPingPongClicked: TNotifyEvent 
      read FOnPingPongClicked write FOnPingPongClicked;
  end;

The Ping method stays and its implementation is unchanged. The PingPongBtnClick event handler also stays, but its implementation now becomes:

procedure TPongFrame.PingPongBtnClick(Sender: TObject);
begin
  DoPingPongClicked;
end;

procedure TPongFrame.DoPingPongClicked;
begin
  if Assigned(FOnPingPongClicked) then
    FOnPingPongClicked(Self);
end;

You could put the code from DoPingPongClicked straight in here, but it is a good practice to fire an event in a separate method. It avoids duplicating the exact same code if you would have an event that can be fired from multiple parts of your code. And it also allows descendants (when you get those) to override the "firing" method (you'll have to mark it virtual in the ancestor) and do something specific all the times the event is fired.

On the TPingFrame side of things you need to code a handler for the new event:

type
  TPingFrame = class(TFrame)
    ...
  protected
    procedure HandleOnPingPongClicked(Sender: TObject);

Note that the signature of this handler needs to be what the TNotifyEvent specifies. And of course you need to ensure that this event handler gets called when the event fires in TPongFrame:

procedure TPingFrame.CreateChildBtnClick(Sender: TObject);
begin
  CreateChildBtn.Enabled := False;
  FPong := TPongFrame.Create(Self);
  FPong.Parent := ContainerPnl;
  FPong.Align := alClient;
  // Listen to event fired by PongFrame whenever it's PingPingBtn is clicked
  FPong.OnPingPongClicked := HandleOnPingPongClicked;
end;

In the handler code you can do what you need to do. It can be general:

procedure TPingFrame.HandleOnPingPongClicked(Sender: TObject);
begin
  Edit1.Text := 'OnPingPongClicked event was fired';
end;

And of course you can also use the fact that the event passes a reference to the instance firing the event as well:

procedure TPingFrame.HandleOnPingPongClicked(Sender: TObject);
var
  Pong: TPongFrame;
begin
  // This checks that Sender actually is a TPongFrame and throws an exception if not
  Pong := Sender as TPongFrame; 

  // Use properties from the Pong instance that was passed in
  Edit1.Text := 'OnPingPongClicked event was fired by ' + Pong.Name;
end;

Enjoy!