Released version 6.1.3

examples/controls/controls.pro

@@ -0,0 +1,34 @@
+################################################################
+# Qwt Widget Library
+# Copyright (C) 1997   Josef Wilgen
+# Copyright (C) 2002   Uwe Rathmann
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the Qwt License, Version 1.0
+################################################################
+
+include( $${PWD}/../examples.pri )
+
+TARGET       = controls
+
+HEADERS = \
+    sliderbox.h \
+    slidertab.h \
+    wheelbox.h \
+    wheeltab.h \
+    knobbox.h \
+    knobtab.h \
+    dialbox.h \
+    dialtab.h
+
+SOURCES = \
+    sliderbox.cpp \
+    slidertab.cpp \
+    wheelbox.cpp \
+    wheeltab.cpp \
+    knobbox.cpp \
+    knobtab.cpp \
+    dialbox.cpp \
+    dialtab.cpp \
+    main.cpp
+

examples/controls/dialbox.cpp

@@ -0,0 +1,163 @@
+#include <qlabel.h>
+#include <qlayout.h>
+#include <qwt_dial.h>
+#include <qwt_dial_needle.h>
+#include <qwt_scale_engine.h>
+#include <qwt_transform.h>
+#include <qwt_round_scale_draw.h>
+#include "dialbox.h"
+
+DialBox::DialBox( QWidget *parent, int type ):
+    QWidget( parent )
+{
+    d_dial = createDial( type );
+
+    d_label = new QLabel( this );
+    d_label->setAlignment( Qt::AlignCenter );
+
+    QVBoxLayout *layout = new QVBoxLayout( this );;
+    layout->setSpacing( 0 );
+    layout->addWidget( d_dial, 10 );
+    layout->addWidget( d_label );
+
+    connect( d_dial, SIGNAL( valueChanged( double ) ), 
+        this, SLOT( setNum( double ) ) );
+
+    setNum( d_dial->value() );
+}
+
+QwtDial *DialBox::createDial( int type ) const
+{
+    QwtDial *dial = new QwtDial();
+    dial->setTracking( true );
+    dial->setFocusPolicy( Qt::StrongFocus );
+    dial->setObjectName( QString( "Dial %1" ).arg( type + 1 ) );
+
+    QColor needleColor( Qt::red );
+
+    switch( type )
+    {
+        case 0:
+        {
+            dial->setOrigin( 135.0 );
+            dial->setScaleArc( 0.0, 270.0 );
+            dial->setScaleMaxMinor( 4 );
+            dial->setScaleMaxMajor( 10 );
+            dial->setScale( -100.0, 100.0 );
+
+            needleColor = QColor( "Goldenrod" );
+
+            break;
+        }
+        case 1:
+        {
+            dial->setOrigin( 135.0 );
+            dial->setScaleArc( 0.0, 270.0 );
+            dial->setScaleMaxMinor( 10 );
+            dial->setScaleMaxMajor( 10 );
+            dial->setScale( 10.0, 0.0 );
+
+            QwtRoundScaleDraw *scaleDraw = new QwtRoundScaleDraw();
+            scaleDraw->setSpacing( 8 );
+            scaleDraw->enableComponent( 
+                QwtAbstractScaleDraw::Backbone, false );
+            scaleDraw->setTickLength( QwtScaleDiv::MinorTick, 2 );
+            scaleDraw->setTickLength( QwtScaleDiv::MediumTick, 4 );
+            scaleDraw->setTickLength( QwtScaleDiv::MajorTick, 8 );
+            dial->setScaleDraw( scaleDraw );
+
+            break;
+        }
+        case 2:
+        {
+            dial->setOrigin( 150.0 );
+            dial->setScaleArc( 0.0, 240.0 );
+
+            QwtLinearScaleEngine *scaleEngine = new QwtLinearScaleEngine( 2 );
+            scaleEngine->setTransformation( new QwtPowerTransform( 2 ) );
+            dial->setScaleEngine( scaleEngine );
+
+            QList< double > ticks[ QwtScaleDiv::NTickTypes ];
+            ticks[ QwtScaleDiv::MajorTick ] << 0 << 4 
+                << 16 << 32 << 64 << 96 << 128;
+            ticks[ QwtScaleDiv::MediumTick ] << 24 << 48 << 80 << 112;
+            ticks[ QwtScaleDiv::MinorTick ] 
+                << 0.5 << 1 << 2 
+                << 7 << 10 << 13
+                << 20 << 28 
+                << 40 << 56 
+                << 72 << 88 
+                << 104 << 120; 
+ 
+            dial->setScale( QwtScaleDiv( 0, 128, ticks ) );
+            break;
+        }
+        case 3:
+        {
+            dial->setOrigin( 135.0 );
+            dial->setScaleArc( 0.0, 270.0 );
+            dial->setScaleMaxMinor( 9 );
+            dial->setScaleEngine( new QwtLogScaleEngine );
+            dial->setScale( 1.0e-2, 1.0e2 );
+
+            break;
+        }
+        case 4:
+        {
+            dial->setOrigin( 225.0 );
+            dial->setScaleArc( 0.0, 360.0 );
+            dial->setScaleMaxMinor( 5 );
+            dial->setScaleStepSize( 20 );
+            dial->setScale( 100.0, -100.0 );
+            dial->setWrapping( true );
+            dial->setTotalSteps( 40 );
+            dial->setMode( QwtDial::RotateScale );
+            dial->setValue( 70.0 );
+
+            needleColor = QColor( "DarkSlateBlue" );
+
+            break;
+        }
+        case 5:
+        {
+            dial->setOrigin( 45.0 );
+            dial->setScaleArc( 0.0, 225.0 );
+            dial->setScaleMaxMinor( 5 );
+            dial->setScaleMaxMajor( 10 );
+            dial->setScale( 0.0, 10.0 );
+
+            break;
+        }
+    }
+
+    QwtDialSimpleNeedle *needle = new QwtDialSimpleNeedle(
+        QwtDialSimpleNeedle::Arrow, true, needleColor,
+        QColor( Qt::gray ).light( 130 ) );
+    dial->setNeedle( needle );
+
+    //const QColor base( QColor( "DimGray" ) );
+    const QColor base( QColor( Qt::darkGray ).dark( 150 ) );
+
+    QPalette palette;
+    palette.setColor( QPalette::Base, base );
+    palette.setColor( QPalette::Window, base.dark( 150 ) );
+    palette.setColor( QPalette::Mid, base.dark( 110 ) );
+    palette.setColor( QPalette::Light, base.light( 170 ) );
+    palette.setColor( QPalette::Dark, base.dark( 170 ) );
+    palette.setColor( QPalette::Text, base.dark( 200 ).light( 800 ) );
+    palette.setColor( QPalette::WindowText, base.dark( 200 ) );
+
+    dial->setPalette( palette );
+    dial->setLineWidth( 4 );
+    dial->setFrameShadow( QwtDial::Sunken );
+
+    return dial;
+}
+
+void DialBox::setNum( double v )
+{
+    QString text;
+    text.setNum( v, 'f', 2 );
+
+    d_label->setText( text );
+}

