Delphi, C++ Builder & .NET Teil von sgcUI

sgcWizard, der Assistent und Stepper für Delphi, C++ Builder & .NET

Führe deine Anwender Schritt für Schritt klar durch Einrichtung, Onboarding und Checkout. Jede Seite, die du hinzufügst, wird zu einem Schritt im Stepper, Zurück, Weiter, Fertig und Abbrechen sind eingebaut, und ein einziges Ereignis lässt dich den Wechsel stoppen, bis die Seite gültig ist.

VCL, FireMonkey, WinForms, WPF, AvaloniaDelphi 7 bis 13 und C++ Builder 2007 bis 13Jede Funktion in der kostenlosen .NET Community EditionEnthalten in sgcUI Enterprise
Onboarding-Assistent bei Schritt 2 von 4, Konto, mit dem Stepper oben und den Schaltflächen Zurück, Weiter und Abbrechen

Alles, was ein Assistent braucht

Zwölf Funktionen, die ein langes Formular in einen geführten Ablauf verwandeln, den deine Anwender zu Ende bringen, mit den Regeln und dem Aussehen deiner Anwendung.

Seiten, Schritte und Regeln

Die Struktur eines Assistenten steht bereit: Du fügst die Seiten hinzu und bestimmst die Regeln.

Mehrschrittige Formulare mit eingebautem Stepper

Seiten, Schritte und Regeln

Mehrschrittige Formulare mit eingebautem Stepper

Lange Formulare überfordern Anwender, während dieselben Felder, auf wenige klare Schritte verteilt, ausgefüllt werden. TsgcVCLWizard macht aus jeder Seite einen Schritt: AddPage erstellt eine Seite und gleichzeitig ihren Eintrag im Stepper-Band, mit Beschriftung, Beschreibungszeile und optionalem Glyph. Das Band zeigt, wo der Anwender ist und was noch kommt, und die Leiste mit Zurück, Weiter, Fertig und Abbrechen ist schon da. Jede Seite ist ein Container, du gestaltest ihren Inhalt also mit normalen Steuerelementen, und der Assistent setzt den Fokus beim Öffnen einer Seite auf das erste Steuerelement.

  • AddPage erstellt eine TsgcVCLWizardPage und ihren Schritt
  • Caption, Description und StepGlyph beschriften jeden Schritt
  • ActivePageIndex und ActivePage wechseln Seiten direkt per Code
  • Next, Back und GoToPage bewegen sich genau wie die Schaltflächen
Hilfethema lesen

Seiten, Schritte und Regeln

Den Anwender aufhalten, bis die Seite gültig ist

Einen Anwender mit leerer E-Mail-Adresse bis zur Zusammenfassung gelangen zu lassen, bedeutet später einen Fehler, weit entfernt von dem Feld, das ihn verursacht hat. OnBeforePageChange wird vor jedem Wechsel ausgelöst, ob der Anwender Weiter, Zurück oder Fertig gedrückt, einen Schritt angeklickt oder dein Code GoToPage aufgerufen hat. Es nennt dir die Seite, die verlassen wird, und die Seite, die sich öffnen soll, und ein var-Flag aAllow stoppt den Wechsel. Da jeder Vorwärtswechsel einen höheren Zielindex hat, validiert ein einziger Test die Seite, was auch immer der Anwender gedrückt hat. Legst du ein Veto ein, ändert sich nichts, du zeigst also den Grund und setzt den Fokus auf das Feld.

  • OnBeforePageChange(Sender, aFromIndex, aToIndex, aAllow) kann jeden Wechsel mit einem Veto stoppen
  • aToIndex = PageCount bedeutet, dass der Anwender Fertig gedrückt hat
  • Der Test aToIndex < aFromIndex lässt Rückwärtswechsel durch
  • OnPageChanged wird nach dem Wechsel ausgelöst, zum Beispiel um eine Zusammenfassungsseite zu füllen
Hilfethema lesen
Schritte überspringen, die nicht zutreffen

Seiten, Schritte und Regeln

Schritte überspringen, die nicht zutreffen

