CMake – это группа инструментов, которые позволяют создавать, тестировать и упаковывать приложения. Как и Qt, он доступен на всех основных платформах разработки. Он также поддерживается различными IDE, включая Qt Creator.
В данной статье мы покажем самый простой способ использования Qt в проекте CMake. Во-первых, мы создадим базовое консольное приложение. Затем расширим проект в приложение с графическим интерфейсом, использующее Qt Widgets, а затем выделим из него статическую библиотеку, добавим ресурсы с изображениями и переводы на другие языки.
Если вы хотите узнать, как собрать существующий проект CMake с помощью Qt, смотрите статью о том, как собирать проекты с помощью CMake через командную строку.
Сборка консольного приложения C++
Проект CMake определяется файлами, написанными на языке CMake. Основной файл называется CMakeLists.txt и обычно находится в том же каталоге, что и исходники программы.
Вот типичный файл CMakeLists.txt для консольного приложения, написанного на C++ с использованием Qt:
Изучение Qt Creator | Урок #1 — Графический интерфейс на С++
cmake_minimum_required(VERSION 3.16) project(helloworld VERSION 1.0.0 LANGUAGES CXX) set(CMAKE_CXX_STANDARD 17) set(CMAKE_CXX_STANDARD_REQUIRED ON) set(CMAKE_AUTOMOC ON) find_package(Qt6 REQUIRED COMPONENTS Core) add_executable(helloworld main.cpp ) target_link_libraries(helloworld PRIVATE Qt6::Core)
Пройдемся по его содержимому.
cmake_minimum_required(VERSION 3.16)
cmake_minimum_required() указывает минимальную версию CMake, которая требуется приложению. Сам Qt требует как минимум CMake версии 3.16. Если вы используете Qt, который был собран статически (по умолчанию это Qt для iOS и Qt для WebAssembly), вам потребуется CMake 3.21.1 или новее.
project(helloworld VERSION 1.0.0 LANGUAGES CXX)
project() устанавливает имя проекта и версию проекта по умолчанию. Аргумент LANGUAGES сообщает CMake, что программа написана на C++.
set(CMAKE_CXX_STANDARD 17) set(CMAKE_CXX_STANDARD_REQUIRED ON)
Для Qt 6 требуется компилятор, поддерживающий C++ версии 17 или новее. Принудительное выполнение этого путем установки переменных CMAKE_CXX_STANDARD и CMAKE_CXX_STANDARD_REQUIRED позволит CMake распечатать ошибку, если компилятор слишком стар.
set(CMAKE_AUTOMOC ON)
Приложения Qt обычно используют компилятор метаобъектов (moc), поставляемый с Qt. Установка для переменной CMAKE_AUTOMOC значения ON позволит CMake автоматически устанавливать правила, чтобы при необходимости компилятор метаобъектов вызывался прозрачным образом.
find_package(Qt6 REQUIRED COMPONENTS Core)
Это говорит CMake искать Qt 6 и импортировать модуль Core . Нет смысла продолжать, если CMake не может найти модуль, поэтому мы устанавливаем флаг REQUIRED , чтобы в этом случае CMake прервал работу.
В случае успеха модуль установит некоторые переменные CMake, задокументированные в переменных модуля. Кроме того, он импортирует цель Qt6::Core , которую мы используем ниже.
Для успешного выполнения find_package CMake должен найти установку Qt. Есть разные способы сообщить CMake о Qt, но наиболее распространенный и рекомендуемый подход – установить переменную кэша CMake CMAKE_PREFIX_PATH для включения префикса установки Qt 6. Обратите внимание, что Qt Creator сделает это для вас прозрачно.
Изучение Qt Creator | Урок #2 — Создание приложения на C++
add_executable(helloworld main.cpp )
add_executable() сообщает CMake, что мы хотим создать исполняемый файл (а не библиотеку) с именем helloworld в качестве цели. Цель должна быть собрана из исходного файла C++ main.cpp .
Обратите внимание, что обычно здесь не указываются заголовочные файлы. Это отличается от qmake, где файлы заголовков должны быть явно перечислены, чтобы они обрабатывались компилятором метаобъектов (moc).
Для менее тривиальных проектов вы можете вместо этого вызвать qt_add_executable() . Это обертка над встроенной командой add_executable() , обеспечивающая дополнительную логику для автоматической обработки таких вещей, как связывание подключаемых модулей Qt в статических сборках Qt, настройка имен библиотек для конкретной платформы и т. д.
Для создания библиотек смотрите qt_add_library .
target_link_libraries(helloworld PRIVATE Qt6::Core)
Наконец, target_link_libraries сообщает CMake, что исполняемый файл helloworld использует Qt Core, ссылаясь на цель Qt6::Core , импортированную вызовом find_package() выше. Это не только добавит компоновщику правильные аргументы, но также гарантирует, что компилятору C++ передаются правильные каталоги включений и определения компилятора. Ключевое слово PRIVATE не обязательно для исполняемого целевого объекта, но его рекомендуется указывать. Если helloworld является библиотекой, а не исполняемым файлом, то следует указать либо PRIVATE , либо PUBLIC ( PUBLIC , если библиотека упоминает что-либо из Qt6::Core в своих заголовках, PRIVATE – в противном случае).
Создание приложения с графическим интерфейсом C++
В предыдущем разделе мы показали файл CMakeLists.txt для простого консольного приложения. Теперь мы расширим его, чтобы создать приложение с графическим интерфейсом, использующее модуль Qt Widgets.
Это полный файл проекта:
cmake_minimum_required(VERSION 3.16) project(helloworld VERSION 1.0.0 LANGUAGES CXX) set(CMAKE_CXX_STANDARD 17) set(CMAKE_CXX_STANDARD_REQUIRED ON) set(CMAKE_AUTOMOC ON) set(CMAKE_AUTOUIC ON) find_package(Qt6 REQUIRED COMPONENTS Widgets) add_executable(helloworld mainwindow.ui mainwindow.cpp main.cpp ) target_link_libraries(helloworld PRIVATE Qt6::Widgets) set_target_properties(helloworld PROPERTIES WIN32_EXECUTABLE ON MACOSX_BUNDLE ON )
Давайте пройдемся по внесенным нами изменениям.
set(CMAKE_AUTOMOC ON) set(CMAKE_AUTOUIC ON)
В дополнение к CMAKE_AUTOMOC мы устанавливаем переменную CMAKE_AUTOUIC в ON . Это автоматически создаст правила для вызова компилятора пользовательского интерфейса Qt (uic) для исходных файлов .ui .
find_package(Qt6 REQUIRED COMPONENTS Widgets)
В вызове find_package мы заменяем Core на Widgets . Это найдет модуль Qt6Widgets и предоставит цели Qt6::Widgets , с которыми мы позже свяжемся.
Обратите внимание, что приложение по-прежнему будет связываться с Qt6::Core , потому что от него зависит Qt6::Widgets .
add_executable(helloworld mainwindow.ui mainwindow.cpp main.cpp )
В исходники целевого приложения мы добавляем файл Qt Designer ( mainwindow.ui ) и соответствующий ему исходный файл C++ ( mainwindow.cpp ).
target_link_libraries(helloworld PRIVATE Qt6::Widgets)
В команде target_link_libraries мы связываемся с Qt6::Widgets вместо Qt6::Core .
set_target_properties(helloworld PROPERTIES WIN32_EXECUTABLE ON MACOSX_BUNDLE ON )
Наконец, мы устанавливаем свойства нашего целевого приложения со следующими эффектами:
- запретить создание окна консоли в Windows:
- создать пакет приложений в macOS.
Дополнительные сведения об этих целевых свойствах смотрите в документации по CMake.
Организация структуры проектов
Проекты, содержащие более одной цели, будут выигрывать от четкой файловой структуры проекта. Для этого мы будем использовать функцию подкаталога CMake.
Поскольку мы планируем расширить проект дополнительными целями, мы перемещаем исходные файлы приложения в подкаталог и создаем там новый файл CMakeLists.txt .
├── CMakeLists.txt └── src └── app ├── CMakeLists.txt ├── main.cpp ├── mainwindow.cpp ├── mainwindow.h └── mainwindow.ui
CMakeLists.txt верхнего уровня содержит общую настройку проекта, вызовы find_package и add_subdirectory :
cmake_minimum_required(VERSION 3.16) project(helloworld VERSION 1.0.0 LANGUAGES CXX) set(CMAKE_CXX_STANDARD 17) set(CMAKE_CXX_STANDARD_REQUIRED ON) set(CMAKE_AUTOMOC ON) set(CMAKE_AUTOUIC ON) find_package(Qt6 REQUIRED COMPONENTS Widgets) add_subdirectory(src/app)
Переменные, установленные в этом файле, видны в файлах проектов подкаталогов.
Файл проекта приложения src/app/CMakeLists.txt содержит исполняемую цель:
add_executable(helloworld mainwindow.ui mainwindow.cpp main.cpp ) target_link_libraries(helloworld PRIVATE Qt6::Widgets) set_target_properties(helloworld PROPERTIES WIN32_EXECUTABLE ON MACOSX_BUNDLE ON )
Такая структура упростит добавление в проект дополнительных целей, таких как библиотеки или модульные тесты.
Сборка библиотек
По мере роста проекта вы можете захотеть превратить части кода вашего приложения в библиотеку, которая используется приложением и, возможно, модульными тестами. В этом разделе показано, как создать такую библиотеку.
В настоящее время наше приложение содержит бизнес-логику непосредственно в main.cpp . Мы извлекаем код в новую статическую библиотеку под названием businesslogic в подкаталоге src/businesslogic , как описано в предыдущем разделе.
Для простоты библиотека состоит только из одного исходного файла C++ и соответствующего ему заголовочного файла, включенного в файл main.cpp приложения:
├── CMakeLists.txt └── src ├── app │ ├── . │ └── main.cpp └── businesslogic ├── CMakeLists.txt ├── businesslogic.cpp └── businesslogic.h
Давайте посмотрим на файл проекта библиотеки ( src/businesslogic/CMakeLists.txt ).
add_library(businesslogic STATIC businesslogic.cpp ) target_link_libraries(businesslogic PRIVATE Qt6::Core) target_include_directories(businesslogic INTERFACE $)
Пройдемся по его содержимому.
add_library(businesslogic STATIC businesslogic.cpp )
Команда add_library создает библиотеку businesslogic . Позже мы позволим приложению связываться с этой целью.
Ключевое слово STATIC обозначает статическую библиотеку. Если бы мы хотели создать общую или динамическую библиотеку, мы бы использовали ключевое слово SHARED .
target_link_libraries(businesslogic PRIVATE Qt6::Core)
У нас есть статическая библиотека, и на самом деле нам не нужно связывать другие библиотеки. Но так как наша библиотека использует классы из QtCore , мы добавляем зависимость линковки на Qt6::Core . Это извлекает необходимые пути включения QtCore и определения препроцессора.
target_include_directories(businesslogic INTERFACE $)
API библиотеки определен в заголовочном файле businesslogic/businesslogic.h . Вызывая target_include_directories , мы убеждаемся, что абсолютный путь к каталогу businesslogic автоматически добавляется в качестве пути включения для всех целей, использующих нашу библиотеку.
Это освобождает нас в main.cpp от использования относительных путей для поиска businesslogic.h . Вместо этого мы можем просто написать
#include
Наконец, мы должны добавить подкаталог библиотеки в файл проекта верхнего уровня:
add_subdirectory(src/app) add_subdirectory(src/businesslogic)
Использование библиотек
Чтобы использовать библиотеку, которую мы создали в предыдущем разделе, мы указываем CMake связать ее:
target_link_libraries(helloworld PRIVATE businesslogic Qt6::Widgets)
Это гарантирует, что файл businesslogic.h будет найден при компиляции main.cpp . Кроме того, статическая библиотека businesslogic станет частью исполняемого файла helloworld .
В терминах CMake библиотека businesslogic определяет требования к использованию (путь включения), которым должен удовлетворять каждый пользователь нашей библиотеки (приложение). Об этом позаботится команда target_link_libraries .
Добавление ресурсов
Как писать программы на qt
Библиотека сайта rus-linux.net
Qt является кроссплатформенным фреймворком для разработки приложений от компании Trolltech, а на данный момент владельцем кода является компания Nokia (на момент перевода статьи компания Nokia передала разработку Qt компании Digia — прим.пер.). Фреймворк предоставляет API на языке C++. Qt часто используется разработчиками для разработки кроссплатформенных приложений.
При помощи Qt можно разрабатывать приложения с графическим интерфейсом, приложения, работающие с сетью, приложения, работающие с базами данных и мультимедийные приложения, работать с XML-структурами и 3D-графикой, осуществлять рисование и доступ к сетевым ресурсам. Поскольку поддерживается ряд платформ, Qt может работать на Linux, Mac OS, Windows, Meego, встраиваемых Linux-системах и Symbian.
Архитектура Qt
Простейшая схема, демонстрирующая архитектуру Qt, представлена на Рисунке 1.
Рисунок 1: Архитектура Qt
На верхнем уровне находится код программы на языке C++. Уровнем ниже расположены классы Qt для создания графического интерфейса, взаимодействия с WebKit, работы с базами данных и.т.д., а еще ниже расположен уровень поддержки различных операционных систем. Ранее Qt поддерживал также язык программирования Java; версия для языка Java называлась Jambie. По мере продвижения разработки Qt, становилось все сложнее поддерживать версии для C++ и Java, поэтому и было принято решение поддерживать только версию для C++.
Установка Qt
Методы установки отличаются в зависимости от операционной системы. В ОС Ubuntu 10.04 LTS я установил Qt при помощи менеджера пакетов Synaptic — при установке пакета qtcreator по зависимостям будут установлены Qt Assistant, Qt Designer, Qt Linguist и Qt Creator.
Если вы хотите попробовать новейшую версию Qt, можете скачать установочный пакет с официального сайта и установить его. От вас требуется только позволить исполнение установочного пакета как программы при помощи команды chmod и запустить его, после чего следовать инструкциям.
Программа ‘Hello World’ (без графического интерфейса)
Откройте терминал. Создайте директорию с названием first и простейшую программу «Hello World» со следующим кодом:
#include int main()
Подключенный заголовочный файл QtCore содержит описания классов, не использующих графический интерфейс. Их мы рассмотрим в подробностях в следующих статьях. На данный момент будем просто использовать класс qDebug , который выводит отладочные сообщения в консоль и обладает функциями, эквивалентными cout при программировании на языке C++.
Как же скомпилировать эту программу? Разработчики из компании Trolltech представили простое решение для осуществления кроссплатформенной компиляции. Для начала должен быть создан файл проекта, на основе которого будет сгенерирован файл Makefile . После этого просто введите make для компиляции программы. Когда вы устанавливаете пакет Qt Creator, утилита qmake устанавливается вместе с ним.
Она является кроссплатформенным генератором файлов Makefile для Qt. Чтобы узнать больше об этой утилите, обратитесь к странице руководства. Выполните команду qmake -project для создания файла проекта (файла с расширением .pro и именем, идентичным имени директории проекта, т.е. first).
$ cat first.pro ###################################################################### # Automatically generated by qmake (2.01a) Mon Nov 28 05:49:29 2011 ###################################################################### TEMPLATE = app TARGET = DEPENDPATH += . INCLUDEPATH += . # Input SOURCES += main.cpp
Вы можете создавать как приложения, так и библиотеки; значением параметра TEMPLATE является app , говорящее о том, что разрабатывается приложение. Я затрону тему разработки библиотек в следующих статьях серии. Аргументом параметра SOURCES является список файлов исходного кода в рамках проекта, подробнее об этом будет сказано далее.
Теперь давайте сгенерируем файл Makefile при помощи утилиты qmake . Это длинный файл — он может содержать до 200 строк. Запустите команду make для компиляции исполняемого файла:
В последней строке вы можете заметить то, что наша программа использует также библиотеку для работы с потоками POSIX. Запустите программу при помощи команды ./first , чтобы увидеть вывод «Hello World». Программа работает! Только что мы успешно скомпилировали нашу первую программу.
Программа с графическим интерфейсом
Qt предоставляет возможность визуального проектирования графических интерфейсов методом drag-and-drop и автоматического создания файлов описания графических интерфейсов, которую мы рассмотрим в следующей статье. Сейчас же мы опишем вручную графический интерфейс нашей новой программы:
#include #include int main(int argc, char *argv[])
В нашем первом примере у программы не было графического интерфейса. Программа завершалась при возвращении из функции main. Тем не менее, мы не можем поступить также в программах с графическим интерфейсом, поскольку программы будет невозможно использовать. Мы хотим, чтобы графический интерфейс работал до того момента, как пользователь закрывает окно.
Для этого необходимо, чтобы программа работала в цикле до того, как пользователь закроет окно, поэтому следует использовать класс QApplication , в котором реализован цикл приема событий. Когда вы создаете экземпляр этого класса и вызываете его метод exec() , функция main не возвращает управления. Приложение находится в режиме ожидания событий от пользователя.
Второй заголовочный файл содержит описание класса QLabel , представляющего из себя простой виджет для вывода текста. Создайте экземпляр этого класса и установите текст «Hello World». При вызове метода show() виджета, он отображается в виде окна. Таким образом, виджет будет выглядеть как окно. На Рисунке 2 можно увидеть это окно с заголовком.
Вы можете изменить размеры окна просто при помощи мыши.
Рисунок 2: Виджет строки
В следующих статьях мы рассмотрим основные классы Qt. Между тем, я рекомендую вам внимательно рассмотреть официальную документацию Qt .
Источник: rus-linux.net
Написание приложений, основаных на Qt, на языке Python
Доброе время суток.
Недавно решил изучить ещё один язык программирования. Выбор пал на python. Написал несколько маленьких скриптов. Но прежде всего я хотел писать приложения с графическим интерфейсом. В интернете наткнулся на этот небольшой туториал, прочтение которого вылилось в предлагаемый Вашему вниманию перевод.
Надеюсь, что кому-нибудь он будет полезен.
Это руководство нацелено на получение представления о том как писать маленькие приложения на python, использующие библотеку Qt.
Для успешного выполнения всех заданий необходимо иметь базовые знания python, однако, Qt знать не обязательно. Я использую linux в этих примерах и я предполагаю, что вы уже имеете работающий Python и PyQt. Для того, чтобы проверить это, откройте оболочку python, просто набрав «python» в консоли в введите
import qt
Если не появилось сообщения об ошибке, вы уже готовы начать. Примеры в этом руководстве упрощены насколько это возможно, и показывают полезные способы чтобы писать и структурировать вашу программу. Важно, чтобы вы прочитали исходный код примеров, болшинство вещей объяснены там. Используйте примеры и попытайтесь изменить их, поиграйте с ними.
Это лучший способ привыкнуть.
Hello, world!
Начнём с простого. Программа открывает окно и показывает что-нибудь. Приведённый дальше код показывает окно, в котором написано «Hello, world!». Очевидно.
#!/usr/bin/python import sys from qt import * #создадим приложение и передадим аргументы a = QApplication(sys.argv) #создание виджета #Первый аргумент – текст, который мы хотим увидеть. #Воторой аргумент – родительский виджет, #т.к. Hello – единственный виджет, то у него нет родителя hello = QLabel(«Hello world!»,None) #делаем виджет главным a.setMainWidget(hello) #показать виджет hello.show() #запустить приложение a.exec_loop()
Около 7 строк кода, и это настолько просто как только можно.
А вот так это выглядит:
Кнопка
Добавим немного нтерактивности! Мы заменим надпись «Hello, World!» кнопкой и назначим ей действие. Это назанчение называется «присоединением сигнала», событие, которое посылается слоту когда кнопка нажата, который является функцией. Эта функция запускается, когда возникает событие.
#!/usr/bin/python # coding=utf-8 import sys from qt import * a = QApplication(sys.argv) # Наша функция, которая будет вызвана пр нажатии на кнопку def sayHello(): print «Hello, World!» #создание кнопки hellobutton = QPushButton(«Say ‘Hello world!'»,None) #назначить обработчик клика кнопке a.connect(hellobutton, SIGNAL(«clicked()»), sayHello) #назначить кнопку главным виджетом a.setMainWidget(hellobutton) #показать виждет hellobutton.show() #запустить приложение a.exec_loop()
Это уже больше похоже на нормальное приложение
Вы можете вообразить, что программирование таким образом не расширяемо и не заходите продолжать. Чтож давайте сделаем это по-питоновски, добавив структуру и использовав объектно-ориентированный подход. Мы создадим наш собственный класс, наследованный от QApplication и поместим необходимые нам вещи в его методы: один метод для того чтобы создать виджеты и слот, который сожержит код, запускаемый при приходе сигнала.
#!/usr/bin/python # coding=UTF-8 import sys from qt import * #класс наследуем от QApplication class HelloApplication(QApplication): def __init__(self, args): «»» В конструкторе мы делаем всё, что необходимо для запуска нашего приложения, которое создаёт QApplication в __init__ методе, затем добваляет наши виджеты и, наконец, запускает exec_loop «»» QApplication.__init__(self, args) self.addWidgets() self.exec_loop() def addWidgets(self): «»» В этом методе мы добавляем виджеты и присоединяем обработчики сигналов. Обработчик сигнала для виджета так же называется «слотом» «»» self.hellobutton = QPushButton(«Say ‘Hello, World!'»,None) self.connect(self.hellobutton, SIGNAL(«clicked()»), self.slotSayHello) self.setMainWidget(self.hellobutton) self.hellobutton.show() def slotSayHello(self): «»» Это пример слота — метода, который вызывается, когда приходит сигнал. «»» print «Hello, World!» # Этот скрипт должен выполняться только отдельно, так что мы должны проверить это, # но мы также должны иметь возможность подключать эту программу без запуска какого-либо кода if __name__ == «__main__»: app = HelloApplication(sys.argv)
Кодирование интерфейсов – отстой
Так что мы хотим использовать Qt3 Designer для создания GUI. На картинке вы можете видеть простой интерфейс. Зелёным цветом написаны имена виджетов. Всё что нам надо сделать
- Скомпилировать .ui файл из Qt designer’а в класс на python
- Написать подкласс и использовать его как mainWidget
Таким образом, мы сможем изменять нтерфейс в Qt designer’е, не копаясь в коде
pyuic testapp_ui.ui -o testapp_ui.py
сделает класс на python, с которым мы сможем работать.
- Мы заполняем lineedit
- К нажатию на кнопку добавления мы присоединим метод, который читает текст из lineedit и добавляет его в listview
- Нажатие на кнопку удаления удалит выбранный элемент из listview.
#!/usr/bin/python # coding=utf-8 from testapp_ui import TestAppUI from qt import * import sys class HelloApplication(QApplication): def __init__(self, args): «»» В конструкторе мы делаем всё, что необходимо для запска нашего приложения, которое создаёт QApplication в __init__ методе, затем добваляет наши виджеты и, наконец, запускает exec_loop «»» QApplication.__init__(self,args) # Мы передаём None т.к. этот виджет верхнего уровня self.maindialog = TestApp(None) self.setMainWidget(self.maindialog) self.maindialog.show() self.exec_loop() class TestApp(TestAppUI): def __init__(self,parent): # Запускаем родительский конструктор и присоединяем слоты к методам TestAppUI.__init__(self,parent) self._connectSlots() # Изначально список пуст, так что кнопка удаления не должна работать # Сделаем её неактивной self.deletebutton.setEnabled(False) def _connectSlots(self): # Устанавливаем обработчики сингналов на кнопки self.connect(self.addbutton,SIGNAL(«clicked()»),self._slotAddClicked) self.connect(self.lineedit,SIGNAL(«returnPressed()»),self._slotAddClicked) self.connect(self.deletebutton,SIGNAL(«clicked()»),self._slotDeleteClicked) def _slotAddClicked(self): # Читаем тескт из lineedit, text = self.lineedit.text() # если lineedit не пуст, if len(text): # вставим новый элемент в список . lvi = QListViewItem(self.listview) # с текстом из lineedit . lvi.setText(0,text) # и очистим lineedit. self.lineedit.clear() # Кнопка удаления м.б. выключена, так что включим её. self.deletebutton.setEnabled(True) def _slotDeleteClicked(self): # Удаляем выбранный элемент из списка self.listview.takeItem(self.listview.currentItem()) # Check if the list is empty — if yes, disable the deletebutton. # Если список после этого оказался пустым, то сделаем кнопку удаления неактивной if self.listview.childCount() == 0: self.deletebutton.setEnabled(False) if __name__ == «__main__»: app = HelloApplication(sys.argv)
И вот результат трудов:
Полезно знать
Создание интерфейса в Qt designer’е не только делает проще создание GUI, но это также хороший инструмент для изучения Qt. Вы можете протестировать как виджет выглядит, увидеть что доступно в Qt и посмотреть свойства, которые вы можете захотеть использовать.
Документация API для C++ также очень полезна (читайте необходима), когда работаете с PyQt. API переведён очень просто, так что попрактиковавшись, вы поймёте, что документация API для разработчиков, один из действительно нужных вам инструментов. Во врема работы в KDE вы можете ввести qt:[widgetname] в конквероре. Т.о. qt:qbutton откроет вам документацию прямо на описании qbutton. Сайт Trolltech содержит гораздо больше документации, которая может оказаться вам полезной.
Примеры в этом руководстве созданы с использованием Qt 3.3. Я быть может обновлю руководство когда появится пригодная к использованию версия pyQt для Qt 4.
Источник: h.amazingsoftworks.com