Skip to content

herzenschein/materiais-de-aprendizado-qt

BranchesTags

Folders and files

NameName
Last commit message
Last commit date

Latest commit

 

History

61 Commits
LICENSE
LICENSE
 
 
README.md
README.md
 
 
_config.yaml
_config.yaml
 
 

Repository files navigation

Materiais de aprendizado para estudar Qt

Este repositório contém materiais para estudar Qt em português e inglês.

Índice

O que é o Qt? Como posso usar o Qt?

Clique aqui para ler

O Qt (pronunciado /kjuːt/, como a palavra cute do inglês) é um framework utilizado para criar aplicativos modernos para desktop, dispositivos móveis e embarcados. Ele é feito em C++ e permite escrever um mesmo código para múltiplas plataformas, como Linux, Windows, Mac e Android, dentre outros.

O Qt extende o C++ e torna ele mais agradável para criar suas aplicações gráficas, e fornece também uma linguagem própria declarativa altamente produtiva, o QML. Ele inclui vários módulos, dentre eles o QtCore, o QtWidgets, o QtQuick, e outros.

Ele possui duas licenças principais: uma LGPL e uma comercial. Os módulos do Qt licenciados como LGPL são de código aberto e permitem que você crie tanto aplicativos de código aberto quanto aplicativos proprietários, de código fechado, gratuitamente, contanto se siga as condições da licença LGPL. Os módulos do Qt licenciados como comerciais fornecem funcionalidade extra e mais facilidades para desenvolvimento e integração em empresas, e o uso desta licença fornece suporte técnico, além de outros serviços. Há alguns poucos módulos que utilizam-se de outras licenças. Por exemplo, módulos que utilizam licença GPL obrigam seu aplicativo a ser de código aberto, embora seja perfeitamente possível lucrar em cima disso, contanto siga-se a licença. Módulos que utilizam licença MIT permitem um uso mais flexível para aplicativos proprietários. Leia mais sobre isso aqui. É possível ver quais módulos seguem quais licenças na página de funcionalidades do Qt.

Qual a diferença entre QtCore, QtWidgets, QtQuick e QML?

Clique aqui para ler

QtCore é um subconjunto de componentes do Qt especializado em aplicações sem interface gráfica (GUI). Ele é usado com C++ (e não QML), mas há language bindings para uso com outras linguagens, como Python. Vários dos seus componentes também estão disponíveis em módulos do QtWidgets e do QtQuick. Sua página inicial da documentação é esta: https://doc.qt.io/qt-6/qtcore-index.html e esta é a sua lista de classes C++: https://doc.qt.io/qt-6/qtcore-module.html. Dentre estas classes, as mais básicas são: QCoreApplication, QDebug, QString, QFile, QList e QVariant.

QtWidgets é um subconjunto de componentes do Qt especializado em aplicações com interface gráfica que oferece integração extra para aplicativos desktop. Ele é usado com C++ (e não QML), mas há language bindings para uso com outras linguagens. Seus componentes principais vem prontos para integrar ao seu sistema opracional. Sua página inicial da documentação é esta: https://doc.qt.io/qt-6/qtwidgets-index.html e esta é a sua lista de classes C++: https://doc.qt.io/qt-6/qtwidgets-module.html. Dentre estas classes, as mais básicas são: QApplication, QWidget, QMainWindow, QDialog, QLabel, QPushButton, QRadioButton, QComboBox, QCheckBox, QLineEdit, QTextEdit, QLayout e QMenu.

QtQuick é um subconjunto de componentes do Qt especializado em aplicações com interface gráfica que oferece integração extra para aplicativos móveis, além da integração para aplicativos desktop. Ele é usado com QML e opcionalmente C++, mas há language bindings para uso com outras linguagens. Sua página inicial da documentação é esta: https://doc.qt.io/qt-6/qtquick-index.html e esta é a sua lista de classes C++: https://doc.qt.io/qt-6/qtquick-module.html e sua lista de tipos QML: https://doc.qt.io/qt-6/qtquick-qmlmodule.html. As classes C++ possibilitam integrar interfaces QML em programas QtWidgets, enquanto os tipos QML são usados para construir interfaces QML. As duas classes C++ básicas são QQuickWindow e QQuickView, enquanto seus tipos QML básicos são Item, Window, Rectangle, Text, Row, Column, Grid, Flow, ListView, Animation, Repeater e Loader.