Echte Abläufe verzweigen. Ein Kunde, der Standardversand wählt, braucht die Kurierseite nicht, und ein Privatkonto hat keinen Firmenschritt. Setze Skip an einer Seite, und sie bleibt im Assistenten, aber Weiter und Zurück springen darüber hinweg, und der Stepper zeichnet ihren Schritt als übersprungen mit gestricheltem Rahmen, sodass Anwender weiterhin den ganzen Weg sehen. Skip kann sich jederzeit ändern, typischerweise über ein Kontrollkästchen oder eine Auswahl auf einer früheren Seite. Die Schaltfläche Zurück wird automatisch deaktiviert, wenn keine frühere Seite erreichbar ist, sodass Anwender nie auf einer Seite landen, die für sie nicht gilt.

  • Skip an einer TsgcVCLWizardPage nimmt sie aus dem Pfad
  • Übersprungene Schritte werden im Zustand wssSkipped gezeichnet
  • GoToPage wechselt nur zu Seiten, die nicht übersprungen werden
  • Die Demo Onboarding überspringt ihre Seite Options über ein Kontrollkästchen
Hilfethema lesen
Fertig und Abbrechen tun, was du bestimmst

Seiten, Schritte und Regeln

Fertig und Abbrechen tun, was du bestimmst

Ein Assistent endet meist damit, etwas zu speichern, und diesen Code willst du an einer Stelle haben. Auf der letzten Seite zeigt die Schaltfläche Weiter die Beschriftung Fertig und wird zur Standardschaltfläche. Ein Klick darauf, Enter oder ein Aufruf von Finish führt zuerst deine Validierung aus und löst dann OnFinish aus, wo du die Daten speicherst, das Formular schließt oder das ModalResult eines Dialogs setzt. Die Schaltfläche Abbrechen, die Esc-Taste und ein Aufruf von Cancel lösen OnCancel aus, sodass du nachfragen kannst, bevor die Arbeit verworfen wird. Der Assistent schließt nie von selbst etwas, der Ablauf bleibt also unter deiner Kontrolle.

  • OnFinish läuft, nachdem OnBeforePageChange das Beenden erlaubt hat
  • OnCancel behandelt die Schaltfläche Abbrechen, die Esc-Taste und Cancel
  • ShowCancel blendet die Schaltfläche Abbrechen für Abläufe aus, die abgeschlossen werden müssen
  • FinishCaption legt den Text der letzten Weiter-Schaltfläche fest
Hilfethema lesen

Ein Stepper, der sich selbst erklärt

Das Fortschrittsband sagt den Anwendern, wo sie sind, was erledigt ist und was schiefgelaufen ist.

Stepper oben, links oder ausgeblendet

Ein Stepper, der sich selbst erklärt

Kurze Abläufe wirken am besten mit den Schritten oben, längere mit Beschreibungen passen besser in eine Spalte links, wie bei einem Installer. StepperPosition verschiebt das Band, ohne deine Seiten anzufassen: wspTop zeigt ein horizontales Band von 80 logischen Pixeln Höhe, wspLeft ein vertikales Band von 200 Pixeln Breite, und wspNone blendet es für einen schlichten Seitendialog aus. Die Schaltflächenleiste bleibt unten. Die Demo Onboarding hat eine Combo, die die Position zur Laufzeit wechselt, sodass du die drei Layouts in Sekunden mit deinen eigenen Inhalten vergleichen kannst.

  • StepperPosition nimmt wspTop, wspLeft oder wspNone
  • Die Orientation eines Steppers ist woHorizontal oder woVertical
  • CircleSize und ConnectorThickness legen die Größe der Schrittmarker und Linien fest
  • ShowDescriptions zeigt oder verbirgt die zweite Zeile jeder Beschriftung
  • Rechts nach links für Arabisch und Hebräisch: Die Seite der Schrittanzeige, die Reihenfolge der Schritte, die Verbinder und die Schaltflächen Zurück und Weiter mit ihren Pfeilen sind gespiegelt
Hilfethema lesen
Klare Schrittzustände durch Farbe

Ein Stepper, der sich selbst erklärt

Klare Schrittzustände durch Farbe

