Présentation de l'IDE Geany

IDE Open Source

Alexandre GALODE

Il y a quelques années encore, beaucoup développaient exclusivement sous vi, son fork vim, ou encore dans un simple GEdit. Le temps passant, les choses ont évolué.

De nos jours, tout développeur se doit de disposer d'un IDE qui lui soit agréable à utiliser afin d'optimiser son travail et d'effectuer ce dernier de manière sereine.

Parmi la pléthore d'IDE (EDI en français) open source existants, je vous invite ici à découvrir Geany.

Commentez

- Titre : Présentation de l'IDE Geany

- Auteur : Alexandre GALODE

- Parution : 16 juin 2015

- Mise à jour : 16 juin 2015

- Public visé :

- Licence : Le contenu de cet article est rédigé par GALODE Alexandre et est mis à disposition selon les termes de la Licence Creative Commons Attribution - Pas d'Utilisation Commerciale 3.0 non transposé. Les logos Developpez.com, en-tête, pied de page, css, et look & feel de l'article sont Copyright ® 2013 Developpez.com.

Sommaire

- I. Introduction

- II. Présentation

- II-A. Historique

- II-B. Philosophie

- III. Utilisation

- III-A. Les différents menus

- III-A-1. Menu Fichiers

- III-A-2. Menu Éditer

- III-A-3. Menu Rechercher

- III-A-4. Menu Affichage

- III-A-5. Menu Document

- III-A-6. Menu Projet

- III-A-7. Menu Construire

- III-A-8. Menu Outils

- III-A-9. Menu Aide

- III-B. Paramétrage global de Geany pour Python

- III-C. Paramétrage de la PEP8 et de Pylint

- III-D. Personnalisation de la coloration syntaxique

- III-E. Choix de la coloration syntaxique

- IV. Plugins

- IV-A. Le plugin GProject

- IV-B. Le plugin Additions

- IV-C. Création d'un plugin en Python avec Geanypy

- IV-C-1. Présentation

- IV-C-2. Installation

- IV-C-3. Emplacement des plugins

- IV-C-4. Fichier principal : les bases

- IV-C-5. Les zones d'interactions possibles

- IV-C-6. Obtenir de l'aide

- IV-C-7. Menu

- IV-C-8. Toolbar

- IV-C-9. Progressbar

- IV-C-10. Notebook

- IV-C-11. Fichiers et espaces de fichiers

- IV-C-12. Projet

- IV-C-13. Messages utilisateur

- IV-C-14. Interactions externes

- V. Liens utiles

- VI. Conclusion

- VII. Remerciements

I - Introduction

Afin de travailler efficacement et sereinement, tout développeur se doit de disposer d'un IDE agréable et performant.

Dans cette optique j'ai été amené à en tester un certain nombre. Mes critères se sont alors affinés au fur et à mesure :

- pas d' « usine à gaz » ;

- rapide à charger ;

- possibilité d'avoir des plugins, quitte à les créer moi-même ;

- multiplateformes ;

- gestionnaire de projet intégré ;

- coloration syntaxique ;

- autocomplétion minimale ;

- …

J'ai de fait essayé beaucoup d'IDE avec plus ou moins de succès, de satisfactions, mais le plus souvent de frustrations. Et après un certain nombre d'essais, je suis tombé sur Geany que j'ai depuis lors adopté, également à titre professionnel.

Je vous invite ici à le découvrir, notamment dans le cadre de projet Python.

Geany est disponible sous Linux, Windows et Mac. Sous Linux, il est disponible dans les dépôts. Sous Windows, il existe également en version portable.

Je n'utilise Geany que pour Python (cas traité dans le cadre de ce tutoriel).

Cependant, il ne se limite pas à cela. Vous pourrez l'utiliser pour de nombreux autres langages (C, java, VHDL…).

II - Présentation

II-A - Historique

Historiquement apparu en 2005 (version 0.1), actuellement en version 1.24.1, Geany est un IDE multiplateforme écrit en C++ et en GTK.

Il est placé sous licence GPL V2.

II-B - Philosophie

Geany est un IDE qui n'a pas la prétention d'égaliser Eclipse ou Netbeans. Son but est de fournir un environnement de développement performant et agréable, sans superflu inutile, et avec un démarrage rapide et une interface épurée.

Afin de garantir une certaine adaptabilité, il est possible d'utiliser, voire de créer, des plugins.

III - Utilisation

III-A - Les différents menus

Nous supposerons ici que les plugins Gproject et Additions (et eux seuls) ont été installés.

III-A-1 - Menu Fichiers

Le menu fichier est relativement simple et complet.

On trouve tout d'abord la création d'un nouveau fichier, totalement vierge, ou basé sur des modèles. Dans ce dernier cas, les informations présentes (nom entreprise, développeur…) sont paramétrables dans les préférences de Geany.

Vient ensuite la gestion des fichiers (ouvrir, documents récents, enregistrer, recharger avec un encodage identique ou différent).

Nous avons ensuite les propriétés du document ouvert. La gestion de l'impression, puis la gestion de fermeture des fichiers (fermer le fichier en cours, tous les fichiers excepté le fichier courant, fermer tous les fichiers) et enfin la fermeture même du logiciel.

III-A-2 - Menu Éditer

Les premières entrées sont classiques et se passent de toute explication.

Vient ensuite la section « commandes ». Elle permet d'effectuer des actions vis-à-vis d'une sélection ou des lignes courantes.

La section « Format » permet de gérer lignes, et blocs, en agissant au choix sur le formatage, la casse, les commentaires ou encore l'indentation.

Les deux entrées suivantes vont vous permettre d'insérer facilement des entêtes spécifiques à une licence, ou encore une date préformatée.

Enfin, en bas nous trouvons le paramétrage « Préférences » pour Geany et les plugins.

Seuls les plugins autorisant du paramétrage seront listés ici. Pour les plugins dépendant de Geanypy, ils auront leur propre menu dans le menu « Outils ».

