Delphi, C++ Builder & .NET Fait partie de sgcUI

sgcToolbar, la barre d'outils et la barre d'état pour Delphi, C++ Builder & .NET

Construis l'ossature d'une application de bureau avec deux contrôles qui ont le même aspect sur toutes les interfaces. Une barre d'outils avec boutons, bascules, groupes radio et listes déroulantes, et une vraie barre d'état avec des panneaux de progression et d'indicateur qu'un thread de travail peut mettre à jour directement.

VCL, FireMonkey, WinForms, WPF, AvaloniaMises à jour de la barre d'état depuis n'importe quel threadÉdition .NET Community gratuiteInclus dans sgcUI Standard
Barre d'outils EditorShell en 2x avec des légendes sur un bouton, une bascule, un séparateur, une liste déroulante, une étiquette et un espaceur

Une barre de commandes et d'état complète

Douze fonctionnalités pour les deux barres dont toute application de bureau a besoin, des groupes radio à la progression en direct depuis un thread de travail.

Commandes

Tous les éléments dont une barre de commandes a besoin, avec le regroupement, les menus et le débordement gérés par le contrôle.

Tous les types d'éléments de barre d'outils dans un seul contrôle

Commandes

Tous les types d'éléments de barre d'outils dans un seul contrôle

Une vraie barre d'outils d'application mélange des boutons simples, des boutons qui restent enfoncés, des boutons avec un menu, des séparateurs et un peu de texte. Avec sgcToolbar, chacun est un élément de la même collection, et Kind décide de la façon dont il est dessiné et dont il réagit. Les éléments sont disposés de gauche à droite avec Spacing entre eux, et un espaceur prend la largeur libre, ce qui permet de repousser Aide ou un nom d'utilisateur au bord droit sans code de mise en page. Width fixe un élément quand tu as besoin d'une taille stable. Les infobulles, les états désactivés et le survol sont dessinés pour chaque type.

  • tikButton, tikToggle et tikDropdown pour les commandes
  • tikSeparator dessine un fin trait vertical
  • tikSpacer repousse les éléments suivants vers la droite
  • tikLabel affiche du texte dans la barre
Lire la rubrique d'aide
Des groupes radio sans code

Commandes

Des groupes radio sans code

L'alignement du texte, les modes d'affichage et les outils de dessin sont des choix classiques parmi plusieurs. Donne le même GroupIndex à plusieurs bascules et elles forment un groupe radio : mettre Down sur l'une d'elles, par un clic ou depuis le code, relâche les autres, et un clic sur l'élément déjà enfoncé le laisse enfoncé, donc un choix reste toujours sélectionné. Une bascule avec GroupIndex 0 est un simple interrupteur comme Gras ou Retour à la ligne. Le clic inverse Down avant le déclenchement de OnItemClick, donc ton gestionnaire lit le nouvel état. Aucun câblage d'événement n'est nécessaire pour garder le groupe cohérent.

  • GroupIndex supérieur à 0 crée un groupe radio
  • Down lit ou définit l'état depuis le code
  • L'état enfoncé est dessiné avec une teinte d'accentuation
  • Une action liée pilote Down via son Checked
Lire la rubrique d'aide

Commandes

Des menus déroulants depuis ton menu contextuel

Les niveaux de zoom, les formats d'export et les fichiers récents ont leur place dans un menu sous un bouton, pas dans dix boutons de plus. Un élément tikDropdown dessine une petite flèche après son libellé et affiche juste sous le bouton le menu contextuel que tu affectes à DropdownMenu : un TPopupMenu en VCL et FireMonkey, un ContextMenuStrip en WinForms. OnItemClick et le OnClick de l'élément se déclenchent avant l'ouverture du menu, donc tu peux d'abord remplir ou cocher ses entrées. Si le menu est libéré, la barre efface la référence pour toi. Une seule cible de clic, un seul menu, et une barre d'outils qui reste courte même quand les commandes se multiplient.

  • DropdownMenu accepte le menu contextuel de ton framework
  • La flèche est dessinée après le libellé
  • Remplis ou coche le menu dans OnItemClick
  • Fonctionne aussi depuis le menu de débordement
