Il y a de nombreuses manières d’installer Debian, plusieurs versions, plein d’architectures…
L’objectif de cet article est de décrire l’installation telle que je l’ai réalisée.

Dans l’ordre :

• le téléchargement ;
• la copie sur une clé USB ;
• l’installation directe de Sid à partir de la clé USB ;
• la conservation du home chiffré mis en place par Ubuntu ;
• l’installation des pilotes NVIDIA et WiFi…

Bien sûr, avant tout, faites des sauvegardes de toutes vos données importantes. Cet avertissement est sûrement inutile, j’imagine que vous faites, comme tout le monde, plusieurs backups par semaine…

Téléchargement

Sur la page d’accueil de Debian, dans « Obtenir Debian », c’est la version stable.
Ce qui nous intéresse, c’est la version testing, à partir de laquelle on peut passer en unstable dès l’installation. Celle-ci est disponible dans « Le coin du développeur », Installateur de Debian.

Ici, il faut regarder la partie « images de CD d’installation par le réseau (en général 135 à 175 Mo) et au format carte de visite (en général 20 à 50 Mo) », et cliquer sur l’architecture souhaitée. Typiquement, il faut prendre amd64 pour du 64 bits et i386 pour du 32 bits.

Choisir l’image businesscard (la plus petite). Pour moi : debian-testing-amd64-businesscard.iso.

Clé USB

Connaître l’emplacement

Nous avons besoin de connaître l’emplacement de la clé, sous la forme /dev/sdX.
Une méthode parmi d’autres est de consulter /var/log/syslog lors du branchement : insérer la clé USB et exécuter :

tail /var/log/syslog

Vous devriez obtenir plusieurs lignes qui ressemblent à ceci :

Aug 28 00:54:27 rom-laptop kernel: [ 1868.930100] sd 4:0:0:0: [sdb] 2015232 512-byte logical blocks: (1.03 GB/984 MiB)

Sur cet exemple, nous voyons [sdb], nous en concluons que l’emplacement de la clé est /dev/sdb.

Alternativement, si la clé est montée, il est possible d’obtenir cet emplacement dans le résultat de :

df -h

Ne vous trompez surtout pas d’emplacement, vous risqueriez d’écraser toutes les données de votre disque dur !

Préparer

Si vous avez une clé réservée pour vos installations de systèmes d’exploitation (sans données à conserver), je vous conseille la méthode la plus simple, qui écrase tout ce qu’il y a sur la clé (4.3.1) :

$ sudo -s
# cat debian-testing-amd64-businesscard.iso > /dev/sdb
# sync

Ensuite, il faut redémarrer, et configurer le BIOS pour qu’il boote sur clé USB (souvent, les clés USB sont reconnues comme un disque dur, il faut donc régler la priorité entre les disques durs).

Installation

Pour l’installation, l’ordinateur doit être connecté à Internet par un câble Ethernet.

L’ordinateur boote sur la clé USB, et affiche un menu d’installation de Debian. Sélectionner « Advanced Options ».
Ici, il est possible changer l’environnement de bureau (Gnome, KDE, XFCE…). Par défaut, c’est Gnome.
Ensuite, sélectionner « Expert Install » pour lancer l’installation (afin de pouvoir choisir sid/unstable au lieu de testing dès l’installation).

Lors de l’étape de partitionnement, dans l’hypothèse où le disque dur utilise une partition séparée pour le home, ne pas oublier de configurer les points de montage (/ et /home), et ne pas formater /home (pour conserver les données personnelles).

Utiliser le même nom d’utilisateur et mot de passe que celui d’Ubuntu (c’est important pour accéder au répertoire home chiffré).

Je ne détaille pas les autres étapes d’installation, il suffit de lire.

Déchiffrer le home

Une fois l’installation terminée et le système démarré, il n’est pas possible de se connecter graphiquement avec le compte utilisateur, car le home est chiffré et par défaut, eCryptFS n’est pas installé. Il faut donc l’installer.

Pour cela, ouvrir un TTY (Ctrl+Alt+F1), se connecter en root (ou avec le compte utilisateur si vous avez interdit la connexion de root, dans ce cas utiliser sudo), puis installer ecryptfs-utils :

apt-get install ecryptfs-utils

Si lors de l’installation vous n’avez pas choisi le même mot de passe que sur Ubuntu, profitez-en pour le rétablir :

passwd monlogin

Maintenant, il est possible de se connecter graphiquement, en retournant dans le TTY graphique (Ctrl+Alt+F7).

Gestionnaire de composite

Pour moi, il est indispensable d’utiliser un gestionnaire de composite. Pour au moins 3 raisons :

• éviter les trainées lors du déplacement de fenêtres ;
• activer les ombres sous les fenêtres (très important pour le confort visuel) ;
• les performances…

Par défaut, Metacity (le gestionnaire de fenêtres de Gnome) n’en utilise pas. C’est la raison pour laquelle Compiz se révèle souvent indispensable.
Cependant, je viens de découvrir que Metacity savait gérer le compositing, grâce à une option bien cachée. Pour l’activer :

gconftool-2 -s -t boolean /apps/metacity/general/compositing_manager true

Il est également possible d’utiliser gconf-editor :

Il n’est pas configurable, et ne permet pas de faire tout ce que fait Compiz, mais pour moi c’est suffisant.

Pilotes NVIDIA

J’ai la malchance d’avoir une carte graphique NVIDIA, qui nécessite dans certains cas d’avoir recours à des pilotes privateurs. Sans eux, impossible de faire fonctionner Compiz ni certains jeux.

Cependant, le pilote libre Nouveau (installé par défaut) est assez impressionnant par rapport à l’ancien (nv). Et même s’il ne permet pas de démarrer Compiz, il supporte le compositing de Metacity avec de bonnes performances.

En installant le paquet libgl1-mesa-dri-experimental, le pilote Nouveau sait faire fonctionner Compiz et surtout Gnome-Shell. Il faut simplement prendre soin d’avoir supprimé toute trace éventuelle du pilote propriétaire :

apt-get remove nvidia-*

Pour néanmoins installer les pilotes privateurs (les dépôts non-free doivent être activés) :

apt-get install nvidia-kernel-dkms nvidia-xconfig nvidia-settings && nvidia-xconfig

(Remplacez nvidia-kernel-dkms par nvidia-kernel-legacy-VERSION-dkms pour une carte graphique nécessitant des pilotes plus anciens.)

Puis rebooter.

Pilotes WiFi

J’ai également dû installer des pilotes pour ma carte WiFi :

$ lspci | grep Network
03:00.0 Network controller: Intel Corporation WiFi Link 5100

Il suffit d’installer le paquet non-libre firmware-iwlwifi :

apt-get install firmware-iwlwifi

Il y a plusieurs paquets en firmware-quelquechose, selon votre matériel.

Agencement du clavier

Avec la version actuelle, Debian Sid installe par défaut l’agencement du clavier « France (Obsolète) Autre » au lieu de « France Autre ». Je vous conseille de le changer dans Système → Préférences → Clavier → Agencements, sinon vous risquez d’avoir des surprises (notamment si vous utilisez des pipes dans un terminal)…
EDIT : Cela ne suffit pas, pour que le réglage soit conservé, il faut en fait le changer dans GDM (l’écran de connexion), une liste déroulante en bas permet de changer la disposition du clavier.

Conclusion

Avant la migration, j’avais un peu peur pour la conservation du home chiffré… Mais finalement, aucun souci.

