StarDict est une interface permettant de consulter des dictionnaires hors ligne (et des outils de traduction en ligne depuis la version 3.0). C'est un logiciel libre distribué sous licence GPL et disponible pour Linux, Windows, FreeBSD et Solaris.

StarDict ne comporte à la base aucun dictionnaire. Il faut les installer soi-même.

Stardict va utiliser ces fichiers de traduction grâce à une interface en 3 zones. La zone du haut permet de saisir un mot à traduire, celle de gauche est une liste de mots se rapprochant de celui saisi, et celle principale, affiche les résultats des différents dictionnaires sélectionnés.

Il offre aussi la possibilité de chercher sur différents moteurs de traduction en ligne le mot saisi.

Enfin, avec des outils comme stardict-editor, il permet de modifier, d'augmenter, voire de créer des dictionnaires.

Pour tout problème d'installation se référer à cette page : comment installer un paquet.

La version 3.0.1 est disponible dans le dépôt Universe (hardy).

On recherche et installe le paquet stardict. Pour ceux voulant convertir des dictionnaires au format stardict : installer aussi le paquet stardict-tools.

On décompresse le fichier tarball simplement en double cliquant dessus (grâce au gestionnaire d'archives file-roller).

Puis deux possibilités :

1) Soit en tant qu'utilisateur courant : on ouvre l'explorateur de fichier nautilus. Affichage : montrer les fichiers cachés, aller dans le répertoire "/home/nom_de_l'utilisateur/.stardict" (qui n'est pas visible par défaut), y créer un dossier nommé "dic" et y placer par copier-coller le répertoire contenant le nouveau dictionnaire auparavant décompressé.

2) Soit en ouvrant l'explorateur de fichiers nautilus en mode superutilisateur, dans un terminal (ce qui permet de l'installer pour tous les utilisateurs de l'ordinateur).

gksudo nautilus

On navigue jusqu'au répertoire des dictionnaires de stardict : /usr/share/stardict/dic et on y met le répertoire décompressé contenant les fichiers du dictionnaire en faisant le copier-coller en tant qu'administrateur cette fois-ci.

Il existe des dictionnaires au format "dictionnaire-arbre" (Tree dictionaries).
Dans ce cas les mettre au choix comme précédemment soit dans .stardict dans un nouveau répertoire treedict ou dans /usr/share/stardict/treedict.