examples/controls/dialbox.h

@@ -0,0 +1,25 @@
+#ifndef _DIAL_BOX_H_
+#define _DIAL_BOX_H_
+
+#include <qwidget.h>
+
+class QLabel;
+class QwtDial;
+
+class DialBox: public QWidget
+{
+    Q_OBJECT
+public:
+    DialBox( QWidget *parent, int type );
+
+private Q_SLOTS:
+    void setNum( double v );
+
+private:
+    QwtDial *createDial( int type ) const;
+
+    QwtDial *d_dial;
+    QLabel *d_label;
+};
+
+#endif

examples/controls/dialtab.cpp

@@ -0,0 +1,17 @@
+#include "dialtab.h"
+#include "dialbox.h"
+#include <qlayout.h>
+
+DialTab::DialTab( QWidget *parent ):
+    QWidget( parent )
+{
+    QGridLayout *layout = new QGridLayout( this );
+
+    const int numRows = 3;
+    for ( int i = 0; i < 2 * numRows; i++ )
+    {
+        DialBox *dialBox = new DialBox( this, i );
+        layout->addWidget( dialBox, i / numRows, i % numRows );
+    }
+}
+

examples/controls/dialtab.h

@@ -0,0 +1,12 @@
+#ifndef _DIAL_TAB_H
+#define _DIAL_TAB_H 1
+
+#include <qwidget.h>
+
+class DialTab: public QWidget
+{
+public:
+    DialTab( QWidget *parent = NULL );
+};
+
+#endif