Par rapport à Ubuntu, j’apprécie beaucoup d’avoir des versions plus à jour des logiciels sans passer par des PPA. Et aussi d’avoir plus de logiciels dans les dépôts par défaut (pino par exemple). L’installation est cependant un peu moins simple qu’Ubuntu (il faut avouer qu’il est difficile de faire plus simple).

Pour finir, voici une capture d’écran juste après l’installation (avec, comme le veut la tradition, un terminal ouvert) :

Une fois connecté à un tel réseau, lorsqu’avec votre navigateur vous tentez d’accéder à n’importe quel site, vous êtes redirigé vers une page d’authentification demandant votre identifiant et votre mot de passe (parfois il ne s’agit que d’accepter des conditions d’utilisation). Après avoir renseigné ces informations, vous êtes authentifié et pouvez accéder à Internet normalement.

Mais il faut avouer que s’authentifier manuellement à chaque connexion est pénible. D’autant plus que la redirection HTTP vers la page d’authentification ne fonctionne… que pour HTTP. Ainsi, alors que vous êtes connecté au réseau Wifi, votre client mail ne parviendra à récupérer les mails, votre client XMPP n’arrivera pas à se connecter au serveur… mais sans message indiquant la cause du problème.

Le but de ce billet est de mettre en place une authentification automatique lors de la connexion au réseau.

Authentification en ligne de commande

La première étape est de pouvoir réaliser cette authentification en ligne de commande, à partir de l’identifiant et du mot de passe. C’est très simple, il suffit d’imiter ce que fait le navigateur lors du clic sur le bouton Valider.

Pour cela, deux choses sont nécessaires : l’URL de la page de validation d’authentification et les champs de formulaire qu’elle utilise.

Pour les connaître, il faut regarder le code source de la page sur laquelle vous êtes redirigés, en particulier la balise form. Voici un exemple de ce que vous pouvez obtenir (le HTML n’est pas toujours super propre sur ce genre de pages) :

<form method="post" action="http://10.9.0.1:8000/">
Login <input name="auth_user" type="text">
Password <input name="auth_pass" type="password">
<input type="checkbox" name="regagree" value="valeur" onClick="ChangeStatut(this.form)"> J'accepte le règlement
<input name="redirurl" type="hidden" value="http://www.google.com/search?ie=UTF-8">
<input type="submit" name="accept" value="Continuer" disabled>
</form>

Tout y est. La valeur de l’attribut action est l’URL de validation, et le nom des champs utilisés est dans l’attribut name de chaque balise input.

Dans cet exemple, seuls auth_user et auth_pass semblent utiles, mais parfois le serveur effectue des vérifications (étranges) supplémentaires. Ici, il vérifie qu’il y a bien un attribut accept qui vaut Continuer (allez savoir pourquoi).

À partir de ces champs, nous allons construire la chaîne des paramètres sous la forme :

champ1=valeur1&champ2=valeur2&champ3=valeur3

et l’envoyer au serveur en POST, par exemple grâce à la commande POST (en majuscules, ça surprend un peu pour une commande shell) :

POST http://10.9.0.1:8000/ <<< 'auth_user=IDENTIFIANT&auth_pass=MOT_DE_PASSE&accept=Continuer'

Si la page d’authentification est en HTTPS, il faudra installer le paquet libcrypt-ssleay-perl, ou alors utiliser wget :

wget -qO- https://10.9.0.1:8000/ --post-data='auth_user=IDENTIFIANT&auth_pass=MOT_DE_PASSE&accept=Continuer'

Voilà, nous avons reproduit en ligne de commande le comportement du navigateur pour l’authentification.
Nous devons maintenant faire en sorte que cette commande soit exécutée dès la connexion au réseau WiFi.

Exécuter un script lors de la connexion

NetworkManager (le gestionnaire de connexion par défaut d’Ubuntu) permet d’exécuter des scripts lors de la connexion ou la déconnexion. Pour cela, il suffit de placer le script dans /etc/NetworkManager/dispatcher.d/ et de le rendre exécutable.

Le script est appelé avec deux paramètres :

• $1 : l’interface réseau concernée par la connexion ou la déconnexion (wlan0 par exemple) ;
• $2 ayant pour valeur soit up (pour la connexion), soit down (pour la déconnection).

Nous voulons exécuter la commande POST uniquement lors de la connexion de wlan0, et seulement pour le réseau concerné (par exemple celui ayant le nom MonLieuDeVacances).

Il est possible de récupérer le nom du réseau (l’ESSID) auquel nous sommes connectés grâce à iwconfig :

iwconfig wlan0 | grep -o 'ESSID:".*$' | sed 's/^ESSID:"\(.*\)".*$/\1/'

Il faut donc créer un script dans /etc/NetworkManager/dispatcher.d/10auth :

gksudo gedit /etc/NetworkManager/dispatcher.d/10auth

ayant cette structure :

#!/bin/bash
if [ "$1 $2" = 'wlan0 up' ]
then
    essid=$(iwconfig wlan0 | grep -o 'ESSID:".*$' | sed 's/^ESSID:"\(.*\)".*$/\1/')
    case "$essid" in
        'MonLieuDeVacances')
            POST http://10.9.0.1:8000/ <<< 'auth_user=IDENTIFIANT&auth_pass=MOT_DE_PASSE&accept=Continuer' ;;
        'MaGare')
            POST http://192.168.0.1 <<< 'accept_cgu=1' ;;
    esac
fi

Et le rendre exécutable :

sudo chmod +x /etc/NetworkManager/dispatcher.d/10auth

Script pour FreeWifi

Les pages d’authentification varient d’un réseau à l’autre, il faut donc adapter les paramètres de connexion selon le service utilisé.

Voici le script à utiliser (en adaptant votre identifiant et votre mot de passe) pour le réseau FreeWifi (très connu) :

#!/bin/bash
if [ "$1 $2" = 'wlan0 up' ]
then
    essid=$(iwconfig wlan0 | grep -o 'ESSID:".*$' | sed 's/^ESSID:"\(.*\)".*$/\1/')
    case "$essid" in
        'FreeWifi')
            wget -qO- https://wifi.free.fr/Auth --post-data='login=IDENTIFIANT&password=MOT_DE_PASSE' ;;
    esac
fi

Tunnel SSH

Ces réseaux ouverts, gérant éventuellement une authentification HTTP, ne sont pas chiffrés : n’importe qui écoutant ce qui transite dans les airs pourra récupérer tout le contenu de votre trafic.
Si vous avez un ordinateur allumé chez vous (sur un réseau « sûr ») accessible en SSH, je vous conseille de faire passer toutes les connexions dans un tunnel chiffré.

Le principe est simple : dès que vous accédez à un serveur (par exemple en tapant l’URL dans un navigateur web), l’ordinateur ne va pas s’y connecter directement, il va transmettre les informations en passant par un tunnel chiffré à votre serveur SSH, qui lui va s’y connecter, et vous renvoyer la page à travers le tunnel. Techniquement, le tunnel est un proxy SOCKS écoutant sur un port local (par exemple localhost:3128).

Pour démarrer le tunnel :

ssh monserveur -CND3128

Pour configurer le système afin qu’il utilise le tunnel SSH, Système → Préférences → Serveur mandataire (gnome-network-properties), puis configurer comme sur la capture d’écran :

Dans l’onglet Hôtes à ignorer, rajouter l’adresse de la page d’authentification.

Ainsi, toutes les connexions des logiciels utilisant les paramètres proxy du système passeront par le tunnel. Il est également possible de configurer ceci dans chaque logiciel individuellement (s’ils le proposent).

Pour Firefox, il est également recommandé dans about:config de passer la variable network.proxy.socks_remote_dns à true, afin que les DNS soient résolus également de l’autre côté du tunnel (sur le réseau « sûr »).