La quasi totalité des dictionnaires stardict sont stockés sur le site même de StarDict (http://stardict.sourceforge.net/Dictionaries.php, prendre le format comprimé tarball ".tar".) ; mais, pour mieux s'y retrouver, les dictionnaires francophones sont recensés ci-dessous (avec la possibilité de les télécharger directement : clic droit, enregistrer la cible du lien sous ...).

(☥) utilise l'alphabet latin.

N.B. : Les dictionnaires français-anglais et anglais-français "woaifayu" (cf. répertoire "fr-français"), parmi les plus riches (en nombre de mots) sont indiqués dans les tableaux ci-dessus. Mais beaucoup d'autres dictionnaires entre ces deux langues existent au format StarDict, dont des dictionnaires spécialisés. Nous les avons regroupés dans le tableau ci-dessous. A chacun de tester pour trouver ceux qui lui sont les plus utiles.

Voir aussi : Babylon
http://www.babylon.com/gloss/glossaries.php
(dictionnaire au format ".bgl" à convertir au format stardic)
http://info.babylon.com/glossaries/387/Babylon_English_French.BGL
http://info.babylon.com/glossaries/4E5/Babylon_French_English_diction.BGL

Depuis la version 3.0, StarDict permet aussi l'utilisation des dictionnaires en ligne.

• StarDict se lance à partir du menu Accessoires > StarDict. Il se met dans la zone de notification.

• Avec un clic droit sur l'icône StarDict de la zone de notification on peut fermer le programme ("Quitter") ou rendre active/inactive la fonction de scan, en cochant/décochant la case "Scan".

• La fonction de scan de StarDict ne doit pas être confondue avec les opérations que l'on peut réaliser avec un scanneur (cf. XSane et autres applications). Elle ne nécessite pas de scanneur. Il s'agit d'une fonction de scan de ce qui se trouve sur l'écran de l'ordinateur. Elle permet d'obtenir la définition de n'importe quel mot présent à l'écran (quel que soit le logiciel utilisé : navigateur Internet, traitement de texte ou autre). Il suffit de sélectionner le mot voulu (par double-clic ou autrement) et la définition apparait dans une nouvelle fenêtre, à condition que le mot soit présent dans les dictionnaires activés. Si le mot est absent des dictionnaires, StarDict affiche "<Non trouvé!>". Exemple, le dictionnaire Littré étant activé dans StarDict :

• Un simple clic sur l'icône StarDict de la zone de notification ouvre le programme en plein champ.

• La fenêtre StarDict comporte un certain nombre d'icônes permettant l'utilisation et la configuration du logiciel. Parmi les plus importantes, les icônes "gestion des dictionnaires" et "préférences".

• Vous pouvez faire un tour dans les préférences pour y mettre vos réglages. Vous pouvez par exemple utiliser le réglage "scanner la sélection" : il vous donne la possibilité de paramétrer une touche d'activation pour la fonction de scan.

• Allez aussi faire un tour dans la gestion des dictionnaires : pour activer ou désactiver ceux-ci et les classer par ordre de prédilection dans la fenêtre des résultats. On peut par exemple mettre tous les dictionnaires anglais-français par ordre d'importance puis les dictionnaires français-anglais. On peut activer de façon distincte pour les modes de "recherche" et de "scan" le ou les dictionnaire(s) que l'on souhaite utiliser en vue d'un travail donné, et désactiver tous les autres dictionnaires dont on n'a pas besoin pour ce travail. Dans la fenêtre "Gestion des dictionnaires", activer le bouton "Gestion des dictionnaires" pour avoir accès à la liste avec les cases à cocher permettant l'activation ou la désactivation des dictionnaires.

• Pour avoir la définition d'un mot (via le mode "scan") il faut sélectionner le mot ou le groupe de mot avec la souris, double cliquer dessus aura le même effet pour un mot seul.

• Il peut être intéressant de lancer automatiquement StarDict au démarrage de la session (Système>Préférences>Sessions) : dans ce cas, il peut être utile de "cacher la fenêtre principale au démarrage de Stardict" (dans Préférences>Options de l'interface StarDict).

Si le fichier "ifo" a été correctement renseigné par l'auteur lors de la création du dictionnaire, vous trouverez les informations utiles comme suit :

• Allez dans la gestion des dictionnaires (icône du bas à droite),

• Bouton "Gestion des Dictionnaires",
• Sélectionnez dans la liste le dictionnaire dont vous souhaitez connaitre les caractéristiques,
• Cliquer sur l'icône "ampoule" à droite.
• Voir la capture d'écran ci-dessous, avec l'exemple du dictionnaire "Corse-Français" :

Pour pouvoir prononcer certains mots (uniquement en anglais) on peut installer le paquet WyabdcRealPeopleTTS. Il est composé d'un ensemble de mot au format wav.

Récupérez le tarball à cette adresse :
http://prdownloads.sourceforge.net/stardict/WyabdcRealPeopleTTS.tar.bz2?download

Décompressez le puis deux possibilités :

1) en tant qu'utilisateur courant : placez le répertoire WyabdcRealPeopleTTS dans le répertoire caché .stardic de votre home : /home/nom_de_l'utilisateur/.stardict/WyabdcRealPeopleTTS.
Allez dans les préférences de stardic>dictionnaire>son, activer le son et mettre le chemin de votre répertoire WyabdcRealPeopleTTS : /home/nom_de_l'utilisateur/.stardict/WyabdcRealPeopleTTS.

2) ou placez le grâce à nautilus en mode superutilisateur dans "/usr/share/".

Quelques informations sur le format des dictionnaires stardict.

Pour ouvrir un dictionnaire Stardict va chercher l'extension .ifo, puis ouvrir le fichier .idx ou .idx.gz et le fichier .dict.dz ou .dict qui est dans le même répertoire et avec le même nom. Il peut y avoir un fichier .syn non obligatoire.

Le fichier ".ifo"

De type :
StarDict's dict ifo file
version=2.4.2
[options] qui sont de types :
bookname= requis
wordcount= requis
synwordcount= requis si le fichier ".syn" existe
idxfilesize= requis
sametypesequence= très important mais non obligatoire
description=
author=
email=
website=

Si l'option de sametypesequence est placée, elle indique à StarDict que les données de chaque mot dans le dossier de .dict auront le même type de données. Chaque dictionnaire devrait essayer d'employer le dispositif de sametypesequence pour économiser l'espace disque.
Exemples :

• 'm' : les mots sont du texte pur au format utf-8 finissant par '\0'.
• 'x' : dictionnaire converti à partir d'un fichier xdxf (cf l'utilitaire makedict ci-dessous), ce qui permet des indications de style (cf le site xdxf).
• 'g' : dictionnaire créé en utilisant les informations de style de pango: cf Pango markup language.

Le fichier ".idx" est une liste de noms.

Le fichier ".syn" contient des informations pour les synonymes, ce qui signifie que quand vous rentrez un synonyme, StarDict va chercher un autre mot en relation avec lui.

