Présentation de l'IDE Geany

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.

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-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… ».

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

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é.

La PEP8https://www.python.org/dev/peps/pep-0008/ permet de rallier l'ensemble des développeurs Python autour de règles fortement recommandées pour un code propre et efficace.

Pylinthttp://www.pylint.org/ 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 :

[MASTER]

# Specify a configuration file.
#rcfile=

# Python code to execute, usually for sys.path manipulation such as
# pygtk.require().
#init-hook=

# Profiled execution.
profile=no

# Add files or directories to the blacklist. They should be base names, not
# paths.
ignore=CVS

# Pickle collected data for later comparisons.
persistent=yes

# List of plugins (as comma separated values of python modules names) to load,
# usually to register additional checkers.
load-plugins=

# DEPRECATED
# include-ids=no

# DEPRECATED
# symbols=no


[MESSAGES CONTROL]

# Enable the message, report, category or checker with the given id(s). You can
# either give multiple identifier separated by comma (,) or put this option
# multiple time. See also the "--disable" option for examples.
#enable=

# Disable the message, report, category or checker with the given id(s). You
# can either give multiple identifiers separated by comma (,) or put this
# option multiple times (only on the command line, not in the configuration
# file where it should appear only once).You can also use "--disable=all" to
# disable everything first and then reenable specific checks. For example, if
# you want to run only the similarities checker, you can use "--disable=all
# --enable=similarities". If you want to run only the classes checker, but have
# no Warning level messages displayed, use"--disable=all --enable=classes
# --disable=W"
disable=W0702,W0201,C0325,R0902,R0912,R0914


[REPORTS]

# Set the output format. Available formats are text, parseable, colorized, msvs
# (visual studio) and html. You can also give a reporter class, eg
# mypackage.mymodule.MyReporterClass.
output-format=text

# Put messages in a separate file for each module / package specified on the
# command line instead of printing them on stdout. Reports (if any) will be
# written in a file name "pylint_global.[txt|html]".
files-output=no

# Tells whether to display a full report or only the messages
reports=no

# Python expression which should return a note less than 10 (10 is the highest
# note). You have access to the variables errors warning, statement which
# respectively contain the number of errors / warnings messages and the total
# number of statements analyzed. This is used by the global evaluation report
# (RP0004).
evaluation=10.0 - ((float(5 * error + warning + refactor + convention) / statement) * 10)

# Add a comment according to your evaluation note. This is used by the global
# evaluation report (RP0004).
comment=no

# Template used to display messages. This is a python new-style format string
# used to format the message information. See doc for all details
#msg-template=


[BASIC]

# Required attributes for module, separated by a comma
required-attributes=

# List of builtins function names that should not be used, separated by a comma
bad-functions=map,filter,apply,input,file

# Good variable names which should always be accepted, separated by a comma
good-names=i,j,k,ex,Run,_

# Bad variable names which should always be refused, separated by a comma
bad-names=foo,bar,baz,toto,tutu,tata

# Colon-delimited sets of names that determine each other's naming style when
# the name regexes allow several styles.
name-group=

# Include a hint for the correct naming format with invalid-name
include-naming-hint=no

# Regular expression matching correct function names
function-rgx=[a-z_][a-z0-9_]{2,30}$

# Naming hint for function names
function-name-hint=[a-z_][a-z0-9_]{2,30}$

# Regular expression matching correct variable names
variable-rgx=[a-z_][a-z0-9_]{2,30}$

# Naming hint for variable names
variable-name-hint=[a-z_][a-z0-9_]{2,30}$

# Regular expression matching correct constant names
const-rgx=(([A-Z_][A-Z0-9_]*)|(__.*__))$

# Naming hint for constant names
const-name-hint=(([A-Z_][A-Z0-9_]*)|(__.*__))$

# Regular expression matching correct attribute names
attr-rgx=[a-z_][a-z0-9_]{2,30}$

# Naming hint for attribute names
attr-name-hint=[a-z_][a-z0-9_]{2,30}$

# Regular expression matching correct argument names
argument-rgx=[a-z_][a-z0-9_]{2,30}$

# Naming hint for argument names
argument-name-hint=[a-z_][a-z0-9_]{2,30}$

# Regular expression matching correct class attribute names
class-attribute-rgx=([A-Za-z_][A-Za-z0-9_]{2,30}|(__.*__))$

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

# Regular expression matching correct inline iteration names
inlinevar-rgx=[A-Za-z_][A-Za-z0-9_]*$

# Naming hint for inline iteration names
inlinevar-name-hint=[A-Za-z_][A-Za-z0-9_]*$

# Regular expression matching correct class names
class-rgx=[A-Z_][a-zA-Z0-9]+$

# Naming hint for class names
class-name-hint=[A-Z_][a-zA-Z0-9]+$

# Regular expression matching correct module names
module-rgx=(([a-z_][a-z0-9_]*)|([A-Z][a-zA-Z0-9]+))$

# Naming hint for module names
module-name-hint=(([a-z_][a-z0-9_]*)|([A-Z][a-zA-Z0-9]+))$

# Regular expression matching correct method names
method-rgx=[a-z_][a-z0-9_]{2,30}$

# Naming hint for method names
method-name-hint=[a-z_][a-z0-9_]{2,30}$