Anwender überfliegen einen Stepper in einer Sekunde, daher muss jeder Zustand offensichtlich sein. Ausstehende Schritte sind Umrisse mit gedämpfter Nummer, der aktive Schritt ist eine Akzentscheibe mit weichem Schein und fetter Beschriftung, abgeschlossene Schritte tragen ein Häkchen, Fehler sind eine rote Scheibe mit Ausrufezeichen, und übersprungene Schritte haben einen gestrichelten Rahmen. Mit aktivem AutoStates schließt das Setzen von ActiveIndex die Schritte davor ab und lässt die danach ausstehend, während Fehler- und Übersprungen-Zustände erhalten bleiben. Schalte AutoStates aus, wenn deine Anwendung jeden Zustand selbst bestimmt.

  • wssPending, wssActive, wssCompleted, wssError und wssSkipped
  • AutoStates leitet die Zustände aus ActiveIndex ab
  • Ein deaktivierter Schritt wird mit verblassten Farben gezeichnet
  • AccentColor färbt die aktiven und abgeschlossenen Schritte um
Hilfethema lesen
Ein eigenständiger Stepper für Checkout-Abläufe

Ein Stepper, der sich selbst erklärt

Ein eigenständiger Stepper für Checkout-Abläufe

Nicht jeder Prozess ist ein Assistent. Ein Checkout, eine Bestellstatus-Seite oder ein Ticket-Lebenszyklus braucht die Fortschrittsanzeige ohne die Seiten. TsgcVCLStepper ist dasselbe Band als eigenes Steuerelement, horizontal oder vertikal, mit Beschriftungen, Beschreibungen und den fünf Zuständen. Setze Clickable, und Anwender springen mit einem Klick oder den Pfeiltasten zu einem abgeschlossenen Schritt zurück, während OnStepClick dir erlaubt, den Wechsel mit einem Veto zu stoppen. Die Demo Stepper zeigt einen horizontalen und einen vertikalen Stepper nebeneinander, mit Schaltflächen, die den aktiven Schritt als Fehler oder als übersprungen markieren.

  • TsgcVCLStepper und TsgcFMXStepper funktionieren ohne Assistent
  • Steps ist eine Collection, die mit dem Standard-Collection-Editor bearbeitet wird
  • Clickable und OnStepClick machen abgeschlossene Schritte zur Navigation
  • ActiveIndex bewegt den Fortschritt aus deinem eigenen Code
Hilfethema lesen

Passt zu deiner Anwendung

Deine Sprache, dein Designer, dein Theme und dein Framework.

Deine Formulierung auf jeder Schaltfläche

Passt zu deiner Anwendung

Deine Formulierung auf jeder Schaltfläche

Eine englische Schaltfläche Next in einer spanischen Anwendung wirkt unfertig. Die vier Beschriftungen der Schaltflächenleiste sind veröffentlichte Eigenschaften mit den Standardwerten Back, Next, Finish und Cancel. Setze sie im Objektinspektor, übersetze sie mit den üblichen Ressourcenwerkzeugen der IDE oder weise sie im Code aus deiner eigenen Übersetzungstabelle zu. Eine Beschriftung wird nur dann in der Formulardatei gespeichert, wenn sie vom Standard abweicht, und die Schaltflächen wachsen für längere Wörter mit. Die Schrittbeschriftungen stammen aus Caption und Description der Seiten, sie werden also zusammen mit den Seiten übersetzt.

  • BackCaption, NextCaption, FinishCaption und CancelCaption
  • ShowCancel entfernt die Schaltfläche Abbrechen
  • Schrittbeschriftungen folgen Caption und Description jeder Seite
  • Das Hilfethema setzt Anterior, Siguiente, Finalizar und Cancelar als Beispiel
Hilfethema lesen

Passt zu deiner Anwendung

Jede Seite visuell in der IDE gestalten

Assistenten sind Formulare, und Formulare gestaltet man am besten im Formular-Designer. Die Palettenseite SGC Wizard registriert den Assistenten und den Stepper für VCL und FireMonkey. Klicke mit der rechten Maustaste auf den Assistenten und wähle Add Page: Eine neue Seite wird erstellt, angezeigt und ausgewählt, bereit für deine Änderungen, Beschriftungen und Kontrollkästchen. Next Page und Previous Page wechseln im Designer zwischen den Seiten, und ein Klick auf einen Schritt des Bandes zeigt seine Seite. Nur die aktive Seite ist sichtbar, und die zur Entwurfszeit angezeigte Seite ist die, die in der Formulardatei gespeichert wird.

  • Die Verben Add Page, Next Page und Previous Page im Kontextmenü
  • TsgcVCLWizard, TsgcVCLStepper, TsgcFMXWizard und TsgcFMXStepper auf der Palette
  • Das Band und die Schaltflächenleiste sind intern und überladen die Formulardatei nie
  • Die Steps eines eigenständigen Steppers nutzen den Standard-Collection-Editor
