Documentation Qtfr - version_PyQt4

Utilisation de PyQt avec Qt 4.4

Visiteur — Thu, 01 May 2008 15:14:00 +0200

Tool69 vous propose, étape par étape, d'utiliser PyQt avec Qt4.4 RC1.

Version : Qt4/PyQt4
Auteur : Tool69

Le document est disponible en 2 formats:

Voir la page sur le blog de l'auteur
libre téléchargement en PDF : téléchargez.

Rapid GUI Programming with Python and Qt

Visiteur — Sun, 25 Nov 2007 15:27:00 +0100

Mark Summerfield déjà co-auteur du célèbre livre C++ GUI Programming with Qt 4 (traduit en Français aux éditions Pearson Education) nous livre un nouvel opus sur la librairie Qt4 mais dédié cette fois-ci au language Python.

Merci à tool69 pour cette revue, qui donne envie de se plonger dans la lecture de cet ouvrage.

Auteur : tool69

Informations

Auteurs : Mark Summerfield
Editeur : Prentice Hall PTR
Langue : anglais
ISBN : 0132354187
Pages : 460
Public visé : tout développeur Python, même débutant
Page du livre : http://www.qtrac.eu/pyqtbook.html

Résumé et revue

Parlons de la qualité du livre lui-même : une belle couverture rigide sur laquelle figure l'image du satellite Hubble en orbite autour de la Terre. Le sens ? Python est utilisé par la NASA pour calibrer et analyser les données recueillies par celui-ci. Que ce soit le papier, la qualité d'impression ou les multiples diagrammes, il n'y a rien à redire si ce n'est qu'on aimerait voir ce genre d'initiatives plus souvent chez nos éditeurs, surtout eû égard au prix pratiqué.

