Comme vous l'avez peut-être remarqué dans notre barre de versions, BlueGriffon, l'éditeur WYSIWYG de pages Web évoluées de Daniel Glazman, est passé en version 1.6 il y a quelques jours. BlueGriffon est basé sur Gecko, le moteur d'affichage de Mozilla (également utilisé par Firefox et Thunderbird). Il supporte les dernières évolutions des langages Web, tels que HTML5, CSS3, SVG et MathML. Il est libre et gratuit, distribué sous triple licence libre MPL / GPL / LGPL. Cette version est disponible pour Windows, Mac OS X et Linux en maintenant 19 langues dont toujours le français.

Sachant que BlueGriffon est financé par la vente d'extensions et d'un manuel de l’utilisateur (en anglais), il est préférable, si vous voulez soutenir son développement, de les acheter que d’accepter d'installer la barre d'outils « Iminent » proposée après l'installation de BlueGriffon 1.6.

Cette nouvelle version propose de nombreuses corrections de bogues et quelques nouveautés plus importantes comme de nouveaux menus « mise en page » et « imprimer », la suppression du panneau flottant et l'ajout des panneaux ancrables, d'un bouton de bloc de citation (blockquote) et d'un item de menu « Ouvrir un fichier ».

Original post of mozillaZine-fr.Votez pour ce billet sur Planet Libre.

Rédigeant mon manuscrit, je ne me voyais compiler toutes les cinq minutes mon documents pour voir si je n’ai pas fait une erreur. En effet, détecter une erreur rapidement permet de la corriger facilement surtout que les compilateurs latex et consorts donnent parfois des erreurs peu facile à décrypter.

L’idée est donc de compiler le document automatiquement à chaque dois que je l’enregistre. Une bulle (lib notify) est affichée de manière à prévenir du succès ou de l’échec. Faire ça en python, c’est très simple avec watchdog et pynotify. Quelqu’un avant moi a déjà pensé à faire quelque chose comme ça.

Dans mon cas, je n’utilise pas de makefile. Je fais donc mon appel xelatex directement. J’utilise subprocess.check_call() afin d’avoir le code de retour de xelatex.

Avec pynotify, j’ai une exception gobject.GError qui est parfois levée. Je n’ai pas d’idée de la raison. Si quelqu’un a une idée… sinon, je chercherai plus tard (ça reste Quick & Dirty).

import subprocess
import os
import time

import pynotify
from gobject import GError

from watchdog.observers import Observer
from watchdog.events import FileSystemEventHandler


class ChangeHandler(FileSystemEventHandler):
    """React to modified .tex files."""
    def on_any_event(self, event):
        """If a file or folder is changed."""
        if event.is_directory:
            return
        if os.path.splitext(event.src_path)[-1].lower() == ".tex":
            pynotify.init("Mon appli python")
            try:
                subprocess.check_call(['xelatex', '-halt-on-error' ,'thesis.tex'])
            except subprocess.CalledProcessError:
                message = pynotify.Notification("Build failed.")
            else:
                message = pynotify.Notification("Build done.")
            try:
                message.show()
            except GError:
                print('Gerror')


def main():
    handler = ChangeHandler()
    observer = Observer()
    observer.schedule(handler, '.')
    observer.start()
    try:
        while True:
            time.sleep(1)
    except KeyboardInterrupt:
        observer.stop()
    observer.join()


if __name__ == '__main__':
    main()

Original post of François.Votez pour ce billet sur Planet Libre.

Un problème récurrent avec les applications en mode texte est qu'elle n'ont pas conscience du fait que la fenêtre qui les héberge gagne, ou perd le focus. Cette information est pourtant bien utile car elle peut par exemple permettre sous VIM de sauvegarder les buffers modifiés lorsque l'on laisse l'éditeur de côté (perte de focus). Mais aussi de mettre les buffers à jour s'ils ont été modifiés à l'extérieur de VIM lorsque l'on y retourne (gain de focus). Nous allons donc voir comment rendre une application texte consciente de ces deux évènements.

Perte et gain de focus

Lorsqu'une fenêtre a le focus, tout ce qui est tapé au clavier lui est envoyé. La sélection de la fenêtre qui a ce focus est réalisée par le gestionnaire de fenêtre. Certains considèrent que le focus est là où se trouve la souris. C'est ainsi que l'on fonctionne sous Unix depuis des lustres. Du moins jusqu'à ce que la mode windowsienne ne prenne le pas et obligent en plus à cliquer dans la fenêtre à rendre prioritaire.