Le fichier ".dict". est une séquence de données, le placement et la taille de chaque mot est enregistré dans le fichier ".idx" correspondant. Ce fichier peut être compressé : son extension est alors ".dict.dz".

Ce paquet contient les outils de conversion de dictionnaires qui peuvent convertir les dictionnaires de DICT, wquick, mova and pydict au format stardict. Il inclut notamment :

stardict-editor est un utilitaire graphique qui permet de "compiler" et "décompiler" un dictionnaire (i.e. passer d'un fichier texte au format stardict et vice-versa).
Pour décompiler un dictionnaire, c'est-à-dire le convertir du format StarDict au format texte tabulé :

• prenons l'exemple d'un dictionnaire "langue1_langue2"
• mettre sur votre bureau le répertoire contenant les trois fichiers du dictionnaire aux extensions "ifo", "dict.dz" et "idx" (certains dictionnaires peuvent comporter un 4ème fichier ayant une extension "syn")
• le dictionnaire ayant son fichier dict compressé - extension .dict.dz au lieu de .dict -, il faut décompresser ce dernier. Pour ce faire, le renommer en langue1_langue2.dict.gz, puis clic-droit, extraire ici.
• lancer stardict-editor (Alt+F2 –> stardict-editor → lancer)
• onglet "DeCompile"... Indiquer le chemin du fichier à décompiler (bouton "Browse...". Important : il faut indiquer précisément le chemin du fichier ayant l'extension "ifo" (langue1_langue2.ifo) et sélectionner celui-ci, puis clic sur "ouvrir")
• clic sur le bouton "Decompile" (en bas de la fenêtre stardict-editor)
• stardict-editor affiche alors le message :

Building...
Write to file: langue1_langue2.txt
Done!

• vous trouverez le fichier langue1_langue2.txt dans /home/votre_identité : il s'agit de votre dictionnaire au format texte tabulé.

Exécutable en ligne de commande, qu'on trouve dans /usr/lib/stardict-tools/. Il permet uniquement de compiler. La syntaxe est : /usr/lib/stardict-tools/tabfile mondico.txt

http://sourceforge.net/project/showfiles.php?group_id=95155&package_id=160978
Il convertit de : dictd, dsl, sdict, stardict, xdxf vers dictd (expérimental), stardict, xdxf. Pour le compiler, téléchargez l'archive et suivre les instructions du fichier README.

Exemple d'utilisation (conversion d'un fichier xdxf (XML) en fichier Stardict) :

./makedict -i xdxf -o stardict exemple.xdxf

(avec sudo ? )

cf DictConv. Le seul outil permettant de convertir les fichiers de babylon de type ".bgl". Il convertit des dictionnaires de Babylon, Freedict, Sdictionary et Stardict vers les dictionnaires au format DICT, plain text et StarDict.

Un petit utilitaire en python, qui transforme le format microsoft rtf en xml. il est téléchargeable ici (j'ai dû télécharger le paquet python-profiler pour que ça marche). Problème avec les caractères non ascii ?

rtf2xml monfichier.rtf

cf ici. tidy (disponible dans synaptic) permet notamment la conversion de HTML en XHTML : ce qui permet ensuite d'utiliser des feuilles XSL, par exemple pour convertir en XDXF.

tidy -asxhtml -o exemple.xhtml exemple.html

(ou "comment échapper aux bidouillages microsoftiens").

Lorsqu'on récupère des lexiques originellement au format doc ou html, composés de caractères non-latins, on risque d'être confronté au problème suivant : les caractères visiblement non-latins peuvent s'avérer être des caractères latins, affublés d'une police comme "symbol". Pour remédier à ça, voici un petit programme en C qui convertit ces caractères en l'unicode correspondant, à compiler ( gcc -o convertcarac convertcarac.c) et exécuter :

./convertcarac lexiquecarac.txt <avant.txt >apres.txt

avec lexiquecarac.txt un fichier de conversion des caractères (encodé en utf-8), dont voici un mini-exemple :

V   ω
a   α
b   β

avant.txt quant à lui est un fichier texte de la même structure que décrite plus haut (paragraphe tabfile), encodé lui aussi en utf-8 :

apo   loin de
agV   conduire

le code convertira les éléments de la première colonne uniquement. apres.txt devrait contenir après exécution :

απο   loin de
αγω   conduire

Le code :

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define ALPHABETMAX 100
 
int creetableau(FILE* fichier , char tab[ALPHABETMAX][2][5], int* taille){
	int i=0, j=0, k=0, drapeau=0;
	char c;
	while((c = getc(fichier)) != EOF){
		if(c=='\t'){
			drapeau=1;
			j=1;
			k=0;		
		}else 
		if(c=='\n'){
			drapeau=0;
			j=0;
			i++;
			k=0;			
		}else{
			tab[i][j][k]=c;
			tab[i][j][++k]='\0';
		}
	}
	*taille=i;
	return 0;
}
 
int apptableau(int taille, char d[5], char tab[ALPHABETMAX][2][5], int* ind){
	int res=-1, i=0, victoire=1, j=0;	
	for(i=0;i<taille;i++){
		victoire=1;
		j=0;
		while( (d[j]!='\0') && (tab[i][0][j]!='\0') ){
			if (d[j]!=tab[i][0][j]){
				victoire=0;
				break;
			}
			j++;
		}
		if (victoire && (j>0)){
			*ind=i;
			res=1;
		}
	}
	return res;
}
 
 
int main(int narg, char** argv) {
	char tab[ALPHABETMAX][2][5]; 
	int i=0, j=0, k=0, drapeau=1, ind=0, res=0, taille=0;
	char c,e;
	char d[5];
	FILE* lexique;
	lexique=fopen(*(argv+1),"r");
	if(lexique==NULL){
		printf("Pas trouvé de fichier.\n");
	}
	res=creetableau(lexique, tab, &taille);
	fclose(lexique);
	while ((c = getchar()) != EOF){
		if (c=='\n'){
			putchar('\n');		
			drapeau=1;
		}else if (c=='\t'){
			putchar('\t');		
			drapeau=0;
		}else if (drapeau){
			i=1;
			*d=c;
			if((unsigned char)c >192){ /* unicode sur 2 octets*/
				e = getchar();
				*(d+(i++))=e;
			}
			if((unsigned char)c >224){/* unicode sur 3 octets*/
				e = getchar();
				*(d+(i++))=e;			
			}
			if((unsigned char)c >240){/* unicode sur 4 octets*/
				e = getchar();
				*(d+(i++))=e;			
			}
			*(d+i)='\0';
			if ((res=apptableau(taille,d,tab,&ind))==1){
				k=0;
				while(tab[ind][1][k] !='\0'){
					putchar(tab[ind][1][k]);
					k++;
				}		
			}else{
				i=0;
				while(*(d+i)!='\0'){			
					putchar(*(d+(i++)));
				}
			}
		}else{
			putchar(c);
		}
	}
	putchar('\x0A');
	return 0;
}

Exemple d'en-tête :

<?xml version="1.0" encoding="UTF-8" ?>
<xdxf lang_from="FRA" lang_to="FRA" format="visual">
<full_name>Nom du dictionnaire</full_name>
<description>blablabla </description>

Compilation :

 gcc -o tab2xdxf tab2xdxf.c

et exécution :

./tab2xdxf <DicoAvant.txt >DicoApres.xdxf

#include <stdio.h>
 
 
int entete(void){
	return 0;
}
 
int baliseouvrante(char* t){
	int i=0;
	putchar('<');
	while(t[i]!='\0'){
		putchar(t[i]);
		i++;
	}
	putchar('>');
	return 0;
}
 
int balisefermante(char* t){
	int i=0;
	putchar('<');
	putchar('/');
	while(t[i]!='\0'){
		putchar(t[i]);
		i++;
	}
	putchar('>');
	putchar('\n');
	return 0;
}
 
int baliseautofermante(char* t){
	int i=0;
	putchar('<');
	while(t[i]!='\0'){
		putchar(t[i]);
		i++;
	}
	putchar('/');
	putchar('>');
	putchar('\n');
	return 0;
}
 
int balises(char* t){
	baliseouvrante(t);
	balisefermante(t);
	return 0;
}
 
int main(int narg, char** argv) {
	int i, drapeau=1, drapeauparenthese=0;
	char* def="ar";
	char* par="tr";	
	char* mot="k";
	char* sen="sens";
	char* bq="blockquote";
	char* tra="traduction";
	char* syn="synonyme";
	char* it="i";
	char* gras="b";
	char* kref="kref";
	char c;
	for(i=0;i<narg;i++){
		while(argv[i]!='\0'){
			i++;
		}
	}
	entete();
	baliseouvrante(def);
	putchar('\n');
	baliseouvrante(mot);	
	while ((c = getchar()) != EOF){
		if(c=='\t'){
			drapeau=0;
			balisefermante(mot);
		}else if (c=='\n'){
			putchar('\n');		
			balisefermante(def);
			baliseouvrante(def);
			putchar('\n');
			baliseouvrante(mot);
			drapeau=1;
		}else{
			putchar(c);
		}
	}
	putchar('\x0A');
	return 0;
}

Pour faciliter la désactivation de "Dict Net" (dictionnaires en réseau)

http://stardict.sourceforge.net/

Contributeur : tartanpion, hector, sorbus