Hilfethema lesen
Themes und Tastatur, Enter ist Weiter

Passt zu deiner Anwendung

Themes und Tastatur, Enter ist Weiter

Ein Assistent sollte sich wie der Rest der Anwendung anfühlen, mit der Maus oder ohne. Theme wechselt zwischen den hellen und dunklen sgcUICore-Themes, und AccentColor legt die Farbe der aktiven Schritte, der abgeschlossenen Verbinder und der Standardschaltfläche fest. Der Assistent wendet das Theme auch auf die Steuerelemente seiner Seiten an, sodass ein TLabel, ein TEdit oder eine TCheckBox auf einer dunklen Seite lesbar bleibt. Solange der Fokus im Assistenten liegt, ist Enter Weiter, oder Fertig auf der letzten Seite, und Esc ist Abbrechen, aber ein Memo behält sein Enter für den Zeilenumbruch.

  • Theme nimmt utDefault (folgt dem Anwendungs-Theme), utLight, utDark oder utCustom
  • AccentColor ist eine ARGB-Farbe, und 0 behält den Akzent des Themes bei
  • Untergeordnete Steuerelemente mit eigener Theme-Eigenschaft erhalten das Theme des Assistenten
  • Ein fokussierter Stepper bewegt sich mit den Pfeiltasten, solange Clickable aktiv ist
Hilfethema lesen
Stepper-Bilder für Doku und Tests

Passt zu deiner Anwendung

Stepper-Bilder für Doku und Tests

Dokumentation, E-Mails und visuelle Regressionstests brauchen oft ein Bild der Schritte statt eines Live-Steuerelements. Der Renderer in sgcWizard_Render zeichnet ein TsgcStepperModel und die Schaltflächenleiste ohne Fenster und ohne VCL oder FireMonkey, sodass ein Konsolenprogramm, ein Dienst, ein Unit-Test oder ein Webserver denselben Stepper als Bild erzeugen kann. Er lässt sich auf jeder Plattform kompilieren, auch unter Linux64. Breite und Höhe sind logische Pixel, und ein Skalierungsfaktor liefert scharfe Bilder: 640 mal 100 bei Skalierung 2 ist ein PNG mit 1280 mal 200.

  • sgcWizardSaveToPNG und sgcWizardSaveToSVG schreiben eine Datei oder einen Stream
  • sgcWizardRender zeichnet auf jede sgcUICore-Canvas
  • sgcWizardSaveButtonBarToPNG und sgcWizardSaveButtonBarToSVG zeichnen die Schaltflächenleiste
  • In .NET schreibt das Paket esegece.sgcWizard.Rendering PNG unter Windows, Linux und macOS
Hilfethema lesen

Passt zu deiner Anwendung

In WPF und Avalonia an dein View-Modell binden

WPF- und Avalonia-Entwickler erwarten Bindung, keinen Code-Behind. In diesen Hosts sind die für Anwender relevanten Eigenschaften des Assistenten, seiner Seiten und des Steppers Dependency Properties oder Avalonia-Properties, sodass sie sich an ein View-Modell binden, Werte aus einem Style übernehmen und animiert werden können. ActivePageIndex bindet standardmäßig TwoWay, weil der Assistent es bei Weiter, Zurück und Schrittklicks selbst ändert, sodass dein View-Modell immer den aktuellen Schritt kennt. Die WinForms-Steuerelemente behalten einfache Eigenschaften, und alle drei Hosts nutzen die Delphi-Namen.

  • TsgcWpfWizard und TsgcAvaloniaWizard, mit ihren Seiten und Steppern
  • Ein statisches Feld wie ActivePageIndexProperty für jede bindbare Eigenschaft
  • Ereignisse behalten die Delphi-Namen, wie OnBeforePageChange, als Delegate-Properties
  • In WPF und Avalonia enthält eine Seite ein untergeordnetes Element, in WinForms ist eine Seite ein Container
Hilfethema lesen

sgcWizard in Aktion erleben