Vous trouverez plus d’infos sur mon billet concernant SSH.

Conclusion

La connexion à des points d’accès WiFi publics demandant à chaque fois une authentification ou une acceptation des conditions d’utilisation devient rapidement insupportable. Il est donc appréciable de l’automatiser.

De plus, ces réseaux ne sont pas « sûrs », n’importe qui peut écouter le trafic. Il est donc nécessaire de le chiffrer en passant par un réseau de confiance, par exemple avec un tunnel SSH.

1101 est à lire en binaire, ça fait légèrement moins qu’en décimal

Gnome

Positionnement d’un ascenseur

Il y a plusieurs interactions possibles avec un « ascenseur » (horizontal ou vertical) :

• un clic sur les petites flèches permettent de déplacer le curseur ligne par ligne ;
• un clic dans la partie grisée permet de déplacer le curseur page par page ;
• un glisser-déposer (clic gauche maintenu sur le curseur pendant un déplacement) permet de placer le curseur à volonté.

Il y existe une 4e méthode, moins connue, mais bien plus pratique, qui permet de positionner le curseur directement à une position (comme le glisser-déposer, mais sans avoir besoin d’aller chercher le curseur) : il suffit de cliquer avec le bouton du milieu à la position désirée dans la barre, le curseur va s’y positionner aussitôt. En maintenant enfoncé le clic milieu, il est également possible de déplacer le curseur.

Ceci fonctionne également pour les sliders, par exemple pour le contrôle du volume dans l’applet de son de Gnome, ou pour la barre d’avancement d’un lecteur vidéo (même si maintenant ils ont adopté ce comportement par défaut sur le clic gauche).

Contrôle du volume

Lorsque l’on clique sur l’applet de son de Gnome, un slider permettant de changer le volume apparaît. Mais il est également possible de survoler l’icône de son et d’augmenter ou de diminuer le volume grâce à la molette de la souris, sans cliquer.

Déplacement d’un applet

Sous Gnome, les barres du haut et du bas accueillent des applets. Avec un clic-droit sur l’un d’entre eux, un menu contextuel permet, entre autres, de le déverrouiller pour pouvoir le déplacer.

Si l’applet est déverrouillé, ce même menu permet de le déplacer. Mais pour cela il y a plus simple : glisser-déposer l’applet en utilisant le clic milieu (cliquer et maintenir enfoncé le clic milieu et déplacer l’applet).

Les icônes de raccourcis étant des applets particuliers, ils sont déplaçables de cette manière.

Double-panneau Nautilus

Nautilus permet d’afficher deux panneaux côte à côte en pressant la touche F3.

Une seconde pression sur F3 repasse en mode « un seul panneau » (le panneau inactif est alors supprimé). Cette fonctionnalité est très pratique pour faire des déplacements ou des copies de fichiers, de manière beaucoup plus directe que par l’utilisation de plusieurs fenêtres ou même d’onglets.

Renommage avec ou sans extension

Pour renommer un fichier dans Nautilus, vous connaissez sûrement la touche F2, qui renomme en présélectionnant le nom du fichier sans l’extension :

Mais il est également possible de renommer en présélectionnant le nom du fichier avec l’extension, grâce à Shift+F2.
EDIT : Ou alors, deux fois F2.

Compiz

Déplacement d’une fenêtre

Cette fonctionnalité est assez connue et utilisée je pense, puisqu’elle fonctionne avec quasiment tous les gestionnaires de fenêtres : le déplacement d’une fenêtre grâce à Alt+clic gauche. Elle est très pratique, car elle évite d’aller chercher la barre de titre pour déplacer une fenêtre.

Redimensionnement d’une fenêtre

De la même manière, il est possible de redimensionner une fenêtre grâce à Alt+clic milieu. Celle-ci est quasiment indispensable, tellement le fait d’aller chercher un bord de fenêtre est « coûteux ».
La fenêtre est virtuellement découpée en 9 parties égales (3 horizontales et 3 verticales). Lorsque vous laissez enfoncée la touche Alt et que vous appuyez sur le clic milieu au-dessus d’une fenêtre, le redimensionnement commence à partir du bord le plus proche (dépendant de la « partie » de la fenêtre que vous survolez).

Capture d’écran rapide par zone

Grâce à Compiz, il est possible de capturer très simplement une zone de l’écran, grâce à Super+clic gauche (la touche Super est la touche Windows sur la majorité des claviers) :

Pour cela, il faut activer le plug-in « Capture d’écran » dans ccsm (compizconfig-settings-manager doit être installé), et choisir un répertoire de destination (le bureau par exemple, j’en avais déjà parlé ici).

Changement de bureau

Par défaut, le changement de bureau est désactivé lors du déplacement d’une fenêtre sur un bord et lors d’un scroll avec la molette de la souris sur le bureau. Personnellement, je préfère l’activer.
Cela se configure dans ccsm (là encore, compizconfig-settings-manager doit être installé).

Pour changer de bureau lors d’un déplacement de fenêtre au bord de l’écran : Bureaux sur un plan (version améliorée) → Changement de bureau aux bords (dernier onglet)→ Changement en déplaçant une fenêtre au bord (2e case à cocher).
Pour changer de bureau lors d’un scroll : Changeur de bureau → Desktop-based viewport switching → Bureau suivant = Button5 ; Bureau précédent = Button4.

Firefox

Ajout d’un lien dans gnome-panel

Pour garder en mémoire une URL, la méthode la plus simple et la plus appropriée est bien sûr l’utilisation de marque-pages. Mais je trouve pratique de mettre un raccourci dans la barre de Gnome, pour une page que je veux lire plus tard.
Pour cela, il suffit de glisser-déposer le petit icône (le favicon) à gauche de la barre d’adresse vers la barre de Gnome. Il est par contre regrettable que l’icône du raccourci ainsi créé ne soit pas le favicon.

Suppression d’un historique de liste déroulante

Lorsqu’une liste déroulante propose des résultats déjà entrés auparavant (à partir de l’historique par exemple), il est possible de supprimer spécifiquement une entrée rapidement, en survolant avec la souris l’entrée correspondante et en appuyant sur Shift+Suppr.

Cela fonctionne dans la barre d’adresse, dans la barre de recherche et dans toute entrée de formulaire d’une page web.

Chargement d’une URL par un clic milieu

Lorsqu’une URL est présente dans le presse-papier, il est possible de la charger dans Firefox avec un simple clic milieu. Pour activer cette fonctionnalité, il faut taper about:config dans la barre d’adresse et passer la valeur de middlemouse.contentLoadURL à true.

Il suffit alors de surligner une URL (dans un fichier texte par exemple) puis de cliquer milieu dans le contenu d’une page dans Firefox (sur un espace « vide », pas sur un lien ou dans un champ de formulaire).

EDIT : Ou sans modifier la configuration par défaut, voir commentaire #1.

Notifications intégrées

Les notifications de Firefox ne sont pas intégrées au système : par défaut c’est un rectangle qui s’ouvre en bas à droite.
Pour utiliser le système de notification d’Ubuntu, il suffit d’installer le paquet xul-ext-notify (anciennement firefox-notify) et de redémarrer Firefox. C’est dommage qu’il ne soit pas installé par défaut.

Conclusion

Voilà les quelques astuces que je pouvais partager avec vous. Si vous en avez d’autres, n’hésitez pas à les détailler.

MPD est un lecteur audio libre un peu particulier : il fonctionne suivant le modèle client/serveur. Le serveur lit la musique, et les clients font office de télécommande (évoluée).

