Fortschrittsbalken in Delphi: Die Komponenten „TfrProgressBar“ und „TfrxProgressBar“ aus FastReport VCL

Der Fortschrittsindikator — eines der anschaulichsten Elemente der Benutzeroberfläche: Er zeigt sofort an, wie viel Arbeit bereits erledigt ist und wie viel bis zum Abschluss des Prozesses verbleibt. In diesem Artikel untersuchen wir, wie sich ein solcher Indikator sowohl in die Oberfläche einer Delphi-Anwendung als auch in Berichte integrieren lässt — mithilfe der neuen Komponenten TfrProgressBar und TfrxProgressBar.

Benutzern von FastReport VCL Ultimate stehen zusätzliche visuelle Oberflächenkomponenten im Rahmen der Sets FastEditors VCL und FastGrid VCL. Nun wurden diese Sets um einen neuen nützlichen Editor erweitert — TfrProgressBar, und die Berichte — um die Komponente TfrxProgressBar. Dabei ist die Berichtskomponente nicht nur Inhabern von Ultimate verfügbar, sondern allen, die Zugriff auf die Hauptberichtskomponente haben — TfrxReport.

Im Folgenden betrachten wir im Detail die Eigenschaften und Möglichkeiten der neuen Komponenten und zeigen sie dann in Aktion: am Beispiel eines Demoprojekts mit realistischen Daten, das im Lieferumfang von FastReport VCL Ultimate enthalten ist.

Die TfrProgressBar-Komponente: Eigenschaften und Möglichkeiten

Die ProgressBar-Komponente ist in der IDE auf der FastEditors-VCL-Palette verfügbar und dient zur Anzeige numerischer Werte im Format eines Fortschrittsindikators. Die Komponente:

• unterstützt horizontale und vertikale Ausrichtung der Skala;
• berechnet automatisch den Prozentwert relativ zum angegebenen Grenzbereich und zeigt ihn an;
• enthält eine Sammlung von Markerlinien und Schwellenwerten, mit denen sich die Bereiche der Fortschrittsskala in verschiedenen Stilen visualisieren lassen: einfarbige Füllung, Verlaufsfüllung, Textur.

Betrachten wir die wichtigsten Eigenschaften, die diese Fortschrittskomponente von den anderen Editoren des FastEditors-VCL-Sets unterscheiden.

• Value — der angezeigte numerische Wert. Die Komponente formatiert ihn automatisch je nach den Einstellungen des visuellen Stils und dem Wertebereich. Wird die ProgressBar innerhalb einer Zelle der FastGrid-Komponente verwendet, wird automatisch der Wert dieser Zelle als Value verwendet.
• Properties.CaptionColor — die Farbe des angezeigten Textes. Hat diese Eigenschaft den Wert clDefault, passt sich die Textfarbe automatisch der Hintergrundfarbe an, damit die Beschriftung auf jedem Hintergrund sichtbar ist.
• Properties.CaptionHorizontalAlignment — horizontale Ausrichtung des Textes.
• Properties.CaptionVerticalAlignment— vertikale Ausrichtung des Textes.
• Properties.CaptionOrientation— horizontale oder vertikale Richtung des Textes.
• Properties.CaptionType — der Typ der Textformatierung. Kann die Werte frpbctPercent (automatische Berechnung des Prozentwerts in Abhängigkeit vom Bereich MinValue/MaxValue), frpbctPosition (Anzeige der Textdarstellung der Eigenschaft Value ohne Formatierung) oder frpbctCustom (Anzeige des Textes, der in der Eigenschaft Properties.ProgressCaption gespeichert ist) annehmen.
• Properties.MarkerLinesVisible — steuert die Sichtbarkeit der Markerlinien auf der Fortschrittsskala. Diese Linien werden in der Sammlung Properties.Thresholds definiert.
• Properties.MaxValue — der maximale Skalenwert zur Berechnung des Fortschrittsprozentsatzes. Er kann nicht kleiner als der Wert von Properties.MinValue sein.
• Properties.MinValue — der minimale Skalenwert zur Berechnung des Fortschrittsprozentsatzes. Er kann nicht größer als der Wert von Properties.MaxValue sein.
• Properties.Orientation — die Richtung, in der sich der Pegel der Fortschrittsskala in Abhängigkeit von Value ändert: von links nach rechts oder von oben nach unten.
• Properties.ProgressBarStyle — der Anzeigestil der Fortschrittsskala. Kann die Werte frpbsSolid (einfarbige Füllung mit der Farbe Properties.ProgressBeginColor), frpbsGradient (Verlaufsfüllung mit sanftem Farbverlauf von Properties.ProgressBeginColor bis Properties.ProgressEndColor) oder frpbsBitmap (Füllung mit einer Textur aus der Eigenschaft Properties.ProgressBitmap) annehmen.
• Properties.ProgressBeginColor — die Anfangsfarbe der Fortschrittsskala.
• Properties.ProgressEndColor — die Endfarbe der Fortschrittsskala.
• Properties.ProgressBitmap — die Textur zur Füllung der Fortschrittsskala für den Fall Properties.ProgressBarStyle = frpbsBitmap.
• Properties.ProgressCaption — der Beschriftungstext für den Fall Properties.CaptionType = frpbctCustom.
• ProgressChunkBorder — steuert die Sichtbarkeit der Umrisslinie für den Verlaufsfüllstil der Hauptskala und der Schwellenwerte.
• Properties.ProgressMargin — das Maß des Abstands der Fortschrittsskala von den Rändern der Komponente.
• Properties.ShowAsLEDs — das Ein- und Ausschalten der visuellen Aufteilung der Fortschrittsskala in Rechtecke.
• Properties.Thresholds — eine Sammlung von Schwellenwerten (mehr darüber — unten).
• Properties.OnGetDisplayText — ein Ereignis, mit dem sich der auf der Skala angezeigte Text (Parameter AText) im Code je nach dem Wert des Parameters AValue manuell ändern lässt.

