Développer un add-in pour Excel 2007 avec Visual Studio 2010.

Les groupes sont les briques de base d'un add-in Office car ils jouent le rôle de conteneur pour les autres composants. Les autres composants graphiques ne peuvent effectivement pas exister en dehors d'un groupe.

Il n'est pas nécessaire (et il n'est pas possible !) de redimensionner soi-même la taille d'un groupe. En effet, celle-ci est automatiquement ajustée pour que tous les composants soient visibles.

Le label est un composant destiné à l'affichage de texte. Le texte à afficher se trouve dans la propriété Label du Label. Aucun évènement n'est associé à ce composant (i.e. il ne peut intercepter aucune action venant de la part de l'utilisateur (passage de la souris sur le composant, clic, etc.)).

Ce composant n'a aucune caractéristique particulière. Il ne peut intercepter qu'un évènement de type clic simple.

Plus exotique que son homologue Button, il est capable d'être poussé et dispose par conséquent d'une propriété Checked. Celle-ci permet de savoir ou de définir si le bouton est poussé. Tout comme le composant Button, le ToggleButton n'est capable d'intercepter que les simples clics.

Ce composant de base (également présent dans les Windows Forms) permet à l'utilisateur de cocher une case. La CheckBox dispose également d'un label placé à côté de la case à cocher. Ce composant ne permet d'intercepter que des clics simples.

Il est utile de remarquer que le ToggleButton et la CheckBox sont équivalents du point de vue des fonctionnalités. Cependant, l'utilisateur moyen est généralement plus habitué aux CheckBox.

L'EditBox est essentiellement une zone de saisie de texte. Il dispose d'un évènement TextChanged permettant d'exécuter certaines instructions lorsque l'utilisateur a modifié le texte contenu dans celui-ci.

Le lecteur remarquera une différence essentielle entre le composant graphique Textbox des Windows Forms et le composant EditBox pour les solutions Office : dans ce dernier, un label est disposé à gauche de la zone de saisie de texte.

Il existe d'autres composants graphiques pour les solutions Office. Néanmoins, ils ne seront pas présentés ici puisqu'ils présentent de fortes similitudes avec les composants Windows Forms et leur découverte reste aisée.

La création d'un Task Pane repose sur un UserControl. La figure ci-dessous montre comment créer un tel contrôle.

L'interface graphique et le code du UserControl sont produits de la même manière qu'avec les Windows Forms classiques. Le code exemple ci-dessous correspond au Task Pane présenté sur la figure en section 2.4. Le programme se contente d'écrire un texte donné dans la cellule spécifiée.

private void btnWrite_Click(object sender, EventArgs e)
        {
            Excel._Worksheet currWorkSheet = Globals.ThisAddIn.Application.Workbooks[1].Worksheets[1];
            // Cellule dans laquelle il faut écrire
            Excel.Range cell = currWorkSheet.get_Range(TBCell.Text);
            // Ecriture du texte
            cell.Value2 = TBNewText.Text;
        }

Dans le code ci-dessus, btnWrite est le bouton "Ecrire", TBCell est la textBox dans laquelle la cellule où le texte doit être écrit est spécifiée et TBNewtexte est la TextBox contenant le texte à afficher.

Il faut également instancier et afficher le Task Pane. Le code suivant décrit cette opération :

using System.Collections.Generic;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using Excel = Microsoft.Office.Interop.Excel;
using Office = Microsoft.Office.Core;
using Microsoft.Office.Tools.Ribbon;

namespace ExcelAddIn1
{
    public partial class MainRib
    {

        private CustomUserControl customUserControl;
        private Microsoft.Office.Tools.CustomTaskPane customTaskPane;

        private void MainRib_Load(object sender, RibbonUIEventArgs e)
        {
            // Construction de l'usercontrol
            customUserControl = new CustomUserControl();
            // Ajout du Task Pane avec comme titre "Un exemple de Task Pane"
            customTaskPane = Globals.ThisAddIn.CustomTaskPanes.Add(customUserControl, "Un exemple de Task Pane");
            // Le Task Pane est caché par défaut
        }

        private void btnAction_Click(object sender, RibbonControlEventArgs e)
        {
            // Rend visible le Task Pane
            customTaskPane.Visible = true;
        }
    }
}

Pour l'exemple, il a été décidé de créer une seule instance du Task Pane au chargement du ribbon et de ne l'afficher que lorsque l'utilisateur presse le bouton btnAction (un bouton placé dans un ribbon).

Le lecteur remarquera que si l'utilisateur ferme le Task Pane, son instance en mémoire ne disparait pas et il suffit par conséquent d'exécuter l'instruction customTaskPane.Visible = true; pour l'afficher de nouveau.

Globals.ThisAddIn.Application.Workbooks.Open("unWorkBook.xls");

Le classeur est ouvert dans une nouvelle instance d'Excel. Le classeur utilisé avant l'ouverture est donc conservé dans l'instance initiale d'Excel.

Globals.ThisAddIn.Application.Workbooks[1].Close(true, @"C:\unWorkBook");

Globals.ThisAddIn.Application.Workbooks[1].Close(false, @"C:\unWorkBook");

Ici, le premier argument de la méthode Close permet de spécifier si le programme doit sauvegarder les changements non enregistrés du classeur avant de fermer celui-ci. Le deuxième argument permet de spécifier un chemin d'enregistrement si le fichier est nouveau (i.e. aucun fichier ne lui correspond sur le disque dur). Dans le cas d'un nouveau fichier, le classeur est toujours sauvegardé au format xlsx.

Il ne faut jamais écrire Globals.ThisAddIn.Application.Workbooks[1].Close(false, @"C:\unWorkBook.xlsx"); (on a écrit l'extension xlsx). L'instruction ci-dessus fait planter le programme car c'est celui-ci qui choisit le format d'enregistrement.

Globals.ThisAddIn.Application.Workbooks[1].Close();

Dans l'exemple ci-dessus, l'utilisateur doit choisir s'il souhaite enregistrer le classeur et le cas échéant à quel emplacement celui-ci doit être sauvegardé.

Globals.ThisAddIn.Application.Workbooks[1].Save();

L'instruction ci-dessus resauvegarde un classeur existant déjà sur le disque dur. Il ne faut donc pas utiliser cette instruction si c'est un nouveau classeur qui est ouvert (dans un tel cas, utiliser la méthode SaveAs décrite ci-dessous).

// Sauve le classeur sous C:\testWorkBook.xlsx.
Globals.ThisAddIn.Application.Workbooks[1].SaveAs(@"C:\testWorkBook", Excel.XlFileFormat.xlOpenXMLWorkbook);

Excel.XlFileFormat fournit une énumération qui permet de choisir parmi les différents formats de sauvegarde disponibles. Un tableau récapitulatif des formats disponibles se trouve sur http://msdn.microsoft.com/en-us/library/bb241279%28office.12%29.aspxhttp://msdn.microsoft.com/en-us/library/bb241279%28office.12%29.aspx.

Un commentaire disponible en accédant à la page internet http://msdn.microsoft.com/en-us/library/bb241279%28office.12%29.aspxhttp://msdn.microsoft.com/en-us/library/bb241279%28office.12%29.aspx indique qu'il n'est pas toujours possible d'ouvrir et/ou de sauver sous tous les formats répertoriés dans l'énumération XlFileFormat. Cependant, seuls les formats de fichier les plus exotiques ou les plus anciens peuvent poser problème. Une liste des formats non supportés pour l'écriture et/ou la lecture est incluse dans le commentaire susmentionné.

La sélection d'une feuille de calcul consiste à afficher celle-ci sur l'écran.

// Sélectionne la deuxième feuille de calcul dans l'ordre du classeur
Excel._Worksheet workSheet = Globals.ThisAddIn.Application.Workbooks[1].Sheets[2];
workSheet.Select();

La sélection se base ici sur la position de la feuille de calcul par rapport aux autres. Pour mieux comprendre ce que l'ordre d'une feuille de calcul représente, voici une illustration :

Sur l'image ci-dessus, la feuille de calcul Sheet1 est la première, suivie de Sheet2, Sheet3, etc. Ainsi, Workbooks[1].Sheets[2] renvoie à la deuxième feuille de calcul (Sheet2 dans l'exemple) du premier classeur ouvert.

// Sélectionne la feuille de calcul du premier classeur nommée "Sheet3"
Excel._Worksheet workSheet = Globals.ThisAddIn.Application.Workbooks[1].Sheets["Sheet3"];
workSheet.Select();

La sélection se base ici sur le nom que porte la feuille de calcul. Cette deuxième méthode peut s'avérer plus fiable que son équivalent avec les index dans la mesure où l'utilisateur pourrait avoir envie de réorganiser l'ordre des feuilles de calcul. Cette difficulté est surmontée dans la deuxième méthode car le nom des feuilles de calcul restera inchangé (pour autant que l'utilisateur soit suffisamment discipliné...).