QML é uma linguagem declarativa similar ao JSON usada principalmente para criar interfaces gráficas. É possível tanto escrever um programa puramente em QML quanto um programa que misture C++ e QML. Para os que estão familiarizados com a terminologia, a linguagem tem embutido o observer pattern e o composite pattern, e permite utilizar o model-view-controller pattern, state pattern, dentre outros padrões de design de programação, além de implementar um scene graph, o que torna a linguagem versátil e altamente produtiva, isto é, permite produzir mais com menos código.

Existem outros componentes do Qt que interessam para quem pretende programar com o QtQuick: o QtQuick Layouts para criar layouts dinâmicos e o QtQuick Controls para obter controles mais elaborados para sua interface gráfica.

Outros componentes interessantes do Qt são o QtGUI, que fornece alguns componentes de interface essenciais como QGuiApplication, QAction e QColor; o QtQuick3D, que permite trabalhar com modelos 3D usando QML; o QtWebEngine, que permite trabalhar com páginas da web diretamente, seja com C++ ou QML; e o Qt for MCUs, que foca em aplicativos com interface gráfica em embarcados.

Que linguagens posso usar para desenvolver em Qt?

Clique aqui para ler

A linguagem principal usada para desenvolver em Qt é o C++. O framework em si é feito em C++, assim como a IDE principal do Qt, o QtCreator. Caso queira aprender C++, dê uma olhada no material de aprendizado do cppbrasil.

Também é possível criar programas em Qt usando a linguagem QML. O QML é uma linguagem declarativa similar ao JSON que pode tanto se integrar a código feito em C++ quanto rodar sozinho utilizando expressões JavaScript para a lógica principal. Apesar de utilizar um engine JavaScript em tempo de execução, ele é bastante eficiente e pode ser transpilado para C++ via compilação just-in-time desde o Qt 5.11 (ou ahead-of-time a partir do Qt 6.3), fazendo uso da eficiência e velocidade do C++.

A The Qt Company também oficialmente suporta o Python por meio do PySide2 (de Qt5) / PySide6 (de Qt6), ou Qt For Python. Alternativamente, há o PyQt5 e PyQt6, ambos mantidos pela Riverbank Computers. Este último, no entanto, não recebe suporte da The Qt Company.

Há também outros language bindings para o Qt. Notavelmente, o Rust tem ganhado popularidade recentemente, e para ele estão disponíveis o Rust-Qt/Ritual, que fornece bindings Rust -> C++; o QMetaObject-rs, que fornece bindings Rust -> QML; o Rust-Qt-Binding-Generator, desenvolvido pela KDE, que permite criar código feito em Rust que é utilizável em código Qt/QML.

Há também o QtJambi para Java, o Qt for Go, para Golang, e o NodeGui, para NodeJS.

Onde/como posso ler a documentação da API do Qt?

Clique aqui para ler

A documentação do Qt reside em https://doc.qt.io/. É recomendável que você utilize a documentação mais atual, do Qt6, porém a documentação do Qt5 pode ser útil especialmente quando se trata do processo de compilação e gerenciamento de recursos, que foi bastante simplificado com a vinda do Qt6 e a transição do QMake pro CMake.

Há também a wiki do Qt, que pode ser particularmente útil para os recursos mais utilizados. Atente para não acabar visualizando uma página deprecada ou conteúdo que não foi atualizado, que pode comumente ocorrer ao utilizar a pesquisa de um motor de busca como o DuckDuckGo ou o Google.

Caso esteja utilizando o instalador oficial da The Qt Company para instalar o Qt e a sua IDE principal, o QtCreator, você terá toda a documentação disponível no QtCreator offline e por padrão. No lado esquerdo do QtCreator, há uma aba chamada Help que permite acessar toda a documentação. Já no editor, é possível apertar F1 para ativar um painel lateral exibindo a documentação referente ao termo em que o cursor está parado, e apertar F1 novamente irá abrir a página da documentação visualizada, porém na aba Help, usando mais espaço.