Le fait de perdre le focus est donc un bon moyen de dire à une application que l'on passe à une autre tâche. On a donc logiquement envie, s'agissant d'un éditeur de texte, d'en profiter pour faire une petite sauvegarde automatique.

Lorsque l'éditeur est une chose graphique (gedit, gVim), il est capable de recevoir directement les messages perte et gain de focus, envoyés par X11. En revanche lorsqu'il s'agit d'une application texte (Vim, Mutt, etc.) c'est plus compliqué car c'est l'émulateur de terminal qui reçoit ces messages. Il nous faut donc faire un pont entre le gestionnaire de fenêtre et l'application en mode texte en utilisant l'émulateur de terminal comme intermédiaire.

Construcion d'un OSC maison

Comme vous le savez déjà, les applications en mode texte conversent avec le terminal sous la forme de séquence d'échappement commençant par le code 27 (aka ESC, aka \\033).

Pour s'y retrouver, ces séquences ont des petits noms. Prenons par exemple les séquences ANSI qui permet de cacher le curseur ESC[?25l. La première partie de cette séquence ESC[ défini les commandes dites CSI (Control Sequence Introducer). On résume donc souvent dans les documentation cette commande de masquage de curseur CSI?25l.

Il existe de nombreuses autres classes de séquence (qui commencent cependant toujours par ESC), comme par exemples les OSC (Operating System Control) qui elles sont de la forme ESC] (notez le crochet dans l'autre sens). Ces séquencent permettent généralement de modifier le comportement du terminal comme par exemple changer la couleur du curseur (OSC 12;red BEL). BEL représente le code qui fait beep qui s'écrit aussi \\007.

Urxvt permet à ses plugins d'intercepter n'importe quelle séquence OSC nous permettant ainsi de composer la notre pour activer et désactiver la prise en charge du focus par le terminal. En effet, si nous ne faisons pas cela, une console ne gérant pas le focus serait rapidement polluée par les entrées/sorties du curseur de la souris.

1. Activation du mode mode "focus" par la séquence \\033]777;focus;on\\007
2. Désactivation du mode "focus" par la séquence \\033]777;focus;off\\007

Notez l'usage de 777 qui est une classe spéciale d'OSC qu'urxvt réserve aux plugins.

Pour terminer, lorsque le mode "focus" sera activé, le terminal va lui aussi émettre des séquences que VIM va interpréter. C'est un peu comme des touches "spéciales" :

1. Focus gagné par la séquence \\033UlFocusIn.
2. Focus perdu par la séquence \\033UlFocusOut.

Ces séquences ne suivent aucune normes. C'est un choix totalement arbitraire avec comme seule contrainte de ne pas taper dans une séquence existante.

Construction du plugin URxvt

URxvt dispose d'une API en perl très bien documentée (man urxvtperl) qui fournit une série d'évènements dont le gain et la perte du focus, mais aussi la gestion des séquences OSC custom.

Construire un plugin pour URxvt est relativement simple. Il suffit pour cela de créer un script perle focus que l'on place par exemple dans un dossier ~/.urxvt/perl :

#!/usr/bin/perl

# Hook invoqué au démarrage d'urxvt
sub on_start {
  my($term) = @_;
  // le mode "focus" est désactivé par défaut
  $terme->{focus_activated} = 0;
}

# Interception des séquences "OSC 777 xxx BEL"
sub on_osc_seq_perl {
  my ($term, $osc, $resp) = @_;
  return unless $osc =~ s/^focus;//;
  $term->{focus_activated} = $osc eq 'on'?1:0;
}

# Hook invoqué au gain de focus
sub on_focus_in {
  my($term) = @_;

  # Si le mode focus est activé, on envoie la notification
  if ($term->{focus_activated}) {
    $term->tt_write("\\033[UlFocusIn");
  }
}

# Hook invoqué à la perte de focus
sub on_focus_out {
  my($term) = @_;

  # Si le mode focus est activé, on envoie la notification
  if ($term->{focus_activated}) {
    $term->tt_write("\\033[UlFocusOut");
  }
}

Plugin URxvt - ~/.urxvt/perl/focus

Comme vous le voyez le plugin est assez simple. Les subs définies sont des hooks, c'est à dire des fonctions qui sont appelées par URxvt en réaction à des évènements :