Typiquement, le serveur est installé sur une machine reliée aux enceintes du salon, et les clients sont installés sur chacun des ordinateurs et des téléphones (ainsi que sur le serveur lui-même s’il est relié à un écran).

Serveur

Installation

L’installation est extrêmement simple (testé sur Ubuntu 10.10), il suffit d’installer mpd :

sudo apt-get install mpd

Ensuite, il y a quelques petites lignes à modifier dans le fichier de configuration /etc/mpd.conf.
Tout d’abord, il faut définir le répertoire du serveur qui contient la musique :

music_directory                "/home/rom/Musique"

Il vaut mieux commenter la ligne bind_to_address (pour éviter pas mal de problèmes) :

#bind_to_address               "localhost"

Pour que MPD ne monopolise pas le son de tout le système, commenter la ligne :

#	device		"hw:0,0"	# optional

Enfin, pour pouvoir changer le volume, décommenter la ligne :

mixer_type                     "software"

Mise à jour de la base de données

La première fois, et à chaque fois que de nouveaux fichiers sont ajoutés au répertoire de musique, la base de données doit être mise à jour :

sudo mpd --create-db

(le serveur doit être stoppé pour mettre à jour la base de cette manière)

Des logiciels clients permettent également de mettre à jour la base d’un simple clic.

Vérifiez bien que les fichiers contenus dans ce répertoire sont bien lisibles par tous (en particulier par l’utilisateur mpd). Si ce n’est pas le cas, modifiez les droits avec :

chmod +r -R /home/rom/Musique

Démarrage et arrêt

Pour démarrer le serveur :

sudo service mpd start

Pour le stopper :

sudo service mpd stop

Il démarrera automatiquement à chaque démarrage du système.

Clients

Les clients permettent de gérer la lecture à distance. Il est possible d’ouvrir plusieurs clients à la fois (un sur l’ordinateur et un sur le téléphone par exemple) qui resteront synchronisés avec le serveur. La lecture ne s’arrête pas lors de la fermeture du client. Chaque client a juste besoin de l’IP du serveur et du port (par défaut 6600).

Il en existe de nombreux pour toutes les plateformes. Malheureusement, beaucoup ne sont pas stables et souffrent de problèmes d’ergonomie. Globalement, ils sont moins agréables à utiliser qu’un vrai lecteur de musique installé localement (mais les contraintes ne sont pas les mêmes).

Je vais en présenter deux, un pour Gnome et un pour Android.

Ario

Après avoir testé de nombreux clients pour PC, mon choix s’est porté sur Ario :

Quelques avantages qui m’ont convaincu :

• il est très bien intégré à Gnome (y compris avec le système de notifications utilisé par Ubuntu) ;
• il ressemble beaucoup à Rhythmbox dans son utilisation ;
• le double-clic sur un album peut être configuré pour remplacer la liste de lecture (plutôt que d’ajouter son contenu à la fin, sans le lire immédiatement), contrairement à de nombreux clients ;
• l’interface ne reste pas figée systématiquement lors d’une communication avec le serveur ;
• la base de données du serveur peut être mise à jour en un clic…

DMix/MPDroid

Du côté d’Android, il y a beaucoup moins de clients. J’ai choisi DMix/MPDroid (qui est un fork de PMix) :

C’est un simple fichier apk à installer.

Dans la bibliothèque, lors de la navigation dans la liste des albums, une pression longue ajoute l’album sélectionné à la liste de lecture alors qu’une pression courte permet de naviguer vers les titres de l’album (pour les ajouter un par un). Le fonctionnement est similaire pour la liste des artistes. C’est bon à savoir

Aller plus loin

Je me suis contenté ici de décrire les fonctionnalités de base de MPD qui me sont utiles. Mais il est également possible de le configurer en serveur de streaming, pour lire la musique du serveur sur un ordinateur ou un téléphone. OpenSyd en parle à la fin d’un récent billet.

Conclusion

Ce lecteur est vraiment très pratique pour une gestion centralisée de la musique chez soi, et permet de toujours lire la musique sur le système son du salon (plutôt que sur la sortie audio de l’ordinateur).

C’est en fait possible, grâce à l’outil adb du SDK Android, à partir la connexion USB de l’ordinateur.

Configurer le téléphone

Pour que l’outil d’installation puisse fonctionner, il faut activer l’option Paramètres > Applications > Développement > Débogage USB sur le téléphone.

Configurer l’ordinateur

Il faut télécharger Android SDK, malheureusement non libre.

Sous GNU/Linux (plus précisément Ubuntu 9.10, adaptez selon votre distribution), voici comment l’installer et permettre la reconnaissance du Motorola Milestone (plus d’infos ici) :

sudo tar xzf android-sdk_r07-linux_x86.tgz -C /opt
sudo ln -s /opt/android-sdk-linux_x86/tools/adb /usr/local/bin
echo 'SUBSYSTEM=="usb", SYSFS{idVendor}=="22b8", MODE="0666"' | sudo tee /etc/udev/rules.d/51-android.rules
sudo service udev reload

Si vous utilisez un système 64 bits, vous aurez besoin également besoin de ia32-libs :

sudo apt-get install ia32-libs

Vous pouvez maintenant brancher votre téléphone sur le PC en USB. Pour vérifier que tout fonctionne :

$ adb devices
List of devices attached
040140621600C00D	device

Installer une application

En ligne de commande

Pour installer une application à partir de l’ordinateur, rien de plus simple :

$ adb install -r ConnectBot-svn-r466-all.apk
2343 KB/s (642578 bytes in 0.267s)
	pkg: /data/local/tmp/ConnectBot-svn-r466-all.apk
Success

(-r permet d’écraser si l’application est déjà installée)

À partir d’un gestionnaire de fichiers

Vous pouvez ensuite ajouter la possibilité d’installer les .apk graphiquement à partir de votre gestionnaire de fichiers. Si vous utilisez nautilus, vous pouvez jouer avec nautilus-actions :

Voici la commande de mon action nautilus (j’ouvre un xterm pour avoir le résultat de l’installation, si vous avez mieux, n’hésitez pas) :

xterm -T adb -e 'cd "%d" && /usr/local/bin/adb install -r "%f"; sleep 5'

Conclusion

J’ai réinitialisé mon téléphone, il n’a plus de compte gmail associé et je n’ai pas accepté les conditions du market, ce qui ne m’empêche donc plus d’installer les applications dont j’ai besoin.

Même pour ceux qui veulent garder leur compte ou utiliser le market, c’est quand même plus rapide d’installer un .apk grâce à un clic-droit, « installer » à partir du gestionnaire de fichiers plutôt que de copier le .apk sur la carte SD, débrancher le câble USB, aller dans une appli qui va chercher le fichier et cliquer sur « installer ».

Il est possible de faire la même chose sous GNU/Linux grâce à scanmem, qu’il faut installer :

sudo apt-get install scanmem

Nous allons le tester sur Gnometris (le Tetris-like intégré à Gnome) pour exploser le record.

Lançons le jeu, et récupérons son pid :

$ gnometris &
[1] 30814

Démarrons scanmem avec comme paramètre le pid de Gnometris :

sudo scanmem 30814

(oui, il faut être root pour lire et écrire la mémoire des autres programmes lancés, c’est plutôt rassurant)

On obtient un joli prompt :

0> 

Il va falloir tout d’abord trouver où se trouve en mémoire la variable à modifier (celle qui contient le score courant). Pour cela, c’est très simple, vu que le score est affiché à l’écran, il suffit d’indiquer à scanmem sa valeur. Pour l’instant, mon score est de 0, je rentre donc 0 :