sgcWizard in den sgcUI-Suite-Demos: vollständige Anwendungen, die offline mit integrierten Simulationsdaten laufen.

Wer mit sgcWizard baut

Onboarding und Ersteinrichtung

Die ersten Minuten entscheiden, ob ein neuer Anwender bleibt. Teile Kontoerstellung, Einstellungen und eine Zusammenfassung auf vier kurze Seiten auf, validiere Name und E-Mail in OnBeforePageChange, bevor der Anwender weitergeht, und überspringe die Optionsseite für Anwender, die die Standardwerte wollen. OnPageChanged füllt die Zusammenfassung, und OnFinish speichert das Konto. Die Demo Onboarding ist genau dieser Ablauf, mit einem Schalter für hell und dunkel und einer Auswahl der Stepper-Position zum Ausprobieren.

  • Validierung
  • Übersprungene Seiten
  • Fertig und Abbrechen
Demo Onboarding ausführen

Checkout und Bestellerfassung

Die Bestellerfassung folgt einem festen Weg: Warenkorb, Adresse, Versand, Zahlung und Bestätigung. Nutze den Assistenten, wenn jeder Schritt eine Seite mit Feldern ist, oder setze einen eigenständigen Stepper über ein Formular, das du schon hast. Abgeschlossene Schritte werden zu anklickbaren Abkürzungen zurück, eine fehlgeschlagene Zahlung erscheint als roter Fehlerschritt, und ein Versandschritt, der nicht zutrifft, bleibt mit gestricheltem Rahmen sichtbar. Die Demo Stepper zeigt jeden Zustand, horizontal und vertikal.

  • Eigenständiger Stepper
  • Schrittzustände
  • Anklickbare Schritte
Demo Stepper ausführen

Konfigurations- und Import-Assistenten

Technische Werkzeuge brauchen Assistenten für Aufgaben, die Anwender selten erledigen: mit einer Datenbank verbinden, eine Datei importieren, ein Gerät einrichten. Ein Assistent mit dem Stepper links listet jeden Schritt mit einer Beschreibung auf, OnBeforePageChange prüft die Eingabe, bevor der Anwender weitergeht, und die Schaltflächenbeschriftungen folgen der Sprache des Werkzeugs. Derselbe Assistent läuft in FireMonkey, wie die Demo OnboardingFMX zeigt, und in WinForms, WPF und Avalonia.

  • Stepper links
  • Validierung
  • Schaltflächenbeschriftungen
Demo OnboardingFMX ausführen

Ein Assistent in wenigen Zeilen

Dieselbe API in Delphi, C++ Builder und C#: Seiten hinzufügen, eine als optional markieren und validieren, bevor der Anwender die Seite Account verlässt.

procedure TMainForm.CreateWizard;
var
  oPage: TsgcVCLWizardPage;
begin
  // the wizard fills the form: stepper on the left, buttons at the bottom
  FWizard := TsgcVCLWizard.Create(Self);
  FWizard.Parent := Self;
  FWizard.Align := alClient;
  FWizard.StepperPosition := wspLeft;
  FWizard.Theme := utDark;
  FWizard.NextCaption := 'Continue';
  FWizard.FinishCaption := 'Create account';
  // every page is a step of the stepper
  oPage := FWizard.AddPage('Welcome');
  oPage.Description := 'Start here';
  oPage := FWizard.AddPage('Account');
  oPage.Description := 'Your details';
  FName := TEdit.Create(Self);
  FName.Parent := oPage;
  FName.SetBounds(24, 24, 240, 24);
  // an optional page the user can skip: Next and Back jump over it
  FOptions := FWizard.AddPage('Options');
  FOptions.Description := 'Optional';
  FOptions.Skip := True;
  oPage := FWizard.AddPage('Done');
  oPage.Description := 'Summary';
  FWizard.ActivePageIndex := 0;
  FWizard.OnBeforePageChange := WizardBeforePageChange;
  FWizard.OnFinish := WizardFinish;
end;

procedure TMainForm.WizardBeforePageChange(Sender: TObject;
  aFromIndex, aToIndex: Integer; var aAllow: Boolean);
begin
  // veto: leaving Account forwards needs a name
  if (aFromIndex = 1) and (aToIndex > aFromIndex) then
    aAllow := Trim(FName.Text) <> '';
