Contribuez à la FAQ BIRT [FAQ]

[Fleur-Anne.Blain]

Bonjour,

Enfin la FAQ BIRT est arrivée Grâce à votre participation 30 Questions/Réponses pour vous aidez sont déjà proposées.

N'hésitez pas à participer

Pour cela, veuillez ajouter à ce topic vos suggestions de questions / réponses.
Les remarques pertinentes seront ainsi ajoutées à la FAQ.

Pour proposer une Q/R, merci de bien vouloir procéder comme ci-dessous :

[QR] Comment présenter la question ?

Techno(s) utilisée(s) de BIRT : xxx

La Q/R doit commencer par un texte introductif pour poser clairement et
brièvement le problème et donner la démarche pour le résoudre.

Code :

Toute formule doit être mise en balise code.

Les noms de fonctions ou mots clés doivent être mis en gras. Vous pouvez également utiliser le soulignement ou l'italique dans votre texte; mais ne modifiez pas la taille du texte.

Merci à tous de votre collaboration

[EDIT BiM 25/02/2011]
A ajouter : 18
A mettre à jour : 2
[/EDIT]

[Stefan C]

Voici un lien vers la FAQ complète de BIRT rendue publique.

http://www.birt-exchange.com/modules...g_BIRT_Reports

A votre dispo pour le partage des modules à traduire.

Je pense que la création de rapports et des charts serait à privilègier dans un premier temps

Egalement voici un lien vers la BIRT Report API

http://www.birt-exchange.com/documen...w-summary.html


RAJOUT : Confirmation officielle de M. Rich Guth , VP Actuate ( Java Reporting Group ) sur l'authorisation de traduire la FAQ de BIRT en français

[openbizz]

Bonjour,

En utilisant la méthode de lazarel sous BIRT 2.3.0 cela ne fonctionne que si je mets le paramètre en dur.

Pour que cela fonctionne il a fallu rajouter le fonction Array.join() à la suite de "params["type"].value" pour obtenir :

Code :

params["type"].value.join().replace(/,/g,"','")

Olivier,
OpenBizz

Envoyé par BiM

Sans savoir forcément (savoir) y répondre, quelles questions vous paraitraient pertinentes en supplément de celles déjà posées ?

Merci.

Ca, pour ça je suis baleze !

[Q]Comment mettre certaines valeurs d'un graphique en couleur selon des critères de valeur/ordre/arbitraire via du code Java avec Birt Engine ?

[Q]Comment mettre en évidence certaines valeurs d'un graphique (Highlighting) lorsque'on les survol avec la souris (Toujours avec Birt Engine)?

[Fleur-Anne.Blain]

Bonjour,


Enfin la FAQ BIRT est arrivée Grâce à votre participation 30 Questions/Réponses pour vous aidez sont déjà proposées.

N'hésitez pas à participer

[Ar3s.]

Ca c'est une très bonne nouvelle pour le jeune stagiaire, qui travail avec BIRT, que je suis.
Birt est un framework très complet, disposant d'énormement de possibilités mais il manque cruellement d'une bonne documentation.

Longue vie à cette FAQ!

[BiM]

Comment rediriger et/ou changer le niveau de log de BIRT ?

En appel Java, il est possible de configurer le niveau de log comme ceci :

Code Java :

engine.changeLogLevel(Level.ERROR);

engine étant de type IReportEngine (ou implémentation).

On peut également le modifier au niveau de la configuration :

Code Java :

config.setLogConfig(IEngineConfig.LOG_DESTINATION, Level.ERROR);

config étant de type EngineConfig.

Sur chacun de ces deux objets, il est possible d'attribuer un autre logger (pour avoir les logs dans un fichier commun à l'application par exemple).

En batch, ce n'est à priori pas possible.

Et via l'utilisation des taglib, on peut le faire via le web.xml : http://www.eclipse.org/birt/phoenix/...erUsage2.2.php

[BiM]

Quelle est la différence entre le Design Engine API (DEAPI) et le Report Engine API (REAPI) ?

Il faut distinguer le DesignEngine du ReportEngine. Un DesignEngine sert à dessiner un rapport alors que le ReportEngine sert à générer le rapport. Pour quelques éléments simples il est possible de modifier ou créer des petites choses dans un rapport directement à partir du ReportEngine.