III-A-3 - Menu Rechercher

Les trois premières entrées permettent une recherche spécifique au document courant. Les deux entrées suivantes visent plutôt l'ensemble des documents. Les deux entrées suivantes permettent de naviguer dans l'onglet « Messages » de la fenêtre de message en bas de Geany.

Les deux suivantes permettent de se déplacer entre les différents marqueurs. Vous pouvez en ajouter en cliquant à droite des numéros de ligne.

Je vous invite à modifier par la suite les raccourcis pour cette fonctionnalité.

Vient ensuite le saut de ligne (déjà en accès direct depuis la toolbar), et des fonctionnalités supplémentaires liées à la sélection d'un mot ou d'un ensemble de mots.

III-A-4 - Menu Affichage

Ce menu permet de gérer tout ce qui concerne l'affichage, d'un point de vue logiciel, et pas seulement le code, même si ce dernier compose l'essentiel du menu.

Les premiers sous-menus concernent l'affichage même du code avec le choix de la police et du jeu de couleurs de l'interface.

Vient ensuite le choix d'afficher ou non certains éléments du code (numéro de ligne, caractères de fin de ligne…).

Ensuite, nous avons l'affichage ou non des différentes fenêtres/barres complémentaires de Geany, et la possibilité de passer en plein écran.

Enfin, nous avons la gestion du zoom sur le code (plus, moins, 100 %).

III-A-5 - Menu Document

Le menu document rassemble l'ensemble des commandes liées au document ouvert. Ce menu est appelé à évoluer selon le type de fichier ouvert, et nous allons le décrire ici pour un fichier Python. Il se décompose en six sections.

La première concerne les sauts de ligne et l'indentation spécifique au document.

La seconde concerne le fichier même : type et BOM.

La troisième section concerne les fins de ligne ainsi que le type de fichier et son encodage. C'est là que vous pourrez définir le langage que vous désirez utiliser, s'il n'a pas déjà été automatiquement détecté.

Nous trouvons ensuite tout ce qui concerne la manipulation de fichiers.

La section suivante permet de manipuler d'un coup l'affichage des différentes fonctions et classes à l'écran.

Enfin, nous trouvons la suppression des marqueurs et des erreurs, servant pour du débogage.

III-A-6 - Menu Projet

Le menu Projet de base offert par Geany est un peu déconcertant. C'est pourquoi nous aurons installé préalablement le plugin « GProject » permettant de rendre plus rationnelle et traditionnelle la gestion de projet.

Ce menu est décomposé en quatre sections.

En premier, la gestion globale de projet (nouveau, ouvrir, projets récents, fermer).

Vient ensuite l'indentation à utiliser : celle définie en global dans Geany, ou celle définie spécifiquement pour le projet. Si on remodifie l'indentation spécifique du projet, elle reprend le pas.

Ensuite les propriétés du projet (nom, description, indentation…).

Enfin la section navigation à travers les fichiers/dossiers du projet.

III-A-7 - Menu Construire

Ce menu permet de regrouper l'ensemble des commandes utiles pour l'ensemble des étapes possibles d'une compilation ou d'une interprétation du code.

Les commandes sont entièrement personnalisables (de même que le nom des sous-menus) et de ce fait, nous ne pourrons détailler ici précisément le contenu de ce menu.

III-A-8 - Menu Outils

Ce menu sert assez peu souvent et se décompose en trois sections.

En premier, les fichiers de configuration de Geany, que je vous recommande de ne pas toucher.

En second, quelques outils.

Enfin, la gestion des plugins. C'est ici que nous pourrons installer GProject et additions.

III-A-9 - Menu Aide

Le menu Aide est décomposé en trois sections.

La première vous permet d'afficher l'aide du logiciel (format HTML), de gérer les raccourcis clavier et d'afficher la console de débogage.

La seconde vous permet d'afficher le site web de Geany, d'accéder directement au wiki, de rapporter un bogue ou encore de faire un don.

Enfin la troisième ne vous permettra que d'afficher la classique fenêtre « À propos de… ».

III-B - Paramétrage global de Geany pour Python

Rendez-vous dans le menu « Éditer », et cliquez sur « préférences ».

Le paramétrage des préférences disposant de nombreuses bulles d'aide, nous ne passerons en revue que les éléments importants dans le cadre d'un développement Python.

Cliquez sur l'onglet « Éditeur ». Sur le second sous-onglet, cochez «Espaces » à la place de « Tabulations ».

Sur le dernier sous-onglet, changez le 72 en 100 et cochez « Afficher les guides d'indentation » et « Afficher les espaces ».

Cliquez ensuite sur l'onglet « Fichier », et dans la section « Enregistrements des fichiers », cochez « Enlever les espaces et tabulations de fins » et « Remplacer les tabulations par des espaces ».

Cliquez ensuite sur l'onglet « Modèles » et renseignez les informations vous concernant. Ces informations sont partiellement reprises à la création d'un projet.

Il ne vous reste plus qu'à valider le tout et votre Geany est configuré.

III-C - Paramétrage de la PEP8 et de Pylint

La PEP8 permet de rallier l'ensemble des développeurs Python autour de règles fortement recommandées pour un code propre et efficace.

Pylint permet de s'assurer du respect d'un certain nombre de règles complémentaires à PEP8, principalement sur la mise en forme du code.

En résumé donc, en intégrant le contrôle de ces règles directement dans Geany, nous avons la possibilité de nous assurer d'un minimum de qualité pour notre code.

Cependant, avant de voir comment faire, quelques petites précisions. Dans les deux cas, il est possible de spécifier des codes erreurs à ne pas tenir compte, de même que des conditions spécifiques.

Dans mon cas par exemple, voici les paramétrages et écarts de ma configuration :

- Ligne de 100 caractères maximum ;

- Ignorer l'erreur E251 (des espaces doivent exister autour de « = »).