Em sistemas Linux, ao instalar o Qt/QtCreator pelo repositório, a documentação do Qt costuma ser encontrada em /usr/share/docs. Caso não esteja presente após a instalação, geralmente é possível instalar pacotes específicos nos repositórios que contenham os pacotes de documentação, assim como os de exemplos e tutoriais. Os pacotes costumam ter a extensão -doc e a documentação vem como arquivos QCH (formato específico do Qt) ou arquivos HTML. Uma vez presentes no seu sistema, é possível abrir os arquivos diretamente ou ver a documentação no QtCreator.

Caso você utilize o KDevelop, é possível configurar a IDE para que use a documentação instalada em /usr/share/docs de maneira similar ao QtCreator.

Quanto à documentação do Qt em si, você verá que ela é extensa e bastante clara, porém pode ser bastante técnica. Há três tipos de documentação: visão geral, exemplos, e referência de classe C++/tipo QML. Caso esteja começando, veja primeiro as principais páginas de visão geral, que costumam ter explicações detalhadas e exemplos simples, como Layout Management, o QML Object Attributes ou o Getting Started with CMake, por exemplo. Após ler as páginas mais importantes de visão geral da documentação, você pode tentar colocar a mão na massa e replicar os exemplos. Caso esteja difícil, tente ver um canal ou curso introdutório de Qt, ou seguir a Rota de Aprendizado a seguir.

Uma vez que você passar para materiais de referência, como descrições de classes como o QList ou tipos como o ColorAnimation, lembre-se: para verificar tudo de que uma classe é realmente capaz, clique em "List of all members, including inherited members". Assim é possível ver as propriedades e funções das classes pai, que também podem ser usadas pela classe/tipo sendo visualizada. O ColorAnimation é um bom exemplo disso.

Se você for iniciante e estiver tendo dificuldade com o QtWidgets em particular e sentir como se estivesse faltando alguma informação que parece óbvia mas você não está captando, talvez esteja faltando o conhecimento necessário de C++. Neste caso, você pode acessar o material de aprendizado do cppbrasil ou focar no QtCore, que é essencialmente um C++ mais agradável de aprender.

Rota de aprendizado para iniciantes

Clique aqui para ler

Não há muito por aqui ainda. Contribua mandando um pull request! :)

Esta seção irá conter uma referência a conceitos, classes/tipos e links para as referências necessárias em uma sequência razoável para que um iniciante em Qt possa adquirir o conhecimento para criar suas próprias aplicações com alguma independência.

Por enquanto, fique claro: o melhor material para QtQuick/QML atualmente é o qmlbook.

Segue um rascunho dos componentes numa ordem razoável. Falta polir melhor a lista, achar mais overviews e explicar detalhes importantes de cada.

QtCore

QCoreApplication

Importância: Alta

Para iniciantes: Aprender como utilizar o construtor e a função exec() é todo o necessário para continuar estudando (isso é válido para o QCoreApplication, QGuiApplication e QApplication). Adicionalmente, aprender as funções usadas para fornecer informações sobre o aplicativo.

Quando retornar: Após aprender sobre signals e slots, verificar as funções quit() e aboutToQuit().

Essencial: Sim

qDebug, qInfo, qWarning, qCritical, qFatal

Importância: Alta, Média, Média, Média, Alta

Para iniciantes: Aprender como printar dados na tela. Adicionalmente, aprender os níveis de logging e quando usá-los.

Quando retornar:

Essencial: Sim

QString, QChar, QByteArray

Importância: Alta, Média, Alta

Para iniciantes: Focar nas funções de manipulação de strings e de casting.

Quando retornar: Ao estudar QTextStream, assim como quaisquer classes QtWidgets que focam em texto, como QLineEdit e QTextEdit.

Essencial: Sim

QStringView, QByteArrayView

Importância: Baixa, Baixa

Para iniciantes: Use sempre que não for modificar uma string.

Quando retornar: Quando estiver confiante em lidar com programas em C++ ou Qt e quiser adicionar uma camada a mais de segurança.

Essencial: Não

QTime, QTimeZone, QDate, QDateTime, QCalendar

Importância: Média, Média, Média, Média, Média

Para iniciantes:

Quando retornar: Após aprender sobre timers.

Essencial: Não

