FPSpreadsheet/fr

This is an old revision of FPSpreadsheet/fr, edited by Georges49 at . The current revision is 70240.

La bibliothèque fpSpreadsheet offre un moyen pratique de générer et de lire des feuilles de calcul dans différents formats. La bibliothèque est écrite d'une manière très flexible, capable d'être étendue pour prendre en charge facilement un certain nombre de formats. Capture d'écran du programme de démonstration spready fourni avec fpspreadsheet montrant un fichier XLS :

Documentation

Cette page wiki couvre la dernière version de développement/tronc de FPSpreadsheet disponible via subversion. Merci de consulter Stable releases pour la documentation sur la version stable que vous pouvez télécharger.

API Documentation

API Reference

Un fichier d'aide au format CHM se trouve dans le dossier d'installation de FPSpreadsheet docs. Si vous n'avez pas encore installé le paquet, suivez http://lazarus-ccr.svn.sourceforge.net/viewvc/lazarus-ccr/components/fpspreadsheet/docs/fpspreadsheet-api.chm

Le deuxième fichier CHM disponible dans le dossier "docs", "fpspreadsheet-wiki.chm", est un instantané des pages wiki relatives à FPSpreadsheet regroupées en un seul fichier d'aide.

Basics

Notions de base Les plus petites entités d'une feuille de calcul sont les cellules qui contiennent les données. Les cellules peuvent contenir différents types de données, comme des chaînes de caractères, des chiffres, des dates, des heures, des valeurs booléennes ou des formules. En outre, les cellules peuvent contenir des informations sur la mise en forme, c'est-à-dire le style de police, la couleur de fond, l'alignement du texte, etc... Les cellules sont disposées dans une structure en forme de grille, appelée feuille de travail, ou feuille de calcul, constituée de lignes et de colonnes. Chaque cellule a une adresse unique donnée par l'index de la ligne et de la colonne. Les feuilles de travail sont liées entre elles pour former un classeur qui représente le document du tableur. Le classeur stocke également les informations nécessaires à toutes les feuilles de travail, c'est-à-dire la liste des polices, les listes de formats de cellules et de numéros, etc. FPSpreadsheet suit cette même structure - il y a un TCell, un TsWorksheet, et un TsWorkbook.

Workbook

La classe TsWorkbook (Classeur) est la classe principale visible par l'utilisateur. Il fournit des méthodes pour lire et écrire des données dans des fichiers. La structure polyvalente de la bibliothèque permet d'accéder à divers formats de fichiers populaires, comme Excel .xls ou .xlsx, ou OpenOffice/LibreOffice .ods.

Le format du fichier est spécifié par le type TsSpreadsheetFormat défini dans l'unité fpstypes.

type
  TsSpreadsheetFormat = (sfExcel2, sfExcel5, sfExcel8, sfExcelXML, sfOOXML, 
    sfOpenDocument, sfCSV, sfHTML, sfWikiTable_Pipes, sfWikiTable_WikiMedia, sfUser);

où

Lorsque vous utilisez fpspreadsheet, la première tâche consiste à créer une instance du classeur:

var
  MyWorkbook: TsWorkbook;
begin
  MyWorkbook := TsWorkbook.Create;
  ...

La lecture des fichiers de tableur est accomplie (entre autres) par les méthodes du classeur.

Les méthodes suivantes peuvent être utilisées pour enregistrer le classeur dans un fichier:

Après avoir appelé ces méthodes, il est avantageux de regarder la propriété ErrorMsg dans laquelle sont collectés les messages dus aux erreurs ou aux avertissements qui auraient pu se produire lors de la lecture/écriture. Cette propriété renvoie une chaîne de caractères multi-lignes qui s'affiche au mieux dans un composant mémo; si tout va bien, c'est une chaîne vide.

Note: FPSpreadsheets fournit des unités spécialisées pour la lecture et l'écriture de chaque format de fichier. Ces unités ne sont pas disponibles automatiquement, vous devez les ajouter explicitement à la clause uses. FPSpreadsheet signalera que le format de fichier n'est pas supporté si l'unité de lecture/écriture demandée n'est pas trouvée. Voici une liste des noms des unités:

Worksheet

Worksheet (Feuille de travail)

Le classeur contient une liste d'instances TsWorksheet. Elles correspondent aux onglets que vous voyez dans Excel ou Open/LibreOffice. Lors de la lecture d'un fichier de feuille de calcul, les feuilles de calcul sont créées automatiquement en fonction du contenu du fichier. Lorsqu'une feuille de calcul est créée manuellement pour être stockée dans un fichier, une feuille de travail doit être créée en l'ajoutant au classeur:

var
  MyWorkbook: TsWorkbook;
  MyWorksheet: TsWorksheet;
begin
  MyWorkbook := TsWorkbook.Create;
  MyWorksheet := MyWorkbook.AddWorksheet('My_Table');  
    // 'My_Table' is the "name" of the worksheet
  ...

On peut accéder aux feuilles de calcul déjà existantes en utilisant les TsWorkbookméthodes .

The count of already existing worksheets can be queried by calling GetWorksheetCount.

Cell

Cell (cellule) The worksheet, finally, gives access to the cells. Une feuille de calcul nouvellement créée, comme dans l'exemple ci-dessus, est vide et ne contient aucune cellule. Les cellules sont ajoutées en leur attribuant des données ou des attributs par l'une des WriteXXXX méthodes de la feuille de calcul. Comme déjà mentionné, une cellule est adressée par l'index de la ligne et de la colonne auxquels elle appartient. Comme d'habitude, les index des lignes et des colonnes commencent à 0. Par conséquent, la cellule "A1" appartient à la ligne 0 et à la colonne 0. Il faut noter que l'indice de ligne et de colonne sont toujours spécifiés dans cet ordre, ceci est différent de la convention de TStringGrid. L'exemple suivant crée une cellule à l'adresse A1 et y place le nombre 1,0.

var
  MyWorkbook: TsWorkbook;
  MyWorksheet: TsWorksheet;
begin
  MyWorkbook := TsWorkbook.Create;
  MyWorksheet := MyWorkbook.AddWorksheet('My_Table');
  MyWorksheet.WriteNumber(0, 0, 1.0);  // "A1" a row=0 et col=0
  ...

Il est également possible d'accéder directement aux cellules au moyen des méthodes FindCell(ARow, ACol) ou GetCell(ARow, ACol) du classeur. Ces deux fonctions existent également dans une version surchargée à laquelle l'adresse de la cellule peut être passée en notation Excel: FindCell(ACellStr: String) ou GetCell(ACellStr: String). Sachez que ces fonctions renvoient un pointeur aux données de la cellule (type PCell). N'oubliez pas de déréférencer les pointeurs! La différence entre FindCell et GetCell est que le premier retourne nil, si une cellule n'existe pas encore, alors que le second crée une cellule vide dans ce cas.

if MyWorksheet.FindCell('A1') = nil then
  WriteLn('Cell A1 does not exist.');
Le record TCell de base

Il s'agit de la déclaration du type de données de la cellule:

