Qwt (Qt Widgets for Technical Applications) est une bibliothèque annexe à Qt, qui utilise cette dernière, et qui simplifie la création de widgets de mesure (courbes, graphiques, jauges, cadrans...). Cette bibliothèque, ainsi que toutes les informations la concernant, sont disponibles sur la page Web du projet.

Quelques images des exemples Qwt sont disponibles dans le chapitre "Screenshots" de la page Web de la bibliothèque. Elles sont assez représentatives du type de composants pouvant être créés, même si une personnalisation est toujours possible.

Les classes Qwt sont basées sur celles de Qt, et leur utilisation est relativement simple. De plus, les classes disponibles sont assez complètes, et permettent facilement de créer l'objet que l'on désire. Cependant, cette bibliothèque est moins intuitive que Qt, et la documentation la concernant est plutôt succincte. Il est nécessaire de connaître les bases de l'utilisation de Qt pour utiliser Qwt.

Qwt est basé sur Qt, et il faut donc préalablement avoir installé le framework Qt. Il suffit ensuite de décompresser l'archive Qwt, modifier le fichier .pri (similaire au fichier .pro) selon vos besoins, puis d'exécuter qmake, puis make ou équivalents (nmake, cmake...).

Les repères des courbes (QwtPlot) et les éléments de type "jauges" (QwtCompass, QwtDial, QwtKnob...) héritent tous de la classe QWidget. Il est donc facile de les ajouter, comme tout autre widget, dans le layout de votre application.

La classe principale pour la gestion des repères est QwtPlot. Son utilisation est très simple. Par défaut, seule la partie positive des axes x et y apparaît, mais cela est modifiable.

#include <QApplication>
#include <qwt_plot.h>

int main(int argc, char** argv)
{
    QApplication app(argc,argv);
    QwtPlot myPlot;
    myPlot.show();
    return app.exec();
}

On utilise la méthode setCanvasBackground (const QColor &c).

#include <QApplication>
#include <qwt_plot.h>

int main(int argc, char** argv)
{
    QApplication app(argc,argv);
    QwtPlot myPlot;
    myPlot.setCanvasBackground(Qt::white);
    myPlot.show();
    return app.exec();
}

Les courbes se créent grâce à la classe QwtPlotCurve. Cette classe permet une grande personnalisation de l'affichage (symboles des points, couleur, traçage ou non de ligne, etc.). Une courbe étant une suite de points, il faut renseigner une suite de points à QwtPlotCurve. Pour cela, on utilise la méthode setData(...), qui peut accepter différents arguments. La plus triviale est setData (const double *xData, const double *yData, int size), où xData représente un tableau de double, contenant toutes les abscisses des points de notre courbe, yData contient, lui, les ordonnées. Ainsi, notre premier point aura comme coordonnées [ xData[0],yData[0] ]. Le troisième paramètre, size, renseigne sur le nombre de points à afficher, en partant de zéro. Bien sûr, xData et yData doivent au moins contenir size éléments.

#include <QApplication>
#include <qwt_plot.h>
#include <qwt_plot_curve.h>

int main(int argc, char** argv)
{
    QApplication app(argc,argv);
    QwtPlot myPlot;
    QwtPlotCurve myCurve;

    // indique à myPlot qu'il doit afficher myCurve
    myCurve.attach(&myPlot);

    // QVector peut être facilement manipulé, et peut être converti en double[];
    QVector<double> x(5);
    QVector<double> y(5);
    // On entre des valeurs
    for(int i=0;i<5;i++)
    {
        x.append((double)i);
        y.append((double)(5-i));
    }
    myCurve.setData(x.data(),y.data(),x.size());

    // Il faut rafraîchir l'affichage à l'aide de la méthode replot(), quand les données ont changé.
    myPlot.replot();
    myPlot.show();
    return app.exec();
}

Vous remarquerez que les axes se sont automatiquement ajustés aux données.

Il faut utiliser la méthode QwtPlotCurve::setPen().

#include <QApplication>
#include <qwt_plot.h>
#include <qwt_plot_curve.h>

int main(int argc, char** argv)
{
    QApplication app(argc,argv);
    QwtPlot myPlot;
    QwtPlotCurve myCurve;
    // indique à myPlot qu'il doit afficher myCurve
    myCurve.attach(&myPlot);

    // QVector peut être facilement manipulé, et peut être converti en double[];
    QVector<double> x(5);
    QVector<double> y(5);
    // On entre des valeurs
    for(int i=0;i<5;i++)
    {
        x.append((double)i);
        y.append((double)(5-i));
    }
    myCurve.setData(x.data(),y.data(),x.size());
    // courbe en rouge
    myCurve.setPen(QPen(Qt::red));
    // Il faut rafraîchir l'affichage à l'aide de la méthode replot(), quand les données ont changé.
    myPlot.replot();
    myPlot.show();
    return app.exec();
}

Il est inutile d'ajouter une multitude de courbes pour faire apparaître une grille sur notre repère. QwtPlotGrid permet d'ajouter facilement une grille à notre repère. De plus, cette grille s'adapte automatiquement aux nouvelles échelles, et peut être personnalisée.

#include <QApplication>
#include <qwt_plot.h>
#include <qwt_plot_curve.h>
#include <qwt_plot_grid.h>