end;

procedure TMainForm.WizardFinish(Sender: TObject);
begin
  ShowMessage('Welcome, ' + FName.Text);
end;
#include <vcl.h>
#include <Vcl.StdCtrls.hpp>
#include "sgcUICore_Theme.hpp"
#include "sgcWizard_Model.hpp"
#include "sgcWizard_VCL.hpp"

class TWizardHandler : public TObject
{
public:
  TEdit *Name;
  void __fastcall BeforePageChange(TObject *Sender, int aFromIndex,
    int aToIndex, bool &aAllow);
  void __fastcall Finish(TObject *Sender);
};

void __fastcall TWizardHandler::BeforePageChange(TObject *Sender,
  int aFromIndex, int aToIndex, bool &aAllow)
{
  // veto: leaving Account forwards needs a name
  if ((aFromIndex == 1) && (aToIndex > aFromIndex))
    aAllow = !Name->Text.Trim().IsEmpty();
}

void __fastcall TWizardHandler::Finish(TObject *Sender)
{
  ShowMessage("Welcome, " + Name->Text);
}

void __fastcall CreateWizard(TForm *Form, TWizardHandler *Handler)
{
  // the wizard fills the form: stepper on the left, buttons at the bottom
  TsgcVCLWizard *Wizard = new TsgcVCLWizard(Form);
  Wizard->Parent = Form;
  Wizard->Align = alClient;
  Wizard->StepperPosition = wspLeft;
  Wizard->Theme = utDark;
  Wizard->NextCaption = "Continue";
  Wizard->FinishCaption = "Create account";
  // every page is a step of the stepper
  TsgcVCLWizardPage *Page = Wizard->AddPage("Welcome");
  Page->Description = "Start here";
  Page = Wizard->AddPage("Account");
  Page->Description = "Your details";
  Handler->Name = new TEdit(Form);
  Handler->Name->Parent = Page;
  Handler->Name->SetBounds(24, 24, 240, 24);
  // an optional page the user can skip: Next and Back jump over it
  Page = Wizard->AddPage("Options");
  Page->Description = "Optional";
  Page->Skip = true;
  Page = Wizard->AddPage("Done");
  Page->Description = "Summary";
  Wizard->ActivePageIndex = 0;
  Wizard->OnBeforePageChange = Handler->BeforePageChange;
  Wizard->OnFinish = Handler->Finish;
}
using System;
using System.Windows.Forms;
using esegece.sgcUICore;
using esegece.sgcWizard;

internal class MainForm : Form
{
    private readonly TsgcWinFormsWizard Wizard = new TsgcWinFormsWizard();
    private readonly TextBox txtName = new TextBox();

    public MainForm()
    {
        // the wizard fills the form: stepper on the left, buttons at the bottom
        Wizard.Dock = DockStyle.Fill;
        Wizard.StepperPosition = TsgcWizardStepperPosition.wspLeft;
        Wizard.Theme = TsgcUITheme.utDark;
        Wizard.NextCaption = "Continue";
        Wizard.FinishCaption = "Create account";
        Controls.Add(Wizard);
        // every page is a step of the stepper
        TsgcWinFormsWizardPage oPage = Wizard.AddPage("Welcome");
        oPage.Description = "Start here";
        oPage = Wizard.AddPage("Account");
        oPage.Description = "Your details";
        txtName.SetBounds(24, 24, 240, 24);
        oPage.Controls.Add(txtName);
        // an optional page the user can skip: Next and Back jump over it
        oPage = Wizard.AddPage("Options");
        oPage.Description = "Optional";
        oPage.Skip = true;
        oPage = Wizard.AddPage("Done");
        oPage.Description = "Summary";
        Wizard.ActivePageIndex = 0;
        Wizard.OnBeforePageChange = WizardBeforePageChange;
        Wizard.OnFinish = sender => MessageBox.Show("Welcome, " + txtName.Text);
    }

    private void WizardBeforePageChange(object sender, int aFromIndex, int aToIndex, ref bool aAllow)
    {
        // veto: leaving Account forwards needs a name
        if (aFromIndex == 1 && aToIndex > aFromIndex)
            aAllow = txtName.Text.Trim() != "";
    }
}
dotnet add package esegece.sgcWizard.WinForms