Schwellenwerte: die Sammlung Properties.Thresholds

Mit all diesen Eigenschaften lässt sich der visuelle Stil der Fortschrittsskala flexibel anpassen und bei Bedarf können mehrere verschiedene Wertebereiche und Marker verwendet werden:

Jeder Schwellenwert der Sammlung Properties.Thresholds besitzt die folgenden Eigenschaften:

• Value — der Skalenwert, ab dem sich Stil und Füllfarben der Skala auf die in diesem Schwellenwert angegebenen ändern;
• BeginColor — die Anfangsfarbe der Füllung dieses Schwellenwerts;
• EndColor — die Endfarbe der Füllung dieses Schwellenwerts;
• MarkerLineColor — die Farbe der Markerlinie, die den Value auf der Skala markiert;
• MarkerLineSize — die Dicke der Markerlinie, die den Value auf der Skala markiert;
• MarkerLineVisible — steuert die Sichtbarkeit der Markerlinie;
• ProgressBarStyle — der Füllstil der Fortschrittsskala dieses Schwellenwerts;
• ProgressBorderVisible — steuert die Sichtbarkeit der Umrisslinie dieses Schwellenwerts;
• ProgressVisible — steuert die Sichtbarkeit der Fortschrittsskala dieses Schwellenwerts (ist die Fortschrittsskala des Schwellenwerts nicht sichtbar, werden für sie die Parameter der Hauptskala verwendet — das ist praktisch, wenn nur die Markerlinie dargestellt werden soll).

Die Berichtskomponente TfrxProgressBar

Einen ähnlichen Satz von Eigenschaften bietet die spezielle Berichtskomponente TfrxProgressBar. Um sie in Ihren Bericht einzubetten:

1.    platzieren Sie die nichtvisuelle Komponente TfrxProgressBarObject auf dem Formular — sie fügt Ihrem Projekt automatisch die erforderlichen Module hinzu;
2.    öffnen Sie den Berichtsdesigner über die Komponente TfrxReport;
3.    wählen Sie die Fortschrittskomponente auf der Komponentenpalette aus und platzieren Sie sie auf der Berichtsseite.

Im Vergleich zur Oberflächenkomponente weist die Berichtskomponente einige Besonderheiten auf:

• ShowGeneralBorder — erlaubt es, einen Rahmen um das Objekt anzuzeigen oder auszublenden;
• DataField und DataSet — ermöglichen es, die Komponente an eines der Felder des Datasets zu binden und die Fortschrittswerte automatisch aus ihm zu übernehmen;
• ProgressCaptionExpression — ermöglicht es, einen Ausdruck zu definieren, um den aus dem Datenfeld erhaltenen Fortschrittswert manuell zu formatieren.

Anwendungsbeispiel: Temperaturkontrolle des Schmelzofens

