Baue den Rahmen einer Desktop-Anwendung mit zwei Steuerelementen, die auf jeder Oberfläche gleich aussehen. Eine Symbolleiste mit Schaltflächen, Umschaltern, Optionsgruppen und Dropdowns, und eine echte Statusleiste mit Fortschritts- und Indikatorfeldern, die ein Worker-Thread direkt aktualisieren kann.
Zwölf Funktionen für die beiden Leisten, die jede Desktop-Anwendung braucht, von Optionsgruppen bis zum Live-Fortschritt aus einem Worker-Thread.
Jedes Element, das eine Befehlsleiste braucht, wobei Gruppierung, Menüs und Überlauf vom Steuerelement übernommen werden.
Befehle
Eine echte Anwendungs-Symbolleiste mischt einfache Schaltflächen, Schaltflächen, die gedrückt bleiben, Schaltflächen mit Menü, Trennstriche und etwas Text. In sgcToolbar ist jedes davon ein Element derselben Collection, und Kind bestimmt, wie es gezeichnet wird und wie es reagiert. Die Elemente werden von links nach rechts mit Spacing dazwischen angeordnet, und ein Platzhalter nimmt die freie Breite ein, sodass du Hilfe oder einen Benutzernamen ohne Layoutcode an den rechten Rand schieben kannst. Width legt ein Element fest, wenn du eine stabile Größe brauchst. Hinweise, deaktivierte Zustände und Hot-Tracking werden für jeden Typ gezeichnet.
tikButton, tikToggle und tikDropdown für BefehletikSeparator zeichnet eine dünne senkrechte LinietikSpacer schiebt die folgenden Elemente nach rechtstikLabel zeigt Text in der Leiste
Befehle
Textausrichtung, Ansichtsmodi und Zeichenwerkzeuge sind klassische Entweder-oder-Auswahlen. Gib mehreren Umschaltern denselben GroupIndex, und sie bilden eine Optionsgruppe: Wird Down bei einem davon gesetzt, per Klick oder per Code, werden die anderen losgelassen, und ein Klick auf das bereits gedrückte Element lässt es gedrückt, sodass immer eine Auswahl bestehen bleibt. Ein Umschalter mit GroupIndex 0 ist ein einfacher Ein-Aus-Schalter wie Fett oder Zeilenumbruch. Der Klick kippt Down, bevor OnItemClick ausgelöst wird, dein Handler liest also den neuen Zustand. Für die Konsistenz der Gruppe ist keine Ereignisverdrahtung nötig.
GroupIndex größer als 0 macht eine OptionsgruppeDown liest oder setzt den Zustand per CodeDown über ihr CheckedBefehle
Zoomstufen, Exportformate und zuletzt verwendete Dateien gehören in ein Menü unter einer Schaltfläche, nicht in zehn weitere Schaltflächen. Ein tikDropdown-Element zeichnet nach seiner Beschriftung einen kleinen Pfeil und zeigt das Popup-Menü, das du DropdownMenu zuweist, direkt unter der Schaltfläche: ein TPopupMenu in VCL und FireMonkey, ein ContextMenuStrip in WinForms. OnItemClick und das OnClick des Elements werden vor dem Öffnen des Menüs ausgelöst, sodass du dessen Einträge vorher füllen oder markieren kannst. Wird das Menü freigegeben, löscht die Leiste die Referenz für dich. Ein Klickziel, ein Menü und eine Symbolleiste, die kurz bleibt, auch wenn die Befehle wachsen.
DropdownMenu nimmt das Popup deines FrameworksOnItemClickBefehle Nur Registered
Anwender ändern die Fenstergröße, und eine Symbolleiste, die ihre letzten Schaltflächen einfach abschneidet, versteckt Befehle, die sie brauchen. Passen die Elemente nicht, verschiebt sgcToolbar die letzten in eine Überlaufliste und zeichnet am rechten Ende eine Schaltfläche mit doppeltem Pfeil. Ein Klick darauf zeigt OverflowMenu, zur Laufzeit mit einem Eintrag pro verstecktem Element aufgebaut, und die Wahl eines Eintrags wirkt genau wie ein Klick: Ein Umschalter kippt, OnItemClick wird ausgelöst und ein Dropdown zeigt sein Menü. Das Modell sagt dir, was versteckt ist. Wird das Fenster wieder größer, kehren die Elemente von selbst in die Leiste zurück.
OverflowMenu wird zur Laufzeit für dich aufgebautHasOverflow, OverflowCount und InOverflow pro ElementItemAtPos meldet einen Treffer auf der ÜberlaufschaltflächeSGC_TOOLBAR_ADVANCEDCommunity: Elemente, die nicht passen, werden abgeschnitten, es gibt keine Überlaufschaltfläche.
Hilfethema lesenBefehle Nur Registered
Wenn deine Befehle bereits in einer TActionList leben, sollte die Symbolleiste sie nicht duplizieren. Verknüpfe ein Element über die Eigenschaft Action mit einer beliebigen VCL- oder FireMonkey-TAction, und es folgt Caption, Enabled, Visible, Hint, ImageIndex und Checked der Aktion. Ein Klick führt die Aktion mit der Leiste als ActionComponent aus, es sei denn, das Element hat einen OnClick-Handler. Die Leisten rufen im Leerlauf InitiateAction auf, sodass eine deaktivierte Aktion ihre Schaltfläche ohne zusätzlichen Code deaktiviert. In .NET hat das Element Command und CommandParameter für ICommand. Eine TActionList kann Symbolleiste, Hauptmenü und Navigationsleiste gemeinsam steuern.
Action verknüpft einen Eintrag mit einer beliebigen TBasicActionDown eines UmschaltersCommand und CommandParameterCommunity: Behandle stattdessen das OnClick des Elements oder das OnItemClick der Leiste, statt einer Aktion.
Hilfethema lesenEine Statusleiste, die sich selbst anordnet, Fortschritt und Zustand zeigt und Updates aus jedem Thread annimmt.
Statusleiste
Zeile und Spalte, ein Dateiname, der Speicherstand und eine Hauptmeldung konkurrieren um den unteren Fensterrand. TsgcVCLStatusBar ordnet ihre Panels von links nach rechts in drei Durchgängen an: Feste Felder nehmen ihre Width, AutoSize-Felder die Breite ihres Textes, und Spring-Felder teilen sich den Rest. Nutze ein Spring-Feld für die Hauptmeldung, und die Leiste bleibt bei jeder Fenstergröße ordentlich. Eine dünne Linie trennt die Felder, und OnPanelClick sagt dir, welches angeklickt wurde. Die Felder sind eine Collection, du kannst sie zur Entwurfszeit im Objektinspektor hinzufügen und bearbeiten.
spkText-Felder mit Alignment und HintSpring-Felder teilen sich die freie BreiteAutoSize-Felder passen sich ihrem Text anOnPanelClick meldet einen Klick auf ein Feld
Statusleiste
Lange Vorgänge brauchen einen Fortschrittsbalken, und Live-Verbindungen ein Licht, das zeigt, ob alles in Ordnung ist. Ein Feld kann ein bis zum Prozentwert Progress in der Akzentfarbe gefüllter Fortschrittsbalken sein oder ein Indikator: ein farbiger Punkt gefolgt vom Text des Feldes. IndicatorState wählt aus, ok, Warnung oder Fehler, mit Grün, Bernstein und Rot, getrennt für das helle und das dunkle Theme abgestimmt. Das passt für den Zustand einer Datenbankverbindung, eines Datenfeeds oder einer Hintergrundsynchronisierung. Setze Progress oder IndicatorState, und das Feld zeichnet sich neu, es gibt keinen Zeichencode zu schreiben.
spkProgress mit Progress von 0 bis 100spkIndicator mit IndicatorStatesisOff, sisOk, sisWarning, sisErrorGetIndicatorColor liefert die Farbe für das ThemeStatusleiste
Downloads, Feeds und lange Berechnungen laufen in Worker-Threads, und jedes Status-Update zurück in den Hauptthread zu marshallen ist mühsam und fehleranfällig. SetPanelText, SetProgress und SetIndicator dürfen aus jedem Thread aufgerufen werden, ohne Synchronize oder Queue. Das Modell schützt die Werte mit einer Sperre und löst OnChange nur aus, wenn sich ein Wert wirklich geändert hat, sodass derselbe Wert nichts kostet. Die VCL-Leiste sendet dann eine Nachricht an ihr Fenster und die FireMonkey-Leiste reiht das Neuzeichnen ein, sodass die Oberfläche nie außerhalb des Hauptthreads berührt wird. Auch ein Thread, der ein Feld überlebt, ist unproblematisch.
SetPanelText, SetProgress, SetIndicator aus jedem ThreadSynchronize oder Queue in deinem CodeSymbole, Themes und Tastaturunterstützung passend zum Rest von sgcUI, dazu Bilder der Leisten für deine Dokumentation.
Aussehen, Tastatur und Ausgabe
Jedes anklickbare Element hat einen Symbolplatz von 16 logischen Pixeln. Er zeigt das Bild an ImageIndex der Images-Liste der Leiste oder, wenn ein Element kein Bild hat, sein Glyph: einen Buchstaben oder ein kurzes Symbol, das gar keine Bildliste braucht. Schalte ShowCaptions aus für eine kompakte Leiste nur mit Symbolen, und die Beschriftung wird zum Hinweis, sodass nichts verloren geht. VCL-Bildlisten werden einmal in geradliniges ARGB konvertiert, mit zurückgewonnenem Alphakanal, und zwischengespeichert, bis sich die Liste ändert, sodass maskierte und 32-Bit-Listen beide richtig aussehen. Mische beides frei, solange die Symbole noch gestaltet werden.
Images und ImageIndex für BildlistenGlyph, wenn es kein Bild gibtShowCaptions False für nur SymboleMirrorGlyph spiegelt gerichtete Icons wie Zurück, Vor, Rückgängig und Wiederholen
Aussehen, Tastatur und Ausgabe
Die Leisten beziehen ihre Farben aus den sgcUICore-Theme-Tokens, denselben, die jedes Produkt der Suite nutzt, sodass eine Symbolleiste über einem sgcGrid und neben einer sgcNavigation-Leiste wie eine einzige Anwendung aussieht. Theme wählt utLight oder utDark, und AccentColor ersetzt den Akzent, den der Fokusring, der Gedrückt-Farbton der Umschalter und die Fortschrittsbalken nutzen. Hot-, Pressed-, Down-, Fokus- und Deaktiviert-Zustände werden für dich abgeleitet. Jede Leiste hat ihr eigenes Theme, setze es also an der Symbolleiste und an der Statusleiste. Der Wechsel zur Laufzeit zeichnet beide Leisten sofort neu.
Theme: utDefault (Standard, folgt dem Anwendungs-Theme), utLight oder utDarkAccentColor als $AARRGGBB, 0 behält den Akzent des Themes beiAussehen, Tastatur und Ausgabe
Die Symbolleiste kann in die Tab-Reihenfolge aufgenommen werden, wenn deine Anwender das brauchen: Setze TabStop, und die fokussierte Schaltfläche zeigt einen Fokusring, Links und Rechts wechseln zwischen aktivierten Schaltflächen, Pos1 und Ende springen, Enter oder Leertaste aktiviert. Standardmäßig ist es aus, damit die Symbolleiste dem Editor darunter nie den Fokus stiehlt. ClickItem aktiviert ein Element per Code, zum Beispiel über ein Formular-Tastenkürzel. An der Statusleiste zeichnet SizeGrip Griffpunkte, und in VCL ändert das Ziehen daran die Größe eines größenveränderlichen Formulars. In FireMonkey wird der Griff gezeichnet, ändert aber die Formulargröße nicht, schalte SizeGrip dort also aus, wenn das Formular nicht größenveränderlich ist.
TabStop in VCL, CanFocus in FireMonkeyClickItem führt ein Element per Code ausSizeGrip und GripRect an der StatusleisteAussehen, Tastatur und Ausgabe
Screenshots einer Symbolleiste in einem Handbuch veralten mit jedem Release. Der Renderer in sgcToolbar_Render zeichnet ein TsgcToolbarModel oder ein TsgcStatusBarModel ohne Fenster und ohne VCL oder FireMonkey, sodass ein Konsolenprogramm, ein Test oder ein Webserver dieselben Leisten als Bild erzeugen kann. SaveToPNG und SaveToSVG nehmen eine Größe in logischen Pixeln und eine Skalierung, sodass 560 mal 44 bei Skalierung 2 ein scharfes Bild von 1120 mal 88 ergibt. Die Units lassen sich auf jeder Plattform kompilieren, auch unter Linux64. Übergib deine eigenen Bilder über OnGetImage, und das Bild passt zur laufenden Anwendung.
SaveToPNG schreibt eine PNG-Datei oder einen StreamSaveToSVG schreibt dieselbe Leiste als SVGTsgcToolbarModel und TsgcStatusBarModelOnGetImage liefert Symbole für die Headless-AusgabesgcToolbar in den sgcUI-Suite-Demos: vollständige Anwendungen, die offline mit integrierten Simulationsdaten laufen.
Eine obere Leiste mit Inject event, Geschwindigkeitsschaltflächen und Theme-Umschalter, darunter die Statusleiste.
Altamira Fleet →
Die obere ERP-Leiste mit Suche, Neu, Benachrichtigungen und dem Benutzermenü.
Altamira ERP →
Die obere PMO-Leiste mit Reset what-if und dem Theme-Umschalter.
Altamira PMO →
Die obere Werksleiste mit Inject fault, Acknowledge all und Geschwindigkeitssteuerung.
Altamira Plant →
Ein Editor braucht Umschalter für Fett und Kursiv, eine Optionsgruppe für die Ausrichtung, ein Zoom-Menü und eine Statusleiste mit Zeile, Spalte und Speicherstand. sgcToolbar deckt alles mit einer Elementcollection und einer Feldcollection ab, verknüpft mit der TActionList, die du bereits hast. Wird das Fenster schmaler, hält das Überlaufmenü jeden Befehl erreichbar. Die Demo EditorShell baut genau das um ein TMemo.
Import-Werkzeuge, Sync-Clients und Monitoring-Apps arbeiten in Hintergrund-Threads und müssen darüber berichten. Rufe SetProgress, SetIndicator und SetPanelText direkt aus dem Worker-Thread auf, und die Statusleiste zeichnet sich im Hauptthread neu, ohne Synchronize in deinem Code. Der Indikator wird grün, bernsteinfarben oder rot, je nach Zustand der Aufgabe. Die Demo LiveStatus simuliert einen Download, der genau das tut.
Eine FireMonkey-Anwendung, die unter Windows, macOS und auf Mobilgeräten läuft, verdient überall dieselbe Symbolleiste. TsgcFMXToolbar und TsgcFMXStatusBar haben dieselben Elemente, Felder und Ereignisse wie die VCL-Leisten, und die .NET-Leisten für WinForms, WPF und Avalonia folgen denselben Namen. EditorShellFMX ist die FireMonkey-Version der Editor-Oberfläche, mit denselben Elementen, demselben Überlaufmenü und denselben Statusfeldern.
Dieselbe API in Delphi, C++ Builder und C#: ein Umschalter, eine Optionsgruppe, ein Dropdown und eine Statusleiste, die aus dem Click-Handler aktualisiert wird.
procedure TMainForm.CreateBars;
var
oItem: TsgcToolbarItem;
oPanel: TsgcStatusBarPanel;
begin
// a toolbar with a toggle, a Left/Center radio group and a dropdown
FToolbar := TsgcVCLToolbar.Create(Self);
FToolbar.Parent := Self;
FToolbar.ShowCaptions := True;
FToolbar.ShowHint := True;
FToolbar.OnItemClick := ToolbarItemClick;
oItem := FToolbar.Items.Add;
oItem.Caption := 'Save';
oItem.Glyph := 'S';
oItem.Hint := 'Save the document';
FToolbar.Items.Add.Kind := tikSeparator;
oItem := FToolbar.Items.Add;
oItem.Kind := tikToggle;
oItem.Caption := 'Bold';
oItem.Glyph := 'B';
oItem := FToolbar.Items.Add;
oItem.Kind := tikToggle;
oItem.GroupIndex := 1;
oItem.Down := True;
oItem.Caption := 'Left';
oItem := FToolbar.Items.Add;
oItem.Kind := tikToggle;
oItem.GroupIndex := 1;
oItem.Caption := 'Center';
oItem := FToolbar.Items.Add;
oItem.Kind := tikDropdown;
oItem.Caption := 'Zoom';
oItem.DropdownMenu := FZoomMenu;
// a status bar: a spring text panel, a progress bar and an indicator
FStatusBar := TsgcVCLStatusBar.Create(Self);
FStatusBar.Parent := Self;
oPanel := FStatusBar.Panels.Add;
oPanel.Spring := True;
oPanel.Text := 'Ready';
FStatusBar.Panels.Add.Kind := spkProgress;
oPanel := FStatusBar.Panels.Add;
oPanel.Kind := spkIndicator;
oPanel.AutoSize := True;
oPanel.Text := 'Saved';
oPanel.IndicatorState := sisOk;
end;
procedure TMainForm.ToolbarItemClick(Sender: TObject; aItem: TsgcToolbarItem);
begin
// the setters are thread safe, a worker thread can call them directly
FStatusBar.SetPanelText(0, aItem.Caption + ' clicked');
FStatusBar.SetProgress(1, 60);
FStatusBar.SetIndicator(2, sisWarning);
end;#include <vcl.h>
#include <Vcl.Menus.hpp>
#include "sgcUICore_Theme.hpp"
#include "sgcToolbar_Model.hpp"
#include "sgcToolbar_VCL.hpp"
class TBarHandler : public TObject
{
public:
TsgcVCLStatusBar *StatusBar;
void __fastcall ItemClick(TObject *Sender, TsgcToolbarItem *aItem);
};
void __fastcall TBarHandler::ItemClick(TObject *Sender, TsgcToolbarItem *aItem)
{
// the setters are thread safe, a worker thread can call them directly
StatusBar->SetPanelText(0, aItem->Caption + " clicked");
StatusBar->SetProgress(1, 60);
StatusBar->SetIndicator(2, sisWarning);
}
void __fastcall CreateBars(TForm *Form, TBarHandler *Handler, TPopupMenu *ZoomMenu)
{
// a toolbar with a toggle, a Left/Center radio group and a dropdown
TsgcVCLToolbar *Toolbar = new TsgcVCLToolbar(Form);
Toolbar->Parent = Form;
Toolbar->ShowCaptions = true;
Toolbar->OnItemClick = Handler->ItemClick;
TsgcToolbarItem *Item = Toolbar->Items->Add();
Item->Caption = "Save";
Item->Glyph = "S";
Item->Hint = "Save the document";
Toolbar->Items->Add()->Kind = tikSeparator;
Item = Toolbar->Items->Add();
Item->Kind = tikToggle;
Item->Caption = "Bold";
Item = Toolbar->Items->Add();
Item->Kind = tikToggle;
Item->GroupIndex = 1;
Item->Down = true;
Item->Caption = "Left";
Item = Toolbar->Items->Add();
Item->Kind = tikToggle;
Item->GroupIndex = 1;
Item->Caption = "Center";
Item = Toolbar->Items->Add();
Item->Kind = tikDropdown;
Item->Caption = "Zoom";
Item->DropdownMenu = ZoomMenu;
// a status bar: a spring text panel, a progress bar and an indicator
TsgcVCLStatusBar *StatusBar = new TsgcVCLStatusBar(Form);
StatusBar->Parent = Form;
TsgcStatusBarPanel *Panel = StatusBar->Panels->Add();
Panel->Spring = true;
Panel->Text = "Ready";
StatusBar->Panels->Add()->Kind = spkProgress;
Panel = StatusBar->Panels->Add();
Panel->Kind = spkIndicator;
Panel->AutoSize = true;
Panel->Text = "Saved";
Panel->IndicatorState = sisOk;
Handler->StatusBar = StatusBar;
}using System;
using System.Windows.Forms;
using esegece.sgcToolbar;
internal class MainForm : Form
{
private readonly TsgcWinFormsToolbar Toolbar = new TsgcWinFormsToolbar();
private readonly TsgcWinFormsStatusBar StatusBar = new TsgcWinFormsStatusBar();
public MainForm()
{
// a toolbar with a toggle, a Left/Center radio group and a dropdown
Toolbar.ShowCaptions = true;
Toolbar.OnItemClick = ToolbarItemClick;
TsgcToolbarItem oItem = Toolbar.Items.Add();
oItem.Caption = "Save";
oItem.Glyph = "S";
oItem.Hint = "Save the document";
Toolbar.Items.Add().Kind = TsgcToolbarItemKind.tikSeparator;
oItem = Toolbar.Items.Add();
oItem.Kind = TsgcToolbarItemKind.tikToggle;
oItem.Caption = "Bold";
oItem = Toolbar.Items.Add();
oItem.Kind = TsgcToolbarItemKind.tikToggle;
oItem.GroupIndex = 1;
oItem.Down = true;
oItem.Caption = "Left";
oItem = Toolbar.Items.Add();
oItem.Kind = TsgcToolbarItemKind.tikToggle;
oItem.GroupIndex = 1;
oItem.Caption = "Center";
ContextMenuStrip oZoom = new ContextMenuStrip();
oZoom.Items.Add("100%");
oZoom.Items.Add("200%");
oItem = Toolbar.Items.Add();
oItem.Kind = TsgcToolbarItemKind.tikDropdown;
oItem.Caption = "Zoom";
oItem.DropdownMenu = oZoom;
// a status bar: a spring text panel, a progress bar and an indicator
TsgcStatusBarPanel oPanel = StatusBar.Panels.Add();
oPanel.Spring = true;
oPanel.Text = "Ready";
StatusBar.Panels.Add().Kind = TsgcStatusPanelKind.spkProgress;
oPanel = StatusBar.Panels.Add();
oPanel.Kind = TsgcStatusPanelKind.spkIndicator;
oPanel.AutoSize = true;
oPanel.Text = "Saved";
oPanel.IndicatorState = TsgcStatusIndicatorState.sisOk;
Controls.Add(Toolbar);
Controls.Add(StatusBar);
}
private void ToolbarItemClick(object sender, TsgcToolbarItem aItem)
{
// the setters are thread safe, a worker thread can call them directly
StatusBar.SetPanelText(0, aItem.Caption + " clicked");
StatusBar.SetProgress(1, 60);
StatusBar.SetIndicator(2, TsgcStatusIndicatorState.sisWarning);
}
}dotnet add package esegece.sgcToolbar.WinFormsDie Demos EditorShell und LiveStatus gibt es für VCL und C++ Builder, dazu eine FireMonkey-Version für Delphi, und in der .NET-Edition als WinForms-, WPF- und Avalonia-Projekte.
Eine TMemo-Editor-Oberfläche mit Umschaltern, einer Optionsgruppe Links, Zentriert und Rechts, einem Zoom-Dropdown, TActionList-Verknüpfungen, dem Überlaufmenü, Feldern für Zeile und Spalte und einem Dark-Umschalter. Sie nutzt Überlauf und Aktionen und braucht daher die Edition Registered oder die Testversion.
Ein Worker-Thread simuliert einen Download und speist ein Textfeld, ein Fortschrittsfeld und einen Indikator, der grün, bernsteinfarben oder rot wird, mit den Schaltflächen Start und Stop. Sie lässt sich mit der Community Edition kompilieren.
Die Demo EditorShell mit einer TsgcFMXToolbar und einer TsgcFMXStatusBar um ein FireMonkey-TMemo, nur für Delphi: dieselben Elemente, Aktionsverknüpfungen, dasselbe Überlaufmenü und dieselben Statusfelder.
Sofort lauffähige Programme jedes sgcUI-Produkts, nichts zu installieren.
sgcUI_bin.zip herunterladen →sgcToolbar ist in jeder sgcUI-Edition enthalten, ab Standard, und wird auch einzeln verkauft. sgcToolbar ist außerdem im All-Access-Paket enthalten.
€149 / Entwickler, voller Quellcode, 1 Jahr Updates.
sgcToolbar kaufen → Preise ansehen →Standard plus sgcCharts, sgcDashboard und sgcGauges, ab €529.
Professional ansehen →Die kostenlose Community Edition (esegece.sgcToolbar.Community auf NuGet) lässt das Überlaufmenü und die Aktionsverknüpfungen weg.
| Funktion | Community (kostenlos) | Registered |
|---|---|---|
| Jeder Elementtyp, Umschalter, Optionsgruppen und Dropdown-Menüs | ✓ | ✓ |
| Text-, Fortschritts- und Indikatorfelder | ✓ | ✓ |
| Threadsichere Status-Updates | ✓ | ✓ |
| Symbole, Glyphs, Themes, Tastatur und Size-Grip | ✓ | ✓ |
| Headless-Ausgabe als PNG und SVG | ✓ | ✓ |
| Überlaufmenü | − | ✓ |
| Aktionsverknüpfungen (Delphi) und Command (.NET) | − | ✓ |
| Komponente | Ziel |
|---|---|
| TsgcVCLToolbar, TsgcVCLStatusBar | Delphi und C++ Builder, VCL (sgcToolbar_VCL) |
| TsgcFMXToolbar, TsgcFMXStatusBar | Delphi und C++ Builder, FireMonkey (sgcToolbar_FMX) |
| TsgcToolbarItem, TsgcStatusBarPanel, TsgcToolbarModel, TsgcStatusBarModel | Framework-neutrale Modelle (sgcToolbar_Model) |
| TsgcWinFormsToolbar, TsgcWinFormsStatusBar | .NET, WinForms |
| TsgcWpfToolbar, TsgcWpfStatusBar | .NET, WPF |
| TsgcAvaloniaToolbar, TsgcAvaloniaStatusBar | .NET, Avalonia |
| Ziel | Komponente | Plattformen |
|---|---|---|
| Delphi 7 bis 13, VCL | TsgcVCLToolbar, TsgcVCLStatusBar | Win32 und Win64 |
| Delphi XE6 bis 13, FireMonkey | TsgcFMXToolbar, TsgcFMXStatusBar | Windows, macOS, iOS, Android und Linux (FMXLinux) |
| C++ Builder 2007 bis 13 | VCL- und FireMonkey-Leisten | Generierte .hpp-Header und statische Bibliotheken |
| Delphi 10.2 bis 13, Framework-neutral | Modelle und Headless-Renderer für PNG und SVG | Linux64, zum Beispiel um eine Symbolleiste auf einem Server zu rendern |
| .NET Framework 4.7.2, .NET 8, 9 und 10 | TsgcWinFormsToolbar, WPF- und Avalonia-Leisten | WinForms, WPF und Avalonia |
Ja. SetPanelText, SetProgress und SetIndicator dürfen aus jedem Thread aufgerufen werden, ohne Synchronize oder Queue. Das Modell schützt die Werte mit einer Sperre, und die Leiste zeichnet sich im Hauptthread neu. Jede andere Eigenschaft wird aus dem Hauptthread gesetzt. Siehe Threadsichere Updates.
Sie deckt dieselben Aufgaben ab: Schaltflächen, Umschalter, Dropdown-Schaltflächen, Trennstriche und Bezeichnungen oben, Textfelder unten. Dazu kommen ein Platzhalter-Element, Fortschritts- und Indikatorfelder, threadsichere Setter, Themes und Headless-Ausgabe. Deine vorhandenen TActionList- und TPopupMenu-Komponenten lassen sich über Action und DropdownMenu anbinden.
Das Überlaufmenü und die Aktionsverknüpfungen der Einträge, in .NET sind das Command und CommandParameter. In Community werden Elemente, die nicht passen, abgeschnitten. Jede andere Funktion, einschließlich der threadsicheren Status-Updates, der Fortschritts- und Indikatorfelder und der Headless-Ausgabe, ist in Community enthalten.
Ja. C++ Builder 2007 bis 13 nutzen dieselben VCL- und FireMonkey-Leisten über generierte Header und Bibliotheken, und die Demos EditorShell und LiveStatus werden auch als C++ Builder-Projekte ausgeliefert. Der Code-Tab auf dieser Seite zeigt dieselbe Symbolleiste in Delphi, C++ Builder und C#.
Ja. Alle Größen sind logische Pixel multipliziert mit der Skalierung des Monitors, und der Symbolplatz hat 16 logische Pixel, sodass Schaltflächen, Glyphs, Fortschrittsbalken und Indikatorpunkte bei jeder DPI scharf bleiben. FireMonkey holt Bilder aus der Bildliste in der Gerätegröße des Frames.
Ja. SaveToSVG und SaveToPNG von TsgcToolbarModel und TsgcStatusBarModel zeichnen die Leisten ohne Fenster, auch unter Linux64 ab Delphi 10.2, sodass ein Build-Schritt die Bilder deines Handbuchs bei jedem Release neu erzeugen kann. Ein Skalierungsparameter liefert scharfe Bilder für High-DPI-Bildschirme und den Druck.
Einführung, Quick Start VCL, Quick Start FireMonkey, TsgcVCLToolbar, TsgcVCLStatusBar, Elementtypen, Statusfelder, Threadsichere Updates, Editionen, Plattformen.
Einführung, Quick Start C++ Builder, TsgcVCLToolbar, TsgcVCLStatusBar, Demos.
.NET-Übersicht, Quick Start WinForms, Quick Start WPF, Quick Start Avalonia, Unterschiede zu Delphi.
Delphi, C++ Builder und .NET, mit allen sgcUI-Produkten.
Ergänze eine Seitenleiste oder ein Akkordeon mit denselben Theme-Tokens, und Symbolleiste, Statusleiste und Menü bilden eine einzige Anwendungsoberfläche.
sgcNavigation entdecken →
Platziere Datumsauswahl, Schieberegler und Token-Eingaben in den Formularen unter der Symbolleiste, mit demselben Theme und derselben Akzentfarbe.
sgcEditors entdecken →
Kombiniere die Statusleiste mit einem Live-Datengrid und zeige Zeilenanzahl, Filter und Feed-Zustand als Felder an.
sgcGrid entdecken →