[SOLVED] How to talk with parent ?

[Fred vS]

Hello everybody.
I have some trouble with calling parent procedure in thread...

That code is working :

Code: [Select]

type
    TMyClass = class(TThread)
 Public
 ...
    EndProc  :  procedure of object; //<<< the Outside procedure is declared inside the Cass.
...
  procedure Execute; override;          //<<< the Inside procedure
      end;
///////////////////////////////////////////////////////// 
Procedure    TMyClass.Execute;   //<<< the Inside procedure
begin
....
EndProc ;  //<<< the Outside procedure
end;     
And in the Form :

Code: [Select]

Procedure procclasstest ; //< the general procedure to test
var
testclass : TMyClass;
begin
testclass :=TMyClass.Create;
testclass.EndProc := @testendproc;  //< the external procedure
testclass.Start ;
end;

Procedure testendproc;  //< the external procedure
begin
form1.caption := 'It is the End' ;
end;

Here code using parent outside procedure EndProc is not executed :

Code: [Select]

type
 TParentClass = class; 
    TChildClass = class(TThread)
   FParent: TParentClass;     
 ...
   procedure Execute; override;          //<<< the Inside procedure
 property Parent: TParentClass read FParent write FParent;     
     end;

type
TParentClass= class(Tobject)
ChildClass               : TChildClass; 
EndProc  :  procedure of object; //< Procedure is declared outside the thread.
end;
 
////////////////////////
Procedure    TChildClass.Execute;   //<<< the Inside procedure
begin
....
Parent.EndProc ;  //<<< the Outside procedure do not run
end;     
and to use in Form :

Code: [Select]

Procedure procclasstest ; //< the general procedure to test
var
testclass : TParentClass;
begin
testclass :=TParentClass.Create;
testclass.EndProc := @testendproc;  //< the external procedure
testclass.ChildClass.Start ;  // start the thread
end;

Procedure testendproc;  //< the external procedure
begin
form1.caption := 'It is the End' ;
end;
Why is it so difficult to deal with parent ? 

[mas steindorff]

I think we need to see a little more code.
where is the create for the childclass (or any of the other Tobjects)?

[Fred vS]

Code: [Select]

type
 TParentClass = class; 
    TChildClass = class(TThread)
   FParent: TParentClass;     
 ...
   procedure Execute; override;          //<<< the Inside procedure
 constructor Create(CreateSuspended: Boolean; const StackSize: SizeUInt = DefaultStackSize);
  property Parent: TParentClass read FParent write FParent;     
     end;

type
TParentClass= class(Tobject)
ChildClass               : TChildClass; 
EndProc  :  procedure of object; //< Procedure is declared outside the thread.
end;
 
////////////////////////
Procedure    TChildClass.Execute;   //<<< the Inside procedure
begin
....
Parent.EndProc ;  //<<< the Outside procedure do not run
end;     

 constructor TChildClass.Create(CreateSuspended: Boolean;
   const StackSize: SizeUInt);
begin
  inherited Create(CreateSuspended,StackSize);
   FreeOnTerminate := True;
   Parent:=FParent;
  end;   
and in Form :

Code: [Select]

Procedure procclasstest ; //< the general procedure to test
var
testclass : TParentClass;
begin
testclass :=TParentClass.Create;
testclass.EndProc := @testendproc;  //< the external procedure
testclass.ChildClass := TChildClass.Create(true);
testclass.ChildClass.Start ;  // start the thread
end;

Procedure testendproc;  //< the external procedure
begin
form1.caption := 'It is the End' ;
end;

[mas steindorff]

I see you have
 testclass :=TParentClass.Create;"  "
that creates memory for a tarentclass type tobject that has a tthread thingy in it but were is the memory for this thingy created?

I would have put it in the TParentClass.Create () something like
  self.childclass = tclildclass.create(...)"
... and any other objects that the tparentclass has

[Fred vS]

@  mas steindorff : thanks for answer but did not understood.

self.childclass = tclildclass.create(...)

?

The code i give is working, the thread is running, only the parent procedure inside execute is not running.

[mas steindorff]

in your original code, the thread object is created directly in the form and is called MyClass

in your second cut, your thread object (now named childclass) does not have a create event.
It's owner (TParentClass) does, but not the thread itself.

for any class that has other objects & classes inside it, it needs to ceate and free them the same as if the objects were used outside of class. 
for example: I sometimes need to use a tstringlist inside a object I'm creating and am required to include a myobject.create that has a tstr := tsringlist.create and a myobject.destroy() that includes a tstr.free statement for proper memory management

[User137]

Code: [Select]

Public
 ...
    EndProc  :  procedure of object

Code: [Select]

Procedure testendproc;  //< the external procedure
begin
form1.caption := 'It is the End' ;
end;

Code: [Select]

testclass.EndProc := @testendproc;
You have procedure " of object", yet you also have procedure testendproc that doesn't belong to any class. I don't understand how your code even compiles.

I guess you should also replace this:

Code: [Select]

testclass.EndProc := @testendproc;with calling this after childclass is created:

Code: [Select]

testclass.childclass.EndProc := @testendproc;
Also, you don't really need 2 classes if you just want to use TThread. Just 1 class that does all that would be simpler, but i don't know deeper needs for your program 

[BigChimp]

To be honest, that's another reason for asking people to submit compilable example project instead of just snippets.

A lot of people seem to take the lazier approach of copy and paste and then change parts of their production code or perhaps various versions of their example project, leading to a lot of unnecessary confusion.

[Fred vS]