0> 0
info: 01/126 searching   0x621000 -   0x623000...........ok
info: 02/126 searching  0x1f9d000 -  0x2f4e000...........ok
…
info: 125/126 searching 0xe83f9000 - 0xe83fa000.ok
info: 126/126 searching 0xdab4b000 - 0xdab67000.ok
info: we currently have 12352024 matches.
12352024> 

Il y a donc 12352024 variables dans la mémoire utilisée par Gnometris qui sont à 0 (pas étonnant).

Je joue un peu, histoire de faire évoluer le score… tac tac tac tac… Voilà, j’ai 100 points (j’ai fait 2 lignes), je tape donc 100 :

12352024> 100
info: we currently have 36 matches.
36> 

Il y a 36 variables qui étaient à 0 tout à l’heure et qui sont à 100 maintenant. Je rejoue, je fais 1 ligne, j’ai 140 points, je tape donc 140 :

36> 140
info: we currently have 1 matches.
info: match identified, use "set" to modify value.
info: enter "help" for other commands.

Voilà, j’ai trouvé la variable qui contient le score, maintenant je peux la modifier :

1> set 12345678
info: setting *0x22e38f0 to 0xbc614e...

Rien ne se passe dans le jeu, c’est normal : pour Gnometris, le score n’a pas pu changer, le label de l’interface graphique contenant le score n’a donc pas été rafraîchi. Il suffit de gagner quelques points pour s’apercevoir que la modification a bien été prise en compte :

Ça fonctionne bien évidemment sur tous les programmes, mais c’est plus intéressant pour les jeux

C’est quand même plus pratique d’obtenir un aperçu du document comme ceci :

EDIT: en fait c’est beaucoup plus simple que prévu.

Il suffit d’installer les paquets libgsf-bin et imagemagick :

sudo apt-get install libgsf-bin imagemagick

et de redémarrer la session.

Faites le test :

• ouvrez firefox ;
• copiez un bout de texte sur une page internet ou l’url de la barre d’adresse (sélectionnez puis Ctrl+C) ;
• fermez firefox (toutes les fenêtres) ;
• ouvrez un éditeur de texte (gedit par exemple) ;
• collez-y le contenu que vous avez copié (Ctrl+V) ;
• 

Eh oui, le contenu du presse-papiers est perdu en même temps que la fermeture du programme d’où il provient…

Pour éviter cela, il faut un Gestionnaire de presse-papiers. KDE en a un par défaut : klipper.

Sous Gnome, il faut en installer un. Il en existe plusieurs, mais personnellement je vous conseille parcellite. Il suffit de l’installer, il se lancera tout seul à chaque démarrage. Il ajoute une icône dans le systray, à partir de laquelle il est possible de le configurer, mais le principal, c’est qu’il permette de ne pas perdre le contenu copié… Il mémorise aussi les n derniers contenus (configurable). Petit inconvénient, il n’est pas en français, mais de toute façon une fois lancé, on n’y touche plus.

Sinon, il existe également glipper sous la forme d’un applet à ajouter au tableau de bord, mais le problème est qu’il plante à quasiment chaque démarrage du système (même si une fois lancé il fonctionne bien).

• c’est en anglais ;
• les actions sont effectuées par défaut sur simple clic ;
• les polices de caractères ne sont pas à la même taille ;
• le thème ne s’intègre pas du tout dans l’environnement Gnome…

Applis KDE en Français

Pour le premier problème, c’est vite réglé, il suffit d’installer le paquet kde-i18n-fr :

sudo apt-get install kde-i18n-fr

EDIT: Sous Ubuntu Lucid Lynx (10.04), le paquet s’appelle maintenant kde-l10n-fr :

sudo apt-get install kde-l10n-fr

SystemSettings

Pour le reste, si on ne veut pas éditer des fichiers de configuration à la main, il faut la fenêtre de configuration de KDE : systemsettings. Mais si on n’installe que ce paquet, la fenêtre de configuration est presque vide ; pour pouvoir tout configurer, il faut également le paquet kdebase-workspace-bin (et ses dépendances)… et ça quand on ne le sait pas, on galère !

sudo apt-get install systemsettings kdebase-workspace-bin

Une fois installé, il suffit de lancer systemsettings (Applications → Outils Système → System Settings).
Quelques icônes n’apparaissent pas (elles sont remplacées par l’icône par défaut), ça n’est pas bien grave.

EDIT: Attention, ceci risque de modifier le rendu des polices de caractères dans certaines applications (notamment Firefox), à cause de certaines configurations par défaut de KDE. Pour résoudre ce problème, il faut supprimer (ou renommer) le fichier ~/.fonts.conf :

mv ~/.fonts.conf{,.old}

Apparence

Dans la configuration de l’apparence (première icône), il est possible de modifier le style (choisir GTK+ au lieu de Oxygen pour une meilleure intégration dans Gnome), le thème d’icônes (par exemple Human) et les polices de caractères (même si personnellement, je n’arrive pas à avoir le même rendu que les polices de Gnome, au moins je peux les mettre à la même taille).

Comportement de la souris

Dans le menu principal de systemsettings, vers le bas se trouve le bouton Clavier & Souris : c’est là qu’il est possible de configurer le comportement de la souris, en particulier effectuer les actions sur double clic plutôt que sur simple clic :

Résultat

Et voilà le résultat pour la fenêtre de dolphin (le navigateur de fichiers de KDE4) :

Principe

Je ne vais pas expliquer comment fonctionne le chiffrement, c’est déjà bien expliqué sur wikipedia. Il est important de comprendre le principe.
Il y a également ce site (en .gouv.fr) qui est sympa pour débuter.

Pour résumer, si A possède une clé publique Apub et une clé privée Apriv, si B possède une clé publique Bpub et une clé privée Bpriv. et si A envoie un message à B :

• A peut chiffrer son message pour B en utilisant Bpub ;
• A peut signer son message en utilisant Apriv ;
• B peut déchiffrer le message reçu de A en utilisant Bpriv ;
• B peut vérifier la signature du message reçu de A en utilisant Apub.

Créer sa paire de clés

Pour créer sa paire de clés (une clé publique et une clé privée) :

• ouvrir Applications → Accessoires → Mots de passe et clés de chiffrement ;
• dans la fenêtre qui s’ouvre, cliquer sur Fichier → Nouveau… (Ctrl+N) ;
• choisir « Clé PGP (utilisée pour chiffrer les courriels et les fichiers) » et cliquer sur Continuer.

Quelques informations sont demandées :

Personnellement, je préfère décocher « N’expire jamais », et faire expirer la clé au bout de deux ans, on ne sait jamais…

Il ne reste plus qu’à cliquer sur Créer, une phrase de passe (un long mot de passe) est demandée, et les clés sont générées. Une nouvelle ligne apparaît alors dans « Mes clés personnelles » :

Si vous avez plusieurs e-mails et/ou adresses Jabber, vous pouvez les rajouter en cliquant droit sur votre clé, Propriétés, Noms et signatures.

Une fois créée, je vous conseille de garder une copie du répertoire ~/.gnupg, qui contient votre clé privée, sur un support externe (une clé USB).

Déverrouiller la clé privée durablement

Il est possible de laisser la clé déverrouillée pendant un certain temps après avoir tapé la phrase de passe. Cela évite de la retaper à chaque fois.
Pour changer ce comportement, il faut aller dans Système → Préférences → Chiffrement et trousseaux, dans l’onglet « Phrases de passe PGP » :

Exporter sa clé publique

Maintenant que nous avons créé notre paire de clés, il faut que notre clé publique soit accessible à ceux avec qui nous souhaitons communiquer.