Voici un exemple d'instanciation pour chaque moteur :

• Report Engine
  
  Code Java :

  1
  2
  3
  4
  5
  EngineConfig config = new EngineConfig();
  config.setBIRTHome("Emplacement de mon dossier runtime/ReportEngine");	//endroit où se trouvent les librairies du Runtime
  Platform.startup(config);
  IReportEngineFactory factory = (IReportEngineFactory) Platform.createFactoryObject(IReportEngineFactory.EXTENSION_REPORT_ENGINE_FACTORY);
  IReportEngine engine = factory.createReportEngine(config);

• Design Engine
  
  Code Java :

  1
  2
  3
  4
  5
  DesignConfig designConfig = new DesignConfig();
  designConfig.setBIRTHome("Emplacement de mon dossier runtime/ReportEngine");
  Platform.startup(designConfig);
  IDesignEngineFactory designFactory = (IDesignEngineFactory)Platform.createFactoryObject(IDesignEngineFactory.EXTENSION_DESIGN_ENGINE_FACTORY);
  IDesignEngine designEngine = designFactory.createDesignEngine(designConfig);

[BiM]

Comment détecter si un rapport contient des données ?

Pour cela, il faut bien séparer les étapes Run & Render. De plus, cette opération peut uniquement être effectuée via du code Java. Ce qui veut dire que cela implique l'utilisation de l'API BIRT.

L'opération doit être faite entre la tâche Run et la tâche Render à partir du Report Document (*.rptdocument) récupéré après avoir effectué la tâche Run.

Voici comment détecter si un rapport contient des données. A partir de là, on peut prévenir l'utilisateur que le rapport n'a pas de données et empêcher le rendu :

Code Java :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
/**
 * Méthode détectant si au moins un DataSet contient des données
 * @param doc Document généré par BIRT
 * @return VRAI si le rapport contient des données, FAUX s'il n'y a pas de données dans le rapport
 * @throws BirtException
 */
private boolean hasData(IReportDocument doc) throws BirtException {
	/* Récupération des données du rapport */
	IDataExtractionTask dataExtractionTask = engine.createDataExtractionTask(doc);
	List<IResultSetItem> resultSetList = (List<IResultSetItem>) dataExtractionTask.getResultSetList();
 
	/* Pour chaque ResultSet récupéré */
	for (IResultSetItem resultItem : resultSetList) {
		/* Récupération des données du DataSet */
		dataExtractionTask.selectResultSet(resultItem.getResultSetName());
		IExtractionResults extractionResults = dataExtractionTask.extract();
 
		/* Contrôle des données dans le DataSet */
		if (extractionResults != null) {
			IDataIterator dataIterator = extractionResults.nextResultIterator();
			if (dataIterator != null && dataIterator.next()) {
				System.out.println("Le dataset a des données");
				return true;
			}
		}
 
		System.out.println("Le dataset n'a pas de données.");
	}
 
	return false;
}

Il est également possible de faire la même chose en listant les noms des DataSet puis en ignorant ceux suffixés par "_ignored" par exemple :

Code Java :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
/**
 * Méthode détectant si au moins un DataSet contient des données en ignorant les DataSets suffixés par "_ignored"
 * @param doc Document généré par BIRT
 * @return VRAI si le rapport contient des données, FAUX s'il n'y a pas de données dans le rapport
 * @throws BirtException
 */
