QMargins из модуля
QtCore
, конструктор которого имеет следующий формат:
QMargins(<Граница слева>, <Граница сверху>, <Граница справа>, <Граница снизу>)
Текущая область при этом не изменяется:
>>> r1 = QtCore.QRect(10, 15, 400, 300)
>>> m = QtCore.QMargins(5, 2, 5, 2)
376
Часть II. Библиотека PyQt 5
>>> r2 = r1.marginsAdded(m)
>>> r2
PyQt5.QtCore.QRect(5, 13, 410, 304)
>>> r1
PyQt5.QtCore.QRect(10, 15, 400, 300)
marginsRemoved()
— то же самое, что marginsAdded()
, но уменьшает новую область на заданные величины границ:
>>> r1 = QtCore.QRect(10, 15, 400, 300)
>>> m = QtCore.QMargins(2, 10, 2, 10)
>>> r2 = r1.marginsRemoved(m)
>>> r2
PyQt5.QtCore.QRect(12, 25, 396, 280)
>>> r1
PyQt5.QtCore.QRect(10, 15, 400, 300)
Переместить область при изменении координат позволяют следующие методы:
moveTo(
, )
, moveTo()
, moveLeft()
и moveTop()
— задают новые координаты левого верхнего угла:
>>> r = QtCore.QRect(10, 15, 400, 300)
>>> r.moveTo(0, 0); r
PyQt5.QtCore.QRect(0, 0, 400, 300)
>>> r.moveTo(QtCore.QPoint(10, 10)); r
PyQt5.QtCore.QRect(10, 10, 400, 300)
>>> r.moveLeft(5); r.moveTop(0); r
PyQt5.QtCore.QRect(5, 0, 400, 300)
moveRight()
и moveBottom()
— задают новые координаты правого нижнего угла;
moveTopLeft()
— задает новые координаты левого верхнего угла;
moveTopRight()
— задает новые координаты правого верхнего угла;
moveBottomLeft()
— задает новые координаты левого нижнего угла;
moveBottomRight()
— задает новые координаты правого нижнего угла.
Примеры:
>>> r = QtCore.QRect(10, 15, 400, 300)
>>> r.moveTopLeft(QtCore.QPoint(0, 0)); r
PyQt5.QtCore.QRect(0, 0, 400, 300)
>>> r.moveBottomRight(QtCore.QPoint(599, 499)); r
PyQt5.QtCore.QRect(200, 200, 400, 300)
moveCenter()
— задает новые координаты центра;
translate(<Сдвиг по оси X>, <Сдвиг по оси Y>)
и translate()
— задают но- вые координаты левого верхнего угла относительно текущего значения координат:
>>> r = QtCore.QRect(0, 0, 400, 300)
>>> r.translate(20, 15); r
PyQt5.QtCore.QRect(20, 15, 400, 300)
>>> r.translate(QtCore.QPoint(10, 5)); r
PyQt5.QtCore.QRect(30, 20, 400, 300)
Глава 18. Управление окном приложения
377
translated(<Сдвиг по оси X>, <Сдвиг по оси Y>)
и translated()
— анало- гичен методу translate()
, но возвращает новый экземпляр класса
QRect
, а не изменяет текущий;
adjust(, , , )
— задает новые координаты левого верхнего и правого нижнего углов относительно текущих значений координат:
>>> r = QtCore.QRect(0, 0, 400, 300)
>>> r.adjust(10, 5, 10, 5); r
PyQt5.QtCore.QRect(10, 5, 400, 300)
adjusted(, , , )
— аналогичен методу adjust()
, но возвращает но- вый экземпляр класса
QRect
, а не изменяет текущий.
Для получения параметров области предназначены следующие методы:
left()
и x()
— возвращают координату левого верхнего угла по оси
X
;
top()
и y()
— возвращают координату левого верхнего угла по оси
Y
;
right()
и bottom()
— возвращают координаты правого нижнего угла по осям
X
и
Y
соот- ветственно;
width()
и height()
— возвращают ширину и высоту соответственно;
size()
— возвращает размеры в виде экземпляра класса
QSize
Примеры:
>>> r = QtCore.QRect(10, 15, 400, 300)
>>> r.left(), r.top(), r.x(), r.y(), r.right(), r.bottom()
(10, 15, 10, 15, 409, 314)
>>> r.width(), r.height(), r.size()
(400, 300, PyQt5.QtCore.QSize(400, 300))
topLeft()
— возвращает координаты левого верхнего угла;
topRight()
— возвращает координаты правого верхнего угла;
bottomLeft()
— возвращает координаты левого нижнего угла;
bottomRight()
— возвращает координаты правого нижнего угла.
Примеры:
>>> r = QtCore.QRect(10, 15, 400, 300)
>>> r.topLeft(), r.topRight()
(PyQt5.QtCore.QPoint(10, 15), PyQt5.QtCore.QPoint(409, 15))
>>> r.bottomLeft(), r.bottomRight()
(PyQt5.QtCore.QPoint(10, 314), PyQt5.QtCore.QPoint(409, 314))
center()
— возвращает координаты центра области. Например, вывести окно по центру доступной области экрана можно так: desktop = QtWidgets.QApplication.desktop() window.move(desktop.availableGeometry().center() - window.rect().center())
getRect()
— возвращает кортеж с координатами левого верхнего угла и размерами об- ласти;
getCoords()
— возвращает кортеж с координатами левого верхнего и правого нижнего углов:
378
Часть II. Библиотека PyQt 5
>>> r = QtCore.QRect(10, 15, 400, 300)
>>> r.getRect(), r.getCoords()
((10, 15, 400, 300), (10, 15, 409, 314))
Прочие методы:
isNull()
— возвращает
True
, если ширина и высота равны нулю, и
False
— в противном случае;
isValid()
— возвращает
True
, если left() < right()
и top() < bottom()
, и
False
— в противном случае;
isEmpty()
— возвращает
True
, если left() > right()
или top() > bottom()
, и
False
— в противном случае;
normalized()
— исправляет ситуацию, при которой left() > right()
или top() > bottom()
, и возвращает новый экземпляр класса
QRect
:
>>> r = QtCore.QRect(QtCore.QPoint(409, 314), QtCore.QPoint(10, 15))
>>> r
PyQt5.QtCore.QRect(409, 314, -398, -298)
>>> r.normalized()
PyQt5.QtCore.QRect(10, 15, 400, 300)
contains([, <Флаг>])
и contains(, [, <Флаг>])
— возвращает
True
, если точка с указанными координатами расположена внутри области или на ее границе, и
False
— в противном случае. Если во втором параметре указано значение
True
, то точка должна быть расположена только внутри области, а не на ее границе. Значение парамет- ра по умолчанию —
False
:
>>> r = QtCore.QRect(0, 0, 400, 300)
>>> r.contains(0, 10), r.contains(0, 10, True)
(True, False)
contains([, <Флаг>])
— возвращает
True
, если указанная область расположена внутри текущей области или на ее краю, и
False
— в противном случае. Если во втором параметре указано значение
True
, то указанная область должна быть расположена толь- ко внутри текущей области, а не на ее краю. Значение параметра по умолчанию —
False
:
>>> r = QtCore.QRect(0, 0, 400, 300)
>>> r.contains(QtCore.QRect(0, 0, 20, 5))
True
>>> r.contains(QtCore.QRect(0, 0, 20, 5), True)
False
intersects()
— возвращает
True
, если указанная область пересекается с текущей областью, и
False
— в противном случае;
intersected()
— возвращает область, которая расположена на пересечении те- кущей и указанной областей:
>>> r = QtCore.QRect(0, 0, 20, 20)
>>> r.intersects(QtCore.QRect(10, 10, 20, 20))
True
>>> r.intersected(QtCore.QRect(10, 10, 20, 20))
PyQt5.QtCore.QRect(10, 10, 10, 10)
Глава 18. Управление окном приложения
379
united()
— возвращает область, которая охватывает текущую и указанную об- ласти:
>>> r = QtCore.QRect(0, 0, 20, 20)
>>> r.united(QtCore.QRect(30, 30, 20, 20))
PyQt5.QtCore.QRect(0, 0, 50, 50)
Над двумя экземплярами класса
QRect можно выполнять операции
&
и
&=
(пересечение),
|
и
|=
(объединение), in
(проверка на вхождение),
==
и
!=
Пример:
>>> r1, r2 = QtCore.QRect(0, 0, 20, 20), QtCore.QRect(10, 10, 20, 20)
>>> r1 & r2, r1 | r2
(PyQt5.QtCore.QRect(10, 10, 10, 10), PyQt5.QtCore.QRect(0, 0, 30, 30))
>>> r1 in r2, r1 in QtCore.QRect(0, 0, 30, 30)
(False, True)
>>> r1 == r2, r1 != r2
(False, True)
Помимо этого, поддерживаются операторы
+
и
-
, выполняющие увеличение и уменьшение области на заданные величины границ, которые должны быть заданы в виде объекта класса
QMargins
:
>>> r = QtCore.QRect(10, 15, 400, 300)
>>> m = QtCore.QMargins(5, 15, 5, 15)
>>> r + m
PyQt5.QtCore.QRect(5, 0, 410, 330)
>>> r - m
PyQt5.QtCore.QRect(15, 30, 390, 270)
18.6. Разворачивание и сворачивание окна
В заголовке окна расположены кнопки Свернуть и Развернуть, с помощью которых мож- но свернуть окно в значок на панели задач или развернуть его на весь экран. Выполнить подобные действия из программы позволяют следующие методы класса
QWidget
:
showMinimized()
— сворачивает окно на панель задач. Эквивалентно нажатию кнопки
Свернуть в заголовке окна;
showMaximized()
— разворачивает окно до максимального размера. Эквивалентно нажа- тию кнопки Развернуть в заголовке окна;
showFullScreen()
— включает полноэкранный режим отображения окна. Окно отобра- жается без заголовка и границ;
showNormal()
— отменяет сворачивание, максимальный размер и полноэкранный режим, возвращая окно к изначальным размерам;
activateWindow()
— делает окно активным (т. е. имеющим фокус ввода). В Windows, если окно было ранее свернуто в значок на панель задач, оно не будет развернуто в из- начальный вид;
setWindowState(<Флаги>)
— изменяет состояние окна в зависимости от переданных фла- гов. В качестве параметра указывается комбинация следующих атрибутов из класса
QtCore.Qt через побитовые операторы:
380
Часть II. Библиотека PyQt 5
•
WindowNoState
—
нормальное состояние окна;
•
WindowMinimized
— окно свернуто;
•
WindowMaximized
— окно максимально развернуто;
•
WindowFullScreen
— полноэкранный режим;
•
WindowActive
— окно имеет фокус ввода, т. е. является активным.
Например, включить полноэкранный режим можно так: window.setWindowState((window.windowState() &
(QtCore.Qt.WindowMinimized | QtCore.Qt.WindowMaximized))
| QtCore.Qt.WindowFullScreen)
Проверить текущий статус окна позволяют следующие методы:
isMinimized()
— возвращает
True
, если окно свернуто, и
False
— в противном случае;
isMaximized()
— возвращает
True
, если окно раскрыто до максимальных размеров, и
False
— в противном случае;
isFullScreen()
— возвращает
True
, если включен полноэкранный режим, и
False
— в противном случае;
isActiveWindow()
— возвращает
True
, если окно имеет фокус ввода, и
False
— в про- тивном случае;
windowState()
— возвращает комбинацию флагов, обозначающих текущий статус окна.
Пример проверки использования полноэкранного режима: if window.windowState() & QtCore.Qt.WindowFullScreen: print("Полноэкранный режим")
Пример разворачивания и сворачивания окна приведен в листинге 18.4.
Листинг 18.4. Разворачивание и сворачивание окна
# -*- coding: utf-8 -*- from PyQt5 import QtCore, QtWidgets class MyWindow(QtWidgets.QWidget): def __init__(self, parent=None):
QtWidgets.QWidget.__init__(self, parent) self.btnMin = QtWidgets.QPushButton("Свернуть") self.btnMax = QtWidgets.QPushButton("Развернуть") self.btnFull = QtWidgets.QPushButton("Полный экран") self.btnNormal = QtWidgets.QPushButton("Нормальный размер") vbox = QtWidgets.QVBoxLayout() vbox.addWidget(self.btnMin) vbox.addWidget(self.btnMax) vbox.addWidget(self.btnFull) vbox.addWidget(self.btnNormal) self.setLayout(vbox) self.btnMin.clicked.connect(self.on_min) self.btnMax.clicked.connect(self.on_max) self.btnFull.clicked.connect(self.on_full) self.btnNormal.clicked.connect(self.on_normal)
Глава 18. Управление окном приложения
381 def on_min(self): self.showMinimized() def on_max(self): self.showMaximized() def on_full(self): self.showFullScreen() def on_normal(self): self.showNormal() if __name__ == "__main__": import sys app = QtWidgets.QApplication(sys.argv) window = MyWindow() window.setWindowTitle("Разворачивание и сворачивание окна") window.resize(300, 100) window.show() sys.exit(app.exec_())
18.7. Управление прозрачностью окна
Сделать окно полупрозрачным позволяет метод setWindowOpacity()
класса
QWidget
. Формат метода: setWindowOpacity(<Вещественное число от 0.0 до 1.0>)
Число
0.0
соответствует полностью прозрачному окну, а число
1.0
— отсутствию прозрач- ности. Для получения степени прозрачности окна из программы предназначен метод windowOpacity()
. Выведем окно со степенью прозрачности
0.5
(листинг 18.5).
Листинг 18.5. Полупрозрачное окно
# -*- coding: utf-8 -*- from PyQt5 import QtWidgets import sys app = QtWidgets.QApplication(sys.argv) window = QtWidgets.QWidget() window.setWindowTitle("Полупрозрачное окно") window.resize(300, 100) window.setWindowOpacity(0.5) window.show() print(window.windowOpacity()) # Выведет: 0.4980392156862745 sys.exit(app.exec_())
18.8. Модальные окна
Модальным называется окно, которое не позволяет взаимодействовать с другими окнами в том же приложении, — пока модальное окно не будет закрыто, сделать активным другое окно нельзя. Например, если в программе Microsoft Word выбрать пункт меню Файл | Со- хранить как, откроется модальное диалоговое окно, позволяющее выбрать путь и название
382
Часть II. Библиотека PyQt 5 файла, и, пока это окно не будет закрыто, вы не сможете взаимодействовать с главным ок- ном приложения.
Указать, что окно является модальным, позволяет метод setWindowModality(<Флаг>)
класса
QWidget
. В качестве параметра могут быть указаны следующие атрибуты из класса
QtCore.Qt
:
NonModal
—
0
— окно не является модальным (поведение по умолчанию);
WindowModal
—
1
— окно блокирует только родительские окна в пределах иерархии;
ApplicationModal
—
2
— окно блокирует все окна в приложении.
Окна, открытые из модального окна, не блокируются. Следует также учитывать, что метод setWindowModality()
должен быть вызван до отображения окна.
Получить текущее значение модальности позволяет метод windowModality()
. Проверить, является ли окно модальным, можно с помощью метода isModal()
— он возвращает
True
, если окно является модальным, и
False
— в противном случае.
Создадим два независимых окна. В первом окне разместим кнопку, по нажатию которой откроется модальное окно, — оно будет блокировать только первое окно, но не второе. При открытии модального окна отобразим его примерно по центру родительского окна (лис- тинг 18.6).
Листинг 18.6. Модальные окна
# -*- coding: utf-8 -*- from PyQt5 import QtCore, QtWidgets import sys def show_modal_window(): global modalWindow modalWindow = QtWidgets.QWidget(window1, QtCore.Qt.Window) modalWindow.setWindowTitle("Модальное окно") modalWindow.resize(200, 50) modalWindow.setWindowModality(QtCore.Qt.WindowModal) modalWindow.setAttribute(QtCore.Qt.WA_DeleteOnClose, True) modalWindow.move(window1.geometry().center() - modalWindow.rect().center() –
QtCore.QPoint(4, 30)) modalWindow.show() app = QtWidgets.QApplication(sys.argv) window1 = QtWidgets.QWidget() window1.setWindowTitle("Обычное окно") window1.resize(300, 100) button = QtWidgets.QPushButton("Открыть модальное окно") button.clicked.connect(show_modal_window) vbox = QtWidgets.QVBoxLayout() vbox.addWidget(button) window1.setLayout(vbox) window1.show() window2 = QtWidgets.QWidget() window2.setWindowTitle("Это окно не будет блокировано при WindowModal")
Глава 18. Управление окном приложения
383 window2.resize(500, 100) window2.show() sys.exit(app.exec_())
Если запустить приложение и нажать кнопку Открыть модальное окно, откроется окно, выровненное примерно по центру родительского окна (произвести точное выравнивание вы сможете самостоятельно). При этом получить доступ к родительскому окну можно только после закрытия модального окна, второе же окно блокировано не будет. Если заменить атрибут
WindowModal атрибутом
ApplicationModal
, оба окна будут блокированы.
Обратите внимание, что в конструктор модального окна мы передали ссылку на первое ок- но и атрибут
Window
. Если не указать ссылку, то окно блокировано не будет, а если не ука- зать атрибут, окно вообще не откроется. Кроме того, мы объявили переменную modalWindow глобальной, иначе при достижении конца функции переменная выйдет из области видимо- сти, и окно будет автоматически удалено. Чтобы объект окна автоматически удалялся при закрытии окна, атрибуту
WA_DeleteOnClose в методе setAttribute()
было присвоено значе- ние
True
Модальные окна в большинстве случаев являются диалоговыми. Для работы с такими окнами в PyQt предназначен класс
QDialog
, который автоматически выравнивает окно по центру экрана или родительского окна. Кроме того, этот класс предоставляет множество специальных методов, позволяющих дождаться закрытия окна, определить статус заверше- ния и выполнить другие действия. Подробно класс
QDialog мы рассмотрим в главе 26.
18.9. Смена значка в заголовке окна
По умолчанию в левом верхнем углу окна отображается стандартный значок. Отобразить другой значок позволяет метод setWindowIcon()
класса
QWidget
. В качестве параметра метод принимает экземпляр класса
QIcon из модуля
QtGui
(см. разд. 24.3.4).
Чтобы загрузить значок из файла, следует передать путь к файлу конструктору класса
QIcon
. Если указан относительный путь, поиск файла будет производиться относительно текущего рабочего каталога. Получить список поддерживаемых форматов файлов можно с помощью статического метода supportedImageFormats()
класса
QImageReader
, объявлен- ного в модуле
QtGui
. Метод возвращает список с экземплярами класса
QByteArray
. Получим список поддерживаемых форматов:
>>> from PyQt5 import QtGui
>>> for i in QtGui.QImageReader.supportedImageFormats(): print(str(i, "ascii").upper(), end=" ")
Вот результат выполнения этого примера на компьютере одного из авторов:
BMP CUR GIF ICNS ICO JPEG JPG PBM PGM PNG PPM SVG SVGZ TGA TIF TIFF WBMP WEBP XBM XPM
Если для окна не указать значок, будет использоваться значок приложения, установленный с помощью метода setWindowIcon()
класса
QApplication
. В качестве параметра метод также принимает экземпляр класса
QIcon
Вместо загрузки значка из файла можно воспользоваться одним из встроенных значков.
Загрузить стандартный значок позволяет следующий код: ico = window.style().standardIcon(QtWidgets.QStyle.SP_MessageBoxCritical) window.setWindowIcon(ico)
384
Часть II. Библиотека PyQt 5
Посмотреть список всех встроенных значков можно в документации к классу
QStyle
(см. https://doc.qt.io/qt-5/qstyle.html#StandardPixmap-enum).
В качестве примера создадим значок размером 16 на 16 пикселов в формате PNG и сохра- ним его в одном каталоге с программой, после чего установим этот значок для окна и всего приложения (листинг 18.7).
Листинг 18.7. Смена значка в заголовке окна
# -*- coding: utf-8 -*- from PyQt5 import QtGui, QtWidgets import sys app = QtWidgets.QApplication(sys.argv) window = QtWidgets.QWidget() window.setWindowTitle("Смена значка в заголовке окна") window.resize(300, 100) ico = QtGui.QIcon("icon.png") window.setWindowIcon(ico) # Значок для окна app.setWindowIcon(ico) # Значок приложения window.show() sys.exit(app.exec_())
18.10. Изменение цвета фона окна
Чтобы изменить цвет фона окна (или компонента), следует установить палитру с настроен- ной ролью
Window
(или
Background
). Цветовая палитра содержит цвета для каждой роли и состояния компонента. Указать состояние компонента позволяют следующие атрибуты из класса
QPalette
(модуль
QtGui
):
Active и
Normal
—
0
— компонент активен (окно находится в фокусе ввода);
Disabled
—
1
— компонент недоступен;
Inactive
—
2
— компонент неактивен (окно находится вне фокуса ввода).
Получить текущую палитру компонента позволяет его метод palette()
. Чтобы изменить цвет для какой-либо роли и состояния, следует воспользоваться методом setColor()
класса
QPalette
. Формат метода: setColor([<Состояние>, ]<Роль>, <Цвет>)
В параметре
<Роль>
указывается, для какого элемента изменяется цвет. Например, атрибут
Window
(или
Background
) изменяет цвет фона, а
WindowText
(или
Foreground
) — цвет текста.
Полный список атрибутов имеется в документации по классу
QPalette
(см. https://doc.qt.io/ qt-5/qpalette.html).
В параметре
<Цвет>
указывается цвет элемента. В качестве значения можно указать атрибут из класса
QtCore.Qt
(например, black
, white и т. д.) или экземпляр класса
QColor
(например,
QColor("red")
,
QColor("#ff0000")
,
QColor(255, 0, 0)
и др.).
После настройки палитры необходимо вызвать метод setPalette()
компонента и передать этому методу измененный объект палитры. Следует помнить, что компоненты-потомки по умолчанию имеют прозрачный фон и не перерисовываются автоматически. Чтобы вклю-
Глава 18. Управление окном приложения
385 чить перерисовку, необходимо передать значение
True методу setAutoFillBackground()
окна.
Изменить цвет фона также можно с помощью CSS-атрибута background-color
. Для этого следует передать таблицу стилей в метод setStyleSheet()
компонента. Таблицы стилей могут быть внешними (подключение через командную строку), установленными на уровне приложения (с помощью метода setStyleSheet()
класса
QApplication
) или установленными на уровне компонента (с помощью метода setStyleSheet()
класса
QWidget
). Атрибуты, установленные последними, обычно перекрывают значения аналогичных атрибутов, ука- занных ранее. Если вы занимались веб-программированием, то язык CSS (каскадные табли- цы стилей) вам уже знаком, а если нет, придется дополнительно его изучить.
Создадим окно с надписью. Для активного окна установим зеленый цвет, а для неактивно- го — красный. Цвет фона надписи сделаем белым. Для изменения фона окна используем палитру, а для изменения цвета фона надписи — CSS-атрибут background-color
(лис- тинг 18.8).
Листинг 18.8. Изменение цвета фона окна
# -*- coding: utf-8 -*- from PyQt5 import QtCore, QtGui, QtWidgets import sys app = QtWidgets.QApplication(sys.argv) window = QtWidgets.QWidget() window.setWindowTitle("Изменение цвета фона окна") window.resize(300, 100) pal = window.palette() pal.setColor(QtGui.QPalette.Normal, QtGui.QPalette.Window,
QtGui.QColor("#008800")) pal.setColor(QtGui.QPalette.Inactive, QtGui.QPalette.Window,
QtGui.QColor("#ff0000")) window.setPalette(pal) label = QtWidgets.QLabel("Текст надписи") label.setAlignment(QtCore.Qt.AlignHCenter) label.setStyleSheet("background-color: #ffffff;") label.setAutoFillBackground(True) vbox = QtWidgets.QVBoxLayout() vbox.addWidget(label) window.setLayout(vbox) window.show() sys.exit(app.exec_())
18.11. Вывод изображения в качестве фона
В качестве фона окна (или компонента) можно использовать изображение. Для этого необ- ходимо получить текущую палитру компонента с помощью метода palette()
, а затем вы- звать метод setBrush()
класса
QPalette
. Формат метода: setBrush([<Состояние>, ]<Роль>, )
386
Часть II. Библиотека PyQt 5
Первые два параметра аналогичны соответствующим параметрам в методе setColor()
, ко- торый мы рассматривали в предыдущем разделе. В третьем параметре указывается кисть — экземпляр класса
QBrush из модуля
QtGui
. Форматы конструктора класса:
<Объект> = QBrush(<Стиль кисти>)
<Объект> = QBrush(<Цвет>[, <Стиль кисти>=SolidPattern])
<Объект> = QBrush(<Цвет>, )
<Объект> = QBrush()
<Объект> = QBrush()
<Объект> = QBrush()
<Объект> = QBrush()
В параметре
<Стиль кисти>
указываются атрибуты из класса
QtCore.Qt
, задающие стиль кисти, — например:
NoBrush
,
SolidPattern
,
Dense1Pattern
,
Dense2Pattern
,
Dense3Pattern
,
Dense4Pattern
,
Dense5Pattern
,
Dense6Pattern
,
Dense7Pattern
,
CrossPattern и др. С по- мощью этого параметра можно сделать цвет сплошным (
SolidPattern
) или имеющим тек- стуру (например, атрибут
CrossPattern задает текстуру в виде сетки).
В параметре
<Цвет>
указывается цвет кисти. В качестве значения можно указать атрибут из класса
QtCore.Qt
(например, black
, white и т. д.) или экземпляр класса
QColor
(например,
QColor("red")
,
QColor("#ff0000")
,
QColor(255, 0, 0)
и др.). При этом установка сплошного цвета фона окна может выглядеть так: pal = window.palette() pal.setBrush(QtGui.QPalette.Normal, QtGui.QPalette.Window,
QtGui.QBrush(QtGui.QColor("#008800"), QtCore.Qt.SolidPattern)) window.setPalette(pal)
Параметры
и
позволяют передать объекты изображений. Конструкторы этих классов принимают путь к файлу — абсолютный или относительный.
Параметр
позволяет создать кисть на основе другой кисти, а параметр
— на основе градиента, представленного объектом класса
QGradient
(см. главу 24).
После настройки палитры необходимо вызвать метод setPalette()
и передать ему изме- ненный объект палитры. Следует помнить, что компоненты-потомки по умолчанию имеют прозрачный фон и не перерисовываются автоматически. Чтобы включить перерисовку, не- обходимо передать значение
True в метод setAutoFillBackground()
Указать, какое изображение используется в качестве фона, также можно с помощью CSS- атрибутов background и background-image
. С помощью CSS-атрибута background-repeat можно дополнительно указать режим повтора фонового рисунка. Он может принимать зна- чения repeat
(повтор по горизонтали и вертикали), repeat-x
(повтор только по горизонта- ли), repeat-y
(повтор только по вертикали) и no-repeat
(не повторяется).
Создадим окно с надписью. Для активного окна установим одно изображение (с помощью изменения палитры), а для надписи — другое (с помощью CSS-атрибута background-image
)
(листинг 18.9).
Листинг 18.9. Использование изображения в качестве фона
# -*- coding: utf-8 -*- from PyQt5 import QtCore, QtGui, QtWidgets import sys
Глава 18. Управление окном приложения
387 app = QtWidgets.QApplication(sys.argv) window = QtWidgets.QWidget() window.setWindowTitle("Изображение в качестве фона") window.resize(300, 100) pal = window.palette() pal.setBrush(QtGui.QPalette.Normal, QtGui.QPalette.Window,
QtGui.QBrush(QtGui.QPixmap("background1.jpg"))) window.setPalette(pal) label = QtWidgets.QLabel("Текст надписи") label.setAlignment(QtCore.Qt.AlignCenter) label.setStyleSheet("background-image: url(background2.jpg);") label.setAutoFillBackground(True) vbox = QtWidgets.QVBoxLayout() vbox.addWidget(label) window.setLayout(vbox) window.show() sys.exit(app.exec_())
18.12. Создание окна произвольной формы
Чтобы создать окно произвольной формы, нужно выполнить следующие шаги:
1. Создать изображение нужной формы с прозрачным фоном и сохранить его, например, в формате PNG.
2. Создать экземпляр класса
QPixmap
, передав конструктору класса абсолютный или отно- сительный путь к изображению.
3. Установить изображение в качестве фона окна с помощью палитры.
4. Отделить альфа-канал с помощью метода mask()
класса
QPixmap
5. Передать получившуюся маску в метод setMask()
окна.
6. Убрать рамку окна, например, передав комбинацию следующих флагов:
QtCore.Qt.Window | QtCore.Qt.FramelessWindowHint
Если для создания окна используется класс
QLabel
, то вместо установки палитры можно передать экземпляр класса
QPixmap в метод setPixmap()
, а маску — в метод setMask()
Для примера создадим круглое окно с кнопкой, с помощью которой можно закрыть окно.
Для использования в качестве маски создадим изображение в формате PNG, установим для него прозрачный фон и нарисуем белый круг, занимающий все это изображение. Окно выведем без заголовка и границ (листинг 18.10).
Листинг 18.10. Создание окна произвольной формы
# -*- coding: utf-8 -*- from PyQt5 import QtCore, QtGui, QtWidgets import sys app = QtWidgets.QApplication(sys.argv) window = QtWidgets.QWidget() window.setWindowFlags(QtCore.Qt.Window | QtCore.Qt.FramelessWindowHint)
388
Часть II. Библиотека PyQt 5 window.setWindowTitle("Создание окна произвольной формы") window.resize(300, 300) pixmap = QtGui.QPixmap("mask.png") pal = window.palette() pal.setBrush(QtGui.QPalette.Normal, QtGui.QPalette.Window,
QtGui.QBrush(pixmap)) pal.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Window,
QtGui.QBrush(pixmap)) window.setPalette(pal) window.setMask(pixmap.mask()) button = QtWidgets.QPushButton("Закрыть окно", window) button.setFixedSize(150, 30) button.move(75, 135) button.clicked.connect(QtWidgets.qApp.quit) window.show() sys.exit(app.exec_())
Получившееся окно можно увидеть на рис. 18.1.
Рис. 18.1. Окно круглой формы
18.13. Всплывающие подсказки
При работе с программой у пользователя могут возникать вопросы о предназначении того или иного компонента. Обычно для информирования пользователя служат надписи, распо- ложенные над компонентом или левее его. Но часто либо место в окне ограничено, либо вывод этих надписей портит весь дизайн окна. В таких случаях принято выводить текст подсказки в отдельном окне без рамки при наведении указателя мыши на компонент. Под- сказка автоматически скроется после увода курсора мыши или спустя определенное время.
В PyQt нет необходимости создавать окно с подсказкой самому и следить за перемещения- ми указателя мыши — весь этот процесс автоматизирован и максимально упрощен. Чтобы создать всплывающие подсказки для окна или любого другого компонента и управлять ими, нужно воспользоваться следующими методами класса
QWidget
:
Глава 18. Управление окном приложения
389
setToolTip(<Текст>)
— задает текст всплывающей подсказки. В качестве параметра можно указать простой текст или HTML-код. Чтобы отключить вывод подсказки, доста- точно передать в этот метод пустую строку;
toolTip()
— возвращает текст всплывающей подсказки;
setToolTipDuration(<Время>)
— задает время, в течение которого всплывающая под- сказка будет присутствовать на экране. Значение должно быть указано в миллисекундах.
Если задать значение
-1
, PyQt будет сама вычислять необходимое время, основываясь на длине текста подсказки (это поведение по умолчанию);
toolTipDuration()
— возвращает время, в течение которого всплывающая подсказка будет присутствовать на экране;
setWhatsThis(<Текст>)
— задает текст справки. Обычно этот метод используется для вывода информации большего объема, чем во всплывающей подсказке. У диалоговых окон в заголовке окна есть кнопка Справка, по нажатию которой курсор принимает вид стрелки со знаком вопроса, — чтобы в таком случае отобразить текст справки, следует нажать эту кнопку и щелкнуть на компоненте. Можно также сделать компонент актив- ным и нажать комбинацию клавиш +. В качестве параметра можно указать простой текст или HTML-код. Чтобы отключить вывод подсказки, достаточно передать в этот метод пустую строку;
whatsThis()
— возвращает текст справки.
Создадим окно с кнопкой и зададим для них текст всплывающих подсказок и текст справки
(листинг 18.11).
Листинг 18.11. Всплывающие подсказки
# -*- coding: utf-8 -*- from PyQt5 import QtCore, QtWidgets import sys app = QtWidgets.QApplication(sys.argv) window = QtWidgets.QWidget(flags=QtCore.Qt.Dialog) window.setWindowTitle("Всплывающие подсказки") window.resize(300, 70) button = QtWidgets.QPushButton("Закрыть окно", window) button.setFixedSize(150, 30) button.move(75, 20) button.setToolTip("Это всплывающая подсказка для кнопки") button.setToolTipDuration(3000) window.setToolTip("Это всплывающая подсказка для окна") button.setToolTipDuration(5000) button.setWhatsThis("Это справка для кнопки") window.setWhatsThis("Это справка для окна") button.clicked.connect(QtWidgets.qApp.quit) window.show() sys.exit(app.exec_())
390
Часть II. Библиотека PyQt 5 18.14. Программное закрытие окна
В предыдущих разделах для закрытия окна мы использовали слот quit() и метод exit([returnCode=0])
объекта приложения. Однако эти методы не только закрывают теку- щее окно, но и завершают выполнение всего приложения. Чтобы закрыть только текущее окно, следует воспользоваться методом close()
класса
QWidget
. Метод возвращает значение
True
, если окно успешно закрыто, и
False
— в противном случае. Закрыть сразу все окна приложения позволяет слот closeAllWindows()
класса
QApplication
Если для окна атрибут
WA_DeleteOnClose из класса
QtCore.Qt установлен в значение
True
, после закрытия окна объект окна будет автоматически удален, в противном случае окно просто скрывается. Значение атрибута можно изменить с помощью метода setAttribute()
: window.setAttribute(QtCore.Qt.WA_DeleteOnClose, True)
После вызова метода close()
или нажатия кнопки Закрыть в заголовке окна генерируется событие
QEvent.Close
. Если внутри класса определить метод с предопределенным названи- ем closeEvent()
, это событие можно перехватить и обработать. В качестве параметра метод принимает объект класса
QCloseEvent
, который поддерживает методы accept()
(позволяет закрыть окно) и ignore()
(запрещает закрытие окна). Вызывая эти методы, можно контро- лировать процесс закрытия окна.
В качестве примера закроем окно по нажатию кнопки (листинг 18.12).
Листинг 18.12. Программное закрытие окна
# -*- coding: utf-8 -*- from PyQt5 import QtCore, QtWidgets import sys app = QtWidgets.QApplication(sys.argv) window = QtWidgets.QWidget(flags=QtCore.Qt.Dialog) window.setWindowTitle("Закрытие окна из программы") window.resize(300, 70) button = QtWidgets.QPushButton("Закрыть окно", window) button.setFixedSize(150, 30) button.move(75, 20) button.clicked.connect(window.close) window.show() sys.exit(app.exec_())
П
РИМЕЧАНИЕ
Закрыв последнее окно приложения, мы тем самым автоматически завершим и само при- ложение. Не забываем об этом.
18.15. Использование таблиц стилей CSS для оформления окон
Вернемся к методу setStyleSheet()
, упомянутому в разд. 18.10 и предназначенному для задания таблиц стилей у приложений и отдельных элементов управления. С помощью таб- лиц стилей можно задавать не только цвет фона и фоновое изображение, но и другие пара- метры оформления.
Глава 18. Управление окном приложения
391
Метод setStyleSheet()
поддерживается классами
QWidget
(и всеми его подклассами) и
QApplication
. Следовательно, его можно вызвать у:
самого приложения — тогда заданные в таблице стилей параметры оформления будут применены ко всем элементам управления всех окон приложения;
отдельного окна — тогда эти параметры будут действовать в пределах данного окна;
отдельного элемента управления — тогда они будут действовать только на этот элемент управления.
При указании таблицы стилей у приложения и окна можно использовать привычный нам по
CSS формат объявления стилей:
<Селектор> {<Определение стилей>}
<Селектор>
записывается в следующем формате:
<Основной селектор>[<Дополнительный селектор>][<Псевдокласс>][<Псевдоселектор>]
Параметр
<Основной селектор>
указывает на класс элемента управления. Его можно указать в одном из следующих форматов:
*
(звездочка) — указывает на все элементы управления (универсальный селектор). На- пример, так можно задать для всех элементов управления зеленый цвет текста:
* {color: green;}
<Класс>
— указывает на элементы управления, относящиеся к заданному
<Классу>
и его подклассам. Задание красного цвета текста для всех элементов управления, относящихся к классу
QAbstractButton и его подклассам, т. е. для командных кнопок,
флажков и пе- реключателей, осуществляется так:
QAbstractButton {color: red;}
.<Класс>
— указывает только на элементы управления, относящиеся к заданному
<Классу>
, но не к его подклассам. Указание полужирного шрифта для всех элементов управления, относящихся к классу
QPushButton
(командных кнопок), но не для его под- классов, осуществляется так:
.QPushButton {font-weight: bold;}
Параметр
<Дополнительный селектор>
задает дополнительные параметры элемента управле- ния. Его форматы:
[<Свойство>="<Значение>"]
— указанное
<Свойство>
элемента управления должно иметь заданное
<Значение>
. Так мы задаем полужирный шрифт для кнопки, чье свойство default имеет значение true
, т. е. для кнопки по умолчанию:
QPushButton[default="true"] {font-weight: bold;}
#<Имя>
— указывает на элемент управления, для которого было задано
<Имя>
<Имя>
можно задать вызовом у элемента управления метода setObjectName(<Имя>)
, а полу- чить — вызовом метода objectName()
. Так выполняется указание красного цвета текста для кнопки с именем btnRed
:
QPushButton#btnRed {color: red;}
Параметр
<Псевдокласс>
указывает на отдельную составную часть сложного элемента управления. Он записывается в формате
::<Обозначение составной части>
. Вот пример ука- зания графического изображения для кнопки разворачивания раскрывающегося списка
(обозначение этой составной части — down-arrow
):
QComboBox::down-arrow {image: url(arrow.png);}
392
Часть II. Библиотека PyQt 5
Параметр
<Псевдоселектор>
указывает на состояние элемента управления (должна ли быть кнопка нажата, должен ли флажок быть установленным и т. п.). Он может быть записан в двух форматах:
:<Обозначение состояния>
— элемент управления должен находиться в указанном со- стоянии. Вот пример указания белого цвета фона для кнопки, когда она нажата (это состояние имеет обозначение pressed
):
QPushButton:pressed {background-color: white;}
:!<Обозначение состояния>
— элемент управления должен находиться в любом состоя- нии, кроме указанного. Вот пример указания желтого цвета фона для кнопки, когда она не нажата:
QPushButton:!pressed {background-color: yellow;}
Можно указать сразу несколько псевдоселекторов, расположив их непосредственно друг за другом — тогда селектор будет указывать на элемент управления, находящийся одно- временно во всех состояниях, которые обозначены этими селекторами. Вот пример ука- зания черного цвета фона и белого цвета текста для кнопки, которая нажата и над кото- рой находится курсор мыши (обозначение — hover
):
QPushButton:pressed:hover {color: white; background-color: black;}
Если нужно указать стиль для элемента управления, вложенного в другой элемент управле- ния, применяется следующий формат указания селектора:
<Селектор "внешнего" элемента><Разделитель><Селектор вложенного элемента>
Поддерживаются два варианта параметра
<Разделитель>
:
пробел —
<Вложенный элемент>
не обязательно должен быть вложен непосредственно во
<"Внешний">
. Так мы указываем зеленый цвет фона для всех надписей (
QLabel
), вложен- ных в группу (
QGroupBox
) и вложенные в нее элементы:
QGroupBox QLabel {background-color: green;}
>
—
<Вложенный элемент>
обязательно должен быть вложен непосредственно во
<"Внеш- ний">
. Так мы укажем синий цвет текста для всех надписей, непосредственно вложенных в группу:
QGroupBox>QLabel {color: blue;}
В стиле можно указать сразу несколько селекторов, записав их через запятую — тогда стиль будет применен к элементам управления, на которые указывают эти селекторы. Вот пример задания зеленого цвета фона для кнопок и надписей:
QLabel, QPushButton {background-color: green;}
В CSS элементы страницы наследуют параметры оформления от их родителей. Но в PyQt это не так. Скажем, если мы укажем для группы красный цвет текста: app.setStyleSheet("QGroupBox {color: red;}") вложенные в эту группу элементы не унаследуют его и будут иметь цвет текста, заданный по умолчанию. Нам придется задать для них нужный цвет явно: app.setStyleSheet("QGroupBox, QGroupBox * {color: red;}")
Начиная с версии PyQt 5.7, поддерживается возможность указать библиотеке, что все элементы-потомки должны наследовать параметры оформления у родителя. Для этого дос- таточно вызвать у класса
QCoreApplication статический метод setAttribute
, передав ему
Глава 18. Управление окном приложения
393 в качестве первого параметра значение атрибута
AA_UseStyleSheetPropagationInWidgetStyles класса
QtCore.Qt
, а в качестве второго параметра — значение
True
:
QtCore.QCoreApplication.setAttribute(
QtCore.Qt.AA_UseStyleSheetPropagationInWidgetStyles, True)
Чтобы отключить такую возможность, достаточно вызвать этот метод еще раз, указав в нем вторым параметром
False
И, наконец, при вызове метода setStyleSheet()
у элемента управления, для которого следу- ет задать таблицу стилей, в последней не указываются ни селектор, ни фигурные скобки — они просто не нужны.
Отметим, что в случае PyQt, как и в CSS, также действуют правила каскадности. Так, таб- лица стилей, заданная для окна, имеет больший приоритет, нежели таковая, указанная для приложения, а стиль, что был задан для элемента управления, имеет наивысший приоритет.
Помимо этого, более специфические стили имеют больший приоритет, чем менее специфи- ческие; так, стиль с селектором, в чей состав входит имя элемента управления, перекроет стиль с селектором любого другого типа.
За более подробным описанием поддерживаемых PyQt псевдоклассов, псевдоселекторов и особенностей указания стилей для отдельных классов элементов управления обращайтесь по интернет-адресу https://doc.qt.io/qt-5/stylesheet-reference.html.
Листинг 18.13 показывает пример задания таблиц стилей для элементов управления разны- ми способами. Результат выполнения приведенного в нем кода можно увидеть на рис. 18.2.
Листинг 18.13. Использование таблиц стилей для указания оформления
# -*- coding: utf-8 -*- from PyQt5 import QtWidgets import sys app = QtWidgets.QApplication(sys.argv)
# На уровне приложения задаем синий цвет текста для надписей, вложенных в группы,
# и курсивное начертание текста кнопок app.setStyleSheet("QGroupBox QLabel {color: blue;}
QPushButton {font-style: italic}") window = QtWidgets.QWidget() window.setWindowTitle("Таблицы стилей")
# На уровне окна задаем зеленый цвет текста для надписи с именем first и
#
красный цвет текста для надписи, на которую наведен курсор мыши window.setStyleSheet("QLabel#first {color: green;} QLabel:hover {color: red;}") window.resize(200, 150)
# Создаем три надписи lbl1 = QtWidgets.QLabel("Зеленый текст")
# Указываем для первой надписи имя first lbl1.setObjectName("first") lbl2 = QtWidgets.QLabel("Полужирный текст")
# Для второй надписи указываем полужирный шрифт lbl2.setStyleSheet("font-weight: bold") lbl3 = QtWidgets.QLabel("Синий текст")
# Создаем кнопку btn = QtWidgets.QPushButton("Курсивный текст")
394
Часть II. Библиотека PyQt 5
# Создаем группу box = QtWidgets.QGroupBox("Группа")
# Создаем контейнер, помещаем в него третью надпись и вставляем в группу bbox = QtWidgets.QVBoxLayout() bbox.addWidget(lbl3) box.setLayout(bbox)
# Создаем еще один контейнер, помещаем в него две первые надписи, группу и кнопку и
# вставляем в окно mainbox = QtWidgets.QVBoxLayout() mainbox.addWidget(lbl1) mainbox.addWidget(lbl2) mainbox.addWidget(box) mainbox.addWidget(btn) window.setLayout(mainbox)
# Выводим окно и запускаем приложение window.show() sys.exit(app.exec_())
Рис. 18.2. Пример использования таблиц стилей
ГЛ А В А
19
Обработка сигналов и событий
При взаимодействии пользователя с окном возникают события — своего рода извещения о том, что пользователь выполнил какое-либо действие или в самой системе возникло неко- торое условие. В ответ на события система генерирует определенные сигналы, которые можно рассматривать как представления системных событий внутри библиотеки PyQt.
Сигналы являются важнейшей составляющей приложения с графическим интерфейсом, поэтому необходимо знать, как назначить обработчик сигнала, как удалить его, а также уметь правильно обработать событие. Сигналы, которые генерирует тот или иной компо- нент, мы будем рассматривать при изучении конкретного компонента.
19.1. Назначение обработчиков сигналов
Чтобы обработать какой-либо сигнал, необходимо сопоставить ему функцию или метод класса, который будет вызван при возникновении события и станет его обработчиком.
Каждый сигнал, поддерживаемый классом, соответствует одноименному атрибуту этого класса (отметим, что это именно атрибуты класса, а не атрибуты экземпляра). Так, сигнал clicked
, генерируемый при щелчке мышью, соответствует атрибуту clicked
. Каждый такой атрибут хранит экземпляр особого класса, представляющего соответствующий сигнал.
Чтобы назначить сигналу обработчик, следует использовать метод connect()
, унаследован- ный от класса
QObject
. Форматы вызова этого метода таковы:
<Компонент>.<Сигнал>.connect(<Обработчик>[, <Тип соединения>])
<Компонент>.<Сигнал>[<Тип>].connect(<Обработчик>[, <Тип соединения>])
Здесь мы назначаем
<Обработчик>
для параметра
<Сигнал>
, генерируемого параметром
<Компонент>
. В качестве обработчика можно указать:
ссылку на пользовательскую функцию;
ссылку на метод класса;
ссылку на экземпляр класса, в котором определен метод
__call__()
;
анонимную функцию;
ссылку на слот класса.
Вот пример назначения функции on_clicked_button()
в качестве обработчика сигнала clicked кнопки button
: button.clicked.connect(on_clicked_button)
396
Часть II. Библиотека PyQt 5
Сигналы могут принимать произвольное число параметров, каждый из которых может от- носиться к любому типу данных. При этом бывает и так, что в классе существуют два сиг- нала с одинаковыми наименованиями, но разными наборами параметров. Тогда следует дополнительно в квадратных скобках указать
<Тип>
данных, принимаемых сигналом, — либо просто написав его наименование, либо задав его в виде строки. Например, оба сле- дующих выражения назначают обработчик сигнала, принимающего один параметр логиче- ского типа: button.clicked[bool].connect(on_clicked_button) button.clicked["bool"].connect(on_clicked_button)
Одному и тому же сигналу можно назначить произвольное количество обработчиков. Это иллюстрирует код из листинга 19.1, где сигналу clicked кнопки назначены сразу четыре обработчика.
Листинг 19.1. Назначение сигналу нескольких обработчиков
# -*- coding: utf-8 -*- from PyQt5 import QtWidgets import sys def on_clicked(): print("Кнопка нажата. Функция on_clicked()") class MyClass(): def __init__(self, x=0): self.x = x def __call__(self): print("Кнопка нажата. Метод MyClass.__call__()") print("x =", self.x) def on_clicked(self): print("Кнопка нажата. Метод MyClass.on_clicked()") obj = MyClass() app = QtWidgets.QApplication(sys.argv) button = QtWidgets.QPushButton("Нажми меня")
# Назначаем обработчиком функцию button.clicked.connect(on_clicked)
# Назначаем обработчиком метод класса button.clicked.connect(obj.on_clicked)
# Назначаем обработчиком ссылку на экземпляр класса button.clicked.connect(MyClass(10))
# Назначаем обработчиком анонимную функцию button.clicked.connect(lambda: MyClass(5)()) button.show() sys.exit(app.exec_())
В четвертом обработчике мы использовали анонимную функцию. В ней мы сначала создаем объект класса
MyClass
, передав ему в качестве параметра число
5
, после чего сразу же вы- зываем его как функцию, указав после конструктора пустые скобки: button.clicked.connect(lambda: MyClass(5)())
Глава 19. Обработка сигналов и событий
397
Результат выполнения в окне консоли при щелчке на кнопке:
Кнопка нажата. Функция on_clicked()
Кнопка нажата. Метод MyClass.on_clicked()
Кнопка нажата. Метод MyClass.__call__() x = 10
Кнопка нажата. Метод MyClass.__call__() x = 5
Классы PyQt 5 поддерживают ряд методов, специально предназначенных для использова- ния в качестве обработчиков сигналов. Такие методы называются слотами. Например, класс
QApplication поддерживает слот quit()
, завершающий текущее приложение. В лис- тинге 19.2 показан код, использующий этот слот.
Листинг 19.2. Использование слота
# -*- coding: utf-8 -*- from PyQt5 import QtWidgets import sys app = QtWidgets.QApplication(sys.argv) button = QtWidgets.QPushButton("Завершить работу") button.clicked.connect(app.quit) button.show() sys.exit(app.exec_())
Любой пользовательский метод можно сделать слотом, для чего необходимо перед его оп- ределением вставить декоратор
@pyqtSlot()
. Формат декоратора:
@QtCore.pyqtSlot(*<Типы данных>, name=None, result=None)
В параметре
<Типы данных>
через запятую указываются типы данных параметров, прини- маемых слотом, — например: bool или int
. При задании типа данных C++ его название не- обходимо указать в виде строки. Если метод не принимает параметров, параметр
<Типы дан- ных>
не указывается. В именованном параметре name можно передать название слота в виде строки — это название станет использоваться вместо названия метода, а если параметр name не задан, название слота будет совпадать с названием метода. Именованный параметр result предназначен для указания типа данных, возвращаемых методом, — если параметр не задан, то метод ничего не возвращает. Чтобы создать перегруженную версию слота, декоратор указывается последовательно несколько раз с разными типами данных. Пример использования декоратора
@pyqtSlot()
приведен в листинге 19.3.
Листинг 19.3. Использование декоратора
@pyqtSlot()
# -*- coding: utf-8 -*- from PyQt5 import QtCore, QtWidgets import sys class MyClass(QtCore.QObject): def __init__(self):
QtCore.QObject.__init__(self)
398
Часть II. Библиотека PyQt 5
@QtCore.pyqtSlot() def on_clicked(self): print("Кнопка нажата. Слот on_clicked()")
@QtCore.pyqtSlot(bool, name="myslot") def on_clicked2(self, status): print("Кнопка нажата. Слот myslot(bool)", status) obj = MyClass() app = QtWidgets.QApplication(sys.argv) button = QtWidgets.QPushButton("Нажми меня") button.clicked.connect(obj.on_clicked) button.clicked.connect(obj.myslot) button.show() sys.exit(app.exec_())
PyQt не требует обязательного превращения в слот метода, который будет использоваться как обработчик сигнала. Однако это рекомендуется сделать, т. к. вызов слота в этом случае выполняется быстрее, чем вызов обычного метода.
Необязательный параметр
<Тип соединения>
метода connect()
определяет тип соединения между сигналом и обработчиком. На этот параметр следует обратить особое внимание при использовании в приложении нескольких потоков, т. к. изменять GUI-поток из другого потока нельзя. В параметре можно указать один из следующих атрибутов класса
QtCore.Qt
:
AutoConnection
—
0
— значение по умолчанию. Если источник сигнала и обработчик находятся в одном потоке, то оно эквивалентно значению
DirectConnection
, а если в разных потоках, то —
QueuedConnection
;
DirectConnection
—
1
— обработчик вызывается сразу после генерации сигнала и вы- полняется в потоке его источника;
QueuedConnection
—
2
— сигнал помещается в очередь обработки событий, а его обра- ботчик выполняется в потоке приемника сигнала;
BlockingQueuedConnection
—
4
— аналогично значению
QueuedConnection за тем исклю- чением, что поток блокируется на время обработки сигнала. Обратите внимание, что ис- точник и обработчик сигнала обязательно должны быть расположены в разных потоках;
UniqueConnection
—
0x80
— указывает, что обработчик можно назначить только один раз. Этот атрибут с помощью оператора
| может быть объединен с любым из представ- ленных ранее флагов:
# Эти два обработчика будут успешно назначены и выполнены button.clicked.connect(on_clicked) button.clicked.connect(on_clicked)
# А эти два обработчика назначены не будут button.clicked.connect(on_clicked, Qt.Core.Qt.AutoConnection |
QtCore.Qt.UniqueConnection) button.clicked.connect(on_clicked, Qt.Core.Qt.AutoConnection |
QtCore.Qt.UniqueConnection)
# Тем не менее, эти два обработчика будут назначены, поскольку они разные button.clicked.connect(on_clicked, Qt.Core.Qt.AutoConnection |
QtCore.Qt.UniqueConnection) button.clicked.connect(obj.on_clicked, Qt.Core.Qt.AutoConnection |
QtCore.Qt.UniqueConnection)
Глава 19. Обработка сигналов и событий
399 19.2. Блокировка и удаление обработчика
Для блокировки и удаления обработчиков предназначены следующие методы класса
QObject
:
blockSignals(<Флаг>)
— временно блокирует прием сигналов, если параметр имеет зна- чение
True
, и снимает блокировку, если параметр имеет значение
False
. Метод возвра- щает логическое представление предыдущего состояния соединения;
signalsBlocked()
— возвращает значение
True
, если блокировка сигналов установлена, и
False
— в противном случае;
disconnect()
— удаляет обработчик. Форматы метода:
<Компонент>.<Сигнал>.disconnect([<Обработчик>])
<Компонент>.<Сигнал>[<Тип>].disconnect([<Обработчик>])
Если параметр
<Обработчик>
не указан, удаляются все обработчики, назначенные ранее, в противном случае удаляется только указанный обработчик. Параметр
<Тип>
указывает- ся лишь в том случае, если существуют сигналы с одинаковыми именами, но прини- мающие разные параметры: button.clicked.disconnect() button.clicked[bool].disconnect(on_clicked_button) button.clicked["bool"].disconnect(on_clicked_button)
Создадим окно с четырьмя кнопками (листинг 19.4). Для кнопки Нажми меня назначим обработчик сигнала clicked
. Чтобы информировать о нажатии кнопки, выведем сообщение в окно консоли. Для кнопок Блокировать, Разблокировать и Удалить обработчик созда- дим обработчики, которые будут изменять статус обработчика для кнопки Нажми меня.
Листинг 19.4. Блокировка и удаление обработчика
# -*- coding: utf-8 -*- from PyQt5 import QtCore, QtWidgets class MyWindow(QtWidgets.QWidget): def __init__(self, parent=None):
QtWidgets.QWidget.__init__(self, parent) self.setWindowTitle("Блокировка и удаление обработчика") self.resize(300, 150) self.button1 = QtWidgets.QPushButton("Нажми меня") self.button2 = QtWidgets.QPushButton("Блокировать") self.button3 = QtWidgets.QPushButton("Разблокировать") self.button4 = QtWidgets.QPushButton("Удалить обработчик") self.button3.setEnabled(False) vbox = QtWidgets.QVBoxLayout() vbox.addWidget(self.button1) vbox.addWidget(self.button2) vbox.addWidget(self.button3) vbox.addWidget(self.button4) self.setLayout(vbox) self.button1.clicked.connect(self.on_clicked_button1)
400
Часть II. Библиотека PyQt 5 self.button2.clicked.connect(self.on_clicked_button2) self.button3.clicked.connect(self.on_clicked_button3) self.button4.clicked.connect(self.on_clicked_button4)
@QtCore.pyqtSlot() def on_clicked_button1(self): print("Нажата кнопка button1")
@QtCore.pyqtSlot() def on_clicked_button2(self): self.button1.blockSignals(True) self.button2.setEnabled(False) self.button3.setEnabled(True)
@QtCore.pyqtSlot() def on_clicked_button3(self): self.button1.blockSignals(False) self.button2.setEnabled(True) self.button3.setEnabled(False)
@QtCore.pyqtSlot() def on_clicked_button4(self): self.button1.clicked.disconnect(self.on_clicked_button1) self.button2.setEnabled(False) self.button3.setEnabled(False) self.button4.setEnabled(False) if __name__ == "__main__": import sys app = QtWidgets.QApplication(sys.argv) window = MyWindow() window.show() sys.exit(app.exec_())
Если нажать кнопку Нажми меня, в окно консоли будет выведена строка
Нажата кнопка button1
. Нажатие кнопки Блокировать производит блокировку обработчика — теперь при нажатии кнопки Нажми меня никаких сообщений в окно консоли не выводится. Отменить блокировку можно с помощью кнопки Разблокировать. Нажатие кнопки Удалить обра- ботчик производит полное удаление обработчика — в этом случае, чтобы обрабатывать нажатие кнопки Нажми меня, необходимо заново назначить обработчик.
Также можно отключить генерацию сигнала, сделав компонент недоступным с помощью следующих методов из класса
QWidget
:
setEnabled(<Флаг>)
— если в параметре указано значение
False
, компонент станет не- доступным. Чтобы сделать компонент опять доступным, следует передать значение
True
;
setDisabled(<Флаг>)
— если в параметре указано значение
True
, компонент станет не- доступным. Чтобы сделать компонент опять доступным, следует передать значение
False
Проверить, доступен компонент или нет, позволяет метод isEnabled()
. Он возвращает зна- чение
True
,
если компонент доступен, и
False
— в противном случае.
Глава 19. Обработка сигналов и событий
401 19.3. Генерация сигналов
В некоторых случаях необходимо сгенерировать сигнал программно. Например, при запол- нении последнего текстового поля и нажатии клавиши можно имитировать нажатие кнопки ОK и тем самым выполнить подтверждение ввода пользователя. Осуществить гене- рацию сигнала из программы позволяет метод emit()
класса
QObject
. Форматы этого ме- тода:
<Компонент>.<Сигнал>.emit([<Данные>])
<Компонент>.<Сигнал>[<Тип>].emit([<Данные>])
Метод emit()
всегда вызывается у объекта, которому посылается сигнал: button.clicked.emit()
Сигналу и, соответственно, его обработчику можно передать данные, указав их в вызове метода emit()
: button.clicked[bool].emit(False) button.clicked["bool"].emit(False)
Также мы можем создавать свои собственные сигналы. Для этого следует определить в классе атрибут, чье имя совпадет с наименованием сигнала. Отметим, что это должен быть атрибут класса, а не экземпляра. Далее мы присвоим вновь созданному атрибуту результат, возвращенный функцией pyqtSignal()
из модуля
QtCore
. Формат функции:
<Объект сигнала> = pyqtSignal(*<Типы данных>[, name=<Имя сигнала>])
В параметре
<Типы данных>
через запятую указываются названия типов данных, передавае- мых сигналу, — например: bool или int
: mysignal1 = QtCore.pyqtSignal(int) mysignal2 = QtCore.pyqtSignal(int, str)
При использовании типа данных C++ его название необходимо указать в виде строки: mysignal3 = QtCore.pyqtSignal("QDate")
Если сигнал не принимает параметров, параметр
<Типы данных>
не указывается.
Сигнал может иметь несколько перегруженных версий, различающихся количеством и типом принимаемых параметров. В этом случае типы параметров указываются внутри квадратных скобок. Вот пример сигнала, передающего данные типа int или str
: mysignal4 = QtCore.pyqtSignal([int], [str])
По умолчанию название создаваемого сигнала будет совпадать с названием атрибута клас- са. Однако мы можем указать для сигнала другое название, после чего он будет доступен под двумя названиями: совпадающим с именем атрибута класса и заданным нами. Для ука- зания названия сигнала применяется параметр name
: mysignal = QtCore.pyqtSignal(int, name="mySignal")
В качестве примера создадим окно с двумя кнопками (листинг 19.5), которым назначим обработчики сигнала clicked
(нажатие кнопки). Внутри обработчика щелчка на первой кнопке сгенерируем два сигнала: первый будет имитировать нажатие второй кнопки, а вто- рой станет пользовательским, привязанным к окну. Внутри обработчиков выведем сообще- ния в окно консоли.
402
Часть II. Библиотека PyQt 5
Листинг 19.5. Генерация сигнала из программы
# -*- coding: utf-8 -*- from PyQt5 import QtCore, QtWidgets class MyWindow(QtWidgets.QWidget): mysignal = QtCore.pyqtSignal(int, int) def __init__(self, parent=None):
QtWidgets.QWidget.__init__(self, parent) self.setWindowTitle("Генерация сигнала из программы") self.resize(300, 100) self.button1 = QtWidgets.QPushButton("Нажми меня") self.button2 = QtWidgets.QPushButton("Кнопка 2") vbox = QtWidgets.QVBoxLayout() vbox.addWidget(self.button1) vbox.addWidget(self.button2) self.setLayout(vbox) self.button1.clicked.connect(self.on_clicked_button1) self.button2.clicked.connect(self.on_clicked_button2) self.mysignal.connect(self.on_mysignal) def on_clicked_button1(self): print("Нажата кнопка button1")
# Генерируем сигналы self.button2.clicked[bool].emit(False) self.mysignal.emit(10, 20) def on_clicked_button2(self): print("Нажата кнопка button2") def on_mysignal(self, x, y): print("Обработан пользовательский сигнал mysignal()") print("x =", x, "y =", y) if __name__ == "__main__": import sys app = QtWidgets.QApplication(sys.argv) window = MyWindow() window.show() sys.exit(app.exec_())
Результат выполнения после нажатия первой кнопки:
Нажата кнопка button1
Нажата кнопка button2
Обработан пользовательский сигнал mysignal() x = 10 y = 20
Вместо конкретного типа принимаемого сигналом параметра можно указать тип
QVariant из модуля
QtCore
. В этом случае при генерации сигнала допускается передавать ему данные любого типа. Вот пример создания и генерирования сигнала, принимающего параметр любого типа: mysignal = QtCore.pyqtSignal(QtCore.QVariant) self.mysignal.emit(20)
Глава 19. Обработка сигналов и событий
403 self.mysignal.emit("Привет!") self.mysignal.emit([1, "2"])
Сгенерировать сигнал можно не только с помощью метода emit()
. Некоторые компоненты предоставляют методы, которые посылают сигнал. Например, у кнопок существует метод click()
. Используя этот метод, инструкцию: button.clicked.emit() можно записать следующим образом: button.click()
Более подробно такие методы мы будем рассматривать при изучении конкретных компо- нентов.
19.4. Передача данных в обработчик
При назначении обработчика в метод connect()
передается ссылка на функцию или метод.
Если после названия функции (метода) указать внутри круглых скобок какой-либо пара- метр, то это приведет к вызову функции (метода) и вместо ссылки будет передан результат ее выполнения, что вызовет ошибку. Передать данные в обработчик можно следующими способами:
создать анонимную функцию и внутри ее выполнить вызов обработчика с параметрами.
Вот пример передачи обработчику числа
10
: self.button1.clicked.connect(lambda : self.on_clicked_button1(10))
Если передаваемое обработчику значение вычисляется в процессе выполнения кода, переменную, хранящую это значение, следует указывать в анонимной функции как зна- чение по умолчанию, иначе функции будет передана ссылка на это значение, а не оно само: y = 10 self.button1.clicked.connect(lambda x=y: self.on_clicked_button1(x))
передать ссылку на экземпляр класса, внутри которого определен метод
__call__()
Передаваемое значение указывается в качестве параметра конструктора этого класса: class MyClass(): def __init__(self, x=0): self.x = x def __call__(self): print("x =", self.x) self.button1.clicked.connect(MyClass(10))
передать ссылку на обработчик и данные в функцию partial()
из модуля functools
Формат функции: partial(<Функция>[, *<Неименованные параметры>][, **<Именованные параметры>])
Пример передачи параметра в обработчик: from functools import partial self.button1.clicked.connect(partial(self.on_clicked_button1, 10))
404
Часть II. Библиотека PyQt 5
Если при генерации сигнала передается предопределенное значение, то оно будет дос- тупно в обработчике после остальных параметров. Назначим обработчик сигнала clicked
, принимающего логический параметр, и дополнительно передадим число: self.button1.clicked.connect(partial(self.on_clicked_button1, 10))
Обработчик будет иметь следующий вид: def on_clicked_button1(self, x, status): print("Нажата кнопка button1", x, status)
Результат выполнения:
Нажата кнопка button1 10 False
19.5. Использование таймеров
Таймеры позволяют через заданный интервал времени выполнять метод с предопределен- ным названием timerEvent()
. Для назначения таймера используется метод startTimer()
класса
QObject
. Формат метода:
Скачать 7.92 Mb.