Hello everybody and thanks to take care about that difficult thing to explain.

Here complete code and in attachments the test project (working).
There are 2 buttons:
Button 1 loads a normal alone thread and run a external procedure (works perfect).
Button 2 loads a child thread and run a external procedure (do not works).

Code: [Select]

unit Unit1;

{$mode objfpc}{$H+}

interface

uses
  Classes, Forms, StdCtrls;

type

  { TForm1 }

  TForm1 = class(TForm)
    Button1: TButton;
    Button2: TButton;
    Label1: TLabel;
    procedure Button1Click(Sender: TObject);
    procedure Button2Click(Sender: TObject);
      Procedure testendproc;
    private
    { private declarations }
  public

    { public declarations }
  end;

  type
    TMyClass = class(TThread)
 Public
    EndProc  :  procedure of object; //<<< the Outside procedure is declared inside the Cass.
   constructor Create(CreateSuspended: Boolean; const StackSize: SizeUInt = DefaultStackSize);
    procedure Execute; override;          //<<< the Inside procedure
      end;

 type
 TParentClass = class;
    TChildClass = class(TThread)
   FParent: TParentClass;
   procedure Execute; override;          //<<< the Inside procedure
 constructor Create(CreateSuspended: Boolean; const StackSize: SizeUInt = DefaultStackSize);
  property Parent: TParentClass read FParent write FParent;
     end;

type
TParentClass= class(Tobject)
ChildClass               : TChildClass;
EndProc  :  procedure of object; //< Procedure is declared outside the thread.
end;

var
  Form1: TForm1;


implementation

{$R *.lfm}

{ TForm1 }

Procedure TForm1.testendproc;  //< the external procedure
begin
form1.label1.caption := 'External Procedure executed' ;
end;

procedure TForm1.Button1Click(Sender: TObject);
var
testclass : TMyClass;
begin
label1.caption := 'Init of Thread...' ;
testclass :=TMyClass.Create(true);
testclass.EndProc := @testendproc;  //< the external procedure
testclass.Start ;  // start the thread

end;

procedure TForm1.Button2Click(Sender: TObject);
var
testclass : TParentClass;
begin
   label1.caption := 'Init of Thread...' ;
testclass :=TParentClass.Create;
testclass.EndProc := @testendproc;  //< the external procedure
testclass.ChildClass := TChildClass.Create(true);
testclass.ChildClass.Start ;  // start the thread
end;

Procedure    TMyClass.Execute;   //<<< the Inside procedure
begin
EndProc ;  //<<< the Outside procedure runs
end;

 constructor TMyClass.Create(CreateSuspended: Boolean;
   const StackSize: SizeUInt);
begin
  inherited Create(CreateSuspended,StackSize);
   FreeOnTerminate := True;
    end ;

 Procedure    TChildClass.Execute;   //<<< the Inside procedure
 begin
 Parent.EndProc ;  //<<< the Outside procedure do not run
 end;

  constructor TChildClass.Create(CreateSuspended: Boolean;
    const StackSize: SizeUInt);
 begin
   inherited Create(CreateSuspended,StackSize);
    FreeOnTerminate := True;
    Parent:=FParent;
   end;

 end.
     

[User137]

Code: [Select]

procedure TForm1.Button2Click(Sender: TObject);
var
  testclass : TParentClass;
begin
  label1.caption := 'Init of Thread...' ;
  testclass :=TParentClass.Create;
  testclass.EndProc := @testendproc;  //< the external procedure
  testclass.ChildClass := TChildClass.Create(true);
  testclass.ChildClass.Parent:=testclass; // You hadn't given parent any value
  testclass.ChildClass.Start ;  // start the thread
end;

[Fred vS]

@ User137 : Hourrra, Youpie, Iiiiiiiaaaaa, you get it 

Many, many, many thanks.

testclass.ChildClass.Parent:=testclass; // You hadn't given parent any value

does the trick.

Well, Class and OOP become every day (and night) more sexy.

[BigChimp]

@Fred: glad it works! I think you're now the perfect test person to see if this article:
http://wiki.lazarus.freepascal.org/property#Objects_as_properties
makes sense...

If you'd like to, please correct/update the article, or let me know in this thread if something is unclear/missing & I'll try and correct it.

Thanks,
BigChimp

[Fred vS]

@ BigChimp : With the greatest pleasure. 

But, before to go, my brain-debugger have already a problem with :

  MyCar.Color:='Green'; 

I do not see any declaration of TCar.Color (only TCar.FColor) 
(It is maybe a convention to add "F" before variable and i did not know that  )

Code: [Select]

type
  TCar = class
  private
    FColor: string;
    FBuildYear: integer;
    procedure SetColor(CarColor: string);
  public
    property TheColor: string read FColor write SetColor; //Reads directly from the FColor variable;
    // directs writes to the SetColor procedure that then changes the FColor variable..
 
  end;

[BigChimp]

You're completely right - the example code is wrong - it should have been like this:

Code: [Select]

type
  TCar = class
  private
    FColor: string;
    FBuildYear: integer;
    procedure SetColor(CarColor: string);
  public
    property Color: string read FColor write SetColor; //Color, not TheColor!!!
 
  end;Edit:
And yes, F<variable name> is a naming convention for class-level variables. If you use it you can easily distinguish class-level variables from variables that are local in your class procedures/functions.
FColor would not be accessible from outside the class because it was declared in the private section: only available within the TCar class code itself.

Updated the example code

[Fred vS]

@ BigChimp : Ouf, im not completely crazy 

OK, i read next line, see you soon...