Articles du blog - Page 2

• se met en plein écran
• joue un son aléatoire à chaque appui de touche (dans le dossier sounds)
• affiche une forme ou une image à chaque appui de touche (dans le dossier images)
• si un nom de fichier image correspond plus ou moins au nom de fichier son joué, c’est cette image qui est affichée (par exemple si c’est dog_2.wav qui est jouée, alors dog_4.png peut être affichée (mais pas cat_2.svg))
• une combinaison de touche pour quitter (à modifier dans le code si elle ne vous plait pas :þ)
• une combinaison de touche pour tout supprimer
• la souris trace des traits
• les boutons affichent les formes/images

• la longueur des mots pour nettoyer/quitter est identique (le code pour nettoyer est venu après)
• il faut faire attention à ce que verr.maj. ne soit pas enclenché pour nettoyer/quitter (et que le raccourci pour passer du clavier azerty vers le bépo non plus…)
• pas vraiment du plein écran sur certains windows manager (comme awesome-wm). Je n’ai pas trop cherché pourquoi.
• je n’ai pas bloqué les touches multimédia, y compris concernant le son… et plein de sons d’animaux, trop fort, c’est trop fort…

Voilà, pas grand chose à dire, si ce n’est que c’est sur bitbucket, et que j’ai inclus un script qui télécharge des sons sur http://soundbible.com/ (normalement un wget -r -nd -A.mp3 est suffisant, mais là il n’y a pas les liens directement sur les fichiers, du coup, il faut tricher un peu). Ah, si, il faut installer python-qt4-phonon pour que cela fonctionne.

Très rapidement, pour jouer un son avec phonon

from PyQt4.phonon import Phonon
...
        self.m_media = Phonon.MediaObject(self)
        audioOutput = Phonon.AudioOutput(Phonon.NotificationCategory, self)
        Phonon.createPath(self.m_media, audioOutput)

    def play(self):
            fic = QtCore.QString("/tmp/myfile.mp3")
            if (QtCore.QFile(fic).exists()):
                self.m_media.setCurrentSource(Phonon.MediaSource(fic))
                self.m_media.play()

Et pour coller une image, c’est encore plus simple :

qp = QtGui.QPainter()
img = QtGui.QImage()
img.load("/tmp/mypic.jpg")
qp.drawImage(x, y, img)

J’ai bien utilisé os.path.join et os.getcwd mais je n’ai pas autre chose que du GNU/Linux à la maison, donc je ne sais pas si ça marche sur autre chose, mais ça devrait !

À la prochaine.

En fait, ce billet, c’est plutôt un vrac, mais à l’origine, c’était vraiment juste pour ça, agrandir le texte comme dans la plupart des applications. À mettre dans son .emacs bien entendu :