Il suffit pour cela de sélectionner la clé et de cliquer sur le bouton Exporter… : la clé publique sera alors exportée dans un fichier portant l’extension .asc. Il ne reste plus qu’à envoyer ce fichier par n’importe quel moyen (mail, messagerie instantanée, clé USB…). Une fois ce fichier reçu, notre contact n’aura qu’à double-cliquer dessus (à partir du navigateur de fichiers) ou l’importer dans Fichier → Importer… (Ctrl+I).

Il est également possible de l’exporter dans le presse-papier, pour pouvoir la coller n’importe où avec Ctrl+V, sans passer par un fichier : il suffit pour cela de cliquer-droit sur la clé, puis de cliquer sur « Copier ».

Pour une diffusion plus globale, il existe des serveurs de clés : ils répertorient les clés publiques de tout le monde. Par exemple, il est possible de publier sa clé sur http://pgp.mit.edu, en y copiant le contenu du fichier .asc exporté.
Attention : une clé publiée ne sera jamais supprimée du serveur, elle pourra simplement être révoquée, en créant un certificat de révocation, indiquant à tous que votre clé est invalide. Ne publiez donc que votre clé « définitive ».
Il est également possible de configurer le gestionnaire de clés pour qu’il les publie et synchronise directement, en activant dans Édition → Préférences → Serveurs de clés → « Publier les clés sur… ».

Grâce à ces serveurs de clés, il est facile de trouver la clé publique d’une personne directement dans le gestionnaire de clés. Il faut cliquer sur le bouton « Chercher des clés distantes… » et taper le nom de la personne, son mail ou l’identifiant de sa clé (la suite de 8 caractères hexadécimale qui apparaît dans la liste des clés) :

Et le résultat :

(la première est barrée car c’était mon ancienne clé, que j’ai révoquée lorsque mon ordinateur a été volé)
Il ne reste plus qu’à cliquer sur Importer.

Signer les clés obtenues de confiance

Une fois la clé d’un contact récupérée, il est possible de la signer pour indiquer qu’on a confiance en cette clé. Certains logiciels n’acceptent d’ailleurs que les clés de confiance. Pour cela, dans l’onglet « Autres clés obtenues » du gestionnaire de clés, il faut cliquer-droit sur une clé, puis « Signer la clé… » :

(si vous ne connaissez pas la personne « en vrai », n’hésitez pas à choisir « Pas du tout » à la question posée)

Voilà, maintenant tout est en place, nous pouvons commencer à chiffrer et à signer.

Chiffrer et signer des fichiers

C’est très simple : il suffit de cliquer-droit sur un fichier, et de choisir Chiffrer ou Signer :

Ces fonctions nécessitent le paquet seahorse-plugins, qui n’est plus installé par défaut dans Ubuntu 9.10).

Chiffrer

L’outil de chiffrement demande les destinataires qui pourront déchiffrer le fichier (avec leur clé privée). Tous ceux n’étant pas dans la liste des destinataire n’auront aucun moyen de déchiffrer le fichier ; en particulier, il peut être utile de s’ajouter en destinataire.
Il est également possible de signer le fichier en même temps (pour que celui qui le déchiffre soit sûr de l’identité de celui qui l’a chiffré).

Il ne reste plus qu’à cliquer sur Valider. Lorsque l’on choisit de signer le fichier en même temps, la phrase de passe de la clé privée est demandée. Ensuite, le fichier est chiffré dans un nouveau fichier portant l’extension .pgp (alors qu’en ligne de commande, cela crée un fichier .gpg, mais peu importe).

Pour le déchiffrer, il suffit de double-cliquer dessus.

Signer uniquement

L’outil de signature demande avec quelle clé nous souhaitons signer (utile si plusieurs utilisateurs utilisent chacun une clé), demande ensuite la phrase de passe (pour déverrouiller la clé), et crée la signature dans un fichier portant l’extension .sig.

Pour vérifier la signature, il suffit de double-cliquer sur ce .sig, une notification indiquera si la signature est valide :

Si le fichier est assez volumineux, cela peut prendre un moment (20 ou 30 secondes), et parfois aucune fenêtre ne s’ouvre indiquant que la vérification est en cours, ce qui est assez perturbant ; mais le processeur, lui, tourne bien à plein régime pour vérifier la signature.

Chiffrer et signer des e-mails (avec Evolution)

Dans Evolution (le gestionnaire de mails par défaut sous Ubuntu), il faut associer la clé que nous avons créée avec le compte mail. Pour cela, ouvrir le menu Édition → Préférences → Comptes de messagerie, sélectionner le compte de messagerie auquel associer la clé, et cliquer sur Édition. Dans l’onglet « Sécurité », recopier l’identifiant de la clé en question, et valider.

Ensuite, lors de la rédaction d’un message, il est possible d’activer la signature et le chiffrement :

Pour que le chiffrement fonctionne, il faut évidemment avoir dans le trousseau de clés les clés publiques de tous les destinataires du mail.

Lorsque nous recevons un message chiffré et/ou signé, Evolution vérifie la signature et déchiffre le mail. Pour l’illustrer, je me suis envoyé à moi-même un message chiffré et signé, lorsque je l’ouvre, Evolution me demande la phrase de passe (pour déchiffrer le message), et ensuite me l’affiche de cette manière :

Chiffrer ses communications Jabber (avec Gajim)

Dans gajim (le client Jabber de référence), il faut associer la clé avec le compte Jabber. Pour cela, ouvrir le menu Édition → Comptes, sélectionner le compte, et dans l’onglet « Informations personnelles », choisir la clé à associer. Au passage, activer la case « Utiliser un Agent GPG ».

Une fois la clé associée au compte, gajim va toujours se connecter en « signant la présence ». Et qui dit signature dit déverrouillage de la clé privée, et donc demande de la phrase de passe à chaque démarrage de gajim. Il est possible de désactiver la signature de la présence : Édition → Préférences, onglet « Avancées » → « Éditeur de configuration avancé » → Ouvrir… et faire passer gpg_sign_presence à « Désactivé ».

Ensuite, il faut avoir les clés publiques des contacts avec qui nous souhaitons communiquer de manière chiffrée. Ces clés doivent être « de confiance » (voir la section « Signer les clés obtenues de confiance » au début de ce billet). Pour assigner une clé à un contact Jabber, il faut cliquer-droit sur ce contact, Gérer le Contact → Assigner une clé OpenPGP… :

Ensuite, lors de la conversation, il est possible d’activer le chiffrement :

Inutile de vous dire que pour la messagerie instantanée, il vaut mieux avoir configuré le trousseau pour que la clé soit déverrouillée durablement, afin de ne pas retaper la phrase de passe à chaque message (voir la section « Déverrouiller la clé privée durablement » au début de ce billet).

Seahorse-applet : l’applet Gnome

Un applet Gnome permet de chiffrer, déchiffrer et signer le presse-papier. Sachant que le presse-papier contient ce qui est surligné avec la souris (ou ce qui est copié avec Ctrl+C), c’est parfois bien pratique. Pour l’ajouter, il faut cliquer droit sur un panel de Gnome (la barre du haut par exemple), puis « Ajouter au tableau de bord… », et l’ajouter :


Petit plus, lorsque le presse-papier contient une clé, l’applet permet de l’importer directement dans le trousseau de clés. Une fois que vous avez ajouté l’applet, essayez de sélectionner tout le texte de cette page (c’est ma clé publique) :
Ensuite, cliquez sur le bouton de l’applet : vous pourrez importer ma clé directement.

Merci à cyril pour cette astuce

Aller plus loin