QRandomGenerator

Importância: Média

Para iniciantes: Focar nas funções generate() e bounded().

Quando retornar:

Essencial: Não

QPoint, QLine, QRect, QSize

Importância: Média, Média, Média, Alta

Para iniciantes: O QSize é comumente utilizado como argumento em funções de outras classes do Qt.

Quando retornar: Ao começar a lidar com gráficos e multimídia.

Essencial: Não

Object Trees and Ownership - https://doc.qt.io/qt-6/objecttrees.html

Importância: Alta

Para iniciantes: Focar no conceito principal de gerenciamento de memória: se o objeto pai é destruído, seus objetos filhos também são destruídos.

Quando retornar: Sempre que for lidar com QObjects direta ou indiretamente.

Essencial: Sim

Signals and Slots - https://doc.qt.io/qt-6/signalsandslots.html

Importância: Alta

Para iniciantes: Focar em: como criar signals e slots, sintaxe do QObject::connect, quando usar this.

Quando retornar: Ao começar a estudar QtWidgets ou QtQuick.

Essencial: Sim

QFile, QDir, QUrl, QIODevice, QSettings, QSysInfo, QStandardPaths

Importância: Alta, Alta, Alta, Média, Alta, Baixa, Alta

Para iniciantes: Focar nas funções de abrir e fechar arquivos com QFile, no enum do QIODevice, em como lidar com arquivos ini com QSettings, em como editar arquivos de configuração do usuário via QStandardPaths (por exemplo, arquivos em XDG_CONFIG_DIR no Linux).

Quando retornar: Quando for lidar com documentos como JSON/XML, quando for lidar com QActions, assim como com diálogos do QtWidgets e QtQuick.

Essencial: Sim

Qt Namespace - https://doc.qt.io/qt-6/qt.html

Importância: Alta

Para iniciantes: Foque nos enums disponíveis para o Qt e veja as classes pertinentes que os usam.

Quando retornar:

Essencial: Não

QFlags - https://doc.qt.io/qt-6/qflags.html

Importância: Baixa

Para iniciantes: Os QFlags são úteis para criar seus próprios enums de maneira segura para uso em classes ou funções.

Quando retornar:

Essencial: Não

Container Classes - https://doc.qt.io/qt-6/containers.html

Importância: Alta

Para iniciantes: Se você tiver experiência com classes de container e iteradores da biblioteca padrão, não será difícil acompanhar.

Quando retornar:

Essencial: Sim

QList, QVector

Importância: Alta, Baixa

Para iniciantes: Foque no QList do Qt6 e nas suas diferenças com os containers da biblioteca padrão. O QVector foi deprecado pelo QList. Passe um bom tempo se acostumando com o QList.

Quando retornar: Quando for estudar qualquer descendente do QList.

Essencial: Sim

QMap, QSet

Importância: Alta, Média

Para iniciantes: Se você tiver experiência com std::map e std::set, não será difícil acompanhar. O QMap será usado extensivamente no futuro, e o QSet fornece algumas funções de conveniência para criar containers facilmente.

Quando retornar: Quando for estudar o QVariant e o QVariantMap, que pode ser usado com QJSon e QXmlStream.

Essencial: Sim

QVariant, QIterator

Importância: Alta, Média

Para iniciantes: Se você tiver experiência com std::variant, não será difícil acompanhar. Passe bastante tempo estudando o QVariant, pois ele é necessário para a integração entre código C++ e QML no QtQuick, além de fornecer classes derivadas muito úteis como QVariantList e QVariantMap.

Quando retornar: Ao começar a estudar QtQuick.

Essencial: Sim

QStringList, QByteArrayList

Importância: Média, Média

Para iniciantes: Se você tiver praticado lidar com o QList, não será difícil acompanhar. Foque nas diferenças de uso do QString e do QByteArray comparado às suas versões QList, assim como ao QList<QString> e QList<QByteArray>.

Quando retornar:

Essencial: Não

QTextStream

Importância: Baixa

Para iniciantes: Esta classe é particularmente útil para implementar o equivalente a std::cout e std::cin, e age de maneira similar. Se você tiver praticado lidar com QString, QByteArray e QIODevice, não será difícil acompanhar.

Essencial: Não