Il est également possible de redimensionner la largeur d'une colonne ou la hauteur d'une ligne.

// La première feuille de calcul
Excel._Worksheet workSheet = Globals.ThisAddIn.Application.Workbooks[1].Sheets[1];
// La quatrième ligne
Excel.Range row = workSheet.Rows[4];
// On utilise l'objet RowHeight pour fixer la hauteur de la ligne
row.RowHeight = 120;

Il est nécessaire de passer par la propriété RowHeight. En effet, la propriété Height ne permet que la lecture de la hauteur de la ligne. Le code suivant marche également :

// La première feuille de calcul
Excel._Worksheet workSheet = Globals.ThisAddIn.Application.Workbooks[1].Sheets[1];
// La première cellule de la quatrième ligne
Excel.Range row = workSheet.Cells[4,1];
// On utilise l'objet RowHeight pour fixer la hauteur de la ligne
row.RowHeight = 120;

Ce code montre qu'il est en fait possible de redimensionner la hauteur de la ligne associée à n'importe quelle cellule. Plus généralement, l'utilisation de l'interface Range permet de modifier la hauteur des lignes d'un "bloc de cellules". Cependant, ceci ne marche que si les lignes de ce "bloc de cellules" ont initialement la même hauteur. Dans le cas contraire, une erreur sera levée. Une discussion plus fine de ceci est disponible sur http://msdn.microsoft.com/en-us/library/microsoft.office.interop.excel.range.rowheight.aspxhttp://msdn.microsoft.com/en-us/library/microsoft.office.interop.excel.range.rowheight.aspx