Pour plus d’infos sur l’outil gpg, rendez-vous sur le site officiel (en anglais) sur sur la doc ubuntu-fr.
Vous pouvez également consulter man gpg pour l’utiliser en ligne de commande.

Pour chiffrer son dossier personnel (/home), c’est ici.

J’utilisais New Wave, mais je viens de me rendre compte qu’il ralentit énormément l’affichage. Par exemple, dans deluge (un client torrent), mettez en téléchargement plusieurs torrents (les différentes iso d’Ubuntu), et essayez de redimensionner une colonne : c’est très lent. Pareil dans rhythmbox (mais un peu moins flagrant). Et d’une manière générale je trouvais que le système, ou du moins son affichage, était assez lent (mais ça reste utilisable), le redimensionnement de colonnes dans deluge n’étant qu’un révélateur.

Puis j’ai sélectionné le thème par défaut (Human), et là c’est très fluide, le redimensionnement de colonne dans deluge est très rapide. Aucun problème non plus avec les autres thèmes (Dust par exemple), c’est vraiment lié à New Wave.

C’est dommage, j’aimais bien ce thème.

Définitions

Afin de comprendre les problèmes, il est important de définir chacun des concepts (je limite ici leur définition au cas d’une image numérique affichée sur un écran).

pixel

Le pixel, abrégé px, est une unité de surface permettant de définir la base d’une image numérique. Son nom provient de la locution anglaise « picture element », qui signifie « élément d’image » ou « point élémentaire ». Il n’a a priori pas de taille « réelle ».

point

Le point (Pica), abrégé pt, est une unité de longueur. Un point pica mesure 1/72e de pouce (1 pouce = 2,54 cm), c’est-à-dire environ 0,03528 cm, soit un peu plus d’un tiers de millimètre.

résolution

La résolution permet de donner une taille réelle à un pixel. Elle est souvent exprimée en DPI (Dot Per Inch : Point Par Pouce). Attention, dans cette unité, le point signifie pixel (et non point Pica, puisque par définition, le nombre de points Pica par pouce est toujours 72, tout comme le nombre de millimètres dans un centimètre est toujours 10).

définition

La définition d’une image ou d’un écran est le nombre de pixels qui composent l’image ou que peut afficher un écran. Elle est souvent donnée sous la forme nombre de pixels horizontalement × nombre de pixels verticalement, par exemple 640×480.

Résolution dpi de l’écran

Intérêt du dpi

Combien mesure sur l’écran une image en 640×480 ?
Quelle est la hauteur en pixels d’un texte en taille 18 pt ?
Cela dépend de la taille des pixels ! Par exemple, une image en 640×480 sera 4 fois plus petite (2 fois dans chaque dimension) sur écran 7″ que sur un écran 14″, si les deux écrans ont la même définition (disons 1024×768). Pareil pour la taille d’un texte.

Quelle taille en pixels doit avoir un rectangle de 13×8 cm ?
Cela dépend également de la taille des pixels : le rectangle sera « plus petit » (en pixels) sur un écran de moindre définition.

Pour déterminer la réponse à ces questions, la connaissance de la résolution, exprimée en dpi, est nécessaire : elle permet de faire la conversion entre une mesure réelle (homogène aux centimètres) et une mesure en nombre de pixels.

Valeur réelle du dpi de l’écran

En ligne de commande

Pour connaître le dpi d’un écran, il suffit de taper :

xdpyinfo | grep resolution

À la main

Il est également possible d’effectuer le calcul à la main (comme je l’ai fait sur le post et sur le bug report cités au début), en connaissant d’une part la définition de l’écran, et d’autre part :

• soit la diagnole d’écran (15,4″ par exemple) ainsi que le ratio (16/10) ;
• soit la hauteur et la largeur (en centimètres par exemple).

Juste pour illustrer le premier exemple, avec ces calculs on trouve qu’un écran 7″ en 1024×768 a une résolution de 183 dpi, et donc qu’une image en 640×480 affichée à l’écran mesure précisément 3,5×2,625″ (8,89×6,6675 cm). De même, un écran 14″ en 1024×768 a une résolution de 91,5dpi, et donc qu’une image en 640×480 affichée à l’écran mesure précisément 7×5,25″ (17,78×13,335 cm).

On remarque que si l’on fait une capture d’écran de ces deux images, dont la surface de l’une 4 fois plus petite que celle l’autre, le résultat sera identique (en 640×480) : une capture d’écran (une image numérique) affichée à l’écran ne prend en compte que la taille en pixels. Ceci a une conséquence importante : une fenêtre F1 sur un écran E1 plus petite qu’une fenêtre F2 sur un écran E2 peut apparaître plus grande sur des captures d’écran.

Valeur du dpi configurée

Le système, en connaissant le dpi, est donc capable d’afficher des objets dont les mesures sont exprimées en centimètres (ou unités homogènes, comme les pouces).

Le problème, c’est qu’il n’utilise pas toujours la valeur « réelle » du dpi : il utilise souvent une valeur pré-configurée (72 ou 96), indépendante de l’écran. La résolution dpi, seule valeur permettant de faire le lien avec la mesure réelle, est choisie arbitrairement : elle ne sert donc à rien. Tout cela avait un sens physique à l’origine, où le matériel avait toujours une résolution très proche de 72 ou de 96 (voir cet article).

Pour continuer à lui donner un sens, il faut que le système utilise le dpi réel de l’écran : c’est le cas depuis KDE4 et Gnome 2.25 ; Windows et MacOS, quant-à-eux, continuent à utiliser une valeur pré-configurée dénuée de sens.

On a donc, dans les deux environnements de bureau principaux sous GNU/Linux, une valeur correcte du dpi : c’est donc gagné !

Malheureusement, ce n’est pas si simple.

Problèmes

Problèmes théoriques

Nous possèdons un écran 15,4″ de définition 1024×768, et nous souhaitons le remplacer par un nouvel écran 15,4″ de définition 2048×1536 (donc de résolution double).

Comment doit se comporter l’affichage des polices de caractères ?
Deux solutions :

• la taille des polices reste identique en pixels (px) : la taille apparente est donc deux fois plus petite (dans chaque dimension) ;
• la taille des polices reste identique en points (pt) : la taille apparente ne change pas, mais chaque caractère est composée de plus de pixels.

La réponse n’est pas évidente.

La première proposition qui consiste à garder la taille identique en pixels ne peut pas être absolument vraie : si nous utilisions un écran 15,4″ de définition 20480×15360 (pourquoi pas?), des lettres de 18 pixels seraient totalement illisibles par l’œil humain.

La seconde semble donc plus valable, mais nous pouvons objecter que la taille des caractères que nous avions sur notre écran 15,4″ en 1024×768 est plus grande que celle dont nous avons réellement besoin : nous ne pouvions pas la diminuer à cause de la faible résolution de l’écran (une lettre représentée par 4 pixels n’est qu’une tache noire). Un écran de meilleure résolution permettrait de diminuer la taille du texte afin d’obtenir une taille réelle « meilleure ».

Nous pouvons également faire remarquer, de manière peut-être moins rigoureuse, que si nous avons investi dans un écran de meilleure définition, c’est pour « avoir plus de place ».

Mon point de vue est donc celui-ci : il existe un ensemble de tailles (une taille pour les titres, une pour les sous-titres, une pour les paragraphes…), exprimées en points, idéales. Plus nous nous en éloignons, plus nous avons une impression de « trop gros » ou « trop petit ». La seconde proposition, qui consiste à garder la taille des polices identique en points est d’après moi asymptotiquement vraie : que nous possédions un écran 20480×15360 ou 40960×30720 ne doit pas changer la taille apparente des polices.
Mais pour des résolutions trop petites (72 ou 96 dpi par exemple), une contrainte intervient fortement : les caractères doivent avoir une forme reconnaissable, et être « suffisamment lisses ». Impossible alors d’afficher des caractères dont la taille réelle serait lisible, mais dont l’équivalent en pixels est trop faible : nous sommes alors obligé d’augmenter artificiellement la taille réelle des polices de caractères.