(global-set-key (kbd "<C-wheel-up>") 'text-scale-increase)

et pour faire l’inverse :

(global-set-key (kbd "<C-wheel-down>") 'text-scale-decrease)

Bouh vi, bouuuuuuuh.

Rien à voir avec le point précédent donc, mais bien pratique : M-x (global-)linum-mode, qui affiche donc le numéro de ligne du buffer dans la marge (ou de tous les buffers si global-…).

Le truc que je fais souvent, c’est un C-s pour surligner une variable dans un buffer, pour voir où elle apparaît un peu plus loin. Alors que pour ça, il y a M-s h r (highlight-regexp) et toute la famille des surlignages (M-s h C-h).

Par défaut, la couleur, c’est hi-yellow, mais, le curseur est sur le y de yellow, du coup, C-k TAB et tout plein de propositions définies dans hi-lock.el s’offrent à vous. Mieux, C-a C-k TAB et c’est toutes les faces définies dans emacs que vous pourrez choisir ;]

En utilisant M-x keep-lines ou M-x delete-matching-lines (ou flush-lines, mais je ne m’y fais pas…) puis une regexp.

M-x apropos renseigne bien plus que C-h a qui ne montre que les commandes…

C-m, C-j, C-o

homoiconicité

Le « palais de la mémoire » (ou la méthode des lieux) est une façon de se rappeler les choses. Pour cela, on se crée un parcours, dans sa maison, dans sa ville, avec des endroits bien spécifiques, et on utilisera toujours le même parcours. Par exemple, on commence par la chambre, on va aux toilettes, dans la cuisine, puis dans la salle de bains. Pour se souvenir des légumes à prendre aux marchés, on place un légume par endroit quand on fait sa liste, en inventant une petite histoire : les poireaux sont en train de dormir au chaud sous la couette, la carotte lutte pour ne pas tomber au fond du trou, le brocoli se fait attaquer par les céréales qui veulent le noyer dans le bol, et le pâtisson prend sa douche. Et arrivé au marché, on refait le parcours en cherchant qui faisait la grasse mat’ puis celui qui était aux toilettes, etc.

Du coup, il est important, à mon avis, d’avoir plusieurs palais, et d’en changer fréquemment pour ne pas se mélanger avec la liste de la semaine dernière…

On peut également placer plusieurs objets dans une même pièce, voire dans un même endroit (si l’ordre n’a pas d’importance par exemple). Dans ce billet (mnemotechnics.org), l’auteur décrit (et illustre) comment il place 10 objets dans une même pièce.

Bon, tout ça c’est bien beau, mais on ne va pas mettre nos cartes et nos faces de rubik’s cube dans toute la maison. Ça ne nous aiderait pas mieux à retenir.

Pour retenir la liste des courses, la méthode du dessus est suffisante. Il suffit de créer des histoires les plus extraordinaires possibles, pour mieux les retenir. Mais pour retenir un numéro de téléphone ? les décimales de tau ? les cartes du paquet ?

Ben pour ça, il va falloir transformer ce que l’on veut retenir en une suite de chiffre, associer chaque chiffre à une lettre, chaque lettre à un mot, et placer ces mots aux quatre coins de la maison.

Jetez également un coup d’œil à http://www.ludism.org/mentat/BrainTrainingGames pour entraîner votre mémoire. Le dual n-back est franchement pas facile, mais les études ont l’air de montrer que c’est efficace.

Dans certains tests (qui sont nommés trucVariable_toto.html), j'ai à tester la présence d'un lien <a href="toto">trucConstant</a>. Parfois, trucConstant change et devient autreChose. Du coup, pleins de fichiers dans lesquels je dois modifier moi aussi trucConstant par autreChose.

C'est un cas assez fréquent (correction d'une typo…), et assez simple à résoudre :

• On ouvre le dossier où sont contenus les fichiers .html (avec C-x C-f) et on se trouve dans dired.
• On marque les fichiers concerné %m TexteDansLeNomDesFichiers.
• On appuie sur Q (pour Query replace regexp in marked files).
• trucConstant (mais une regexp est possible).
• autreChose.
• Y (Yes, toutes les condordances pour tous les fichiers marqués (y,y,y au début pour voir que ça va bien si jamais on a un doute ;]).
• Nos fichiers sont modifiés mais pas sauvés, et ouverts dans des buffers. Du coup M-x ibuffer (Parce que C-x C-b n'est parfois pas suffisant (h dans ibuffer pour l'aide)).
• * u (pour marquer tous les non-sauvés).
• S (pour sauver les buffers marqués).
• D (pour supprimer les buffer marqués).
• q (quitter ibuffer).
• Profiter du temps gagné.

Parfois, c'est tout un tableau qui est à changer. Et ce tableau est identique pour tous les fichiers. Ça reste dans ce cas relativement simple. Pour ce cas, je copie le tableau, je le mets dans un buffer temporaire, je le prépare pour être « regexp ready », le stocke dans un registre, fais ma modification, stocke dans un second registre, et fais comme au-dessus, sauf qu'au lieu de taper trucConstant et autreChose, je restitue mes registres.

