How to check how long a button is pressed? - c++

Question

I'm looking for a way to check how long a button is pressed! My idea was starting a counter which starts when pressed() is emitted and stops when released() is emitted. But I currently don't know how to wait for the released- or similar events. Normally I would connect() a signal with a slot but in this case both are slots. Maybe you've got a better idea maybe this one is good enough.

Answer 1

When pressed. Start a timer. When released check for how long the timer has been running (and stop it). Save the elapsed time in a variable in the class.
That's one way to do it at least.

Answer 2

When the pressed signal is sent, start the timer. When the relesed signal is sent, read how much time has elapsed on the timer.
This is a complete example using Qt 5 and a C++ compiler that's not prehistoric:
// https://github.com/KubaO/stackoverflown/tree/master/questions/button-timer-38645219
#include <QtWidgets>
int main(int argc, char ** argv) {
QApplication app{argc, argv};
QWidget w;
QFormLayout layout{&w};
QPushButton button{"Press Me"};
QLabel label;
layout.addRow(&button);
layout.addRow(&label);
QElapsedTimer timer;
QObject::connect(&button, &QPushButton::pressed, [&]{ timer.start(); });
QObject::connect(&button, &QPushButton::released, [&]{
label.setText(QStringLiteral("Pressed for %1 ms").arg(timer.elapsed()));
});
w.show();
return app.exec();
}
Of course you can shove all the variables into a class. You'll notice that C++11 makes this transformation almost a no-brainer: it's by design, not by coincidence.
#include <QtWidgets>
class Widget : public QWidget {
QFormLayout layout{this};
QPushButton button{"Press Me"};
QLabel label;
QElapsedTimer timer;
public:
Widget() {
layout.addRow(&button);
layout.addRow(&label);
connect(&button, &QPushButton::pressed, [&]{ timer.start(); });
connect(&button, &QPushButton::released, [&]{
label.setText(QStringLiteral("Pressed for %1 ms").arg(timer.elapsed()));
});
}
};
int main(int argc, char ** argv) {
QApplication app{argc, argv};
Widget w;
w.show();
return app.exec();
}
It is generally frowned upon to have "business logic" in UI objects, so we can separate out the functionality into that of a Timer, a Widget, and of a Controller. The code external to all of these objects sets up the requisite connections.
#include <QtWidgets>
class Timer : public QObject {
Q_OBJECT
QElapsedTimer timer;
public:
Q_SLOT void start() { timer.start(); }
Q_SLOT void stop() { emit elapsed(timer.elapsed()); }
Q_SIGNAL void elapsed(qint64);
};
class Widget : public QWidget {
Q_OBJECT
QFormLayout layout{this};
QPushButton button{"Press Me"};
QLabel label;
public:
Widget() {
layout.addRow(&button);
layout.addRow(&label);
connect(&button, &QPushButton::pressed, this, &Widget::pressed);
connect(&button, &QPushButton::released, this, &Widget::released);
}
Q_SIGNAL void pressed();
Q_SIGNAL void released();
Q_SLOT void setText(const QString & text) { label.setText(text); }
};
class Controller : public QObject {
Q_OBJECT
public:
Q_SLOT void elapsed(qint64 ms) {
emit hasText(QStringLiteral("Pressed for %1 ms").arg(ms));
}
Q_SIGNAL void hasText(const QString &);
};
int main(int argc, char ** argv) {
QApplication app{argc, argv};
Timer t;
Widget w;
Controller c;
w.show();
//
QObject::connect(&w, &Widget::pressed, &t, &Timer::start);
QObject::connect(&w, &Widget::released, &t, &Timer::stop);
QObject::connect(&t, &Timer::elapsed, &c, &Controller::elapsed);
QObject::connect(&c, &Controller::hasText, &w, &Widget::setText);
return app.exec();
}
#include "main.moc"
Of course you can scream that the controller, even if not really coupled to the other code, is still somewhat dependent on the design of the rest of the code. Thankfully, it doesn't have to be so: lambdas make simple adaptations simple.
We can use a "foreign" controller, provided by our big business vendor, too:
// use Timer and Widget from preceding example
#include <sstream>
#include <string>
#include <functional>
class Controller {
public:
using callback_t = std::function<void(const std::string&)>;
Controller(callback_t && callback) : callback{std::move(callback)} {}
void onElapsed(int ms) {
std::stringstream s;
s << "Pressed for " << ms << " ms";
callback(s.str());
}
private:
callback_t callback;
};
int main(int argc, char ** argv) {
QApplication app{argc, argv};
Timer t;
Widget w;
Controller c{ [&](const std::string & s){ w.setText(QString::fromStdString(s)); } };
QObject::connect(&w, &Widget::pressed, &t, &Timer::start);
QObject::connect(&w, &Widget::released, &t, &Timer::stop);
QObject::connect(&t, &Timer::elapsed, [&](qint64 ms) { c.onElapsed(ms); });
w.show();
return app.exec();
}
#include "main.moc"
All of the examples above are compileable: put any one of them into main.cpp, rebuild the project, and go.
When you're posting test cases for questions, you should go backwards: you start somewhere towards the end of this answer, and work your way towards the beginning, minimal setup. It'll help you understand your own code better, too, since the verbosity is minimized. It's telling, I hope, that both the first and the last version have same functionality.