Traduction par Jean-luc Biord, du Site de la communauté Qt francophone.
English TOC.

11. QWT

QWT est l'abréviation de Qt Widgets for Technical Applications (Widgets Qt pour les applications techniques). C'est une collection de widgets et de classes de soutien pour créer des applications techniques telles que celles créées en utilisant, par exemple, LabView ou Test Point.

Ce chapitre couvre l'installation de la bibliothèque et une brève description de plusieurs des widgets fournis. Pour le lecteur intéressé, des détails peuvent être trouvés dans la documentation officielle.

Qwt, version 0.4.1 est utilisé dans tout ce chapitre.

Installation

Tout d'abord, n'est couvert que l'installation de la bibliothèque sur une plateforme Unix (j'emploie Mandrake Linux). Le site Internet donne des informations au sujet de l'installation sur d'autres plateformes. L'installation utilise qmake/tmake et devrait être ainsi assez portable.

D'abord, rendez-vous sur la page d'accueil de QWT en utilisant votre navigateur favori, ou téléchargez simplement le source directement depuis la page du projet sur SourceForge. Désarchivez le fichier tar. Maintenant, le répertoire contenant QWT sera connu avec $(QWT). Pour configurer les variables d'environnement, exécuter cd pour vous rendre dans le répertoire de QWT et saisissez export QWT=`pwd`.

Ce que les instructions d'installation (disponibles en ligne) indique c'est d'exécuter qmake qwt.pro -o Makefile puis de lancer make. Cela construira la bibliothèque. Maintenant, en tant qu'utilisateur Unix, mettez les liens symboliques à un endroit dans LD_LIBRARY_PATH (comme /usr/lib) pour les fichiers du répertoire $(QWT)/lib, ou modifiez LD_LIBRARY_PATH pour inclure ce répertoire.

La bibliothèque est maintenant installée, et maintenant, tout que vous devez faire pour l'utiliser est d'inclure le répertoire $(qwt)/include dans l'INCLUDEPATH de vos fichier-projets et de spécifier le commutateur -lqwt en liant.

Tracé de Base

Dans cette section les détails de l'affichage d'un tracé trivial seront couverts. L'exemple se compose d'un widget personnalisé hérité de la classe QwtPlot. La classe QwtPlot possède la plupart des possibilités de traçage de la bibliothèque Qwt. Le code de la classe dérivée, MyPlot est montré dans l'exemple 11-1.

class MyPlot : public QwtPlot
{
public:
  MyPlot( QWidget *parent=0, char *name=0 ) : QwtPlot( parent, name )
  {
    // Show a title
    setTitle( "This is an Example" );

    // Show a legend at the bottom
    setAutoLegend( true );
    setLegendPos( Qwt::Bottom );

    // Show the axes
    setAxisTitle( xBottom, "x" );
    setAxisTitle( yLeft, "y" );

    // Insert two curves and get IDs for them
    long cSin = insertCurve( "y = sin(x)" );
    long cSign = insertCurve( "y = sign(sin(x))" );

    // Calculate the data, 500 points each
    const int points = 500;
    double x[ points ];
    double sn[ points ];
    double sg[ points ];

    for( int i=0; i<points; i++ )
    {
      x[i] = (3.0*3.14/double(points))*double(i);
    
      sn[i] = 2.0*sin( x[i] );
      sg[i] = (sn[i]>0)?1:((sn[i]<0)?-1:0);
    }

    // Copy the data to the plot
    setCurveData( cSin, x, sn, points );
    setCurveData( cSign, x, sg, points );

    // Set the style of the curves
    setCurvePen( cSin, QPen( blue ) );
    setCurvePen( cSign, QPen( green, 3 ) );

    // Show the plots
    replot();
  }
};

Exemple 11-1

La classe dérivée initialise simplement le tracé dans le constructeur. Les commentaires du code indiquent où chaque action a lieu, mais les détails sont expliqués dans les paragraphes suivants.

La première chose qui est faite c'est que le titre est défini et qu'une légende est automatiquement activée. La légende est placée en dessous du widget, c'est-à-dire. en dessous du tracé. Toutes les courbes qui sont ajoutées au tracé quand la légende automatique est activée seront ajoutées au tracé.

Maintenant, les axes sont définis avec leurs titres. Comme cela peut être vu dans la documentation de setAxisTitle (oui, Qwt a une documentation de référence en ligne avec du code d'exemple) les titres sont placés à gauche et en bas. Enfin deux ID de courbe sont récupérés avant que des données factices soient générées. Les données sont non pertinentes dans l'exemple. Les données pour ces courbes sont alors copiées dans le tracé par les appels à setCurveData.

La dernière tâche lancée avant un replot forcé est de définir les styles de pen à employer pour chaque courbe.

Afin de montrer le tracé, une instance du widget doit être créé. C'est fait dans le main classique montré dans l'exemple 11-2.

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

  MyPlot p;
  a.setMainWidget( &p );
  p.show();

  return a.exec();
}

Exemple 11-2

Traçage Avançé