• Ouvrir un des fichiers et aller au début de la partie à modifier.
• C-SPC pour poser la marque.
• Déplacer le curseur à la fin de la partie à modifier.
• M-w pour copier.
• Ouvrir un buffer temporaire C-x b auie (ou *scratch*).
• Coller C-y la région précédemment sauvegardée.
• Se placer au début du buffer M-<, ou sélectionner tout le buffer C-x h.
• Changer les [ et ] par \[ et \] pour que Query replace regexp in marked files ne les prennent pas pour des caractères spéciaux : C-M-% changer \(\[\|\]\) par \\\1.
• ! pour tout substituer.
• Notre trucConstant un peu plus long est prêt. On sélectionne tout C-x h, et on stocke dans un registre C-x r s a par exemple. On peut faire notre deuxième registre.
• On supprime avec C-w (comme tout le buffer est sélectionné).
• On colle la région sauvegardée du début. Pour cela, on remonte dans l'historique du kill-ring avec C-y puis M-y.
• On fait les modifications nécessaires.
• On resélectionne tout C-x h, et on stocke notre deuxième registre avec C-x r s b par exemple.
• On supprime notre buffer temporaire C-x k.
• On se place dans notre dossier où on marque les fichiers contenant le texte qqChoseDansLeTableau avec % g puis qqChoseDansLeTableau.
• Q puis on restitue notre premier registre avec C-x r i a.
• La substitution est assurée par le registre b : C-x r i b.
• Et comme au dessus, on appelle M-x ibuffer pour sauver/détruire les buffers modifiés.

Pas bien plus compliqué donc. Il faut juste faire attention au fait que Query replace regexp in marked files prend en première partie une regexp, ce qui peut poser quelques problèmes, mais aussi être utile puisqu'on peut se servir de bouts de la regexp pour les restituer avec \1, \2… D'ailleurs, c'est ce que l'on pourrait faire si le tableau n'est pas vraiment identique d'un fichier à l'autre. Mais comme ça risque d'être long et fastidieux, je préfère passer par des macros !

Pour ceux qui ne suivent que moyennement, je replace le contexte : plein de fichiers .html à changer, avec plus ou moins la même chose à l'intérieur, mais pas vraiment, et du coup, ça pourrait être chiant. Mais au final, pas tant que ça.

Afin de mieux expliquer, voici ce que contient une des pages du site que je dois tester :

.                       .                          .
.                       .                          .
|                       |                          | 
+-----------------------+--------------------------+
|    texte a :          |       valeur             |
+-----------------------+--------------------------+
|    texte b :          |       valeur             |
+-----------------------+--------------------------+
|    texte c :          |                          |
+-----------------------+--------------------------+
|      sstexte i        |       valeur             |
+-----------------------+--------------------------+
|      sstexte ii       |       valeur             |
+-----------------------+--------------------------+
|                       |                          |
.                       .                          .
.                       .                          .

Un tableau, avec des valeurs qui changent selon ce que l'on a fait avant, comment on a navigué, etc.

Mais maintenant, le site a changé, et la ligne avec texte b a disparu :

.                       .                          .
.                       .                          .
|                       |                          | 
+-----------------------+--------------------------+
|    texte a :          |       valeur             |
+-----------------------+--------------------------+
|    texte c :          |                          |
+-----------------------+--------------------------+
|      sstexte i        |       valeur             |
+-----------------------+--------------------------+
|      sstexte ii       |       valeur             |
+-----------------------+--------------------------+
|                       |                          |
.                       .                          .
.                       .                          .

Dans mes tests selenium, j'utilise xpath pour retrouver les éléments. Les éléments du tableau ont pour chemin quelque chose comme :

.                       .                          .
.                       .                          .
|                       |                          | 
+-----------------------+--------------------------+
|  //path/to/elem[x]    |     //path/to/avec[x]    |
+-----------------------+--------------------------+
|  //path/to/elem[x+2]  |                          |
+-----------------------+--------------------------+
|  //path/to/elem[x+4]  |     //path/to/avec[x+4]  |
+-----------------------+--------------------------+
|  //path/to/elem[x+5]  |     //path/to/avec[x+5]  |
+-----------------------+--------------------------+
|                       |                          |
.                       .                          .
.                       .                          .

Et là, on voit bien le problème : le texte c n'est plus à l'indice x+2 à présent, mais x+1. À partir de x, il va falloir décrémenter tous les chiffres.

Ça ferait un bon exercice, mais ne parlant pas encore le (e)lisp couramment, https://duckduckgo.com/?q=!+emacs+increment+number+at+point me donne la réponse plus rapidement…

