1:
2:
3:
4:

procedure TScanThread.UpdatePeaksTh;
begin
  FNform.UpdatePeaks(FpeaksL, FpeaksR);
end;//<------und hier krachts!!!                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:

procedure TScanThread.Execute;
var
  .....
  .....
begin
     OutputDebugString('ich arbeite');//ist nur für mich
     ....
     ....
     while (buflen > 0) and (not terminated) do
     begin
         ..... //jedemenge berechnen
         .....
     end;
     OutputDebugString('Daten können abgeholt werden'); // ist nur für mich
     Synchronize(UpdatePeaksTh);
     ....
     ....
     OutputDebugString('ich beende mich'); // ist nur für mich
     Terminate;
end;                    

1:
2:
3:
4:
5:
6:

       if OpenDialog1.Execute then
       begin
            ....
            ....
           NewForm:= TForm3.Create(self);
       end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:

procedure TForm3.FormCreate(Sender: TObject);
begin
    ....
    ....
    TScanThread.Create(mychan1, xzoom, self);
end;
.....
.....
//hier der Aufruf um die Daten abzuholen
//wird auch komplett durchgeführt
procedure TForm3.UpdatePeaks(pL, pR: array of smallint);
var i: integer;
begin
    for i:= low(pL) to high(pL) do
    begin
  wavebufL[i]:= pL[i];
  wavebufR[i]:= pR[i];
    end;

   timer1.Enabled:= true;
end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:

constructor TScanThread.Create(decoder: HSTREAM; zoom: integer; Nform: TForm3);
begin
  inherited create(false);
  Priority:= tpNormal;
  FreeOnTerminate:= true;
  FDecoder:= decoder;
  FZoom:= zoom;
  FNform:= NForm;
end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:

private
  MyThread: TScanThread;
...
//FormCreate:
MyThread := TScanThread.Create(...); // nicht FreeOnTerminate und nicht sofort loslaufen
MyThread.MyForm := ...; // geht natürlich auch im Konstruktor, soll nur zeigen, dass es auch so geht
MyThread.Resume;

//FormDestroy:
MyThread.Terminate; // wenn der Thread in einer Schleife mit "while not Terminated" läuft
MyThread.WaitFor; // oder so ähnlich, glaub es hieß so
MyThread.Free;                    

1:
2:
3:
4:

NewThread:= TscanThread.Create(...)

//Abfrage ob fertig
if NewThread.Binfertig then   //mache was                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:

// im Thread:
public
  property Array1: ...
  property Array2: ...
end;

// im Formular:
private
  FMyThread; TMyThread;

FMyThread := ...
FMyThread.OnTerminate := MyThreadTerminate;


procedure TMyForm.MyThreadTerminate(Sender: TObject);
begin
  FMyThread.Array1 ...
end;                    

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:

// im Thread:
TMyUpdatePeaksEvent = procedure(Sender: TObject; pL, pR: array of SmallInt) of object;

...

public
  OnUpdatePeaks: TMyUpdatePeaksEvent read FOnUpdatePeaks write FOnUpdatePeaks;

...

// und im synchronisierten dann:
if Assigned(FOnUpdatePeaks) then
  FOnUpdatePeaks(Self, MyArray1, MyArray2);

// und im Formular:
private
  FMyThread; TMyThread;

FMyThread := ...
FMyThread.OnUpdatePeaks := MyThreadUpdatePeaks;


procedure TMyForm.MyThreadUpdatePeaks(Sender: TObject; pL, pR: array of SmallInt);
begin
  pL...
end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:

type TMyUpdatePeaksEvent = procedure(Sender: TObject; pL, pR: array of SmallInt) of object;

type TScanThread = class(TThread)
   private
       Fdecoder: HSTREAM;
       Fzoom: integer;
       Fsec: integer;
       FpeaksL: array of smallint;
       FpeaksR: array of smallint;
       //FNform: TForm;
       FBinfertig: Boolean;
       FOnUpdatePeaks: array of smallint;///muss hier sein oder wo????
       //FDatenholen: TDatenholen;
    protected
       procedure Execute; override;
       //procedure DoTerminate; override;
       //procedure UpdatePeaksTh(peaksL, peaksR: array of smallint);
       procedure SetBinfertig(const Value: Boolean);
    public
      constructor Create(decoder: HSTREAM; zoom: Integer; sec: integer);
      property Binfertig: Boolean read FBinfertig default False;
      property OnUpdatePeaks: TMyUpdatePeaksEvent read FOnUpdatePeaks write FOnUpdatePeaks;
  end;                    

1:

FOnUpdatePeaks: TMyUpdatePeaksEvent;                    

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:

procedure TScanThread.Execute;
var 
  PeakBuf: array[0..176400] of integer;  //=1sekunde daten
  .....
  .....
begin
  inherited;
  try     

     setlength(FpeaksL, 2600);  //max witdh |muss noch genau bestimmt werden;
     setlength(FpeaksR, 2600);  //ist nur zum Test
     .....
     .....
     OutputDebugString('Daten können abgeholt werden'); // ist nur für mich
     FBinfertig:= True;
     Synchronize(UpdatePeaksTh);
finally

    //setlength(FpeaksL, 0);
    //setlength(FpeaksR, 0);
    //FpeaksL:= nil;
    //FpeaksR:= nil;

    OutputDebugString('ich beende mich'); // ist nur für mich
    Terminate;
end;                    

1:
2:
3:
4:
5:
6:

procedure TScanThread.UpdatePeaksTh;//(FpeaksL, FpeaksR);
begin
if Assigned(FOnUpdatePeaks) then
  FOnUpdatePeaks(Self, FpeaksL, FpeaksR);

end;//<----hier krachts