Et voici pour Pylint :

- Ignorer l'erreur W0702 (spécifier le type d'exception) ;

- Ignorer l'erreur W0201 (toutes les variables d'une classe définies dans le init) ;

- Ignorer l'erreur C0325 (utilisation inutile de parenthèses) ;

- Ignorer l'erreur R0902 (trop d'attributs pour l'instance en cours) ;

- Ignorer l'erreur R0912 (trop de branches) ;

- Ignorer l'erreur R0914 (trop de variables locales).

Concernant Pylint, il vous faudra générer un fichier de configuration. Il faut utiliser la commande suivante :

pylint --generate-rcfile > ./my_rc_file.rc

Une fois le fichier standard généré, vous pourrez le personnaliser. Pour information, voici mon fichier :

pylint_config.rc

1. [MASTER]

3. # Specify a configuration file.

4. #rcfile=

6. # Python code to execute, usually for sys.path manipulation such as

7. # pygtk.require().

8. #init-hook=

10. # Profiled execution.

11. profile=no

13. # Add files or directories to the blacklist. They should be base names, not

14. # paths.

15. ignore=CVS

17. # Pickle collected data for later comparisons.

18. persistent=yes

20. # List of plugins (as comma separated values of python modules names) to load,

21. # usually to register additional checkers.

22. load-plugins=

24. # DEPRECATED

25. # include-ids=no

27. # DEPRECATED

28. # symbols=no

31. [MESSAGES CONTROL]

33. # Enable the message, report, category or checker with the given id(s). You can

34. # either give multiple identifier separated by comma (,) or put this option

35. # multiple time. See also the "--disable" option for examples.

36. #enable=

38. # Disable the message, report, category or checker with the given id(s). You

39. # can either give multiple identifiers separated by comma (,) or put this

40. # option multiple times (only on the command line, not in the configuration

41. # file where it should appear only once).You can also use "--disable=all" to

42. # disable everything first and then reenable specific checks. For example, if

43. # you want to run only the similarities checker, you can use "--disable=all

44. # --enable=similarities". If you want to run only the classes checker, but have

45. # no Warning level messages displayed, use"--disable=all --enable=classes

46. # --disable=W"

47. disable=W0702,W0201,C0325,R0902,R0912,R0914

50. [REPORTS]

52. # Set the output format. Available formats are text, parseable, colorized, msvs

53. # (visual studio) and html. You can also give a reporter class, eg

54. # mypackage.mymodule.MyReporterClass.

55. output-format=text

57. # Put messages in a separate file for each module / package specified on the

58. # command line instead of printing them on stdout. Reports (if any) will be

59. # written in a file name "pylint_global.[txt|html]".

60. files-output=no

62. # Tells whether to display a full report or only the messages

63. reports=no

65. # Python expression which should return a note less than 10 (10 is the highest

66. # note). You have access to the variables errors warning, statement which

67. # respectively contain the number of errors / warnings messages and the total

68. # number of statements analyzed. This is used by the global evaluation report

69. # (RP0004).

70. evaluation=10.0 - ((float(5 * error + warning + refactor + convention) / statement) * 10)

72. # Add a comment according to your evaluation note. This is used by the global

73. # evaluation report (RP0004).

74. comment=no

76. # Template used to display messages. This is a python new-style format string

77. # used to format the message information. See doc for all details

78. #msg-template=

81. [BASIC]

83. # Required attributes for module, separated by a comma

84. required-attributes=

86. # List of builtins function names that should not be used, separated by a comma

87. bad-functions=map,filter,apply,input,file

89. # Good variable names which should always be accepted, separated by a comma

90. good-names=i,j,k,ex,Run,_

92. # Bad variable names which should always be refused, separated by a comma

93. bad-names=foo,bar,baz,toto,tutu,tata

95. # Colon-delimited sets of names that determine each other's naming style when

96. # the name regexes allow several styles.

97. name-group=

99. # Include a hint for the correct naming format with invalid-name

100. include-naming-hint=no

102. # Regular expression matching correct function names

103. function-rgx=[a-z_][a-z0-9_]{2,30}$

105. # Naming hint for function names

106. function-name-hint=[a-z_][a-z0-9_]{2,30}$

108. # Regular expression matching correct variable names

109. variable-rgx=[a-z_][a-z0-9_]{2,30}$

111. # Naming hint for variable names

112. variable-name-hint=[a-z_][a-z0-9_]{2,30}$

114. # Regular expression matching correct constant names

115. const-rgx=(([A-Z_][A-Z0-9_]*)|(__.*__))$

117. # Naming hint for constant names

118. const-name-hint=(([A-Z_][A-Z0-9_]*)|(__.*__))$

120. # Regular expression matching correct attribute names

121. attr-rgx=[a-z_][a-z0-9_]{2,30}$

123. # Naming hint for attribute names

124. attr-name-hint=[a-z_][a-z0-9_]{2,30}$

126. # Regular expression matching correct argument names

127. argument-rgx=[a-z_][a-z0-9_]{2,30}$

129. # Naming hint for argument names

130. argument-name-hint=[a-z_][a-z0-9_]{2,30}$

132. # Regular expression matching correct class attribute names

133. class-attribute-rgx=([A-Za-z_][A-Za-z0-9_]{2,30}|(__.*__))$

135. # Naming hint for class attribute names

136. class-attribute-name-hint=([A-Za-z_][A-Za-z0-9_]{2,30}|(__.*__))$

138. # Regular expression matching correct inline iteration names

139. inlinevar-rgx=[A-Za-z_][A-Za-z0-9_]*$

141. # Naming hint for inline iteration names

142. inlinevar-name-hint=[A-Za-z_][A-Za-z0-9_]*$

144. # Regular expression matching correct class names

145. class-rgx=[A-Z_][a-zA-Z0-9]+$

147. # Naming hint for class names

148. class-name-hint=[A-Z_][a-zA-Z0-9]+$