Die sgcWizard-Demos ausführen

Onboarding und Stepper gibt es für Delphi VCL und für C++ Builder, OnboardingFMX für Delphi FireMonkey, und die .NET-Edition hat Onboarding und Stepper für WinForms, WPF und Avalonia.

Onboarding

Onboarding

Vier Seiten, Welcome, Account, Options und Summary. OnBeforePageChange legt ein Veto gegen Weiter ein, bis Name und E-Mail gültig sind, ein Kontrollkästchen überspringt die Seite Options, OnPageChanged füllt die Zusammenfassung und OnFinish zeigt sie an. Ein Theme-Schalter und eine StepperPosition-Combo lassen dich jedes Layout ausprobieren.

Stepper

Stepper

Zwei eigenständige TsgcVCLStepper-Steuerelemente, horizontal und vertikal, mit denselben fünf Schritten. AutoStates schließt die Schritte vor dem aktiven ab, Schaltflächen markieren einen Schritt als Fehler oder übersprungen, und ein Klick auf einen abgeschlossenen Schritt bewegt beide Stepper zurück.

OnboardingFMX

Der Onboarding-Ablauf mit TsgcFMXWizard und vier TsgcFMXWizardPage-Kindern: dasselbe Validierungs-Veto, dieselbe übersprungene Seite Options, eine Zusammenfassung bei Fertig und ein Kontrollkästchen für das dunkle Theme. Nur für Delphi.

Kompilierte Demos

Sofort lauffähige Programme jedes sgcUI-Produkts, nichts zu installieren.

sgcUI_bin.zip herunterladen →

Wo sgcWizard enthalten ist

sgcWizard ist Teil von sgcUI Enterprise und wird auch einzeln verkauft. sgcWizard ist außerdem im All-Access-Paket enthalten.

sgcWizard Einzelpaket

€149 / Entwickler, voller Quellcode, 1 Jahr Updates.

sgcWizard kaufen → Preise ansehen →

sgcUI Enterprise

Alle 14 sgcUI-Produkte, ab €699.

Enterprise ansehen →

sgcWizard für .NET

esegece.sgcWizard.WinForms, .Wpf und .Avalonia auf NuGet, zum selben Preis wie Delphi. Die kostenlose Community Edition (esegece.sgcWizard.Community) hat jede Funktion, nur der Testversionshinweis unterscheidet sich.

sgcWizard .NET kaufen →

Die Builds Registered, Testversion und Community enthalten alle jede sgcWizard-Funktion. Nur der Testversionshinweis unterscheidet sich.

FunktionCommunity (kostenlos)Registered
Assistent mit Seiten und Stepper-Band✓✓
Validierung mit OnBeforePageChange✓✓
Übersprungene Seiten und die fünf Schrittzustände✓✓
Eigenständiger Stepper✓✓
Schaltflächenbeschriftungen, helle und dunkle Themes, Akzentfarbe✓✓
Headless-Ausgabe als PNG und SVG✓✓

Unterstützte Frameworks und Plattformen

Komponenten in sgcWizard

TsgcVCLWizard und TsgcVCLWizardPage

Der VCL-Assistent und seine Seiten. Ein Komponenteneditor fügt Seiten zur Entwurfszeit von der Palettenseite SGC Wizard aus hinzu.

TsgcFMXWizard und TsgcFMXWizardPage

Derselbe Assistent für FireMonkey unter Windows, macOS, iOS, Android und Linux (FMXLinux).

TsgcVCLStepper und TsgcFMXStepper

Das eigenständige Stepper-Steuerelement, horizontal oder vertikal, für jeden mehrstufigen Ablauf.

TsgcStepperModel

Das Framework-neutrale Modell hinter beiden Steuerelementen: Schritte, Zustände und Layout, mit sgcWizardSaveToPNG und sgcWizardSaveToSVG für die Headless-Ausgabe.

.NET-Steuerelemente

TsgcWinFormsWizard, TsgcWpfWizard und TsgcAvaloniaWizard, jeweils mit ihren Seiten- und Stepper-Klassen.

Zwei Demos in jeder Sprache

Onboarding, eine Anmeldung mit vier Seiten und Validierung, und Stepper, ein eigenständiger Stepper mit Zuständen.