// La première feuille de calcul
Excel._Worksheet workSheet = Globals.ThisAddIn.Application.Workbooks[1].Sheets[1];
// La troisième colonne
Excel.Range column = workSheet.Columns[3];
// On utilise l'objet RowHeight pour fixer la hauteur de la ligne
column.ColumnWidth = 80;

ColumnWidth est l'équivalent pour les colonnes de RowHeight pour les lignes.

Une différence essentielle entre RowHeight et ColumnWidth existe cependant. ColumnWidth = i attribue à la colonne une largeur correspondant à i fois la largeur d'un caractère dans le style Normal. En revanche, la propriété Width est exprimée en pixels tout comme RowHeight et Height. Pour plus d'informations : http://msdn.microsoft.com/en-us/library/microsoft.office.tools.excel.namedrange.columnwidth(VS.80).aspxhttp://msdn.microsoft.com/en-us/library/microsoft.office.tools.excel.namedrange.columnwidth(VS.80).aspx .

// Classeur dans lequel insérer les nouvelles feuilles de calcul
Excel._Workbook workBook = Globals.ThisAddIn.Application.Workbooks[1];
// Feuille de calcul avant laquelle insérer les nouvelles feuilles de calcul
Excel._Worksheet befSheet = workBook.Sheets[2];
// Ajout de deux nouvelles feuilles de calcul avant la deuxième feuille de calcul
workBook.Sheets.Add(befSheet, Type.Missing, 2, Excel.XlSheetType.xlWorksheet);