150. # Regular expression matching correct module names

151. module-rgx=(([a-z_][a-z0-9_]*)|([A-Z][a-zA-Z0-9]+))$

153. # Naming hint for module names

154. module-name-hint=(([a-z_][a-z0-9_]*)|([A-Z][a-zA-Z0-9]+))$

156. # Regular expression matching correct method names

157. method-rgx=[a-z_][a-z0-9_]{2,30}$

159. # Naming hint for method names

160. method-name-hint=[a-z_][a-z0-9_]{2,30}$

162. # Regular expression which should only match function or class names that do

163. # not require a docstring.

164. no-docstring-rgx=__.*__

166. # Minimum line length for functions/classes that require docstrings, shorter

167. # ones are exempt.

168. docstring-min-length=-1

171. [MISCELLANEOUS]

173. # List of note tags to take in consideration, separated by a comma.

174. notes=FIXME,XXX,TODO

177. [SIMILARITIES]

179. # Minimum lines number of a similarity.

180. min-similarity-lines=4

182. # Ignore comments when computing similarities.

183. ignore-comments=yes

185. # Ignore docstrings when computing similarities.

186. ignore-docstrings=yes

188. # Ignore imports when computing similarities.

189. ignore-imports=no

192. [FORMAT]

194. # Maximum number of characters on a single line.

195. max-line-length=100

197. # Regexp for a line that is allowed to be longer than the limit.