examples/controls/knobbox.cpp

@@ -0,0 +1,119 @@
+#include <qlabel.h>
+#include <qlayout.h>
+#include <qwt_knob.h>
+#include <qwt_scale_engine.h>
+#include <qwt_transform.h>
+#include "knobbox.h"
+
+KnobBox::KnobBox( QWidget *parent, int knobType ):
+    QWidget( parent )
+{
+    d_knob = createKnob( knobType );
+    d_knob->setKnobWidth( 100 );
+
+    d_label = new QLabel( this );
+    d_label->setAlignment( Qt::AlignCenter );
+
+    QVBoxLayout *layout = new QVBoxLayout( this );;
+    layout->setSpacing( 0 );
+    layout->addWidget( d_knob, 10 );
+    layout->addWidget( d_label );
+    layout->addStretch( 10 );
+
+    connect( d_knob, SIGNAL( valueChanged( double ) ), 
+        this, SLOT( setNum( double ) ) );
+
+    setNum( d_knob->value() );
+}
+
+QwtKnob *KnobBox::createKnob( int knobType ) const
+{
+    QwtKnob *knob = new QwtKnob();
+    knob->setTracking( true );
+
+    switch( knobType )
+    {
+        case 0:
+        {
+            knob->setKnobStyle( QwtKnob::Sunken );
+            knob->setMarkerStyle( QwtKnob::Nub );
+            knob->setWrapping( true );
+            knob->setNumTurns( 4 );
+            knob->setScaleStepSize( 10.0 );
+            knob->setScale( 0, 400 );
+            knob->setTotalSteps( 400 );
+            break;
+        }
+        case 1:
+        {
+            knob->setKnobStyle( QwtKnob::Sunken );
+            knob->setMarkerStyle( QwtKnob::Dot );
+            break;
+        }
+        case 2:
+        {
+            knob->setKnobStyle( QwtKnob::Sunken );
+            knob->setMarkerStyle( QwtKnob::Tick );
+            
+            QwtLinearScaleEngine *scaleEngine = new QwtLinearScaleEngine( 2 );
+            scaleEngine->setTransformation( new QwtPowerTransform( 2 ) );
+            knob->setScaleEngine( scaleEngine );
+
+            QList< double > ticks[ QwtScaleDiv::NTickTypes ];
+            ticks[ QwtScaleDiv::MajorTick ] << 0 << 4 
+                << 16 << 32 << 64 << 96 << 128;
+            ticks[ QwtScaleDiv::MediumTick ] << 24 << 48 << 80 << 112;
+            ticks[ QwtScaleDiv::MinorTick ] 
+                << 0.5 << 1 << 2 
+                << 7 << 10 << 13
+                << 20 << 28 
+                << 40 << 56 
+                << 72 << 88 
+                << 104 << 120; 
+ 
+            knob->setScale( QwtScaleDiv( 0, 128, ticks ) );
+
+            knob->setTotalSteps( 100 );
+            knob->setStepAlignment( false );
+            knob->setSingleSteps( 1 );
+            knob->setPageSteps( 5 );
+
+            break;
+        }
+        case 3:
+        {
+            knob->setKnobStyle( QwtKnob::Flat );
+            knob->setMarkerStyle( QwtKnob::Notch );
+            knob->setScaleEngine( new QwtLogScaleEngine() );
+            knob->setScaleStepSize( 1.0 );
+            knob->setScale( 0.1, 1000.0 );
+            knob->setScaleMaxMinor( 10 );
+            break;
+        }
+        case 4:
+        {
+            knob->setKnobStyle( QwtKnob::Raised );
+            knob->setMarkerStyle( QwtKnob::Dot );
+            knob->setWrapping( true );
+            break;
+        }
+        case 5:
+        {
+            knob->setKnobStyle( QwtKnob::Styled );
+            knob->setMarkerStyle( QwtKnob::Triangle );
+            knob->setTotalAngle( 180.0 );
+            knob->setScale( 100, -100 );
+            break;
+        }
+    }
+
+    return knob;
+}
+
+void KnobBox::setNum( double v )
+{
+    QString text;
+    text.setNum( v, 'f', 2 );
+
+    d_label->setText( text );
+}