Passons maintenant au contenu proprement dit, qui se divise en quatre parties distinctes (cinq en fait si l'on compte les divers appendices qui représentent à eux seuls presque une centaine de pages) :

Programmation avec Python;
Programmation d'interfaces graphiques niveau basique;
Programmation d'interfaces graphiques niveau intermédiaire;
Programmation d'interfaces graphiques niveau avancé;

On peut s'interroger sur le bien fondé de la première partie, en effet il serait étonnant qu'une personne ne connaissant pas le language se risque à acheter un tel livre. Et pourtant Mark réussi là un véritable tour de force : on balaye les fonctionnalités du language par la pratique, avec des exemples vraiment très pertinents. J'avoue même avoir appris certains concepts dont je ne soupçonnais pas l'existence, sans doute faute d'en avoir eû un réel besoin. Les fonctions partielles par exemple ont un intérêt certain dans la suite de l'ouvrage. De la même façon, vous pourrez y voir de multiples références au PEPs (Python Enhancement Proposals : les fonctionnalités à venir de Python).

Si l'anglais peut rebuter au départ, surtout lorsqu'il est technique, on se surprend rapidement à lire un thème donné sans avoir recours au dictionnaire (je précise que je n'ai aucune thèse en anglais). Le style se veut simple et efficace, sans être simpliste.

Autant vous rassurer tout de suite, le contenu des trois parties consacrées au vif du sujet, la programmation d'interfaces graphiques n'est pas du tout un plagiat du livre précédent : C++ GUI Programming with Qt 4. On y aborde évidemment plus ou moins les mêmes sujets, mais un réel travail a été fourni sur les nouvelles fonctionnalités apparues depuis la version 4.2 de Qt4. Citons par exemple un chapitre entier consacré à l'architecture du Graphics view : un réel plus par rapport au livre précédent.

Les exemples sont abondants, collent à la pratique et vous pourrez en outre les récupérez gratuitement sur la page que Marc à consacré à son ouvrage. Sachez du reste qu'elle est remise à jour régulièrement, afin d'améliorer encore certains exemples et de proposer un errata.

Citons aussi quelques petits cadeaux vraiment bien venus : des utilitaires écrits par l'auteur afin de gérer au mieux vos projets PyQt4.

A chaque fois, on vous place en situation de développeur et vous serez amené à résoudre quelques exercices proposés en fin de chapitre.

J'ai beaucoup apprécié l'éventail d'alternatives à un problème donné. Comment imprimer le contenu d'un QTextEdit par exemple ? Marc vous propose trois méthodes abondamment commentées, de la plus simple à la plus complexe, à vous de choisir ensuite en fonction de vos besoins, de votre niveau ou du temps que vous allez y passer.

Vous l'aurez donc compris, j'ai été plus que séduit par ce livre. On ne passe pas son temps à comparer Qt à tel autre toolkit comme le font certains ouvrages (d'ailleurs, serait-ce vraiment la peine ?), on pratique avant tout, et les repères ne manquent pas: index abondant, diagrammes de classes, éventail visuel de tous les widgets.

Des critiques ? Un chapitre de C++ GUI Programming with Qt 4 était consacré au développement de plugins avec C++, il est absent ici, comme dans tout livre sur Python consacré à ce vaste sujet. Il est vrai que les possibilités dynamiques qu'offrent Python permettent de pallier à ce problème assez facilement, mais encore faut-il mettre la main à la pâte. S'il est absent, c'est à mon avis surtout parce qu'il n'existe pas de recette toute faite, mais j'aurais au moins aimé disséquer un exemple simple sur le sujet.

Enfin contrairement à beaucoup d'autres ouvrages, Rapid GUI Programming with Python and Qt se distingue aussi par la façon dont il a été écrit. Pas de LaTeX, de Scribus, de QuarkXPress ni même de InDesign ici, mais une alternative originale et légère : Lout.

Un conteneur pour MPlayer (utilisation de QProcess)

IrmatDen — Mon, 02 Apr 2007 09:01:00 +0200

Comment visualiser une vidéo dans Qt ?
Comment intégrer MPlayer et Qt ?

Qt, dans son souci de framework généraliste, n'implémente pas toujours tout ce dont on peut avoir besoin, surtout lorsque cela n'est pas d'usage courant. Les vidéos font partie de ce qui n'était pas couvert par Qt (maintenant supporté depuis la 4.4 par le biais de Phonon). Cependant, un grand nombre de librairies et autres backends existent. Nous allons voir comment utiliser l'un d'entre eux: MPlayer.

Version concernée : Toutes versions (exemple fait avec C++/Qt4 et une version pyQt disponible)
Auteur : Denys Bulant (IrmatDen), alteo_gange et egaudrain pour les versions pyQt
Résumé : utiliser MPlayer conjointement à Qt pour afficher une vidéo
Fil de discussion : Forum

Généralité sur MPlayer en tant que backend...

La particularité de MPlayer est de ne pas s'intégrer par le biais d'une api, mais par un process externe. Les applications désirant l'utiliser en tant que tel, doivent communiquer avec lui par le biais de son flux d'entrée. Les flux de sorties (standard/erreur) peuvent bien sûr être analysés pour récupérer diverses infos sur la vidéo ainsi que les réponses à des requêtes pouvant être formulées par votre application.

Voici ce dont vous aurez besoin :

MPlayer installé, et fonctionnel,
La page des options de MPlayer,
Et la liste des options en slave mode pour mplayer (c'est toutes les manip qui vous sont permises, donc considérez ce fichier comme votre référence ;)).

Pour utiliser MPlayer comme backend, il y a 2 arguments à lui passer impérativement:

l'id du widget à utiliser pour le rendu par le biais de "-wid"
"-slave" qui permet de le mettre en mode esclave, d'où le nom ;-)

Exemple de code lançant MPlayer comme backend:

QStringList args;
// On demande à utiliser mplayer comme backend
args << "-slave";
#ifdef Q_WS_WIN
// reinterpret_cast<unsigned int> obligatoire, HWND ne se laissant pas convertir gentiment ;)
args << "-wid" << QString::number(reinterpret_cast<unsigned int>(renderTarget->winId()));
#else
// Sur linux, pas de manip pour Wid :)
args << "-wid" << QString::number(renderTarget->winId());
#endif

A savoir aussi que sur Windows, je n'ai trouvé que directx comme driver de sortie :/ Cela ne concerne pas les autres OS; lors de mon test sur Linux, je n'ai eu aucun driver à spécifier et cela marche nickel.

Et apparemment les seuls drivers compatibles pour un embarquement de MPlayer sous Linux sont xv, x11 et gl. Et sous Linux, il faut faire attention à avoir un widget de taille raisonnable pour contenir la vidéo. En effet, contrairement à Windows, un resize à la volée n'est pas possible :/

Ensuite, le mode esclave permet donc de commander MPlayer pour:

obtenir des infos (ex: get_video_resolution/get_time_length/...)
lui donner un ordre (ex: play/pause/quit/...)

Tout ce qui lui est transmis, doit être terminé par un retour chariot. Si vous demandiez une information, elle sera renvoyée sur la sortie standard, avec un début de ligne propre à chaque commande (ex: get_video_resolution renverra ANS_VIDEO_RESOLUTION='resX x resY')

Exemple complet

Voici un programme proposant les fonctionnalités suivantes:

lecture d'une vidéo
arrêt
avancer/reculer en déplaçant le slider
affiche le log de toutes ce qui sort sur les flux stdout et stderr de mplayer

Vous le trouverez en annexe de ce tuto ; seuls les points essentiels sont repris ici par souci de clarté. Pour vos tests, pensez à changer les valeurs de mPlayerPath et movieFile, en haut du fichier.

Ce n'est pas un frontend complet, mais cela vous permettra de voir fonctionner Qt 4 avec MPlayer en utilisant QProcess :)

Comme dit dans l'introduction, une version pyQt a été réalisée par alteo_gange. Elle est disponible sur le forum. A noter qu'une version multi-plateforme a été postée par egaudrain; le code est dispo à ce post.

class PlayerWidget: public QWidget
{
    Q_OBJECT
 
public:
    PlayerWidget(QWidget *parent =0)
        :QWidget(parent), isPlaying(false)
    {
        [...]
        renderTarget = new QWidget;
        renderTarget->setSizePolicy(QSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed));
        renderTarget->setAttribute(Qt::WA_PaintOnScreen);
        renderTarget->setMinimumSize(320, 240);
        [...]
 
        mplayerProcess = new QProcess(this);
 
        [...]
        connect(mplayerProcess, SIGNAL(readyReadStandardOutput()),
            this, SLOT(catchOutput()));
        connect(mplayerProcess, SIGNAL(finished(int, QProcess::ExitStatus)),
            this, SLOT(mplayerEnded(int, QProcess::ExitStatus)));
        [...]
    }
 
protected:
    virtual void closeEvent(QCloseEvent *e)
    {
        [...]
    }
 
    private:
    bool startMPlayer()
    {
        [...]
        QStringList args;
        // On demande à utiliser mplayer comme backend
        args << "-slave";
        // Et on veut ne pas avoir trop de chose à parser  :) 
        args << "-quiet";
 
#ifdef Q_WS_WIN
        // reinterpret_cast<qlonglong> obligatoire, winId() ne se laissant pas convertir gentiment ;)
        args << "-wid" << QString::number(reinterpret_cast<qlonglong>(renderTarget->winId()));
        args << "-vo" << "directx:noaccel";
#else
        // Sur linux, aucun driver n'a été nécessaire et pas de manip pour Wid :)
        args << "-wid" << QString::number(renderTarget->winId());
        log->append("Video output driver may not be necessary for your platform. \
                    Check: http://www.mplayerhq.hu/DOCS/man/en/mplayer.1.html \
                    at the VIDEO OUTPUT DRIVERS section.");
#endif
 
        args << movieFile;
        qDebug(args.join(" ").toUtf8());
 
        // On parse la stdout et stderr au même endroit, donc on demande à "fusionnner" les 2 flux
        mplayerProcess->setProcessChannelMode(QProcess::MergedChannels);
        mplayerProcess->start(mplayerPath, args);
        if(!mplayerProcess->waitForStarted(3000))
        {
            qDebug("allez, cherche le bug :o");
            return false;
        }
 
        // On récupère les infos de base
        mplayerProcess->write("get_video_resolution\n");
        mplayerProcess->write("get_time_length\n");
        [...]
    }
 
    bool stopMPlayer()
    {
        [...]
        mplayerProcess->write("quit\n");
        if(!mplayerProcess->waitForFinished(3000))
        {
            qDebug("ZOMG, ça plante :(");
            return false;
        }
 
        return true;
    }
 
private slots:
    void catchOutput()
    {
        while(mplayerProcess->canReadLine())
        {
            QByteArray buffer(mplayerProcess->readLine());
            log->append(QString(buffer));
 
            // On vérifie si on a eu des réponses
            // réponse à get_video_resolution : ANS_VIDEO_RESOLUTION='176 x 144'
            if(buffer.startsWith("ANS_VIDEO_RESOLUTION"))
            {
                buffer.remove(0, 21);
                buffer.replace(QByteArray("'"), QByteArray(""));
                buffer.replace(QByteArray(" "), QByteArray(""));
                buffer.replace(QByteArray("\n"), QByteArray(""));
                buffer.replace(QByteArray("\r"), QByteArray(""));
                int sepIndex = buffer.indexOf('x');
                int resX = buffer.left(sepIndex).toInt();
                int resY = buffer.mid(sepIndex+1).toInt();
                renderTarget->setMinimumSize(resX, resY);
            }
            // réponse à get_time_length : ANS_LENGTH=45.28
            if(buffer.startsWith("ANS_LENGTH"))
            {
                buffer.remove(0, 11);
                buffer.replace(QByteArray("'"), QByteArray(""));
                buffer.replace(QByteArray(" "), QByteArray(""));
                buffer.replace(QByteArray("\n"), QByteArray(""));
                buffer.replace(QByteArray("\r"), QByteArray(""));
                float maxTime = buffer.toFloat();
                timeLine->setMaximum(static_cast<int>(maxTime+1));
            }
            // réponse à get_time_pos : ANS_TIME_POSITION=2.4
            if(buffer.startsWith("ANS_TIME_POSITION"))
            {
                buffer.remove(0, 18);
                buffer.replace(QByteArray("'"), QByteArray(""));
                buffer.replace(QByteArray(" "), QByteArray(""));
                buffer.replace(QByteArray("\n"), QByteArray(""));
                buffer.replace(QByteArray("\r"), QByteArray(""));
                float currTime = buffer.toFloat();
                timeLine->setValue(static_cast<int>(currTime+1));
            }
        }
    }
 
    void pollCurrentTime()
    {
        mplayerProcess->write("get_time_pos\n");
    }
 
    // Dirige la timeline
    void timeLineChanged(int pos)
    {
        mplayerProcess->write(QString("seek " + QString::number(pos) + " 2\n").toUtf8());
    }
 
    // Play/stop
    void switchPlayState()
    {
        [...]
    }
 
    void mplayerEnded(int exitCode, QProcess::ExitStatus exitStatus)
    {
        [...]
    }
 
private:
    [...]
    QWidget *renderTarget;
    QProcess *mplayerProcess;
    [...]
};

Si vous avez des remarques...

Si vous avez besoin d'un éclaircissement, vous pouvez le faire ici.

Utilisation du designer avec PyQt4

Visiteur — Fri, 30 Mar 2007 21:03:00 +0200

Comment utiliser le designer avec PyQt4 ?
Comment intégrer les widgets créer avec le designer dans un programme python ?

Cet article va détailler l'intégration d'un widget créer avec le designer Qt dans un programme python, en utilisant le binding python de PyQt de Riverbank. Il va aussi détailler l'utilisation de pyuic, qui permet de générer le code python à partir des fichiers créés par le designer.

Auteur : Kib² (tool69)
Version : PyQt4 (Riverbank)

L'article est disponible sur le site de Kib² : http://kib2.webfactional.com/blog/2....

Si jamais vous avez déjà programmé en Python avec la bibliothèque d'origine TkInter, vous savez déjà que coder une interface utilisateur à la main est une tâche à la fois longue et fastidieuse.

QtDesigner est l'outil fourni par la bibliothèque Qt qui vous permet de réaliser une GUI (en Français une IHM : Interface Homme-Machine), par le biais d'un système de glisser-déposer. Il est ainsi possible de créer trois types de « formes » : des widgets, des dialogues ou des applications, tout ceci vous étant demandé par QtDesigner lors de création d'une nouvelle « form » (à partir du menu, choisir File/New Form).

QtDesigner ne génère pas de code source directement. Il peut uniquement sauvegarder votre « forme » avec l'extension « .ui », un dérivé du format XML. Il vous est alors possible, grâce à un module nommé « uic » (lui même écrit en Python) de générer le code Python à l'interface que vous avez précédemment déssiné. C'est à la fois un gain de temps et de productivité, mais aussi une bonne façon de séparer le fond de la forme de votre interface.

C'est l'utilitaire en ligne de commande nommé « pyuic4 » qui vous permettra de manipuler le module « uic », il sera détaillé un peu plus loin.

Il est aussi disponible en libre téléchargement en annexe au format PDF et html.