(defun decrement-number-at-point ()
      (interactive)
      (skip-chars-backward "0123456789")
      (or (looking-at "[0123456789]+")
          (error "No number at point"))
      (replace-match (number-to-string (1- (string-to-number (match-string 0))))))

On va procéder maintenant en deux étapes : enregistrer une macro pour faire le changement dans un fichier, et appeler cette macro pour faire le changement dans tous les fichiers.

Rien qui change à part la façon de faire les rectangles, ainsi que la position du point de départ et la nourriture :

def populate(self, gridFood, startPos):
    """initialise la grille"""
    w = self.wsiz
    h = self.hsiz
    x = self.dimx
    y = self.dimy
    #on met le point de départ en rouge
    item = self.scene.addRect(startPos[0]*w/x, startPos[1]*h/y, w/x, h/y,
                              self.pen, QtGui.QBrush(QtGui.QColor("red")))
    #que l'on passe en avant
    item.setZValue(2)
    #on place de la même façon la nourriture, en vert
    for i in range(len(gridFood)):
        for j in range(len(gridFood[0])):
            if gridFood[i][j]:
                item = self.scene.addRect(i*w/x, j*h/y, w/x, h/y, self.pen,
                              QtGui.QBrush(QtGui.QColor("green")))
                item.setZValue(2)

Le plus gros changement se fait chez les fourmis. Sur le chemin du retour, elles se « rappellent » de leur chemin, et évite de faire des boucles…

def shorten(lwloop):
    """ On enlève les boucles de la liste """
    i = 0
    while i < len(lwloop):
        item = lwloop[i]
        lwloop.reverse()
        last = len(lwloop) - (lwloop.index(item) + 1)
        lwloop.reverse()
        lwloop.__delslice__(i, last)
        i = i + 1

Pour se déplacer, si elles trouvent de la nourriture à côté d’elles, elles y vont. Une fois qu’elles l’ont, elles retournent au point de départ.

def move(self):
    """
    Un pas, selon l'environnemnt.
    """
    #Si a trouvé de la nourriture
    if self.parentGrid.gridFood[self.coord[0]][self.coord[1]]:
        #retour a la maison
        self.goHome = True
        #sans faire de boucle
        shorten(self.pathDone)

    #si sur le chemin du retour
    if self.goHome:
        #et qu'il reste du chemin
        if self.pathDone:
            self.lastCoord = self.coord
            self.coord = self.pathDone.pop()
        else:
            #sinon, on repart
            self.goHome = False

Sinon, elles errent, ou essayent plus ou moins de suivre un chemin de phéromones.

else:
    #si pas encore trouvé de nourritére
    directions = [(-1, -1), (-1, 0), (-1, 1),
                 (0, -1), (0, 1),
                 (1, -1), (1, 0), (1, 1)]
    gfood = self.parentGrid.gridFood
    food = [(gfood[(self.coord[0] + x) % self.parentGrid.xmax]
                 [(self.coord[1] + y) % self.parentGrid.ymax],
                 [(self.coord[0] + x) % self.parentGrid.xmax,
                  (self.coord[1] + y) % self.parentGrid.ymax])
             for (x, y) in directions]
    food.sort()
    #si de la nourriture juste a coté, on y va
    if (food[-1][0]):
        self.lastCoord = self.coord
        self.coord =  food[-1][1]
    else:
        #sinon où sont les phéromones ?
        grid = self.parentGrid.gridPhero
        phero = [(grid[(self.coord[0] + x) % self.parentGrid.xmax]
                     [(self.coord[1] + y) % self.parentGrid.ymax],
                     [(self.coord[0] + x) % self.parentGrid.xmax,
                      (self.coord[1] + y) % self.parentGrid.ymax])
                 for (x,y) in directions]
        actualPhero = [(i, j) for (i, j) in phero if (i!= 0)]
        lenAP = len(actualPhero)
        if lenAP > 0:
            #À 95%, on suit la plus forte phéromones
                if (randint(0,100) < 95):
                    newCoord = actualPhero[randint(0,lenAP-1)][1]
                else:
                    #sinon, on erre
                    newCoord = phero[randint(0,7)][1]
        else:
            #s'il n'y a pas de phéromones à côté, on erre
            newCoord = phero[randint(0,7)][1]
        while newCoord == self.lastCoord:
            #mais on ne veut pas retourner sur nos pas!
            newCoord = phero[randint(0,7)][1]
        self.lastCoord = self.coord
        self.coord = newCoord
        self.pathDone += [self.coord[:]]

