Shadoware.Org - Mot-clé - libre

KMDAlert - Logiciel de surveillance de périphérique RAID - Version pour KDE 4.0

Ulrich Van Den Hekke — Sun, 14 Aug 2011 20:43:00 +0200

Présentation

Possédant chez moi des disques durs en RAID logiciels sous Gnu/Linux, en 2007 (cela fait déjà 4 ans), j'avais écrit un petit logiciel dont le but était de faire du monitoring RAID.

En cas de reconstruction du RAID ou de disque défectueux, le logiciel affiche une notification à l'utilisateur, et change le statut affiché dans la barre de notification (systray). L'icône change bien sur en fonction de l'état du RAID :

dégradé (avec un point d'exclamation)
en cours de synchronisation (avec une barre de progression)
disque RAID dans un état normal

Ce logiciel ne tournait que sous KDE 3.X.

Voici donc une nouvelle version (qui a mis le temps de sortir) qui est un portage de l'application sous KDE 4.X. Elle utilise donc le nouveau système de notification de KDE (pour l'instant en passant uniquement par les notifications standard). Quelques améliorations y seront apportées plus tard.

Requis

Pour fonctionner KMDAlert nécessite que le dossier /sys soit monté et que /sys/block/ soit renseigné pour chaque volume RAID (exemple /sys/block/md0, /sys/block/md1, ...). KMDAlert observe ensuite les modifications faites sur les fichiers pour informer l'utilisateur des modifications faites sur le volume RAID ou sur les disques le composant.

De nos jours le dossier /sys et /sys/block devraient être toujours présents.

L'application a été développée sur Gnu/Debian Squeeze, sur un KDE 4.4.5 avec un noyau 2.6.32.

KMDAlert ne nécessite pas de Inotify. KMDAlert lit le contenu de plusieurs fichiers dans le dossier /sys toutes les 6 secondes pour être informé de la modification de l'état du périphérique. Sur l'application d'origine, développé sous un noyau 2.6.18, Inotify n'est pas averti des modifications faites sur le système de fichier /sys. Les dates de ces fichiers ne sont pas non plus modifiées. Si quelqu'un a une autre méthode à me proposer, je reste ouvert à toutes propositions.