L'ajout d'une feuille de calcul se fait par la méthode Add de workBook.Sheets. Celle-ci est très bien décrite dans la MSDN. Voir : http://msdn.microsoft.com/fr-fr/library/microsoft.office.interop.excel.sheets.add%28v=office.11%29.aspx

// La deuxième feuille de calcul du premier classeur
Excel._Worksheet workSheet = Globals.ThisAddIn.Application.Workbooks[1].Sheets[2];
workSheet.Delete();

Le code ci-dessus est une façon basique de supprimer une feuille de calcul. Cependant, il postule l'existence d'au moins deux feuilles de calcul. Cette hypothèse est vérifiée par le code suivant :

// Nombre total de feuilles de calcul dans le premier classeur
int workSheetNb = Globals.ThisAddIn.Application.Workbooks[1].Sheets.Count;
// Vérification de l'existence de la feuille de calcul
if (workSheetNb > 1)
    {
        // La deuxième feuille de calcul du premier classeur
        Excel._Worksheet workSheet = Globals.ThisAddIn.Application.Workbooks[1].Sheets[2];
        workSheet.Delete();
    }

3-2-4-1. Suppression d'une feuille de calcul à partir de son nom▲

Une méthode générale de sélection des feuilles de calcul sur base de leurs noms est décrite ci-dessous. Ci-dessus, la propriété Count de Workbooks[1].Sheets a été utilisée afin de savoir si la feuille de calcul (donnée par son index) existe. Dans le cas où un nom est utilisé, il est clair qu'une telle technique n'est plus valable.

Tout d'abord, il faut introduire la ligne suivante au début du code source :

 

Sélectionnez

using System.Runtime.InteropServices;

Ceci fournira l'accès à la classe ComException. Celle-ci constitue la classe de base pour la gestion des exceptions dans Office (plus généralement, dans une application reposant sur l'architecture COM). Le code suivant permet de traiter l'exception voulue :

Interception d'une exception dans Excel

Sélectionnez

try
    {
        Excel._Worksheet workSheet = Globals.ThisAddIn.Application.Workbooks[1].Sheets["unNom"];
        workSheet.Delete();
    }
catch (COMException exp)
    {
        if ((uint)exp.ErrorCode == 0x8002000B)
        {
            // Le code à exécuter si la feuille de calcul n'existe pas
            // ...
        }
    }

Comme suggéré ci-dessus, la nature de l'exception est donnée par un code d'erreur associé à l'objet exp (classe COMException). Une méthode pour déterminer le code qui correspond à une erreur donnée est décrite ci-dessous.

3-2-4-1-1. Détermination du code d'erreur associé à une action particulière▲

L'idée consiste à provoquer volontairement l'erreur et à récupérer le code correspondant dans le débogueur de Visual Studio. Pour déterminer le code d'erreur associé à la sélection d'une feuille de calcul qui n'existe pas, il suffit de créer un bouton avec les instructions suivantes pour le simple clic sur celui-ci :

 

Sélectionnez

private void btnAction_Click(object sender, RibbonControlEventArgs e)
{
	Excel._Worksheet workSheet = Globals.ThisAddIn.Application.Workbooks[1].Sheets["unNomQuiNexistePas"];
}

En cliquant sur ce bouton, la fenêtre ci-dessous apparaît. Il suffit alors de copier-coller le code d'erreur et de l'insérer dans le code source.

4-3-1-1. L'objet Style▲