private boolean hasDataWithIgnored(IReportDocument doc) throws BirtException {
	/* Récupération des données du rapport */
	IDataExtractionTask dataExtractionTask = engine.createDataExtractionTask(doc);
	List<IResultSetItem> resultSetList = (List<IResultSetItem>) dataExtractionTask.getResultSetList();
 
	/* Pour chaque ResultSet récupéré */
	for (IResultSetItem resultItem : resultSetList) {
		/* Récupération du nom du DataSet par son identifiant */
		String name = resultItem.getResultSetName();
		name = name.replace("ELEMENT_", "");
		ReportItemHandle item = (ReportItemHandle)doc.getReportDesign().getElementByID(Long.valueOf(name));
		name = item.getDataSet().getName();
		System.out.println("Dataset trouvé : " + name);
 
		/* On ignore les dataSets suffixés par "_ignored" */
		if (!name.endsWith("_ignored")) {
			/* Récupération des données du DataSet */
			dataExtractionTask.selectResultSet(resultItem.getResultSetName());
			IExtractionResults extractionResults = dataExtractionTask.extract();
 
			/* Contrôle des données dans le DataSet */
			if (extractionResults != null) {
				IDataIterator dataIterator = extractionResults.nextResultIterator();
				if (dataIterator != null && dataIterator.next()) {
					System.out.println("Le dataset " + name + " a des données");
					return true;
				}
			}
 
			System.out.println("Le dataset " + name + " n'a pas de données.");
		}
		else {
			System.out.println("Le dataSet " + name + " a été ignoré.");
		}
	}
 
	return false;
}

Pour récupérer le nom du DataSet :

• On récupère le ResultSet et on voit à quel élément ce résultat est lié.
• Cependant, le résultat n'est pas lié à un DataSet directement mais à un élément du rapport. Finalement, ce n'est pas le DataSet qui est regardé mais le DataBind. Puisqu'ensuite il peut y avoir des filtres supplémentaires.
• Au final, on récupère le DataSet lié à l'élément puis son nom.

Merci à gronono pour son aide

[BiM]

Comment créer et utiliser un Handler en Java pour remplacer les scripts ?

Dans BIRT, les utilisateurs avancés utilisent souvent des scripts qui permettent de faire des opérations particulières sur le rapport.

Il n'est pas facile de maintenir un rapport BIRT quand les scripts sont directement écrits dans celui-ci. D'autre part, cela empêche la réutilisation de code (à moins de passer par des fonctions définies dans une librairie commune) et donc augmente les risques d'erreurs. Enfin, le déboguage est beaucoup moins évident lorsqu'on a des scripts.

BIRT propose cependant une solution : Externaliser ses scripts dans des Handler Java. Cela demande plusieurs pré-requis :

• Savoir retranscrire du script en Java
• Utiliser l'API pour lancer BIRT (et non le Web Viewer ou l'appel par batch)

Nous allons prendre pour exemple un cas classique de scripts pour un ScriptedDataSet. Ces DataSets permettent notamment de traiter des objets Java pour les insérer dans un DataSet qui sera utilisé dans le rapport.

Il y a deux principales étapes :

• Ecrire le handler :
  
  Code Java :

  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33
  34
  35
  36
  37
  38
  39
  40
  41
  42
  43
  44
  45
  46
  47
  48
  49
  50
  51
  52
  53
  54
  55
  56
  57
  58
  59
  60
  61
  62
  63
  64
  65
  66
  67
  68
  69
  70
  71
  72
  73
  74
  package fr.societe.projet.birt.handler;
   
  import fr.societe.projet.domain.Personne;
   
  import java.util.List;
   
  import org.eclipse.birt.report.engine.api.script.IReportContext;
  import org.eclipse.birt.report.engine.api.script.IScriptedDataSetMetaData;
  import org.eclipse.birt.report.engine.api.script.IUpdatableDataSetRow;
  import org.eclipse.birt.report.engine.api.script.ScriptException;
  import org.eclipse.birt.report.engine.api.script.eventadapter.ScriptedDataSetEventAdapter;
  import org.eclipse.birt.report.engine.api.script.instance.IDataSetInstance;
   
  /**
   * Handler sur un ScriptedDataSet qui contient des objets de type Personne.
   * 
   * @author BiM
   */
  public class PersonneHandler extends ScriptedDataSetEventAdapter {
  	private final static String COL_ID = "Id";
  	private final static String COL_NOM = "Nom";
  	private final static String COL_PRENOM = "Prenom";
  	private final static String COL_SEXE = "Sexe";
  	private final static String COL_AGE = "Age";
   
  	private List<Personne> personnes = null;
  	private int taille = 0;
  	private int enCours = 0;
   
  	@Override
  	public boolean describe(IDataSetInstance dataSet, IScriptedDataSetMetaData metaData) {
  		metaData.addColumn(COL_ID, Long.class);
  		metaData.addColumn(COL_NOM, String.class);
  		metaData.addColumn(COL_PRENOM, String.class);
  		metaData.addColumn(COL_SEXE, Character.class);
  		metaData.addColumn(COL_AGE, Integer.class);
   
  		return true;
  	}
   
  	@Override
  	@SuppressWarnings("unchecked")
  	public void beforeOpen(IDataSetInstance dataSet, IReportContext reportContext) {
  		if (reportContext != null) {
  			personnes = (List<Personne>)reportContext.getParameterValue("Personnes");
   
  			if (personnes != null) {
  				taille = personnes.size();
  			}
  		}
  	}
   
  	@Override
  	public void open(IDataSetInstance dataSet) {
  		enCours = 0;
  	}
   
  	@Override
  	public boolean fetch(IDataSetInstance dataSet, IUpdatableDataSetRow row) throws ScriptException {
  		if (enCours < taille) {
  			Personne personne = personnes.get(enCours);
  			enCours++;
   
  			row.setColumnValue(COL_ID, personne.getId());
  			row.setColumnValue(COL_NOM, personne.getNom());
  			row.setColumnValue(COL_PRENOM, personne.getPrenom());
  			row.setColumnValue(COL_SEXE, personne.getSexe());
  			row.setColumnValue(COL_AGE, personne.getAge());
   
  			return true;
  		}
  		return false;
  	}
  }