Rien de bien différent si ce n’est la façon de générer les phéromones

#taux de phéromones qu'une fourmi pose
self.pheroUp = 50
#taux d'évaporation des phéromones
self.pheroDown = 0.1

self.dictPhero = {} # { taux : [liste de [x, y]]}
self.gridPhero = [[0 for _ in range(self.ymax)] for _ in range(self.xmax)]

#point de départ et nourriture
self.gridFood = [[0 for _ in range(self.ymax)] for _ in range(self.xmax)]
self.gridFood[10][10] = 1
startPos = [self.xmax/2, self.ymax/2]

#no food on starting pos
self.gridFood[startPos[0]][startPos[1]] = 0

#le widget central est notre affichage de la grille
self.resize(self.wsize, self.hsize)
self.centralWidget = GridDisplay(self.xmax, self.ymax, self.wsize, self.hsize)
self.setCentralWidget(self.centralWidget)

self.centralWidget.populate(self.gridFood, startPos)

Pour dire qu’au final, on a quelque chose qui tient vaguement la route. Si vous voulez rendre les fourmis plus intelligentes, c’est dans la fonction move qu’il faut aller. Pour jouer avec les « 95% » et sur le fait que prendre un random, c’est pas terrible. Le mieux serait de choisir une direction et de garder ± le cap.

Faudrait aussi ajouter quelques p’tites choses comme des boutons pour arrêter, changer la vitesse, modifier les options (nombre de fourmis, taille, etc.), mais ça, vous êtes grand ;]

Oh, et pour les sources, direction bitbucket.

mencoder fichierEnEntree.avi -oac copy -ovc copy -o fichierDeSortie.avi

Les options :

-oac : choix du codec audio, codec copy = pas d’encodage, on recopie

-ovc : choix du codec vidéo, codec copy = pas d’encodage, on recopie

Cette ligne de commande ne fait donc « rien » :þ mais en changeant les codecs audio ou vidéo…

Il est valide (enfin, il devrait), mais les liens qu’il contient sont relatifs, y a pas de date de publication ; bref, le minimum syndical. Et pour le moment, je n’ai pas mis de limite sur le nombre d’articles, mais si ça sera pas trop dur (si le tri est fait comme je pense qu’il est fait).

Bon, je m’suis vraiment pas cassé… j’ai pris la fonction qui fait le sitemap, et je l’ai modifiée pour faire celle qui fait le rss.

Du coup, c’est moche, mais c’est fait…

