Pour la manipulation de documents Word en Go, plusieurs bibliothèques existent. Parmi elles, deux se distinguent : github.com/unidoc/unioffice et sa version communautaire github.com/carmel/gooxml.

github.com/unidoc/unioffice (Commercial)

Cette bibliothèque offre une gamme complète de fonctionnalités pour interagir avec les documents Word. Elle est destinée à un usage commercial et propose une période d'essai de 100 utilisations après enregistrement. Pour des exemplse détaillés, consultez unioffice-examples.

github.com/carmel/gooxml (Gratuit)

gooxml est une alternative gratuite dérivée de unidoc/unioffice, basée sur la version 1.4.0 de cette dernière. Bien qu'elle ne dispose pas de toutes les fonctionnalités de la version payante, elle couvre la majorité des besoins fondamentaux pour la manpiulation de documents Word.

Installation

Pour intégrer cette bibliothèque à votre projet, utilisez la commande suivante :

go get github.com/carmel/gooxml

Utilisation Fondamentale

1. Création et Remplissage d'un Document

Pour créer un nouveau document et y ajouter du contenu :

package main

import (
	"log"

	"github.com/carmel/gooxml/document"
	"github.com/carmel/gooxml/measurement"
	"github.com/carmel/gooxml/wml"
)

func main() {
	doc := document.New()
	para := doc.AddParagraph() // Ajoute un nouveau paragraphe
	run := para.AddRun()
	run.AddText("Ceci est un texte de paragraphe.") // Ajoute du texte

	// Pour un saut de ligne dans le même paragraphe : utiliser '\r'
	run.AddText("Première ligne.\rDeuxième ligne.")

	// Sauvegarder le fichier (utiliser un chemin absolu)
	err := doc.SaveToFile("document_simple.docx")
	if err != nil {
		log.Fatalf("Erreur lors de la sauvegarde du fichier : %s", err)
	}
}

2. Application de Styles aux Paragraphes

Vous pouvez appliquer divers styles prédéfinis ou personnalisés aux paragraphes :

// Styles prédéfinis
para.SetStyle("Title")
para.SetStyle("Heading1") // D'autres niveaux : Heading2, Heading3, etc.

// Indentation de la première ligne
para.Properties().SetFirstLineIndent(0.5 * measurement.Inch)

// Commencer une nouvelle section sur une nouvelle page
para.Properties().AddSection(wml.ST_SectionMarkNextPage)

3. Mise en Forme du Texte

Le contenu textuel (Run) peut être formaté individuellement :

run := para.AddRun()
run.Properties().SetBold(true)             // Mettre en gras
run.Properties().SetFontFamily("Arial")    // Définir la police
run.Properties().SetSize(12)               // Définir la taille (en points)
run.Properties().SetColor("0000FF")       // Définir la couleur (ex: bleu)
run.Properties().SetHighlight("Yellow")    // Appliquer un surlignage jaune
run.Properties().SetUnderline(wml.ST_UnderlineWavyDouble, "FF0000") // Soulignement ondulé double rouge

4. Configuration des En-têtes et Pieds de Page

Les en-têtes et pieds de page peuvent être personnalisés :

// En-tête
hdr := doc.AddHeader()
headerPara := hdr.AddParagraph()
headerPara.Properties().AddTabStop(2.5 * measurement.Inch, wml.ST_TabJcCenter, wml.ST_TabTlcNone)
headerRun := headerPara.AddRun()
headerRun.AddTab()
headerRun.AddText("Titre du Document")

// Pied de page
ftr := doc.AddFooter()
footerPara := ftr.AddParagraph()
footerPara.Properties().AddTabStop(6 * measurement.Inch, wml.ST_TabJcRight, wml.ST_TabTlcNone)
footerRun := footerPara.AddRun()
footerRun.AddText("Sous-titre")
footerRun.AddTab()

5. Insertion d'Images

Pour ajouter des images au document :