type
  TCell = record
    { L'emplacement de la cellule }
    Worksheet: TsWorksheet;
    Col: Cardinal; // zero-based
    Row: Cardinal; // zero-based

    { Index of format record }
    FormatIndex: Integer;

    { Drapeaux de l'état }
    Flags: TsCellFlags; // (cfHasComment, cfMerged, cfHyperlink, ...)

    { Contenu de la cellule }
    UTF8StringValue: String; // les chaînes de caractères ne peuvent pas faire partie d'un enregistrement de variant.
    case ContentType: TCellContentType of /// doit être à la fin de la déclaration
      cctEmpty : ();// n'a pas de données du tout
      cctFormula: (); // UTF8StringValue est en dehors the variant record
      cctNumber: (Numbervalue: Double);
      cctUTF8String: (); // FormulaValue est en dehors the variant record
      cctDateTime: (DateTimevalue: TDateTime);
      cctBool: (BoolValue: boolean);
      cctError: (ErrorValue: TsErrorValue);
  end;
  PCell = ^TCell;

Le champ ContentType indique quel type de données est stocké dans la cellule:

type
  TCellContentType = (cctEmpty, cctFormula, cctNumber, cctUTF8String, cctDateTime, cctBool, cctError);

Selon ce champ, les données correspondantes peuvent être trouvées dans les champs

En raison de l'utilisation d'un record variant, la plupart de ces valeurs se chevauchent, c'est-à-dire que la modification de NumberValue affecte également les autres valeurs. Par conséquent, il faut toujours respecter le ContentType lorsqu'on accède directement à l'enregistrement TCell (les méthodes de feuille de calcul discutées ci-dessous en tiennent compte automatiquement).

Le champ Flags indique si des données supplémentaires sont associées à la cellule qui ne sont pas incluses dans l'enregistrement de la cellule généralement pour économiser de la mémoire:

7

<a href="/File:fpsgrid.png view-source:<a class="external free" href="https://wiki.freepascal.org/File:fpsgrid.png">https://wiki.freepascal.org/File:fpsgrid.png</a>" class="image"><img alt="Note-icon.png" src="/images/0/02/fpsgrid.png view-source:<a class="external free" href="https://wiki.freepascal.org/images/0/02/fpsgrid.png">https://wiki.freepascal.org/images/0/02/fpsgrid.png</a>" width="24" height="29" /></a>

Invalid template name "Note\:Après calcul d'une formule ou après lecture d'un fichier, le ContentType de la cellule de formule est converti en celui du résultat. Ensuite, la présence d'une formule ne peut être détectée qu'en appelant la fonction HasFormula(cell) pour la cellule à interroger (cell: PCell) dans l'unité fpsUtils; cette fonction vérifie la présence de l'élément cfHasFormula dans les flags de la cellule.": The title is too long
How to add and read data to/from a cell
Comment ajouter et lire des données dans une cellule

L'ajout de valeurs à une cellule s'effectue le plus facilement en utilisant l'une des WriteXXXX de la feuille de calcul. Les plus importantes sont:

type
  TsWorksheet = class
    
    {Ecriture des valeurs monétaires}
    function WriteCurrency(ARow, ACol: Cardinal; AValue: Double;
      ANumFormat: TsNumberFormat = nfCurrency; ADecimals: Integer = 2;
      ACurrencySymbol: String = '?'; APosCurrFormat: Integer = -1;
      ANegCurrFormat: Integer = -1): PCell; overload;
    procedure WriteCurrency(ACell: PCell; AValue: Double;
      ANumFormat: TsNumberFormat = nfCurrency; ADecimals: Integer = -1;
      ACurrencySymbol: String = '?'; APosCurrFormat: Integer = -1;
      ANegCurrFormat: Integer = -1); overload;
    function WriteCurrency(ARow, ACol: Cardinal; AValue: Double;
      ANumFormat: TsNumberFormat; ANumFormatString: String): PCell; overload;
    procedure WriteCurrency(ACell: PCell; AValue: Double;
      ANumFormat: TsNumberFormat; ANumFormatString: String); overload;

    {Écriture de valeurs de date/heure }
    function WriteDateTime(ARow, ACol: Cardinal; AValue: TDateTime): PCell; overload;
    procedure WriteDateTime(ACell: PCell; AValue: TDateTime); overload;
    function WriteDateTime(ARow, ACol: Cardinal; AValue: TDateTime;
      ANumFormat: TsNumberFormat; ANumFormatStr: String = ''): PCell; overload;
    procedure WriteDateTime(ACell: PCell; AValue: TDateTime;
      ANumFormat: TsNumberFormat; ANumFormatStr: String = ''); overload;
    function WriteDateTime(ARow, ACol: Cardinal; AValue: TDateTime;
      ANumFormatStr: String): PCell; overload;
    procedure WriteDateTime(ACell: PCell; AValue: TDateTime;
      ANumFormatStr: String); overload;

    {Écriture de valeurs numériques}
    function WriteNumber(ARow, ACol: Cardinal; ANumber: double): PCell; overload;
    procedure WriteNumber(ACell: PCell; ANumber: Double); overload;
    function WriteNumber(ARow, ACol: Cardinal; ANumber: double;
      ANumFormat: TsNumberFormat; ADecimals: Byte = 2): PCell; overload;
    procedure WriteNumber(ACell: PCell; ANumber: Double;
      ANumFormat: TsNumberFormat; ADecimals: Byte = 2); overload;
    function WriteNumber(ARow, ACol: Cardinal; ANumber: double;
      ANumFormat: TsNumberFormat; ANumFormatString: String): PCell; overload;
    procedure WriteNumber(ACell: PCell; ANumber: Double;
      ANumFormat: TsNumberFormat; ANumFormatString: String); overload;

    {Écriture de chaîne de caractères }
    function WriteText(ARow, ACol: Cardinal; AText: ansistring;
      ARichTextParams: TsRichTextParams = nil): PCell; overload;
    procedure WriteText(ACell: PCell; AText: String;
      ARichTextparams: TsRichTextParams = nil); overload;

    // les anciennes méthodes de chaîne "WriteUTF8Text" sont désormais obsolètes.

Certaines de ces méthodes existent dans des versions surchargées dans lesquelles les paramètres de formatage de la cellule peuvent être ajoutés avec la valeur de la cellule. De manière correspondante à l'écriture, il existe également un certain nombre de worksheet méthodes de lecture des valeurs des cellules:

type
  TsWorksheet = class
    
    {Lecture du contenu d'une cellule qui contient une valeur string }
    function ReadAsText(ARow, ACol: Cardinal): string; overload;
    function ReadAsText(ACell: PCell): string; overload;
    function ReadAsText(ACell: PCell; AFormatSettings: TFormatSettings): string; overload;

    {Lecture du contenu d'une cellule qui contient une valeur nombre }
    function ReadAsNumber(ARow, ACol: Cardinal): Double; overload;
    function ReadAsNumber(ACell: PCell): Double; overload;
    function ReadNumericValue(ACell: PCell; out AValue: Double): Boolean;

    {Lecture du contenu d'une cellule qui contient une valeur date/heure }
    function ReadAsDateTime(ARow, ACol: Cardinal; out AResult: TDateTime): Boolean; overload;
    function ReadAsDateTime(ACell: PCell; out AResult: TDateTime): Boolean; overload;
Index du format de la cellule

FormatIndex est l'index de l'enregistrement du format de cellule. Il décrit les attributs de mise en forme d'une cellule. Ces enregistrements sont collectés par une liste interne du classeur et sont définis comme suit:

10

Pour spécifier un format pour une cellule donnée, appelez la méthode correspondante de la feuille de calcul WriteXXXX, pour récupérer un format appelez ReadXX. Ces méthodes reçoivent généralement un pointeur sur la cellule comme paramètre, mais il existe également des versions surchargées qui acceptent l'index de la ligne et de la colonne. De plus, les styles de mise en forme peuvent également être appliqués directement à la cellule en utilisant une aide d'enregistrement implémentée dans l'unité fpsCell.

Voir formatage des cellules ci-dessous pour une description plus détaillée.

Colonnes et lignes

Des records de colonnes et de lignes sont ajoutés pour chaque colonne et ligne ayant des propriétés autres que celles par défaut:

type
  TCol = record
    Col: Cardinal;
    Width: Single;
    ColWidthType: TsColWidthType; // = (cwtDefault, cwtCustom)
    FormatIndex: Integer;
    Options: TsColRowOptions; // set of [croHidden, croPageBreak]
  end;
  PCol = ^TCol;

  TRow = record
    Row: Cardinal;
    Height: Single;
    RowHeightType: TsRowHeightType; // = (rhtDefault, rhtCustom, rhtAuto)
    FormatIndex: Integer;
    Options: TsColRowOptions; // set of [croHidden, croPageBreak]
    Hidden: Boolean;
    PageBreak: Boolean;
  end;
  PRow = ^TRow;
Largeur de colonne / hauteur de ligne

La largeur des colonnes et la hauteur des lignes peuvent être spécifiées dans différentes unités définies par leur type TsSizeUnits = (suChars, suLines, suMillimeters, suCentimeters, suPoints, suInches). ursuChars fait référence au nombre de 0 caractères entrant dans la largeur de la colonne - c'est ainsi qu'Excel définit les largeurs de colonne. suLines est le nombre de lignes s'adaptant à la hauteur de la ligne. Les deux unités sont basées sur la taille des caractères de la police par défaut du classeur. Les autres unités sont des unités de longueur physique conventionnelle (1 cm = 10 mm, 1 pouce = 25,4 mm = 72 pts). Les valeurs fractionnaires sont acceptées. Le classeur et les feuilles de calcul stockent les longueurs en interne en millimètres (MonWorkbook.Units).

Les applications Office ajustent généralement les hauteurs de ligne automatiquement en fonction de la police ou de la rotation du texte du contenu de la cellule. Ce cas est identifié par RowHeightType ayant la valeur rhtAuto. Comme la feuille de calcul ne peut pas calculer très précisément la taille du texte, les hauteurs de ligne automatiques ne sont pas écrites par FPSpreadsheet; elles sont remplacées par la hauteur de ligne par défaut. La hauteur de ligne par défaut est également utilisée si une ligne est vide, c'est-à-dire si elle ne contient aucune cellule de données. Sa valeur peut être modifiée en appelant la WriteDefaultRowHeight() ou en utilisant la propriété de la feuille de calcul DefaultRowHeight. Dans WriteDefaultRowHeight, les unités doivent être spécifiées alors que dans DefaultRowHeight, elles sont supposées être des lignes. De même, la largeur de colonne par défaut peut être spécifiée par WriteDefaultColWidth() ou la propriété DefaultColWidth (en caractères).

Pour outrepasser les hauteurs de ligne automatiques et par défaut, appelez la méthode de la feuille de calcul WriteRowHeight(). Ces records de lignes sont identifiés par RowHeightType ayant la valeur rhtCustom. De même, la largeur des colonnes peut être fixée à une valeur spécifique en appelant WriteColWidth(). ColWidthType de ces colonnes est cwtCustom.

La hauteur/largeur d'une ligne/colonne particulière peut être récupérée au moyen des méthodes GetRowHeight ou GetColWidth. Notez que ces méthodes renvoient les hauteurs de ligne/largeurs de colonne par défaut s'il n'y a pas de TRow/TCol records.

type 
  TsWorksheet = class
  
  {Définir la hauteur de la ligne}
  procedure WriteRowHeight(ARowIndex: Cardinal; AHeight: Single; AUnits: TsSizeUnits);
  { Définir la largeur de la colonne }
  procedure WriteColWidth(AColIndex: Cardinal; AWidth: Single; AUnits: TsSizeUnits);
  {Définir la hauteur de ligne par défaut }
  procedure WriteDefaultRowHeight(AHeight: Single; AUnits: TsSizeUnits);
  {Définir la largeur par défaut de la colonne }
  procedure WriteDefaultColWidth(AWidth: Single; AUnits: TsSizeUnits);

  { Retourner la hauteur de la ligne}
  function GetRowHeight(ARowIndex: Cardinal; AUnits: TsSizeUnits): Single;
  { Retourner la largeur de la colonne }
  function GetColWidth(AColIndex: Cardinal; AUnits: TsSizeUnits): Single;
  { Retourner la hauteur de ligne par défaut }
  function ReadDefaultRowHeight(AUnits: TsSizeUnits): Single;
  { Retourner la largeur de colonne par défaut }
  function ReadDefaultColWidth(AUnits: TsSizeUnits): Single;

  property DefaultRowHeight: Single; // en lignes
  property DefaultColWidht: Single; // en caractères

Il existe également des versions surchargées de ces méthodes qui ne nécessitent pas le paramètre AUnits. Dans ce cas, la hauteur des lignes est définie en fonction du nombre de lignes et la largeur des colonnes est définie en fonction du nombre de caractères. Notez que ces variantes sont issues de versions antérieures et sont désormais obsolètes.

Formats des colonnes et des lignes

L'élément FormatIndex de la ligne et de la colonne enregistre le format appliqué à la ligne ou à la colonne entière. Avec les cellules, ces formats sont stockés comme TsCellFormat records dans une liste interne du classeur, FormatIndex est l'index des propriétés du format dans cette liste. Voir les détails dans la section Formatage des cellules. Les formats de ligne et de colonne sont principalement appliqués aux cellules vides, mais si une nouvelle cellule est ajoutée, elle obtiendra automatiquement le format de la ligne ou de la colonne. (Si la ligne et la colonne ont des formats différents, le format de la ligne sera utilisé).

Voici une liste des méthodes de feuille de calcul disponibles pour le formatage des colonnes et des lignes:

<syntaxhighlight lang="pascal"> type

 TsWorksheet = class
 // Attribue un format à une colonne ou à une ligne
 procedure WriteColFormatIndex(ACol: Cardinal; AFormatIndex: Integer);
 procedure WriteRowFormatIndex(ARow: Cardinal; AFormatIndex: Integer);
 // récupère le format d'une colonne ou d'une ligne
 function GetColFormatIndex(ACol: Cardinal): Integer;
 function GetRowFormatIndex(ARow: Cardinal): Integer;
 // Renvoie la police affectée à une colonne ou à une ligne.
 function ReadColFont(ACol: PCol): TsFont;
 function ReadRowFont(ARow: PRow): TsFont;
 // Vérifie si une colonne ou une ligne utilise un format spécial.
 function HasRowFormats: Boolean;
 function HasColFormats: Boolean;
Colonnes / lignes cachées

Ajouter l'indicateur croHidden à l'Options cache la ligne ou la colonne dans l'application Office (ou dans TsWorksheetGrid). Les méthodes de feuille de calcul suivantes sont des aides pour gérer la visibilité des lignes/colonnes:

<span></span>type TsWorksheet = class
  
  { Masquer la colonne/ligne }
  procedure HideCol(ACol: Cardinal);
  procedure HideRow(ARow: Cardinal);

  { Afficher une colonne/ligne précédemment cachée }
  procedure ShowCol(ACol: Cardinal);
  procedure ShowRow(ARow: Cardinal);

  { Vérifier si la colonne/ligne} est cachée }
  function ColHidden(ACol: Cardinal): Boolean;
  function RowHidden(ARow: Cardinal): Boolean;
Sauts de page

L'indicateur croPageBreak peut être ajouté à l'Options de la ligne ou de la colonne afin de forcer un saut de page avant la ligne ou la colonne correspondante lorsque la feuille de calcul est imprimée par les applications Office. Notez que FPSpreadsheet lui-même ne prend pas en charge l'impression. Les méthodes de feuille de calcul suivantes aident à gérer les sauts de page:

<span></span>type TsWorksheet = class
  
  {Forcer un saut de page avant la colonne/ligne spécifiée }
  procedure AddPageBreakToCol(ACol: Cardinal);
  procedure AddPageBreakToRow(ARow: Cardinal);

  {Supprime un saut de page précédemment ajouté à une colonne/ligne }
  procedure RemovePageBreakFromCol(ACol: Cardinal);
  procedure RemovePageBreakFromRow(ARow: Cardinal);

  {Vérifie si un saut de page est forcé avant la colonne/ligne spécifiée }
  function IsPageBreakCol(ACol: Cardinal): Boolean;
  function IsPageBreakRow(ARow: Cardinal): Boolean;

Événements

Les feuilles de calcul et les classeurs déclenchent une série d'événements tels que OnChangeCell, OnChangeFont, etc. Les événements sont généralement destinés à l'interaction avec les commandes visuelles du tableur. Si vous devez joindre vos propres gestionnaires, vous devez vous assurer que le gestionnaire d'origine est appelé, au moins dans un programme gui utilisant les contrôles de feuille de calcul. Ou vous utilisez les événements fournis par les contrôles visuels eux-mêmes, par exemple WorksheetGrid.OnEditingDone au lieu de WorksheetGrid.Worksheet.OnChangeCell.

Formules

Deux types de formules sont pris en charge par FPSpreadsheet:

FPSpreadsheet peut convertir les formules de type chaîne et rpn. Les formules des deux types peuvent être calculées.

Dans les anciennes versions de FPSpreadsheet, les formules étaient stockées directement dans le record de la cellule. On y a renoncé pour avoir des formules analysées disponibles pour un calcul plus rapide. Les formules sont stockées dans l'arbre Formules de la feuille de calcul. Le record de la formule contient l'indice de ligne et de colonne de la cellule à laquelle appartient la formule, la représentation de la chaîne de caractères de la formule, ainsi que l'arbre d'analyse syntaxique pour une évaluation rapide.

FPSpreadsheet prend en charge la majorité des formules fournies par les tableurs courants. Toutefois, lors de la lecture d'un fichier créé par ces applications, il est toujours possible qu'une formule non prise en charge soit contenue. Pour éviter le plantage de fpspreadsheet, la lecture des formules est désactivée par défaut; la cellule affiche uniquement le résultat de la formule écrite par l'application Office. Pour activer la lecture des formules, ajoutez l'élément boReadformulas aux Options du classeur avant d'ouvrir le fichier. Si une erreur se produit dans ce cas, le lecteur capture normalement l'exception, écrit le message d'exception dans le journal des erreurs du classeur et continue la lecture. Si vous voulez que la lecture s'arrête, vous devez ajouter le boAbortReadingOnFormulaError au classeur Options.

Les formules peuvent être liées aux données d'autres feuilles du même classeur ("formules 3d") en appliquant la syntaxe Excel (voir ci-dessous). Les liens externes vers des feuilles de calcul dans d'autres fichiers ne sont pas pris en charge.

Le calcul des formules n'est normalement pas nécessaire lorsqu'un fichier est écrit par FPSpreadsheet pour être ouvert dans une application Office car celle-ci calcule automatiquement les résultats des formules. Cependant, si le même fichier est ouvert par une application basée sur FPSpreadsheet, les cellules calculées seront vides car les formules ne sont pas calculées automatiquement par défaut. Pour activer le calcul des formules avant d'écrire une feuille de calcul dans un fichier, vous devez ajouter l'option boCalcBeforeSaving aux Options.

Si FPSpreadshet est utilisé dans une application interactive (telle que la spready démo trouvée dans le dossierexamples de l'installation de FPSpreadsheet), il est souhaitable de calculer les formules automatiquement chaque fois que les chaînes de formules ou les valeurs des cellules sont modifiées par l'utilisateur. Cela peut être réalisé par l'option boAutoCalc dans les Options du classeur.

Le cadre le plus général concernant les formules est donc le suivant

<span></span>  MyWorkbook.Options:= MyWorkbook.Options + [boReadFormulas, boCalcBeforeSaving, boAutoCalc];

Le calcul des formules peut être déclenché manuellement en appelant la méthode CalcFormulas de la feuille de calcul ou du classeur. Cette dernière est absolument nécessaire lorsque le classeur contient des formules 3D où le résultat d'une cellule peut affecter les cellules d'autres feuilles. S'il n'y a que des formules internes à la feuille de calcul, le CalcFormulas de la feuille de calcul est suffisant.

Formules de chaîne de texte

Les formules de chaînes de caractères sont écrites de la même manière que dans les applications Office. La méthode de feuille de calcul pour créer une formule de chaîne est WriteFormula:

<span></span><span class="k">var</span>
  MyWorksheet: TsWorksheet;
  MyWorksheet.WriteFormula(0, 1, '=ROUND(A1+B2+1.215,0)');
  // Par défaut, utiliser le point comme décimal et la virgule comme séparateur de liste!

Quelques notes sur la syntaxe:

<span></span><span class="k">var</span>
  MyWorksheet: TsWorksheet;
  MyWorksheet.WriteFormula(0, 1, '=ROUND(A1+B2+1.215,0)');
  // En raison du "true", l'analyseur de formule accepte la virgule comme décimale et la
  // le point-virgule comme séparateur de liste si les paramètres de format du classeur sont configurés comme ceci.

Utilisez les méthodes de feuille de calcul ReadFormula ou ReadFormulaAsString pour récupérer la chaîne de caractères de la formule affectée à la cellule. Le pointeur de la cellule doit être donné en paramètre. Cette dernière fonction accepte un paramètre supplémentaire (booléen) ALocalized pour utiliser les séparateurs décimaux et de liste du FormatSettings du classeur pour la création de la chaîne de formule.

<span></span><span class="k">var</span>
  MyWorksheet: TsWorksheet;
  cell: PCell;
  if MyWorksheet.FindCell('A1') = nil then
  WriteLn('Le format interne de la formule est: ', MyworkSheet.ReadFormula(cell));
  // Pour l'exemple précédent, cela donnera la sortie suivante

Formules RPN

Au niveau des applications, les formules de type chaîne de caractères sont principalement utilisées, et les formules RPN ont peu d'importance pratique. Par conséquent, la documentation des formules RPN a été retirée de ce wiki principal de FPSpreadsheet et peut être trouvée dans l'article "Formules RPN dans FPSpreadsheet".

Formules partagées et formules de tableau

Liste des formules intégrées

FPSpreadsheet prend en charge plus de 80 formules intégrées. Afin de ne pas trop gonfler cette page wiki, la documentation de ces formules a été déplacée vers le document séparé "Liste des formules".

Pour en savoir plus sur les fonctions disponibles, consultez le fichier testcases_calcrpnformula.inc dans le dossier tests de l'installation de FPSpreadsheet où chaque fonction est incluse avec au moins un exemple.

Extension de FPSpreadsheet par des formules définies par l'utilisateur

Bien que les formules intégrées couvrent la plupart des applications, il peut être nécessaire d'accéder à une formule disponible dans l'application Office, mais pas dans FPSpreadsheet Pour cette raison, la bibliothèque prend en charge un mécanisme d'enregistrement qui permet d'ajouter des fonctions, définies par l'utilisateur, aux feuilles de calcul. Cela peut être fait en appelant la procédure RegisterFunction depuis l'unité fpsExprParser:

<span></span>procedure RegisterFunction(const AName: ShortString; const AResultType: Char;
  const AParamTypes: String; const AExcelCode: Integer; ACallBack: TsExprFunctionCallBack); overload;
  const AParamTypes: String; const AExcelCode: Integer; ACallBack: TsExprEventCallBack); overload;
<span></span><span class="k">type</span>
  TsExprFunctionCallBack = procedure (var Result: TsExpressionResult; const Args: TsExprParameterArray);
  TsExprFunctionEvent = procedure (var Result: TsExpressionResult; const Args: TsExprParameterArray) of object;

Le TsExpressionResult est un record de variant contenant des données de résultat ou d'argument de plusieurs types:

<span></span><span class="k">type</span>
  TsResultType = (rtEmpty, rtBoolean, rtInteger, rtFloat, rtDateTime, rtString,
    rtCell, rtCellRange, rtError, rtAny);

  TsExpressionResult = record
    Worksheet: TsWorksheet;
    ResString: String;
    case ResultType: TsResultType of
      rtEmpty: ();
      rtError: (ResError: TsErrorValue);
      rtBoolean: (ResBoolean: Boolean);
      rtInteger: (ResInteger: Int64);
      rtFloat: (ResFloat: TsExprFloat);
      rtDateTime: (ResDateTime: TDatetime);
      rtCell: (ResRow, ResCol: Cardinal);
      rtCellRange: (ResCellRange: TsCellRange);
      rtString: ();
  end;

  TsExprParameterArray = array of TsExpressionResult;

À titre d'exemple, nous montrons ici le code de la CONCATENATE() formule qui joint deux ou plusieurs chaînes de caractères:

<span></span>const
  INT_EXCEL_SHEET_FUNC_CONCATENATE = 336;
  procedure fpsCONCATENATE(var Result: TsExpressionResult; const Args: TsExprParameterArray);
  s: String;
  i: Integer;
  s:= '';
  for i:=0 to Length(Args)-1 do
  begin
    if Args[i].ResultType = rtError then
    begin
      Result:= ErrorResult(Args[i].ResError);
      exit;
    end;
    s:= s + ArgToString(Args[i]);
    // "ArgToString" simplifie l'obtention de la chaîne de caractères d'un TsExpressionResult en tant que
    // chaîne de caractères, peut être contenue dans le champ ResString et dans le champ ResCell.
    // Il existe une telle fonction pour chaque type de données de base.
  end;
  Result:= StringResult(s);
  // "StringResult" stocke la chaîne s dans le champ ResString de l'objet
  // TsExpressionResult et définit le ResultType à rtString.
  // Il existe une telle fonction pour chaque type de données de base.

Il existe un exemple travaillé (demo_formula_func.pas) dans le dossier examples/other de l'installation de FPSpreadsheet. Dans cette démo, quatre fonctions financières (FV(), PV(), PMT(), RATE()) sont ajoutées à FPSpreadsheet.

Formules non prises en charge

Il est parfois nécessaire de créer des fichiers pour les applications Office avec des formules non prises en charge par fpspreadsheet. Cela est possible dans une certaine mesure lorsque l'option du classeur boIgnoreFormulas est active. Il est alors possible d'écrire n'importe quelle formule arbitraire dans une cellule, et la formule n'est ni vérifiée ni évaluée. Le classeur peut être écrit dans un fichier .ods ou .xlsx. L'ancien format de fichier xls ne peut être utilisé car la formule devrait être analysée pour créer la formule rpn nécessaire.

Dans le dossier exemples/autres vous trouverez le projet d'exemple demo_ignore_formula qui crée un fichier ods avec des références à un autre fichier de données - les références externes ne sont normalement pas supportées par fpspreadsheet, et donc la solution de contournement ignore-formules doit être utilisée. Notez que cet exemple ne fonctionne pas avec xlsx car Excel écrit les informations sur les liens externes dans des fichiers xml séparés à l'intérieur du conteneur xlsx.

Mise en forme des cellules

Formats de nombres et de dates/heures

Les nombres et les valeurs de date/heure peuvent être affichés dans différents formats. Dans FPSpreadsheet, cela peut être réalisé de deux manières:

Les formats des nombres peuvent être spécifiés par ces méthodes de feuille de calcul:

<span></span><span class="k">type</span>
  TsWorksheet = class
  public
    // Définir seulement les formats des nombres
    function WriteNumberFormat(ARow, ACol: Cardinal; ANumberFormat: TsNumberFormat;
      const AFormatString: String = ''): PCell; overload;
    procedure WriteNumberFormat(ACell: PCell; ANumberFormat: TsNumberFormat;
      const AFormatString: String = ''); overload;

    function WriteNumberFormat(ARow, ACol: Cardinal; ANumFormat: TsNumberFormat;
      ADecimals: Integer; ACurrencySymbol: String = ''; APosCurrFormat: Integer = -1;
      ANegCurrFormat: Integer = -1): PCell; overload;
    procedure WriteNumberFormat(ACell: PCell; ANumFormat: TsNumberFormat;
      ADecimals: Integer; ACurrencySymbol: String = '';
      APosCurrFormat: Integer = -1; ANegCurrFormat: Integer = -1); overload;

    function WriteFractionFormat(ARow, ACol: Cardinal; AMixedFraction: Boolean;
      ANumeratorDigits, ADenominatorDigits: Integer): PCell; overload;
    procedure WriteFractionFormat(ACell: PCell; AMixedFraction: Boolean;
      ANumeratorDigits, ADenominatorDigits: Integer); overload;

    // Définir uniquement les formats de date et d'heure
    function WriteDateTimeFormat(ARow, ACol: Cardinal; ANumberFormat: TsNumberFormat;
      const AFormatString: String = ''): PCell; overload;
    procedure WriteDateTimeFormat(ACell: PCell; ANumberFormat: TsNumberFormat;
      const AFormatString: String = ''); overload;


    // Définissez les valeurs des cellules et les formats des nombres en un seul appel.

    // valeurs numériques
    function WriteNumber(ARow, ACol: Cardinal; ANumber: double;
      AFormat: TsNumberFormat = nfGeneral; ADecimals: Byte = 2;
      ACurrencySymbol: String = ''): PCell; overload;
    procedure WriteNumber(ACell: PCell; ANumber: Double; AFormat: TsNumberFormat = nfGeneral;
      ADecimals: Byte = 2; ACurrencySymbol: String = ''); overload;
    function WriteNumber(ARow, ACol: Cardinal; ANumber: double;
      AFormat: TsNumberFormat; AFormatString: String): PCell; overload;
    procedure WriteNumber(ACell: PCell; ANumber: Double;
      AFormat: TsNumberFormat; AFormatString: String); overload;

    // valeurs de date/heure
    function WriteDateTime(ARow, ACol: Cardinal; AValue: TDateTime;
      AFormat: TsNumberFormat = nfShortDateTime; AFormatStr: String = ''): PCell; overload;
    procedure WriteDateTime(ACell: PCell; AValue: TDateTime;
      AFormat: TsNumberFormat = nfShortDateTime; AFormatStr: String = ''); overload;
    function WriteDateTime(ARow, ACol: Cardinal; AValue: TDateTime;
      AFormatStr: String): PCell; overload;
    procedure WriteDateTime(ACell: PCell; AValue: TDateTime;
      AFormatStr: String); overload;

    // valeurs monétaires
    function WriteCurrency(ARow, ACol: Cardinal; AValue: Double;
      AFormat: TsNumberFormat = nfCurrency; ADecimals: Integer = 2;
      ACurrencySymbol: String = '?'; APosCurrFormat: Integer = -1;
      ANegCurrFormat: Integer = -1): PCell; overload;
    procedure WriteCurrency(ACell: PCell; AValue: Double;
      AFormat: TsNumberFormat = nfCurrency; ADecimals: Integer = -1;
      ACurrencySymbol: String = '?'; APosCurrFormat: Integer = -1;
      ANegCurrFormat: Integer = -1); overload;
    function WriteCurrency(ARow, ACol: Cardinal; AValue: Double;
      AFormat: TsNumberFormat; AFormatString: String): PCell; overload;
    procedure WriteCurrency(ACell: PCell; AValue: Double;
      AFormat: TsNumberFormat; AFormatString: String); overload;
  
Formats numériques intégrés

Les formats intégrés sont définis par l'énumération TsNumberFormat. Malgré son nom, les éléments couvrent à la fois les valeurs numériques et les valeurs de date/heure:

<span></span><span class="k">type</span>
  TsNumberFormat = (
    // polyvalent pour tous les nombres
    nfGeneral,
    // nombres
    nfFixed, nfFixedTh, nfExp, nfPercentage, nfFraction,
    // monnaitaire
    nfCurrency, nfCurrencyRed,
    // dates et heures
    nfShortDateTime, nfShortDate, nfLongDate, nfShortTime, nfLongTime,
    nfShortTimeAM, nfLongTimeAM, nfDayMonth, nfMonthYear, nfTimeInterval,
    // autre (en utilisant la chaîne de caractères du format).
    nfCustom);

Comme déjà noté, le classeur possède une propriété FormatSettings qui fournit des informations supplémentaires pour contrôler le formatage résultant. Il s'agit essentiellement d'une copie de l'élément DefaultFormatSettings déclaré dans l'unité sysutils (les éléments LongDateFormat et ShortDateFormat sont légèrement modifiés pour mieux correspondre aux paramètres par défaut des principales applications de tableur). L'objectif principal du FormatSettings est d'ajouter une manière simple de localisation aux formats de nombres.

Chaînes de format des nombres

En plus de ces formats prédéfinis, un formatage plus spécialisé peut être réalisé en utilisant la constante de format nfCustom ainsi qu'une chaîne de format dédiée. La chaîne de format est construite selon la syntaxe Excel qui est proche de la syntaxe des commandes FormatFloat et FormatDateTime (acceptées également, voir l'aide en ligne de ces fonctions).

Voici une liste de base des symboles utilisés:

<tbody> </tbody>

Symbol Meaning Format string: Number -- Output string
General Affiche toutes les décimales du nombre 'General': 1.2345678 -- '1.2345678'
0 Affiche des zéros non significatifs si un nombre a moins de chiffres qu'il n'y a de zéros dans le format. S'il est utilisé pour les décimales, le nombre est arrondi à autant de décimales que de 0 sont trouvés. '000': 1 -- '001' '0.0': 1 -- '1.0' '0.0': 1.2345678 -- '1.2'
* Comme "0" ci-dessus, mais n'affiche pas les zéros non significatifs. '0.*': 1 -- '1.' '0.*': 1.2345678 -- '1.2'
? Comme "0" ci-dessus, mais les zéros non significatifs sont remplacés par des caractères d'espacement. Bon pour aligner les points décimaux et les fractions '??0': 1 -- ' 1' '0.0??': 1 -- '1.0 '
. Séparateur décimal; sera remplacé par la valeur utilisée dans le DecimalSeparator du FormatSettings du classeur. '0.00': 8.9 -- '8.90'
, Le séparateur de milliers; sera remplacé par la valeur utilisée dans le ThousandSeparator du FormatSettings du classeur. Si à la fin d'une séquence de formatage de nombres, la valeur affichée est divisée par 1000. '#,##0.00': 1200 -- '1,200.00' '0.00,': 1200 -- '1.20'
E+, e+ Affiche un nombre au format exponentiel. Les chiffres utilisés pour l'exposant sont définis par le nombre de zéros ajoutés à ce symbole. Le signe de l'exposant est indiqué pour les exposants positifs et négatifs. '0.00E+00': 1200 -- 1.20E+03
E+, e+ Affiche un nombre au format exponentiel. Les chiffres utilisés pour l'exposant sont définis par le nombre de zéros ajoutés à ce symbole. Le signe de l'exposant n'est indiqué que pour les exposants négatifs. '0.00e-000': 1200 -- 1.20e003
% Affiche le nombre sous forme de "pourcentage", c'est-à-dire que le nombre est multiplié par 100 et un signe% est ajouté. '0.0%': 0.75 -- 75.0%
/ Ce symbole a deux significations: si la cellule représente un "nombre", la barre oblique indique le formatage en tant que fraction, les caractères de remplacement pour le numérateur et le dénominateur doivent suivre. Si la cellule représente une "date/heure" alors la barre oblique indique le séparateur de date qui sera remplacé par le DateSeparator du FormatSettings du classeur. '#/#': 1.5 -- '3/2' '# #/#': 1.5 -- '1 1/2' '# #/16': 1.5 -- '1 8/16' également: voir les exemples de date/heure ci-dessous
: Séparateur entre les heures, les minutes et les secondes d'une valeur de date/heure. Sera remplacé par le TimeSeparator du FormatSettings du classeur. voir les exemples ci-dessous
yyyy Emplacement pour l'année d'une valeur de date/heure. L'année est affichée sous la forme d'un nombre à quatre chiffres. 'yyyy/mm/dd': Jan 3, 2012 -- '2012-01-03'Dans cet exemple, le DateSeparator est un caractère tiret (-).
yy Emplacement pour l'année d'une valeur de date/heure. L'année est affichée sous la forme d'un nombre à deux chiffres. 'yy/mm/dd': Jan 3, 2012 -- '2012-01-03'
m Emplacement pour le mois d'une valeur de date/heure. Le mois est affiché comme un nombre sans chiffres supplémentaires. Veuillez noter que le code m peut également être interprété comme les "minutes" d'une valeur temporelle (voir ci-dessous). 'yyyy/m/dd': Jan 3, 2012 -- '2012-01-03'
mm Emplacement pour le mois d'une valeur de date/heure. Le mois est indiqué sous la forme d'un nombre à deux chiffres, c'est-à-dire qu'un zéro initial est ajouté pour les mois de janvier à septembre. Veuillez noter que le code mm peut également être interprété comme les "minutes" d'une valeur temporelle (voir ci-dessous). 'yyyy/mm/dd': Jan 3, 2012 -- '2012-01-03'
mmm Emplacement pour le mois d'une valeur de date/heure. Le mois est affiché par son nom abrégé. 'yyyy/mmm/dd': Jan 3, 2012 -- '2012-Jan-03'
mmmm Emplacement pour le mois d'une valeur de date/heure. Le mois est affiché par son nom complet. 'yyyy/mmm/dd': Jan 3, 2012 -- '2012-January-03'
d Emplacement pour le jour d'une valeur de date/heure à afficher sous forme de nombre. Le jour est affiché sous la forme d'un simple chiffre, sans ajout d'un zéro initial. 'yyyy/mm/d': Jan 3, 2012 -- '2012-01-03'
dd Emplacement pour le jour d'une valeur de date/heure à afficher sous forme de nombre. dd ajoute un zéro de tête aux numéros de jour à un chiffre. 'yyyy/mm/dd': Jan 3, 2012 -- '2012-01-03'
ddd Support pour le jour d'une valeur de date/heure. Le jour est affiché sous son nom abrégé. 'dddd, yyyy/mm/ddd': Jan 03, 2012 -- 'Tue 2012-01-03'
dddd Support pour le jour d'une valeur de date/heure. Le jour est affiché sous son nom complet. 'dddd, yyyy/mmmm/dd': Jan 03, 2012 -- 'Tuesday 2012-01-03'
h Support de la partie horaire d'une valeur de date/heure. L'heure est affichée sous la forme d'un simple chiffre, sans ajout d'un zéro initial. 'h:mm': 0.25 -- '6:00'
hh Support de la partie horaire d'une valeur de date/heure. L'heure est affichée avec un zéro en tête si l'heure est inférieure à 10. 'hh:mm': 0.25 -- '06:00'
[hh], ou [h] Affiche le temps écoulé de manière à ce que la partie des heures puisse devenir supérieure à 23. '[h]:mm': 1.25 -- '30:00'
m Support de la partie minutes d'une valeur de date/heure. Les minutes sont indiquées sous la forme d'un nombre simple sans ajout d'un zéro initial. Notez que si les codes m sont entourés de symboles de date (y, d), ils sont interprétés comme "mois". 'h:m': 0.25 -- '6:0'
mm Support de la partie minutes d'une valeur de date/heure. Les minutes à un chiffre sont affichées avec un zéro en tête. Notez que si le code mm est entouré de symboles de date (y, d), il est interprété comme "mois". 'h:mm': 0.25 -- '6:00'
[mm], ou [m] Affiche le temps écoulé de telle sorte que la partie minutes peut devenir supérieure à 59 '[mm]:ss': 1.25 -- '1800:00'
s Support de la partie secondes d'une valeur de date/heure. Les secondes sont affichées sous la forme d'un simple nombre, sans ajout de zéro. 'hh:mm:s': 0.25 -- '06:00:0'
ss Support de la partie secondes d'une valeur de date/heure. Les secondes à un chiffre sont affichées avec un zéro en tête. 'hh:mm:ss': 0.25 -- '06:00:00'
[ss], ou [s] Affiche le temps écoulé de telle sorte que la partie secondes peut devenir supérieure à 59 '[ss]': 1.25 -- '108000'
AM/PM, am/pm, A/P, ou a/p Affiche l'heure au format 12 heures. 'hh:mm:ss AM/PM': 0.25 -- '6:00:00 AM'
" Le texte entre guillemets est inséré dans les chaînes formatées de manière littérale. 'yyyy"/"mm"/"dd': 3 janvier 2012 -- '2012/01/03' (c'est-à-dire que le / n'est pas remplacé par le DateSeparator du classeur).
\ Le caractère suivant de la chaîne de format apparaît littéralement dans la chaîne de résultat. Le lui-même n'apparaît pas. 'yyyy/mm/dd': Jan 3, 2012 -- '2012-01-03'
; Une chaîne de caractères de format peut contenir jusqu'à trois sections séparées par un point-virgule. La première section est utilisée pour les nombres positifs, la deuxième section pour les nombres négatifs, et la troisième section pour les nombres zéro. Si la troisième section est manquante, une valeur nulle est formatée comme indiqué dans la première section. Si la deuxième section est également manquante, toutes les valeurs sont formatées selon la première section. '"#,##0"$"';-#,##0"$";"-"': 1200 -- '1,200$' -1200 -- '1,200$' 0 -- '-'
(, et ) Parfois utilisé pour les valeurs monétaires afin d'indiquer les nombres négatifs, au lieu du signe moins. '#,##0"$";(#,##0)"$"': -1200 -- '(1200)$'
[red] La chaîne de caractères formatée est affichée dans la couleur spécifiée. Au lieu de [red],vous pouvez utiliser en conséquence [black], [white], [green], [blue], [magenta], [yellow], or [cyan]. Souvent utilisé pour mettre en évidence des valeurs monétaires négatives. '"$" #,##0.00;[red]("$" #,##0.00)': -1200 -- '($ 1200.00)'
Une note sur les dates Excel

Il existe une divergence entre la présentation des dates dans FPSpreadsheet et dans Excel: Excel suppose à tort que l'année 1900 était une année bissextile et autorise donc la date du 29 février 1900. FPSpreadsheet fait le calcul de la date correctement. En conséquence, les dates antérieures au 1er mars 1900 sont décalées d'une unité! Par ailleurs, FPSpreadsheet traite ce problème de la même manière que LibreOffice Calc.

Couleurs

FPSpreadsheet prend en charge les couleurs pour le texte, l'arrière-plan des cellules et les bordures des cellules. Les couleurs de base de l'EGA sont déclarées dans l'unité fpstypes comme des constantes:

<a href="/File:fpsgrid.png view-source:<a class="external free" href="https://wiki.freepascal.org/File:fpsgrid.png">https://wiki.freepascal.org/File:fpsgrid.png</a>" class="image" title="Couleurs prédéfinies"><img alt="Couleurs prédéfinies" src="/images/0/02/fpsgrid.png view-source:<a class="external free" href="https://wiki.freepascal.org/images/0/02/fpsgrid.png">https://wiki.freepascal.org/images/0/02/fpsgrid.png</a>" width="137" height="339" /></a>

<span></span><span class="k">type</span>
  TsColor = DWORD;
  scBlack = $00000000;
  scWhite = $00FFFFFF;
  scRed = $000000FF;
  scGreen = $0000FF00;
  scBlue = $00FF0000;
  scYellow = $0000FFFF;
  scMagenta = $00FF00FF;
  scCyan = $00FFFF00;
  scDarkRed = $00000080;
  scDarkGreen = $00008000;
  scDarkBlue = $00800000;
  scOlive = $00008080;
  scPurple = $00800080;
  scTeal = $00808000;
  scSilver = $00C0C0C0;
  scGray = $00808080;
  scGrey = scGray; // redefine to allow different spelling

  // Identifiant pour une couleur non définie
  scNotDefined = $40000000;

  // Identificateur de la couleur transparente
  scTransparent = $20000000;

Le TsColor représente la valeur rgb d'une couleur, un seul octet étant utilisé pour les composantes rouge, verte et bleu. Le nombre résultant est en notation little endian, c'est-à-dire que la valeur rouge vient en premier en mémoire: $00BBGGRR. (Ceci est directement compatible avec les valeurs de couleur telles que définies dans l'unité graphique).

L'octet de poids fort est généralement égal à zéro, mais il est utilisé en interne pour identifier des valeurs de couleur spéciales, comme pour les couleurs indéfinies ou transparentes.

<a href="/File:fpsgrid.png view-source:<a class="external free" href="https://wiki.freepascal.org/File:fpsgrid.png">https://wiki.freepascal.org/File:fpsgrid.png</a>" class="image"><img alt="Note-icon.png" src="/images/0/02/fpsgrid.png view-source:<a class="external free" href="https://wiki.freepascal.org/images/0/02/fpsgrid.png">https://wiki.freepascal.org/images/0/02/fpsgrid.png</a>" width="24" height="29" /></a>

Note: Dans les anciennes versions de la bibliothèque, les couleurs étaient définies comme des index dans une palette de couleurs. Ceci ne fonctionne plus.

L'unité fpsutils contient quelques fonctions utiles pour la modification des couleurs:

Arrière-plan de la cellule

L'arrière-plan des cellules peut être rempli par des motifs prédéfinis qui sont identifiés par l'enregistrement TsFillPattern:

<span></span><span class="k">type</span>
  TsFillPattern = record
    Style: TsFillStyle; /// modèle de style de remplissage tel que défini ci-dessous.
    FgColor: TsColor; /// couleur d'arrière-plan du motif de remplissage.
    BgColor: TsColor; /// couleur du motif de remplissage.
  end;

  TsFillStyle = (fsNoFill, fsSolidFill, fsGray75, fsGray50, fsGray25, fsGray12, fsGray6,
    fsStripeHor, fsStripeVert, fsStripeDiagUp, fsStripeDiagDown,
    fsThinStripeHor, fsThinStripeVert, fsThinStripeDiagUp, fsThinStripeDiagDown,
    fsHatchDiag, fsThinHatchDiag, fsThickHatchDiag, fsThinHatchHor);
<span></span><span class="k">type</span>
  TsWorksheet = class
  public
    function WriteBackground(ARow, ACol: Cardinal; AStyle: TsFillStyle; APatternColor, ABackgroundColor: TsColor): PCell; overload;
    procedure WriteBackground(ACell: PCell; AStyle: TsFillStyle; APatternColor, ABackgroundColor: TsColor); overload;

    function WriteBackgroundColor(ARow, ACol: Cardinal; AColor: TsColor): PCell; overload;
    procedure WriteBackgroundColor(ACell: PCell; AColor: TsColor); overload;

    function ReadBackground(ACell: PCell): TsFillPattern;
    function ReadBackgroundColor(ACell: PCell): TsColor; overload;
    <span class="c1">// ...</span>
  end;
  cell: PCell;
  // Exemple 1: Attribue un motif de fines rayures horizontales jaunes sur l'arrière-plan bleu de la cellule vide A1 (ligne 0, colonne 0).
  MyWorksheet.WriteBackground(0, 0, fsThinStripeHor, scYellow, scBlue);

  // Exemple 2: Couleur d'arrière-plan gris uniforme de la cellule B1 (ligne 0, colonne 1) contenant le nombre 3,14.
  if MyWorksheet.FindCell('A1') = nil then
  MyWorksheet.WriteBackgroundColor(cell, clSilver);

Bordures des cellules

Les cellules peuvent être mises en valeur en dessinant des lignes de bordure le long de leurs bords ou des lignes diagonales. Il existe quatre bordures plus deux diagonales énumérées dans le type de données TsCellBorder:

<span></span><span class="k">type</span>
  TsCellBorder = (cbNorth, cbWest, cbEast, cbSouth, cbDiagUp, cbDiagDown);
  TsCellBorders = set of TsCellBorder;

Pour afficher une ligne de bordure, ajoutez la bordure correspondante à l'ensemble Borders de la cellule (type TsCellBorders, voir ci-dessus). De cette façon, chaque bord de cellule peut être traité séparément. Utilisez la méthode de la feuille de calcul WriteBorders à cet effet. Cet exemple ajoute des bordures supérieure et inférieure aux bords A1 et B1:

<span></span>  MyWorksheet.WriteBorders(0, 0, [cbNorth, cbSouth]); /// A1: ligne 0, colonne 0
  MyWorksheet.WriteBorders(0, 0, [cbNorth, cbSouth]); /// A1: ligne 0, colonne 0

Les lignes sont généralement dessinées comme des lignes fines, solides et noires. Mais il est possible de modifier le style de ligne et la couleur de chaque ligne. À cette fin, la cellule fournit un tableau de records TsCellBorderStyle:

<span></span><span class="k">type</span>
  TsLineStyle = (lsThin, lsMedium, lsDashed, lsDotted, lsThick, lsDouble, lsHair,
    lsMediumDash, lsDashDot, lsMediumDashDot, lsDashDotDot, lsMediumDashDotDot, lsSlantDashDot);

  TsCellBorderStyle = record
    LineStyle: TsLineStyle;
    Color: TsColor;
  end;

  TsCellBorderStyles = array[TsCellBorder] of TsCellBorderStyle;

  TsWorksheet = class
  public
    function WriteBorderStyle(ARow, ACol: Cardinal; ABorder: TsCellBorder; AStyle: TsCellBorderStyle): PCell; overload;
    procedure WriteBorderStyle(ACell: PCell; ABorder: TsCellBorder; AStyle: TsCellBorderStyle); overload;

    function WriteBorderStyle(ARow, ACol: Cardinal; ABorder: TsCellBorder; ALineStyle: TsLineStyle; AColor: TsColor): PCell; overload;
    procedure WriteBorderStyle(ACell: PCell; ABorder: TsCellBorder; ALineStyle: TsLineStyle; AColor: TsColor); overload;

    function WriteBorderColor(ARow, ACol: Cardinal; ABorder: TsCellBorder; AColor: TsColor): PCell; overload;
    procedure WriteBorderColor(ACell: PCell; ABorder: TsCellBorder; AColor: TsColor): PCell; overload;

    function WriteBorderLineStyle(ARow, ACol: Cardinal; ABorder: TsCellBorder; ALineStyle: TsLineStyle): PCell; overload;
    procedure WriteBorderLineStyle(ACell: PCell; ABorder: TsCellBorder; ALineStyle: TsLineStyle): PCell; overload;

    function WriteBorderStyles(ARow, ACol: Cardinal; const AStyles: TsCellBorderStyles): PCell; overload;
    procedure WriteBorderStyles(ACell: PCell; const AStyles: TsCellBorderStyles); overload;

    function WriteBorders(ARow, ACol: Cardinal; ABorders: TsCellBorders): PCell; overload
    procedure WriteBorders(ACell: PCell; ABorders: TsCellBorders); overload

    function ReadCellBorders(ACell: PCell): TsCellBorders;
    function ReadCellBorderStyle(ACell: PCell; ABorder: TsCellBorder): TsCellBorderStyle;
    function ReadCellBorderStyles(ACell: PCell): TsCellBorderStyles;
    
  end;

Le style de la bordure d'une cellule donnée peut être spécifié par les méthodes suivantes fournies par la feuille de calcul:

Cet exemple ajoute une fine bordure noire en haut et une épaisse bordure bleue en bas des cellules A1 et B1:

<span></span><span class="k">var</span>
  cellA1, cellB1: PCell;
  MyWorksheet.WriteBorders(0, 0, [cbNorth, cbSouth]); /// A1: ligne 0, colonne 0
  MyWorksheet.WriteBorderStyle(cellA1, cbNorth, lsThin, scBlack);
  MyWorksheet.WriteBorderStyle(cellA1, cbSouth, lsThick, scBlue);

  MyWorksheet.WriteBorders(0, 0, [cbNorth, cbSouth]); /// A1: ligne 0, colonne 0
  MyWorksheet.WriteBorderStyles(cellB1, cellA1^.BorderStyles); // copier tous les styles de bordure de la cellule A1 à B1

<a href="/File:fpsgrid.png view-source:<a class="external free" href="https://wiki.freepascal.org/File:fpsgrid.png">https://wiki.freepascal.org/File:fpsgrid.png</a>" class="image"><img alt="Note-icon.png" src="/images/0/02/fpsgrid.png view-source:<a class="external free" href="https://wiki.freepascal.org/images/0/02/fpsgrid.png">https://wiki.freepascal.org/images/0/02/fpsgrid.png</a>" width="24" height="29" /></a>

Note: Les lignes diagonales ne sont pas supportées par sfExcel2 et sfExcel5 - elles sont simplement omises. sfExcel8 et sfOOXML utilisent le même style de ligne et la même couleur pour les deux diagonales; lors de l'écriture, le style de bordure de la ligne en diagonale haute est supposé être également valable pour la ligne en diagonale basse. Certains auteurs ne prennent pas en charge tous les styles de ligne de l'énumération TsLineStyle. Dans ce cas, les styles de ligne de remplacement appropriés sont utilisés.

Polices de caractères

Le texte de la cellule peut s'afficher dans différentes polices. À cette fin, le classeur fournit une liste d'éléments TsFont:

<span></span><span class="k">type</span>
  TsFont = class
    FontName: String;
    Size: Single;
    Style: TsFontStyles;
    Color: TsColor;
    Position: TsFontPosition;
  end;

Chaque cellule est dotée d'un index dans la liste des polices.

Pour attribuer une police particulière à une cellule, utilisez l'une des méthodes suivantes de TsSpreadsheet:

<span></span><span class="k">type</span>
  TsSpreadsheet = class
  public
    function WriteFont(ARow, ACol: Cardinal; const AFontName: String;
      AFontSize: Single; AFontStyle: TsFontStyles; AFontColor: TsColor): Integer; overload;
    procedure WriteFont(ARow, ACol: Cardinal; AFontIndex: Integer); overload;
    function WriteFontColor(ARow, ACol: Cardinal; AFontColor: TsColor): Integer;
    function WriteFontSize(ARow, ACol: Cardinal; ASize: Integer): Integer;
    function WriteFontStyle(ARow, ACol: Cardinal; AStyle: TsFontStyles): Integer;
    // plus: versions surchargées acceptant un pointeur vers un enregistrement de cellule au lieu de l'index de ligne et de colonne comme paramètre.
    <span class="c1">// ...</span>
  end;

La liste des polices du classeur contient au moins un élément qui est la police par défaut pour les cellules dont les polices ne sont pas modifiées. Par défaut, il s'agit de la police "Arial" de 10 points. Utilisez la méthode du classeur SetDefaultFont pour affecter une police différente au premier élément de la liste.

La police à un indice donné de la liste des polices peut être recherchée en appelant la fonction du classeur GetFont. Le compte des polices disponibles est renvoyé par GetFontCount.

Voici un exemple qui diminue la taille de toutes les polices "Arial" de 10 points à 9 points:

<span></span><span class="k">var</span>
  i: Integer;
  font: TsFont;
  for i:= 0 to MyWorkbook.GetFontCount-1 do
  begin
    font:= MyWorkbook.GetFont(i);
    if (font.FontName = 'Arial') and (font.Size = 10.0) then
      font: TsFont;
  end;

Mise en forme de texte enrichi

Outre l'utilisation d'une police spécifique pour chaque cellule, il est également possible de spécifier des attributs de police particuliers pour des caractères individuels ou des groupes de caractères dans le texte de chaque cellule. Suivant la notation Excel, nous appelons cette fonction Formatage en Rich-text (bien qu'elle n'ait rien à voir avec le format de fichier "Rich-text").

For this purpose, unit fpstypes declares the type TsRichTextParams which is an array of TsRichTextParam records:

<span></span><span class="k">type</span>
  TsRichTextParam = record
    FontIndex: Integer;
    FirstIndex: Integer;
  end;

  TsRichTextParams = array of TsRichTextParam;

FontIndex fait référence à l'index de la police dans la FontList du classeur à utiliser pour le formatage des caractères commençant à l'index FirstIndex. Étant un indice de caractères de chaîne, le FirstIndex est basé sur 1.

Il existe deux façons d'ajouter un formatage "Rich-text" au texte d'une cellule:

<span></span>  MyWorksheet.WriteTextAsHTML(0, 0, 'Area (m<sup>2</sup>');
<span></span><span class="k">var</span>
  richTextParams: TsRichTextParams;
  fnt: TsFont;
  cell: PCell;
  SetLength(rtp, 2);
  if MyWorksheet.FindCell('A1') = nil then
  fnt:= MyWorksheet.ReadCellFont(cell);
  richTextParams[0].FirstIndex:= 8; // Les groupes en exposant commencent par "2", qui est le caractère n° 8 (basé sur 1) du texte de la cellule.
  <span class="n">richTextParams</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="o">.</span><span class="n">FontIndex</span> <span class="o">:=</span> <span class="n">MyWorkbook</span><span class="o">.</span><span class="n">AddFont</span><span class="p">(</span><span class="n">fnt</span><span class="o">.</span><span class="n">FontName</span><span class="o">,</span> <span class="n">fnt</span><span class="o">.</span><span class="n">Size</span><span class="o">,</span> <span class="n">fnt</span><span class="o">.</span><span class="n">Style</span><span class="o">,</span> <span class="n">fnt</span><span class="o">.</span><span class="n">Color</span><span class="o">,</span> <span class="n">fpSuperscript</span><span class="p">)</span><span class="o">;</span>
  richTextParams[1].FirstIndex:= 9; // La police normale recommence à partir du caractère n° 9.
  richTextParams[1].FontIndex:= MyWorksheet.ReadCellFontIndex(0, 0);
  MyWorksheet.WriteUTF8Text(cell, 'Area (m2)', richTextParams);

Utilisez la méthode de feuille de calcul DeleteRichTextParams pour supprimer le formatage du Rich-text d'une cellule précédemment formatée.

<a href="/File:fpsgrid.png view-source:<a class="external free" href="https://wiki.freepascal.org/File:fpsgrid.png">https://wiki.freepascal.org/File:fpsgrid.png</a>" class="image"><img alt="Note-icon.png" src="/images/0/02/fpsgrid.png view-source:<a class="external free" href="https://wiki.freepascal.org/images/0/02/fpsgrid.png">https://wiki.freepascal.org/images/0/02/fpsgrid.png</a>" width="24" height="29" /></a>

Note: Si la cellule est censée avoir une police différente de la police par défaut de la feuille de calcul, alors cette police doit être écrite dans la cellule avant d'écrire le texte formaté en Rich-text. Sinon, la police dans les régions non formatées ne sera pas à jour.

Rotation de texte

En général, le texte s'affiche horizontalement dans les cellules. Toutefois, il est également possible de le faire pivoter de 90 degrés dans le sens des aiguilles d'une montre ou dans le sens inverse. En outre, il est également possible d'empiler des caractères horizontaux verticalement les uns au-dessus des autres.

Si vous avez besoin de cette fonctionnalité, utilisez la méthode de feuille de calcul WriteTextRotation et spécifiez la direction du texte par un élément du type énumération TsTextRotation:

<span></span><span class="k">type</span>
  TsTextRotation = (trHorizontal, rt90DegreeClockwiseRotation,
    rt90DegreeCounterClockwiseRotation, rtStacked);

  TsWorksheet = class
  public
    function WriteTextRotation(ARow, ACol: Cardinal; ARotation: TsTextRotation): PCell; overload;
    procedure WriteTextRotation(ACell: PCell; ARotation: TsTextRotation); overload;

    function ReadTextRotation(ACell: PCell): TsTextRotation;
    <span class="c1">// ...</span>
  end;

  // exemple de texte tourné dans le sens inverse des aiguilles d'une montre dans la cellule A1:
  WriteTextRotation(0, 0, rt90DegreeCounterClockwiseRotation);

<a href="/File:fpsgrid.png view-source:<a class="external free" href="https://wiki.freepascal.org/File:fpsgrid.png">https://wiki.freepascal.org/File:fpsgrid.png</a>" class="image"><img alt="Warning-icon.png" src="/images/0/02/fpsgrid.png view-source:<a class="external free" href="https://wiki.freepascal.org/images/0/02/fpsgrid.png">https://wiki.freepascal.org/images/0/02/fpsgrid.png</a>" width="24" height="24" /></a>

Avertissement: Les degrés de rotation plus fins qui peuvent être pris en charge par certains formats de fichiers de tableur sont ignorés.

Alignement du texte

Par défaut, les textes des cellules sont alignés sur les bords gauche et inférieur de la cellule, sauf pour les nombres qui sont alignés à droite. Ce comportement peut être modifié en utilisant les méthodes de feuille de calcul WriteHorAlignment et WriteVertAlignment:

<span></span><span class="k">type</span>
  TsHorAlignment = (haDefault, haLeft, haCenter, haRight);
  TsVertAlignment = (vaDefault, vaTop, vaCenter, vaBottom);

  TsWorkbook = class
  public
    function WriteHorAlignment(ARow, ACol: Cardinal; AValue: TsHorAlignment): PCell; overload;
    procedure WriteHorAlignment(ACell: PCell; AValue: TsHorAlignment); overload;
    function ReadHorAlignment(ACell: PCell): TsHorAlignment;

    function WriteVertAlignment(ARow, ACol: Cardinal; AValue: TsVertAlignment): PCell; overload;
    procedure WriteVertAlignment(ACell: PCell; AValue: TsVertAlignment); overload;
    function ReadVertAlignment(ACell: PCell): TsVertAlignment;
    <span class="c1">// ...</span>
  end;

  // Exemple: Centrer le texte de la cellule A1 à la fois horizontalement et verticalement.
  MyWorkbook.WriteHorAlignment(0, 0, haCenter);
  MyWorkbook.WriteHorAlignment(0, 0, haCenter);

Retour à la ligne

Le texte qui est plus long que la largeur d'une cellule peut s'étendre sur plusieurs lignes en appelant la méthode WriteWordwrap du tableur:

<span></span><span class="k">type</span>
  TsWorksheet = class
  public
    function WriteWordwrap(ARow, ACol: Cardinal; AValue: Boolean): PCell; overload;
    procedure WriteWordwrap(ACell: PCell; AValue: Boolean); overload;
    function ReadWordwrap(ACell: PCell): Boolean;
    <span class="c1">//...</span>
  end;

  // Exemple: activer le retour à la ligne dans la cellule A1
  MyWorksheet.WriteFormula(0, 1, '=ROUND(A1+B2+1.215,0)');

Fusion de cellules

Comme les applications Office, FPSpreadsheet prend également en charge la fonction de fusion des cellules en une seule grande cellule qui est souvent utilisée comme en-tête commun au-dessus de colonnes simlaires. Il suffit d'appeler MergeCells et de passer un paramètre pour spécifier la plage de cellules à fusionner, soit une chaîne de plage Excel (comme A1:D5), soit les première et dernière lignes et colonnes:

<span></span>  MyWorksheet: TsWorksheet;
  // ou: MyWorksheet.MergeCells(0, 0, 4, 3); /// première ligne, première colonne, dernière ligne, dernière colonne

Le contenu et le format affichés pour une plage fusionnée sont pris dans le coin supérieur gauche de la plage, cellule A1 dans l'exemple ci-dessus. Cette cellule est appelée la MergeBase dans la bibliothèque. À l'exception de cette cellule d'angle, il ne doit pas y avoir d'autres cellules dans la plage. S'il y en a, leur contenu et leur format seront cachés.

Pour décomposer à nouveau une plage fusionnée en cellules individuelles, utilisez la commande Unmerge et passez toute cellule qui se trouve dans la plage fusionnée:

<span></span>  MyWorksheet: TsWorksheet;
  // ou: MyWorksheet.UnmergeCells(0, 1); /// ligne, colonne de n'importe quelle cellule de la plage.

Les cellules fusionnées peuvent être lues/écrites dans tous les formats de fichiers, à l'exception de sfCSV, sfExcel2 et sfExcel5 qui ne supportent pas cette fonctionnalité de manière native.

L'information selon laquelle les cellules sont fusionnées est stockée dans une liste interne. Contrairement aux versions précédentes, il n'est plus possible d'accéder directement à la MergeBase depuis la cellule. Utilisez les fonctions suivantes pour extraire des informations sur les cellules fusionnées:

<span></span><span class="k">var</span>
  cell, base: PCell;
  r1,c1,r2,c2: Cardinal;
  if MyWorksheet.FindCell('A1') = nil then
  fnt:= MyWorksheet.ReadCellFont(cell);
  begin
    WriteLn('Cell B1 is merged.');

    fnt:= MyWorksheet.ReadCellFont(cell);
    WriteLn('The merged range is ' + GetCellRangeString(r1, c1, r2, c2));

    fnt:= MyWorksheet.ReadCellFont(cell);
    WriteLn('The merge base is cell ' + GetCellString(base^.Row, base^.Col));
  end;

Protection des cellules

Ceci est décrit dans une section distincte ci-dessous.

Données supplémentaires

Commentaires des cellules

Les commentaires peuvent être attachés à n'importe quelle cellule en appelant

<span></span>  MyWorksheet.WriteComment(0, 0, 'This is a comment for cell A1');

Ils sont stockés dans une liste interne de la feuille de calcul. Utilisez les méthodes des feuilles de calcul correspondantes pour accéder aux commentaires:

Hyperliens

Des hyperliens peuvent être attachés aux cellules afin de les relier à d'autres documents ou à d'autres cellules du même classeur. La syntaxe générale pour créer des hyperliens est la suivante

<span></span>  procedure TWorksheet.WriteHyperlink(ARow, ACol: Cardinal; ATarget: String; ATooltip: String = '');

<a href="/File:fpsgrid.png view-source:<a class="external free" href="https://wiki.freepascal.org/File:fpsgrid.png">https://wiki.freepascal.org/File:fpsgrid.png</a>" class="image"><img alt="Note-icon.png" src="/images/0/02/fpsgrid.png view-source:<a class="external free" href="https://wiki.freepascal.org/images/0/02/fpsgrid.png">https://wiki.freepascal.org/images/0/02/fpsgrid.png</a>" width="24" height="29" /></a>

Note: Les hyperliens peuvent être ajoutés à des cellules vides ou à des cellules avec du contenu. Dans ce dernier cas, le contenu affiché n'est pas modifié par le lien hypertexte; dans le premier cas, la cellule est convertie en cellule d'étiquette affichant la cible du lien hypertexte. Sachez qu'OpenOffice/LibreOffice n'accepte que les hyperliens avec des cellules non textuelles.

Exemples:

<span></span>  // Ouvrir le site web www.google.com
  MyWorksheet.WriteText(0, 0, 'Open google');
  MyWorksheet.WriteHyperlink(0, 0, 'http://www.google.com');

  // Ouvrez le fichier local avec le chemin absolu "C:\readme.txt" (avec Windows).
  MyWorksheet.WriteHyperlink(1, 0, 'file:///c:\readme.txt');

  // Ouvrir le client de messagerie pour envoyer un courrier
  MyWorksheet.WriteText('Send mail');
  MyWorksheet.WriteHyperlink(3, 0, 'mailto:somebody@gmail.com?subject=Test');

  // Sauter à une cellule particulière
  MyWorksheet.WriteText(5, 0, 'Jump to cell A10 on sheet2');
  MyWorksheet.WriteHyperlink(0, 0, 'http://www.google.com');

  // Sauter à la cellule A10 de la feuille courante et afficher une info-bulle.
  MyWorksheet.WriteHyperlink(5, 0, '#A10', 'Go to cell A10');

<a href="/File:fpsgrid.png view-source:<a class="external free" href="https://wiki.freepascal.org/File:fpsgrid.png">https://wiki.freepascal.org/File:fpsgrid.png</a>" class="image"><img alt="Note-icon.png" src="/images/0/02/fpsgrid.png view-source:<a class="external free" href="https://wiki.freepascal.org/images/0/02/fpsgrid.png">https://wiki.freepascal.org/images/0/02/fpsgrid.png</a>" width="24" height="29" /></a>

Note: FPSpreadsheet ne "suit" pas les liens, il fournit seulement un mécanisme permettant d'accéder aux données des liens. TsWorksheetGrid du package laz_fpspreadsheet_visual, cependant, déclenche l'événement OnClickHyperlink si une cellule avec un hyperlien externe est cliquée pendant des fractions de seconde. Dans le gestionnaire d'événement correspondant, vous pouvez, par exemple, charger une feuille de calcul cible ou ouvrir un navigateur Web pour afficher le site Web lié. Si le lien est un lien interne vers une autre cellule du même classeur, la grille saute à la cellule concernée.

Images

FPSpreadsheet prend en charge l'intégration d'images dans les feuilles de calcul. Utilisez une des méthodes de la feuille de calcul WriteImage() pour ajouter une image à la feuille de calcul:

<span></span>  MyWorksheet.WriteImage(row, col, filename, offsetX, offsetY, scaleX, scaleY);
  MyWorksheet.WriteImage(row, col, filename, offsetX, offsetY, scaleX, scaleY);
  MyWorksheet.WriteImage(row, col, filename, offsetX, offsetY, scaleX, scaleY);

Le coin supérieur/gauche de l'image est placé au coin supérieur/gauche de la cellule dans la ligne et la colonne spécifiées. Les paramètres à virgule flottante offsetX, offsetY, scaleX et scaleY sont facultatifs: ils définissent un décalage de ce point d'ancrage de l'image par rapport au coin de la cellule et un facteur d'agrandissement. Le chemin du fichier image est donné comme paramètre filename. Il est également possible d'utiliser des versions surchargées qui acceptent un flux à la place du nom de fichier ou un index d'image dans la liste EmbeddedObj du classeur - utilisez MyWorkbook.FindEmbeddedObj(filename) pour obtenir cet index pour un fichier image précédemment chargé.

Notez que FPSpreadsheet doit connaître le type d'image pour réussir l'importation d'une image. Actuellement, les types png, jpg, tiff, bmp, gif, svg, wmf, emf, et pcx sont prises en charge (Excel2007 ne peut pas lire les images svg et pcx importées). D'autres formats peuvent être enregistrés en écrivant une fonction qui détermine la taille de l'image et la densité des pixels, et en enregistrant le nouveau format à l'aide de la procédure RegisterImageType - voir l'unité fpsImages pour des exemples:

<span></span><span class="k">type</span>
  TsImageType = integer;
  TGetImageSizeFunc = function (AStream: TStream; out AWidth, AHeight: DWord; out dpiX, dpiY: Double): Boolean;

En raison des différences de calcul de la hauteur des lignes et de la largeur des colonnes entre FPSpreadsheet et les applications Office, il n'est pas possible de positionner correctement les images. Si la position exacte des images est importante, vous devez suivre ces règles:

Tri

Les cellules d'une feuille de calcul peuvent être triées selon divers critères en appelant la méthode Sort de la feuille de calcul. Cette méthode prend un record TsSortParams et les bords du rectangle de cellules à trier comme paramètres; dans une version surchargée, le rectangle de cellules peut également être spécifié au moyen d'une chaîne de plage de type Excel (par exemple 'A1:G10'):

<span></span><span class="k">type</span>
  TsWorksheet = class
    <span class="c1">// ...</span>
    procedure Sort(const ASortParams: TsSortParams;
      ARowFrom, AColFrom, ARowTo, AColTo: Cardinal); overload;
    procedure Sort(ASortParams: TsSortParams; ARange: String); overload;
    <span class="c1">// ...</span>
  end;

Les critères de tri sont définis par un record de type TsSortParams:

<span></span><span class="k">type</span>
  TsSortParams = record
    SortByCols: Boolean;
    Priority: TsSortPriority; // spNumAlpha ("d'abord les nombres"), ou spAlphaNum ("d'abord le texte").
    Keys: TsSortKeys;
  end;

  TsSortKey = record
    ColRowIndex: Integer;
    Options: TsSortOptions; // set of [spDescending, spCaseInsensitive]
  end;

InitSortParams est un utilitaire pratique pour initialiser les paramètres de tri:

<span></span>function InitSortParams(ASortByCols: Boolean = true; ANumSortKeys: Integer = 1;
  ASortPriority: TsSortPriority = spNumAlpha): TsSortParams;

Le fragment de code suivant montre un appel de tri typique:

<span></span><span class="k">var</span>
  sortParams: TsSortParams;
  sortParams:= InitSortParams(true, 2); // sorting along columns, 2 sorting keys

  // clé de tri primaire: colonne 3, ascendante, insensible à la casse
  sortParams.Keys[0].ColRowIndex:= 3;
  sortParams.Keys[0].Options:= [ssoCaseInsensitive];

  // clé de tri secondaire: colum 1, descendant
  sortParams.Keys[0].ColRowIndex:= 3;
  sortParams.Keys[0].Options:= [ssoCaseInsensitive];

  // Le bloc trié s'étend entre les cellules A1 (row=0, col=0) et F10 (row=9, col=5)
  MyWorksheet.Sort(sortParams, 0, 0, 9, 5);
  // ou: MyWorksheet.Sort(sortParams, 'A1:F10');

Rechercher et remplacer

L'unité fpsSearch met en œuvre un moteur de recherche qui peut être utilisé pour rechercher un contenu de cellule spécifique dans un classeur, ou pour remplacer le contenu de cellule trouvé par une autre chaîne.

Exemple:

<span></span>uses
  fpsTypes, fpSpreadsheet, fpsUtils, fpsSearch, fpsAllFormats;
  <span class="n">MyWorkbook</span><span class="o">:</span> <span class="n">TsWorkbook</span><span class="o">;</span>
  foundWorksheet: TsWorksheet;
  foundRow, foundCol: Cardinal;
  MySearchParams: TsSearchParams;
  <span class="o">MyWorkbook</span> <span class="n">:=</span> <span class="o">TsWorkbook</span><span class="n">.</span><span class="o">Create</span><span class="k">;</span>
  try
    procedure ReadFromFile(AFileName: string);

    // Spécifier les critères de recherche
    MySearchParams.SearchText:= 'Hallo';
    sortParams.Keys[0].Options:= [ssoCaseInsensitive];
    MySearchParams.SearchText:= 'Hallo';

    // ou: MySearchParaams:= InitSearchParams('Hallo', [soEntireDocument], swWorkbook);

    // Créer un moteur de recherche et exécuter la recherche
    with TsSearchEngine.Create(MyWorkbook) do begin
      if FindFirst(MySearchParams, foundWorksheet, foundRow, foundCol) then begin
        WriteLn('First "', MySearchparams.SearchText, '" found in cell ', GetCellString(foundRow, foundCol), ' of worksheet ', foundWorksheet.Name);
        while FindNext(MySeachParams, foundWorksheet, foundRow, foundCol) do
          WriteLn('First "', MySearchparams.SearchText, '" found in cell ', GetCellString(foundRow, foundCol), ' of worksheet ', foundWorksheet.Name);
      end;
      Free;
    end;
  finally
    Free;
  end;

Le moteur de recherche fournit deux méthodes de recherche: FindFirst et FindNext. Ils sont très similaires, ils ne diffèrent que par le point de départ de la recherche. En cas de FindFirst, la cellule de départ est déterminée à partir des Options décrites ci-dessous. Dans le cas de FindNext la recherche commence à la cellule adjacente à la cellule précédemment trouvée. Les deux méthodes renvoient la feuille de calcul et les indices de ligne et de colonne de la cellule dans laquelle se trouve le texte recherché. Si la recherche n'aboutit pas, le résultat de la fonction est FALSE, et la FoundWorksheet est nulle. Il est clair que la feuille de travail trouvée ne peut pas être utilisée pour autre chose pendant que la recherche est en cours.

Le record TsSearchParams spécifie les critères utilisés pour la recherche: .

<span></span><span class="k">type</span>
  TsSearchParams = record
    SearchText: String;
    Options: TsSearchOptions;
    Within: TsSearchWithin;
  end;

En plus du texte à rechercher (SearchText), il fournit un ensemble d'options pour affiner la recherche:

Le champ record Within identifie la partie de la feuille de calcul à rechercher:

L'enregistrement des paramètres de recherche peut être initialisé en appelant InitSearchParams (dans l'unité fpsutils) avec les éléments du record comme paramètres facultatifs. Utilisez les méthodes Workbook.ActiveWorksheet et Worksheet.SelectCell(ARow, ACol) pour définir respectivement la feuille de travail active et la position de la cellule active, si la recherche le nécessite.

En plus de la recherche, le moteur de recherche peut également être utilisé pour remplacer le texte trouvé par une autre chaîne de caractères. Appelez les fonctions ReplaceFirst ou ReplaceNext à cette fin. Ils agissent comme leurs FindXXXX homologues, ils nécessitent donc un TsSearchParams record pour spécifier les critères de recherche. Mais en plus de la recherche, ces fonctions effectuent également le remplacement du texte selon la spécification dans un TsReplaceParams record:

<span></span><span class="k">type</span>
  TsReplaceParams = record
    ReplaceText: String;
    Options: TsReplaceOptions;
  end;

Le ReplaceText identifie la chaîne qui remplacera le motif de texte trouvé. Les Options est un ensemble de critères qui définissent comment le remplacement est effectué:

Utilisez la fonction InitReplaceParams (dans l'unité fpsutils) pour initialiser le record des paramètres de remplacement avec les valeurs fournies (mais facultatives).

Opérations sur les colonnes et les lignes

La feuille de calcul fournit ces méthodes pour insérer, supprimer, masquer ou démasquer des colonnes et des lignes:

<span></span><span class="k">type</span>
  TsWorksheet = class
  
    procedure DeleteCol(ACol: Cardinal);
    procedure DeleteRow(ARow: Cardinal);

    procedure InsertCol(ACol: Cardinal);
    procedure InsertRow(ARow: Cardinal);

    procedure RemoveCol(ACol: Cardinal);
    procedure RemoveRow(ARow: Cardinal);

    procedure RemoveAllCols;
    procedure RemoveAllRows

    procedure HideCol(ACol: Cardinal);
    procedure HideRow(ARow: Cardinal);

    procedure ShowCol(ACol: Cardinal);
    procedure ShowRow(ARow: Cardinal);

    function ColHidden(ACol: Cardinal): Boolean;
    function RowHidden(ARow: Cardinal): Boolean;

Mise en page

General

Pour l'instant, FPSpreadsheet ne prend pas en charge l'impression des feuilles de calcul, mais les applications Office le font, et elles fournissent une section d'information dans leurs fichiers à cet effet. Dans FPSpreadsheets, ces informations sont disponibles dans la classe TsPageLayout qui appartient à la structure de données TsWorksheet. Ses propriétés et méthodes combinent les caractéristiques les plus importantes des mondes Excel et OpenDocument.

<span></span><span class="k">type</span>
  TsPageOrientation = (spoPortrait, spoLandscape);

  TsPrintOption = (poPrintGridLines, poPrintHeaders, poPrintPagesByRows,
    poMonochrome, poDraftQuality, poPrintCellComments, poDefaultOrientation,
    poUseStartPageNumber, poCommentsAtEnd, poHorCentered, poVertCentered,
    poDifferentOddEven, poDifferentFirst, poFitPages);

  TsPrintOptions = set of TsPrintOption;

  TsHeaderFooterSectionIndex = (hfsLeft, hfsCenter, hfsRight);

  TsCellRange = record
    Row1, Col1, Row2, Col2: Cardinal;
  end;

  TsPageLayout = class
  
  public
    
    { Methods }
    // images d'en-tête et de pied de page intégrées
    procedure AddHeaderImage(AHeaderIndex: Integer;
      ASection: TsHeaderFooterSectionIndex; const AFilename: String);
    procedure AddFooterImage(AFooterIndex: Integer;
      ASection: TsHeaderFooterSectionIndex; const AFilename: String);
    procedure GetImageSections(out AHeaderTags, AFooterTags: String);
    function HasHeaderFooterImages: Boolean;

    // Lignes et colonnes répétées
    function HasRepeatedCols: Boolean;
    function HasRepeatedRows: Boolean;
    procedure SetRepeatedCols(AFirstCol, ALastCol: Cardinal);
    procedure SetRepeatedRows(AFirstRow, ALastRow: Cardinal);

    // imprimer les plages
    function AddPrintRange(ARow1, ACol1, ARow2, ACol2: Cardinal): Integer; overload;
    function AddPrintRange(const ARange: TsCellRange): Integer; overload;
    function GetPrintRange(AIndex: Integer): TsCellRange;
    function NumPrintRanges: Integer;
    procedure RemovePrintRange(AIndex: Integer);

    { Propriétés }
    property Orientation: TsPageOrientation read FOrientation write FOrientation;
    property PageWidth: Double read FPageWidth write FPageWidth;
    property PageHeight: Double read FPageHeight write FPageHeight;
    property LeftMargin: Double read FLeftMargin write FLeftMargin;
    property RightMargin: Double read FRightMargin write FRightMargin;
    property TopMargin: Double read FTopMargin write FTopMargin;
    property BottomMargin: Double read FBottomMargin write FBottomMargin;
    property HeaderMargin: Double read FHeaderMargin write FHeaderMargin;
    property FooterMargin: Double read FFooterMargin write FFooterMargin;
    property StartPageNumber: Integer read FStartPageNumber write SetStartPageNumber;
    property ScalingFactor: Integer read FScalingFactor write SetScalingFactor;
    property FitHeightToPages: Integer read FFitHeightToPages write SetFitHeightToPages;
    property FitWidthToPages: Integer read FFitWidthToPages write SetFitWidthToPages;
    property Copies: Integer read FCopies write FCopies;
    property Options: TsPrintOptions read FOptions write FOptions;
    property Headers[AIndex: Integer]: String read GetHeaders write SetHeaders;
    property Footers[AIndex: Integer]: String read GetFooters write SetFooters;
    property RepeatedCols: TsRowColRange read FRepeatedCols;
    property RepeatedRows: TsRowColRange read FRepeatedRows;
    property PrintRange[AIndex: Integer]: TsCellRange read GetPrintRange;
    property FooterImages[ASection: TsHeaderFooterSectionIndex]: TsHeaderFooterImage read GetFooterImages;
    property HeaderImages[ASection: TsHeaderFooterSectionIndex]: TsHeaderFooterImage read GetHeaderImages;
  end;

  TsWorksheet = class
  
  public
    property PageLayout: TsPageLayout;
    
  end;

<a href="/File:fpsgrid.png view-source:<a class="external free" href="https://wiki.freepascal.org/File:fpsgrid.png">https://wiki.freepascal.org/File:fpsgrid.png</a>" class="image"><img alt="Note-icon.png" src="/images/0/02/fpsgrid.png view-source:<a class="external free" href="https://wiki.freepascal.org/images/0/02/fpsgrid.png">https://wiki.freepascal.org/images/0/02/fpsgrid.png</a>" width="24" height="29" /></a>

Note: Le fait que le PageLayout appartienne à la feuille de calcul indique qu'il peut y avoir plusieurs mises en page dans le même classeur, une pour chaque feuille de calcul.

<span></span>  Ce paramètre nécessite d'ajouter l'option poUseStartPageNumber aux Options du PageLayout - mais cela est normalement fait automatiquement.
  MyWorksheet.PageLayout.FitWidthToPages:= 1; /// toutes les colonnes sur une largeur de page
  MyWorksheet.PageLayout.FitHeightToPages:= 0; ///utiliser autant de pages que nécessaire

En-têtes et pieds de page

Les textes d'en-tête et de pied de page peuvent être composés de chaînes de caractères alignés à gauche, centrés ou alignés à droite. Ajoutez le symbole &L pour indiquer que la chaîne suivante doit être imprimée en tant que partie alignée à gauche; utilisez &C en conséquence pour les parties centrées et &R pour les parties alignées à droite. Il existe d'autres symboles qui seront remplacés par leurs homologues lors de l'impression:

Les tableaux Headers[]/Footers[] offrent un espace pour l'utilisation de trois en-têtes ou pieds de page différents:

Laissez les chaînes aux indices 0 et 2 vides si l'impression doit toujours avoir le même en-tête/pied de page. Vous pouvez utiliser la constante HEADER_FOOTER_INDEX_ALL pour plus de clarté. Exemple:

<span></span>  MyWorksheet.PageLayout.Headers[HEADER_FOOTER_INDEX_ALL]:= '&C&D &T'; // centré "date heure" sur toutes les pages comme en-tête
  MyWorksheet.PageLayout.Footers[HEADER_FOOTER_INDEX_ODD]:= '&RPage &P of &N'; // aligné à droite "Page ... de ..." sur les pages impaires comme pied de page
  MyWorksheet.PageLayout.Footers[HEADER_FOOTER_INDEX_EVEN]:= '&LPage &P of &N'; // dto, mais aligné à gauche sur les pages paires

Protection

Dans les applications Office, les classeurs peuvent être protégés contre toute modification involontaire par l'utilisateur. fpspreadsheet est capable de lire et d'écrire les structures de données liées à la protection, mais ne les applique pas. Cela signifie, par exemple, que les cellules peuvent être modifiées par l'utilisateur bien que la feuille de calcul soit spécifiée comme étant verrouillée.

La protection est gérée à trois niveaux: protection du classeur, protection de la feuille de calcul et protection des cellules.

Protection du classeur

TsWorkbook contient un ensemble d'options de protection du classeur ou du document:

En relation avec la protection du classeur, il y a l'option de feuille de travail soPanesProtection qui empêche les volets d'une feuille de travail d'être modifiés si le classeur est protégé.

Selon le format du fichier, seules certaines de ces options peuvent être prises en charge. Dans ces cas, les options non prises en charge sont des valeurs par défaut communément acceptées.

Protection des feuilles de travail

TsWorksheet abrite un ensemble similaire d'options de protection. Chaque fois qu'une option est incluse dans l'ensemble Protection du classeur, l'action correspondante n'est pas autorisée et verrouillée:

Ces niveaux de protection deviennent actifs si l'option soProtected est ajoutée aux Options, ou en appelant la méthode Protect(true).

Protection des cellules

La protection des cellules devient active lorsque la protection de la feuille de calcul est activée. Il est contrôlé par un ensemble d'éléments TsCellProtection qui appartient au format de la cellule record:

La protection des cellules peut être modifiée en appelant la méthode de feuille de calcul WriteCellProtection. A l'inverse, ReadCellProtection peut être utilisé pour récupérer l'état de protection d'une cellule particulière:

<span></span>// interroge et modifie l'état de protection de la cellule A1 (row=0, col=0)
  cell: PCell;
  cellprot: TsCellProtections;
  // Chercher la cellule
  if MyWorksheet.FindCell('A1') = nil then
  // interroge la protection de la cellule.
  cellprot:= worksheet.ReadCellProtection(cell);
  // Déverrouille la cellule pour l'édition, ne modifie pas la visibilité des formules.
  worksheet.WriteCellProtection(cell, cellprot - [cpLockCell]);
  // Masque la formule et déverrouille la cellule.
  worksheet.WriteCellProtection(cell, cellprot - [cpLockCell]);

Mots de passe

La protection des classeurs et des feuilles de calcul peut être sécurisée par des mots de passe. Notez que ces mots de passe ne chiffrent pas le fichier (sauf pour la protection des classeurs dans Excel 2007). Dans les applications Office, l'utilisateur doit saisir ce mot de passe pour désactiver la protection ou pour modifier les éléments de protection. Le mot de passe crypté est stocké dans le CryptoInfo record du classeur et des feuilles de calcul, respectivement:

<span></span><span class="k">type</span>
  TsCryptoInfo = record
    PasswordHash: String;
    Algorithm: TsCryptoAlgorithm; // caExcel, caSHA1, caSHA256, etc.
    SaltValue: String;
    SpinCount: Integer;
  end;

<a href="/File:fpsgrid.png view-source:<a class="external free" href="https://wiki.freepascal.org/File:fpsgrid.png">https://wiki.freepascal.org/File:fpsgrid.png</a>" class="image"><img alt="Warning-icon.png" src="/images/0/02/fpsgrid.png view-source:<a class="external free" href="https://wiki.freepascal.org/images/0/02/fpsgrid.png">https://wiki.freepascal.org/images/0/02/fpsgrid.png</a>" width="24" height="24" /></a>

Avertissement: FPSpreadsheet n'effectue aucun calcul de hachage, le CryptoInfo record est juste passé de la lecture à l'écriture. Cela pose des problèmes lorsque des formats de fichiers différents sont impliqués dans la lecture et l'écriture. On tente de détecter les combinaisons incompatibles. Dans ces cas, la protection par mot de passe est supprimée, et une erreur est enregistrée par le classeur.

Charger et sauvegarder

Ajout de nouveaux formats de fichiers

FPSpreadsheet est ouvert à tout format de fichier de tableur. En plus des formats de fichiers intégrés qui sont spécifiés par l'une des sfXXXX déclarations, il est possible de fournir des unités de lecture et d'écriture dédiées pour accéder à des formats de fichiers spéciaux.

<span></span>function RegisterSpreadFormat(AFormat: TsSpreadsheetFormat; AReaderClass: TsSpreadReaderClass; AWriterClass: TsSpreadWriterClass;
  AFormatName, ATechnicalName: String; const AFileExtensions: array of String): TsSpreadFormatID;

Stream selection

Les classeurs sont chargés et enregistrés au moyen des méthodes ReadFromFile et WriteToFile, respectivement (ou par leurs équivalents de flux, ReadFromStream et WriteToStream).

Par défaut, on accède aux fichiers de données au moyen de memory streams, ce qui donne l'accès le plus rapide aux fichiers. Toutefois, dans le cas de fichiers très volumineux (par exemple, des dizaines de milliers de lignes), le système peut manquer de mémoire. Il existe deux méthodes pour différer dans une certaine mesure le débordement de la mémoire.

Mode virtuel

Au-delà de l'utilisation transitoire de la mémoire pendant la lecture et l'écriture, la principale consommation de mémoire provient de la structure interne de FPSpreadsheet qui conserve toutes les données en mémoire. Pour surmonter cette limitation, un "mode virtuel" a été introduit. Dans ce mode, les données sont reçues d'une source de données (telle qu'une table de base de données) et sont transmises à l'éditeur sans être collectées dans la feuille de calcul. Il est clair que les données chargées en mode virtuel ne peuvent pas être affichées dans les contrôles visuels. Le mode virtuel est bon pour la conversion entre différents formats de données.

Voici les étapes à suivre pour utiliser ce mode:

Le mode virtuel fonctionne également pour la lecture des fichiers de tableur.

Le dossier exemple/autre contient un projet d'exemple travaillé démontrant le mode virtuel en utilisant des données aléatoires. Des exemples de bases de données plus réalistes se trouvent dans exemple/db_import_export et dans le chapitre sur la conversion d'une grande table de base de données en utilisant le mode virtuel.

Exportation des données

FPC contient un ensemble d'unités qui vous permettent d'exporter des ensembles de données vers différents formats (XML, instructions SQL, fichiers DBF, ...). Il existe un paquet maître qui vous permet de choisir un format d'exportation au moment de la conception ou de l'exécution (paquet Lazarus lazdbexport).

FPSpreadsheet possède TFPSExport qui se branche sur ce système. Il permet d'exporter le contenu d'un ensemble de données vers un nouveau fichier de type tableur (.xls, .xlsx, .ods, format wikitable) dans un tableau sur la première feuille par défaut. En outre, si MultipleSheets est défini sur TRUE, il est possible de combiner plusieurs feuilles en feuilles de travail individuelles dans le même fichier. Vous pouvez éventuellement inclure les noms des champs en tant que cellules d'en-tête sur la première ligne en utilisant les propriétés HeaderRow dans les paramètres d'exportation. Le composant d'exportation tente de trouver le format de numérotation des cellules en fonction des types de champs de l'ensemble de données.

Pour les exportations plus compliquées, vous devez coder manuellement une solution (voir les exemples ci-dessous) mais pour les simples transferts de données/exportations dynamiques à la demande de l'utilisateur, cette unité sera probablement suffisante.

Un exemple simple de ce fonctionnement:

<span></span>end;
  Exp: TFPSExport;
  ExpSettings: TFPSExportFormatSettings;
  TheDate: TDateTime;
  FDataset.First; //supposons que nous ayons un ensemble de données appelé FDataset
  Exp:= TFPSExport.Create(nil);
  ExpSettings:= TFPSExportFormatSettings.Create(true);
  try
    ExpSettings.ExportFormat:= efXLS; // choisir le format de fichier
    ExpSettings.HeaderRow:= true; // inclure la ligne d'en-tête avec les noms des champs
    Exp.FormatSettings:= ExpSettings; // appliquer les paramètres à l'objet d'exportation
    Exp.Dataset:=FDataset; // spécifier la source
    Exp.FileName:= 'c:\temp\datadump.xls';
    Exp.Execute; // exécute l'exportation
  finally
    Free;
    Free;
  end;

Exporter en DBF

Vous pouvez sauvegarder les informations d'Excel vers dbf assez facilement. Voici un exemple tiré du forum. Veuillez noter que cet exemple est censé fonctionner avec l'encodage Win1251 par défaut. Pour obtenir plus d'informations, veuillez vous reporter à ce fil de discussion [1].

<span></span>procedure TForm1.ExportToDBF(AWorksheet: TsWorksheet; AFileName: String);
  i: Integer;
  f: TField;
  r, c: Cardinal;
  cell: PCell;
  DbfGlobals.DefaultCreateCodePage:= 1251; //codage par défaut du dbf
  DbfGlobals.DefaultCreateCodePage:= 1251; //codage par défaut du dbf
  if Dbf1.Active then Dbf1.Close;
  if FileExists(AFileName) then DeleteFile(AFileName);

  Dbf1.FilePathFull:= ExtractFilePath(AFileName);
  Dbf1.TableName:= ExtractFileName(AFileName);
  Dbf1.TableLevel:= 25; // DBase IV: 4 - le plus utilisé; ou 25 = FoxPro supporte nfCurrency
  Dbf1.LanguageID:= $C9; //langue russe par défaut
  <span class="n">Dbf1</span><span class="o">.</span><span class="n">FieldDefs</span><span class="o">.</span><span class="n">Clear</span><span class="o">;</span>
  //ci-dessous se trouvent les champs en excel
  Dbf1.FieldDefs.Add('fam', ftString);
  //ajoutez les autres champs que vous voulez sauvegarder

  Dbf1.CreateTable;
  Dbf1.Open;

  for f in Dbf1.Fields do
    f.OnGetText:= @DbfGetTextHandler;

  // Sauter la ligne 0 qui contient les en-têtes
  for r:= 1 to AWorksheet.GetLastRowIndex do begin
    Dbf1.Append;
    for c:= 0 to Dbf1.FieldDefs.Count-1 do begin
      f:= Dbf1.Fields[c];
      cell:= AWorksheet.FindCell(r, c);
      if cell = nil then
        f.Value:= NULL
      else
        case cell^.ContentType of
          cctUTF8String: f.AsString:= UTF8ToCP1251(cell^.UTF8StringValue);
          cctNumber: f.AsFloat:= cell^.NumberValue;
          cctDateTime: f.AsDateTime:= cell^.DateTimeValue;
          cctUTF8String: f.AsString:= UTF8ToCP1251(cell^.UTF8StringValue);
        end;
    end;
    Dbf1.Post;
  //Cette procédure est appelée pour que le texte dans les cellules puisse être correctement distribué sur la WorkSheetGrid du formulaire, sinon les symboles '?
  if DisplayText then
    <span class="n">AText</span> <span class="o">:=</span> <span class="n">CP1251ToUTF8</span><span class="p">(</span><span class="n">Sender</span><span class="o">.</span><span class="n">AsString</span><span class="p">)</span><span class="o">;</span>
<span class="k">end</span><span class="o">;</span>

Contrôles visuels pour FPSpreadsheet

Le paquet laz_fpspreadsheet_visual implémente une série de contrôles qui simplifient la création d'applications visuelles GUI:

Voir le <a href="#Protection view-source:<a class="external free" href="https://wiki.freepascal.org/FPSpreadsheet#Protection">https://wiki.freepascal.org/FPSpreadsheet#Protection</a>">Tutoriel FPSpreadsheet: Écriture d'une mini application de tableur</a> pour plus d'informations et un tutoriel, et voir les projets de démonstration pour des exemples d'application de ces composants.

Exemples

Voir FPSpreadsheet: Exemples pour une variété d'exemples de code.

Download

Subversion

Vous pouvez télécharger FPSpreadsheet en utilisant le logiciel subversion et la ligne de commande suivante:

<span></span>svn checkout https://svn.code.sf.net/p/lazarus-ccr/svn/components/fpspreadsheet fpspreadsheet

Journal des modifications SVN

Modifications incompatibles

Versions stables

Vous pouvez trouver toutes les versions de FPSpreadsheet sur sourceforge.

Version 1.12

Journal des modifications (par rapport à la v1.10x)

Version 1.10.1

Il s'agit de la dernière version stable.

Journal des modifications (par rapport à la v1.8x)
Modifications incompatibles

Version 1.8

Journal des modifications (par rapport à la v1.6x)
Modifications incompatibles

Version 1.6

Journal des modifications (par rapport à la v1.4.x)
Modifications incompatibles

Version 1.4

Journal des modifications (par rapport à la v1.2.x)
Modifications incompatibles

Documentation wiki des anciennes versions

This wiki page is work in progress and updated whenever a new feature is added; therefore, its state corresponds to the svn trunk version of the package. If you work with an older stable version please use these "historic" wiki versions:

Installation

Options du compilateur

Here is a list of conditional defines which can be activated in order to tweak some operating modes of the packages and/or make it compilable with older Lazarus/FPC versions:

All these defines are collected in the include file fps.inc.

Support and Bug Reporting

The recommended place to discuss FPSpreadsheet and obtain support is asking in the <a class="external text" href="<a class="external free" href="http://forum.lazarus.freepascal.org/index.php?board=49.0">http://forum.lazarus.freepascal.org/index.php?board=49.0</a> view-source:<a class="external free" href="http://forum.lazarus.freepascal.org/index.php?board=49.0">http://forum.lazarus.freepascal.org/index.php?board=49.0</a>">Lazarus Forum</a>.

Bug reports should be sent to the <a class="external text" href="<a class="external free" href="http://bugs.freepascal.org/">http://bugs.freepascal.org/</a> view-source:<a class="external free" href="http://bugs.freepascal.org/">http://bugs.freepascal.org/</a>">Lazarus/Free Pascal Bug Tracker</a>; please specify the "Lazarus-CCR" project.

Current Progress

Amélioration du contenu des cellules

<tbody></tbody>

Format Multiple sheets Unicode Reader support Writer support Text Number String Formula RPN Formula 3D cell references Date/Time Comments Hyperliens Images +++ Protection Conditional formats
CSV files No Yes + Working ++ Working ++ Working ++ Working ++ N/A N/A N/A Working ++ N/A N/A N/A N/A N/A
Excel 2.x No No * Working ** Working Working Working Working Working *** N/A Working **** Working N/A N/A Working N/A
Excel 5.0 (Excel 5.0 and 95) Yes No * Working ** Working Working Working Working Working *** Working Working **** Working N/A N/A Working N/A
Excel 8.0 (Excel 97- 2003) Yes Yes Working ** Working Working Working Working Working *** Working Working **** Reading only Working Not working Working Not working
Excel 2003/XML Yes Yes Working ** Working Working Working Working *** Working Working Working **** Working Working N/A Working Working
Excel OOXML Yes Yes Working ** Working Working Working Working *** Working Working Working **** Working Working Writing only Working Working ++++
OpenDocument Yes Yes Working ** Working Working Working Working *** Working Working Working **** Working Working Working Working Working
HTML No Yes Working ++ Working ++ Working ++ Working ++ N/A N/A N/A Working ++ N/A Working Not working N/A N/A
Wikitable files (Mediawiki) No Yes planned Working ++ Working ++ Working ++ N/A N/A N/A Working ++ N/A N/A Not working N/A N/A

(+) Depends on file.
(++) No "true" number format support because the file does not containg number formatting information. But the number format currently used in the spreadsheet understood.
(+++) Only very basic image support: no transformations, no cropping, no image manipulation.
(++++) Extended OOXML formatting options not supported.
(*) In formats which don't support Unicode the data is stored by default as ISO 8859-1 (Latin 1). You can change the encoding in TsWorkbook.Encoding. Note that FPSpreadsheet offers UTF-8 read and write routines, but the data might be converted to ISO when reading or writing to the disk. Be careful that characters which don't fit selected encoding will be lost in those operations. The remarks here are only valid for formats which don't support Unicode.
(**) Some cell could be returned blank due to missing or non ready implemented number and text formats.
(***) This is the format in which the formulas are written to file (determined by design of the file format).
(****) Writing of all formats is supported. Some rare custom formats, however, may not be recognized correctly. BIFF2 supports only built-in formats by design.

Amélioration des options de formatage

The following formatting options are available:

<tbody> </tbody>

Format Text alignment Text rotation Font Rich text Border Color support Back ground Word wrap Col&Row size Number format Merged cells Page layout Print ranges Header/footer images Column/row format Hide cols/rows Page breaks
CSV files N/A N/A N/A N/A N/A N/A N/A N/A N/A N/A N/A N/A N/A N/A N/A N/A N/A
Excel 2.x Working * N/A Working N/A Working Working Working** N/A Working Working N/A Working N/A N/A Working N/A Working
Excel 5.0 (Excel 5.0 and 95) Working Working Working Working Working Working Working Working Working Working N/A Working Working N/A Working Working Working
Excel 8.0 (Excel 97 - XP) Working Working Working Working Working Working Working Working Working Working Working Working Working Not working Working Working Working
Excel 2003/XML Working Working Working Working Working Working Working Working Working Working Working Working Working N/A Working Wworking Working
Excel OOXML (xlsx) Working Working Working Working Working Working Working Working Working Working Working Working Working Writing only Working Working Working
OpenDocument Working Working Working Working Working Working Working*** Working Working Working Working Working Working Working Working Working
HTML (+) Working bugs Working Working bugs Working Working **** Writing only Writing only N/A Working N/A N/A Not working Writing only to be done N/A
Wikitable (Mediawiki) Writing only N/A Writing only Not working Writing only Writing only Writing only Writing only N/A Writing only N/A N/A Not working Writing only to be done N/A

(N/A) Feature is not available for this format intrinsically.
(*) BIFF2 supports only horizontal text alignment, vertical alignment is ignored.
(**) BIFF2 does not support a background color; a dotted black&white background is used instead.
(***) OpenDocument supports only uniform backgrounds; a fill color interpolated between foreground and background colors is written instead.
(****) Only uniform background color, no fill styles.
(+) HTML reader does not support styles. Since the writer does use styles these files are not read back correctly.

Amélioration des options de l'interface utilisateur des classeurs/feuilles de travail.

Some additional options were added to interface the file contents with the TsWorksheetGrid:

<tbody></tbody>

Format Hide grid lines Hide headers Frozen Panes Active sheet/cell Zooming BiDi mode Tab color
Excel 2.x Working Working not working N/A N/A N/A N/A
Excel 5.0 (Excel 5.0 and 95) Working Working Working Working Working N/A N/A
Excel 8.0 (Excel 97 - XP) Working Working Working Working Working Working Working
Excel2003/XML Working Working Working Working Working Working N/A
Excel OOXML Working Working Working Working Working Working Working
OpenDocument Working Working Working Working Working Working Working
HTML Writing only Writing only N/A N/A N/A not working N/A

To do list

Note: this list is provisional, maintained by developers and can change without notice. If you are interested in contributing, please feel free to get in touch and submit a patch - thanks!

Long-term:

Changelog

Changes in the development version that have not yet been released are already documented on this page.

  • 2 June 2020:
    Version 1.12 based on revision 7479
  • 13 August 2018:
    Version 1.10.1 bug fix release, based on revision 6598.
  • 6 July 2018:
    Version 1.10 release, based on svn revision 6547.
  • 16 June 2017:
    Version 1.8.3. Fixes compilation with Lazarus 1.8. New, highDPI-aware component palette icons
  • 11 April 2017:
    Version 1.8.2, based on svn revision 5832. Fixes writing distorted images due to incorrect row height calculation.
  • 2 March 2017:
    Version 1.8, based on svn revision 5781.
  • 13 April 2016:
    Version 1.6.2 released, based on svn revision 4619. Fixes integer overflow in formulas (<a class="external text" href="<a class="external free" href="https://bugs.freepascal.org/view.php?id=29999">https://bugs.freepascal.org/view.php?id=29999</a> view-source:<a class="external free" href="https://bugs.freepascal.org/view.php?id=29999">https://bugs.freepascal.org/view.php?id=29999</a>">Issue #29999</a>).
  • 28 June 2015:
    Version 1.6 released, based on svn release 4106. Improved memory consumption, comments, hyperlinks, background fill patterns, cell enumerator, fraction number format, page layout, modified color management, offline wiki version included.
  • 13 March 2015:
    Version 1.4.3 released. Fixes formula calculation in worksheet grid.
  • 31 January 2015:
    Version 1.4.2 released. Fixes incomplete reading of ods files with repeated cells (<a class="external text" href="<a class="external free" href="https://bugs.freepascal.org/view.php?id=0027389">https://bugs.freepascal.org/view.php?id=0027389</a> view-source:<a class="external free" href="https://bugs.freepascal.org/view.php?id=0027389">https://bugs.freepascal.org/view.php?id=0027389</a>">Issue #0027389</a>)
  • 26 January 2015:
    Version 1.4.1 released. A bugfix release for 1.4 that fixes incorrect streaming of TsWorksheetGrid and reading errors of biff5 and biff8 readers.
  • 31 December 2014:
    Version 1.4 released (based on subversion revision 3856 with full formula support, xlsx reader, csv reader and writer, wikitables writer, speed enhancement, virtual mode, db export component, row and column insertion/deletion, sorting, merged cells, visual controls in addition to (improved) fpspreadsheet grid.
  • 3 September 2014:
    Version 1.2.1 released. This is a bugfix release for 1.2 that fixes a bug in spreadsheetGrid (<a class="external text" href="<a class="external free" href="https://bugs.freepascal.org/view.php?id=26521">https://bugs.freepascal.org/view.php?id=26521</a> view-source:<a class="external free" href="https://bugs.freepascal.org/view.php?id=26521">https://bugs.freepascal.org/view.php?id=26521</a>">Issue #26521</a>)
  • 26 June 2014:
    Version 1.2 released (based on subversion revision 3241) with fpsgrid improvements, date/time cell support for .xls, .ods, vastly improved cell formatting support, improved formula support, unit tests.
  • Jan 2013:
    Version 1.1 released with all improvements up to revision 2621
  • Nov 2011:
    Released version 1.0, which includes OO XML generation support with bold formatting supported and also a lot of improvements from the last years
  • Jan 2009:
    Implemented a cross-platform support for OLE file. Now Excel 5.0 files can be created in any operating system. Adds read support for Excel 2.1
  • Feb 2008:
    Initial commit to lazarus-ccr with write support for Excel 2.1, Excel 5.0 (Windows only) and experimental OOXML and OpenDocument

License

LGPL with static linking exception. This is the same license as is used in the Lazarus Component Library.

References

Liens Wiki

Liens externes

Retrieved from "<a dir="ltr" href="https://wiki.freepascal.org/index.php?title=FPSpreadsheet/fr&oldid=145905">https://wiki.freepascal.org/index.php?title=FPSpreadsheet/fr&oldid=145905</a>" Navigation menuViews

Personal tools

Navigation

<label for="searchInput">Search</label><form action="/index.php" id="searchform"><input type="hidden" value="Special:Search" name="title"/><input type="search" name="search" placeholder="Search Free Pascal wiki" title="Search Free Pascal wiki [f]" accesskey="f" id="searchInput"/><input type="submit" name="go" value="Go" title="Go to a page with this exact name if it exists" id="searchGoButton" class="searchButton"/> <input type="submit" name="fulltext" value="Search" title="Search the pages for this text" id="mw-searchButton" class="searchButton"/></form>Tools

<a href="https://sourceforge.net"><img src="https://sflogo.sourceforge.net/sflogo.php?group_id=92177&type=1" alt="" width="88" height="31"/></a><a href="//www.mediawiki.org/">\<img src="/resources/assets/poweredby_mediawiki_88x31.png" alt="Powered by MediaWiki" srcset="/resources/assets/poweredby_mediawiki_132x47.png 1.5x, /resources/assets/poweredby_mediawiki_176x62.png 2x" width="88" height="31"/></a>

<script>(window.RLQ=window.RLQ||[]).push(function(){mw.config.set({"wgPageParseReport":{"limitreport":{"cputime":"0.160","walltime":"0.161","ppvisitednodes":{"value":846,"limit":1000000},"ppgeneratednodes":{"value":2636,"limit":1000000},"postexpandincludesize":{"value":0,"limit":2097152},"templateargumentsize":{"value":0,"limit":2097152},"expansiondepth":{"value":2,"limit":40},"expensivefunctioncount":{"value":0,"limit":100},"unstrip-depth":{"value":0,"limit":20},"unstrip-size":{"value":46861,"limit":5000000},"timingprofile":["100.00% 0.000 1 -total"]},"cachereport":{"timestamp":"20210720150814","ttl":86400,"transientcontent":false}}});});</script><script>(window.RLQ=window.RLQ||[]).push(function(){mw.config.set({"wgBackendResponseTime":59});});</script></body></html>