[solved] adding Qt to existing program

mzimmers

Is your project developed in qt-creator? Does it use qmake as the build system or something else (e.g. cmake)?

Yes, and yes.

Where does your updating data come from? Are you calculating it or getting it from a network connection etc?

For now, let's restrict this to data that is internally calculated.

Do you have a QObject sub-class that performs the data updates (from whatever source)? If so then all we need to do is to add a signal to this class that gets emitted whenever your variable changes. something like:

No, I don't have any QObjects defined. This is currently a vanilla C++ program. Should I modify my program to create and use a QObject?

ZapB

OK then let's modify last night's exampe to do something more along the lines of what you need.

We'll start by adding in a simple class that generates some data in response to a function call. Go to File->New file or project...->C++ class. Enter a name for the class of Generator and choose QObject as the base class.

Edit the files for this class to look like this:

generator.h
@
#ifndef GENERATOR_H
#define GENERATOR_H

#include <QObject>

class Generator : public QObject
{
Q_OBJECT
public:
explicit Generator( QObject* parent = 0 );

public slots:
void calculateNextValue();

signals:
void dataChanged( double value );

private:
int m_n;
};

#endif // GENERATOR_H
@

generator.cpp
@
#include "generator.h"

Generator::Generator( QObject* parent ) :
QObject( parent ),
m_n( 0 )
{
}

void Generator::calculateNextValue()
{
++m_n;
double value = m_n * m_n;
emit dataChanged( value );
}
@

As you can see this is a very simple class. Each time a call to calculateNextValue() is made it simply increments a counter and calculates the square if it. This value is then broadcast to the world via the dataChanged() signal which is declared in the header file in the "signals:" section.

This is where you would integrate your existing calculation code.

Now to get this to play nicely with our GUI. Since we are only going to be displaying read-only data I have simply deleted the line edit from our Widget using the design mode. I have then changed the Widget header file to look like this:

@
#ifndef WIDGET_H
#define WIDGET_H

#include <QWidget>

namespace Ui {
class Widget;
}

class Generator;

class QTimer;

class Widget : public QWidget
{
Q_OBJECT

public:
explicit Widget(QWidget *parent = 0);
~Widget();

public slots:
void setValue( double value );

private:
Ui::Widget ui;
QTimer m_timer;
Generator* m_generator;
};
@

Here you can see I have replaced the old string-based function with a new slot called setValue() that accepts a double as an argument.

I have also declared as member variables, pointers to a QTimer and an object of our new Generator class.

The corresponding .cpp file now looks like this:

@
#include "widget.h"
#include "ui_widget.h"

#include "generator.h"

#include <QTimer>

Widget::Widget( QWidget* parent ) :
QWidget( parent ),
ui( new Ui::Widget ),
m_timer( new QTimer( this ) ),
m_generator( new Generator( this ) )
{
ui->setupUi( this );

// Use a couple of connections to do something useful.

// This one causes new data to be calculated once a second (once the timer is started)
connect( m_timer, SIGNAL( timeout() ), m_generator, SLOT( calculateNextValue() ) );

// This one causes the new data to update the GUI
connect( m_generator, SIGNAL( dataChanged( double ) ), this, SLOT( setValue( double ) ) );

// Start the timer off to kick things into motion
m_timer->start( 1000 );

}

Widget::~Widget()
{
delete ui;
}

void Widget::setValue( double value )
{
QString s = QString( "The current value is %1" ).arg( value );
ui->label->setText( s );
}
@

In the constructor we create a QTimer and a Generator object. Note that we pass through "this" to the constructors. This has the effect of making these object schildren of our Widget object which in turn means that we do not need to worry about deleting them explicitly since QObject (and hence our Widget) class automatically deletes its QObject-based children when it is destroyed.

Then in the constructor we use a couple of signal-slot connections to make our objects interact with each other.

First of all we want our Generator object to calculate a new value at regular intervals of 1s say. To do this we connect the "timeout()" signal of the QTimer object to the "calculateNextValue()" slot of the Generator object.

That gets our data calculated but it is not yet enough to make our GUI reflect it in the window. To do so we need a second signal. This time we connect the "dataChanged()" signal of the Generator object to the "setValue()" slot of the Widget class.

Finally in the constructor we start the timer off such that it emits signals at intervals of 1000ms (1s).

In the implementation of the Widget::setValue( double value ) function, we simply use QString::arg() to construct a suitable string for display and then tell the QLabel to show that string. Simple! ;-)

Now when you build and run the app you should see a label showing the sequence of square numbers being updated at a rate of 1 per second.