(defun org-publish-org-rss (project &optional sitemap-filename)
  "Create a rss of pages in set defined by PROJECT."
  (let* ((project-plist (cdr project)) ; (:property value :property value ...) ou (:components ("proj1" "proj2"...)
         (dir (file-name-as-directory
               (plist-get project-plist :base-directory)));on recupere le dossier a traiter
         (exclude-regexp (plist-get project-plist :exclude)) ;s'il y a des exclusions
         (files (nreverse (org-publish-get-base-files project exclude-regexp)));liste des fichiers du projet (sans les exclus)
         (rss-filename (concat dir "other/rss.rss")) ;nom du fichier rss
         (sitemap-filename (concat dir (or sitemap-filename "sitemap.org"))) ;nom du fichier sitemap
         (visiting (find-buffer-visiting rss-filename));est-ce qu'on visite le fichier "rss.org"? (contient le buffer, nil sinon)
         file rss-buffer);fin du let*, file et rss-buffer sont nil
    (with-current-buffer (setq rss-buffer;on travaille temporairement avec ce fichier qui contient
                               (or visiting (find-file rss-filename))); soit le buffer qui le contenait, soit un nouveau buffer qu'on ouvre et qui contient "rss.org"
      (erase-buffer) ;on l'efface
      (insert (concat "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n<rss version=\"2.0\">\n")) ; on met le debut
      (insert (concat "<channel>\n"))
      (insert (concat "<description>Flux de fredtantini.free.fr</description>\n"))
      (insert (concat "<link>http://fredtantini.free.fr</link>\n"))
      (insert (concat "<title>Flux de fredtantini.free.fr</title>\n"))
      (while (setq file (pop files)) ; tant qu'il y a des fichiers dans le projet à traiter
        (let ((link (file-relative-name file dir))) ; le nom relatif par rapport au dossier à traiter, lnk
          ;; rss shouldn't list sitemap
          (unless (equal (file-truename sitemap-filename)
                         (file-truename file)) ;cf commentaire
            (insert (concat "<item>\n<title>"))
            (insert (concat (org-publish-find-title file)))
            (insert (concat "</title>\n<link>http://fredtantini.free.fr/"))
            (insert (concat (if (string-match "\\.org$" link)
                                (replace-match ".html" t t link)
                              )))
            (insert (concat "</link>\n<description><![CDATA["))
            (with-temp-buffer
              (insert-file-contents file nil nil nil t)
              (mark-whole-buffer)
              (org-html-convert-region-to-html)
              (copy-region-as-kill (point-min) (point-max))
              )
            (yank)
            (insert (concat "]]>\n</description>\n</item>\n"))
            ))
      (save-buffer));on sauve le fichier
      (insert (concat "</channel>\n"))
      (insert (concat "</rss>\n")) ; on met le debut
      (save-buffer)
      (or visiting (kill-buffer rss-buffer)))));et on tue le buffer si on ne le visitait pas

Oh, il est là :)

Je pense en effet que la prochaine sera la dernière, même s’il reste du boulot pour avoir des fourmis moins bêtes…

Comme expliqué lors de la seconde partie (oui, on peut dire second(e) même s’il y en a plus que deux), on va mettre en place les phéromones. Pour ça, pas besoin de changer le fichier ant.py, les phéromones sont gérés dans le fichier principal, et lors de l’affichage.

Pour gérer les phéromones, on va utiliser un dictionnaire : pour chaque taux de phéromones présent, on associe la liste des coordonnées sur la grille pour lesquelles il y a des phéromones à ce taux. Ça permet de reconstruire un tableau à deux dimensions qui contient le taux des phéromones. On le déclare dans l’initialisation :

self.phero = {} # { taux : [liste de [x, y]]}

Ensuite, on va changer notre fonction animate pour mettre à jour le dictionnaire de phéromones :

1. à chaque étape, les phéromones s’évaporent un peu ;
2. on reconstruit ensuite le tableau des phéromones ;
3. chaque fourmi dépose un peu de phéromones avant de se déplacer.

#atténuation des phéromones présentes (5 de moins à chaque endroit)
newPhero = {}
for lLev in self.phero:
    newLev = lLev - 5
    if (newLev > 0):
        newPhero[newLev] = self.phero[lLev]
self.phero = newPhero

#reconstruction de la grille des phéromones
gridPhero = [[0 for _ in range(self.ymax)] for _ in range(self.xmax)]
for lLev in self.phero:
    for [i, j] in self.phero[lLev]:
        gridPhero[i][j] = lLev

self.compteur += 1
for fourmi in self.lAnts:
    ##ajout de la phéromone
    ###on récupère l'ancienne valeur
    oldPhero = gridPhero[fourmi.coord[0]][fourmi.coord[1]]
    ###s'il y avait des phéromones, on enlève l'ancienne valeur
    if oldPhero:
        if fourmi.coord in self.phero.get(oldPhero):
            self.phero.get(oldPhero).remove(fourmi.coord)
    ###on met à jour avec la nouvelle valeur (50 de plus)
    gridPhero[fourmi.coord[0]][fourmi.coord[1]] = oldPhero + 50
    self.phero.setdefault(oldPhero + 50, []).append(fourmi.coord[:])

    ##déplacement de la fourmi
    fourmi.move()

#maj de la grille
self.centralWidget.animate(self.phero)

