"Unendlicher Progressbar"

[TigerLilly]

Ja. Und wenn du informativere Infos ausgibst, wird es noch schöner:

. . .
Labels erzeugt
Daten der Labels geladen
Edits erzeugt
Daten der Edits geladen
Grids erzeugt
Daten der Grids geladen
. . .

etc.

[Uwe Raabe]

Als Beispiel könnte der Splash-Screen der IDE dienen, die ja auch im unteren Bereich ihre Aktivitäten mitteilt.

[skoschke]

Ich habe das nun versucht, umzusetzen, aber irgendwie wird der Thread (und dessen Labelaktualisierung) vom HauptThread und der dort stattfindenden Control-Erzeugung blockiert...

Erst wenn im Mainthread alles abgelaufen ist, wird das Label im Thread aktualisiert!

Irgendwas läuft da schief!

Ciao
Stefan

[haentschman]

Zeig Mal...

[skoschke]

Hier der Thread:

Delphi-Quellcode:

unit ThreadProgress;

interface

uses
  Classes, Sysutils, VCL.Dialogs, VCL.Forms, VCL.ComCtrls, VCL.ExtCtrls,
  VCL.Controls;

var
  ShowProgress: boolean;

type
  TProgressThread = class(TThread)
    constructor Create;
    destructor Destroy; override;
  private
    SplashForm: TForm;
    ProgressRand: TPanel;
    sb, sh: integer;
    step: integer;
  protected
    procedure Execute(); override;
  public
  end;

var
  Thread_Progress: TProgressThread;

implementation

constructor TProgressThread.Create;
begin
  FreeOnTerminate := True;
  // Suspended starten
  inherited Create(True);
  ShowProgress := True;
  SplashForm := TForm.Create(nil);
  sb := 200;
  sh := 50;
  step := 0;
  SplashForm.Width := sb;
  SplashForm.Height := sh;
  SplashForm.BorderStyle := bsNone;
  ProgressRand := TPanel.Create(SplashForm);
  ProgressRand.Margins.Left := 5;
  ProgressRand.Margins.Top := 5;
  ProgressRand.Margins.Right := 5;
  ProgressRand.Margins.Bottom := 5;
  ProgressRand.AlignWithMargins := True;
  ProgressRand.Parent := SplashForm;
  ProgressRand.Caption := 'Bitte warten';
  ProgressRand.ShowCaption := True;
  ProgressRand.Align := alClient;
  ProgressRand.BorderStyle := bsSingle;
  ProgressRand.BevelOuter := bvNone;
  ProgressRand.StyleElements := [];
  SplashForm.Position := poMainFormCenter;
  SplashForm.Visible := True;
  SplashForm.BringToFront;
end;

destructor TProgressThread.Destroy;
begin
  // globale Variable rücksetzen
  Thread_Progress := nil;
  inherited;
end;

procedure TProgressThread.Execute;
begin
  while ShowProgress do
  begin
    SplashForm.BringToFront;
    inc(step);
    if step = 5 then
      step := 0;
    ProgressRand.Caption := 'Bitte warten' + StringOfChar('.', step);
    Application.ProcessMessages;
    sleep(500);
  end;
end;

end.

Den starte ich jetzt testweise bereits im MainForm.Create.

Delphi-Quellcode:

  
  Thread_Progress := TProgressThread.Create;
  Thread_Progress.Start;

Das Fensterchen erscheint und die Caption läuft wie gewünscht.
Wird nun im Hauptprogramm der zeitintensive Erzeugungsteil gestartet, bleibt der Splashscreen stehen!

Was habe ich übersehen?

Ciao
Stefan

[himitsu]

KEINE VCL im Thread benutzen.

Wenn, dann als NonVCL direkt mit CreateWindow, CreateDialog oder Dergleichen.

[jaenicke]

Du darfst aus dem Thread nicht unsynchronsiert auf das Formular zugreifen.

Du könntest allerdings einen Dialog hiermit verwenden:
https://github.com/jaenicke/MTCL
Der funktioniert im Thread unabhängig von anderen Threads.

An solch einer Komponentensammlung scheint nicht wirklich Interesse zu bestehen, so dass ich diese auch nicht mehr weiterentwickelt habe, zumindest öffentlich. Aber das Prinzip funktioniert.

[Uwe Raabe]

Zitat von jaenicke:

Du darfst aus dem Thread nicht unsynchronsiert auf das Formular zugreifen.

Richtig! Allerdings funktioniert synchronisiert zugreifen auch nicht, da der Hauptthread ja beschäftigt ist.

Besser wäre es, den SplashScreen im HauptThread als erstes zu erzeugen und anzuzeigen und regelmäßig bei jeder abgeschlossenen Aufgabe den Texteintrag zu aktualisieren. Threads würde ich da komplett außen vor lassen.

[Benmik]

Wenn ich das richtig verstanden habe, dann ist doch der MainThread ein VCL-Thread, der pausenlos läuft und auf Nachrichten wartet. Wenn ich jetzt alle Arbeiten in separate Threads verlege, dann müsste doch der MainThread frei sein und alle Anzeigen verzögerungsfrei und nicht blockierend verarbeiten. Es müsste also theoretisch alles ganz einfach sein. Tatsächlich klappt das auch, aber schwierig wird es, wenn man Application.ProcessMessages vermeiden will. Ich bringe ohne z.B. einen Timer unter AsyncCalls nicht zum Laufen. Und die Einarbeitung in die OTL ist schwieriger als gedacht, und bisher ist AsyncCalls auch schneller.