examples/controls/knobbox.h

@@ -0,0 +1,25 @@
+#ifndef _KNOB_BOX_H_
+#define _KNOB_BOX_H_
+
+#include <qwidget.h>
+
+class QLabel;
+class QwtKnob;
+
+class KnobBox: public QWidget
+{
+    Q_OBJECT
+public:
+    KnobBox( QWidget *parent, int knobType );
+
+private Q_SLOTS:
+    void setNum( double v );
+
+private:
+    QwtKnob *createKnob( int knobType ) const;
+
+    QwtKnob *d_knob;
+    QLabel *d_label;
+};
+
+#endif

examples/controls/knobtab.cpp

@@ -0,0 +1,17 @@
+#include "knobtab.h"
+#include "knobbox.h"
+#include <qlayout.h>
+
+KnobTab::KnobTab( QWidget *parent ):
+    QWidget( parent )
+{
+    QGridLayout *layout = new QGridLayout( this );
+
+    const int numRows = 3;
+    for ( int i = 0; i < 2 * numRows; i++ )
+    {
+        KnobBox *knobBox = new KnobBox( this, i );
+        layout->addWidget( knobBox, i / numRows, i % numRows );
+    }
+}
+

examples/controls/knobtab.h

@@ -0,0 +1,12 @@
+#ifndef _KNOB_TAB_H
+#define _KNOB_TAB_H 1
+
+#include <qwidget.h>
+
+class KnobTab: public QWidget
+{
+public:
+    KnobTab( QWidget *parent = NULL );
+};
+
+#endif

examples/controls/main.cpp

@@ -0,0 +1,41 @@
+#include <qapplication.h>
+#include <qtabwidget.h>
+#include "slidertab.h"
+#include "wheeltab.h"
+#include "knobtab.h"
+#include "dialtab.h"
+
+
+int main ( int argc, char **argv )
+{
+    QApplication a( argc, argv );
+
+    QTabWidget tabWidget;
+
+    SliderTab *sliderTab = new SliderTab();
+    sliderTab->setAutoFillBackground( true );
+    sliderTab->setPalette( QColor( "DimGray" ) );
+
+    WheelTab *wheelTab = new WheelTab();
+    wheelTab->setAutoFillBackground( true );
+    wheelTab->setPalette( QColor( "Silver" ) );
+
+    KnobTab *knobTab = new KnobTab();
+    knobTab->setAutoFillBackground( true );
+    knobTab->setPalette( Qt::darkGray );
+
+    DialTab *dialTab = new DialTab();
+    dialTab->setAutoFillBackground( true );
+    dialTab->setPalette( Qt::darkGray );
+
+    tabWidget.addTab( new SliderTab, "Slider" );
+    tabWidget.addTab( new WheelTab, "Wheel/Thermo" );
+    tabWidget.addTab( knobTab, "Knob" );
+    tabWidget.addTab( dialTab, "Dial" );
+
+    tabWidget.resize( 800, 600 );
+    tabWidget.show();
+
+    return a.exec();
+}
+

examples/controls/sliderbox.cpp