KMDAlert est une application écrite en utilisant les librairies de KDE, mais devrait tout de même fonctionner sous Gnome. Les messages de notification utilisent donc le système de notification de KDE (bien que je n'utilise pas toutes ses possibilités).

Compilation / Installation

La compilation et l'installation de KMDAlert se fait à l'aide du trio habituel :

# Décompression de KMDAlert
tar xjfv kmdalert-0.2-77c0d6b4d49f.tar.gz
cd kmdalert-77c0d6b4d49f
 
# Préparation de la compilation
mkdir build
cd build
 
# Comilation
cmake ../
make
 
# Installation
make install

La compilation nécessite les librairies de développement KDE et Qt3, ainsi que le compilateur GCC.

Licence

La licence choisie est la GNU GENERAL PUBLIC LICENSE

Téléchargement

Vous pouvez télécharger une archive déjà construite de l'application sur KDE-Apps.org.
Le dépôt officiel pour télécharger les sources et participer : http://hg.shadoware.org/kmdalert.
Vous pouvez également télécharger la version attachée au billet.

Système de suivi

Il n'y a actuellement plus de système de suivi pour ce logiciel. En cas de problème, vous pouvez laisser un message dans les commentaires ou m'envoyer un mail.

XINX v0.10.1

Ulrich Van Den Hekke — Tue, 03 May 2011 18:46:00 +0200

Bonjour à tous,

Je suis heureux de vous annoncer la nouvelle version de XINX. Cette version apporte, en plus de la ré-écriture complète de la gestion du contenu et de la complétion, son petit lot de nouveautés et de corrections.

La version 0.10.1 est beaucoup plus stable que sa grande soeur 0.9. Un soin particulier a été apporté à la recherche des sources d'anomalie possible, ainsi que des fuites mémoires. Ces opérations ont été faites grâce à des outils tels que valgrind, mais aussi grâce aux béta-testeurs (Merci à eux).

De plus l'utilisation des pointeurs intelligents de Qt ont permis de passer plus de temps, sur la gestion des structures et moins de temps sur la gestion de la mémoire, sur des parties du code assez critiques (comme ContentView et CodeCompletion). Ils ont également permis un partage plus facile des structures entre les différents threads avec moins de contrôle de synchronisation.

Liens

Gestion Projet et Gestion des sessions

Multi-projet

XINX est maintenant capable d'ouvrir plusieurs projets en même temps. Cela permet donc plusieurs choses :

Rechercher un fichier pouvant se trouver dans plusieurs projets différents (par exemple un projet trunk et un projet branche).
Comparer des fichiers venant de plusieurs projets différents.
Ne pas basculer d'un projet à l'autre en continu, lorsque l'on travaille sur plusieurs projets en même temps.

A cause de cette gestion de plusieurs projets en même temps, toute la partie de gestion de projet de XINX a été ré-écrite (entre autre la partie concernant la session, que l'on verra ensuite).

De plus à l'ouverture du projet, l'application recherche l'ensemble des fichiers présents sur le disque afin de permettre une recherche beaucoup plus rapide. Cela a néanmoins quelques répercussions : il n'est pas possible de supprimer un dossier du projet sans fermer XINX.

Inclusion / Exclusion de chemin

Afin d'avoir une vue propre, XINX affiche déjà uniquement les fichiers qu'il est capable de gérer. Il est également possible de lui définir une liste de chemin qu'il doit ignorer.

Exemple :

WEB-INF/lib
dico
configuration

Il est possible d'utiliser des expressions régulières pour définir ces chemins.

A l'inverse il est possible d'inclure un dossier externe au projet directement dans la vue de celui-ci. L'équivalent d'un lien symbolique mais propre au projet sous XINX. Il est alors possible d'inclure dans le dossier projet, un répertoire temporaire contenant les données utilisées par les feuilles de styles, ou inclure un dossier contenant des fichiers de logs, ...

Sessions

Suite à la gestion du multi-projet, il a fallu ré-écrire le système de gestion des sessions. Il est maintenant plus proche des systèmes de session des autres applications.

Alors que sur la version 0.9 et précédente, la session était directement associée à un projet (et donc ouverte en même temps), maintenant la session est séparée de la notion de projet.

Une session peut alors désormais contenir une liste de projet ouvert, une liste de fichier ouvert (associé ou non à un projet), des signets. Plusieurs sessions différentes peuvent pointer vers un même projet mais proposer une vue (un ensemble de fichier ouvert) différente. Une session par défaut est créée pour l'utilisation courante de l'application.

Modification du système de complétion

Le système de vue contenue et de code complétion a complètement été ré-écrit. La lecture des différents imports des différents fichiers est faite en mémoire (et non plus dans une base de donnée SQL) et en parallèle (s'il y a plusieurs processeurs sur la machine). La lecture des fichiers est ainsi plus rapide. Le système a complètement été ré-écrit pour que la complétion du code soit rapide et stable en même temps.

La complétion du code affiche désormais les différentes lignes dans des catégories suivant leur emplacement (par exemple le fichier où se trouve chaque template), les snipets dans une catégorie différente...

XINX est maintenant capable également de compléter

les paramètres des templates du type call-template
les imports (proposition des différents fichiers, et des alias si le plugin Generix est activé)

et plein d'autres choses

Et plein d'autres nouveautés

Utilisation de la librairie SVN directement

Un nouveau plugin pour SubVersion a été écrit. Ce plugin utilise directement les librairies de SubVersion au lieu d'utiliser l'exécutable svn. Ce plugin est plus performant que le wrapper et ne nécessite pas l'installation d'un client SubVersion (tel que CollabNet SubVersion sous Windows ou le client svn sous linux.

L'ancien plugin est toujours disponible et utilisable.

Créer des tickets depuis XINX

Une boite de dialogue permet maintenant de créer automatiquement un compte et un ticket sur le site Internet de XINX. Vous pouvez ainsi créer facilement des demandes d'évolution, des demandes de correction, ... De plus lors de la sortie d'une nouvelle version, XINX vous informera automatiquement qu'une nouvelle version est disponible.

Dock des logs et des erreurs

Le dock d'affichage des erreurs a été amélioré pour ne plus perturber l'utilisateur en s'ouvrant de façon intempestive. Il est maintenant possible de définir que le dock doit rester fermé, un compteur affiche alors le nombre d'erreur .

Modification de la recherche

Suite à la gestion du multi-projet, XINX peut maintenant rechercher dans plusieurs projets en même temps. Il est aussi possible d'arrêter la recherche en plein milieu.

Validation d'un fichier XML

XINX peut également valider un fichier XML à partir d'un schéma. Il ne peut malheureusement pas encore valider de fichier XSL (les parseurs XSL trouvés n'arrivent pas à lire les schémas des fichiers XSLT).

Correction de bugs

Beaucoup de corrections de bug ont été faites ce qui rend cette version très stable.

Et pour la suite ?

Dans la même série, j'ai l'intention de sortir une version avec de nouveaux modèles, de la documentation, ....

Pour la version suivante, le moteur JavaScript sera amélioré pour ne plus donner d'erreur, voir proposer de la complétion plus performante.

[C++/Qt] Concaténation de chaînes de caractères

Ulrich Van Den Hekke — Wed, 22 Dec 2010 13:03:00 +0100

Présentation

Qt est un framework orienté objet écrit en C++ et permettant de faire des interfaces graphiques à l’aide de ces widgets. Ce framework est utilisé par le projet KDE depuis ses débuts pour en faire un environnement très complet.

Qt permet donc de faire des interfaces graphiques mais aussi d’accéder à des bases de données SQL, de faire de la communication réseau, une gestion simplifiée des threads, la lecture de fichier XML. Qt intègre aussi le moteur HTML Webkit.

Qt ajoute une couche supplémentaire au C++ permettant de faire de l’introspection de classe un peu plus poussée (comme l’appel d’une méthode dont on ne connaît le nom qu’à l’exécution). Qt permet également la gestion d’évènement par l’intermédiaire d’un système puissant de SIGNALS et de SLOTS.

Dans la suite de cet article nous allons nous concentrer sur une très petite partie de Qt mais qui est utilisée dans beaucoup d’applications écrites en Qt : les chaînes de caractères, et plus précisément, la concaténation de chaînes de caractères.

Concaténation de chaînes de caractères.

Comme dans d’autres langages, la concaténation de chaînes de caractères se fait à l'aide de l'opérateur +. Prenons un exemple simple :

#include <QString>
 
QString abc = "abc", def = "def";
QString result;
 
result = abc + def;

L'utilisation de l'opérateur + facilite l'écriture de la concaténation des chaînes de caractères (tout comme l'opérateur == permet de facilement comparer des chaînes de caractères de type QString).

Malheureusement cette écriture rend le code peu performant pour diverses raisons (que l’on peut retrouver dans la documentation de l’objet QString).

Concaténation rapide de chaînes de caractères

A partir de Qt 4.6, Nokia, a ajouté un template nommé QStringBuilder (cet objet fait beaucoup penser à l'objet StringBuilder de JAVA permettant d'accélérer les concaténations de chaînes de caractères).

Ce template ne s’utilise pas directement mais au travers de l'opérateur %. En remplaçant donc l'opérateur + par % on gagne en performance (dixit la doc de Qt).

Pour pouvoir utiliser l'opérateur, il suffit d'inclure le fichier QStringBuilder :

#include <QStringBuilder>
 
QString abc = "abc", def = "def", ghi = "ghi";
QString result;
 
result = abc % def % ghi;

Une autre possibilité est de définir (par exemple dans votre fichier .pro ou dans un include général de votre application) les définitions QT_USE_FAST_CONCATENATION, et QT_USE_FAST_OPERATOR_PLUS.

Ces définitions permettent de remplacer l'opérateur + par l'opérateur % dans toute l'application. Par contre cette opération peut demander quelques modifications de votre code.

#define QT_USE_FAST_CONCATENATION
#define QT_USE_FAST_OPERATOR_PLUS
 
#include <QString>
 
QString abc = "abc", def = "def";
QString result;
 
result = abc + def;

Benchmark

Nous allons donc dans la suite du document vérifier que l'opérateur % est plus rapide que l'opérateur +. Pour cela nous allons utiliser le module de benchmark de Qt.

Code source

Voici le petit programme permettant de tester la performance de la concaténation. Notre exemple simple va constituer à la concaténation de 26 chaînes de caractères créées au début. L'appel se fera une première fois en utilisant l'opérateur + et une seconde fois en utilisant l'opérateur %.

#include <QtCore/QString>
#include <QtTest/QtTest>
#include <QStringBuilder>
 
class TestPerf : public QObject
{
    Q_OBJECT
 
public:
    TestPerf();
 
private Q_SLOTS:
    void concat();
    void concat_data();
};
 
TestPerf::TestPerf()
{
}
 
void TestPerf::concat()
{
	QFETCH(bool, useStringBuilder);
	QString result;
 
	QString a("a"), b("b"), c("c"), d("d"), e("e"), f("f"), g("g"), h("h"), i("i"), j("j"), k("k"), l("l"), m("m"), n("n"), o("o"), p("p"), q("q"), r("r"), s("s"), t("t"), u("u"), v("v"), w("w"), x("x"), y("y"), z("z");
 
	if (useStringBuilder)
	{
		QBENCHMARK
		{
			// Concaténation en utilisant QStringBuilder
			// Dans ce cas la concaténation devrait être plus rapide
			result = a % b % c % d % e % f % g % h % i % j % k % l % m % n % o % p % q % r % s % t % u % v % w % x % y % z;
		}
	}
	else
	{
		QBENCHMARK
		{
			// Concaténation en n'utilisant pas QStringBuilder. On utilise alors la concaténation normal de chaînes de caractères en utilisant
			// QString
			result = a + b + c + d + e + f + g + h + i + j + k + l + m + n + o + p + q + r + s + t + u + v + w + x + y + z;
		}
	}
}
 
void TestPerf::concat_data()
{
	QTest::addColumn<bool>("useStringBuilder");
	QTest::newRow("Don't use QStringBuilder") << false;
	QTest::newRow("Use QStringBuilder") << true;
}
 
QTEST_APPLESS_MAIN(TestPerf);
 
#include "tst_testperf.moc"

Résultat du test

Le test a été fait en utilisant la version 4.6.3 de Qt. Le résultat est sensiblement le même avec la version 4.7.0

Sans QStringBuilder	0.00367 msec
Avec QStringBuilder	0.00046 msec

On voit dans ce test que la version en utilisant QStringBuilder est 8 fois plus rapide que sans. Bien sûr vu le temps que prend la concaténation de chaînes de caractères, ce test commence à avoir de l'intérêt uniquement à partir du moment où on fait beaucoup de concaténation dans la seconde, ou si les temps de réponses sont critiques.

Sur ce, je vous souhaite à tous un Joyeux noël et une bonne année.

Calcul de la distance entre deux fichiers

Ulrich Van Den Hekke — Sun, 06 Jun 2010 11:40:00 +0200

Présentation

Suite à un billet sur LinuxFR, où je demandais comment calculer la distance (ou le pourcentage de similitude entre deux logiciels), j'ai obtenu la formule suivante :

distance = 1 - ( C(A) + C(B) - C(AB) ) / Max(C(A), C(B))

où C(X) est la taille du fichier X compressé^[1].

Après avoir testé les formats gzip, bzip2 et lzma, j'ai conclu que le format de compression le plus performant pour le calcul, est le format lzma, car le dictionnaire avec la mise en commun était le plus gros, et donc le calcul de distance est plus efficace.

Notes

[1] On peut retrouver l'explication de cette formule ici

Le programme

J'ai donc décidé d'écrire un programme parcourant un dossier (avec plusieurs milliers de fichiers) et de calculer pour toutes les combinaisons des fichiers la distance entre chaque fichier. Ce programme consommant énormément de mémoire, il se peut que pour un grand nombre de fichier, le programme se plante avec une erreur d'allocation de mémoire.

Ce programme permet de pouvoir faire une cartographie de ces fichiers et ainsi de pouvoir les classer. Testé sur des fichiers textes (sources de logiciels), le programme est assez efficace.

Testé sur des images, ou des vidéos, les fichiers sont considérés comme tous éloignés les uns des autres, même s'ils sont identiques à compression différente près, ou s'ils sont identiques à un mouvement près sur la photo (du genre une photo où une même personne se tient dans une position différente).

Si vous avez une idée sur comment calculer la distance entre deux fichiers déjà compressés (avec perte qui plus est), ca m'intéresse.

Comme l'exécution est très lente (compression lzma niveau 9), le programme peut être arrêté et redémarré.

Pour démarrer le programme, il faut exécuter la commande :

./calcul_distance /mon/dossier

Le programme va alors créer un fichier {5ac1fd3c-504f-4110-9f7e-d6fc89e57bdb}.db où {5ac1fd3c-504f-4110-9f7e-d6fc89e57bdb} est différent à chaque nouveau lancement.

Pour reprendre le traitement où il était, il suffit alors de lancer :

./calcul_distance --uuid {5ac1fd3c-504f-4110-9f7e-d6fc89e57bdb}

Si on veut ajouter un dossier au traitement après coup :

./calcul_distance /nouveau/dossier --uuid {5ac1fd3c-504f-4110-9f7e-d6fc89e57bdb}

Exemple

Par exemple soit les différentes versions d'un logiciel, mis dans des archives tar. Pour ne prendre que le code source des versions, on va supprimer tous les fichiers suivants de l'archive tar : *.jpg, *.png, *.ico, *.qm, *.db, ... les sources externes à l'application. On ne garde donc que les fichiers textes dont nous avons la possession.

Après le nettoyage des dossiers :

$ for i in `ls` ; do
> tar -c $i/* > $i.tar
> done
$ ls -l
-rw-r--r-- 1 phoenix phoenix 2,5M  6 juin  13:24 v0.6.10.tar
-rw-r--r-- 1 phoenix phoenix 440K  6 juin  13:24 v0.6.4.tar
-rw-r--r-- 1 phoenix phoenix 530K  6 juin  13:24 v0.6.5.tar
-rw-r--r-- 1 phoenix phoenix 610K  6 juin  13:24 v0.6.6.tar
-rw-r--r-- 1 phoenix phoenix 690K  6 juin  13:24 v0.6.7.tar
-rw-r--r-- 1 phoenix phoenix 1,2M  6 juin  13:24 v0.6.8.tar
-rw-r--r-- 1 phoenix phoenix 1,3M  6 juin  13:24 v0.6.9.tar
-rw-r--r-- 1 phoenix phoenix 2,9M  6 juin  13:24 v0.7.0.tar
-rw-r--r-- 1 phoenix phoenix 2,2M  6 juin  13:24 v0.7.1.tar
-rw-r--r-- 1 phoenix phoenix 3,3M  6 juin  13:24 v0.7.2.tar
-rw-r--r-- 1 phoenix phoenix 3,3M  6 juin  13:24 v0.8.0.tar
-rw-r--r-- 1 phoenix phoenix 3,1M  6 juin  13:24 v0.8.1_services.tar
-rw-r--r-- 1 phoenix phoenix 3,1M  6 juin  13:24 v0.8.1.tar
-rw-r--r-- 1 phoenix phoenix 3,8M  6 juin  13:24 v0.9.0.tar
$ cd ..
$ calcul_distance ./xinx/
Step 0 : Create database
Step 1 : Create file list
Step 2 : Compress single file                                     
Step 3 : Compress pair file                                       
$ ls 
{051b93a0-d9a9-4778-ac73-81ee01a3905d}.db
xinx
$ sqlite3 {051b93a0-d9a9-4778-ac73-81ee01a3905d}.db

Nous allons maintenant faire une requête dans la base de données sqlite :

$ .TABLES
distances  files 
$ SELECT files1.path, files2.path, distances.distance FROM distances, files files1, files files2 WHERE distances.id1=files1.id AND distances.id2=files2.id ORDER BY distance ASC;

Version 1	Version 2	Distance
v0.8.1	v0.8.1_services	0.0350740694634633
v0.6.8	v0.6.9	0.132275346477201
v0.8.0	v0.8.1	0.142321125298336
v0.8.0	v0.8.1_services	0.161719318637048
v0.6.5	v0.6.6	0.196933113059686
v0.6.4	v0.6.5	0.231812199675573
v0.6.6	v0.6.7	0.266593999923953
v0.6.10	v0.7.0	0.27412838729727
v0.7.2	v0.8.0	0.312111739912996
v0.6.5	v0.6.7	0.351347925829225
v0.6.4	v0.6.6	0.364115163581424
v0.7.2	v0.8.1	0.386971922637303
v0.7.2	v0.8.1_services	0.401055941017259
v0.7.1	v0.7.2	0.436705836223058
v0.7.0	v0.7.1	0.465121645779551
v0.6.4	v0.6.7	0.468472350726879
v0.8.1_services	v0.9.0	0.516795574578859
v0.8.1	v0.9.0	0.51733623689019
v0.8.0	v0.9.0	0.544376861655528
v0.6.7	v0.6.8	0.558824765667689
v0.7.1	v0.8.0	0.560609480175814
v0.6.10	v0.6.9	0.594036969567445
v0.7.1	v0.8.1	0.604226316444666
v0.7.1	v0.8.1_services	0.613613062086946
v0.6.7	v0.6.9	0.622950487834501
v0.7.0	v0.7.2	0.631060763867616
v0.6.10	v0.7.1	0.632444883185258
v0.6.10	v0.6.8	0.637234847328374
v0.6.6	v0.6.8	0.6494052372746
v0.6.9	v0.7.1	0.666200571812458
v0.7.2	v0.9.0	0.678423568871868
v0.6.5	v0.6.8	0.692250570944195
v0.6.8	v0.7.1	0.701063946130892
v0.6.6	v0.6.9	0.701698986545754
v0.6.9	v0.7.0	0.717262408423359
v0.7.0	v0.8.0	0.720311680104721
v0.6.5	v0.6.9	0.738013305804084
v0.6.4	v0.6.8	0.747495551539097
v0.6.10	v0.7.2	0.747929200720491
v0.6.8	v0.7.0	0.748031544518325
v0.7.0	v0.8.1	0.758510349354368
v0.7.0	v0.8.1_services	0.767204482779187
v0.6.4	v0.6.9	0.772451857549627
v0.6.10	v0.8.0	0.796649043913944
v0.7.1	v0.9.0	0.801221496333008
v0.6.9	v0.7.2	0.804765901655414
v0.6.8	v0.7.2	0.819917045496318
v0.6.10	v0.8.1	0.823540395867048
v0.6.10	v0.8.1_services	0.831055117394626
v0.6.10	v0.6.7	0.838850951377793
v0.6.9	v0.8.0	0.849001032539087
v0.6.7	v0.7.1	0.853848016623182
v0.7.0	v0.9.0	0.860291356912217
v0.6.8	v0.8.0	0.86075956509228
v0.6.10	v0.6.6	0.863340151908353
v0.6.9	v0.8.1	0.872265541006983
v0.6.6	v0.7.1	0.873275579233521
v0.6.10	v0.6.5	0.875332023895544
v0.6.9	v0.8.1_services	0.87987037883801
v0.6.7	v0.7.0	0.879941907871053
v0.6.8	v0.8.1	0.881174812987336
v0.6.5	v0.7.1	0.886172606121206
v0.6.8	v0.8.1_services	0.889515283880001
v0.6.10	v0.6.4	0.892364892140999
v0.6.6	v0.7.0	0.894375709613201
v0.6.10	v0.9.0	0.895694726039398
v0.6.7	v0.7.2	0.898582911617307
v0.6.4	v0.7.1	0.902038058337369
v0.6.5	v0.7.0	0.904821831317442
v0.6.6	v0.7.2	0.910637046476578
v0.6.4	v0.7.0	0.918347943544789
v0.6.5	v0.7.2	0.919716704855963
v0.6.9	v0.9.0	0.921714099772221
v0.6.7	v0.8.0	0.924717744438112
v0.6.8	v0.9.0	0.925849165227404
v0.6.4	v0.7.2	0.928888262611658
v0.6.7	v0.8.1	0.933685479216414
v0.6.6	v0.8.0	0.933940067594635
v0.6.7	v0.8.1_services	0.939898268404416
v0.6.5	v0.8.0	0.940789807767177
v0.6.6	v0.8.1	0.94210246370087
v0.6.6	v0.8.1_services	0.946464528845253
v0.6.4	v0.8.0	0.948830071149278
v0.6.5	v0.8.1	0.94922082772201
v0.6.5	v0.8.1_services	0.951278461132112
v0.6.4	v0.8.1	0.955572468114482
v0.6.4	v0.8.1_services	0.95567206186826
v0.6.7	v0.9.0	0.96084453455483
v0.6.6	v0.9.0	0.964619158469125
v0.6.5	v0.9.0	0.965955795849916
v0.6.4	v0.9.0	0.968866861905835

On peut ainsi voir d'après ce tableau, les versions ayant peu de différences et celles qui ont fait des plus gros bonds en avant.

On voit ainsi qu'il y a plus de différences entre la version 0.8.0 et la 0.9.0, qu'il y en a eu entre la version 0.6.8 et la 0.6.9. On peut également voir que les versions 0.6.4 et 0.9.0 n'ont plus rien à voir entre elles.

Vous pouvez télécharger le logiciel attaché à ce billet.

Présentation de XINX

Ulrich Van Den Hekke — Sun, 02 May 2010 21:55:00 +0200

Ce billet fait suite à la sortie de la version 0.9.0 de XINX et va vous décrire ce logiciel. XINX est éditeur de feuille de style XSL (il fait également éditeur JavaScript et CSS mais actuellement moins bien que ce que peuvent faire d'autres).

Il permet l'édition des feuilles de styles en proposant de compléter sur le nom des balises (normal), sur les attributs (normal), sur les valeurs d'attributs : les variables, les paramètres, ... Il propose également automatiquement les différents paramètres lors de l'utilisation d'un call:template.

L'éditeur est fortement tourné vers l'édition de feuille de style XSL pour génération d'HTML mais peut être utilisé pour générer du XML.

Historique

Depuis un certain temps déjà (5 ans), je travaille pour la société Generix Group éditant et intégrant un ERP^[1] du nom de GCE.

Sur la partie Web de cet ERP, il est possible d'intervenir à plusieurs endroits pour modifier son fonctionnement :

Le paramétrage (BDD) : Modification d'un paramètre pour agir sur le comportement du logiciel
La couche métier (JAVA) : Lit le paramétrage (BDD) et réalise les traitements. Il est possible de développer de nouveaux objets, mais aussi de dériver ceux existants.
La couche de présentation (XSL) : A l'aide d'un flux de présentation généré par la couche métier et d'un fichier de configuration, présente les données à l'écran.

La dernière couche est donc l'interprétation d'un flux de donnée, générée à partir de la couche métier (JAVA), à l'aide de feuille de style XSL.

XINX sert à modifier la couche de présentation (XSL). Sur cette dernière couche, on crée et modifie des feuilles de styles pour modifier la présentation des données à l'écran (Déplacer des champs, supprimer des champs, ajouter des champs, règle de gestion simple ...).

En mode projet, chez les clients, les modifications ne sont pas faites directement sur les feuilles de styles standard livrées, mais sur des feuilles de styles dérivées, afin de faciliter les migrations, et la correction des anomalies.

Lors de la modification de feuille de style standard, il faut alors renommer et placer ce fichier dans un dossier séparé. C'est de cette tâche récurrente qu'est venue la création de l'éditeur de feuille de style XINX.

Le but était alors, lors de la sauvegarde d'un fichier standard, de proposer automatiquement la sauvegarde dans le bon dossier.

L'autre point à l'origine de la création de XINX est la non-existence d'un logiciel de développement de feuille de style XSL gratuit et/ou libre (Il y a bien XML Spy qui correspondait à peu prés mais qui était payant, et dont nous n'avions pas la licence).

Sont alors venu s'ajouter d'autres fonctionnalités : la complétion sur les balises, les attributs, les variables, ....

Qu'est que XINX aujourd'hui ?

XINX prévu initialement comme aide au développement des consultants qui font des développements de feuille de style, est maintenant un éditeur de feuille de style XSL avec gestion des plugins. L'un des plugins contient des petites fonctionnalités utiles au quotidien par les consultants travaillants sur l'ERP, fonctionnalité auparavant implémenté directement dans le logiciel.

Dit autrement, cette nouvelle version marque donc une étape : La partie de XINX propre à Generix Group à été séparée dans un plugin. XINX en lui même n'est alors plus qu'un éditeur de feuille de style, extensible via des plugins, mais il retrouve les mêmes fonctionnalités grâce à ce plugin.

Licence

XINX est un logiciel libre dont la licence choisie est la GPLv3. Ce qui signifie que vous pouvez :

télécharger le logiciel
utiliser le logiciel pour faire ce que vous voulez
télécharger les sources du logiciels
modifier les sources du logiciels
utiliser le logiciel modifié par vos soins
distribuer le logiciel ou la version modifiée (attention à différencier les parties originales du logiciel avec le bon copyright, et les parties modifiées).

En tant que logiciel libre XINX possède une plateforme de contribution (ticket, wiki, source, ...) qui se trouve à l'adresse http://xinx.shadoware.org. Vous pouvez donc y aller pour contribuer.

Vous pouvez contribuer de plusieurs façons :

Développement d'un Plugin
Développement d'un script ECMAScript
Développement d'un petit patch
Développement d'un gros patch

Technologie

XINX est un logiciel développé en Qt. Il compile et tourne sous Gnu/Debian (normalement n'importe quelle distribution devrait faire l'affaire, mais Gnu/Debian est la seule distribution testée), et sous MS/Windows. Il devrait normalement également tourner sous MacOS (si les dépendances comme les librairies libxml2 et libxslt sont compilables sous cet OS).

A chaque version un paquet Gnu/Debian est mis à disposition sur le dépôt (apt.shadoware.org) et un binaire MS/Windows est proposé en téléchargement. XINX est toujours compilable à partir des sources pour les autres distributions ou juste parce que vous préférez ainsi. :D

Intégration continue & Tests

A chaque validation sur le référenciel SubVersion, l'application est compilée et testée (vous pouvez voir le résultat des tests à l'adresse suivante. A la sortie de la version 0.9.0, les tests couvrent 27% de la librairie principale. Je dois donc encore écrire d'autres jeux de tests.

Code réutilisable pour d'autres projets

XINX peut également être intéressant pour d'autres développeurs Qt.

En effet, vous pouvez trouver dans la dernière version, ainsi que dans les versions précédentes plusieurs classes utilitaires. Par exemple (liste presque non exhaustive) :

TreeProxyItemModel : convertit un modèle format table en modèle format arbre. Utile lorsque l'arbre est représenté dans une base de donnée relationnelle par exemple.
RecursiveSortFilterProxyModel : Utilisé pour rechercher facilement des données dans un arbre et permet d'afficher les enfants.
XinxLineEdit : Inspiré de KDE, affiche un bouton pour effacer le texte dans la ligne d'édition
XinxListWidgetImpl : Permet de modifier une liste de valeur (ajout, suppression, valeur par défaut, classement, ...)
PluginSelector : Inspiré de KDE, permet d'afficher une liste des plugins, avec un bouton A propos de ... et un bouton Configurer ....
QMenuView : Inspiré d'un exemple de Qt et permet d'afficher un menu à partir d'un modèle.

Fonctionnalités

Recherche parmi les fichiers d'un dossier

Un dock sur le coté permet en mode projet de rechercher et d'ouvrir un fichier parmi une multitude de fichier d'un projet (utile pour les fichiers avec beaucoup de feuille de style).

La recherche peut se faire avec des Jockers (*)

La complétion XSL

XINX permet de compléter sur les feuilles de styles à plusieurs niveaux^[2] :

la balise (fonctionnalité standard vous allez me dire) : XINX permet de compléter sur les balises xsl:, les balises html ...
les attributs (encore standard). Pour chaque balise, XINX est capable de compléter sur les attributs de la balise saisie.
les valeurs d'attribut (là c'est intéressant). Permet de compléter sur les variables déclarées dans le fichier XSL, ainsi que dans les fichiers importés (pour retrouver les fichiers importés, XINX, utilise le mode projet et les paramètres qui y sont définits). De plus sur les attributs non XSL, XINX ajoute automatiquement les accolades { } et les $ pour les variables et les paramètres.

De plus lors de l'utilisation de la balise call:template, XINX va chercher automatiquement les paramètres (xsl:param) du template donné, et les ajoute automatiquement en xsl:with-param. Pour les balises xsl:apply-templates XINX propose la liste des modes des templates existants.

Le parsing de la feuille de style

Fonctionnalité du moment, si vous indiquez un flux de données et une feuille de style, XINX est capable d'afficher le résultat (la source HTML et le résultat dans un navigateur Webkit)

Si l'emplacement où doivent s'exécuter les pages est définit alors, les feuilles de styles, les images, ... pourront être affichées.

A venir

Bien que l'avenir du logiciel dépend de ces utilisateurs, voici les nouvelles fonctionnalités que devrait apporter la prochaine version :

Déverminage de feuille de style XSL
Amélioration du parseur JavaScript et CSS
Quelques réécritures (Vue projet, ...)

Le plugin GCE

Comme indiqué ci-dessous, il existe un plugin GCE utilisé par les consultants travaillants sur l'ERP GCE.

Ce plugin permet de dupliquer une feuille de style d'un dossier à un autre (sans modification des fichiers standards), de lire les dictionnaires de libellé de l'ERP GCE, la lecture du fichier de configuration du lecteur GCE.

Téléchargement

Vous pouvez télécharger XINX à l'adresse http://xinx.shadoware.org/downloads (source et version Windows).

Si vous voulez installer XINX sur une Gnu/Debian (32 ou 64 bits) vous pouvez inclure le dépôt suivant :

# Shadoware.Org
deb http://apt.shadoware.org/ squeeze main

Et installé de la façon suivante :

aptitude install xinx

Vous pouvez vous tenir au courant des sorties de version grâce à la mailing list

Notes

[1] Un ERP et un logiciel de gestion d'entreprise. Un ERP permet de gérer, par exemple, les produits, les clients, les fournisseurs, les stocks, les ventes, les achats, la logistique, la comptabilité, .... Je ne vais pas vous faire une présentation des ERPs, car même si cela pourrait faire un billet intéressant, ce n'est pas le but ici.

[2] Merci à QCodeEdit qui me fournit quelques fonctionnalités utiles.

[Qt] Transformation d'une vue tableau en une vue hiérarchique

Ulrich Van Den Hekke — Mon, 21 Sep 2009 13:50:00 +0200

Pour visualiser des données internes à l'écran, Nokia/Qt nous propose l'architecture MVC à l'aide des classes QAbstractItemModel et de ses sous classes (QAbstractListModel, QAbstractTableModel, ...). Le but de l'architecture MVC est de séparer la représentation mémoire des données, de l'affichage qu'elles auront.

Si les données sont par exemple issue d'une requête SQL, le modèle QSqlQueryModel permet de représenter la sélection SQL, à l'écran dans un composant QTableView. Ces données sont alors représentées sous forme d'un tableau deux dimensions.

Si l'on veut représenter les dossiers de l'ordinateur, le modèle QDirView permet d'afficher les données de façon hiérarchique.

Il est également possible d'écrire nos propres modèles pour représenter nos propres données.

Le but de cet article est de présenter l'écriture d'un modèle, transformant une vue plane (tableau deux dimensions) en vue hiérarchique. Pour cela nous allons prendre l'exemple de l'affichage d'une liste de catégorie^[1].

Notes

[1] La construction de notre objet s'est basé sur l'analyse de l'objet QSortFilterProxyModel de Nokia.

Présentation de l'exemple

Nous allons voir ci-dessous comment transformer une vue plane en une vue hiérarchique. Pour cela nous allons prendre l'exemple d'une liste de catégorie. Ces catégories seront stockées dans une base de données Sqlite. Ceci n'a pas d'importance mais permet d'expliquer pourquoi les données en mémoire ne sont pas déjà sous forme hiérarchique.

La description d'une catégorie passe donc par :

un identifiant unique appelé id
un nom de catégorie
un lien vers la catégorie parente appelé parent_id

C'est le champ parent_id qui permettra de déterminer dans quelle catégorie notre sous-catégorie se trouve. Dans notre cas, test3 a comme parent_id l'identifiant 11 qui est la catégorie test.

Dans notre exemple, nous allons nous conditionner à un modèle en lecture seul. Il est également possible de faire un modèle en lecture/écriture mais nous n'en parlerons pas dans cet article. Nous nous cantonnerons donc à un modèle lecture seul sur un modèle source de type QSqlTableView. (Un modèle en lecture/écriture peut nécessiter de mettre à jour notre structure, ce qui peut être assez compliqué, par exemple en cas de changement de la catégorie parente).

Déclaration d'un modèle

Qu'est qu'un proxy ?

Notre interface se basera sur la classe QAbstractProxyModel. Le but de cette classe est de permettre de faire une transposition entre un premier modèle et une vue. Elle peut par exemple (à l'aide de QSortFilterProxyModel) permettre de filtrer ou trier les données d'une vue.

Cette vue nous permettra de faire la transposition entre un modèle tableau et une vue arborescente.

Interface du proxy

Les méthodes à ré-implémenter pour faire fonctionner une proxy, sont les suivantes :

virtual QModelIndex index( int row, int column, const QModelIndex & parent ) const;
virtual QModelIndex parent( const QModelIndex & index ) const;
 
virtual int rowCount( const QModelIndex & parent = QModelIndex() ) const;
virtual int columnCount( const QModelIndex & parent = QModelIndex() ) const;
 
virtual QModelIndex mapFromSource ( const QModelIndex & sourceIndex ) const;
virtual QModelIndex mapToSource ( const QModelIndex & proxyIndex ) const;

Les quatre premières méthodes appartiennent à l'objet QAbstractItemModel et seront questionnées par la vue (liste, arbre, …) pour connaître la représentation à l'écran.

Les méthodes mapFromSource(), et mapToSource() sont à implémenter pour l'objet QAbstractProxyModel. Elles permettent de faire la liaison entre les indexes (QModelIndex) du modèle d'origine et les indexes du nouveau modèle.

Les méthodes data(), headerData(), flags() sont réimplémentées par l'objet QAbstractProxyModel et utilisent les méthodes mapFromSource() et mapToSource() pour, lors de l'appel d'une de ces méthodes, récupérer les informations stockées sur le modèle d'origine.

Des méthodes sourceModel() et setSourceModel() permettent de spécifier le modèle d'origine.

Implémentation de notre modèle

Structure interne

Nous allons, dans cette partie, parler de la structure interne utilisée par notre objet.

struct Mapping {
	int id, parrentId;
	int index, parentIndex;
	QVector<int> source_rows;
};
typedef QMap<int,Mapping*> IndexMap;
 
IndexMap m_sourcesIndexMapping;
QHash<int,int> m_categoryIdMapping;

Nous allons créer une structure Mapping qui associera pour une ligne dans le modèle source, les informations concernant :

l'identifiant de la ligne.
l'identifiant de la ligne parente.
l'index dans le modèle source.
l'index du parent dans le modèle source.
la liste des indexes dans le modèle source des enfants dans notre modèle.

Une table de hashage permettra de retrouver à partir d'un identifiant (id), la ligne dans le modèle source correspondante. On ne gardera que la seconde colonne (le nom de la catégorie), on ne fera donc l'association qu'entre le nom de la colonne de notre modèle et le modèle source en dure dans le programme.

createMapping()

Le but de cette méthode est de générer l'arborescence qui sera ensuite utilisée dans la suite des méthodes. Cette arborescence étant générée une fois pour toute (ou à chaque fois que le modèle source sera réinitialisé), il faudra parcourir l'ensemble des lignes du modèle source pour construire notre arbre. Parcourir l'ensemble des lignes du modèle source peut prendre du temps si ce dernier contient beaucoup de ligne.

Nous allons considérer dans la suite, que l'identifiant de ligne 1 (id) correspond à la catégorie de plus haut niveau (ci-dessus du nom de Categories). Nous allons créer une catégorie fictive 0 qui correspondra à la racine de notre modèle. Cette catégorie sera donc la catégorie parente de celle à l'identifiant 1. Dans notre modèle source, la catégorie 0 n'a pas d'équivalence parmi les lignes du modèle source. Nous allons donc lui associer la ligne -1 dans le modèle source.

Maintenant voyons la génération de la structure interne.

qDeleteAll( m_sourcesIndexMapping );
m_sourcesIndexMapping.clear();
m_categoryIdMapping.clear();

Nous commençons ci-dessous par nettoyer les différentes structures afin de les régénérer. Il faudra à la suite de la création du mapping appeler la méthode reset() afin de prévenir la vue que l'ensemble des indexes du modèle sont obsolètes.

int source_rows = m_sourceModel->rowCount();
for( int i = -1; i < source_rows; ++i ) {
	Mapping * m = new Mapping;
	IndexMap::const_iterator it = IndexMap::const_iterator( m_sourcesIndexMapping.insert( i, m ) );
	m->index = i;
	m->parrentId = 0;
	m->parentIndex = 0;
 
	if( i >= 0 ) {
		QSqlRecord record = m_sourceModel->record( i );
		m_categoryIdMapping[ record.value( list_id ).toInt() ] = i;
		m->id = record.value( list_id ).toInt();
	} else { // Create the root Item
		m->id = 0;
		m_categoryIdMapping[ 0 ] = -1;
	}
}

Nous récupérons le nombre de ligne dans le modèle source et commençons à initialiser notre structure. Le but de cette boucle est surtout d'initialiser dans notre correspondance identifiant/index (m_categoryIdMapping), l'emplacement des identifiants dans notre tableau. Ainsi dans la suite lorsque l'on essaiera d'associer une ligne à son parent, nous pourrons savoir à quel emplacement retrouver notre id dans la structure m_sourcesIndexMapping.

Nous profitons également de cette boucle pour initialiser les différents champs de notre structure comme l'index (qui correspond à la ligne dans le modèle source), et l'id qui correspond à un identifiant unique dans notre liste.

Nous n'oublions pas notre cas particulier que représente notre racine (ligne source -1 inexistante).

for( int i = 0; i < source_rows; ++i ) {
	QSqlRecord record = m_sourceModel->record( i );
 
	int parentCategoryId = record.value( list_parentid ).toInt();
	int parentCategoryIndex = m_categoryIdMapping.value( parentCategoryId, -2 );
	Q_ASSERT( parentCategoryIndex > -2 );
	Mapping * mapping = m_sourcesIndexMapping.value( i );
	mapping->parentIndex = parentCategoryIndex;
	mapping->parrentId   = parentCategoryId;
 
	Mapping * categoryMapping = m_sourcesIndexMapping.value( parentCategoryIndex );
	categoryMapping->source_rows.append( i );
}

Enfin pour chaque enregistrement de notre modèle source, nous récupérons l'identifiant du parent et recherchons dans la structure que nous venons de créer l'index dans le modèle source de la catégorie parente.

Ces valeurs sont alors renseignées dans le modèle. Nos ajoutons également dans la structure de mapping de la catégorie parent, notre ligne dans la liste des enfants.

Notre structure est ainsi complètement initialisé. Un identifiant connaît donc son parent, et la liste de ses enfants. C'est sur cette structure que se basera le reste des méthodes de notre modèle.

mapFromSource()

Le but de cette méthode est de convertir notre index venant du modèle source vers un index de notre modèle à nous.

L'index du modèle source nous donne l'emplacement de la donnée dans le modèle source sous forme (ligne, colonne) alors que l'index de notre modèle doit donner l'emplacement dans notre modèle sous la forme (ligne, colonne, pointeur indiquant le parent).

if( ! sourceIndex.isValid() ) return QModelIndex();
if( sourceIndex.model() != m_sourceModel ) {
	qWarning( "CategoryItemModel: index from wrong model passed to mapFromSource" );
	return QModelIndex();
}

Il faut donc d'abord vérifier que l'index du modèle source est valide. S'il n'est pas valide, alors il ne sera pas valide non plus dans notre modèle à nous.

int row = sourceIndex.row();
IndexMap::const_iterator it = m_sourcesIndexMapping.constFind( row );
Q_ASSERT( it != m_sourcesIndexMapping.constEnd() );

Nous récupérons l'index dans le modèle source, et à l'aide de notre tableau d'index source, nous allons retrouver l'objet Mapping correspondant. Cette objet Mapping correspondra à celui de notre index source. Ce dont nous avons besoin pour notre modèle est l'objet Mapping de l'objet parent (En effet, notre index est construit sous la forme : ligne, colonne, pointeur sur la structure Mapping du parent de notre index). Nous récupérons donc l'index de la ligne source dans l'objet parent.

int parentRow = it.value()->parentIndex;
IndexMap::const_iterator parentIt = m_sourcesIndexMapping.constFind( parentRow );
Q_ASSERT( parentIt != m_sourcesIndexMapping.constEnd() );
 
Mapping * m = parentIt.value();

Cela nous permet de récupérer l'objet Mapping de l'index parent.

int proxyRow    = m->source_rows.indexOf( row );
int proxyColumn = sourceColumnToProxy( sourceIndex.column() );
if( proxyColumn == -1 ) return QModelIndex();

La méthode sourceColumnToProxy() permet de transformer une colonne de l'objet source en une colonne de l'objet courant. Cela signifie que la colonne 2 sera convertie en colonne 1, et que les colonnes 1 et 3 ne seront pas converties (et cachées). Dans ce dernier cas, nous retournons QModelIndex().

L'index de la ligne dans notre modèle sera donné par la position dans la liste source_rows dans notre structure de conversion.

return createIndex( proxyRow, proxyColumn, *parentIt );

Nous pouvons alors créer notre index.

mapToSource()

De la manière inverse à la méthode mapFromSource(), cette méthode permet de convertir un index de notre objet en un index du modèle source.

if( ! proxyIndex.isValid() ) return QModelIndex();
if( proxyIndex.model() != this ) {
	qWarning( "CategoryItemModel: index from wrong model passed to mapToSource" );
	return QModelIndex();
}

Si le modèle est invalide dans notre modèle, il l'est aussi dans le modèle source. Il n'y a pas d'équivalent dans le modèle source de l'index racine.

Mapping * m = static_cast<Mapping*>( proxyIndex.internalPointer() );

Nous récupérons la structure dans le pointeur interne de notre index.

int sourceColumn = proxyColumnToSource( proxyIndex.column() );
if( sourceColumn == -1 ) return QModelIndex();

Nous récupérons également les informations sur notre colonne (Soit, conversion de la colonne 0 dans notre modèle, en la colonne 1 dans le modèle source).

int sourceRow = m->source_rows.at( proxyIndex.row() );

Nous recherchons dans notre liste source_rows la ligne dans le modèle source qui correspond à la ligne (relative au père) indiqué par notre index et nous construisons un index de type (ligne, colonne) correspondant au modèle source.

return m_sourceModel->index( sourceRow, sourceColumn );

L'implémentation des méthodes mapFromSource() et mapToSource() permettent de faire fonctionner les implémentations des méthodes data(), headerData(), et flags(). Il n'y aura donc aucun intérêt à ré-implémenter ces méthodes à moins de vouloir traiter les données de ces fonctions. Nous ne les décrirons donc pas ici, mais vous pourrez voir dans le fichier attaché, un exemple d'utilisation.

index()

Le principe de cette méthode est de générer un index pour notre modèle. L'index doit être valide et réutilisable dans les méthodes rowCount(), flags(), columnCount(), data(), mapToSource().

if( ( row < 0 ) || ( column < 0 ) ) return QModelIndex();

Si la ligne ou la colonne est inférieure à 0, l'index n'est pas valide.

IndexMap::const_iterator it = m_sourcesIndexMapping.constFind( -1 );
 
QModelIndex sourceParent = mapToSource( parent );
if( sourceParent.isValid() ) {
	it = m_sourcesIndexMapping.constFind( sourceParent.row() );
}

A partir de l'index parent nous retrouvons l'index qui correspond dans le modèle source (sourceParent'). Si l'on ne trouve pas d'index dans le modèle source, nous considérons être sur l'élément racine de notre arbre. Sinon nous recherchons dans la table de Mapping'' la structure qui correspond.

Q_ASSERT( it != m_sourcesIndexMapping.constEnd() );
if( it.value()->source_rows.count() <= row )
	return QModelIndex();

Nous vérifions le nombre d'élément dans la structure et nous retournons un index non valide si l'index demandé va au delà de la taille du tableau.

return createIndex( row, column, *it );

Finalement nous retournons l'index créé avec le pointeur vers la structure Mapping du père en internalData.

parent()

Cette méthode permet de retourner pour l'index donné du proxy, l'index du parent. Un index invalide n'a pas de parent.

if( ! index.isValid() ) return QModelIndex();
 
Mapping * m = static_cast<Mapping*>( index.internalPointer() );

On récupère la structure de correspondance stockée dans le pointeur interne de l'objet. Cette structure nous donne les informations du parent (en effet dans internalPointer(), on stock la structure Mapping du parent), et donc l'index dans le modèle source.

int sourceRow = m->index;
if( sourceRow == -1 ) return QModelIndex();
 
QModelIndex sourceParent = m_sourceModel->index( sourceRow, proxyColumnToSource( 0 ) );
QModelIndex proxyParent = mapFromSource( sourceParent );

On utilise alors notre méthode mapFromSource() pour retrouver l'index du parent dans le référentiel du proxy.

return proxyParent;

rowCount()

Le but de cette méthode est de retourner le nombre de ligne enfant pour un index. Dans le modèle source les indexes n'ont pas d'enfant. Lorsque l'index vaut QModelIndex(), cela signifie qu'il faut retourner le nombre de ligne pour notre racine.

if( index.column() > 0 ) return 0;

Seul la première colonne a des enfants.

if( ! index.isValid() ) {
	Mapping * rootMapping = m_sourcesIndexMapping.value( -1 );
	return rootMapping->source_rows.count();

Pour l'index racine, on récupère le nombre de ligne à la ligne -1 du modèle source.

} else {
	Mapping * parrentMapping = static_cast<Mapping*>( index.internalPointer() );
	int sourceRowIndex = parrentMapping->source_rows.at( index.row() );
	Mapping * rowMapping = m_sourcesIndexMapping.value( sourceRowIndex );
 
	return rowMapping->source_rows.count();

Sinon on récupère la structure stockée dans le pointeur interne. Cette structure est celle du parent de notre objet. On récupère à l'aide de la méthode row() de l'index l'emplacement de la ligne source. Cette ligne source nous permet de récupérer la structure de correspondance de notre index, et ainsi le nombre de ligne de notre index.

columnCount()

Notre modèle ne possède qu'une seule colonne.

return 1;

proxyColumnToSource()

Si la colonne du proxy vaut 0, alors on retourne la colonne 1, sinon on retourne la colonne -1 : la colonne n'est pas convertible, elle n'existe pas dans notre proxy.

if( proxyColumn == 0 )
	return list_name;
return -1;

sourceColumToProxy()

Si la colonne source est 1, alors nous convertissons celle-ci en la colonne 0. Sinon la colonne n'existe pas dans notre proxy.

if( sourceColumn == list_name )
	return 0;
return -1;

KMyMoney - Logiciel de compte

Ulrich Van Den Hekke — Sat, 23 May 2009 12:31:00 +0200

Voilà un bon logiciel sur lequel on peut compter (mouarf ! mouarf ! mouarf !), KMyMoney est un éditeur de compte. Je l'utilise quotidiennement, et je décide donc d'en parler un peu, pour que d'autres personnes puissent s'intéresser aussi à ce logiciel.

KMyMoney est un logiciel de gestion de compte pour particulier. Il vous permet de gérer plusieurs de vos comptes en banque, en vous permettant de saisir les dépenses et les recettes sur chacun de vos comptes.

Vous pouvez également lui indiquer vos échéances (par exemple : forfait téléphone, prêt immobilier^[1], mais aussi salaire, vos virements internes ou externes, ...) qu'il s'occupera de mettre à jour dans le registre automatiquement ou à votre demande.

Après une année d'utilisation, il vous permet également de sortir un rapport détaillé sur vos dépenses et vos recettes suivant les catégories saisies pour vos opérations. Cette information peut vous être très utile pour voir où se trouve le "trou" de votre porte monnaie et ainsi faire une rustine. Il vous permet aussi de vous projeter vers l'avenir et de faire votre budget pour l'année prochaine. KMyMoney vous offre pour cela, la saisie de votre budget, ainsi que plusieurs rapports d'écart, vous permettant ainsi de retrouver facilement où vous avez finalement dépensé plus que le budget prévu, et où vous avez dépensé moins.

En plus de vos comptes en banque normaux, KMyMoney vous permet également de gérer vos comptes titre, et les actions que vous y avez mises. Vous pouvez alors facilement suivre la chute vertigineuse de la bourse et votre portefeuille fondre littéralement, mais aussi la remontée (on espère), des actions d'ici quelques ... siècles.

Enfin pour les paranos, vos comptes peuvent être cryptés à l'aide de votre clé GnuPG automatiquement par KMyMoney

Après cette courte présentation, je vous souhaite bon compte

Pour une vie équilibrée, n'oubliez pas de profiter du soleil, au lieu de passer votre temps sur votre ordinateur

Notes

[1] Il s'occupera d'ailleurs de calculer la durée des échéances, ... en fonction des différents chiffres que vous allez lui entrer.

Le net en france ...

Ulrich Van Den Hekke — Mon, 02 Mar 2009 14:09:00 +0100

Devant le ridicule d'un gouvernement qui s'entête à vouloir déconnecter du Net des familles entières sans preuves valables ni procès, la Quadrature appelle les citoyens épris de liberté à procéder au « black-out » de leurs sites, blogs, profils, avatars, etc. Comme en Nouvelle-Zélande, seul pays avec la France où la « riposte graduée » devait être imposée par la loi, pour finalement être repoussée : pour protester contre cette loi imbécile et sa « liste blanche » de sites autorisés, le Net français doit agir et se draper de noir.
La quadrature du net, Paris, le 25 février

Outil de sécurisation non intéropérable

Ulrich Van Den Hekke — Fri, 20 Feb 2009 10:00:00 +0100

Alors que l'UMP est accusé de contrefaçon du groupe MGMT^[1], et est donc accusé du terme de piratage selon le mot utilisé à mauvais escient, nous avons des nouvelles sur le logiciel espion du gouvernement^[2].

Ce dernier sera non seulement payant mais également non interopérable. Pour le rapporteur Riester, l'interopérabilité est un frein au choix et n'est pas nécessaire :

Je n’y suis pas favorable, a-t-il expliqué avant de poursuivre il faut laisser au consommateur sa totale liberté de choix en fonction de son système d’exploitation. L’interopérabilité n’est pas nécessaire pour les consommateurs et elle est trop contraignante pour les éditeurs de logiciels

les moyens de sécurisation mis en place ne sauraient être gratuits, à l’image des logiciels de contrôle parental, mis à la disposition des consommateurs à titre payant, même si leur prix est modique

En plus de l'abonnement internet et du modem ADSL de l'opérateur, il faudra également donc s'acheter ce logiciel espion, ainsi que le système d'exploitation Redmondien qui va avec. En effet, aucun éditeur de logiciel ne trouvera un intérêt (monétaire) à développer un tel logiciel espion (qui sera, de surcroit, à source fermé) pour un système d'exploitation libre. Comment donc pourrions-nous nous défendre, nous utilisateurs du logiciel libre, si vis-à-vis de la loi, nous ne pourrons nous justifier d'un téléchargement illégal même s'il n'en est pas le cas.

Alors que l'on parle de vente lié, M. Henrard répond On crée une incitation et chacun se détermine en fonction de ses obligations. Il y a des aléas dont on veut se protéger et si on est un tout petit peu rationnel, il est évident qu’on va demander à son FAI l’utilisation d’un tel dispositif. et donc payer ...

Le président de l'APRIL^[3] s'insurge qu'il reste encore à l'Assemblée nationale des députés qui sont opposés à l'interopérabilité, opposés à la libre concurrence, opposés au libre-choix des utilisateurs, et opposés au logiciel libre

Quand au logiciel en lui-même, personne ne connait son fonctionnement : - Qu'enverra-t-il comme donnée ? - A qui enverra-t-il les données (au FAI ? au gens plein de fric (major) ? au marketing ? au gouvernement ? à tout ces gens ?) - Devras-t-il être sur chaque ordinateur (avec une licence par ordinateur à payer) ? Sur le modem ADSL ? Sur un seul des ordinateurs (et il nous sera alors interdis d'avoir plus d'un ordinateur par foyer) ?

La France apparaitra alors surement bientôt (pour 2009) dans les pays ennemis d'Internet^[4]. Vive la république et vive la France.

Notes

[1] http://www.lexpress.fr/culture/musique/l-ump-a-t-il-pirate-mgmt_742192.html

[2] http://www.pcinpact.com/actu/news/49218-hadopi-interoperabilite-logiciel-libre-payant.htm?vc=1

[3] Benoît Sibaud, président de l'APRIL

[4] http://fr.wikipedia.org/wiki/Internet_et_la_censure#Les_ennemis_d.E2.80.99Internet