Die Komponente zur Fortschrittsanzeige eignet sich gut für Anwendungen, in denen Werte im zeitlichen Verlauf im Vergleich zu Grenz- und Schwellenwerten visualisiert werden müssen: in Prozessleitsystemen, zur KPI-Verfolgung oder zur Überwachung der Lagerbelegung.
Zur Demonstration der Möglichkeiten der ProgressBar haben wir uns für die Metallurgie entschieden. Gerade in ihr sind die Schwellenwerte der Temperaturen und die Variabilität des Schmelzprozesses wichtig, und Datenabzüge eignen sich gut zum Drucken. Mit anderen Worten: Hier ist alles vorhanden, worin die ProgressBar gut ist.

Simulation des Schmelzprozesses

Zunächst schreiben wir einen kleinen Hilfscode, der die Schwankungen der Temperatursensoren in verschiedenen Zonen des Schmelzofens simuliert: der Beschickungszone, der Schmelzzone, der Überhitzungszone, der Abstichzone und der Ausmauerung. In jeder Zone schwankt die Temperatur zufällig um die Nennwerte während der folgenden Prozessphasen: Aufheizen, Schmelzen, Überhitzen, Korrektur. Natürlich ist das ein stark vereinfachtes Schema, das dem realen Prozess nicht entspricht, aber zur Demonstration der Möglichkeiten der Komponente eignet sich diese Simulation hervorragend.

Den Quellcode der Simulation finden Sie im FastGrid-Demoprojekt in den Modulen frFurnaceZones und frFurnaceSimulator, den Hauptcode für die Arbeit mit der Komponente — im Modul ProgressBarDemo.

Konfiguration der FastGrid-Spalte und der Fortschrittskomponenten

Die Hauptarbeit in diesem Projekt geschieht in den Ereignisbehandlern OnShow und UpdateUI.

In OnShow wird ein Dataset auf Basis der Standardkomponente TClientDataSet erstellt und die Bindung dieser Daten an FastGrid implementiert. FastGrid kann zwar auch direkt mit Daten arbeiten, ohne einen Vermittler in Form eines DataSet, aber in diesem Projekt wollten wir die Möglichkeiten des Druckens von mit der ProgressBar formatierten Daten zeigen, sowohl direkt aus der Quelle als auch über FastGrid. Und dafür eignet sich ein universaler Datenspeicher in Form von TClientDataSet oder einer ähnlichen Komponente am besten.

Anschließend werden im OnShow-Handler die Eigenschaften der FastGrid-Spalte konfiguriert, die für die Anzeige des Fortschritts verantwortlich ist, sowie die Eigenschaften der einzelnen TfrProgressBar-Komponenten auf dem Schema des Schmelzofens:

gFurnaceTableView1.Columns.RetrieveMissingColumns;
LColumn := gFurnaceTableView1.Columns[0];
LColumn.Caption := 'Furnace Zone';
LColumn.Options.Editing := False;
LColumn.PropertiesClass := TfrEditProperties;
LColumn := gFurnaceTableView1.Columns[1];
LColumn.Caption := 'Temperature, C';
LColumn.Width := 300;
LColumn.PropertiesClass := TfrProgressBarProperties;
LProperties := TfrProgressBarProperties(LColumn.Properties);
LProperties.CaptionType := frpbctPosition;
LProperties.CaptionColor := clBlack;
LProperties.ProgressBarStyle := frpbsGradient;
LProperties.MaxValue := FConfig.ScaleMax;
LProperties.MinValue := FConfig.ScaleMin;
LProperties.MarkerLinesVisible := True;
LProperties.CaptionType := frpbctPosition;
LProperties.ProgressBeginColor := clWhite;
LProperties.ProgressEndColor := FConfig.Thresholds[0].Color;
LProperties.ProgressChunkBorder := False;
LProperties.OnGetDisplayText := DoGetDisplayText;
for J := 1 to Length(FConfig.Thresholds) - 1 do
begin
  LThresholdItem := LProperties.Thresholds.Add;
  LThresholdItem.MarkerLineVisible := False;
  LThresholdItem.ProgressBarStyle := frpbsGradient;
  LThresholdItem.MarkerLineVisible := FConfig.Thresholds[J].Caption = 'Overheat';
  LThresholdItem.MarkerLineSize := 2;
  LThresholdItem.Value := FConfig.Thresholds[J - 1].UpperBound;
  LThresholdItem.BeginColor := FConfig.Thresholds[J - 1].Color;
  LThresholdItem.EndColor := FConfig.Thresholds[J].Color;