Remarque: Ce raisonnement n’est valable que pour le changement de la résolution sur un écran de même taille réelle. Si nous voulions définir comment doit se comporter l’affichage sur un écran de résolution identique mais de taille plus grande (donc de meilleure définition), il faudrait prendre en compte l’éloignement des yeux par rapport à l’écran (nous sommes plus proches de l’écran sur un écran 7″ que sur un écran 45″). A priori, je dirais ce que qui est asymptotiquement vrai n’est pas la conservation des tailles en points, mais la conservation des angles que forment le haut et le bas d’un caractère avec l’œil (ce qui est équivalent si on conserve un écran de même taille).

Si vous avez des remarques ou d’autres explications, je suis tout à fait ouvert

Problèmes pratiques

En pratique, c’est compliqué.

La majorité des applications utilise des tailles de polices de caractères exprimées en points, mais des parties de l’interface sont exprimées en pixels. Par exemple, la barre de menu de Gnome a par défaut une hauteur de 24px… et son texte a une taille de 10pt. Ces mesures donnent un rendu cohérent à 96 dpi, mais plus le dpi augmente, plus le texte est « gros » par rapport à la barre (les variations de dpi ne font varier que les mesures exprimées en points). Voici le rendu par défaut sur mon écran 130 dpi :

Pour les applications, ce problème est contournable : on peut facilement les configurer pour définir la taille des composants ou la taille des polices.

Mais le plus gros problème se pose sur les sites internet : certains sites expriment leurs mesures en pixels et d’autres en points. Plus la valeur du dpi est élevée, plus les sites exprimés en points paraîtront gros par rapport à ceux exprimées en pixels. Sans parler des nombreux sites qui mélangent les unités de mesure. Et le pire, c’est qu’il n’y a pas de « bonne manière de faire » : les tailles en pixels et les tailles en points ont chacunes leurs avantages et leurs inconvénients sur les sites internet. On ne peut donc pas espérer que ces problèmes soient gommés au fur et à mesure.

Tout ça pour ça !

La solution que j’utilise pour éviter ces différences de tailles de texte est de… faire croire à Gnome que mon écran est en 96 dpi. Comme s’il avait une diagonale de 20,85″ (15,4×130/96) : il se comporte donc exactement comme un écran 20,85″ à 96 dpi qui aurait été rétréci. Au lieu de définir mes polices en 7pt à 130 dpi, je leur donne la valeur 10pt à 96 dpi, et ça évite les incohérences de rendu.

Évidemment, comme je l’ai déjà signalé, cette solution n’est pas satisfaisante : si au lieu de 130 dpi j’avais un écran à 200 dpi, les caractères seraient beaucoup trop petits si je configurais Gnome à 96 dpi (pour lui faire croire que mon écran est un 32,08″).

La valeur arbitraire donnée au dpi par le système rendait la résolution absolument dénuée de sens ; maintenant que la valeur est correcte, je la force à une valeur incorrecte pour avoir un rendu cohérent. C’était bien la peine !

Et je ne vois aucune solution envisageable pour obtenir un rendu cohérent actuellement sur d’éventuels écrans 200 ou 300 dpi. Pourtant, on pourrait penser a priori que les résolutions d’écran ne vont pas arrêter de s’améliorer dans les années à venir : ces problèmes seront-ils un frein à leur développement?

• É : Alt+144
• A : Alt+65
• ® : Alt+169

Note : Le code ASCII est utilisé pour les nombres inférieurs à 128. Pour les autres, je ne sais pas quel codage est utilisé, d’autant que rajouter un 0 devant le nombre change le code (Alt+169 c’est ® alors que Alt+0169 c’est ©, et ® peut s’écrire aussi Alt+0174). Si quelqu’un a une explication…

Sous Ubuntu, on a peu de raison d’utiliser une telle méthode, car le layout France (Alternative), par défaut sous gnome, permet d’utiliser bon nombre de caractères spéciaux, comme vous pouvez le voir sur ce schéma :

Il y a 4 caractères possibles par touche. Voici comment écrire les caractères possibles d’une touche, en fonction de leur position sur le schéma :

• en bas à gauche : touche ;
• en haut à gauche : Shift+touche ;
• en bas à droite : AltGr+touche ;
• en haut à droite : AltGr+Shift+touche.

Ainsi, pour écrire ® (dans ®om par exemple), il suffit de faire AltGr+Shift+C, tandis que AltGr+C donne ©. De même, AltGr+Shift+2 génère un É. Pour les espagnols, le ñ peut être obtenu en pressant AltGr+^, n, le ¿ et le ¡ respectivement grâce à AltGr+? et AltGr+!.

Note : Pour les caractères majuscules se trouvant sur les touches numériques, il est également possible d’activer la touche CapsLock : avec CapsLock activé, la touche 2 génère un É.

Il est donc très simple de faire rapidement des « guillemets » ou des flèches (←↑↓→), d’écrire le mot « œuf » correctement, d’insérer un vrai signe de mutiplication (2×3) ou d’utiliser de vrais points de suspension…

Par ailleurs, certaines combinaisons de touches donnent naturellement des caractères spéciaux, par exemple ^ suivi d’un chiffre le met en exposant : ¹²³⁴⁵⁶⁷⁸⁹⁰.

Il est possible également d’utiliser la composition de caractères :

• ae → æ ;
• oe → œ ;
• ‘e → é ;
• ~n → ñ…

Pour cela, il faut définir une touche du clavier qui permettra d’activer la composition : Système → Préférences → Clavier → Agencements → Autres options… → Position de la touche Compose :

Ensuite, il suffit de laisser appuyée cette touche pendant l’écriture des caractères à composer. Sur la capture, j’ai utilisé la touche Menu, qui se trouve à droite de AltGr ; quand je laisse enfoncée cette touche et que j’écris ae, le caractère æ est généré.

En dernier recours, il est aussi possible d’écrire un caractère directement à partir de son code Unicode en hexadécimal. Pour cela, il suffit de taper : Ctrl+Shift+u+code.

Par exemple, le code hexadécimal de ® est AE (voir ici). Ainsi, Ctrl+Shift+uae insère un ®.

L’outil gucharmap (Applications → Accessoires → Table des caractères) donne, en bas de la fenêtre, le code Unicode d’un caractère sélectionné. Par exemple ‰ affiche U+2030 : pour écrire ce caractère, on peut donc taper Ctrl+Shift+u2030.

Si on veut écrire que x∊ℝ, on fait : x, puis Ctrl+Shift+u220a, suivi de Ctrl+Shift+u211d.

Il ne reste plus qu’à apprendre la table Unicode, bon courage !

En voici une très simple, grâce à Rhythmbox (le lecteur par défaut d’Ubuntu).

Pour activer le partage, dans Édition → Greffons, il suffit d’activer Partage de musique DAAP (cette case est déjà activée par défaut dans Ubuntu 8.10), de cliquer sur Configurer, et d’activer Partager ma musique.

Vous obtiendrez une nouvelle entrée dans le menu de gauche de Rhythmbox, et vous pourrez lire directement toute la musique se trouvant sur un autre ordinateur :

Rhythmbox doit resté ouvert sur l’ordinateur « serveur ».