• on_start est déclenché lorsque le plugin est instancé. On va y régler l'état du mode "focus" par défaut (désactivé)
• on_focus_in est déclenché lorsqu'URxvt est notifié de la prise de focus. On vérifie alors que le mode focus est activé et si c'est le cas, on écrit la séquence qui va bien dans le terminal.
• on_focus_out est déclenché lorsqu'URxvt est notifié de la perte de focus.
• on_osc_seq_perl est déclenché dés qu'URXVT reçoit une séquence OSC. On vérifie juste qu'il s'agit bien de la notre et on active/désactive le mode focus.

Une fois que ce plugin écrit, il nous reste à l'installer dans URxvt. Pour cela rajouter les lignes suivantes à ~.Xdefaults :

# On dit ou se trouvent nos extensions
URxvt.perl-lib : /home/gaston/.urxvt/perl

# Et on active l'extension "focus"
URxvt.perl-ext-common: focus

Nous pouvons maintenant relancer URxvt (éventuellement faire un coup de xrdb -load ~/.Xdefaults pour s'assurer que les ressources sont bien à jour) et tester l'activation du mode "focus" :

gaston$echo -ne "\\033]777;focus;on\\007"

Si tout c'est bien passé, en survolant la fenêtre (ou en cliquant dessus selon votre gestionnaire de fenêtres) vous devriez voir des choses apparaître. Idem en perte de focus. Les choses en question sont une tentative échouée d'interprétation de nos séquences par Bash. D'où l'intérêt de pouvoir activer/désactiver ce mode à convenance.

Implémentation du mode focus dans VIM

Maintenant que notre plugin est en place, il ne reste plus qu'à l'intégrer dans VIM :

" Initialisation du mode "focus"
exe 'silent !echo -ne "\\033]777;focus;on\\007"'

" Gestion de la séquence focusin/focusout
map ^[[UlFocusIn :bufdo checktime<CR>
map ^[[UlFocusOut :wa!
map! ^[[UlFocusIn <C-O>:bufdo checktime<CR>
map! ^[[UlFocusOut <C-O>:wa!

" Désactivation du mode focus en partant
autocmd VimLeavePre * exe 'silent !echo -ne "\\033]777;focus;off\\007"'

En relançant votre VIM, la magie devrait fonctionner. En perte du focus on force la sauvegarde de tous les buffers (wa!). Et lorsque l'on regagne le focus, on demande à VIM de passer en revue tous les buffers ouverts (bufdo) pour les recharger s'ils ont été modifiés (checktime).

Approche un peu plus sauvage

Cette technique ne marche pas mal mais elle souffre d'un défaut désagréable. Lorsque l'on passe en mode commande par : (ou recherche par ? ou /) et que l'on a le malheur de perdre le focus, la ligne que l'on saisissait vient se faire pourrir par les messages de notification.

Malheureusement il n'y a pas à ma connaissance de moyen de détourner le problème. VIM ne propose en effet pas d'évènement déclenché à l'entrée et à la sortie des modes commande. La solution est donc d'aller hacker le code de VIM.

Pour cela il faut récupérer le code source. Le mieux est de passer par le gestionnaire de version mercurial comme indiqué ici.

Lorsque le dossier vim est créé, il faut aller modifier le fichier src/os_unix.c et aux environs de la ligne 3342, dans la fonction mch_setmouse, nous allons modifier comme ceci :

# ifdef FEAT_MOUSE_URXVT
    if (ttym_flags == TTYM_URXVT) {
  out_str_nf((char_u *)
       (on
       ? IF_EB("\\033[?1015h", ESC_STR "[?1015h")
       : IF_EB("\\033[?1015l", ESC_STR "[?1015l")));

        // ----------- LE VILAIN PATCH... {{{
  out_str_nf((char_u *)
       (on
       ? IF_EB("\\033]777;focus;on\\007",  ESC_STR "]777;focus;on" (char_u *)"\\077")
       : IF_EB("\\033]777;focus;off\\007", ESC_STR "]777;focus;off" (char_u *)"\\077")));
       // ------------ FIN DU PATCH}}}

  ison = on;
    }
    # endif

Ceci fait il ne reste plus qu'à configure/compiler/installer. Perso je fais comme ceci, mais la configuration est à adapter selon vos goûts. Je vous conseille si vous vous lancez là dedans de désinstaller proprement VIM _avant_ d'installer ce résultat de compilation !!

make distclean
./configure \\
  --prefix=/usr  \\
  --with-features=huge \\
  --disable-selinux \\
  --enable-pythoninterp \\
  --enable-xim \\
  --enable-float \\
  --enable-gui=no \\
  --disable-workshop \\
  --with-x

  #--enable-perlinterp \\
  #--enable-cscope \\
make -j 10
sudo make install

Alors avant de lancer, comment ça marche. Le principe est assez simple. VIM au lancement va activer la notification des évènements souris auprès du terminal (set mouse=...). Lorsqu'il va s'arrêter, il va désactiver cette notification. Et lorsqu'il passe en mode commande, il va aussi désactiver. L'astuce est ici donc juste de prendre le train en marche et d'activer/désactiver le mode "focus" en même temps que le mode "souris". Oui je sais c'est stupide, c'est moche, mais ça marche super bien ;-)

Pour que cela fonctionne, il faut supprimer du chapitre précédent tout ce qui touche à l'activation/désactivation du mode "focus" (mais pas la gestion des notifications évidemment) et laisser vim faire...

Conclusion

Voilà en tout cas une manière de replacer avantageusement l'auto-sauvegarde pour VIM que j'avais réalisée précédemment. Car contrairement à la méthode que je proposais, celle-ci fonctionne en toute circonstances et sans aucun délai.

Après cette technique peut être exploitée pour bien d'autres usages. Par exemple un problème classique lorsque l'on bosse en console est de pouvoir copier du texte sur une console distante (un vim en ssh) et de récupérer ce contenu en local. Par cette approche c'est facilement réalisable en définissant une séquence OSC "presse-papier" qu'URxvt récupérerait pour transférer le contenu dans la sélection CLIPBOARD du serveur X11 local. Quelque chose comme :

gaston$echo -en "\\033]777;CLIPBOARD;ON\\077Ceci est mon texte à copier\\033]777;CLIPBOARD;OFF\\077"

D'ailleurs l'idée est déjà une petit peu mis en place dans un plugin peu connu d'URXVT, clipboard-osc. Sur le même principe peut être utilisé pour implémenter un protocole de transfert de fichier type ZModem/Kermit.

Comme vous le voyez, les usages sont nombreux. Et c'est une fois de plus la preuve qu'URxvt est un fantastiquement outil rentrant pleinement dans la catégories des "ce que je veux, je peux".

Original post of Artisan Numérique.Votez pour ce billet sur Planet Libre.

Le monde change. Le Web sera bientôt autant consulté depuis un « mobile » (smartphone) que depuis un « fixe » (PC). Dans certains pays, comme l'Inde, c'est déjà le cas. La fondation Mozilla ne laisse pas passer le mouvement sans rien faire. Elle tente même un pari osé en lançant son propre système d'exploitation pour mobile : Firefox OS. Jusqu'ici, il s'agissait d'une annonce assez nébuleuse pour beaucoup, mais les choses s'accélèrent avec la réservation possible de téléphones pour les développeurs en février, c'est-à-dire très bientôt. Et, dans deux jours, le premier atelier destiné aux développeurs d'applications pour Firefox OS aura lieu à Paris : Les « Firefox OS App Days ».

Le pari semble osé, mais l'est-il plus que celui fait il y a un peu plus de 10 ans, lorsque Mozilla se lançait face à l'hégémonie d'Internet Explorer ? Aujourd'hui Firefox OS sera comparé à l'iPhone d'Apple et à Android de Google, rien que ça... Qu'en pensez-vous ?

Original post of mozillaZine-fr.Votez pour ce billet sur Planet Libre.

Voici une astuce pratique permettant d’automatiser l’arrêt de votre terminal lorsque vous ne l’utilisez plus.

Il est en effet possible, si par exemple vous lancez une mise à jour de votre Ubuntu dans votre terminal à l’aide de la commande :

sudo apt-get update && sudo apt-get upgrade

de faire en sorte que le terminal se ferme automatiquement après une période prédéfinie d’inactivité.

Pour activer cette fonction, ouvrez un terminal et entrez la commande :

sudo gedit /etc/profile

Ajoutez à la fin du fichier qui s’est ouvert les lignes

# Exit Terminal
TMOUT=600
export TMOUT

600 correspond à la durée souhaitée d’inactivité exprimée en secondes soit 10 minutes dans mon exemple. Vous pouvez remplacer cette durée par celle de votre choix.

Enregistrez et fermez le fichier.

Pour que cette opération soit prise en compte, il vous suffit de fermez puis votre session puis de la rouvrir. Vous pouvez également entrer la commande :

source /etc/profile

Pour supprimer cette fonction, rouvrez ce fichier et supprimez les lignes que vous avez ajoutées.

Amusez-vous bien.

Source : UpUbuntu

Original post of Clapico.Votez pour ce billet sur Planet Libre.