sgcSpreadsheet: una hoja de cálculo estilo Excel para Delphi y .NET

Tarde o temprano, toda aplicación empresarial necesita una hoja de cálculo. Los usuarios planifican un presupuesto, valoran una oferta, calculan costes o revisan las cifras que un cliente envió en un archivo de Excel, y esperan fórmulas, varias hojas y gráficos mientras lo hacen. Una simple cuadrícula no basta para nada de eso.

sgcSpreadsheet es un control de hoja de cálculo estilo Excel construido sobre sgcGrid y sobre un motor de fórmulas compartido en sgcUICore. Mantiene un libro real con hojas, nombres definidos y matrices dinámicas, recalcula solo las celdas que afecta un cambio y carga y guarda XLSX. El mismo motor gobierna los controles VCL y FireMonkey para Delphi y C++ Builder y los controles WinForms, WPF y Avalonia para .NET.

sgcSpreadsheet en acción

Fórmulas, matrices con desbordamiento, varias hojas, gráficos en vivo y archivos XLSX en todas las plataformas. También en YouTube.

Fórmulas que tus usuarios ya conocen

Quienes trabajan con números piensan en fórmulas de Excel. En sgcSpreadsheet, un texto que empieza por = es una fórmula, y el motor calcula 211 funciones de hoja de cálculo: matemáticas, estadísticas, de texto, de fecha y hora, de búsqueda, lógicas, de información y de matrices dinámicas. El motor reside en sgcUICore, de modo que las fórmulas de sgcGrid dan los mismos resultados.

Hojas, nombres y matrices con desbordamiento

Una hoja de cálculo es un libro con una o más hojas. Las pestañas bajo la cuadrícula cambian de hoja y la pestaña + añade una, y una hoja renombrada se renombra en todas las fórmulas que la mencionan. Desde el código, AddSheet, ActiveSheet y SheetCount gestionan las hojas, y Grid.Sheets.Names guarda los nombres definidos del libro.

El método siguiente rellena una lista de precios, da nombre a sus rangos y construye una hoja de resumen que la lee. SORT devuelve la lista completa de productos, que se desborda hacia las celdas de debajo, y A1# hace referencia a ese rango desbordado por larga que se haga la lista. XLOOKUP encuentra un precio y el nombre VAT añade el impuesto.

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;

El resumen muestra los tres productos en orden, 3 elementos y 264,99 para el monitor. Cambia un precio en la primera hoja y solo se recalculan las celdas que dependen de él. FreezePanes(1, 0) mantiene fija una fila de encabezado mientras el resto de la hoja se desplaza, y las barras de fórmulas TsgcVCLSpreadsheetFormulaBar y TsgcFMXSpreadsheetFormulaBar ofrecen a tus usuarios un cuadro de nombres y la fórmula de la celda actual.

Tus propias funciones

Las aplicaciones de ingeniería, finanzas y laboratorio necesitan sus propios cálculos. El motor de fórmulas tiene un registro de funciones, y una función registrada allí funciona en todas las fórmulas de la hoja de cálculo, de sgcGrid y de un TsgcCalcEvaluator, exactamente igual que una incorporada. El manejador es una función normal, que se registra desde la sección initialization de una unidad.

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.

Añade la unidad al proyecto y tus usuarios podrán escribir =MARKUP(B2). Con las matrices dinámicas, el motor llama a la función para cada elemento de un argumento de tipo matriz, así que =MARKUP(B2:B4, 0.3) desborda un resultado por precio y =SUM(MARKUP(B2:B4)) funciona sin código adicional. Una función que necesita las celdas de un rango se registra con el indicador cfRanges y las recorre con un iterador.

Gráficos a partir de rangos de celdas

Un gráfico muestra los valores de un rango de celdas y flota sobre la hoja, como un gráfico de Excel. Lo dibuja sgcCharts, y cuando cambia una celda del rango, o una fórmula del rango da un valor nuevo, el gráfico lo sigue. Los usuarios mueven y redimensionan los gráficos con el ratón, y cada hoja tiene sus propios gráficos.

• 7 tipos de gráfico: columnas, barras, líneas, áreas, sectores, anillos y dispersión.
• AddChart con un rango como 'A1:D10' o 'Sheet1!A1:D10', con los nombres de las series y las categorías leídos de la fila y la columna de encabezado.
• TsgcSpreadsheetCharts guarda los gráficos de cada hoja, y SaveToXLSX los escribe como gráficos que Excel abre.

XLSX de entrada, XLSX de salida

Los clientes envían archivos XLSX y esperan recibir archivos XLSX. LoadFromXLSX lee todas las hojas de un libro y SaveToXLSX escribe todas las hojas, desde un nombre de archivo o un flujo, así que un archivo hace el viaje de ida y vuelta entre tu aplicación y Excel.

• Valores, fórmulas y formatos de celda.
• Nombres definidos y matrices dinámicas.
• Paneles inmovilizados y anchos de columna.
• Gráficos, guardados como gráficos que Excel abre.

VCL, FireMonkey y .NET

Delphi y C++ Builder disponen de TsgcVCLSpreadsheet para VCL y TsgcFMXSpreadsheet para FireMonkey, cada uno con su barra de fórmulas. Para .NET existen TsgcWinFormsSpreadsheet, TsgcWpfSpreadsheet y TsgcAvaloniaSpreadsheet, también con barras de fórmulas, en los paquetes NuGet esegece.sgcSpreadsheet, esegece.sgcSpreadsheet.WinForms, esegece.sgcSpreadsheet.Wpf y esegece.sgcSpreadsheet.Avalonia. Los controles .NET usan los mismos nombres que los de Delphi, y una función personalizada puede ser una 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");

Ejecuta las demos

Las demos de Delphi y C++ Builder se instalan con la versión de prueba de sgcUI, y las demos de .NET se incluyen en la descarga .NET Registered.

• Basic: un libro de ventas construido en código con SUM, AVERAGE, IF y XLOOKUP, una hoja de resumen que lo lee, una fila de encabezado inmovilizada, la barra de fórmulas, y Abrir y Guardar como XLSX.
• Functions: funciones matemáticas, de texto, de fecha y hora, de búsqueda y de matrices dinámicas, una hoja por categoría, con cada fórmula junto a su resultado.
• Charts: gráficos de columnas, líneas y sectores a partir de rangos de celdas. Edita un ingreso o un coste y los gráficos lo siguen.
• CustomFunction, BasicFMX y ChartsFMX: funciones registradas por la aplicación, y las demos Basic y Charts en FireMonkey. Basic y Charts también se incluyen como proyectos de C++ Builder.
• .NET: SpreadsheetBasic para WinForms, SpreadsheetBasicWpf, SpreadsheetBasicAvalonia, SpreadsheetFunctions, SpreadsheetCharts y SpreadsheetCustomFunction.

Dónde se incluye sgcSpreadsheet

sgcSpreadsheet se incluye en sgcUI Enterprise y en el paquete All-Access, y se vende por separado como paquete individual para Delphi y C++ Builder y para .NET. Al instalar sgcSpreadsheet se instalan también sgcGrid y sgcCharts, de modo que la cuadrícula y los gráficos funcionan siempre. No existe una edición Community gratuita. Consulta la página de precios para los detalles.

¿Preguntas o comentarios? Ponte en contacto con nosotros, recibirás respuesta de las personas que escribieron el código.