@@ -0,0 +1,172 @@
+#include <qlabel.h>
+#include <qlayout.h>
+#include <qwt_slider.h>
+#include <qwt_scale_engine.h>
+#include <qwt_transform.h>
+#include "sliderbox.h"
+
+SliderBox::SliderBox( int sliderType, QWidget *parent ):
+    QWidget( parent )
+{
+    d_slider = createSlider( sliderType );
+
+    QFlags<Qt::AlignmentFlag> alignment;
+
+    if ( d_slider->orientation() == Qt::Horizontal )
+    {
+        if ( d_slider->scalePosition() == QwtSlider::TrailingScale )
+            alignment = Qt::AlignBottom;
+        else
+            alignment = Qt::AlignTop;
+
+        alignment |= Qt::AlignHCenter;
+    }
+    else
+    {
+        if ( d_slider->scalePosition() == QwtSlider::TrailingScale )
+            alignment = Qt::AlignRight;
+        else
+            alignment = Qt::AlignLeft;
+
+        alignment |= Qt::AlignVCenter;
+    }
+
+    d_label = new QLabel( this );
+    d_label->setAlignment( alignment );
+    d_label->setFixedWidth( d_label->fontMetrics().width( "10000.9" ) );
+
+    connect( d_slider, SIGNAL( valueChanged( double ) ), SLOT( setNum( double ) ) );
+
+    QBoxLayout *layout;
+    if ( d_slider->orientation() == Qt::Horizontal )
+        layout = new QHBoxLayout( this );
+    else
+        layout = new QVBoxLayout( this );
+
+    layout->addWidget( d_slider );
+    layout->addWidget( d_label );
+
+    setNum( d_slider->value() );
+}
+
+QwtSlider *SliderBox::createSlider( int sliderType ) const
+{
+    QwtSlider *slider = new QwtSlider();
+
+    switch( sliderType )
+    {
+        case 0:
+        {
+            slider->setOrientation( Qt::Horizontal );
+            slider->setScalePosition( QwtSlider::TrailingScale );
+            slider->setTrough( true );
+            slider->setGroove( false );
+            slider->setSpacing( 0 );
+            slider->setHandleSize( QSize( 30, 16 ) );
+            slider->setScale( 10.0, -10.0 ); 
+            slider->setTotalSteps( 8 ); 
+            slider->setSingleSteps( 1 ); 
+            slider->setPageSteps( 1 ); 
+            slider->setWrapping( true );
+            break;
+        }
+        case 1:
+        {
+            slider->setOrientation( Qt::Horizontal );
+            slider->setScalePosition( QwtSlider::NoScale );
+            slider->setTrough( true );
+            slider->setGroove( true );
+            slider->setScale( 0.0, 1.0 );
+            slider->setTotalSteps( 100 );
+            slider->setSingleSteps( 1 );
+            slider->setPageSteps( 5 );
+            break;
+        }
+        case 2:
+        {
+            slider->setOrientation( Qt::Horizontal );
+            slider->setScalePosition( QwtSlider::LeadingScale );
+            slider->setTrough( false );
+            slider->setGroove( true );
+            slider->setHandleSize( QSize( 12, 25 ) );
+            slider->setScale( 1000.0, 3000.0 );
+            slider->setTotalSteps( 200.0 );
+            slider->setSingleSteps( 2 );
+            slider->setPageSteps( 10 );
+            break;
+        }
+        case 3:
+        {
+            slider->setOrientation( Qt::Horizontal );
+            slider->setScalePosition( QwtSlider::TrailingScale );
+            slider->setTrough( true );
+            slider->setGroove( true );
+
+            QwtLinearScaleEngine *scaleEngine = new QwtLinearScaleEngine( 2 );
+            scaleEngine->setTransformation( new QwtPowerTransform( 2 ) );
+            slider->setScaleEngine( scaleEngine );
+            slider->setScale( 0.0, 128.0 );
+            slider->setTotalSteps( 100 );
+            slider->setStepAlignment( false );
+            slider->setSingleSteps( 1 );
+            slider->setPageSteps( 5 );
+            break;
+        }
+        case 4:
+        {
+            slider->setOrientation( Qt::Vertical );
+            slider->setScalePosition( QwtSlider::TrailingScale );
+            slider->setTrough( false );
+            slider->setGroove( true );
+            slider->setScale( 100.0, 0.0 );
+            slider->setInvertedControls( true );
+            slider->setTotalSteps( 100 );
+            slider->setPageSteps( 5 );
+            slider->setScaleMaxMinor( 5 );
+            break;
+        }
+        case 5:
+        {
+            slider->setOrientation( Qt::Vertical );
+            slider->setScalePosition( QwtSlider::NoScale );
+            slider->setTrough( true );
+            slider->setGroove( false );
+            slider->setScale( 0.0, 100.0 );
+            slider->setTotalSteps( 100 );
+            slider->setPageSteps( 10 );
+            break;
+        }
+        case 6:
+        {
+            slider->setOrientation( Qt::Vertical );
+            slider->setScalePosition( QwtSlider::LeadingScale );
+            slider->setTrough( true );
+            slider->setGroove( true );
+            slider->setScaleEngine( new QwtLogScaleEngine );
+            slider->setStepAlignment( false );
+            slider->setHandleSize( QSize( 20, 32 ) );
+            slider->setBorderWidth( 1 );
+            slider->setScale( 1.0, 1.0e4 );
+            slider->setTotalSteps( 100 );
+            slider->setPageSteps( 10 );
+            slider->setScaleMaxMinor( 9 );
+            break;
+        }
+    }
+
+    if ( slider )
+    {
+        QString name( "Slider %1" );
+        slider->setObjectName( name.arg( sliderType ) );
+    }
+
+    return slider;
+}
+
+void SliderBox::setNum( double v )
+{
+    QString text;
+    text.setNum( v, 'f', 2 );
+
+    d_label->setText( text );
+}

