1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
|
---
category: tool
tool: Qt Framework
language: C++
filename: learnqt-pt.cpp
contributors:
- ["Aleksey Kholovchuk", "https://github.com/vortexxx192"]
translators:
- ["Lucas Pugliesi", "https://github.com/fplucas"]
lang: pt-br
---
**Qt** é amplamente conhecido como um framework para desenvolvimento de
software multi-plataforma que pode rodar em vários outras plataformas de
softwares e hardwares com pouca ou nenhuma alteração no código, enquanto mantém
o poder e a velocidade de uma aplicação nativa. Embora o **Qt** tenha sido
originalmente escrito em *C++*, é possível utilizá-lo em outras linguagens:
*[PyQt](https://learnxinyminutes.com/docs/pyqt/)*, *QtRuby*, *PHP-Qt*, etc.
**Qt** é ótimo para criar aplicações com interface gráfica (GUI). Esse tutorial
será feito em *C++*.
```c++
/*
* Vamos começar
*/
// Todos as dependências do framework Qt iniciam com a letra 'Q' maiúscula
#include <QApplication>
#include <QLineEdit>
int main(int argc, char *argv[]) {
// Cria um objeto para utilizar todos os recursos da aplicação
QApplication app(argc, argv);
// Cria um widget com linha editável e exibe na tela
QLineEdit lineEdit("Hello world!");
lineEdit.show();
// Inicia a aplicação em um evento de loop
return app.exec();
}
```
A parte gráfica do **Qt** é toda composta de *widgets* e *conexões* entre eles.
[LEIA MAIS SOBRE WIDGETS](http://doc.qt.io/qt-5/qtwidgets-index.html)
```c++
/*
* Vamos criar um label e um botão.
* Um label irá aparecer quando o botão for clicado
*
* O próprio código do Qt é autoexplicativo.
*/
#include <QApplication>
#include <QDialog>
#include <QVBoxLayout>
#include <QPushButton>
#include <QLabel>
int main(int argc, char *argv[]) {
QApplication app(argc, argv);
QDialog dialogWindow;
dialogWindow.show();
// Adiciona um layout vertical
QVBoxLayout layout;
dialogWindow.setLayout(&layout);
QLabel textLabel("Thanks for pressing that button");
layout.addWidget(&textLabel);
textLabel.hide();
QPushButton button("Press me");
layout.addWidget(&button);
// Exibe o label oculto quando o botão é clicado
QObject::connect(&button, &QPushButton::pressed,
&textLabel, &QLabel::show);
return app.exec();
}
```
Veja o *QObject::connect*. O método é usado para conectar o *SINAL* de um objeto
ao *ENCAIXE* outro.
**Sinais** são emitidos quando algo ocorre com o objeto, como quando o sinal de
*clique* é acionado apertando o QPushButton.
**Encaixes** são *ações* que são executadas em resposta aos sinais recebidos.
[LEIA MAIS SOBRE SINAIS E ENCAIXES](http://doc.qt.io/qt-5/signalsandslots.html)
A seguir vamos aprender como usar não somente o comportamento padrão dos
widgets, mas também extender seus comportamentos usando herança. Vamos criar um
botão e contar quantas vezes é pressionado. Para esse propósito definiremos
nossa própria classe *CounterLabel*. Ela deve ser declarada em um arquivo
diferente devido a estrutura específica do Qt.
```c++
// counterlabel.hpp
#ifndef COUNTERLABEL
#define COUNTERLABEL
#include <QLabel>
class CounterLabel : public QLabel {
Q_OBJECT // Define os macros presente em todo objeto Qt
public:
CounterLabel() : counter(0) {
setText("Counter has not been increased yet"); // método do QLabel
}
public slots:
// Ação que será chamada em resposta ao clique do botão
void increaseCounter() {
setText(QString("Counter value: %1").arg(QString::number(++counter)));
}
private:
int counter;
};
#endif // COUNTERLABEL
```
```c++
// main.cpp
// Quase igual ao exemplo anterior
#include <QApplication>
#include <QDialog>
#include <QVBoxLayout>
#include <QPushButton>
#include <QString>
#include "counterlabel.hpp"
int main(int argc, char *argv[]) {
QApplication app(argc, argv);
QDialog dialogWindow;
dialogWindow.show();
QVBoxLayout layout;
dialogWindow.setLayout(&layout);
CounterLabel counterLabel;
layout.addWidget(&counterLabel);
QPushButton button("Push me once more");
layout.addWidget(&button);
QObject::connect(&button, &QPushButton::pressed,
&counterLabel, &CounterLabel::increaseCounter);
return app.exec();
}
```
É isso! Claro, o framework Qt é muito maior do que exemplificamos no tutorial,
então esteja preparado para ler e praticar mais.
## Leitura complementar
- [Tutoriais Qt 4.8](http://doc.qt.io/qt-4.8/tutorials.html)
- [Tutoriais Qt 5](http://doc.qt.io/qt-5/qtexamplesandtutorials.html)
Boa sorte e divirta-se!
|