Lire la rubrique d'aide

Commandes Enregistrée uniquement

Les éléments qui ne tiennent pas passent dans un menu de débordement

Les utilisateurs redimensionnent les fenêtres, et une barre d'outils qui coupe simplement ses derniers boutons cache des commandes dont ils ont besoin. Quand les éléments ne tiennent pas, sgcToolbar déplace les derniers dans une liste de débordement et dessine un bouton à double chevron à l'extrémité droite. Un clic affiche OverflowMenu, construit à l'exécution avec une entrée par élément masqué, et choisir une entrée agit exactement comme un clic : une bascule s'inverse, OnItemClick se déclenche et une liste déroulante affiche son menu. Le modèle te dit ce qui est masqué. Quand la fenêtre s'agrandit de nouveau, les éléments reviennent dans la barre d'eux-mêmes.

  • OverflowMenu est construit pour toi à l'exécution
  • HasOverflow, OverflowCount et InOverflow par élément
  • ItemAtPos signale un clic sur le bouton de débordement
  • Compilé sous SGC_TOOLBAR_ADVANCED

Community : les éléments qui ne tiennent pas sont coupés, il n'y a pas de bouton de débordement.

Lire la rubrique d'aide

Commandes Enregistrée uniquement

Réutilise tes TAction

Si tes commandes vivent déjà dans une TActionList, la barre d'outils ne doit pas les dupliquer. Relie un élément à n'importe quelle TAction VCL ou FireMonkey via sa propriété Action et il suit les Caption, Enabled, Visible, Hint, ImageIndex et Checked de l'action. Un clic exécute l'action avec la barre comme ActionComponent, sauf si l'élément a un gestionnaire OnClick. Les barres appellent InitiateAction en temps libre, donc une action désactivée désactive son bouton sans code supplémentaire. En .NET, l'élément a Command et CommandParameter pour ICommand. Une seule TActionList peut piloter ensemble la barre d'outils, le menu principal et la barre de navigation.

  • Action relie un élément à n'importe quelle TBasicAction
  • Le Checked de l'action pilote le Down d'une bascule
  • Le OnUpdate des actions s'exécute en temps libre
  • .NET : Command et CommandParameter

Community : gère le OnClick de l'élément ou le OnItemClick de la barre à la place d'une action.

Lire la rubrique d'aide

Barre d'état

Une barre d'état qui se dispose toute seule, affiche la progression et l'état, et accepte les mises à jour depuis n'importe quel thread.

Des panneaux d'état qui se disposent d'eux-mêmes

Barre d'état

Des panneaux d'état qui se disposent d'eux-mêmes

Ligne et colonne, un nom de fichier, l'état d'enregistrement et un message principal se disputent le bord inférieur de la fenêtre. TsgcVCLStatusBar dispose ses Panels de gauche à droite en trois passes : les panneaux fixes prennent leur Width, les panneaux AutoSize prennent la largeur de leur texte et les panneaux Spring se partagent ce qui reste. Utilise un panneau Spring pour le message principal et la barre reste propre à toutes les tailles de fenêtre. Un fin trait sépare les panneaux, et OnPanelClick t'indique lequel a reçu le clic. Les panneaux forment une collection, donc tu peux les ajouter et les modifier dans l'inspecteur d'objets à la conception.

  • Panneaux spkText avec Alignment et Hint
  • Les panneaux Spring se partagent la largeur libre
  • Les panneaux AutoSize s'adaptent à leur texte
  • OnPanelClick signale un clic sur un panneau
Lire la rubrique d'aide
Barres de progression et indicateurs d'état

Barre d'état

Barres de progression et indicateurs d'état