examples/controls/sliderbox.h

@@ -0,0 +1,25 @@
+#ifndef _SLIDER_BOX_H_
+#define _SLIDER_BOX_H_ 1
+
+#include <qwidget.h>
+
+class QLabel;
+class QwtSlider;
+
+class SliderBox: public QWidget
+{
+    Q_OBJECT
+public:
+    SliderBox( int sliderType, QWidget *parent = NULL );
+
+private Q_SLOTS:
+    void setNum( double v );
+
+private:
+    QwtSlider *createSlider( int sliderType ) const;
+
+    QwtSlider *d_slider;
+    QLabel *d_label;
+};
+
+#endif

examples/controls/slidertab.cpp

@@ -0,0 +1,37 @@
+#include "slidertab.h"
+#include "sliderbox.h"
+#include <qlayout.h>
+
+SliderTab::SliderTab( QWidget *parent ):
+    QWidget( parent )
+{
+    int i;
+
+    QBoxLayout *hLayout = createLayout( Qt::Vertical );
+    for ( i = 0; i < 4; i++ )
+        hLayout->addWidget( new SliderBox( i ) );
+    hLayout->addStretch();
+
+    QBoxLayout *vLayout = createLayout( Qt::Horizontal );
+    for ( ; i < 7; i++ )
+        vLayout->addWidget( new SliderBox( i ) );
+
+    QBoxLayout *mainLayout = createLayout( Qt::Horizontal, this );
+    mainLayout->addLayout( vLayout );
+    mainLayout->addLayout( hLayout, 10 );
+}
+
+QBoxLayout *SliderTab::createLayout( 
+    Qt::Orientation orientation, QWidget *widget )
+{
+    QBoxLayout *layout =
+        new QBoxLayout( QBoxLayout::LeftToRight, widget );
+
+    if ( orientation == Qt::Vertical )
+        layout->setDirection( QBoxLayout::TopToBottom );
+
+    layout->setSpacing( 20 );
+    layout->setMargin( 0 );
+
+    return layout;
+}

examples/controls/slidertab.h

@@ -0,0 +1,18 @@
+#ifndef _SLIDER_TAB_H
+#define _SLIDER_TAB_H 1
+
+#include <qwidget.h>
+
+class QBoxLayout;
+
+class SliderTab: public QWidget
+{
+public:
+    SliderTab( QWidget *parent = NULL );
+
+private:
+    QBoxLayout *createLayout( Qt::Orientation,
+        QWidget *widget = NULL );
+};
+
+#endif

examples/controls/wheelbox.cpp