• Lier le Handler au DataSet :
  
  Code Java :

  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  /* Lier le Handler au DataSet */
  try {
  	ReportDesignHandle report = (ReportDesignHandle)design.getDesignHandle();
  	ScriptDataSetHandle dataSet = (ScriptDataSetHandle)report.findDataSet("MonDataSet");
  	dataSet.setEventHandlerClass("fr.societe.projet.birt.handler.MonDataSetHandler");
  }
  catch (Exception e) {
  	e.printStackTrace();
  }
   
  /* Exécution */
  IRunTask runTask = engine.createRunTask(design);
   
  /* Paramètres */
  runTask.setParameterValue(clef, parametres.get(clef));
   
  [...]

Vu qu'on récupère un paramètre contenant la liste des personnes, il faut aussi passer ce paramètre au rapport au moment de l'appel à la tâche d'exécution (run).

Dans mon rapport, j'ai simplement un ScriptedDataSet nommé Personnes qui contient cinq colonnes (Id, Nom, Prénom, Sexe, Age) et j'ai glisser/déposer ce tableau dans mon rapport.

[nicolas.1.vives]

Quelles sont les sources de documentation disponibles pour BIRT ?

----
Note : Je propose cette question, en gros, pour m'obliger à arrêter les recherches Google dès que j'ai besoin d'une information. Il n'y a pas des masses de sources différentes pour BIRT, surtout si on réduit sa recherche aux sources francophones, alors autant les lister exhaustivement (en filtrant celles que l'on considère sans intérêt, bien sûr).
Cette réponse n'est qu'une ébauche, qui ne traite que des ressources web, et les commentaires sont très discutables.
----

Plusieurs sites internet sont des sources d'information pour les utilisateurs de BIRT. Il y a plusieurs types d'information différents :
- Tutoriels généraux ou spécifiques
- Documents de références techniques
- Discussion générale (forums)
- Traçage de bugs

La plupart des sites proposent plusieurs types d'information, et/ou des liens vers d'autres sites. Voici les plus importants :

Sources francophones :

• developpez.net : ce site est certainement la principale source francophone, pour ne pas dire la seule. Il propose, en plus de cette FAQ :
  • Un forum (qui est donc LE forum francophone)
  • Des tutoriels
• La traduction française du guide utilisateur (moins à jour que la version anglaise, cf. ci-dessous)
• Le Google User Group France (un peu complètement vide à l'heure actuelle)

Sources anglophones :

• Le site officiel de BIRT qui rassemble la quasi-totalité des informations nécessaires, ou des références vers les autres principales sources ; notamment :
  • Le tutoriel officiel
  • La documentation de la référence technique
• birt-exchange.org, site d'Actuate, société éditrice qui a lancé le projet BIRT. Il contient notamment :
  • LE forum anglophone
  • Un guide utilisateur 2.1, 2.2 et 2.3 très complet (Javadoc, exemples et autres, disponible aussi dans l'aide d'Eclipse)
  • La référence technique (Javadoc)
• La page Wikipedia
• Enfin, Bugzilla permet de rechercher et de suivre l'évolution des bugs détectés

[BiM]

Quels sont les différents types de fichiers existants dans BIRT ?

Modèle (*.rpttemplate)
Permet de créer un nouveau rapport à partir d’un modèle. Ainsi, à la création d’un rapport, on peut faire apparaître les modèles utilisés dans le Designer. Attention, si un modèle est modifié les rapports ne sont pas mis à jour en conséquence. Cependant, cela peut servir pour mettre en place le lien avec les librairies, les CSS et la page maître (entête, pied de page, fond de page, format, marges, etc.).

Librairie (*.rptlibrary)
Permet de mettre en place des objets pour les réutiliser dans les rapports. Ces objets peuvent être des sources de données, des jeux de données, des cubes, des paramètres, des tableaux, des libellés, des tableaux, des grilles, des images, des pages maîtres, des scripts (JavaScript), des thèmes, etc. Une librairie peut-être utilisée dans un template.

Rapport (*.rptdesign)
C’est la représentation d’un rapport. C’est le fichier que l’on va appeler lors de la génération d’un document. On peut lui passer différents paramètres dont la langue et les informations de connexion.

Document (*.rptdocument)
Le document est le format intermédiaire de génération. C’est le format généré avec les données mais pas encore sous son format final : PDF, XLS, DOC, etc. Ce format permet une génération multiple dans différents formats.

Processus
Lors de la création d’un état, on utilise un rapport (*.rptdesign). Un rapport peut-être créé à partir d’un modèle (*.rpttemplate). Le rapport comme le modèle peuvent faire appel à une ou plusieurs librairies (*.rptlibrary), les librairies permettent de disposer d’éléments prédéfinis, en particulier les sources de données et jeux de données.
Lors de la génération il y a deux étapes : run (exécution) et render (rendu). Lors de l’exécution on passe du rapport au document (*.rptdocument). Le document contient tous les éléments (tableaux, libellés, graphiques, etc.) avec les données mais n’est pas affichable tel quel par l’utilisateur avec quelconque logiciel que ce soit. Pour voir ce que donne un document, il faut passer à l’étape de rendu. Dans ce cas, on génère le document final dans le format de son choix (HTML, PDF, XLS, DOC, etc.). Le format document (dérivé du XML) permet d’avoir un format intermédiaire générant effectivement l’état mais sans définir le format final. Ainsi, cela permet de régénérer le document à sa guise et dans le format souhaité.
En résumé :
- Création :
Modèle (*.rpttemplate) <==créé à partir de== Rapport (*.rptdesign) ou Modèle ==dépend de==> Librairie (*.rptlibrary)
Un rapport est toujours créé à partir d’un modèle (au moins celui de base) est n’est pas toujours lié à des librairies.
- Génération :
Rapport (*.rptdesign) ==run==> Document (*.rptdocument) == render==> Fichier final (HTML, PDF, CLS, DOC, etc.)

[Ykk_Jeff]

Quand on construit un chart, l'interface graphique de BIRT permet de changer la couleur des points pour chaque élément au sein d'une même série.
La version 2.6 de BIRT permet même d'attribuer des "patterns" pour chaque point d'une série, cependant, à ce jour il n'est pas possible d'utiliser l'interface graphique du "BIRT Report Designer" pour changer la forme des marqueurs à chaque point d'une série.

Aussi, pour parvenir à réaliser cela, on peut passer par les scripts de BIRT.

Voici un exemple qui permet de changer la forme des marqueurs d'une série composée de 3 éléments.

Dans la partie "initialize" du rapport, on déclare une variable globale pour mémoriser le numéro du point de graphe à afficher :

Code javascript :

1
2
 
reportContext.setPersistentGlobalVariable("pointNumber","0");

Dans la partie onRender du chart, fonction "beforeDrawMarker": avant de dessiner chaque marquer, on va regarder le numéro du point à dessiner, et lui attribuer un type de marqueur:

Code javascript :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
 
        importPackage(Packages.org.eclipse.birt.chart.model.type.impl);
	importPackage(Packages.org.eclipse.birt.chart.model.attribute.impl);
	importPackage(Packages.org.eclipse.birt.chart.model.attribute);
 
	if (dph ==null)
	{
		marker.setVisible(false);
	}
	else
	{
		this.pointNum = parseInt(icsc.getExternalContext().getScriptable().getPersistentGlobalVariable('pointNumber'));
 
		switch(this.pointNum)
		{
			case 0: 
				marker.setType(MarkerType.CROSS_LITERAL);
				marker.setSize(5);
				break;
			case 1:
				marker.setType(MarkerType.STAR_LITERAL);
				marker.setSize(5);
				break;
			default:
				marker.setType(MarkerType.FOUR_DIAMONDS_LITERAL);
				marker.setSize(5);
			break;		
		}
		if (this.pointNum<2)
		this.pointNum++;
		else
		this.pointNum=0;
 
 
		icsc.getExternalContext().getScriptable().setPersistentGlobalVariable("pointNumber",this.pointNum.toString());
                }
         }

Voir http://www.eclipse.org/birt/phoenix/...kerscripts.png pour un autre exemple de modification dynamique des marqueurs d'un graphe sous BIRT.

[David55]

Comment rendre le viewer de BIRT en français ?

- dézipper viewservlets.jar (birt-viewer\WEB-INF\lib) - dans le dossier dé-zippé, ajouter dans le dossier org\eclipse\birt\report\resource le ficher Messages_fr.properties (fournie dans un fichier zip en pièce jointe)
- rezipper le tout 'viewservlets.zip': attention à ne pas créer un niveau de plus dans l'arborescence du zip
- renommer en viewservlets.jar (donc écraser l'ancien)
- modifier la valeur BIRT_VIEWER_LOCALE dans le fichier birt-viewer\WEB-INF\web.xml de "en-US" à "fr-FR"

Code :

1
2
3
4
<context-param>
<param-name>BIRT_VIEWER_LOCALE</param-name>
<param-value>fr_FR</param-value>
</context-param>

Si le Viewer est intégré à eclipse et/ou au RCP:
Même démarche avec le fichier org.eclipse.birt.report_[version].jar



_______________________________________

Note: Synthèse d'une conversation.
Solutions proposées par BIM, miaou et 46_Alex

[xavier.rouviere]

Bonjour,

Un exemple pour afficher/masquer via un lien un élément dans la vue html d'un report BIRT

[BiM]

MAJ : Comment faire une classe générique de génération BIRT en Java ?

Dans une application J2EE ou RCP, il est possible de créer une classe qui acceptera n'importe quels :

• état BIRT
• nom du fichier de sortie
• nom de document intermédiaire (facultatif)
• format (HTML, PDF, XLS, PPT, DOC, PostScript ou autre si emitter supplémentaire)
• paramètres
• langue (s'il y a internationalisation de l'état à la norme I18N ou L10N)

Cette classe gère également la gestion des conflits grâce à ses méthodes synchronized et la division des étapes de génération et de rendu.

Code Java :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
import java.util.Locale;
import java.util.Map;
 
import org.eclipse.birt.core.exception.BirtException;
import org.eclipse.birt.core.framework.Platform;
import org.eclipse.birt.report.engine.api.EngineConfig;
import org.eclipse.birt.report.engine.api.EngineException;
import org.eclipse.birt.report.engine.api.IRenderOption;
import org.eclipse.birt.report.engine.api.IRenderTask;
import org.eclipse.birt.report.engine.api.IReportDocument;
import org.eclipse.birt.report.engine.api.IReportEngine;
import org.eclipse.birt.report.engine.api.IReportEngineFactory;
import org.eclipse.birt.report.engine.api.IReportRunnable;
import org.eclipse.birt.report.engine.api.IRunTask;
import org.eclipse.birt.report.engine.api.RenderOption;
 
/**
 * Cette classe permet la génération dans n'importe quel format
 * de n'importe quelle édition.
 * Il faut d'abord l'instancier, puis on lance le rapport et on
 * fait le rendu.
 * Si nécessaire, cette classe peut être threadée facilement.
 * 
 * @author BiM
 *
 */
public final class Edition {
	private static final String ENGINE_PATH = "D:\\birt-runtime-2_6_1\\ReportEngine";
	private static final String REPORT_PATH = "C:\\MesRapports\\";
	private static Edition m_Instance = null;
	private IReportEngine engine;
 
	/**
	 * Constructeur.
	 * Il configure le moteur BIRT de sorte à ce qu'il puisse retrouver
	 * les ressources BIRT mais également les librairies le faisant tourner
	 * Il est alors démarré avec cette configuration.
	 * @throws BirtException
	 */
	private Edition() throws BirtException {
		EngineConfig config = new EngineConfig();
		config.setBIRTHome(ENGINE_PATH);
		Platform.startup(config);
		IReportEngineFactory factory = (IReportEngineFactory) Platform
			.createFactoryObject(IReportEngineFactory.EXTENSION_REPORT_ENGINE_FACTORY);
		engine = factory.createReportEngine(config);
	}
 
	/**
	 * Instanciation du service.
	 * @return l'instance en cours du service
	 * @throws BirtException
	 */
	public static synchronized Edition getInstance() throws BirtException {
		if (m_Instance == null) {
			m_Instance = new Edition();
		}
		return m_Instance;
	}
 
	/**
	 * Génération de l'état.
	 * @param _input Nom du fichier d'entrée sans l'extension (rptdesign), le fichier de sortie portera le même nom
	 * @param _langue Locale pour définir la langue de génération du rapport
	 * @param _parameters Map contenant les paramètres du rapport sous la forme <Nom, Valeur>
	 * @throws EngineException 
	 */
	public synchronized void run(String _input, Locale _langue, Map<String, Object> _parameters) throws EngineException {
		this.run(_input, _input, _langue, _parameters);
	}
 
	/**
	 * Génération de l'état.
	 * @param _input Nom du fichier d'entrée sans l'extension (rptdesign)
	 * @param _output Nom du fichier de sortie sans l'extension (rptdocument)
	 * @param _langue Locale pour définir la langue de génération du rapport
	 * @param _parameters Map contenant les paramètres du rapport sous la forme <Nom, Valeur>
	 * @throws EngineException 
	 */
 	public synchronized void run(String _input, String _output, Locale _langue, Map<String, Object> _parameters) throws EngineException {
		IRunTask runTask = null;
		try {
			/* Récupération du rptDesign */
			IReportRunnable design = engine.openReportDesign(REPORT_PATH + _input + ".rptdesign");
 
			/* Création de la tâche d'éxécution */
			runTask = engine.createRunTask(design);
 
			/* Paramètres */
			runTask.setParameterValues(_parameters);
 
			/* Langue */
			runTask.setLocale(_langue);
 
			/* Exécution */
			runTask.run(REPORT_PATH + _output + ".rptdocument");
		}
		finally {
			if (runTask != null) {
				runTask.close();
			}
		}
	}
 
	/**
	 * Rendu de l'état.
	 * @param _input Nom du fichier d'entrée sans l'extension (rptdocument)
	 * @param _format Format de sortie du fichier
	 * @throws EngineException
	 */
 	public synchronized void render(String _input, String _format) throws EngineException {
 		this.render(_input, _input, _format);
 	}
 
	/**
	 * Rendu de l'état.
	 * @param _input Nom du fichier d'entrée sans l'extension (rptdocument), le fichier de sortie portera le même nom.
	 * @param _output Nom du fichier de sortie sans l'extension (format final)
	 * @param _format Format de sortie du fichier
	 * @throws EngineException
	 */
	public synchronized void render(String _input, String _output, String _format) throws EngineException {
		IReportDocument doc = null;
		IRenderTask renderTask = null;
		try {
			/* Création des options de rendu */
			IRenderOption option = new RenderOption();
 
			/* Fichier et format de sortie */
			option.setOutputFileName(REPORT_PATH + _output + "." + _format);
			option.setOutputFormat(_format);
 
			/* Récupération du rptDocument */
			doc = engine.openReportDocument(REPORT_PATH + _input + ".rptdocument");
 
			/* Rendu */
			renderTask = engine.createRenderTask(doc);
 
			/* Chargement des options de rendu */
			renderTask.setRenderOption(option);
 
			/* Création du fichier de rendu */
			renderTask.render();
		}
		finally {
			if (renderTask != null) {
				renderTask.close();
			}
			if (doc != null) {
				doc.close();
			}
		}
	}
 
	/**
	 * Permet de détruire le moteur de façon propre.
	 */
	public void destructeur() {
		engine.destroy();
		Platform.shutdown();
		m_Instance = null;
	}
}

Pour lancer l'édition. Il suffira de faire :

Code Java :

1
2
3
4
5
6
7
8
9
10
11
try
{
	Edition ed = Edition.getInstance();
	ed.run("monRapport", Locale.FRENCH, new HashMap<String, Object>());
	ed.render("monRapport", "monRapportFinal", "pdf");
	ed.destructeur();
}
catch (BirtException e)
{
	e.printStackTrace();
}

Note 1 : Il n'est pas nécessaire de détruire le moteur après chaque instanciation, c'est même déconseillé dans le cas d'applications qui feront potentiellement plusieurs appels à BIRT. L'instanciation du moteur prend plusieurs secondes et est une opération relativement lourde, il faut donc éviter de réinstancier le moteur à chaque utilisation et plutôt reprendre le moteur déjà instancié à chaque fois, en ne le détruisant pas à chaque fin de génération.

Note 2 : Pour les versions anciennes, il y a quelques changements à noter dans le constructeur, particulièrement l'utilisation de la classe org.eclipse.birt.report.engine.api.RenderOptionBase au lieu de classe RenderOption et la méthode setParametersValues(...) qui n'existe pas forcément à remplacer par une boucle et setParameterValue(...).

[lazarel]

Comment appeler un paramètre dans un graphique ?

Dans les graphiques, nous n'avons pas directement accès aux paramètres du rapport, il est cependant possible de les récupérer grâce au contexte du rapport.
Dans chaque méthode scriptable du Chart, on a le paramètre icsc de type IChartScriptContext, on peut alors récupérer le ReportContext qui a accès à toutes sortes d'éléments du rapport, notamment les paramètres :

Code Java :

icsc.getExternalContext().getScriptable().getParameterValue("param");

De la même manière, il est possible d'éditer un paramètre.

[lazarel]

Comment appeler une variable dans un graphique ?

Uniquement les variables persistantes sont accessibles depuis un Chart.
Par exemple, j'en définis une dans l'initialisation du rapport avec le code suivant :

Code java :

reportContext.setPersistentGlobalVariable("toto", "lol");

Dans chaque méthode scriptable du Chart, on a le paramètre icsc de type IChartScriptContext, on peut alors récupérer le ReportContext qui a accès à toutes sortes d'éléments du rapport, notamment les variables persistantes :

Code java :

icsc.getExternalContext().getScriptable().getPersistentGlobalVariable("toto");

Il est également possible de stocker des fonctions dans des variables persistantes

[lazarel]

Comment changer le titre d'un graphique ?

Mode dynamique

Dans le rptdesign au niveau du script du graphique dans la méthode beforeGeneration.

Code java :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
importPackage( Packages.org.eclipse.birt.chart.model.attribute.impl );
importPackage( Packages.org.eclipse.birt.chart.model.data.impl );
/**
 * Called before generation of chart model to GeneratedChartState.
 * 
 * @param chart
 *            Chart
 * @param icsc
 *            IChartScriptContext
 */
 
function beforeGeneration( chart, icsc )
{
	//edit title chart
	var title = "myTitle";
	chart.getTitle().getLabel().getCaption().setValue(title);
}

[lazarel]

Comment accéder aux abscisse/ordonnées d'un graphique ?

Mode dynamique

Dans le rptdesign au niveau du script du graphique dans la méthode beforeGeneration.

Code java :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
importPackage( Packages.org.eclipse.birt.chart.model.attribute.impl );
importPackage( Packages.org.eclipse.birt.chart.model.data.impl );
/**
 * Called before generation of chart model to GeneratedChartState.
 * 
 * @param chart
 *            Chart
 * @param icsc
 *            IChartScriptContext
 */
 
function beforeGeneration( chart, icsc )
{
	//xAxis
	xAxis = chart.getBaseAxes()[0];
	//yAxis
	yAxis = chart.getOrthogonalAxes( xAxis, true)[0];
}