end;
pbLoading.Properties.Assign(LProperties);
pbLoading.Properties.Thresholds.Assign(LProperties.Thresholds);
pbLoading.Properties.CaptionType := frpbctPercent;
pbMelting.Properties.Assign(LProperties);
pbMelting.Properties.Thresholds.Assign(LProperties.Thresholds);
pbMelting.Properties.CaptionType := frpbctPercent;
pbDischarge.Properties.Assign(LProperties);
pbDischarge.Properties.Thresholds.Assign(LProperties.Thresholds);
pbDischarge.Properties.Orientation := frpboVertical;
pbDischarge.Properties.CaptionType := frpbctPercent;
pbOverheat.Properties.Assign(LProperties);
pbOverheat.Properties.Thresholds.Assign(LProperties.Thresholds);
pbOverheat.Properties.Orientation := frpboVertical;
pbOverheat.Properties.CaptionType := frpbctPercent;
pbLining.Properties.Assign(LProperties);
pbLining.Properties.Thresholds.Assign(LProperties.Thresholds);
pbLining.Properties.Orientation := frpboVertical;
pbLining.Properties.CaptionType := frpbctPercent;

Mehr zur Arbeit mit der FastGrid-Komponente erfahren Sie im Artikel «Detaillierter Überblick über die Möglichkeiten der FastGrid-Bibliothek».

Datenaktualisierung per Timer

Im UpdateUI-Ereignishandler werden die Werte im Dataset und in den einzelnen Komponenten per Timer aktualisiert:

procedure TfrmProgressBar.UpdateUI;
var
  I: Integer;
  LZoneRuntime: TFurnaceZoneRuntime;
  LControl: TfrProgressBar;
  LZoneName: string;
begin
  dmData.cdsZones.DisableControls;
  try
    dmData.cdsZones.First;
    for I := 0 to Length(FProcess.FRuntime) - 1 do
    begin
      LZoneRuntime := FProcess.FRuntime[I];
      dmData.cdsZones.Edit;
      dmData.cdsZones.FieldByName('Temperature').AsFloat := LZoneRuntime.CurrentTemp;
      dmData.cdsZones.Post;
      dmData.cdsZones.Next;
      LZoneName := LZoneRuntime.Zone.Name;
      if LZoneName = 'Loading zone' then
        LControl := pbLoading
      else if LZoneName = 'Melting zone' then
        LControl := pbMelting
      else if LZoneName = 'Overheat zone' then
        LControl := pbOverheat
      else if LZoneName = 'Discharge zone' then
        LControl := pbDischarge
      else
        LControl := pbLining;
      LControl.Value := LZoneRuntime.CurrentTemp;
    end;
  finally
    dmData.cdsZones.EnableControls;
  end;
  // General progress
  lOrders.Caption := ' Furnace Grid - Progress: ' +
    IntToStr(Round(FProcess.Progress01 * 100)) + ' % finished. ' +
    Format('Melting time: %s', [FormatDateTime('nn:ss', FProcess.TotalElapsed / SecsPerDay)]);
end;

Konfiguration der Berichtskomponente

Die Konfiguration der Berichtskomponente und ihre Bindung an die Daten erfolgen im Berichtsdesigner wie folgt:

Das Ergebnis ist eine kleine Anwendung, die die Phasen des Aufheizens und Schmelzens im Ofen anschaulich demonstriert:

Zudem lässt sich jederzeit ein Datenabzug der Temperaturen in Form eines Berichts abrufen:

Fazit

Die Komponenten TfrProgressBar und TfrxProgressBar — praktische Werkzeuge, mit denen sich eine visuelle Fortschrittsanzeige nicht nur in die Benutzeroberfläche Ihrer Anwendung, sondern auch in Berichte einfügen lässt. Die Datenbindung, die Einbettung in Tabellenzellen und die flexiblen Einstellungen für Skalen- und Textstile — all das hilft, Informationen einfach und schnell in einer leicht verständlichen Form darzustellen.

Wenn zu Ihren Aufgaben die Überwachung von Prozessabläufen, KPI-Dashboards oder Berichte über den Aufgabenfortschritt gehören — laden Sie die neueste Version von FastReport VCL Ultimate herunter, öffnen Sie das FastGrid-Demoprojekt und probieren Sie den neuen Fortschrittsindikator an Ihren eigenen Daten aus.