sgcSpreadsheet : un tableur de style Excel pour Delphi et .NET

Tôt ou tard, toute application métier a besoin d'une feuille de calcul. Les utilisateurs planifient un budget, chiffrent un devis, calculent des coûts ou vérifient les chiffres qu'un client a envoyés dans un fichier Excel, et ils attendent des formules, plusieurs feuilles et des graphiques pour le faire. Une simple grille ne suffit à aucun de ces usages.

sgcSpreadsheet est un contrôle tableur de style Excel construit sur sgcGrid et sur un moteur de formules partagé dans sgcUICore. Il conserve un véritable classeur avec des feuilles, des noms définis et des tableaux dynamiques, ne recalcule que les cellules touchées par une modification, et charge et enregistre du XLSX. Le même moteur alimente les contrôles VCL et FireMonkey pour Delphi et C++ Builder ainsi que les contrôles WinForms, WPF et Avalonia pour .NET.

sgcSpreadsheet en action

Formules, tableaux à débordement, plusieurs feuilles, graphiques en direct et fichiers XLSX sur toutes les plateformes. Aussi sur YouTube.

Des formules que vos utilisateurs connaissent déjà

Ceux qui travaillent avec des chiffres pensent en formules Excel. Dans sgcSpreadsheet, un texte qui commence par = est une formule, et le moteur calcule 211 fonctions de feuille de calcul : mathématiques, statistiques, texte, date et heure, recherche, logiques, informations et tableaux dynamiques. Le moteur réside dans sgcUICore, si bien que les formules de sgcGrid donnent les mêmes résultats.

Feuilles, noms et tableaux à débordement

Un tableur est un classeur composé d'une ou plusieurs feuilles. Les onglets sous la grille changent de feuille et l'onglet + en ajoute une, et une feuille renommée l'est dans toutes les formules qui s'y réfèrent. Depuis le code, AddSheet, ActiveSheet et SheetCount gèrent les feuilles, et Grid.Sheets.Names conserve les noms définis du classeur.

La méthode ci-dessous remplit une liste de prix, nomme ses plages et construit une feuille de synthèse qui la lit. SORT renvoie toute la liste des produits, qui déborde dans les cellules situées en dessous, et A1# désigne cette plage débordante quelle que soit la longueur de la liste. XLOOKUP trouve un prix et le nom VAT ajoute la taxe.

uses
  sgcSpreadsheet_VCL;

procedure TForm1.BuildPriceList;
var
  vSummary: Integer;
begin
  // Sheet1: a price list, row and column are 0-based, (0, 0) is A1
  sgcVCLSpreadsheet1.SetCellInput(0, 0, 'Product');
  sgcVCLSpreadsheet1.SetCellInput(0, 1, 'Price');
  sgcVCLSpreadsheet1.SetCellInput(1, 0, 'Monitor');
  sgcVCLSpreadsheet1.SetCellInput(1, 1, '219');
  sgcVCLSpreadsheet1.SetCellInput(2, 0, 'Keyboard');
  sgcVCLSpreadsheet1.SetCellInput(2, 1, '49');
  sgcVCLSpreadsheet1.SetCellInput(3, 0, 'Mouse');
  sgcVCLSpreadsheet1.SetCellInput(3, 1, '25');
  // defined names: formulas use them instead of cell addresses
  sgcVCLSpreadsheet1.Grid.Sheets.Names.Add('Products', '=Sheet1!$A$2:$A$4');
  sgcVCLSpreadsheet1.Grid.Sheets.Names.Add('Prices', '=Sheet1!$B$2:$B$4');
  sgcVCLSpreadsheet1.Grid.Sheets.Names.Add('VAT', '0.21');
  // a second sheet that reads the first one
  vSummary := sgcVCLSpreadsheet1.AddSheet('Summary');
  sgcVCLSpreadsheet1.ActiveSheet := vSummary;
  // a dynamic array: the sorted names spill into A1:A3
  sgcVCLSpreadsheet1.SetCellInput(0, 0, '=SORT(Products)');
  // A1# is the whole spilled range, however long the list grows
  sgcVCLSpreadsheet1.SetCellInput(0, 2, 'Items');
  sgcVCLSpreadsheet1.SetCellInput(0, 3, '=ROWS(A1#)');
  // XLOOKUP finds the price of a product, VAT included
  sgcVCLSpreadsheet1.SetCellInput(1, 2, 'Monitor');
  sgcVCLSpreadsheet1.SetCellInput(1, 3, '=XLOOKUP(C2,Products,Prices)*(1+VAT)');
  // every sheet, formula and name goes to a file that Excel opens
  sgcVCLSpreadsheet1.SaveToXLSX('prices.xlsx');