QVariantList, QVariantMap

Importância: Alta, Alta

Para iniciantes: Se você tiver praticado lidar com QVariant, não será difícil acompanhar. Passe bastante tempo estudando estas classes, pois elas são usadas bem comumente em programas grandes ou com estruturas de dados complexas, e são necessários para a integração entre código C++ e QML no QtQuick, além de serem úteis com QJSon e QXmlStream.

Quando retornar: Ao começar a estudar QtQuick, ou ao lidar com QJSon e QXmlStream.

Essencial: Sim

QCommandLineParser, QCommandLineOption

Importância: Baixa, Média

Para iniciantes: Excetuando o addPositionalArgument() de QCommandLineParser, o construtor e as demais funções são simples. Foque mais no QCommandLineOption e seus construtores. É necessário ter bom entendimento do int argc (contagem de argumentos) e do char* argv[] (vetor/lista de argumentos) e seu papel ao rodar o programa em linha de comando.

Quando retornar:

Essencial: Não

QJsonObject, QJsonDocument

Importância: Média, Média

Para iniciantes: Se você tiver praticado lidar com QFile/QIODevice/QStandardPaths, não será difícil acompanhar.

Quando retornar:

Essencial: Não

QXmlStreamReader, QXmlStreamWriter

Importância: Média, Média

Para iniciantes: É necessário entendimento do Document Object Model (DOM), além de QFile e QByteArray, e boa prática com iteradores.

Quando retornar:

Essencial: Não

QEvent

Importância: Alta

Para iniciantes: De início, basta focar nas opções disponíveis de seu enum. Mais tarde, ao estudar QtWidgets, convém voltar a esta classe para ver suas classes derivadas, uma vez que são necessárias para manipular eventos de interface ou dispositivos de entrada (mouse, teclado).

Quando retornar: Ao lidar com os signals e slots de QtWidgets.

Essencial: Sim

Timers, QTimer - https://doc.qt.io/qt-6/timers.html

Importância: Média, Média

Para iniciantes: Excetuando callOnTimeout(), não será difícil acompanhar. Mesmo que para os seus objetivos o QTimer não seja tão útil, a classe permite facilmente testar outras classes conforme são aprendidas.

Quando retornar: Quando você começar a fazer conexões entre eventos mais complexas com QtWidgets.

Essencial: Não

QtWidgets

QApplication
QWidget, QDialog
QLabel, QLineEdit, QTextEdit, QTextBrowser
QPushButton, QRadioButton, QCheckBox, QComboBox, QSpinBox, QSlider
QDial, QProgressBar
QScrollArea
Layout Management - https://doc.qt.io/qt-6/layout.html
QHBoxLayout, QVBoxLayout, QGridLayout, QFormLayout
QAction
QMainWindow, QMenu, QMenuBar
QToolBar, QTabWidget
QColor, QFont, QIcon, QImage, QStyle
Model/View Programming - https://doc.qt.io/qt-6/model-view-programming.html
Model/View Tutorial - https://doc.qt.io/qt-6/modelview.html
QListView
QColumnView, QTableView, QTreeView
QAbstractItemModel, QModelIndex
QKeyEvent, QShortcut, QValidator
Accessibility for QWidget Applications - https://doc.qt.io/qt-6/accessible-qwidget.html
Internationalization with Qt - https://doc.qt.io/qt-6/internationalization.html

Canais para seguir

Introduções ao Qt

Em Português:

Em Inglês:

Cursos completos de Qt

Em Português:

Em Inglês:

Livros para aprender Qt

Em Português:

Em Inglês:

Tutoriais de Qt oficiais da The Qt Company em Inglês

O seguinte conteúdo e mais é disponibilizado pela The Qt Company por meio do Learning Hub, e é possível encontrar este material no QtCreator.

Talks de Qt oficiais da The Qt Company em Inglês (material opcional)

Clique aqui para ver o material opcional

QtCore

Em Português:

Em Inglês:

Detalhes adicionais:

  • O QtCore serve como excelente porta de entrada para quem sabe bem pouco de C++. Na prática se vê uma API bastante similar à da biblioteca padrão do C++, porém mais legível e fácil de usar.

QtWidgets

Em Português:

Em Inglês:

