Configuration De SciTE

De Ensiwiki
Aller à : navigation, rechercher


Fonctionnement des fichiers .properties

Localisation

Comme vous devez le savoir si vous avez lu la page de SciTE, les fichiers de configurations de SciTE sont des fichiers .properties. Il existe les fichiers propres à chaque langages, et le fichier général ("SciTEGlobal"). Ceux ci peuvent être trouvé dans /usr/share/scite sous Linux, et dans le même répertoire que le fichier SciTEGlobal.properties sous Windows.

Il existe enfin le fichier de configuration utilisateur, situé dans votre dossier personnel, sous le nom (.)SciTEUser.properties. (Le point n'est présent que sous Linux)

Hierarchie

SciTE interprète dans l'ordre :

  • Le fichier propre au langage du fichier que vous avez ouvert
  • Le fichier SciTEGlobal
  • Le fichier SciTEUser

De plus, pour une même option, la dernière occurence sera conservée : cela fait de SciTEUser le fichier "maitre", vient ensuite le Global, et les langages. Je vous conseille donc vivement d'effectuer toute vos modifications dans le SciTEUser, en effet les autres fichiers sont susceptibles d'être remplacés lors d'une mise à jour, et vous risqueriez de perdre votre configuration.


Options générales

D'une manière générale, le SciTEGlobal présente une série d'options que vous pouvez activer/changer, il suffit pour ça de copier la ou les lignes de votre choix dans votre SciTEUser, et de modifiez à votre guise. Une option se compose en deux parties, l'option en partie gauche, et sa valeur en partie droite. Les commentaires sont définis par des dièses.

Exemple :

#Un commentaire
prop.sousprop=valeur


Une fois les options modifiées, il suffit de sauvegarder le fichier, et les modifications seront prises en compte immédiatement (pas besoin de relancer SciTE).


Fenêtre principale

  • Affichage des numéros de ligne
# Style de l'affichage des numéros de ligne
line.margin.visible=1
line.margin.width=4
margin.width=12


  • Navigation par onglet
#Activer les onglets
tabbar.multiline=1


  • Barre d'outils
#Barre D'outils
toolbar.visible=1
#Option pour les utilisateurs avec GTK : utilisation de plus belles icones
toolbar.usestockicons=1


  • Barre de statut

Cette barre située en bas de la fenètre récapitule les informations sur la position courante du curseur : ligne, colonne, caractère de fin de ligne

#Afficher la barre de statut
statusbar.visible=1


Comportement

  • Ouverture dans une seule application

Par défaut SciTE ouvre chaque fichier dans une instance différente, avoir tout dans les onglets, sous une seule fenètre, est généralement plus agréable.

#ouverture dans une seule instance de scite
check.if.already.open=1
#Et le nombre maximum de fichiers acceptables dans une seule instance
buffers=30


  • Rechargement des pages

Cette option permet de recharger le contenu des fichiers automatiquement, s'ils ont été modifiés par une application extérieure. (Typiquement un svn up ou un git pull)

#reload des pages
load.on.activate=1


  • Sauvegarde de la session

Autorise SciTE à garder en mémoire les fichiers ouverts et la position du curseur lors de la fermeture de SciTE. Par défaut la dernière session est conservée dans ~/.SciTE.session. Il est aussi possible d'enregistrer et de charger des session personalisées (pour un projet par exemple), via le menu fichier=>Charger/Enregistrer un session.

#Sauvegarde de la session
save.session=1
#Sauvegarde des blocs ouverts/fermés et des marques dans le fichier
session.bookmarks=1
session.folds=1

*Langage par défaut 

Il suffit de remplacer .c par votre extension favorite...

#nouveau fichier par defaut
default.file.ext=.c


Édition

  • Encodage

Par défaut l'encodage est en latin1, je vous conseille donc d'utiliser la propriété suivante pour mettre l'utf8 par défaut :

#utf8...
code.page=65001


  • Autocomplétion

Par défaut, SciTE n'active pas l'autocomplétion! (Je vous l'ai dit, une vraie chèvre!) Il faut donc l'activer soi-même via les lignes suivantes :

#Proprietes d'autocompletion
#autocomplete.*.ignorecase=1
autocomplete.choose.single=0

#Fini l'autocomplétion si appui sur "(", et du coup propose le prototype s'il est disponible.
autocomplete.*.fillups=(

#active l'autocompletion sur les mots dans le document
autocompleteword.automatic=1

Un peu de détail sur les sous options de autocomplete :

-- ignorecase : insensible à la casse si mis à 1

-- choose.single : Mise à 1, cela complète directement le mot, sans vous proposer la liste. Autrement dit, si vous avez tapé "optionnel" dans votre document, et que vous voulez taper "option", cela completera automatiquement en "optionnel". Ainsi je vous conseille de la laisser à 0!

-- fillups : permet de définir un caractère qui valide l'autocomplétion, en plus de la touche "Entrée". En le mettant sur "(", et pour peu que vous ayez installé des APIs, cela permet de finir la déclaration de fonction et d'ouvrir le prototype.

Voici ce que ça donne en action : saisie de "str", edition->completer le symbole (Ctrl+i), selection de strcmp, et appui sur "(". Scite ex fillup.png

Très vite, vous allez trouver ça lourd de devoir appuyer sur un racourci pour que SciTE vous propose les fonctions de l'API qui matchent, et vous allez aussi trouver ça lourd de n'avoir la complétion que si un et un seul mot du document matche. Exemple : vous avez tapé "entrainement", et "entrain" dans le même fichier, si vous commencez un mot par "entr", il ne completera pas jusqu'à "entrain". En revanche si vous tapez "entraine", il vous proposera "entrainement". Pour résoudre ce problème, direction le patch autocomplétion disponible ici.


  • Coding Style

La première chose à faire est de paramètrer SciTE pour qu'il respecte votre coding style, par exemple pour le coding style du kernel :

#Proprietes des tabulations
tabsize=8
indent.size=8
use.tabs=1

#Indentation auto
indent.automatic=1
indent.opening=0
indent.closing=0


  • Blocs

On peut activer la fonctionalité de réduction de blocs : cela permet de réduire un corps de fonction, un bloc if/then/else, ou tout autre bloc, à une seule ligne. Pratique dans les gros fichiers!

#réduction des blocs
fold=1
fold.compact=0
fold.flags=16
#icone pour la réduction, choix : 0, 1, 2, 3
fold.symbols=3
fold.comment=1


  • Avoir le dernier mot ...

Pour toujours rajouter une ligne en fin de fichier :

#ligne finale
ensure.final.line.end=1


Options propres aux langages

Un mot sur les commentaires

Par défaut, le racourci pour commenter/décommenter une ligne est Ctrl+Q. Néanmoins SciTE à la facheuse manie de rajouter un "~" après la déclaration de commentaire. Par exemple, en C :

//~ Un commentaire

Pour retirer ce tilde, il suffit de redéfinir la marque de début d'un commentaire, avec cette option :

comment.block.cpp=//

J'en profite pour vous faire remarquer que les propriétés du C/C++ sont regroupées sous le nom "cpp". Cette option est valable aussi pour les autres langage :

comment.block.ada=--


Compilation

Comme je vous l'annonçais dans les fonctionalité de base de SciTE, il est possible de choisir la commande à exécuter lors du lancement de la commande Outils->Compiler.

En fait on peut aussi personnaliser les commandes "Générer" (Build), et "Exécuter" (Go), et ceci pour chaque extension de fichier. Syntaxe de la déclaration :

#Exemple en Latex :
command.compile.*.tex=latex "$(FileNameExt)"
command.build.*.tex=latex "$(FileNameExt)"
command.go.*.tex=xdvi "$(FileName).dvi"
#Exemple en C, avec un makefile présent, et des flags de base :
command.compile.*.c=gcc -m32 -std=c99 $(FileNameExt) -o $(FileName)
command.build.*.c=make
command.go.*.c=./$(FileName)

Cette fois il faut déclarer vos commandes personnelles pour chacune des extensions de fichiers que vous utilisez (.c .cpp .adb .tex ...), et pas seulement pour un langage (Ce qui se faisait pour les commentaires juste au dessus : voir la section avancée à la fin de cette page).

Une fois que vous avez lancé la compilation ou l'exécution, un cadre avec les résultats apparait, qui est en fait un terminal à part entière, que vous pouvez afficher/masquer via F8 ou Afficher->Fenêtre de résultats.

APIs

Quoi de plus confortable qu'un logiciel qui vous indique quels types d'arguments passer à une fonction standard que vous voulez utiliser ? C'est ce que propose SciTE grace aux APIs (Application Programming Interface) : ce sont des fichiers propres à chaque langage, contenant les prototypes des fonctions standards. Ils sont bien sur modifiables, et permettent donc l'ajout de fonction personnalisées.

Exemple de prototype pris dans c.api :

fwrite(const void* ptr, size_t size, size_t nobj, FILE* stream);

Ces fichiers ne sont pas interprétés par défaut par SciTE, il faut donc lui dire de les charger. Pour ce faire on créer d'abord une variable contenant le chemin où sont sockés ces fichiers .api :

repertoireApi=$(SciteDefaultHome)/api

Dans mon exemple, cela correspond à /usr/share/api, pour que tous les utilisateurs aient accès aux fichiers, mais vous pouvez très bien les stocker dans votre répertoire personnel via une déclaration du type :

#Chemin relatif à partir du repertoire personnel
if PLAT_WIN
	repertoireApi=$(SciteUserHome)/scite/api
if PLAT_GTK
	#autant cacher le repertoire
	repertoireApi=$(SciteUserHome)/.scite/api

Ensuite copiez vos fichiers .api dans ce repertoire, et incluez les grâce à une ligne du genre (/!\ SciTE charge les APIs en fonction de l'extension du fichier ouvert /!\) :

api.*.c=$(repertoireApi)/c.api

Vous pouvez inclure plusieurs fichiers pour une même extension :

api.*.extension=$(repertoireApi)/premiere.api;$(repertoireApi)/deuxieme.api

Maintenant vous pouvez ouvrir un fichier pour lequel vous avez défini une api, taper une fonction définie (suivie d'une parenthèse ouvrante), et le prototype devrait vous être proposé (Ctrl+espace sinon). (Pour un apperçu : voir le paragraphe sur l'autocomplétion). À propos d'autocomplétion, vous pouvez maintenant taper le début du nom de la fonction, et en appuyant sur Ctrl+i (edition=>completer le symbole), la complétion sur les noms de fonctions correpondants devrait vous être proposée. Pour rendre cette proposition automatique, voir le patch d'autocomplétion ici.

TODO : mettre à disposition les api de base

Abréviations

Les abréviations sont des racourcis pour des phrases/blocs que l'on tape régulièrement (ex : un if, une déclaration de fonction). Le seul fichier chargé par défaut est le fichier abbrev.properties de /usr/share. On va ici définir d'autres fichiers et les charger, et ceci pour deux raisons :

  • Certaines abréviations identiques devrait être remplacées différement selon les langages.
  • abbrev.properties est chmodé 644 en root...

Pour bien faire, on défini le repertoire ou seront sotckés les fichiers d'abréviations :

#Chemin relatif à partir du repertoire personnel
if PLAT_WIN
	repertoireAbbrev=$(SciteUserHome)/scite
if PLAT_GTK
	#autant cacher le repertoire
	repertoireAbbrev=$(SciteUserHome)/.scite

Il suffit maintenant de créer les racourcis de nos choix dans des fichiers .properties stockés dans ce repertoire. Exemple d'un fichier c_abbrev.properties, contenant des abréviations vraiment basiques pour le C :

main=int main(int argc, char *argv[])\n{\n|\n}
if=if (|) {\n\n}

Comme vous pouvez le noter, une déclaration est de la forme :

abreviation=remplacement

De plus le caractère "|" indique la position du curseur une fois l'abréviation complétée.

Maintenant que vos abréviations sont crées, il faut indiquer à SciTE de les charger (Il les charge par extensions, il faut donc les déclarer pour les différentes extensions que vous utilisez pour écrire du C) :

abbreviations.*.c=$(repertoireAbbrev)/c_abbrev.properties
abbreviations.*.h=$(repertoireAbbrev)/c_abbrev.properties

Enfin, il suffit d'ouvrir un fichier.c ou .h, de taper "main" et de completer l'abréviation en utilisant Ctrl+b ou édition=>Compléter l'abréviation.


Remarque pour utilisateur avancéComme vous avez pu le voir, on a utilisé comment.block.cpp pour les commentaires, et api.*.c ou encore abbreviations.*.h pour d'autres commandes.

Cela vient de la manière dont SciTE gère les langages : il distingue le Lexer (analyseur lexical du langage) des extensions que peuvent prendre ce langage. Ainsi pour changer la manière de commenter en C ou en Ada, on modifie la propriété du Lexer (cpp dans l'exemple), tandis que pour une commande de compilation, une api, ou une abréviation, on se réfère à l'extension.

Pour voir quelles extensions sont prises en compte dans un Lexer, ouvrez un des fichier properties de /usr/share/scite, et regardez une déclaration de Lexer.

Exemple pour cpp.properties

file.patterns.cpp=*.c;*.cc;*.cpp;*.cxx;*.h;*.hh;*.hpp;*.hxx;*.ipp;*.sma
lexer.$(file.patterns.cpp)=cpp

On constate que les fichiers C/C++ font partie du même Lexer, du fait de leur proximité lexicale. De plus, imaginons que vous ayez un fichier .toto que vous vouliez considérer comme du C, il suffit alors de rajouter .toto dans le file.patterns.cpp .


Style et coloration syntaxique

Cette section relève plus du gadget que d'une véritable fonctionalité : il est possible de modifier les couleurs et styles de la coloration syntaxique. Je ne vais pas tellement le détailler, juste expliquer le principe; il y a deux types de modification possible :

  • Les styles globaux auquels les langages se réfèrent
  • Les styles propres aux langages

Modification globale

Si vous ouvrez le SciTEGlobal.properties, vous constaterez vers la fin du fichier (~ l. 400), que certains styles globaux sont définis :

colour.number=fore:#CC9900
colour.keyword=fore:#7F007F,bold
colour.string=fore:#7F0000
colour.char=fore:#007F00
colour.operator=fore:#20931b,bold
colour.preproc=fore:#7F7F00
colour.error=fore:#FFFF00,back:#FF0000

Ici se sont les couleurs des principales composantes d'un langage qui sont définies, il vous suffit alors de modifier à votre guise ces lignes. Une couleur de police se définie grace au paramètre "fore:#xxxxxx", une couleur de fond grace à "back:#xxxxxx", et on peut bien sur mettre le texte en gras, italique etc... Je vous renvoie à la doc de SciTE pour toutes les modifications possible sur un texte.


Modification spécifique

On peut aussi modifier les styles langage par langage. Pour savoir exactement quelle propriétés correspond à quoi, le mieux est d'ouvrir le fichier de propriétés du langage en question, et de récupérer des lignes ressemblant à ça :

# Default
style.xml.0=fore:#000000,$(font.text)
# Tags
style.xml.1=fore:#000080
# Unknown Tags
style.xml.2=fore:#000080
# Attributes
style.xml.3=fore:#008080
# Unknown Attributes
style.xml.4=fore:#008080
# Numbers
style.xml.5=$(colour.number)
# Double quoted strings
style.xml.6=$(colour.string)
# Single quoted strings
style.xml.7=$(colour.string)

Cette exemple est pris du html.properties, qui défini les propriétés de la plupart des langages web.

Comme vous pouvez le voir, les commentaires présents sont relativement explicites, je ne détaillerai donc pas plus le changement de style.