La dernière étape consistant à rafraîchir le widget central en lui donnant le dictionnaire des phéromones.

Là aussi, seule la fonction animae change vraiment. À chaque rafraîchissement on va :

1. supprimer les anciennes phéromones ;
2. ajouter les nouvelles ;
3. déplacer les fourmis.

Tout comme les fourmis, on gère les phéromones par des petits rectangles que l’on ajoute/supprime de la scène :

#on supprime de la scène les anciens carrés de phéromones
if self.lPhero:
    print len(self.lPhero)
    for phero in self.lPhero:
        self.scene.removeItem(phero)
        self.lPhero.remove(phero)

#et on ajoute les nouveaux
for lLev in dictPhero:
    for phero in dictPhero[lLev]:
        item = self.scene.addRect(phero[0]*w/x, phero[1]*h/y, w/x, h/y, self.pen,
                           QtGui.QBrush(QtGui.QColor(max(0, 255 - lLev), 255, 255)))
        item.setZValue(1)
        self.lPhero.append(item)

#et on déplace les fourmis
for (nitem, ant) in enumerate(self.lAnts):
    [i, j] = ant.coord
    item = self.lItems[nitem]
    item.setRect(i*w/x, j*h/y, w/x, h/y)
    #que l'on place au premier plan
    item.setZValue(2)

Rien de bien compliqué en somme… Comme d’hab, les sources sont sur bitbucket. La prochaine fois, les fourmis seront moins crétines et arriveront à détecter les phéromones pour être guidées vers de la nourriture et rentrer au bercail.

Comme d’habitude : pourquoi pas ? En fait, sur plusieurs sites, je me suis aperçu que j’aurais bien aimé avoir la possibilité de trier les résultats par note, vote, date…

Par exemple, si on cherche des recettes de dessert sur 750g, sur marmiton, voire yummly, je vois pas trop comment sont triés les résultats… Pas possible non plus de trier selon le nombre de commentaires sur /. ou MeFi, certains tableaux sur wikipedia ne sont pas triés. Ce n’est clairement pas quelque chose que je veux faire tous les jours, mais ça m’arrive. Du coup j’ai pris mon courage à deux mains, mon clavier dans l’autre, et je me suis mis à coder une petite fonction, qui a ses limites, mais qui marche dans la plupart des cas.

Je voulais un truc léger (sans jquery), et donc partir de zéro. Puis j’ai été confronté au problème qui fait que, quand on clique sur un span qui se trouve dans un div lui-même dans un li qui est… si on a ajouté une fonction qui écoute les événements pour tous les objets, et bien le span va bien répondre présent, mais aussi le div, le li et tous les autres… Je me suis alors demandé comment avait fait tontof pour kriss pin. Et, comme toute bonne personne qui se respecte, il a mis en commentaire dans son code comment il a résolu ce problème. Ce commentaire c’est « http://www.quirksmode.org/js/events_order.html », et ça explique bien mieux que moi… Et plutôt que de pomper honteusement ses fonctions, je m’suis dit, pourquoi ne pas intégrer ça à kriss pin ?

J’ai donc forké sur github, fait mes modifications, et un pull request.

Allez voir chez tontof pour savoir comment mettre un bookmarklet. Sinon, pour tester sur des exemples à la con, c'est ici.

Si vous cliquez sur un élément, puis sur un second, appuyez sur la touche p pour trier. Cela trie de façon croissante ou décroissante, selon que le premier élément est plus grand que le second ou non. Les entêtes des tableaux sont également sensés restés en tête du tableau.

Ça marche dans la plupart des cas. Mais je sais que ça peut ne pas marcher. Par exemple, si vous triez une ligne d'entête d'une table, elle ne reste plus en place si vous triez une colonne. Il y a également un bug sur les tables qui contiennent des multilignes. Ce n'est non plus pas possible de trier un tableau « horizontal » (et donc à double entrées). De plus, c'est pas forcément possible non plus de trier suivant des étoiles selon comment est codée la page. Par exemple, ça marche bien sur yummly, mais pas sur marmiton. Ça peut également rendre la page très moche :Þ

À part ça, j'en suis plutôt content.