198. ignore-long-lines=^\s*(# )?<?https?://\S+>?$

200. # Allow the body of an if to be on the same line as the test if there is no

201. # else.

202. single-line-if-stmt=no

204. # List of optional constructs for which whitespace checking is disabled

205. no-space-check=trailing-comma,dict-separator

207. # Maximum number of lines in a module

208. max-module-lines=10000

210. # String used as indentation unit. This is usually " " (4 spaces) or "\t" (1

211. # tab).

212. indent-string='    '

214. # Number of spaces of indent required inside a hanging or continued line.

215. indent-after-paren=4

218. [TYPECHECK]

220. # Tells whether missing members accessed in mixin class should be ignored. A

221. # mixin class is detected if its name ends with "mixin" (case insensitive).

222. ignore-mixin-members=yes

224. # List of module names for which member attributes should not be checked

225. # (useful for modules/projects where namespaces are manipulated during runtime

226. # and thus extisting member attributes cannot be deduced by static analysis

227. ignored-modules=

229. # List of classes names for which member attributes should not be checked

230. # (useful for classes with attributes dynamically set).

231. ignored-classes=SQLObject

233. # When zope mode is activated, add a predefined set of Zope acquired attributes

234. # to generated-members.

235. zope=no

237. # List of members which are set dynamically and missed by pylint inference

238. # system, and so shouldn't trigger E0201 when accessed. Python regular

239. # expressions are accepted.

240. generated-members=REQUEST,acl_users,aq_parent

243. [LOGGING]

245. # Logging modules to check that the string format arguments are in logging

246. # function parameter format

247. logging-modules=logging

250. [VARIABLES]

252. # Tells whether we should check for unused import in __init__ files.

253. init-import=no

255. # A regular expression matching the name of dummy variables (i.e. expectedly

256. # not used).

257. dummy-variables-rgx=_$|dummy

259. # List of additional names supposed to be defined in builtins. Remember that

260. # you should avoid to define new builtins when possible.

261. additional-builtins=

264. [CLASSES]

266. # List of interface methods to ignore, separated by a comma. This is used for

267. # instance to not check methods defines in Zope's Interface base class.

268. ignore-iface-methods=isImplementedBy,deferred,extends,names,namesAndDescriptions,queryDescriptionFor,getBases,getDescriptionFor,getDoc,getName,getTaggedValue,getTaggedValueTags,isEqualOrExtendedBy,setTaggedValue,isImplementedByInstancesOf,adaptWith,is_implemented_by

270. # List of method names used to declare (i.e. assign) instance attributes.

271. defining-attr-methods=__init__,__new__,setUp

273. # List of valid names for the first argument in a class method.

274. valid-classmethod-first-arg=cls

276. # List of valid names for the first argument in a metaclass class method.

277. valid-metaclass-classmethod-first-arg=mcs

280. [DESIGN]

282. # Maximum number of arguments for function / method

283. max-args=5

285. # Argument names that match this expression will be ignored. Default to name

286. # with leading underscore

287. ignored-argument-names=_.*

289. # Maximum number of locals for function / method body

290. max-locals=15

292. # Maximum number of return / yield for function / method body

293. max-returns=6

295. # Maximum number of branch for function / method body

296. max-branches=12

298. # Maximum number of statements in function / method body

299. max-statements=50

301. # Maximum number of parents for a class (see R0901).

302. max-parents=7

304. # Maximum number of attributes for a class (see R0902).

305. max-attributes=7

307. # Minimum number of public methods for a class (see R0903).

308. min-public-methods=2

310. # Maximum number of public methods for a class (see R0904).

311. max-public-methods=20

314. [IMPORTS]

316. # Deprecated modules which should not be used, separated by a comma

317. deprecated-modules=regsub,TERMIOS,Bastion,rexec

319. # Create a graph of every (i.e. internal and external) dependencies in the

320. # given file (report RP0402 must not be disabled)

321. import-graph=

323. # Create a graph of external dependencies in the given file (report RP0402 must

324. # not be disabled)

325. ext-import-graph=

327. # Create a graph of internal dependencies in the given file (report RP0402 must

328. # not be disabled)

329. int-import-graph=

332. [EXCEPTIONS]

334. # Exceptions that will emit a warning when being caught. Defaults to

335. # "Exception"

336. overgeneral-exceptions=Exception

Déposez ce fichier dans un endroit de votre choix. Pour la suite de notre démonstration, ce chemin sera « /home/lm17/pylint_config.rc ».

Maintenant, passons à la configuration dans Geany. Allez dans le menu « Construire » et cliquez sur « Définir les commandes de constructions ».

Nous allons modifier la section « Commandes pour Python ». En cliquant sur un bouton sur la gauche de la fenêtre, vous pourrez modifier le titre de la commande dans le menu.

Comme vous pouvez le constater, cette section dispose de quatre lignes. Voici ce qu'il faut alors saisir :

Titre

valeur

PEP8

pep8 --max-line-length 100 --ignore=E251 "%f"

Pylint

pylint -rcfile="/home/lm17/pylint_config.rc" --msg-template='{path}:{line}: [{msg_id}, {symbol}, {obj}] {msg}' "%f"

Compiler

python -m py_compile "%f"

([^:]+):([0-9]+):([0-9:]+)? .*

Voilà, Geany est maintenant configuré et vous trouverez les sous-menus mis à jour.

Comme vous pouvez le constater, un simple appui sur F8 et F9 vous permettra désormais de vérifier que votre code respecte la PEP8 et les règles de base, via Pylint.

Votre code n'en sera alors qu'amélioré.

Afin que tout fonctionne correctement, n'oubliez pas d'installer en sus PEP8 et Pylint sur votre machine.

III-D - Personnalisation de la coloration syntaxique

Geany est basé sur Scintilla. À ce titre, il hérite des lexers de ce dernier. Nous n'allons pas ici voir comment créer un lexer de toute pièce, car cela est assez complexe, et est plus lié à Scintilla qu'à Geany.

Cependant, nous allons aborder la personnalisation de lexer sous Geany. Entendez par là que nous allons hériter d'un lexer existant, et personnaliser les mots clés et les couleurs.

Pour cela, nous interviendrons à deux niveaux :

- le fichier de configuration filetypes.common ;

- un fichier, que nous créerons, filetypes.<nom_du_langage>.conf.

Avant de plonger plus avant dans ces fichiers, détaillons le fonctionnement de la coloration sous Geany.

À chaque type (commentaire, ligne de code, entête…) correspond un style. Ce style peut être détaillé ou tout ou partie hérité depuis un autre type. L'exemple qui suit sera plus parlant

1. comment=0xd00000

2. comment_doc=0x3f5fbf

3. comment_line=comment

4. comment_line_doc=comment_doc

5. comment_doc_keyword=comment_doc,bold

6. comment_doc_keyword_error=comment_doc,italic

Dans cet exemple, le type comment possède un style simple correspondant juste à une couleur, de même que le type comment_doc. Les deux types suivants, héritent de comment et comment_doc, donc d'une simple couleur. Enfin, les deux derniers types héritent de comment_doc, et on précise en plus que l'un est en gras et l'autre en italique.

Concernant le style à appliquer, vous avez les possibilités suivantes :

Paramètres

Description

0xrrggbb

Valeur d'une couleur RGB en hexadécimal

bold

Mettre le texte en gras

italic

Mettre le texte en italique

Maintenant, voyons comment modifier le fichier « filetype_extensions.conf ». Pour l'ouvrir, rendez-vous dans le menu outils/Fichiers de configuration.

Afin de modifier ce fichier, il vous faudra bénéficier des droits root/administrateurs.

Dans la section [Extensions], veuillez renseigner le nom de votre langage, ainsi que l'extension ou les extensions admises pour les fichiers. Puis, renseignez le nom de votre langage dans la section [Groups], dans le groupe où vous désirez le voir apparaître.

Une fois tout cela fait, il ne vous reste plus qu'à enregistrer le fichier, cliquer sur « Mettre à jour la configuration » dans le menu « Outils », puis à redémarrer Geany.

Toutefois, ce n'est pas encore fini. Nous avons déclaré le langage auprès de Geany, mais il reste à créer le fichier de configuration pour notre langage.

Pour trouver l'emplacement sur votre OS, effectuez une recherche afin de trouver le fichier « filetypes.common ». En effet cet emplacement peut varier d'un PC à l'autre.

Créez ensuite un fichier texte nommé tel que précédemment indiqué.

Le contenu doit ensuite ressembler à ce qui suit :

[build-menu]
FT_00_LB=_Compiler
FT_00_CM=bash /home/kannagi/Documents/SDK/SNES/bin/sms.sh main
FT_00_WD=
EX_00_LB=_Exécuter
EX_00_CM=mednafen main.sms
EX_00_WD=

[styling=ASM]
#default=default
#comment=comment_line
#commentblock=comment
#commentdirective=comment
#number=number_1
#string=string_1
#operator=operator
#identifier=identifier_1
#cpuinstruction=keyword_1
#mathinstruction=keyword_2
#register=type
#directive=preprocessor
#directiveoperand=keyword_3
#character=character
#stringeol=string_eol
#extinstruction=keyword_4

[keywords]
variables=
functions=
labels=
userdefined=
primary=
instructions=adc add and bit call ccf cp cpd cpdr cpi cpir cpl daa dec di djnz ei ex exx halt im in inc inc ind indr ini inir jp jr ld ldd lddr ldr ldir neg nop or otdr otir out outd outi pop push res ret retn rl rla rlc rlca rld rr rra rrc rrca rrd rst sbc scf set sla sra srl sub xor
registers=a b c d e f h l ix iy sp pc hl af bc de
directives=.define .section .bank .org .include .ends .db .macro .endm .memorymap .endme .rombankmap .endro

[indentation]
#width=4

[settings]
extension=mnl

lexer_filetype=ASM

# single comments, like # in this file
comment_single=;
# multiline comments
comment_open=/*
comment_close=*/

Comme nous pouvons le constater, le fichier est décomposé en différentes sections.

Tout d'abord, [build-menu]. Ce menu permet d'indiquer des informations concernant notre langage. Il est défini selon un modèle GG_NN_FF, ou NN est un nombre décimal à deux chiffres, démarrant à 00, valant généralement 00.

GG

Paramètres

Description

FT

Filetype

NF

Non-filetype, independent (non utilisé en général)

EX

Execute

FF

Paramètres

Description

LB

Label

CM

Command

WD

Working directory

Vient ensuite la section [Styling]. Deux solutions ici. Hériter directement de la section mère, auquel cas laissez la section vide (sauf surcharge) et saisissez simplement « [Styling=<nom_du_langage_herité>] », ou bien définir ses propres styles. Dans ce dernier cas, il vous faudra saisir « [Styling] », puis définir simplement vos styles tel que vu précédemment.

La section [Keywords] va permettre de définir les différents mots clés de votre langage. Ils sont séparés par un espace. Les paramètres que l'on peut définir sont :

Paramètres

variables

functions

labels

userdefined

primary

instructions

registers

directives

La section [indentation] permet de définir la valeur par défaut d'une indentation pour votre langage.

Enfin la section la plus importante, la section [Settings]. Cette section doit contenir l'extension de vos fichiers (les mêmes que déclarées dans filetypes.common), le langage hérité, via lexer_filetype, et optionnellement le paramétrage concernant les commentaires.

Une fois tout cela fait, un simple redémarrage de Geany suffira à prendre en compte votre nouveau langage.

III-E - Choix de la coloration syntaxique

Par défaut, Geany lira l'extension de votre fichier et appliquera la coloration syntaxique la plus adaptée. Cas échéant, il préférera n'appliquer aucune coloration.

Cependant, si le choix de Geany ne vous convenait pas, vous avez la possibilité de choisir/forcer une coloration syntaxique en particulier.

Pour cela, il faut vous rendre au menu « Document/Définir le type de fichier ». Les langages sont alors divisés en plusieurs catégories :

- Programmation ;

- Scripting ;

- Markup/Balisage ;

- Divers ;

- None.

None revient à n'appliquer aucune coloration syntaxique. Divers est un peu la catégorie joker, permettant de classer les langages n'entrant dans aucune des catégories précédentes.

Voici maintenant la liste complète des langages disponibles.

Programmation

Scripting

Cython

Abaqus

Go

ActionScript

Scala

Cmake

(O)Caml

Erlang

Ada

Ferite

Assembleur

Forth

C

Javascript

C#

Lisp

C++

Lua

Cobol

Matlab

D

Octave

Fortran F77

NSIS

Fortran F90

Perl

FreeBasic

PHP

GLSL

Python

Haskell

R

Haxe

Ruby

Java

Tcl

Objective-C

Makefile

Pascal

Script Shell

Vala

Verilog

VHDL

Markup

Divers

XML

Abc

Css

Config

AsciiDoc

Gettext

DocBook

Diff

HTML

SQL

Latex

YAML

MarkDown

ReStructuredText

Txt2tags

S'il vous est possible de choisir votre coloration syntaxique pour un document vierge, Geany vous proposera également quelques fichiers préremplis, et ce pour plusieurs langages. Pour cela, rendez-vous dans le menu « Fichier=>Nouveau selon modèle »

IV - Plugins

À mes yeux, voici les trois principaux plugins utiles :

- Additions : permet d'ajouter des fonctionnalités supplémentaires à Geany ;

- GProject : s'interface avec Geany afin de proposer une meilleure gestion de projet ;

- Geanypy : permet la création et l'utilisation de plugins en langage Python.

IV-A - Le plugin GProject

Grâce à GProject, la gestion d'un projet est très simple.

Créez-vous un dossier où sera stocké votre projet. Puis ouvrez le menu « Projet », et cliquez sur « nouveau ».

Dans la fenêtre qui s'ouvre, renseignez le nom du projet, ainsi que le dossier que vous avez précédemment créé.

Dans le dossier ainsi créé, vous trouverez alors un fichier « .geany » qui contient le descriptif de votre projet.

J'ai personnellement l'habitude de créer à cet endroit un sous-dossier au nom du projet afin d'isoler le projet du fichier descriptif du projet.

Rendez-vous ensuite dans le menu « Projet », et cliquez sur « Propriétés ». Apparaît alors une fenêtre avec six onglets.

Sur le premier, vous pouvez paramétrer le nom du projet, son descriptif, son dossier de base, ainsi que les fichiers à prendre en compte (ex. : *.py, *.html, ou plus simplement *.*).

Sur le second vous retrouverez le paramétrage d'indentation pour votre projet. L'indentation doit être réglée sur espaces avec une valeur de 4.

Le troisième onglet sert au paramétrage de l'éditeur. Choisissez un indicateur à 100 caractères.

Le quatrième sert pour configurer l'assistance utilisateur pour les développements

L'onglet suivant sert à paramétrer les règles de construction de votre projet. Par défaut, il s'agit d'une copie des règles de Geany.

Enfin, le dernier onglet permet de paramétrer GProject pour la gestion du projet.

Validez afin de finir de paramétrer votre projet.

Une fenêtre sur votre gauche apparaît alors, onglet « Projet ».

Le bouton en bleu permet de recharger le contenu du dossier projet. Le bouton en vert permet de déplier tous les nœuds (répertoires) contenus dans le dossier Projet, tandis que le rouge permet de les plier. Enfin, le bouton orange, s'il est activé, permet au gestionnaire de projet de suivre sur quel fichier vous vous trouvez, et de le mettre en surbrillance.

IV-B - Le plugin Additions

Ouvrez le menu « Éditer », puis cliquez sur « Préférences des plugins ».

Sur la fenêtre qui s'ouvre, cochez alors « Marquer toutes les occurrences d'un mot lors d'un double-clic » et « Supprimer les lignes vides à la fin d'un document », puis validez.

Voilà, Geany est maintenant configuré.

IV-C - Création d'un plugin en Python avec Geanypy

IV-C-1 - Présentation

Geanypy est un plugin Geany permettant de coder les plugins non pas en C, mais en Python.

La partie graphique repose sur PyGTK. Mais attention, car les fonctionnalités dépréciées génèrent des bogues à l'exécution. Je vous invite à regarder cette documentation pour plus d'informations sur PyGTK.

Une fois le plugin Geanypy installé, un nouveau menu apparaît, sous le gestionnaire de plugins, lequel vous permet alors de gérer vos plugins Python.

Vous ne pouvez pas lancer le code de votre plugin à l'intérieur de Geany, cela ne fonctionnera pas. La meilleure méthode pour tester est d'activer votre plugin dans Geany, puis de lancer Geany depuis un terminal. Si des erreurs ont lieu, des messages s'afficheront alors. Si vous désirez plus d'infos encore, lancez « geany -v ».

IV-C-2 - Installation

La procédure d'installation est indiquée ICI.

git clone git://github.com/codebrainz/geanypy
GEANY_PREFIX=`pkg-config --variable=prefix geany`
cd geanypy
./autogen.sh
./configure --prefix=$GEANY_PREFIX
make
sudo make install

Après l'installation, GeanyPy est alors disponible comme plugin, et si vous l'activez, un nouveau menu apparaîtra.

Il existe un bogue connu faisant que GeanyPy se désactive à chaque démarrage. Pour pallier cela, repérez le « system plugin path » de Geany. Ouvrez simplement Geany, puis allez dans le menu « aide »/« message de débogage ». Le « system plugin path » y sera indiqué. Ensuite, copiez son contenu dans « /usr/lib/geany » dans le « system plugin path ».

IV-C-3 - Emplacement des plugins

L'intégralité des plugins Python que vous développerez ou installerez seront à mettre dans : « /home/<user>/.config/geany/plugins/geanypy/plugins/<nom_du_plugin> ».

IV-C-4 - Fichier principal : les bases

Quand vous allez écrire votre plugin, vous avez deux options : tout mettre dans un seul fichier ou alors, comme je le préfère, séparer les différents blocs de code par fonction.

Dans tous les cas, le fichier principal, qui sera appelé par Geany doit porter le nom de votre plugin et respecter la structure de base suivante.

#! /usr/bin/env PYTHON
# -*- coding: utf-8 -*-

import geany

# =========================================================== #
class <nom_du_plugin>(geany.Plugin):
__plugin_name__ = "<nom_du_plugin>"
__plugin_description__ = ("<descriptif>")
__plugin_version__ = "<version>"
__plugin_author__ = "<prenom_auteur> <nom_auteur> <<mail>>"
# ex : __plugin_author__ = "Alexandre GALODE <ag@dvp.com>"

# ==================================== #
def __init__(self):
"""
Init method
"""
# import externe autre que geany

geany.Plugin.__init__(self)

self.load_gui()

# ==================================== #
def load_gui(self):
"""
Allows to load the plugin's GUI
"""
pass

# ==================================== #
def show_configure(self):
"""
Method called when we want to parameter the plugin
"""
pass

# ==================================== #
def cleanup(self):
"""
Method called when we deactivate the plugin.
"""
pass

# =========================================================== #
if __name__ == "__main__":
pass

Voyons maintenant plus en détail cette structure de base.

Pour commencer, seul le module Geany est importé au début du fichier. Tout autre module externe (gtk, sqlite…) doit être importé dans le « __init__ », sans quoi vous aurez des erreurs au lancement du plugin.

Il doit y avoir une classe au nom de votre plugin et elle doit hériter de « geany.Plugin ». Cette classe possède quatre métadonnées qui permettent de connaître le nom du plugin, son descriptif, sa version et l'auteur.

Dans le « __init__ », hors de l'initialisation de la classe héritée, on appelle la méthode qui va permettre de créer le plugin (ici « load_gui »).

Les deux autres méthodes, dont vous ne pouvez modifier le nom, sont « show_configure » et « cleanup ». La première permet d'ajouter une fenêtre d'option pour paramétrer votre plugin. Si votre plugin n'a pas besoin d'être paramétré, vous pouvez omettre cette méthode.

La seconde, « cleanup » est OBLIGATOIRE. Si lorsque vous activez un plugin, le « __init__ » est appelé, lorsque vous le désactivez, c'est le cleanup qui est appelé.

À l'heure actuelle, vous devez importer les modules à l'endroit où vous voulez vous en servir. Cela a été remonté à l'équipe, qui travaille dessus.

IV-C-5 - Les zones d'interactions possibles

Vous pouvez interagir avec l'IHM à cinq niveaux :

- les menus ;

- la toolbar ;

- la progressbar de Geany ;

- l'espace des fichiers ;

- le notebook côté gauche, nommé « sidebar_notebook » ;

- le notebook en bas de l'écran, nommé « message_window_notebook ».

Seuls quelques menus sont accessibles, via différents objets :

- « geany.main_widgets.tools_menu » pour le menu « Outils » ;

- « geany.main_widgets.project_menu » pour le menu « Projet » ;

- « geany.main_widgets.editor_menu » pour le menu « Éditer ».

La toolbar est accessible via l'objet « geany.main_widgets.toolbar ».

La progressbar de Geany est accessible via l'objet « geany.main_widgets.progressbar».

L'espace de fichiers est accessible via l'objet « geany.main_widgets.notebook ».

Le sidebar_notebook est accessible via un objet Geany « geany.main_widgets.sidebar_notebook ».

Le message_window_notebook est accessible via un objet « geany.main_widgets.message_window_notebook ».

IV-C-6 - Obtenir de l'aide

Un des plugins livrés de base est un terminal Python dédié à GeanyPy. Vous pouvez y effectuer un « import geany », un « import gtk » et un « import pygtk ».

Vous avez alors la possibilité de créer des objets liés à Geany et de faire un appel au help() pour avoir plus d'informations.

La documentation de l'API n'étant pas encore très complète, c'est la meilleure façon d'obtenir actuellement de l'aide pour vos développements de plugins.

De plus, les méthodes associées aux widgets sont inspirées de celles de PyGTK. Si vous cherchez comment faire quelque chose, c'est une piste à suivre.

IV-C-7 - Menu

Self.menu_outils =  geany.main_widgets.tools_menu

# Creation d'un item de classe
self.menu_item = gtk.MenuItem("Hello World")

# Ajout au menu
self.menu_outils.append(self.menu_item)
self.menu_item.show()

# Connexion a une methode
self.menu_item.connect("activate", self.clicked_menu)

# Suppression
self.menu_item.destroy()

IV-C-8 - Toolbar

geany_toolbar = geany.main_widgets.toolbar

# Connaitre le nombre d'element dans la toolbar, separateurs compris
geany_toolbar.get_n_items()

# Connaitre le ToolItem a une position precise
geany_toolbar.get_nth_item(<position>)

# Connaitre la position d'un ToolItem
geany_toolbar.get_item_index(<gtk.ToolItem object>)

# Connaitre le nom d'un ToolItem
<gtk.ToolItem object>.get_name()

# Ajouter un ToollItem
geany_toolbar.insert(<gtk.ToolItem object>, position)

# Enlever le 25e ToolItem, en partant de 0
geany_toolbar.remove(geany.main_widgets.toolbar.get_nth_item(25))

# Enlever un ToolItem précis
geany_toolbar.remove(<gtk.ToolItem object>)

IV-C-9 - Progressbar

pb =  geany.main_widgets.progressbar

# Afficher la progressbar ou la cacher
pb.show()
pb.hide()

# Mettre a jour l'avancement, en %
pb.set_fraction(0.5)  # 50%

# Lire l'avancement de la progressbar
pb.get_fraction()

# Signaler une progression sans pouvoir la quantifier
pb.set_pulse_step(0.1)
pb.pulse()  # Chaque appel a pulse() fera bouger pb de 10 %
# a utiliser avec un timer ou dans une boucle

IV-C-10 - Notebook

Pour rappel, il existe deux notebook principaux : la sidebar et la message_window.

# Sidebar
sidebar = geany.main_widgets.sidebar_notebook
sidebar.append(widget, gtk.Label(titre))
sidebar.remove_page(n°_onglet)  # si -1 enleve le dernier

# Message window
msgw = geany.main_widgets.message_window_notebook
msgw.append(widget, gtk.Label(titre))
msgw.remove_page(n°_onglet)  # si -1 enleve le dernier

# Connaitre le label du dernier onglet
msgw.get_tab_label_text(msgw.get_nth_page(-1))

IV-C-11 - Fichiers et espaces de fichiers

doc = geany.document

# Ouvrir un fichier
doc.open_file(chemin_absolu)

# Lister les fichiers ouverts
list_doc = doc.get_documents_list()

# Connaitre le nom d'un document precis (avec son chemin absolu)
list_doc[0].file_name

# Trouver une instance precise d'apres son chemin absolu
tmp = doc.find_by_filename(chemin_du_fichier)

# Lire le contenu du fichier actif
tmp.editor.scintilla.get_contents()

# Ecrire le contenu du fichier actif
tmp.editor.scintilla.set_text("hello world")

# Sauver un fichier
tmp.save_file()

IV-C-12 - Projet

Cela ne fonctionnera que si vous avez un projet ouvert. Dans le cas inverse, le code suivant tombera en erreur.

project = geany.project.Project()

# Lecture du chemin du projet
BASE_PATH = project.base_path

# Lecture du nom du projet
NAME_PJ = project.name

# Lecture du descriptif du projet
DESCRIPTION = project.description

# Lecture de l'auteur du projet
AUTHOR = project.description

IV-C-13 - Messages utilisateur

Geany autorise la création de fenêtres pop-up simplifiées.

diag = geany.dialogs

# Demander a l'utilisateur de saisir quelque chose
# Retourne la valeur saisie
diag.show_input(titre,None,label,valeur_par_defaut)

# Demander a l'utilisateur de saisir un nombre
# Retourne une valeur de type float
diag.show_input_numeric(titre,label,valeur_par_defaut,min,max,step)

# Afficher un message à l'utilisateur
dialogs.show_msgbox(texte,gtk.MESSAGE_INFO)
dialogs.show_msgbox(texte,gtk.MESSAGE_WARNINGc)
dialogs.show_msgbox(texte,gtk.MESSAGE_ERROR)

# Poser une question a l'utilisateur (retourne True ou False)
diag.show_question("Appreciez vous ce tuto?")

IV-C-14 - Interactions externes

Pour tout ce qui est programmation, hors spécificités Geany, cela reste du Python standard. Vous avez donc le loisir d'interagir à votre guise avec des modules externes tels la génération de rapport HTML, la génération PDF…

Votre principale limite reste alors votre imagination.

V - Liens utiles

http://codebrainz.github.io/geanypy/

https://media.readthedocs.org/pdf/geanypy/latest/geanypy.pdf

https://geanypy.readthedocs.org/en/latest/api.html

http://www.geany.org/manual/reference/

VI - Conclusion

Bien que relativement simpliste, Geany est un petit IDE fort agréable à utiliser dans la vie de tous les jours. Cette simplicité fait sa force et explique qu'il arrive à s'imposer aisément dans de nombreuses équipes face à des grands noms tels qu'Eclipse ou encore Netbeans.

Rapide à charger, léger, multiplateformes… cet IDE est rempli d'atouts, et bien qu'encore jeune, est promis à un bel avenir.

J'espère que cette présentation vous aura donné envie, ne serait-ce que d'essayer Geany afin de vous faire votre propre opinion et de visualiser le potentiel de ce logiciel qui m'est désormais indispensable. Peut-être même voudrez-vous maintenant développer vos propres plugins.

VII - Remerciements

Merci aux personnes suivantes pour leur aide :

- chrtophe

- LittleWhite

- Kannagi