# Regular expression which should only match function or class names that do
# not require a docstring.
no-docstring-rgx=__.*__

# Minimum line length for functions/classes that require docstrings, shorter
# ones are exempt.
docstring-min-length=-1


[MISCELLANEOUS]

# List of note tags to take in consideration, separated by a comma.
notes=FIXME,XXX,TODO


[SIMILARITIES]

# Minimum lines number of a similarity.
min-similarity-lines=4

# Ignore comments when computing similarities.
ignore-comments=yes

# Ignore docstrings when computing similarities.
ignore-docstrings=yes

# Ignore imports when computing similarities.
ignore-imports=no


[FORMAT]

# Maximum number of characters on a single line.
max-line-length=100

# Regexp for a line that is allowed to be longer than the limit.
ignore-long-lines=^\s*(# )?<?https?://\S+>?$

# Allow the body of an if to be on the same line as the test if there is no
# else.
single-line-if-stmt=no

# List of optional constructs for which whitespace checking is disabled
no-space-check=trailing-comma,dict-separator

# Maximum number of lines in a module
max-module-lines=10000

# String used as indentation unit. This is usually " " (4 spaces) or "\t" (1
# tab).
indent-string='    '

# Number of spaces of indent required inside a hanging or continued line.
indent-after-paren=4


[TYPECHECK]

# Tells whether missing members accessed in mixin class should be ignored. A
# mixin class is detected if its name ends with "mixin" (case insensitive).
ignore-mixin-members=yes

# List of module names for which member attributes should not be checked
# (useful for modules/projects where namespaces are manipulated during runtime
# and thus extisting member attributes cannot be deduced by static analysis
ignored-modules=

# List of classes names for which member attributes should not be checked
# (useful for classes with attributes dynamically set).
ignored-classes=SQLObject

# When zope mode is activated, add a predefined set of Zope acquired attributes
# to generated-members.
zope=no

# List of members which are set dynamically and missed by pylint inference
# system, and so shouldn't trigger E0201 when accessed. Python regular
# expressions are accepted.
generated-members=REQUEST,acl_users,aq_parent


[LOGGING]

# Logging modules to check that the string format arguments are in logging
# function parameter format
logging-modules=logging


[VARIABLES]

# Tells whether we should check for unused import in __init__ files.
init-import=no

# A regular expression matching the name of dummy variables (i.e. expectedly
# not used).
dummy-variables-rgx=_$|dummy

# List of additional names supposed to be defined in builtins. Remember that
# you should avoid to define new builtins when possible.
additional-builtins=


[CLASSES]

# List of interface methods to ignore, separated by a comma. This is used for
# instance to not check methods defines in Zope's Interface base class.
ignore-iface-methods=isImplementedBy,deferred,extends,names,namesAndDescriptions,queryDescriptionFor,getBases,getDescriptionFor,getDoc,getName,getTaggedValue,getTaggedValueTags,isEqualOrExtendedBy,setTaggedValue,isImplementedByInstancesOf,adaptWith,is_implemented_by

# List of method names used to declare (i.e. assign) instance attributes.
defining-attr-methods=__init__,__new__,setUp

# List of valid names for the first argument in a class method.
valid-classmethod-first-arg=cls

# List of valid names for the first argument in a metaclass class method.
valid-metaclass-classmethod-first-arg=mcs


[DESIGN]

# Maximum number of arguments for function / method
max-args=5

# Argument names that match this expression will be ignored. Default to name
# with leading underscore
ignored-argument-names=_.*

# Maximum number of locals for function / method body
max-locals=15

# Maximum number of return / yield for function / method body
max-returns=6

# Maximum number of branch for function / method body
max-branches=12

# Maximum number of statements in function / method body
max-statements=50

# Maximum number of parents for a class (see R0901).
max-parents=7

# Maximum number of attributes for a class (see R0902).
max-attributes=7

# Minimum number of public methods for a class (see R0903).
min-public-methods=2

# Maximum number of public methods for a class (see R0904).
max-public-methods=20


[IMPORTS]

# Deprecated modules which should not be used, separated by a comma
deprecated-modules=regsub,TERMIOS,Bastion,rexec

# Create a graph of every (i.e. internal and external) dependencies in the
# given file (report RP0402 must not be disabled)
import-graph=

# Create a graph of external dependencies in the given file (report RP0402 must
# not be disabled)
ext-import-graph=

# Create a graph of internal dependencies in the given file (report RP0402 must
# not be disabled)
int-import-graph=


[EXCEPTIONS]

# Exceptions that will emit a warning when being caught. Defaults to
# "Exception"
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 :

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é.

Geany est basé sur Scintilla. À ce titre, il hérite des lexershttp://foicica.com/scintillua/LexerList.html 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

comment=0xd00000
comment_doc=0x3f5fbf
comment_line=comment
comment_line_doc=comment_doc
comment_doc_keyword=comment_doc,bold
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 :

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

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.

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 :

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.

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.

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.

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-1. Présentation▲

IV-C-2. Installation▲

La procédure d'installation est indiquée ICIhttp://codebrainz.github.io/geanypy/.

 

Sélectionnez

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 boguehttps://github.com/codebrainz/geanypy/issues/13 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▲

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

#! /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

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

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

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▲

# 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▲

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▲

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▲