Les opérations longues ont besoin d'une barre de progression, et les connexions actives d'un voyant qui dit si tout va bien. Un panneau peut être une barre de progression remplie à Progress pour cent dans la couleur d'accentuation, ou un indicateur : un point coloré suivi du texte du panneau. IndicatorState choisit éteint, ok, avertissement ou erreur, avec un vert, un ambre et un rouge réglés séparément pour le thème clair et le thème sombre. Il convient à l'état d'une connexion à une base de données, d'un flux de données ou d'une synchronisation en arrière-plan. Définis Progress ou IndicatorState et le panneau se redessine, il n'y a aucun code de dessin à écrire.

  • spkProgress avec Progress de 0 à 100
  • spkIndicator avec IndicatorState
  • sisOff, sisOk, sisWarning, sisError
  • GetIndicatorColor renvoie la couleur pour le thème
Lire la rubrique d'aide

Barre d'état

Mets à jour la barre d'état depuis un thread de travail

Les téléchargements, les flux et les longs calculs tournent dans des threads de travail, et renvoyer chaque mise à jour d'état vers le thread principal est fastidieux et facile à mal faire. SetPanelText, SetProgress et SetIndicator peuvent être appelés depuis n'importe quel thread sans Synchronize ni Queue. Le modèle protège les valeurs par un verrou et ne déclenche OnChange que lorsqu'une valeur a vraiment changé, donc répéter la même valeur ne coûte rien. La barre VCL poste alors un message à sa fenêtre et la barre FireMonkey met le redessin en file, donc l'interface n'est jamais touchée hors du thread principal. Un thread qui survit à un panneau est lui aussi sans danger.

  • SetPanelText, SetProgress, SetIndicator depuis n'importe quel thread
  • Aucun Synchronize ni Queue dans ton code
  • Les valeurs inchangées ne coûtent rien
  • Un index hors limites est ignoré, jamais levé en erreur
Lire la rubrique d'aide

Aspect, clavier et rendu

Icônes, thèmes et prise en charge du clavier cohérents avec le reste de sgcUI, plus des images des barres pour ta documentation.

Icônes ou lettres de glyphe, libellés facultatifs

Aspect, clavier et rendu

Icônes ou lettres de glyphe, libellés facultatifs

Chaque élément cliquable a un emplacement d'icône de 16 pixels logiques. Il affiche l'image à ImageIndex de la liste Images de la barre ou, quand un élément n'a pas d'image, son Glyph : une lettre ou un court symbole qui n'a besoin d'aucune liste d'images. Désactive ShowCaptions pour une barre compacte avec les seules icônes, et le libellé devient l'infobulle, donc rien n'est perdu. Les listes d'images VCL sont converties une seule fois en ARGB direct avec l'alpha récupéré et mises en cache jusqu'à ce que la liste change, donc les listes masquées et 32 bits s'affichent bien. Mélange les deux librement tant que les icônes sont en cours de conception.

  • Images et ImageIndex pour les listes d'images
  • Glyph quand il n'y a pas d'image
  • ShowCaptions à False pour les icônes seules
  • Listes d'images FireMonkey à partir de Delphi XE8
  • De droite à gauche pour l'arabe et l'hébreu : les éléments s'écoulent depuis la droite, et MirrorGlyph retourne les icônes directionnelles comme précédent, suivant, annuler et rétablir
Lire la rubrique d'aide
Clair, sombre et ta couleur d'accentuation

Aspect, clavier et rendu

Clair, sombre et ta couleur d'accentuation