// Charger l'image
img, err := document.ImageFromFile("chemin/vers/votre/image.png")
if err != nil {
	log.Fatalf("Impossible de charger l'image : %s", err)
}
imgRef, err := doc.AddImage(img)
if err != nil {
	log.Fatalf("Impossible d'ajouter l'image au document : %s", err)
}

// Intégrer l'image dans un paragraphe
para := doc.AddParagraph()
run := para.AddRun()
drawing, err := run.AddDrawingAnchored(imgRef)
if err != nil {
	log.Fatalf("Impossible d'ajouter l'image ancrée : %s", err)
}

// Configurer les propriétés de l'image
drawing.SetName("MonImageLogo")
drawing.SetSize(2 * measurement.Inch, 2 * measurement.Inch) // Taille
drawing.SetOrigin(wml.WdST_RelFromHPage, wml.WdST_RelFromVTopMargin) // Position relative
drawing.SetHAlignment(wml.WdST_AlignHCenter) // Alignement horizontal
drawing.SetYOffset(0.5 * measurement.Inch) // Décalage vertical
drawing.SetTextWrapSquare(wml.WdST_WrapTextBothSides) // Habillage du texte

6. Remplacement de Contenu dans un Modèle

Cette bibliothèque permet de modifier des documents existants en remplaçant du texte basé sur un modèle :

doc, err := document.Open("modele.docx")
if err != nil {
	log.Fatalf("Erreur lors de l'ouverture du modèle : %s", err)
}

// Parcourir tous les paragraphes (y compris ceux des balises SDT)
allParagraphs := []document.Paragraph{}
for _, p := range doc.Paragraphs() {
	allParagraphs = append(allParagraphs, p)
}
// Les balises SDT (Structured Document Tags) peuvent aussi contenir des paragraphes
for _, sdt := range doc.StructuredDocumentTags() {
	for _, p := range sdt.Paragraphs() {
		allParagraphs = append(allParagraphs, p)
	}
}

// Remplacer le texte
for _, p := range allParagraphs {
	for _, r := range p.Runs() {
		originalText := r.Text()
		if originalText == "Texte à remplacer" {
			r.ClearContent() // Efface le contenu existant
			r.AddText("Nouveau texte.")
			r.AddBreak() // Ajoute un saut de ligne après le nouveau texte si nécessaire

			// Insérer un nouveau paragraphe avant le paragraphe courant
			newParaBefore := doc.InsertParagraphBefore(p)
			newParaBefore.AddRun().AddText("Ajout avant.")

			// Insérer un nouveau paragraphe après le paragraphe courant
			newParaAfter := doc.InsertParagraphAfter(p)
			newParaAfter.AddRun().AddText("Ajout après.")
		}
	}
}

// Sauvegarder le document modifié
err = doc.SaveToFile("document_modifie.docx")
if err != nil {
	log.Fatalf("Erreur lors de la sauvegarde du document modifié : %s", err)
}

7. Ajout de Filigranes (Watermarks)

La bibliothèque ne propose pas de fonction directe pour les filigranes. Une méthode consiste à utiliser un document modèle pré-existant contenant déjà le filigrane. Le nouveau contenu est ensuite ajouté à ce modèle.

// Ouvrir un modèle qui contient déjà le filigrane
doc, err := document.Open("modele_avec_filigrane.docx")
if err != nil {
	log.Fatalf("Erreur lors de l'ouverture du modèle : %s", err)
}

// Ajouter le contenu textuel
content := "Texte principal du document."
newPara := doc.AddParagraph()
newRun := newPara.AddRun()
newRun.AddText(content)

// Pour ajouter une nouvelle page (sans filigrane si le modèle n'en a pas deux)
// Si vous avez besoin de nouvelles pages avec filigrane, le modèle doit avoir plusieurs pages vierges filigranées.
// newPara.Properties().AddSection(wml.ST_SectionMarkNextPage)

// Sauvegarder le document final
err = doc.SaveToFile("document_final_avec_filigrane.docx")
if err != nil {
	log.Fatalf("Erreur lors de la sauvegarde du document final : %s", err)
}