end;

La synthèse affiche les trois produits dans l'ordre, 3 articles, et 264,99 pour l'écran. Modifiez un prix sur la première feuille et seules les cellules qui en dépendent sont recalculées. FreezePanes(1, 0) maintient une ligne d'en-tête en place pendant que le reste de la feuille défile, et les barres de formule TsgcVCLSpreadsheetFormulaBar et TsgcFMXSpreadsheetFormulaBar offrent à vos utilisateurs une zone de nom et la formule de la cellule courante.

Vos propres fonctions

Les applications d'ingénierie, de finance et de laboratoire ont besoin de leurs propres calculs. Le moteur de formules dispose d'un registre de fonctions, et une fonction qui y est enregistrée fonctionne dans toutes les formules du tableur, de sgcGrid et d'un TsgcCalcEvaluator, exactement comme une fonction intégrée. Le gestionnaire est une simple fonction, enregistrée depuis la section initialization d'une unité.

unit MyFunctions;

interface

implementation

uses
  sgcUICore_Calc;

{ =MARKUP(price, [rate]): the price plus a margin, 20% by default }
function DoMarkup(aCall: TsgcCalcCall): Variant;
var
  vPrice, vRate: Double;
  vError: string;
begin
  vError := aCall.Number(0, vPrice);
  vRate := 0.2;
  if (vError = '') and (aCall.Count > 1) then
    vError := aCall.Number(1, vRate);
  if vError <> '' then
    Result := vError
  else
    Result := vPrice * (1 + vRate);
end;

initialization
  // MARKUP takes 1 or 2 arguments
  sgcCalcRegisterFunction('MARKUP', DoMarkup, 1, 2);

end.

Ajoutez l'unité au projet et vos utilisateurs peuvent saisir =MARKUP(B2). Avec les tableaux dynamiques, le moteur appelle la fonction pour chaque élément d'un argument de type tableau, de sorte que =MARKUP(B2:B4, 0.3) déborde avec un résultat par prix et que =SUM(MARKUP(B2:B4)) fonctionne sans code supplémentaire. Une fonction qui a besoin des cellules d'une plage est enregistrée avec l'indicateur cfRanges et les parcourt avec un itérateur.

Graphiques issus de plages de cellules

Un graphique affiche les valeurs d'une plage de cellules et flotte au-dessus de la feuille, comme un graphique dans Excel. Il est dessiné par sgcCharts, et lorsqu'une cellule de la plage change, ou qu'une formule de la plage donne une nouvelle valeur, le graphique suit. Les utilisateurs déplacent et redimensionnent les graphiques à la souris, et chaque feuille possède ses propres graphiques.

• 7 types de graphiques : colonnes, barres, courbes, aires, secteurs, anneau et nuage de points.
• AddChart avec une plage telle que 'A1:D10' ou 'Sheet1!A1:D10', les noms des séries et les catégories étant lus dans la ligne et la colonne d'en-tête.
• TsgcSpreadsheetCharts contient les graphiques de chaque feuille, et SaveToXLSX les écrit sous forme de graphiques qu'Excel ouvre.

XLSX en entrée, XLSX en sortie

Les clients envoient des fichiers XLSX et attendent des fichiers XLSX en retour. LoadFromXLSX lit toutes les feuilles d'un classeur et SaveToXLSX écrit toutes les feuilles, à partir d'un nom de fichier ou d'un flux, de sorte qu'un fichier fait l'aller-retour entre votre application et Excel.