ZielKomponentePlattformen
Delphi 7 bis 13, VCLTsgcVCLWizard, TsgcVCLStepperWin32 und Win64 ab XE2
Delphi XE6 bis 13, FireMonkeyTsgcFMXWizard, TsgcFMXStepperWindows, macOS, iOS, Android und Linux (FMXLinux)
C++ Builder 2007 bis 13TsgcVCLWizard, TsgcVCLStepperGenerierte .hpp-Header und statische Bibliotheken
Delphi 10.2 bis 13, Framework-neutralTsgcStepperModelLinux64, zum Beispiel um einen Stepper auf einem Server als PNG oder SVG zu rendern
.NETTsgcWinFormsWizard, TsgcWpfWizard, TsgcAvaloniaWizardWinForms, WPF und Avalonia

Häufig gestellte Fragen

Ja. OnBeforePageChange wird vor jedem Wechsel ausgelöst, über die Schaltflächen, die Tastatur, einen Klick auf einen Schritt oder deinen eigenen Code. Es erhält die Seite, die verlassen wird, und die Seite, die sich öffnen soll, und wenn du aAllow auf False setzt, bleibt der Anwender, wo er ist. Auch Fertig löst es aus, mit PageCount als Ziel, sodass die letzte Seite auf dieselbe Weise validiert wird.

Ja. Platziere einen TsgcVCLWizard oder einen TsgcFMXWizard auf einem Formular, klicke mit der rechten Maustaste darauf und wähle Add Page. Jede Seite wird wie jeder andere Container gestaltet, mit deinen eigenen Steuerelementen. Die Verben Next Page und Previous Page oder ein Klick auf einen Schritt des Bandes zeigen die anderen Seiten im Designer.

Ja. sgcWizard wird aus einer einzigen Quelle gebaut, und Registered, die Testversion und Community haben jede Funktion: die Assistenten, die Stepper, die Validierung, übersprungene Seiten, die Schrittzustände, die Themes und die Headless-Ausgabe als PNG und SVG. Community ist das kostenlose Paket esegece.sgcWizard.Community auf NuGet.

Ja. TsgcWpfWizard und TsgcAvaloniaWizard kommen mit ihren Seiten und Steppern, und ihre Eigenschaften sind Dependency Properties und Avalonia-Properties, die du an ein View-Modell binden kannst. In diesen beiden Hosts enthält eine Seite ein untergeordnetes Element, meist ein Panel oder ein Grid. WinForms hat TsgcWinFormsWizard mit Container-Seiten, wie in der VCL.

Ja. TsgcVCLStepper, TsgcFMXStepper und die .NET-Stepper sind eigenständige Steuerelemente mit denselben fünf Zuständen. Setze einen über ein bestehendes Formular für einen Checkout, einen Bestellstatus oder einen Ticket-Lebenszyklus, setze ActiveIndex aus deinem Code und schalte Clickable ein, damit Anwender zu einem abgeschlossenen Schritt zurückgehen können.

Ja. BackCaption, NextCaption, FinishCaption und CancelCaption sind veröffentlichte Eigenschaften, sie werden also mit den üblichen Ressourcenwerkzeugen der IDE übersetzt oder im Code gesetzt. Sie werden nur gespeichert, wenn sie vom Standard abweichen, und die Schaltflächen wachsen mit längeren Beschriftungen. Die Schrittbeschriftungen stammen aus den Beschriftungen und Beschreibungen der Seiten.

Der VCL-Assistent und -Stepper unterstützen Delphi 7 bis 13 unter Win32 und Win64 sowie C++ Builder 2007 bis 13. Die FireMonkey-Unterstützung beginnt mit Delphi XE6 für Windows, macOS, iOS, Android und Linux über FMXLinux. Der Headless-Renderer lässt sich außerdem ab Delphi 10.2 für Linux64 kompilieren.

sgcWizard Hilfe

3,000+Entwickler
20+Jahre
761+Komponenten
30+API-Integrationen
5Plattformen
30 Tage Geld-zurück-GarantieNicht zufrieden? Fordere innerhalb von 30 Tagen nach dem Kauf eine vollständige Rückerstattung an. Rückerstattungsrichtlinie ansehen

sgcWizard heute testen

Die sgcUI-Testversion enthält sgcWizard und jedes andere sgcUI-Produkt.