Excel.Style currStyle = Globals.ThisAddIn.Application.Workbooks[1].Styles.Add("unNouveauStyle");
// Dans la suite, on paramétrise le style (par exemple, définir la taille des bordures et leur couleur)
// ...

Excel.Style currStyle = Globals.ThisAddIn.Application.Workbooks[1].Styles["unStyleExistantDeja"];

Globals.ThisAddIn.Application.Workbooks[1].Styles["unStyleASupprimer"].Delete();

// Création du nouveau style
Excel.Style customStyle = Globals.ThisAddIn.Application.Workbooks[1].Styles.Add("customStyle");
// Première feuille de calcul (du premier classeur)
Excel._Worksheet workSheet = Globals.ThisAddIn.Application.Worksheets[1];
// Cellule B1
Excel.Range cell = workSheet.Cells[1, 2];
// Assignation du style
cell.Style = customStyle;

// Première feuille de calcul (du premier classeur)
Excel._Worksheet workSheet = Globals.ThisAddIn.Application.Worksheets[1];
// Cellule B1
Excel.Range cell = workSheet.Cells[1, 2];
// Assignation du style
cell.Style = "customStyle";

La deuxième méthode travaille directement sur les propriétés de la cellule elle-même. Ainsi, si la couleur intérieure de la cellule A1 doit être changée, nous pouvons écrire

// Première feuille de calcul (du premier classeur)
Excel._Worksheet currWorkSheet = Globals.ThisAddIn.Application.Worksheets[1];
// Cellule A1
Excel.Range cell = currWorkSheet.Cells[1, 1];
// La couleur de fond de la cellule est maintenant rouge (Red).
cell.Interior.Color = System.Drawing.Color.Red;

La suite de ce tutoriel traite de quelques opérations particulières sur les styles. Celles-ci sont réalisées en utilisant la première méthode mais l'adaptation à la seconde est simple et presque immédiate.

Pour changer l'alignement du texte (i.e. sa position dans la cellule), il faut modifier d'une part l'alignement vertical et d'autre part l'alignement horizontal.

// Création du nouveau style
Excel.Style customStyle = Globals.ThisAddIn.Application.Workbooks[1].Styles.Add("customStyle");
// Le texte est écrit au bas de la cellule
customStyle.VerticalAlignment = Excel.XlVAlign.xlVAlignBottom;

// Création du nouveau style
Excel.Style customStyle = Globals.ThisAddIn.Application.Workbooks[1].Styles.Add("customStyle");
// Le texte est écrit au milieu de la cellule (le milieu est ici envisagé au sens horizontal)
customStyle.HorizontalAlignment = Excel.XlHAlign.xlHAlignCenter;

L'alignement est totalement défini par les propriétés VerticalAlignement et HorizontalAlignement du style. Les énumérations XlVAlign (V pour vertical) et XlHAlign (H pour horizontal) fournissent tous les alignements possibles.

4-4-3-1. Mise en forme de base : écriture en gras, italique et soulignage▲

 // Création du nouveau style
Excel.Style customStyle = Globals.ThisAddIn.Application.Workbooks[1].Styles.Add("customStyle");
// Le texte est écrit en gras
customStyle.Font.Bold = true;
// Le texte est écrit en italique
customStyle.Font.Italic = true;
// Le texte est souligné
customStyle.Font.Underline = true;

4-4-3-2. Taille de la police▲

// Création du nouveau style
Excel.Style customStyle = Globals.ThisAddIn.Application.Workbooks[1].Styles.Add("customStyle");
// Le texte est écrit en taille 18
customStyle.Font.Size = 18;

4-4-3-3. La couleur du texte▲

// Création du nouveau style
Excel.Style customStyle = Globals.ThisAddIn.Application.Workbooks[1].Styles.Add("customStyle");
// La couleur du texte est vert foncé
customStyle.Font.Color = System.Drawing.Color.DarkGreen;

Cette section montre comment personnaliser les bordures des cellules.