Les barres prennent leurs couleurs dans les jetons de thème de sgcUICore, les mêmes que ceux de tous les produits de la suite, donc une barre d'outils au-dessus d'un sgcGrid et à côté d'une barre sgcNavigation ressemble à une seule application. Theme choisit utLight ou utDark, et AccentColor remplace l'accentuation utilisée par l'anneau de focus, la teinte enfoncée des bascules et les barres de progression. Les états survol, appui, enfoncé, focus et désactivé sont tous dérivés pour toi. Chaque barre a son propre Theme, donc définis-le sur la barre d'outils et sur la barre d'état. Changer à l'exécution redessine les deux barres d'un coup.

  • Theme : utDefault (par défaut, suit le thème de l'application), utLight ou utDark
  • AccentColor comme $AARRGGBB, 0 conserve l'accentuation du thème
  • Les couleurs des indicateurs suivent le thème
  • Change à l'exécution pour un interrupteur de mode sombre
Lire la rubrique d'aide

Aspect, clavier et rendu

Accès au clavier et poignée de redimensionnement fonctionnelle

La barre d'outils peut entrer dans l'ordre de tabulation quand tes utilisateurs en ont besoin : active TabStop et le bouton qui a le focus affiche un anneau de focus, Gauche et Droite passent d'un bouton activé à l'autre, Début et Fin sautent, Entrée ou Espace active. C'est désactivé par défaut, donc la barre d'outils ne prend jamais le focus à l'éditeur situé dessous. ClickItem active un élément depuis le code, par exemple depuis un raccourci de la fiche. Sur la barre d'état, SizeGrip dessine les points de la poignée, et en VCL les faire glisser redimensionne une fiche redimensionnable. En FireMonkey la poignée est dessinée mais ne redimensionne pas la fiche, donc désactive SizeGrip quand la fiche n'est pas redimensionnable.

  • TabStop en VCL, CanFocus en FireMonkey
  • ClickItem exécute un élément depuis le code
  • SizeGrip et GripRect sur la barre d'état
  • La poignée ne redimensionne la fiche que si elle est redimensionnable
Lire la rubrique d'aide

Aspect, clavier et rendu

Dessine les deux barres sans fenêtre

Les captures d'écran d'une barre d'outils dans un manuel se périment à chaque version. Le moteur de rendu de sgcToolbar_Render dessine un TsgcToolbarModel ou un TsgcStatusBarModel sans fenêtre et sans VCL ni FireMonkey, donc un programme console, un test ou un serveur web peut produire les mêmes barres sous forme d'image. SaveToPNG et SaveToSVG prennent une taille en pixels logiques et une échelle, donc 560 par 44 à l'échelle 2 donne une image nette de 1120 par 88. Les unités se compilent sur toutes les plateformes, Linux64 compris. Passe tes propres images via OnGetImage et l'image correspond à l'application en cours d'exécution.

  • SaveToPNG écrit un fichier ou un flux PNG
  • SaveToSVG écrit la même barre en SVG
  • Fonctionne sur TsgcToolbarModel et TsgcStatusBarModel
  • OnGetImage fournit les icônes au rendu sans interface
Lire la rubrique d'aide

Découvre sgcToolbar en action

sgcToolbar dans les démos de la suite sgcUI : des applications complètes qui fonctionnent hors ligne avec des données simulées intégrées.

Qui construit avec sgcToolbar

Éditeurs de documents et de code

Un éditeur a besoin de bascules Gras et Italique, d'un groupe radio d'alignement, d'un menu Zoom et d'une barre d'état avec la ligne, la colonne et l'état d'enregistrement. sgcToolbar couvre tout cela avec une seule collection d'éléments et une seule collection de panneaux, reliées à la TActionList que tu as déjà. Quand la fenêtre se rétrécit, le menu de débordement garde chaque commande accessible. La démo EditorShell construit exactement cela autour d'un TMemo.

  • Types d'éléments
  • Groupes radio
  • Menu de débordement
Lance la démo EditorShell

Outils de longue durée et flux en direct

Les outils d'import, les clients de synchronisation et les applications de supervision travaillent dans des threads d'arrière-plan et doivent le signaler. Appelle SetProgress, SetIndicator et SetPanelText directement depuis le thread de travail, et la barre d'état se redessine dans le thread principal sans Synchronize dans ton code. L'indicateur passe au vert, à l'ambre ou au rouge selon l'état de la tâche. La démo LiveStatus simule un téléchargement qui fait exactement cela.

  • Mises à jour thread-safe
  • Panneaux de progression
  • Indicateurs
Lance la démo LiveStatus

Une seule barre de commandes sur toutes les plateformes

Une application FireMonkey livrée sous Windows, macOS et mobile mérite la même barre d'outils partout. TsgcFMXToolbar et TsgcFMXStatusBar ont les mêmes éléments, panneaux et événements que les barres VCL, et les barres .NET pour WinForms, WPF et Avalonia suivent les mêmes noms. EditorShellFMX est la version FireMonkey de la structure d'éditeur, avec les mêmes éléments, le même menu de débordement et les mêmes panneaux d'état.

  • Barres FireMonkey
  • Thèmes
  • Panneaux d'état
Lance la démo EditorShellFMX

Une barre d'outils et une barre d'état en quelques lignes

La même API en Delphi, C++ Builder et C# : une bascule, un groupe radio, une liste déroulante et une barre d'état mise à jour depuis le gestionnaire de clic.

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.WinForms

Lance les démos de sgcToolbar

Les démos EditorShell et LiveStatus sont fournies pour VCL et C++ Builder, avec en plus une version FireMonkey pour Delphi, et dans l'édition .NET sous forme de projets WinForms, WPF et Avalonia.

EditorShell

Enregistrée uniquement EditorShell

Une structure d'éditeur TMemo avec des bascules, un groupe radio Gauche, Centre et Droite, une liste déroulante Zoom, des liens TActionList, le menu de débordement, des panneaux ligne et colonne et une bascule Dark. Elle utilise le débordement et les actions, donc elle demande l'édition Enregistrée ou l'essai.

LiveStatus

Un thread de travail simule un téléchargement et alimente un panneau de texte, un panneau de progression et un indicateur qui passe au vert, à l'ambre ou au rouge, avec des boutons Start et Stop. Elle se compile avec l'édition Community.

Enregistrée uniquement EditorShellFMX

La démo EditorShell avec un TsgcFMXToolbar et un TsgcFMXStatusBar autour d'un TMemo FireMonkey, pour Delphi uniquement : les mêmes éléments, liens d'action, menu de débordement et panneaux d'état.

Démos compilées

Des exécutables prêts à lancer pour chaque produit sgcUI, rien à installer.

Télécharger sgcUI_bin.zip →

Où sgcToolbar est inclus

sgcToolbar est dans toutes les éditions sgcUI, à partir de Standard, et il est aussi vendu seul. sgcToolbar est également inclus dans le pack All-Access.

sgcToolbar, package seul

€149 / développeur, code source complet, 1 an de mises à jour.

Acheter sgcToolbar → Voir les tarifs →

sgcUI Standard

sgcToolbar, sgcGrid, sgcNavigation et sgcEditors, à partir de €380.

Voir Standard →

sgcUI Professional

Standard plus sgcCharts, sgcDashboard et sgcGauges, à partir de €529.

Voir Professional →

sgcUI Enterprise

Les 14 produits sgcUI, à partir de €699.

Voir Enterprise →

L'édition Community gratuite (esegece.sgcToolbar.Community sur NuGet) ne comprend ni le menu de débordement ni les liens d'action.

FonctionnalitéCommunity (gratuite)Enregistrée
Tous les types d'éléments, bascules, groupes radio et menus déroulants✓✓
Panneaux de texte, de progression et d'indicateur✓✓
Mises à jour d'état thread-safe✓✓
Icônes, glyphes, thèmes, clavier et poignée de redimensionnement✓✓
Rendu PNG et SVG sans interface✓✓
Menu de débordement−✓
Liens d'action (Delphi) et Command (.NET)−✓

Frameworks et plateformes pris en charge

Composants de sgcToolbar

ComposantCible
TsgcVCLToolbar, TsgcVCLStatusBarDelphi et C++ Builder, VCL (sgcToolbar_VCL)
TsgcFMXToolbar, TsgcFMXStatusBarDelphi et C++ Builder, FireMonkey (sgcToolbar_FMX)
TsgcToolbarItem, TsgcStatusBarPanel, TsgcToolbarModel, TsgcStatusBarModelModèles indépendants du framework (sgcToolbar_Model)
TsgcWinFormsToolbar, TsgcWinFormsStatusBar.NET, WinForms
TsgcWpfToolbar, TsgcWpfStatusBar.NET, WPF
TsgcAvaloniaToolbar, TsgcAvaloniaStatusBar.NET, Avalonia
CibleComposantPlateformes
Delphi 7 à 13, VCLTsgcVCLToolbar, TsgcVCLStatusBarWin32 et Win64
Delphi XE6 à 13, FireMonkeyTsgcFMXToolbar, TsgcFMXStatusBarWindows, macOS, iOS, Android et Linux (FMXLinux)
C++ Builder 2007 à 13Barres VCL et FireMonkeyEn-têtes .hpp générés et bibliothèques statiques
Delphi 10.2 à 13, indépendant du frameworkModèles et moteur de rendu PNG et SVG sans interfaceLinux64, par exemple pour dessiner une barre d'outils sur un serveur
.NET Framework 4.7.2, .NET 8, 9 et 10TsgcWinFormsToolbar, barres WPF et AvaloniaWinForms, WPF et Avalonia

Foire aux questions

Oui. SetPanelText, SetProgress et SetIndicator peuvent être appelés depuis n'importe quel thread sans Synchronize ni Queue. Le modèle protège les valeurs par un verrou et la barre se redessine dans le thread principal. Toutes les autres propriétés se définissent depuis le thread principal. Voir Mises à jour thread-safe.

Elle couvre les mêmes tâches : boutons, bascules, boutons déroulants, séparateurs et étiquettes en haut, panneaux de texte en bas. Elle ajoute un élément espaceur, des panneaux de progression et d'indicateur, des accesseurs thread-safe, des thèmes et le rendu sans interface. Tes composants TActionList et TPopupMenu existants se branchent via Action et DropdownMenu.

Le menu de débordement et les liens d'action des éléments, qui sont Command et CommandParameter en .NET. Dans Community, les éléments qui ne tiennent pas sont coupés. Toutes les autres fonctionnalités, dont les mises à jour d'état thread-safe, les panneaux de progression et d'indicateur et le rendu sans interface, sont dans Community.

Oui. C++ Builder 2007 à 13 utilisent les mêmes barres VCL et FireMonkey via des en-têtes et des bibliothèques générés, et les démos EditorShell et LiveStatus sont aussi fournies comme projets C++ Builder. L'onglet de code de cette page montre la même barre d'outils en Delphi, C++ Builder et C#.

Oui. Toutes les tailles sont des pixels logiques multipliés par l'échelle du moniteur, et l'emplacement d'icône fait 16 pixels logiques, donc les boutons, les glyphes, les barres de progression et les points d'indicateur restent nets à toute densité. FireMonkey prend les images de la liste d'images à la taille de périphérique du cadre.

Oui. SaveToSVG et SaveToPNG de TsgcToolbarModel et TsgcStatusBarModel dessinent les barres sans fenêtre, y compris sous Linux64 à partir de Delphi 10.2, donc une étape de compilation peut régénérer les images de ton manuel à chaque version. Un paramètre d'échelle donne des images nettes pour les écrans haute densité et l'impression.

Aide de sgcToolbar

3,000+Développeurs
20+Ans
761+Composants
30+Intégrations d'API
5Plateformes
Garantie satisfait ou remboursé de 30 joursPas satisfait ? Demandez un remboursement intégral dans les 30 jours suivant l'achat. Voir la politique de remboursement

Essaie sgcToolbar dès aujourd'hui

L'essai sgcUI inclut sgcToolbar et tous les autres produits sgcUI.