@@ -0,0 +1,188 @@
+#include <qlabel.h>
+#include <qlayout.h>
+#include <qwt_wheel.h>
+#include <qwt_thermo.h>
+#include <qwt_scale_engine.h>
+#include <qwt_transform.h>
+#include <qwt_color_map.h>
+#include "wheelbox.h"
+
+WheelBox::WheelBox( Qt::Orientation orientation,
+        int type, QWidget *parent ):
+    QWidget( parent )
+{
+    QWidget *box = createBox( orientation, type );
+    d_label = new QLabel( this );
+    d_label->setAlignment( Qt::AlignHCenter | Qt::AlignTop );
+
+    QBoxLayout *layout = new QVBoxLayout( this );
+    layout->addWidget( box );
+    layout->addWidget( d_label );
+
+    setNum( d_wheel->value() );
+
+    connect( d_wheel, SIGNAL( valueChanged( double ) ), 
+        this, SLOT( setNum( double ) ) );
+}
+
+QWidget *WheelBox::createBox( 
+    Qt::Orientation orientation, int type ) 
+{
+    d_wheel = new QwtWheel();
+    d_wheel->setValue( 80 );
+    d_wheel->setWheelWidth( 20 );
+    d_wheel->setMass( 1.0 );
+
+    d_thermo = new QwtThermo();
+    d_thermo->setOrientation( orientation );
+
+    if ( orientation == Qt::Horizontal )
+    {
+        d_thermo->setScalePosition( QwtThermo::LeadingScale );
+        d_wheel->setOrientation( Qt::Vertical );
+    }
+    else
+    {
+        d_thermo->setScalePosition( QwtThermo::TrailingScale );
+        d_wheel->setOrientation( Qt::Horizontal );
+    }
+
+    switch( type )
+    {
+        case 0:
+        {
+            QwtLinearColorMap *colorMap = new QwtLinearColorMap(); 
+            colorMap->setColorInterval( Qt::blue, Qt::red );
+            d_thermo->setColorMap( colorMap );
+
+            break;
+        }
+        case 1:
+        {
+            QwtLinearColorMap *colorMap = new QwtLinearColorMap();
+            colorMap->setMode( QwtLinearColorMap::FixedColors );
+
+            int idx = 4;
+
+            colorMap->setColorInterval( Qt::GlobalColor( idx ),
+                Qt::GlobalColor( idx + 10 ) );
+            for ( int i = 1; i < 10; i++ )
+            {
+                colorMap->addColorStop( i / 10.0, 
+                    Qt::GlobalColor( idx + i ) );
+            }
+
+            d_thermo->setColorMap( colorMap );
+            break;
+        }
+        case 2:
+        {
+            d_wheel->setRange( 10, 1000 );
+            d_wheel->setSingleStep( 1.0 );
+
+            d_thermo->setScaleEngine( new QwtLogScaleEngine );
+            d_thermo->setScaleMaxMinor( 10 );
+
+            d_thermo->setFillBrush( Qt::darkCyan );
+            d_thermo->setAlarmBrush( Qt::magenta );
+            d_thermo->setAlarmLevel( 500.0 );
+
+            d_wheel->setValue( 800 );
+
+            break;
+        }
+        case 3:
+        {
+            d_wheel->setRange( -1000, 1000 );
+            d_wheel->setSingleStep( 1.0 );
+            d_wheel->setPalette( QColor( "Tan" ) );
+
+            QwtLinearScaleEngine *scaleEngine = new QwtLinearScaleEngine();
+            scaleEngine->setTransformation( new QwtPowerTransform( 2 ) );
+
+            d_thermo->setScaleMaxMinor( 5 );
+            d_thermo->setScaleEngine( scaleEngine );
+
+            QPalette pal = palette();
+            pal.setColor( QPalette::Base, Qt::darkGray );
+            pal.setColor( QPalette::ButtonText, QColor( "darkKhaki" ) );
+
+            d_thermo->setPalette( pal );
+            break;
+        }
+        case 4:
+        {
+            d_wheel->setRange( -100, 300 );
+            d_wheel->setInverted( true );
+
+            QwtLinearColorMap *colorMap = new QwtLinearColorMap(); 
+            colorMap->setColorInterval( Qt::darkCyan, Qt::yellow );
+            d_thermo->setColorMap( colorMap );
+
+            d_wheel->setValue( 243 );
+
+            break;
+        }
+        case 5:
+        {
+            d_thermo->setFillBrush( Qt::darkCyan );
+            d_thermo->setAlarmBrush( Qt::magenta );
+            d_thermo->setAlarmLevel( 60.0 );
+
+            break;
+        }
+        case 6:
+        {
+            d_thermo->setOriginMode( QwtThermo::OriginMinimum );
+            d_thermo->setFillBrush( QBrush( "DarkSlateBlue" ) );
+            d_thermo->setAlarmBrush( QBrush( "DarkOrange" ) );
+            d_thermo->setAlarmLevel( 60.0 );
+
+            break;
+        }
+        case 7:
+        {
+            d_wheel->setRange( -100, 100 );
+
+            d_thermo->setOriginMode( QwtThermo::OriginCustom );
+            d_thermo->setOrigin( 0.0 );
+            d_thermo->setFillBrush( Qt::darkBlue );
+
+            break;
+        }
+    }
+
+    double min = d_wheel->minimum();
+    double max = d_wheel->maximum();
+
+    if ( d_wheel->isInverted() )
+        qSwap( min, max );
+
+    d_thermo->setScale( min, max );
+    d_thermo->setValue( d_wheel->value() );
+
+    connect( d_wheel, SIGNAL( valueChanged( double ) ), 
+        d_thermo, SLOT( setValue( double ) ) );
+
+    QWidget *box = new QWidget();
+
+    QBoxLayout *layout;
+
+    if ( orientation == Qt::Horizontal )
+        layout = new QHBoxLayout( box );
+    else
+        layout = new QVBoxLayout( box );
+
+    layout->addWidget( d_thermo, Qt::AlignCenter );
+    layout->addWidget( d_wheel );
+
+    return box;
+}
+
+void WheelBox::setNum( double v )
+{
+    QString text;
+    text.setNum( v, 'f', 2 );
+
+    d_label->setText( text );
+}

