Moved resources to the blog site

6 files changed, 602 insertions, 0 deletions

diff --git a/content/resources/backup.sh b/content/resources/backup.sh
new file mode 100644
index 0000000..aaf16f4
--- /dev/null
+++ b/content/resources/backup.sh
@@ -0,0 +1,100 @@
+#!/bin/sh
+###########################################################
+# This script uses rsync to backup directories on a media
+# (ex: USB disk) with a copy and incremental method.
+###########################################################
+#     This program is free software; you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation; either version 2 of the License, or
+#    (at your option) any later version.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with this program; if not, write to the Free Software
+#    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+############################################################
+#
+# Written by Spip
+# Adapted by Chimrod
+#    added script path detection
+#          delete with find
+# Version 1.0
+#
+############################################################
+#to be nice...
+ionice -c3 -p$$
+renice +15 -p $$
+THEDATE=`date +%F_%Hh%M`
+#FILE=`dirname $0`
+FILE=`dirname "$(cd "${0%/*}" 2>/dev/null; echo "$PWD"/"${0##*/}")"`
+LOGFILE=$FILE'/log/sauvegarde'
+
+SPLIT='====================================================================='
+#check logfile directory
+
+if ! [ -e $LOGFILE ]
+then
+	/bin/mkdir -p $LOGFILE
+fi
+
+#check if the media is mounted
+
+if ! [ -e $FILE ]
+then
+	echo "$THEDATE : péripherique non connecté. Pas de sauvegarde possible" >> "$LOGFILE/save.log"
+	echo $SPLIT >> "$LOGFILE/save.log"
+	exit 0
+fi
+
+#prevent a second task
+LOCKFILE="/var/lock/sauvegarde.lock"
+[ -f $LOCKFILE ] && exit 0
+
+#if the script are stoped, remove lockfile
+trap "rm -f $LOCKFILE" EXIT
+touch $LOCKFILE
+echo "$THEDATE : Début de sauvegarde" >> "$LOGFILE/save.log"
+# $1:time to keep files; $2: name of the backup; $3: target
+
+function save() {
+
+	echo "$SPLIT" >> "$LOGFILE/$2.log"
+	echo "$THEDATE" >> "$LOGFILE/$2.log"
+
+	#Incremental & copie
+	INC="$FILE/$2/INC/$THEDATE"
+	BAK="$FILE/$2/BAK"
+	TOSAVE="$3"
+	mkdir -p $INC
+
+	if ! [ -e "$BAK" ]
+	then
+	/bin/mkdir -p "$BAK"
+	fi
+
+	#a: archivage :recurcif, preserve dates, persmissions, groupes...
+	#v: verbose mode
+	#delete : supprime les fichiers n'etant plus chez l'émeteur >> copie conforme.
+	/usr/bin/rsync -a --stats --delete --backup --backup-dir="$INC" "$TOSAVE" "$BAK" >> "$LOGFILE/$2.log"
+
+	cd $FILE/$2/INC
+	tar -czvf "$INC.tar.gz" "$THEDATE"
+	echo tar -czvf "$INC.tar.gz" "$FILE/$2/INC/$THEDATE"
+	rm -rf "$THEDATE"
+	#Remove the file older than $1 days
+	find "$FILE/$2/INC" -mtime +$1 -delete >> "$LOGFILE/save.log"
+
+}
+
+#List here all repositories to backup
+
+save 90 etc /etc/
+
+#to log the end of the backup
+THEDATE=`date +%F_%Hh%M`
+echo "$THEDATE : Sauvegarde effectuée" >> "$LOGFILE/save.log"
+exit 0
diff --git a/content/resources/ir_control_0.py b/content/resources/ir_control_0.py
new file mode 100644
index 0000000..dfce76a
--- /dev/null
+++ b/content/resources/ir_control_0.py
@@ -0,0 +1,118 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import cwiid
+
+## Configuration
+#wiimote_hwaddr = '' # Use your address to speed up the connection proccess
+wiimote_hwaddr = '00:1F:C5:5A:8C:69'
+
+def connect(wm_addr = ''):
+    '''Connects and syncs with a wiimote
+    wm_addr - Is a string representing the hwaddr of the wiimote we will try to
+            connect, or none to try to connect with any discoverable device
+            for example "00:19:1D:5D:5D:DC"'''
+
+    pygame.display.flip() # called now because cwiid.Wiimote is a blocking call
+
+    # This could be done in a thread to allow pygame to draw while searching
+    # but this is only a test
+    try:
+        return cwiid.Wiimote(wm_addr)
+    except:
+        print "Error conectando con wiimote " + str(wm_addr)
+
+
+def wmplugin_init(id, wiimote_arg):
+    #global wiimote
+
+    #wiimote = wiimote_arg
+    wmplugin.set_rpt_mode(id, cwiid.RPT_IR | cwiid.RPT_BTN)
+    return
+
+def wmplugin_info():
+    return [], \
+      [("X", wmplugin.REL | wmplugin.ABS, 1024, 0, 0, 0), \
+       ("Y", wmplugin.REL | wmplugin.ABS, 768, 0, 0, 0)], \
+    []
+
+def wmplugin_exec(messages, buton=[0]):
+    '''Wiimote callback managing method
+    Recieves a message list, each element is different, see the libcwiid docs'''
+    x = y = 0
+
+    for msg in messages:
+
+        if msg[0] == cwiid.MESG_BTN:
+            # msg is of the form (cwiid.MESG_BTN, cwiid.BTN_*)
+            buton[0] = msg[1]
+
+        if msg[0] == cwiid.MESG_IR:
+            if screen:
+                # red dot for the sources
+                [screen.fill((255, 0, 0), (point, (4, 4))) \
+                        for point in ir_sensor.get_positions_points(msg)]  
+
+            if buton[0] & cwiid.BTN_B == 0 :
+                x, y = (0, 0) 
+
+    return [], (x, y)
+
+if __name__ == '__main__':
+    import pygame
+    from pygame.locals import *
+    runing = 0
+    def handle_events():
+        '''Typical event handling via pygame'''
+        for event in pygame.event.get():
+            if event.type == QUIT:
+                return 0
+            elif event.type == KEYUP:
+                if event.key == K_ESCAPE:
+                    return 0
+                elif event.key == K_SPACE:
+                    canvas.fill((0, 0, 0), ((0, 0), canvas.get_size()))
+        return 1
+
+    pygame.init()
+    pygame.display.set_caption('Wiimote IR test')
+    window = pygame.display.set_mode((cwiid.IR_X_MAX, cwiid.IR_Y_MAX), DOUBLEBUF)
+    screen = pygame.display.get_surface()
+    canvas = pygame.Surface(screen.get_size()) # persistent drawing here
+    canvas = canvas.convert()
+
+    wm = None # our wiimote
+    clock = pygame.time.Clock()
+    runing = 1
+    while(runing):
+        clock.tick(100)
+        runing = handle_events()
+        if not wm:
+            wm = connect(wiimote_hwaddr)
+            if not wm:
+                continue
+            # each message will contain info about ir and buttons
+            wm.rpt_mode = cwiid.RPT_IR | cwiid.RPT_BTN # | cwiid.RPT_STATUS
+            # tell cwiid to use the callback interface and allways send button events
+            wm.enable(cwiid.FLAG_MESG_IFC
+                      #| cwiid.FLAG_NONBLOCK
+                      | cwiid.FLAG_REPEAT_BTN)
+
+            # specify wich function will manage messages AFTER the other settings
+            wm.mesg_callback = wmplugin_exec
+
+            # quick check on the wiimote
+            print "Got Wiimote!"
+            st = wm.state
+            for e in st:
+                print str(e).ljust(8), ">", st[e]
+
+        screen.blit(canvas, (0, 0))
+        pygame.display.flip()
+
+    if wm:
+        wm.close()
+else:
+    #This code is used as a plugin for cwiid, we import the wminput system
+    import wmplugin
+    screen = None
diff --git a/content/resources/mymenu.lua b/content/resources/mymenu.lua
new file mode 100644
index 0000000..b3e5be4
--- /dev/null
+++ b/content/resources/mymenu.lua
@@ -0,0 +1,67 @@
+-- Menu d'application
+
+local awbeautiful = require("beautiful")
+local awful = require("awful")
+local capi     = {
+    screen     = screen,
+}
+
+local function getStickyIcon(client)
+    if client.sticky then
+        return awbeautiful.get().titlebar_sticky_button_focus_active
+    end
+    return awbeautiful.get().titlebar_sticky_button_focus_inactive
+end
+
+local function getOnTopIcon(client)
+    if client.ontop then
+        return awbeautiful.get().titlebar_ontop_button_focus_active
+    end
+    return awbeautiful.get().titlebar_ontop_button_focus_inactive
+end
+
+function newAppMenu(client)
+    local data = {}
+    local myAppMenu = {}
+
+    local args = {}
+    args.keygrabber = true
+
+    -- Insert the ontop entry
+    -- When onTop is selelected, set in floating mode too
+   table.insert(myAppMenu, {"On Top", function()
+        -- We do not use floating.togle() but syncronize the floating on top value
+        awful.client.floating.set( client, not client.ontop ) 
+        client.ontop = not client.ontop
+    end , getOnTopIcon(client)}  )
+
+    -- Insert the Sticky entry
+   table.insert(myAppMenu, {"Sticky", function() client.sticky = not client.sticky end , getStickyIcon(client)}  )
+
+    -- Insert the Hide entry
+    if not client.minimized then
+        table.insert(myAppMenu, {"Minimize", function() client.minimized = true end } )
+    end
+    table.insert(myAppMenu, {"Close", function() client:kill() end, awbeautiful.get().titlebar_close_button_focus } )
+
+    -- Add the move to tag entry
+    local moveToTag = {}
+    local tags = capi.screen[1]:tags()
+    for i = 1, #tags do
+        -- We do not show the curent client tags
+        local isInTag = false
+        local clientTag = tags[i]:clients()
+        for j = 1, #clientTag do
+            isInTag = isInTag or clientTag[j] == client
+        end
+        if not isInTag then
+            table.insert(moveToTag, {tags[i].name, function() awful.client.movetotag(tags[i], client) end } )
+        end
+    end
+    table.insert(myAppMenu, {"Move To", moveToTag } )
+
+    data.menu = awful.menu.new( { items = myAppMenu} )
+    data.menu:show(args)
+
+    return data
+end
diff --git a/content/resources/rstodt/article.rst b/content/resources/rstodt/article.rst
new file mode 100644
index 0000000..3e8001f
--- /dev/null
+++ b/content/resources/rstodt/article.rst
@@ -0,0 +1,185 @@
+.. -*- mode: rst -*-
+.. -*-  coding: utf-8 -*-
+
+Blogguer en rst sous wordpress
+##############################
+
+:tags: Libre, reStructuredText
+:summary: |summary|
+
+.. default-role:: literal
+
+Le format reStructuredText_ est un langage de balise (un peu comme le HTML, ou
+le laTex), issu du monde de la programmation. Son but est de répondre au
+problème suivant : comment écrire du texte simplement et sans avoir besoin
+d'apprendre une syntaxe spécifique (ou du moins un minimum), tout en
+conservant des possibilités de formatage et d'export ?
+
+.. _reStructuredText : http://docutils.sourceforge.net/rst.html
+
+Présentation de RST
+===================
+
+.. |summary| replace::
+    Quand on écrit un article (par exemple ici cet article de blog), il est
+    nécessaire d'indiquer des directives de mise en page : ceci est un
+    paragraphe, ceci est un lien, inclure une image, une citation… Pour cela on
+    ne passe pas par un logiciel de traitement de texte pour le faire
+    (openOffice) : c'est lourd et cela n'apporte rien, mais la plupart du temps
+    par un éditeur intégré au blog qui permet de formater notre texte.
+
+|summary|
+
+Cet éditeur se charge pour nous de formater le texte en quelques clics. Le
+problème est que bien souvent ce texte ne pourra pas sortir du blog (par
+exemple pour prendre un extrait de l'article et l'utiliser ailleurs, nous
+sommes obligés de passer à nouveau par cette interface)
+
+Une autre solution est de rédiger notre texte directement dans le format de
+sortie (par exemple HTML), mais cela nécessite de connaître la syntaxe, et ne
+rend pas la lecture du fichier source très lisible (essayez de lire un article
+de presse en HTML avec un éditeur de texte pour voir…)
+
+Le format reStructuredText se veut être une réponse à ces problèmes : un
+fichier RST est lisible (le fichier source est compréhensible et peut être lu
+directement), ne nécessite pas de connaissances particulières (du moins peu), et
+à l'avantage de pouvoir être exporté dans de nombreux format de sortie (odt,
+pdf, latex, html…) On dispose donc d'un format unique pouvant servir à écrire
+des articles de blog, des documents de travail, ou encore de la documentation.
+
+La syntaxe est très simple, et ne charge pas le document à la lecture. Par
+exemple pour voir le document ayant servi à générer cet article est disponible
+ici_ : on laisse des lignes blanches pour indiquer que l'on passe d'un
+paragraphe à un autre, ou « souligne » avec les caractères = _ ou - les titres
+et les sous-titres, et le résultat donne un document très aéré et agréable à
+travailler.
+
+.. _ici : {filename}/resources/rstodt/article.rst
+
+Plugin wordpress
+================
+
+Il existe un plugin wordpress qui permet d'utiliser ce format pour l'écriture
+de documents dans le blog.  À chaque fois que l'on va publier un article, le
+plugin va tester si le fichier est au format rst, et dans ce cas, va en faire
+la conversion en html en passant par la commande `rst2html`.
+
+**Attention**, pour le mettre en place, il est
+nécessaire d'avoir un accès à la machine pour y installer quelques
+applications.
+
+Pré-requis
+----------
+
+Python doit être disponible sur la machine, ainsi que le script `rst2html` (je
+ne pense pas que cela soit le cas pour les blogs hébergés et cela limite les
+possibilités).
+
+.. code-block:: console
+
+    $ sudo aptitude install python-docutils
+
+Installation
+------------
+
+Il s'agit juste d'un fichier à installer dans le répertoire des plugin de
+wordpress. Celui-ci est disponible sur launchpad_ et ne pose aucun problème de
+compatibilité.
+
+.. _launchpad : http://bazaar.launchpad.net/~gldnspud/rest-wordpress/trunk/files
+
+Le fichier README explique comment l'installer et le paramétrage à faire; les
+options (comme le chemin vers `rst2pdf`) se font directement dans le fichier php.
+
+.. code-block:: php startinline=True
+
+    // Set this to the prefix of your docutils installation.
+    $prefix = "/usr/local";
+
+    // Set this to the path of rst2html.py
+    $rst2html = "$prefix/bin/rst2html.py";
+
+Un petit test devrait montrer le résultat tout de suite. Dans le cas où le
+contenu est vide, regardez les logs d'erreur du serveur web, vous devriez y
+trouver les causes de votre erreur.
+
+Coloration syntaxique
+---------------------
+
+Il est possible de disposer de la coloration syntaxique automatique du code :
+
+.. code-block:: python
+
+    import os
+    # Standard hello world stuff
+    class Hello()
+        def do_it(self)
+            print "Hello world"
+
+    if __name__ == '__main__':
+        Hello().do_it()
+
+    def main()
+        print "Hello world"
+
+Pour intégrer la coloration syntaxique, il faut passer par pygment (un
+programme python qui s'occupe de ça) :
+
+.. code-block:: console
+
+    # aptitude install python-pygments
+
+Ensuite il va falloir modifier le script à lancer. En effet, par défaut, la
+commande `rst2pdf` n'intègre pas la coloration de code. Nous allons donc devoir
+modifier la commande à exécuter pour le faire (j'ai mis à disposition le script
+à télécharger_). Assurez-vous que le script peut être exécuté par l'utilisateur
+lancé par le service web.
+
+.. _télécharger : {filename}/resources/rstodt/rst2html-pygments.py
+
+La CSS n'est pas inclue dans le document et peut être définie à l'extérieur. Il
+est possible de définir son style à partir de pygment avec la commande suivante
+(pour appliquer le style tango) :
+
+.. code-block:: console
+
+    $ pygmentize -S tango -f html > style.css
+
+Conclusion
+==========
+
+Je cherchais depuis un petit moment une solution pour pouvoir écrire mes
+articles sans me connecter au blog. Les applications clientes ne me convenant
+pas tout à fait, le RST me permet d'utiliser une application totalement séparée
+du blog (par exemple VIM) et un format pérenne.
+
+Je ne sais pas s'il existe une solution équivalente pour les autres moteurs de
+blog, le RST étant encore un format assez jeune, et n'est pas encore très
+répandu…
+
+Sans être aussi complet que le latex, il est bien plus souple et
+beaucoup plus facile à utiliser. De plus il s'agit bien sûr d'un format
+ouvert, pouvant générer des documents sous openOffice, en PDF, voire en latex
+pour ceux qui veulent…
+
+Édit (29/05/11)
+===============
+
+Je reviens sur le plugin en constatant que par défaut, celui-ci met en cache le
+contenu de l'article, même si celui-ci est déjà en html. Une petite
+modification dans le code permet de ne sauvegarder le fichier que s'il s'agit
+d'un fichier rst :
+
+Rechercher dans le script la chaîne suivante :
+
+.. code-block:: php
+
+  if ($pos === false) {
+    // No modeline.
+    $rval = wpautop($text);
+
+Et rajouter la ligne suivante en dessous :
+
+.. code-block:: php
+
+    return $rval;
diff --git a/content/resources/rstodt/rst2html-pygments.py b/content/resources/rstodt/rst2html-pygments.py
new file mode 100644
index 0000000..7e2a826
--- /dev/null
+++ b/content/resources/rstodt/rst2html-pygments.py
@@ -0,0 +1,55 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+from docutils.core import publish_cmdline
+
+# Define a new directive `code-block` that uses the `pygments` source
+# highlighter to render code in color. 
+#
+
+from docutils import nodes
+from docutils.parsers.rst import directives, Directive
+from pygments import highlight
+
+from pygments.lexers import get_lexer_by_name, TextLexer
+from pygments.formatters import HtmlFormatter
+
+INLINESTYLES = False
+pygments_formatter = HtmlFormatter()
+DEFAULT = HtmlFormatter(noclasses=INLINESTYLES,linenos="table")
+VARIANTS = {}
+
+class Pygments(Directive):
+    """ Source code syntax hightlighting.
+    """
+    required_arguments = 1
+    optional_arguments = 1
+    final_argument_whitespace = True
+
+    has_content = True
+    linenos=1
+
+    def run(self):
+        dic = {}
+
+        # On crée un dictionnaire à partir des options
+        for options in self.arguments[1:]:
+            clef, arg = options.split("=")
+            dic[clef] = arg
+
+        self.assert_has_content()
+        try:
+            lexer = get_lexer_by_name(self.arguments[0], **dic)
+        except ValueError:
+            # no lexer found - use the text one instead of an exception
+            lexer = TextLexer()
+        # take an arbitrary option if more than one is given
+        formatter = self.options and VARIANTS[self.options.keys()[0]] or DEFAULT
+        parsed = highlight(u'\n'.join(self.content), lexer, formatter)
+        return [nodes.raw('', parsed, format='html')]
+
+
+directives.register_directive('code-block', Pygments)
+
+publish_cmdline(writer_name='html') 
+
diff --git a/content/resources/rstodt/rst2odt.py b/content/resources/rstodt/rst2odt.py
new file mode 100644
index 0000000..f1f107f
--- /dev/null
+++ b/content/resources/rstodt/rst2odt.py
@@ -0,0 +1,77 @@
+#!/usr/bin/python
+
+# $Id: rst2odt.py 5839 2009-01-07 19:09:28Z dkuhlman $
+# Author: Dave Kuhlman <dkuhlman@rexx.com>
+# Copyright: This module has been placed in the public domain.
+
+"""
+A front end to the Docutils Publisher, producing OpenOffice documents.
+"""
+
+try:
+    import locale
+    locale.setlocale(locale.LC_ALL, '')
+except:
+    pass
+
+from docutils.core import publish_cmdline_to_binary, default_description
+from docutils.writers.odf_odt import Writer, Reader
+
+from docutils.parsers.rst.roles import set_classes
+
+from docutils import nodes
+from docutils.parsers.rst import directives, Directive
+
+
+description = ('Generates OpenDocument/OpenOffice/ODF documents from '
+               'standalone reStructuredText sources.  ' + default_description)
+
+class Codeblock(Directive):
+    """ Source code syntax highlighting.
+    """
+    required_arguments = 1
+    optional_arguments = 1
+    final_argument_whitespace = True
+
+    has_content = True
+    linenos=1
+
+    directives = {":include:": lambda self, *args, **kwargs : self.include(*args, **kwargs)}
+
+    def include(self, param):
+        """ Include a file and return it as a content.
+        """
+        try:
+            self.content = unicode(open(param, 'r').read(), "utf-8").split("\n")
+        except IOError:
+            self.content = ("FileNotFound",)
+
+    def run(self):
+        for argument in self.arguments:
+            directives = argument.split(" ")
+            processor = self.directives.get(directives[0], None)
+            if processor is None:
+                continue
+            processor(self, directives[1])
+
+        set_classes(self.options)
+        self.assert_has_content()
+        text = '\n'.join(self.content)
+        text_nodes, messages = self.state.inline_text(text, self.lineno)
+        node = nodes.literal_block(text, '', *text_nodes, **self.options)
+        node.line = self.content_offset + 1
+        self.add_name(node)
+        node.attributes['language'] = self.arguments[0]
+
+        return [node] + messages
+
+
+directives.register_directive('code-block', Codeblock)
+
+
+writer = Writer()
+reader = Reader()
+output = publish_cmdline_to_binary(reader=reader, writer=writer,
+    description=description)
+
+