int main(int argc, char** argv)
{
    QApplication app(argc,argv);
    QwtPlot myPlot;
    QwtPlotCurve myCurve;
    QwtPlotGrid myGrid;
    // indique à myPlot qu'il doit afficher myCurve
    myCurve.attach(&myPlot);

    // QVector peut être facilement manipulé, et peut être converti en double[];
    QVector<double> x(5);
    QVector<double> y(5);

    // On entre des valeurs
    for(int i=0;i<5;i++)
    {
        x.append((double)i);
        y.append((double)(5-i));
    }

    myCurve.setData(x.data(),y.data(),x.size());

    // indique à myPlot qu'il doit afficher myGrid
    myGrid.attach(&myPlot);

    // Il faut rafraîchir l'affichage grâce à la méthode replot(), quand les données ont changé.
    myPlot.replot();
    myPlot.show();
    return app.exec();
}

On peut facilement réaliser ce type de grille grâce aux méthodes QwtPlotGrid::enableX() et QwtPlotGrid::enableY().

#include <Application>
#include <QHBoxLayout>
#include <qwt_plot.h>
#include <qwt_plot_curve.h>
#include <qwt_plot_grid.h>

int main(int argc, char** argv)
{
    QApplication app(argc,argv);
    QWidget myWidget;

    QwtPlot myLeftPlot;
    QwtPlotGrid myLeftGrid;
    myLeftGrid.enableX(false); // On affiche seulement les lignes horizontales
    myLeftGrid.attach(&myLeftPlot);

    QwtPlot myRightPlot;
    QwtPlotGrid myRightGrid;
    myRightGrid.enableY(false); // On affiche seulement les lignes verticales
    myRightGrid.attach(&myRightPlot);

    QHBoxLayout myLayout(&myWidget);
    myWidget.setLayout(&myLayout);
    myLayout.addWidget(&myLeftPlot);
    myLayout.addWidget(&myRightPlot);

    myLeftPlot.replot();
    myRightPlot.replot();
    myWidget.show();
    return app.exec();
}

Les axes peuvent être aisément personnalisés à l'aide des fonctions setAxisScale (axe,min,max,step) et setAxisTitle (axe,titre). Dans la majorité des cas, la grille s'ajuste automatiquement sur l'échelle du repère.

#include <QApplication>
#include <qwt_plot.h>
#include <qwt_plot_curve.h>
#include <qwt_plot_grid.h>

int main(int argc, char** argv)
{
    QApplication app(argc,argv);

    QwtPlot myPlot;
    QwtPlotGrid myGrid;
    myGrid.attach(&myPlot);

    // l'axe x ira de -15 à +35, en affichant les valeurs de 5 en 5
    myPlot.setAxisScale(QwtPlot::xBottom,-15.0,35.0,5.0);
    myPlot.setAxisScale(QwtPlot::yLeft,-70.0,-35.0,5.0);

    myPlot.setAxisTitle(QwtPlot::xBottom,QString("My x values"));
    // On peut bien sûr utiliser les mêmes propriétés que QString
    myPlot.setAxisTitle(QwtPlot::yLeft,QString("<u>My y values</u>"));
 
    myPlot.replot();
    myPlot.show();

    return app.exec();
}

Il existe une classe dédiée au zoom nommée QwtPlotZoomer. Elle permet de créer très simplement un outil de zoom, et d'autres fonctionnalités. On peut zoomer successivement sur une zone. Le zoom s'effectue en faisant un cliquer-glisser sur une zone du repère, le clic sur la molette permet de revenir au zoom précédent, et le clic droit permet de revenir au repère initial. La grille et les axes s'ajustent avec le zoom.

#include <QApplication>
#include <qwt_plot.h>
#include <qwt_plot_curve.h>
#include <qwt_plot_grid.h>
#include <qwt_plot_zoomer.h>
int main(int argc, char** argv)
{
    QApplication app(argc,argv);

    QwtPlot myPlot;
    QwtPlotGrid myGrid;
    myGrid.attach(&myPlot);
    QwtPlotZoomer myZoomer(myPlot.canvas());

    myPlot.replot();
    myPlot.show();

    return app.exec();
}

Pour intégrer le plug-in Qwt dans Qt Creator par exemple :

1. Compiler Qwt et son plug-in en mode release (ou vérifier qu'ils le sont bien) ;
2. Copier qwt.dll dans C:\Qt\version\bin ;
3. Copier qwt_designer_plugin5.dll dans C:\Qt\version\bin\designer.

(Où version est le numéro de votre version de Qt.)

Il faut ensuite redémarrer Qt Creator et Qwt est maintenant intégré.

Il faut que Designer et/ou Qt Creator aient accès à qwt.dll (version release de la dll Qwt) et que le plugin qwt_designer_plugin.dll (version release toujours, c'est-à-dire celle installée par défaut) soit trouvable par Designer/Qt Creator. Une bonne façon de faire est :

1. installer Qwt (réf. question ci-dessus). qwt.dll est ensuite accessible dans le PATH ;
2. créer la variable d'environnement QT_PLUGIN_PATH avec pour valeur <chemin_d'installation>/plugins.

Attention, pour fonctionner, un plug-in doit être compilé avec le même compilateur que celui qui l'utilise. Donc par exemple si vous compilez Qwt avec MinGW, les binaires de Qt Creator étant livrés compilés avec MSVC, vous ne pourrez pas intégrer Qwt à son Designer. Il faudra donc recompiler Qt Creator en MinGW.

Il est possible que le placement de la macro Q_OBJECT dans la section privée d'une classe dérivée de l'une que fournit Qwt n'ait aucun effet notable. Dans ce cas, pour pouvoir disposer du système de métaobjets dans une classe dérivée d'une classe de Qwt, et donc pour pouvoir profiter des signaux, des slots, des propriétés et de tous les autres dispositifs mis à disposition, il sera nécessaire d'ajouter la ligne suivante dans le fichier .pro :

DEFINES += QWT_DLL

Ce problème n'apparaît que sous Windows, cette solution ne s'applique donc qu'à ce système.