Tutorial Qt – Capitulo 10 – QWT

QWT é a abreviação de Qt Widgets for Technical Applications. É uma coleção de widgets e classes de suporte para a criação de aplicações técnicas como aquelas criadas usando, por exemplo, LabView e TestPoint. Esse capitulo cobre a instalação da biblioteca e uma breve visão de vários dos widgets fornecidos. Para os leitores interessados mais detalhes podem ser encontrados na documentação oficial. O Qwt versão 0.4.1 é usado ao longo desse capitulo, mas os conceitos gerais aplicam-se às demias versões.

Instalação

Em primeiro lugar, esse tutorial cobre a instalação da biblioteca em plataforma Unix. O site da biblioteca possui mais informações referentes a instalação emk outras plataformas. A instalação usa qmake/tmake e deve ser altamente portável.

Primeiro, vá até a página do QWT usando seu navegador, ou simplesmente baixe a código fonte diretamente da página do projeto do SourceForge. Descompacte-o. De agora em diante, o diretório que contém a QWT será referenciado como $(QWT). Para configurar o ambiente para ele, entre no diretório e digite “export QWT=pwd”>

O que as instruções de instalação diz para executar “qmake qet.pro -o Makefile” e depois executar make. Isso compilará a biblioteca. Agora, como um usuário Unix, crie os links simbólicos em um lugar do LD_LIBRARY_PATH (como /usr/lib) para os arquivos do diretório $(QWT)/lib, ou modifique LD_LIBRARY_PATH para incluir esse diretório.

Isso significa que a biblioteca está instalada, e agora, tudo que você tem que fazer para usá-la é incluir o diretório $(QWT)/include no INCLUDEPATH de seus arquivos de projeto e usar o -lqwt.

Plotagem básica

Nessa seção os detalhes de exibir uma plotagem básica serão mostrados. O exemplo abaixo consiste de um widget personalizado herdade da classe QWidget. A classe QwtPlot embute muitas dos recursos de plotagem da biblioteca Qwt. O código da classe derivada, MyPlot, é mostrado abaixo:

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();
}
};

A classe simplesmente inicializa o plot no construtor. Os comentários do código mostra onde cada ação é executada, mas os detalhes são explicados nos próximos parágrafos.

A primeira coisa que acontede é que o titulo é ajustado e uma legenda é gerada automaticamente. A legenda será colocada na parte de baixo do widget, isto é, abaixo da plotagem. Todas as curvas adicionadas a plotagem quando a legenda é ligada serão adicionadas a plotagem.

Depois, os eixos ganham titulos. Como pode ser visto da documentação de setAxisTitle os titulos são colocados a esquerda e na parte de baixo. Finalmente, duas IDs de curvas são recuperadas antes dos dados de teste serem gerados. O dado é irrelevante para o exemplo mas é composto de duas curvas. Os dados para essas curvas são então copiadas para a plotagem pela chamada a setCurveData.

A última tarefa executada antes da replotagem forçada é definir o estilo da caneta a ser usado para cada curva.

Para poder exibir a plotagem, uma instância do widget tem que ser criada. Isso é feito através do main mostrado  abaixo:

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

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

return a.exec();
}

Plotagem avançada

O widget QwtPlot é idela para a maioria das necessidades de plotagem. Ela é baseada todavia em uma faixa inteira de classes Qwt que fornecem controle direto sobre a plotagem. Essa seção irá introduzir alguma dessas classes, mas o leitor interessado deve dar uma olhada na documentação oficial para mais detalhes.

A classe QwtCurve é usada para manipular instâncias de curvas. Essa classe oferece controle sobre a  aparência,  métodos de interpolação e outros. Para representações eficientes de dados, por exemplo, filtragem baseado em requisição pode ser implementada como uma sub-classe QwtData. Essas duas classes combinadas fornecem controle total dos dados mostrados.

Ao invés de disponibilizar um widget, QwtCurve possui um método de desenho. Chamando esse método a partir de um widget personalizado, qualquer widget de plotagem pode ser criado. Isso torna possivel usar a classe para impressão. O QwtDiMaps usado na chamada mapeia um intervalo de valores reais em um intervalo inteiro. Pode manipular tantos mapeamentos lineares e logaritmos.

Para completar qualquer widget de plotagem, um grid de algum tipo é necessário. Isso é manipulado pela classe QwtGrid. Essa classe funciona como a classe QwtCurve e oferece um método de desenho para ser usado numa rotina de desenho.

Widgets

O Qwt oferece vários widgets. Nessa seção, três deles, um knob, um slider e um wheel serão demonstrados. A figura abaixo mostra o que a aplicação exemplo irá exibir.

 

Esses widgets fornecem signals e slots que podem ser esperados por qualquer widget Qt e podem assim ser inter-conectados para mostrar o mesmo valor em todas as vezes. O exemplo abaixo mostra a classe exemplo que guarda os widgets. Observe que é derivada de um QHBox, que automaticamente arranja seus widgets filhos.

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)) );
}
};

Esse código não deve ser nenhuma surpresa. Observe que a orientação padrão da wheel e slider é horizontal e a o slider não exibe nenhuma escala a menos que uma posição seja especificada. Isso pode ser feito  também usando o construtor como no exemplo de código aqui ou pelo método setScalePos.

Para exibir o widget é preciso o main abaixo:

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

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

return a.exec();
}

O qmake é usado para compilar o exemplo. O exemplo abaixo mostra o resultado da execução de “qmake -project” no diretório de nosso exemplo (o diretório é chamado wid e o arquivo de código fonte wid.cpp).

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

TEMPLATE = app
CONFIG -= moc
INCLUDEPATH += .

# Input
SOURCES += wid.cpp

O exemplo abaixo mostra o arquivo de projeto modificado que torna possivel usar o Qwt. Observe que é necessário que a variável de ambiente QWT esteja configurada como descrito no início desse capitulo.

######################################################################
# 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

Para compilar o exemplo, simplesmente digite no terminal “qmake && make && ./wid”.

Sumário

Não existe código exemplo disponível para esse capitulo.

Traduzido de  http://www.digitalfanatics.org/projects/qt_tutorial/chapter11.html