Le widget QwtPlot est bon pour la plupart des besoins de traçage. Il est cependant basé sur un ensemble de classes de Qwt qui fournit un contrôle plus direct du traçage. Cette section présentera certaines de ces classes, mais il est recommandé au lecteur intéressé de regarder la documentation officielle pour plus de détails.

La classe QwtCurve est employée pour manipuler des instances de courbe. Cette classe offre le contrôle de l'apparence, des méthodes d'interpolation et autres. Pour la représentation de données efficace, par exemple, en temps réel, le filtrage basé sur la requête, peut être mis en application comme sous-classe de QwtData. Ces deux classes combinées fournissent le contrôle total des données affichées.

Au lieu d'offrir un widget, QwtCurve a une méthode draw. En l'appelant depuis un widget personnalisé, n'importe quel widget de traçage peut être créé. Cela rend également possible d'utiliser la classe pour l'impression. Les QwtDiMaps utilisés dans l'appel sont employés pour tracer un vrai intervalle de valeur dans un intervalle de nombre entier. Il peut manipuler les tracés linéaires et logarithmiques.

Pour terminer tout dessin d'un widget de tracé, une grille est nécessaire. Elle est fournie par la classe QwtGrid. Cette classe fonctionne également comme classe de QwtCurve et offre une méthode draw à utiliser dans une routine de dessin.

Widgets

Qwt offre beaucoup de widgets. Dans cette section trois d'entre eux, un bouton, une glissière et une roulette seront montrés. Le schéma 11-1 montre à quoi ressemblera l'application d'exemple.

Qwt Widgets

Schéma 11-1 Les Widgets Qwt

Ces widgets fournissent les signaux et les slots qui peuvent être attendus de n'importe quel widget de Qt et peuvent être ainsi facilement interconnectés ensemble pour afficher la même valeur à tout moment. L'exemple 11-3 montre la classe d'exemple qui utilise les widgets. Notez qu'elle est dérivée d'un QHBox de sorte qu'elle arrange automatiquement ses widgets d'enfant.

class MyWidgetWidget : public QHBox
{
public:
  MyWidgetWidget( QWidget *parent=0, char *name=0 ) : QHBox( parent, name )
  {
    // A knob
    QwtKnob *knob = new QwtKnob( this );
    
    // A slider
    QwtSlider *slider = new QwtSlider( this, "", Qt::Vertical, QwtSlider::Left );
    
    // A wheel
    QwtWheel *wheel = new QwtWheel( this );
    wheel->setOrientation( Qt::Vertical );
    wheel->setTotalAngle( 360*5 );

    // Setup the ranges
    knob->setRange( 0.0, 1000.0 );
    slider->setRange( 0.0, 1000.0 );
    wheel->setRange( 0.0, 1000.0 );

    // Connect the widgets to each other
    connect( knob, SIGNAL(valueChanged(double)), slider, SLOT(setValue(double)) );
    connect( knob, SIGNAL(valueChanged(double)), wheel, SLOT(setValue(double)) );

    connect( slider, SIGNAL(valueChanged(double)), knob, SLOT(setValue(double)) );
    connect( slider, SIGNAL(valueChanged(double)), wheel, SLOT(setValue(double)) );

    connect( wheel, SIGNAL(valueChanged(double)), knob, SLOT(setValue(double)) );
    connect( wheel, SIGNAL(valueChanged(double)), slider, SLOT(setValue(double)) );
  }
};

Exemple 11-3

Ce code ne devrait avoir aucune surprise. Notez que l'orientation par défaut de la roulette et de la glissière est horizontale et que la glissière ne montre aucune échelle à moins qu'une position soit indiquée. Ceci peut être fait en utilisant le constructeur comme dans le code d'exemple ou la méthode setScalePos.

Pour montrer le widget, le main classique de l'exemple 11-4 est employé.

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

  MyWidgetWidget w;
  a.setMainWidget( &w );
  w.show();

  return a.exec();
}

Exemple 11-4

qmake est utilisé pour construire l'exemple. L'exemple 11-5 montre le résultat de l'exécution de qmake -project dans le répertoire de l'exemple (le répertoire s'appelle wid et le source de l'exemple est dans le fichier wid.cpp).

######################################################################
# Automatically generated by qmake (1.04a) Sun Feb 22 16:54:26 2004
######################################################################

TEMPLATE = app
CONFIG -= moc
INCLUDEPATH += .

# Input
SOURCES += wid.cpp

Exemple 11-5

L'exemple 11-6 montre le fichier-projet modifié qui rend possible d'utiliser Qwt. Notez que cela nécessite que la variable d'environnement QWT soit définie comme décrit plus tôt dans ce chapitre.

######################################################################
# Automatically generated by qmake (1.04a) Thu Feb 19 20:44:51 2004
######################################################################


TEMPLATE = app
CONFIG -= moc
INCLUDEPATH += $(QWT)/include
LIBS += -lqwt

# Input
SOURCES += wid.cpp

Exemple 11-6

Pour construire l'exemple, tapez simplement qmake && make && ./wid dans la console.

Résumé

Il n'y a pas de source d'exemple disponible pour ce chapitre.

Exercices

This is a part of digitalfanatics.org and is valid XHTML.