Detalhes adicionais:

  • O QtWidgets vem com widgets praticamente prontos para o desktop. Por padrão integra com o sistema e o tema com quase nenhum esforço.
  • Não é apropriado para mobile.
  • A nova API do CMake pro Qt6 qt_standard_project_setup tira a necessidade definir manualmente certas configurações do CMake, como AUTOMOC, AUTORCC e AUTOUIC, reduzindo significativamente o tamanho dos arquivos CMake.

QtQuick

Em Português:

Em Inglês:

Detalhes adicionais:

  • O QtQuick vem com widgets mais crus por padrão, requer definir propriedades para integrar ao sistema.
  • É a tecnologia recomendada caso for fazer aplicativos mobile.
  • A partir do Qt 5.15 e do Qt 6.0 pra frente, é possível fazer imports sem versionamento.
  • Caso queira verificar as versões das bibliotecas QML que você tem no seu sistema Linux, dentro das pastas /usr/lib64/qt5/qml e /usr/lib64/qt6/qml há arquivos chamados plugins.qmltypes para cada biblioteca. Neles, a versão mínima de cada módulo pode ser vista em linhas contendo a palavra "exports".
  • Lembre-se: filhos de um Layout devem usar attached properties, não anchors.
  • Lembre-se: nunca use anchors e attached properties ao mesmo tempo no mesmo componente.
  • Lembre-se: signals disponíveis ou criados pelo QML automaticamente geram signal handlers do tipo on + Nome (e em certos casos + Changed). Por exemplo, o signal clicked do QtQuick.Controls Button possui o signal handler onClicked; o signal value do QtQuick.Controls Slider possui o signal handler onValueChanged. Signal handlers NÃO aparecem na documentação de referência do Qt.
  • Há certos tipos QML especiais que não precisam de layout ou anchors, como o Repeater, porque internamente eles transferem a relação de pai/filho para cima. Por exemplo, no caso de um ColumnLayout contendo um Repeater de Buttons, os Buttons se tornam filhos diretos do ColumnLayout.
  • A nova API do CMake pro Qt6 qt_add_qml_module já cria resources para você, logo não é necessário (nem recomendado) usar o qt_add_resources junto dele.
  • Singletons feitos pelo QML usando pragma singleton requerem a propriedade QT_QML_SINGLETON_TYPE definida usandos set_source_files_properties.

PySide/PyQt

Em Português:

Em Inglês:

Detalhes adicionais:

Outros links

Em Português:

Em Inglês:

Contribuindo

Clique aqui para ler

As diretrizes para contribuir são as seguintes:

  • A licença deste readme é GPLv3, porque sim.

  • Material em inglês é permitido, mas dê preferência a material em português brasileiro, caso exista/você conheça.

  • Material pago é permitido, mas dê preferência a material gratuito, caso exista. Em toda lista, o material pago deve aparecer abaixo.

  • Material de Qt4 de referência é permitido apenas como material complementar (ou seja, na seção Outros links ou outra futura para isso).

  • Material de Qt4 que não seja de referência é permitido (na seção Outros links ou outra futura para isso).

  • Dê prioridade a links, não texto; isso significa que seções grandes de texto devem ser colapsáveis. Isso torna todo o material imediatamente acessável sem aumentar o tamanho da página excessivamente.

  • Dê preferência a autores de renome/especialistas.

  • Se o curso for em multimídia, dê preferência a autores de boa pronúncia/com áudio decente.

  • Materiais complementares de CMake são aceitos, mas em sua própria seção.

  • Materiais complementares de C++ são aceitos, mas em sua própria seção. Prefira contribuir diretamente ao material de aprendizado do cppbrasil ou ao livro de C++.

  • Caso não haja objeções durante o pull request, o material será incluso. A ideia do repositório é ser completo; é preferível adicionar antes e vetar depois do que restringir desnecessariamente a inclusão de material. A única exceção são cursos pagos, que precisam de veto para garantir a qualidade antes de serem inclusos.

About

Materiais de aprendizado para estudar Qt

Resources

Readme

License

GPL-3.0 license
Activity

Stars

11 stars

Watchers

1 watching

Forks

1 fork
Report repository

Releases

No releases published

Packages

No packages published