Does that help you get closer to what you wish to accomplish?

I recommend that you have a read up on signals/slots in the Qt docs and also have a look at the tutorials/examples/demos that ship with Qt.

Good luck!

andre

Hey ZapB,

Perhaps you could use the very clear descriptions you wrote above to make a very simple "Qt Ui Basics" Tutorial, or something like that?

ZapB

Yeah I will try to do that. I'll make some screenshots as I go along too. Good idea.

mzimmers

Hey, Zap -

Thanks a ton for this information. I will hopefully have a chance to play with it tomorrow, and I imagine I'll come back with some more questions.

ZapB

No problem. I just noticed that I forgot to post the modified main.cpp. It is a simple modification though, just remove the call to w.setName(). The rest is the same.

mzimmers

OK, I've made the changes you outline above, and I tried to build. I'm getting a curious error (probably not germane to this thread): "the build directory needs to be at the same level as the root directory." I did move the files, but I thought I kept the directory structures intact. Any idea what this is?

Once I get this built, I'll step through it and re-read your explanations above.

EDIT: don't sweat this; I just nuked the project files and re-generated them. I think it's OK now. Time to start watching this work.

mzimmers

OK...I have a few questions. Hopefully, the answers to these will also be of use in preparing your introductory tutorial.

I notice we had a few choices when we selected widget for our base class. What is a good working definition of a widget (for Qt purposes), and why did we choose it for this example?

I don't really understand the syntax of widget.cpp, line 30. It appears you're making a new variable called s, but what does the first pair of parens contain? Is this some kind of compound function call?

what controls the position and format of the output in the GUI window?

if I wanted to add a pause button, how would I go about that? (this question is mostly out of curiosity, so don't spend a lot of time on it.)

can you explain the return a.exec(); in main.cpp? It seems like this is where the program spends all of its time, and I think I need to know more about this if I'm going to successfully decouple my main program from its auxiliary GUI.

Thanks!

goetz

[quote author="mzimmers" date="1300743352"]# I notice we had a few choices when we selected widget for our base class. What is a good working definition of a widget (for Qt purposes), and why did we choose it for this example?
[/quote]

A widget is just a collection of GUI elements, together with its internal logic (eg. the code that increases the value if you click on the up-arrow of a spin box widget). A widget can be displayed as a single toplevel window (like in the hello world examples) or can be embedded in other widgets to construct more complex user interfaces.

Dialoges, MainWindows and the like are more specialized widgets. A dialog, for example, is intended to be shown as its own top level window, but not to be embedded into another user interface. The same holds for main windows which contain a menu bar, a tool bar and other goodies by default.

To start with a widget in an example is just for simplicity :-)

[quote author="mzimmers" date="1300743352"]# I don't really understand the syntax of widget.cpp, line 30. It appears you're making a new variable called s, but what does the first pair of parens contain? Is this some kind of compound function call?
[/quote]

You mean this on line 35:

@
QString s = QString( "The current value is %1" ).arg( value );
@

<pre>QString( "The current value is %1" )</pre> is the constructor of a new QString object. It's the call for a value of the object (= allocation on the stack), in contrast to creating an object on the heap with new xxx. Subsequently you call method arg() on that newly created object. The resulting string is eventually assigned to variable s.

[quote author="mzimmers" date="1300743352"]# what controls the position and format of the output in the GUI window?
[/quote]

The position of a new toplevel window is usually the center of the screen (or the centered over the parent window if, for example, a QDialog has a parent). The size is calculated by the layout and respects the size of the parts of the widget (sizeHint etc.)

[quote author="mzimmers" date="1300743352"]# if I wanted to add a pause button, how would I go about that? (this question is mostly out of curiosity, so don't spend a lot of time on it.)
[/quote]

You would add the button in Qt Designer (or the designer component of Qt Creator). It depends on the actual layout of your existing UI if you just drop the button on the right place or if you have to break the layout and re-layout things afterwards. Just play around, you'll get a feeling for this very soon. It lasts longer to describe it textually :-)

[quote author="mzimmers" date="1300743352"]# can you explain the return a.exec(); in main.cpp? It seems like this is where the program spends all of its time, and I think I need to know more about this if I'm going to successfully decouple my main program from its auxiliary GUI.

Thanks![/quote]

Every Qt GUI application has a so called event loop. It is responsible to receive all the events from the user (mouse moves and clicks, keyboard and all this) and to activate the appropriate actions on the application's GUI elements. exec() is just the method that starts the event loop. It only returns, when the event loops is stopped, which usually only happens when your program terminates.

ZapB