• Valeurs, formules et formats de cellules.
• Noms définis et tableaux dynamiques.
• Volets figés et largeurs de colonnes.
• Graphiques, enregistrés sous forme de graphiques qu'Excel ouvre.

VCL, FireMonkey et .NET

Delphi et C++ Builder disposent de TsgcVCLSpreadsheet pour VCL et de TsgcFMXSpreadsheet pour FireMonkey, chacun avec sa barre de formule. Pour .NET, il y a TsgcWinFormsSpreadsheet, TsgcWpfSpreadsheet et TsgcAvaloniaSpreadsheet, eux aussi avec des barres de formule, dans les packages NuGet esegece.sgcSpreadsheet, esegece.sgcSpreadsheet.WinForms, esegece.sgcSpreadsheet.Wpf et esegece.sgcSpreadsheet.Avalonia. Les contrôles .NET utilisent les mêmes noms que ceux de Delphi, et une fonction personnalisée peut être une lambda.

using esegece.sgcSpreadsheet;
using esegece.sgcUICore;

// once at startup, before the first formula is parsed
sgcUICore_Calc.sgcCalcRegisterFunction("MARKUP", aCall =>
{
    double vPrice;
    double vRate = 0.2;
    string vError = aCall.Number(0, out vPrice);
    if ((vError.Length == 0) && (aCall.Count > 1))
        vError = aCall.Number(1, out vRate);
    if (vError.Length > 0)
        return vError;
    return vPrice * (1 + vRate);
}, 1, 2);

// sheet is a TsgcWinFormsSpreadsheet: open a workbook made in Excel
sheet.LoadFromXLSX("prices.xlsx");
sheet.ActiveSheet = 0;
// the custom function spills over the whole price column
sheet.SetCellInput(0, 2, "=MARKUP(B2:B4, 0.3)");
// a column chart of the range, drawn by sgcCharts
TsgcSpreadsheetChart chart = sheet.AddChart(TsgcSpreadsheetChartType.sctColumn, "A1:B4");
chart.Title = "Prices";
sheet.SaveToXLSX("prices-markup.xlsx");

Lancez les démos

Les démos Delphi et C++ Builder s'installent avec l'évaluation de sgcUI, et les démos .NET sont fournies avec le téléchargement .NET Registered.

• Basic : un classeur de ventes créé en code avec SUM, AVERAGE, IF et XLOOKUP, une feuille de synthèse qui le lit, une ligne d'en-tête figée, la barre de formule, et Ouvrir et Enregistrer en XLSX.
• Functions : fonctions mathématiques, de texte, de date et d'heure, de recherche et de tableaux dynamiques, une feuille par catégorie, avec chaque formule à côté de son résultat.
• Charts : graphiques en colonnes, en courbes et en secteurs issus de plages de cellules. Modifiez un revenu ou un coût et les graphiques suivent.
• CustomFunction, BasicFMX et ChartsFMX : des fonctions enregistrées par l'application, et les démos Basic et Charts sur FireMonkey. Basic et Charts sont aussi fournies sous forme de projets C++ Builder.
• .NET : SpreadsheetBasic pour WinForms, SpreadsheetBasicWpf, SpreadsheetBasicAvalonia, SpreadsheetFunctions, SpreadsheetCharts et SpreadsheetCustomFunction.

Où sgcSpreadsheet est inclus

sgcSpreadsheet est inclus dans sgcUI Enterprise et dans le pack All-Access, et il est vendu seul sous forme de package unique pour Delphi et C++ Builder ainsi que pour .NET. L'installation de sgcSpreadsheet installe aussi sgcGrid et sgcCharts, de sorte que la grille et les graphiques fonctionnent toujours. Il n'existe pas d'édition Community gratuite. Consultez la page des tarifs pour les détails.

Des questions ou des retours ? Contactez-nous, vous recevrez une réponse de ceux qui ont écrit le code.