4-4-4-1. Introduction▲

Toute cellule contient six bordures : la bordure gauche, droite, supérieure, inférieure, en diagonale montante et en diagonale descendante.

Chaque bordure peut bien sûr être modifiée indépendamment des autres.

Une erreur dans l'énumération XlBordersIndex du framework nécessite un petit ajustement au niveau du code qui sera présenté dans la suite.

4-4-4-2. Modifier la totalité des bordures en même temps▲

// Création du nouveau style
Excel.Style customStyle = Globals.ThisAddIn.Application.Workbooks[1].Styles.Add("customStyle");
// La couleur des bordures est orange foncé
// REMARQUE : Cette instruction fait aussi apparaitre toutes les bordures (et plus particulièrement
// les deux bordures diagonales)
customStyle.Borders.Color = System.Drawing.Color.DarkOrange;
// Le trait de la bordure est moyen
customStyle.Borders.Weight = Excel.XlBorderWeight.xlMedium;

4-4-4-3. Modifier les bordures une à une▲

// Création du nouveau style
Excel.Style customStyle = Globals.ThisAddIn.Application.Workbooks[1].Styles.Add("customStyle");
/* NOTE : Erreur dans l'enum (XlBordersIndex) du framework
* Valeurs correctes : 
* xlEdgeLeft = 1,
* xlEdgeRight = 2,
* xlEdgeTop = 3,
* xlEdgeBottom = 4,
* xlDiagonalTop et XlDiagonalDown : l'enum marche correctement
*/
// La bordure de droite (xlEdgeRIGHT) est constituée d'une succession de points
customStyle.Borders[(Excel.XlBordersIndex)2].LineStyle = Excel.XlLineStyle.xlDot;

4-4-4-4. Opérations sur les bordures▲

// Création du nouveau style
Excel.Style customStyle = Globals.ThisAddIn.Application.Workbooks[1].Styles.Add("customStyle");
/* NOTE : Erreur dans l'enum (XlBordersIndex) du framework
* Valeurs correctes : 
* xlEdgeLeft = 1,
* xlEdgeRight = 2,
* xlEdgeTop = 3,
* xlEdgeBottom = 4,
* xlDiagonalTop et XlDiagonalDown : l'enum marche correctement
*/
// La bordure de droite (xlEdgeRIGHT) est constituée d'une succession de points et de traits d'union (-.-.-.)
customStyle.Borders[(Excel.XlBordersIndex)2].LineStyle = Excel.XlLineStyle.xlDashDot;

// Création du nouveau style
Excel.Style customStyle = Globals.ThisAddIn.Application.Workbooks[1].Styles.Add("customStyle");
/* NOTE : Erreur dans l'enum (XlBordersIndex) du framework
* Valeurs correctes : 
* xlEdgeLeft = 1,
* xlEdgeRight = 2,
* xlEdgeTop = 3,
* xlEdgeBottom = 4,
* xlDiagonalTop et XlDiagonalDown : l'enum marche correctement
*/
// L'épaisseur de la bordure de droite (xlEdgeRIGHT) est très petite (xlHairline == la plus petite épaisseur disponible)
customStyle.Borders[(Excel.XlBordersIndex)2].Weight = Excel.XlBorderWeight.xlHairline;

// Création du nouveau style
Excel.Style customStyle = Globals.ThisAddIn.Application.Workbooks[1].Styles.Add("customStyle");
/* NOTE : Erreur dans l'enum (XlBordersIndex) du framework
* Valeurs correctes : 
* xlEdgeLeft = 1,
* xlEdgeRight = 2,
* xlEdgeTop = 3,
* xlEdgeBottom = 4,
* xlDiagonalTop et XlDiagonalDown : l'enum marche correctement
*/
// La bordure de gauche est de couleur rouge
customStyle.Borders[(Excel.XlBordersIndex)1].Color = System.Drawing.Color.Red;