examples/controls/wheelbox.h

@@ -0,0 +1,29 @@
+#ifndef _WHEEL_BOX_H_
+#define _WHEEL_BOX_H_ 1
+
+#include <qwidget.h>
+
+class QLabel;
+class QwtThermo;
+class QwtWheel;
+
+class WheelBox: public QWidget
+{
+    Q_OBJECT
+public:
+    WheelBox( Qt::Orientation, 
+        int type, QWidget *parent = NULL );
+
+private Q_SLOTS:
+    void setNum( double v );
+
+private:
+    QWidget *createBox( Qt::Orientation, int type );
+
+private:
+    QwtWheel *d_wheel;
+    QwtThermo *d_thermo;
+    QLabel *d_label;
+};
+
+#endif

examples/controls/wheeltab.cpp

@@ -0,0 +1,28 @@
+#include "wheeltab.h"
+#include "wheelbox.h"
+#include <qlayout.h>
+
+WheelTab::WheelTab( QWidget *parent ):
+    QWidget( parent )
+{
+    const int numBoxes = 4;
+
+    QGridLayout *layout1 = new QGridLayout();
+    for ( int i = 0; i < numBoxes; i++ )
+    {
+        WheelBox *box = new WheelBox( Qt::Vertical, i );
+        layout1->addWidget( box, i / 2, i % 2 );
+    }
+
+    QGridLayout *layout2 = new QGridLayout();
+    for ( int i = 0; i < numBoxes; i++ )
+    {
+        WheelBox *box = new WheelBox( Qt::Horizontal, i + numBoxes );
+        layout2->addWidget( box, i / 2, i % 2 );
+    }
+
+    QHBoxLayout *layout = new QHBoxLayout( this );
+    layout->addLayout( layout1, 2 );
+    layout->addLayout( layout2, 5 );
+}
+

examples/controls/wheeltab.h

@@ -0,0 +1,12 @@
+#ifndef _WHEEL_TAB_H
+#define _WHEEL_TAB_H 1
+
+#include <qwidget.h>
+
+class WheelTab: public QWidget
+{
+public:
+    WheelTab( QWidget *parent = NULL );
+};
+
+#endif