Установка текущего окна заголовка

Обновлено: 06.05.2024

Цитатник веб-разработчиков В тексте курса вы встретите цитаты, высказанные в разное время разработчиками системы и разработчиками проектов на базе Bitrix Framework. Надеемся, что такие неформальные замечания внесут некоторое разнообразие в процесс изучения. Заодно опытные специалисты поделятся и своим опытом.

Имена авторов цитат даются в том написании, в каком авторы зарегистрировали себя на сайте "1С-Битрикс". .

Курс для разработчиков - продолжение линейки учебных курсов по Bitrix Framework. Получение сертификата по курсу рекомендуется после успешной сдачи тестов по всей линейке курсов, так как без понятия о работе Контент-менеджера и Администратора создание успешных сайтов будет затруднено.

Чтобы научиться программировать в Bitrix Framework, нет необходимости изучать всю линейку курсов. Но есть моменты, которые необходимо знать разработчикам о системе, они раскрыты в начальных курсах:

Интерфейс программы - в главе Элементы управления курса Контент-менеджер.
Компоненты 2.0 (начальные сведения) в главе Компоненты 2.0 (начальные сведения) курса Контент-менеджер.
Информационные блоки - в главе Информационные блоки (начальные сведения) курса Контент-менеджер.
Управление доступом к файлам, элементам контента, модулям и другие права доступа в главе Управление доступом курса Администратор. Базовый.
Работа с инструментами системы - в главе Работа с инструментами курса Администратор. Базовый.
Модуль Поиск - в главе Поиск курса Администратор. Базовый.
Вся информация по администрированию модулей размещена в курсах:
Как построен курс

Общепринятая градация квалификации разработчиков в рамках курса обозначает что:
- Junior сможет создавать простые сайты работая со штатными компонентами и модифицируя их шаблоны.
- Middle разработчик может работать с API Bitrix Framework.
- Senior умеет работать над производительностью и безопасностью сайтов, создавать свои модули и компоненты.
Примечание: Такое построение удобно для пошагового изучения принципов работы Bitrix Framework. По этому же принципу построены и тесты. Но такая структура не очень удобна для использования содержания курса как постоянного источника информации. Что бы переключить курс в режим Справочника, воспользуйтесь переключателем в верхнем правом углу шапки курса.

Начальные требования к подготовке

Для успешного изучения курса и овладения мастерством разработки сайтов на Bitrix Framework необходимо владеть (хотя бы на начальном уровне):
- основами PHP, баз данных;
- основами HTML, CSS.
У нас часто спрашивают, сколько нужно заплатить

Курс полностью бесплатен. Изучение курса, прохождение итоговых тестов и получение сертификатов - ничего из этого оплачивать не нужно.

Ещё у нас есть Академия 1С-Битрикс, где можно обучиться на платной основе на курсах нашей компании либо наших партнёров.

Баллы опыта

В конце каждого урока есть кнопка Прочитано! . При клике на неё в Вашу итоговую таблицу опыта добавляется то количество баллов, которое указано в прочитанном После нажатия кнопки Прочитано! появится
окно подтверждения:

уроке.

Периодически мы заново оцениваем сложность уроков, увеличивая/уменьшая число баллов, поэтому итоговое количество набранных Вами баллов может отличаться от максимально возможного. Не переживайте! Отличный результат - это если общее число набранных Вами баллов отличается от максимального на 1-2%.

Тесты

После изучения курса вам будет предложено пройти тесты на сертификацию. При успешной сдаче последовательности тестов на странице Моё обучение можно просмотреть результат обучения и загрузить сертификат в формате PDF.

Комментарии к статьям

Что дальше?

Одновременно с изучением курса Разработчик Bitrix Framework вам придётся обращаться к информации о других технологиях Bitrix Framework. Эта информация размещена в следующих курсах:

Для преподавания офлайн

Если данный курс берётся в качестве основы для офлайнового преподавания, то рекомендуемая продолжительность: 5 дней (40 академических часов).

Если нет интернета

iPhone:
FBReader
CoolReader
iBook
Bookmate

Windows:
Calibre
FBReader
Icecream Ebook Reader
Плагины для браузеров:
EpuBReader – для Firefox
Readium – для Google Chrome

iOS
Marvin for iOS
ShortBook
обновляются периодически, поэтому возможно некоторое отставание их от онлайновой версии курса. Версия файла - от 10.03.2022.

Если вы нашли неточность в тексте, непонятное объяснение, пожалуйста, сообщите нам об этом в комментариях.

Это руководство по проектированию было создано для Windows 7 и не было обновлено для более новых версий Windows. Большая часть рекомендаций по-прежнему применяется в принципе, но презентация и примеры не отражают наше текущее руководство по проектированию.

В этой статье рассматривается размещение окон по умолчанию при первоначальном отображении на экране, их порядок размещения относительно других окон (Z), их начальный размер и влияние их отображения на фокус ввода.

Для выполнения следующих рекомендаций:
- Окно верхнего уровня не имеет окна владельца и отображается на панели задач. Примеры: окна приложений. В Windows Vista и более поздних версиях диалоговые окна без окон владельцев и листов свойств также считаются верхним уровнем.
- В окне владельца нет окна владельца и не отображается на панели задач. Примеры: модальные диалоговые окна, немодальные диалоговые окна.
- Окно, инициированное пользователем, отображается в качестве прямого результата действия пользователя. В противном случае программа инициируется, если она инициируется программой или системой, инициированной корпорацией Майкрософт Windows. Например, диалоговое окно "Параметры" инициируется пользователем, но инициируется напоминание о собрании.
- Контекстное окно — это окно, инициируемое пользователем, которое имеет сильную связь с объектом, из которого он был запущен. Например, окна, отображаемые контекстными меню или значками области уведомлений, являются контекстными, но окна, отображаемые в строках меню, не являются.
- Активный монитор — это монитор, в котором выполняется активная программа.
- Монитор по умолчанию — это монитор с меню , панелью задач и областью уведомлений.
Принципы проектирования

Управление окнами является одной из самых фундаментальных действий пользователей. До Windows Vista окна часто получают небольшие размеры по умолчанию и помещаются в середину экрана. Этот подход хорошо подходит для старых мониторов с низким разрешением, но не для современного видеоустройства.

Windows предназначена для поддержки современного видеоустройства, которое часто выполняется с разрешениями значительно выше минимально поддерживаемого разрешения экрана и может иметь несколько мониторов. Это:
- Позволяет пользователям полностью воспользоваться своим расширенным оборудованием.
- Требует меньше усилий от пользователей для перемещения мыши на большее расстояние.
- Делает размещение окна более предсказуемым и, следовательно, упрощает поиск.
Минимальное поддерживаемая разрешение экрана

Минимальное эффективное разрешение экрана, поддерживаемого Windows, составляет 800 x 600 пикселей. Это означает, что окна фиксированного размера должны полностью отображаться в минимальном разрешении (при резервируемом пространстве для панели задач), но размеры окон можно оптимизировать для эффективного разрешения 1024 x 768 пикселей, если они работают с минимальным разрешением.

Хотя в настоящее время наиболее распространенные физические разрешения экрана для Windows пк — 1024 x 768 пикселей или больше, то для 800 x 600 пикселей можно Windows:
- Хорошо работает со всеми современными аппаратными устройствами, включая небольшие компьютеры с записными книжками.
- Поддержка параметров с высоким разрешением (точек на дюйм).
- Поддержка более крупных шрифтов для специальных возможностей.
- Поддержка оборудования, используемого на глобальной основе.
Выбор минимального разрешения для поддержки требует удара по правильному балансу. Ориентация на более высокое разрешение приведет к неоптимальному взаимодействию со значительным процентом современного оборудования, в то время как назначение более низкого разрешения не позволит конструкторам воспользоваться всеми преимуществами доступного пространства экрана.

Если вы считаете, что целевые пользователи используют значительно более высокие разрешения, чем минимальный Windows, вы можете разработать программу, чтобы воспользоваться всеми преимуществами дополнительного пространства экрана с помощью масштабируемых окон с возможностью изменения размера.

Рекомендации

Общие сведения
- Поддержка минимального Windows эффективного разрешения 800 x 600 пикселей. Для критически важных пользовательских интерфейсов (UIs), которые должны работать в безопасном режиме, поддерживайте эффективное разрешение 640 x 480 пикселей. Обязательно учитывайте пространство, используемое панелью задач, зарезервировав 48 вертикальных относительных пикселей для окон, отображаемых с помощью панели задач.
- Оптимизируйте изменяемые макеты окон для эффективного разрешения 1024x768 пикселей. Автоматическое изменение размера этих окон для более низкого разрешения экрана таким образом, который по-прежнему работает.
- Обязательно протестируйте окна в 96 точек на дюйм (100 процентов) на 800 x 600 пикселей, 120 точек на дюйм (125 процентов) на 1024 x 768 пикселей и 144 точек на дюйм (150 процентов) на 1200 x900 пикселей. Проверьте наличие проблем с макетом, таких как обрезка элементов управления, текст и окна, а также растяжение значков и растровых изображений.
- Для программ с сценариями использования сенсорного и мобильного устройства оптимизируйте для 120 точек на дюйм. Экраны с высоким разрешением на дюйм в настоящее время распространены на сенсорных и мобильных пк.
- Изменяемые окна больше не должны отображать глиф изменения размера в правом нижнем углу, так как:
  - Все стороны и края окна могут изменяться, а не только в правом нижнем углу.
  - Для глифа требуется отобразить строку состояния, но многие окна с изменяемыми размерами не предоставляют строки состояния.
  - Изменяемые границы окна и указатели изменения размера более эффективны при взаимодействии с изменением размера окна, чем глиф изменения размера.
  Элементы управления заголовком
  
  Используйте элементы управления заголовка строки следующим образом:
  - Близко. Все основные и вторичные окна со стандартной рамкой окна должны иметь кнопку "Закрыть" в заголовке строки. Нажатие кнопки "Закрыть" влияет на отмену или закрытие окна.
  В этом примере диалоговое окно не имеет кнопку "Закрыть" в строке заголовка.
  - Минимизация. Все основные окна и длительные немодерные вторичные окна (например, диалоги хода выполнения) должны иметь кнопку "Свернуть". При нажатии кнопки "Свернуть" окно уменьшается до кнопки панели задач. Следовательно, окна, которые могут быть свернуты, требуют значка строки заголовка.
  - Развернуть или восстановить вниз. Все окна с изменяемыми размерами должны иметь кнопку "Развернуть или восстановить вниз". При нажатии кнопки "Развернуть" окно отображается в самом большом размере, которое для большинства окон является полноэкранным; в то время как при нажатии кнопки "Восстановить" окно отображается в предыдущем размере. Однако некоторые окна не получают преимуществ от использования полноэкранного экрана, поэтому эти окна должны максимально увеличить их максимальный полезный размер.
  Размер окна
  - Выберите размер окна по умолчанию, соответствующий его содержимому. Не бойтесь использовать более крупные начальные размеры окон, если вы можете эффективно использовать пространство.
  - Используйте изменяемые окна всякий раз, чтобы избежать полос прокрутки и усеченных данных. Windows с динамическим содержимым и списками пользуются наибольшим преимуществом в окнах с изменяемыми размерами.
  - Для текстовых документов рекомендуется использовать максимальную длину строки в 65 символов , чтобы упростить чтение текста. (Символы включают буквы, знаки препинания и пробелы.)
  - Окна фиксированного размера:
    - Должен быть полностью видимым и размером, чтобы поместиться в рабочую область.
    - Можно оптимизировать для более высоких разрешений, но при необходимости уменьшить размер во время отображения до фактического разрешения экрана.
    - Для постепенно большего размера окна должен отображаться постепенно больше информации. Убедитесь, что по крайней мере одна часть окна или элемент управления содержит изменяемое содержимое.
    - Следует избегать максимальных или близких к максимальному размеру размеров по умолчанию. Вместо этого выберите размер по умолчанию, который обычно является наиболее полезным без полноэкранного отображения. Предположим, что пользователи будут разворачивать окно вместо изменения размера, чтобы сделать его полноэкранным.
    - Следует задать минимальный размер окна, если размер содержимого больше не подходит для использования. Для элементов управления с изменяемыми размерами задайте минимальные размеры элементов с изменяемыми размерами, например минимальные функциональные ширины столбцов в представлениях списка.
    - Если это делает содержимое пригодным для использования с меньшим размером, следует изменить презентацию.
    В этом примере Медиаплеер Windows изменяет его формат, когда окно становится слишком маленьким для стандартного формата.
    
    Расположение окна
    
    Для следующих рекомендаций "центрирование" означает смещение вертикального размещения немного в сторону верхней части монитора, а не размещения точно в середине. Поместите 45 процентов пространства между верхней частью монитора или владельца и верхней частью окна и 55 процентов между нижней частью монитора или владельца и нижней частью окна. Сделайте это, потому что глаз, естественно, предвзято к верхней части экрана.
    
    "Центрирование" означает смещение вертикального размещения немного в сторону верхней части монитора.
    
    Если окно является контекстным, всегда отображает его рядом с объектом, с которым он был запущен. Поместите его вне пути, чтобы исходный объект не был охвачен окном.
    - Если оно отображается с помощью мыши, по возможности поместите его смещение вниз и справа.
    Отображение контекстных окон рядом с объектом, с которым он был запущен.
    
    Windows, запущенные из значков области уведомлений, отображаются рядом с областью уведомлений.
    
    Если он отображается с помощью пера, когда это возможно, чтобы оно не было покрыто рукой пользователя. Для пользователей с правой рукой отображается слева; в противном случае отображается справа.
    
    При использовании пера также отображаются контекстные окна, чтобы они не охватывались рукой пользователя.
    
    Разработчики: События мыши и события пера можно различать с помощью API GetMessageExtraInfo . Вы можете определить передачу пользователя с помощью API SystemParametersInfo с SPI_GETMENUDROPALIGNMENT.
    
    Поместите диалоги хода выполнения в правый нижний угол активного монитора.
    
    Поместите диалоги хода выполнения в правый нижний угол.
    
    Если окно не связано с текущим контекстом или действием пользователя, поместите его подальше от текущего расположения указателя. Это предотвращает случайное взаимодействие.
    
    Если окно является приложением верхнего уровня или документом, всегда каскадно его происхождение от левого верхнего угла монитора. При создании активной программой используйте активный монитор; в противном случае используйте монитор по умолчанию.
    
    Каскадное приложение верхнего уровня или окна документов с левого верхнего угла монитора.
    
    Если окно является служебной программой верхнего уровня, всегда отображает ее по центру в мониторе. При создании активной программой используйте активный монитор; в противном случае используйте монитор по умолчанию.
    
    Центр окон служебной программы верхнего уровня.
    
    Если окно является принадлежащим окну, сначала отобразите его по центру в верхней части окна владельца. Для последующего отображения рекомендуется отобразить его в последнем расположении (относительно окна владельца), если это, скорее всего, будет удобнее.
    
    Изначально центральные окна принадлежат верхней части окна владельца.
    
    Для диалоговых окон без режима всегда отображается в верхней части окна владельца, чтобы упростить поиск. Однако если пользователь активирует окно владельца, это может скрыть немодерное диалоговое окно.
    
    Отображайте бессерверные диалоги в верхней части окна владельца, чтобы упростить их поиск.
    
    При необходимости настройте начальное расположение, чтобы все окно отображалось в целевом мониторе. Если размер окна превышает размер целевого монитора, уменьшите его в соответствии с размерами.
    
    С выходом Windows 10 компания Microsoft вернула понятие окна в его первозданном виде для приложений из Windows Store. Теперь, используя привычные кнопки в правом верхнем углу, можно менять размер, сворачивать/разворачивать и закрывать окно, независимо от типа приложения. Самое интересное, что Microsoft не отказалась от своего изначального направления – ориентации на контент. Эта философия не универсальна, но она хорошо подходит для целого пласта приложений. Согласитесь, если вы делаете игру или читалку, то стандартный заголовок с цветами заданными автоматически может слегка подпортить дизайн приложения. Поэтому новые широкие возможности настройки заголовка в приложениях универсальной платформы Windows (UWP) стали безусловным плюсом.
    
    1. Скрываем заголовок. Как раз для тех случаев, когда в приложении необходимо полное погружение в контент и заголовок не нужен, существует функция сокрытия заголовка и перевода приложения в полноэкранный режим.
    
    Сделать это крайне просто:
    
    Обратите внимание, что функция TryEnterFullScreenMode возвращает значение Boolean, что позволит убедится в успехе перехода в полноэкранный режим, который не всегда гарантирован.
    
    Данный код лучше всего использовать в случае, когда необходимо перевести приложение в полноэкранный режим и обратно в ответ на действия пользователя. В случае, если требуется запуск приложения в полноэкранном режиме, нужно поместить в начале метода OnLaunched приложения следующий код:
    
    Приятное дополнение такого подхода в том, что приложение сразу запустится в полноэкранном режиме, включая экран-заставку, а также запомнит данное правило для последующих запусков.
    
    На заметку: для унификации поведения UWP-приложений и WinRT, при переходе в полноэкранный режим можно увидеть строку заголовка если подвести курсор мыши к верхнему краю окна. Это будет полезно при проектировании приложения.
    
    2. Тонкая настройка. На самом деле, возможность полностью заменить стандартный заголовок на свой без необходимости заботится о стандартном поведении вроде перетаскивания окна за заголовок появилась впервые. По сути это значит, что теперь можно разместить на месте заголовка все, что придет в голову. Данный способ позволяет заменить только ту часть заголовка, которая содержит иконку и наименование приложения. Часть с кнопками управления окном заменить на собственную не получится.
    
    Если погрузиться в этот функционал, слово «замена» не совсем подходит. Скорее мы просим платформу скрыть стандартный заголовок и говорим какой элемент в XAML будет выполнять его функции.
    
    Делается всего двумя строчками кода:
    
    И вот здесь начинается самое интересное. Указанный элемент может не только сильно отличаться от привычного заголовка, но и располагаться в любом месте окна. Вторая строчка кода не поместит его в нужное место и не даст правильных размеров, она всего лишь уведомит платформу о том, что по мнению разработчика является заголовком. Единственное, что получится в итоге – это возможность перетаскивать окно нажатием на данный элемент, без необходимости дополнительных действий в коде.
    
    Все это крайне важно понимать и помнить, что персонализация никогда не должна идти в разрез с привычками пользователя. Помня это нужно позаботится о том, чтобы заголовок был размещен на месте стандартного заголовка и имел соответствующую высоту и цвет.
    
    Как это выглядит в XAML:
    
    В данном примере видно, что текст заголовка и иконка поменялись местами. Все выглядит предельно просто и понятно, но при этом есть целый ряд важных аспектов.
    
    Во-первых, если сообщить платформе о том, что нужно использовать собственный заголовок, она отдаст ранее не доступную часть окна под макет, а значит все содержимое сдвинется вверх. Учитывая это, нужно позаботиться о том, чтобы в верхней части макета был только элемент заменяющий стандартный заголовок, а также убедиться, что ничто не перекрывается кнопками управления окном. В XAML выше корневой Grid отдает под заголовок одну строку высотой в 32 единицы. Здесь кроется еще один подвох – высота кнопок управления окном зависит от настроек Windows и равна 32 только при стандартных настройках, поэтому уважающий своего пользователя разработчик позаботится об отслеживании изменения настроек и отреагирует на это. В статье MSDN, посвященной методу Window.SetTitleBar можно узнать подробнее о том, как это сделать.
    
    Во-вторых, нужно помнить, что платформа обрабатывает элемент как обычный заголовок, а значит поместив туда кнопку будет невозможно отлавливать события ее нажатия. Все события мыши будут перехватываться платформой и использоваться для перетаскивания окна.
    
    Вам может показаться, что обойти предыдущее ограничение можно просто убрав строчку кода:
    
    Но, платформа просто скроет стандартный заголовок, а необходимый элемент в качестве заголовка не установит. Тогда можно просто определить участки, за которые окно можно перетаскивать и добавить нужные действия в коде? Но, нет, все не так просто. На самом деле, если не вызвать метод SetTitleBar, то все что находится в макете окна попадет на место бывшего заголовка, потеряет возможность отлавливать ввод и будет вести себя как заголовок. Для чего же тогда нужна эта строчка кода? Она нужна для того, чтобы точно определить места, ведущие себя как заголовок. Если необходимо поместить туда кнопку, то она должна быть за пределами элемента CustomTitleBar.
    
    Перепишем наш XAML следующим образом:
    
    А в коде окна будет написано следующее:
    
    В качестве примера, помещаем в заголовок кнопку разворачивания окна в полноэкранный режим. Несмотря на то, что смысла в такой кнопке не так много, о чем станет понятно ниже, данный пример вполне подходит для осваивания тонкостей работы с заголовком.
    
    Теперь, в тот момент, когда переводим окно в полноэкранный режим, заголовок никуда не исчезает. CustomTitleBar остается на своем месте, но при этом теряет функции заголовка. При наведении курсора мыши в верхнюю часть экрана, сверху появляются кнопки управления окном, которые позволяют вернуться в обычный режим. Если для переходя в полноэкранный режим и скрытия своего заголовка, достаточно отреагировать на событие кнопки, то для того, чтобы узнать, что окно вернулось в обычный режим, придется подписаться на событие изменения размеров окна.
    
    Экспериментируя с данным кодом, можно добиться многих интересных результатов, но не стоит забывать о стандартизации и удобстве. Например, вы можете поместить CustomTitleBar внизу окна и тогда появится возможность перетаскивать окно не за верхнюю, а за нижнюю часть, но пользователь вряд ли скажет за это «спасибо». Хорошо обдумайте необходимость решения, прежде чем его применять. Кстати очень хорошим примером реализации собственного заголовка можно назвать браузер Microsoft Edge, в котором частью заголовка являются вкладки.
    
    3. Смена цвета заголовка. Описанный выше метод крайне интересен и достаточно гибок, но в большинстве сценариев будет излишне создавать свой элемент и усложнять жизнь его правильной настройкой. Намного проще просто перекрасить элементы системного заголовка в цвета приложения. Набор параметров, отвечающих за цвета заголовка, достаточно широк, чтобы достичь гармонии с остальным приложением.
    
    Для сокращения кода можно получить ссылку на текущий TitleBar и далее работать с ней:
    
    Рассмотрим все свойства, отвечающие за цвета элементов заголовка:
    
    Поэкспериментировав с каждым из этих свойств, вы можете добиться гармоничного дизайна и ваше приложение будет успешно отвечать философии ориентации на контент.
    
    Также, возможно использовать свойства, отвечающие за цвета кнопок для адаптации их под ваш персональный заголовок, который можно создать, используя способ, описанный выше.
    
    На этом описание настройки заголовка в приложениях UWP можно завершить. Стоит заметить, что все выше сказанное актуально для приложений, запускаемых на рабочем столе. Если приложение выполняется в режиме планшета или на мобильном устройстве, то заголовок в нем отсутствует.
    
    К старту курса по разработке на Python делимся детальным руководством по работе с современным PyQt. Чтобы читать было удобнее, мы объединили несколько статей в одну:
    
    За подробностями приглашаем под кат.
    
    Простое приложение Hello World! на Python и Qt6
    
    PyQt — это библиотека Python для создания приложений с графическим интерфейсом с помощью инструментария Qt. Созданная в Riverbank Computing, PyQt является свободным ПО (по лицензии GPL) и разрабатывается с 1999 года. Последняя версия PyQt6 — на основе Qt 6 — выпущена в 2021 году, и библиотека продолжает обновляться. Это руководство можно также использовать для PySide2, PySide6 и PyQt5.
    
    Сегодня используются две основные версии: PyQt5 на основе Qt5 и PyQt6 на основе Qt6. Обе почти полностью совместимы, за исключением импорта и отсутствия поддержки некоторых продвинутых модулей из Qt6. В PyQt6 вносятся изменения в работу пространств имён и флагов, но ими легко управлять. В этом руководстве мы узнаем, как использовать PyQt6 для создания настольных приложений.
    
    Сначала создадим несколько простых окон на рабочем столе, чтобы убедиться, что PyQt работает, и разберём базовые понятия. Затем кратко изучим цикл событий и то, как он связан с программированием графического интерфейса на Python. В заключение поговорим о QMainWindow с полезными элементами интерфейса, такими как панели инструментов и меню. Подробно я расскажу о них в следующих руководствах.
    
    Создание приложения
    
    Сначала создадим новый файл Python с любым названием (например app.py) и сохраним его. Исходный код приложения показан ниже. Введите его полностью и постарайтесь не ошибиться. Если что-то напутаете, Python укажет, что именно:
    
    Запускаем приложение из командной строки, как и любой скрипт Python:
    
    Выполнив его, мы увидим окно. В Qt автоматически создаётся окно с обычным оформлением, возможностью его перетаскивать и менять размер. То, что вы увидите, зависит от платформы, где этот пример выполняется. Вот как отображается это окно на Windows, macOS и Linux (Ubuntu):
    
    Окно на Windows, macOS и Linux
    
    Разбор кода
    
    Пройдём код построчно, чтобы понять, что именно происходит. Сначала мы импортируем классы PyQt для приложения: здесь это обработчик приложения QApplication и базовый пустой виджет графического интерфейса QWidget (оба из модуля QtWidgets):
    
    Основные модули для Qt: QtWidgets, QtGui и QtCore.
    
    Возможен ещё from import * , но этот вид импорта обычно не приветствуется в Python. Дальше создаём экземпляр QApplication и передаём sys.arg (список Python с аргументами командной строки, передаваемыми приложению):
    
    Если не будете использовать аргументы командной строки для управления Qt, передайте пустой список:
    
    Затем создаём экземпляр QWidget, используя имя переменной window:
    
    В Qt все виджеты верхнего уровня — окна, то есть у них нет родительского элемента и они не вложены в другой виджет или макет. В принципе, окно можно создать, используя любой виджет.
    
    Виджеты без родительского элемента по умолчанию невидимы. Поэтому после создания объекта window необходимо всегда вызывать функцию .show(), чтобы сделать его видимым. .show() можно удалить, но тогда, запустив приложение, вы не сможете выйти из него!
    
    В окне находится пользовательский интерфейс приложения. У каждого приложения он как минимум один. Приложение (по умолчанию) завершает работу при закрытии последнего окна.
    
    Наконец, вызываем app.exec(), чтобы запустить цикл события.
    
    Что такое «цикл событий»?
    
    Прежде чем вывести окно на экран, разберём ключевые понятия, касающиеся организации приложений в мире Qt. Если вам уже знакомы циклы событий, можете пропустить эту часть статьи.
    
    Основной элемент всех приложений в Qt — класс QApplication. Для работы каждому приложению нужен один — и только один — объект QApplication, который содержит цикл событий приложения. Это основной цикл, управляющий всем взаимодействием пользователя с графическим интерфейсом:
    
    При каждом взаимодействии с приложением — будь то нажатие клавиши, щелчок или движение мыши — генерируется событие, которое помещается в очередь событий. В цикле событий очередь проверяется на каждой итерации: если найдено ожидающее событие, оно вместе с управлением передаётся определённому обработчику этого события. Последний обрабатывает его, затем возвращает управление в цикл событий и ждёт новых событий. Для каждого приложения выполняется только один цикл событий.
    
    Класс QApplication содержит цикл событий Qt (нужен один экземпляр QApplication). Приложение ждёт в цикле событий новое событие, которое будет сгенерировано при выполнении действия. Всегда выполняется только один цикл событий.
    
    QMainWindow
    
    Итак, в Qt любые виджеты могут быть окнами. Например, если заменить QtWidget на QPushButton. В этом примере получается окно с одной нажимаемой кнопкой:
    
    Классно, но не очень полезно на самом деле: редко когда нужен пользовательский интерфейс, состоящий только из одного элемента управления. Зато возможность с помощью макетов вкладывать одни виджеты в другие позволяет создавать сложные пользовательские интерфейсы внутри пустого QWidget.
    
    В Qt уже есть решение для окна — виджет QMainWindow, имеющий стандартные функции окна для использования в приложениях, который содержит панели инструментов, меню, строку состояния, закрепляемые виджеты и многое другое. Рассмотрим эти расширенные функции позже, а пока добавим в приложение простой, пустой QMainWindow:
    
    Запускаем и видим главное окно. Точно такое же, как и раньше.
    
    QMainWindow пока не очень интересный. Добавим контент. Чтобы сделать настраиваемое окно, лучше создать подкласс QMainWindow, а затем настроить окно в блоке __init__. Так окно станет независимым в плане поведения. Итак, добавляем подкласс QMainWindow — MainWindow:
    
    Для этого демо используем QPushButton. Основные виджеты Qt всегда импортируются из пространства имён QtWidgets, как и классы QMainWindow и QApplication. При использовании QMainWindow задействуем .setCentralWidget для размещения виджета (здесь виджет — QPushButton) в QMainWindow, по умолчанию он занимает всё окно. Как добавлять в окна несколько виджетов? Об этом поговорим рассмотрим в руководстве по макетам.
    
    При создании подкласса из класса Qt, чтобы разрешить Qt настраивать объект, всегда нужно вызывать функцию super __init__.
    
    В блоке __init__ сначала используем .setWindowTitle(), чтобы поменять заголовок главного окна. Затем добавляем первый виджет — QPushButton — в середину окна. Это один из основных виджетов Qt. При создании кнопки можно ввести текст, который будет на ней отображаться. Вызываем .setCentralWidget() в окне. Это специальная функция QMainWindow, которая позволяет установить виджет на середину окна.
    
    Запускаем и снова видим окно, но на этот раз с виджетом QPushButton в центре. Нажатие кнопки ничего не даст — с этим мы разберёмся после:
    
    QMainWindow с одной кнопкой QPushButton на Windows, macOS и Linux
    
    Скоро мы подробно рассмотрим другие виджеты, но, если вам не терпится и хочется забежать вперёд, можете заглянуть в документацию QWidget. Попробуйте добавить различные виджеты в окно.
    
    Изменение размеров окон и виджетов
    
    Сейчас размер окна можно свободно поменять: щёлкните мышью на любой угол и перетаскивайте, меняя таким образом размер. Можно дать возможность пользователям самим менять размер приложений, а можно установить ограничения на минимальные или максимальные размеры или фиксированный размер окна.
    
    В Qt размеры определяются с помощью объекта QSize. Он принимает параметры ширины и высоты. Например, так создаётся окно фиксированного размера 400 x 300 пикселей:
    
    Запускаем и видим окно фиксированного размера. Поменять его размер не получится.
    
    Окно фиксированного размера
    
    Элемент управления maximize отключён на Windows и Linux. На macOS можно развернуть приложение на весь экран, но размер центрального виджета не изменится.
    
    Кроме .setFixedSize() можно также вызвать .setMinimumSize() и .setMaximumSize(), чтобы установить минимальный и максимальный размеры соответственно. Попробуйте сами! Эти методы регулирования размеров работают в любом виджете. Продолжить изучение Python вы сможете на наших курсах:
    
    А ещё вы можете приобрести книгу автора этих уроков или продолжить чтение.
    
    Слоты и сигналы
    
    Ранее мы рассмотрели классы QApplication и QMainWindow, цикл событий и добавили в окно простой виджет. А теперь изучим механизмы Qt для взаимодействия виджетов и окон друг с другом. В статью внесены изменения, связанные с PyQt6.
    
    Мы создали окно и добавили в него простой виджет push button, но кнопка пока бесполезна. Нужно связать действие нажатия кнопки с происходящим. В Qt это делается с помощью сигналов и слотов или событий.
    
    Сигналы — это уведомления, отправляемые виджетами, когда что-то происходит. Этим «чем-то» может быть что угодно — нажатие кнопки, изменение текста в поле ввода или изменение текста в окне. Многие сигналы инициируются в ответ на действия пользователя, но не только: в сигналах могут отправляться данные с дополнительным контекстом произошедшего.
    
    Можно также писать собственные сигналы, их мы рассмотрим позже.
    
    Слоты в Qt — это приёмники сигналов. Слотом в приложении на Python можно сделать любую функцию (или метод), просто подключив к нему сигнал. Принимающая функция получает данные, отправляемые ей в сигнале. У многих виджетов Qt есть встроенные слоты, а значит, виджеты можно подключать друг к другу напрямую.
    
    Рассмотрим основные сигналы Qt и их использование для подключения виджетов в приложениях. Сохраните эту заготовку приложения в файле app.py:
    
    Сигналы QPushButton
    
    Сейчас у нас есть QMainWindow с центральным виджетом QPushButton. Подключим эту кнопку к пользовательскому методу Python. Создадим простой настраиваемый слот the_button_was_clicked, принимающий сигнал clicked от QPushButton:
    
    Запускаем. Если нажать на кнопку, в консоли появится текст Clicked! («Нажата!»):
    
    Получение данных
    
    В сигналах может отправляться дополнительная информация о произошедшем. И сигнал .clicked — не исключение: с его помощью сообщается о нажатом (или переключенном) состоянии кнопки. Для обычных кнопок это значение всегда False, поэтому первый слот проигнорировал эти данные. Включим возможность нажатия кнопки, чтобы увидеть этот эффект. Ниже добавляется второй слот и выводится состояние нажатия:
    
    Запускаем! Если нажать на кнопку, она подсветится и станет checked («Нажатой»). Чтобы отключить её, нажимаем ещё раз. Найдите состояние нажатия в консоли:
    
    К сигналу подключается сколько угодно слотов, в которых можно реагировать сразу на несколько версий сигналов.
    
    Хранение данных
    
    Текущее состояние виджета на Python часто хранят в переменной, что позволяет работать со значениями без доступа к исходному виджету. Причём для их хранения используются отдельные переменные или словарь. В следующем примере сохраняем значение кнопки checked («Нажата») в переменной button_is_checked в self:
    
    Сначала устанавливаем переменной значение по умолчанию True, а затем используем это значение, чтобы установить исходное состояние виджета. Когда состояние виджета меняется, получаем сигнал и соответственно обновляем переменную.
    
    Эта же схема применима к любым виджетам PyQt. Если в виджете нет сигнала, которым отправляется текущее состояние, нужно получить значение из виджета прямо в обработчике. Например, здесь мы проверяем состояние checked («Нажата») в нажатом обработчике:
    
    Сохраним ссылку на кнопку в self, чтобы получить к ней доступ в слоте.
    
    Сигнал released срабатывает, когда кнопка отпускается, при этом состояние нажатия не отправляется. Его получают из кнопки в обработчике, используя .isChecked().
    
    Изменение интерфейса
    
    Мы уже видели, как принимаются сигналы и выводятся на консоль результаты. Но что происходит с интерфейсом, когда нажимают на кнопку? Обновим метод слота, чтобы изменить кнопку, поменяв текст, отключив её и сделав её недоступной. И отключим пока состояние, допускающее нажатие:
    
    Снова нужен доступ к кнопке в методе the_button_was_clicked, поэтому сохраняем ссылку на неё в self. Чтобы поменять текст кнопки, передаём str в .setText(). Чтобы отключить кнопку, вызываем .setEnabled() с аргументом False. И запускаем программу. Если нажать на кнопку, текст изменится и кнопка станет недоступной.
    
    В методах слота можно не только менять кнопку, которая активирует сигнал, но и делать всё что угодно. Например, поменять заголовок окна, добавив в метод the_button_was_clicked эту строку:
    
    Большинство виджетов, в том числе QMainWindow, имеют свои сигналы. В следующем, более сложном примере подключим сигнал .windowTitleChanged в QMainWindow к пользовательскому методу слота. А также сделаем для этого слота новый заголовок окна:
    
    При нажатии на кнопку заголовок окна случайным образом изменится. Если новый заголовок окна изменится на Something went wrong («Что-то пошло не так»), кнопка отключится.
    
    Запускаем! Нажимайте на кнопку, пока заголовок не изменится на Something went wrong. В этом примере стоит обратить внимание вот на что:
    
    Сигнал windowTitleChanged при установке заголовка окна выдаётся не всегда. Он срабатывает, только если новый заголовок отличается от предыдущего: если один и тот же заголовок устанавливается несколько раз, сигнал срабатывает только в первый раз. Чтобы избежать неожиданностей, важно перепроверять условия срабатывания сигналов при их использовании в приложении.
    
    С помощью сигналов создаются цепочки. Одно событие — нажатие кнопки — может привести к тому, что поочерёдно произойдут другие. Эти последующие эффекты отделены от того, что их вызвало. Они возникают согласно простым правилам. И это отделение эффектов от их триггеров — один из ключевых принципов, которые учитываются при создании приложений с графическим интерфейсом. Возвращаться к этому будем на протяжении всего курса.
    
    Мы рассмотрели сигналы и слоты, показали простые сигналы и их использование для передачи данных и состояния в приложении. Теперь переходим к виджетам Qt, которые будут использоваться в приложениях вместе с сигналами.
    
    Подключение виджетов друг к другу напрямую
    
    Мы уже видели примеры подключения сигналов виджетов к методам Python. Когда сигнал из виджета срабатывает, вызывается метод Python, из сигнала он получает данные. Но для обработки сигналов не всегда нужна функция Python — можно подключать виджеты друг к другу напрямую.
    
    Добавим в окно виджеты QLineEdit и QLabel. В __init__ для окна и подключим сигнал редактирования строки .textChanged к методу .setText в QLabel. Когда в QLineEdit меняется текст, он сразу будет поступать в QLabel (в метод .setText):
    
    Внимание: чтобы подключить входные данные к метке, нужно определить и эти данные, и метку. В этом коде в макет добавляются два виджета и устанавливаются в окне. Подробно рассмотрим макеты позже, а пока не обращайте на них внимания.
    
    Введите текст в верхнем поле — он сразу появится в виде метки.
    
    У большинства виджетов Qt есть доступные слоты, к которым подключается любой сигнал, возврощающий тот же тип, что он принимает. В документации по виджетам, в разделе Public Slots («Общедоступные слоты»), имеются слоты для каждого виджета. Посмотрите документацию для QLabel.
    
    События
    
    Любое взаимодействие пользователя с приложением Qt — это событие. Есть много типов событий, каждое из которых — это отдельный тип взаимодействия. В Qt события представлены объектами событий, в которые упакована информация о произошедшем. События передаются определённым обработчикам событий в виджете, где произошло взаимодействие.
    
    Определяя пользовательские или расширенные обработчики событий, можно менять способ реагирования виджетов на них. Обработчики событий определяются так же, как и любой другой метод, но название обработчика зависит от типа обрабатываемого события.
    
    QMouseEvent — одно из основных событий, получаемых виджетами. События QMouseEvent создаются для каждого отдельного нажатия кнопки мыши и её перемещения в виджете. Вот обработчики событий мыши:
    
    Модуль, используемый для управления окном и отображением экрана в Pygame.
    
    Примечание. Чтобы адаптироваться к контексту, в этом документе отображение иногда переводится как «отображение», а иногда как «интерфейс отображения».
    
    функция
    - pygame.display.init () - Инициализирует модуль дисплея
    - pygame.display.quit () - Завершить отображение модуля
    - pygame.display.get_init () - Если дисплейный модуль был инициализирован, вернуть True
    - pygame.display.set_mode () - Инициализирует окно или экран для отображения
    - pygame.display.get_surface () - Получить текущий отображаемый объект Surface
    - pygame.display.flip () - Обновляет весь объект Surface для отображения на экране
    - pygame.display.update () - Обновляет часть отображения интерфейса программного обеспечения
    - pygame.display.get_driver () - Получить имя серверной части дисплея Pygame
    - pygame.display.Info () - Создать информационный объект об интерфейсе дисплея
    - pygame.display.get_wm_info () - Получить информацию о текущей оконной системе
    - pygame.display.list_modes () - получает разрешение, которое можно использовать в полноэкранном режиме
    - pygame.display.mode_ok () - Выбрать наиболее подходящую глубину цвета для режима отображения
    - pygame.display.gl_get_attribute () - Получить значение атрибута текущего интерфейса отображения OpenGL
    - pygame.display.gl_set_attribute () - Установить значение атрибута OpenGL для текущего режима отображения
    - pygame.display.get_active () - возвращает True, когда текущий интерфейс дисплея отображается на экране
    - pygame.display.iconify () - Свернуть отображаемый объект Surface
    - pygame.display.toggle_fullscreen () - переключение между полноэкранным и оконным режимами
    - pygame.display.set_gamma () - Изменяет гамма-рампу, отображаемую оборудованием
    - pygame.display.set_gamma_ramp () - настраивает и изменяет гамма-рампу, отображаемую оборудованием
    - pygame.display.set_icon () - Изменить значок окна отображения
    - pygame.display.set_caption() — Set the current window caption
    - pygame.display.get_caption() — Get the current window caption
    - pygame.display.set_palette() — Set the display color palette for indexed displays
    Этот модуль предоставляет различные функции для управления интерфейсом отображения Pygame (display). Pygame's Surface Объект может отображаться в виде окна или в полноэкранном режиме. Когда вы создаете и отображаете обычный Surface После объекта изменения на объекте не будут немедленно отражены на видимом экране.Вы должны выбрать функцию переворота, чтобы отобразить измененный экран.
    
    Отображаемое начало координат - это положение (x = 0, y = 0) и верхнего левого угла экрана. Ось координат увеличивается в правом нижнем углу.
    
    На самом деле отображение Pygame можно инициализировать несколькими способами. По умолчанию дисплей действует как программный буфер кадра. Кроме того, вы можете использовать специальные модули, поддерживающие аппаратное ускорение и OpenGL. Они контролируются передачей параметра flags в pygame.display.set_mode ().
    
    Pygame допускает только один интерфейс отображения в любое время. Новый интерфейс отображения, созданный с помощью pygame.display.set_mode (), автоматически заменит старый. Если вам нужно точно контролировать формат пикселей или разрешение экрана, используйте pygame.display.mode_ok (), pygame.display.list_modes () и pygame.display.Info () для запроса информации об интерфейсе дисплея.
    
    однажды Surface Создается интерфейс отображения объекта, и функция этого модуля влияет только на текущий интерфейс отображения. Если модуль не инициализирован, Surface Объект также станет «нелегальным». Если установлен новый режим отображения, текущий Surface Объект автоматически переключится на новый интерфейс отображения.
    
    Когда установлен новый режим отображения, несколько связанных событий будут помещены в очередь событий Pygame. Когда используется для закрытия программы, будет отправлено событие pygame.QUIT; когда интерфейс дисплея получает и теряет фокус, окно получит событие pygame.ACTIVEEVENT; если интерфейс дисплея установлен с флагом pygame.RESIZABLE, тогда, когда пользователь регулирует размер окна , Будет отправлено событие Pygame.VIDEORESIZE; аппаратный дисплей означает, что при получении события pygame.VIDEOEXPOSE часть окна, которую необходимо перерисовать, отображается непосредственно на экране.
    
    В некоторых средах отображения есть возможность автоматически растягивать все окна. Когда эта опция активирована, автоматическое растягивание искажает внешний вид окна Pygame. В каталоге примеров Pygame есть демонстрационный код (prevent_display_stretching.py), который показывает, как отключить свойство автоматического растягивания отображения Pygame в системах Microsoft (системы выше Vista).
    
    Описание функции
    
    pygame.display.init()
    
    Инициализируйте модуль дисплея.
    
    Инициализировать модуль отображения Pygame. До инициализации модуль дисплея ничего не может делать. Но когда вы вызываете pygame.init () более высокого уровня, изменение автоматически вызывает pygame.display.init () для инициализации.
    
    После инициализации Pygame автоматически выберет один из нескольких внутренних модулей отображения. Режим отображения определяется платформой и текущими полномочиями пользователя. Перед инициализацией модуля отображения можно использовать переменную среды SDL_VIDEODRIVER, чтобы установить, какой серверный модуль отображения будет использоваться. К системам с несколькими серверными модулями отображения относятся следующие:
    
    Windows : windib, directx
    Unix : x11, dga, fbcon, directfb, ggi, vgl, svgalib, aalib
    
    На некоторых платформах вы можете встроить отображение Pygame в существующее окно. Если вы это сделаете, переменная среды SDL_WINDOWID должна быть установлена в строку, содержащую идентификатор окна или дескриптор. Когда отображение Pygame инициализировано, переменные среды будут проверены. Обратите внимание, что встраивание отображения в работающее окно может иметь много странных побочных эффектов.
    
    Нет проблем с вызовом этой функции несколько раз, но эффекта нет.
    
    pygame.display.quit()
    
    Закройте модуль дисплея.
    
    Эта функция закроет весь дисплейный модуль. Это будет означать, что любой активный интерфейс дисплея будет закрыт. Эта функция также будет вызываться автоматически при выходе из основной программы.
    
    Нет проблем с вызовом этой функции несколько раз, но эффекта нет.
    
    pygame.display.get_init()
    
    Если модуль дисплея был инициализирован, верните True.
    
    Если модуль дисплея был инициализирован, верните True.
    
    pygame.display.set_mode()
    
    Инициализируйте окно или экран для отображения.
    
    set_mode(resolution=(0,0), flags=0, depth=0) -> Surface
    
    Эта функция создаст Surface Интерфейс отображения объекта. Переданные параметры используются для определения типа отображения. Окончательный созданный интерфейс дисплея будет максимально соответствовать текущей операционной системе.
    
    Параметр разрешения - это кортеж из двух элементов, представляющий ширину и высоту. Параметр flags представляет собой набор дополнительных опций. Параметр глубины указывает используемую глубину цвета.
    
    возвращение Surface Объект может быть как обычный Surface Объект нарисован так, но происходящие изменения со временем отобразятся на экране.
    
    Если параметр разрешения не передан или используется настройка по умолчанию (0, 0), а Pygame использует SDL1.2.10 или новее, созданный объект Surface будет иметь то же разрешение, что и текущий пользователь экрана. Если только одна из ширины или высоты установлена на 0, то объект Surface заменит ее шириной или высотой разрешения экрана. Если версия SDL ниже 1.2.10, будет создано исключение.
    
    Вообще говоря, лучше всего не передавать параметр глубины. Потому что по умолчанию Pygame выберет лучшую и самую быструю глубину цвета в соответствии с текущей операционной системой. Если вашей игре действительно нужен особый цветовой формат, вы можете сделать это, управляя параметром глубины. Pygame потребуется больше времени для имитации нестандартной глубины цвета.
    
    При использовании полноэкранного режима отображения иногда не удается полностью подобрать необходимое разрешение. В этом случае Pygame автоматически выберет наиболее подходящее разрешение для использования, и вернет Surface Объект останется в соответствии с требуемым разрешением.
    
    Параметр flags определяет желаемый тип отображения. Вам предлагается несколько вариантов. Вы можете использовать несколько типов одновременно с помощью битовых операций (оператор вертикальной черты "|"). Если вы передадите параметр 0 или без флагов, по умолчанию будет использоваться окно программного драйвера. Вот несколько вариантов, предоставляемых параметром flags:
    
    Параметры
    
    смысл
    
    pygame.display.get_surface()
    
    Получить текущий отображаемый Поверхностный объект.
    
    Вернуть текущий отображаемый Surface Объект. Если режим отображения не установлен, возвращается значение None.
    
    pygame.display.flip()
    
    Обновите все для отображения Поверхность объекта на экране.
    
    Эта функция обновит содержимое всего интерфейса дисплея. Если в вашем режиме отображения используются флаги pygame.HWSURFACE (аппаратное ускорение) и pygame.DOUBLEBUF (двойная буферизация), вы дождетесь вертикальной развертки и переключите интерфейс дисплея. Если вы используете другой тип режима отображения, он просто обновит содержимое всего интерфейса дисплея.
    
    При использовании режима отображения pygame.OPENGL (с использованием рендеринга OPENGL) будет создана область переключения буфера gl.
    
    Напоминание: вертикальный откат - это измерение времени, связанное с отображением видео. Оно представляет собой временной интервал между концом одного кадра и началом следующего кадра.
    
    pygame.display.update()
    
    Обновите часть отображения интерфейса программного обеспечения.
    
    Эту функцию можно рассматривать как оптимизированную версию функции pygame.display.flip (), отображаемой в программном интерфейсе. Это позволяет обновлять часть экрана без необходимости обновления полностью. Если параметры не переданы, функция обновляет весь интерфейс так же, как pygame.display.flip ().
    
    Вы можете передать в эту функцию одну или несколько прямоугольных областей. Одновременное прохождение нескольких прямоугольных областей более эффективно, чем многократное прохождение. Если передан пустой список или None, параметр будет проигнорирован.
    
    Эта функция не может быть вызвана в режиме отображения pygame.OPENGL, в противном случае будет выдано исключение.
    
    pygame.display.get_driver()
    
    Получите имя серверной части дисплея Pygame.
    
    При инициализации Pygame выберет один из нескольких доступных бэкэндов отображения. Эта функция возвращает имя, используемое внутренне серверной частью дисплея. Может использоваться для предоставления некоторой информации об ускорении работы дисплея. Вы можете обратиться к переменной среды SDL_VIDEODRIVER в pygame.display.set_mode ().
    
    pygame.display.Info()
    
    Создайте информационные объекты об интерфейсе дисплея.
    
    Создайте объект, содержащий описание некоторых свойств текущей графической среды. На некоторых платформах, если эта функция вызывается перед pygame.display.set_mode (), она может предоставить некоторую информацию о режиме отображения по умолчанию. Вы также можете вызвать эту функцию после настройки режима отображения, чтобы убедиться, что параметры отображения удовлетворительны.
    
    Возвращенный объект VideoInfo содержит следующие свойства:
    
    Атрибуты
    
    смысл
    
    pygame.display.get_wm_info()
    
    Получить информацию о текущей оконной системе.
    
    Создайте словарь, заполненный данными операционной системы. Некоторые операционные системы могут не заполнять информацию и возвращать пустой словарь. Большинство платформ вернут ключ «окна», соответствующее значение - это системный идентификатор текущего интерфейса дисплея.
    
    Pygame 1.7.1 добавлен недавно.
    
    pygame.display.list_modes()
    
    Получите разрешение, которое можно использовать в полноэкранном режиме.
    
    list_modes(depth=0, flags=pygame.FULLSCREEN) -> list
    
    Эта функция возвращает список, содержащий все разрешения, поддерживаемые указанной глубиной цвета. Если режим отображения не является полноэкранным, возвращается пустой список. Если он возвращает -1, поддерживается любое разрешение (аналогично оконному режиму). Возвращенный список отсортирован от наибольшего к наименьшему.
    
    Если глубина цвета равна 0, SDL выберет текущую / наиболее подходящую глубину цвета для отображения. Значение по умолчанию для параметра flags - pygame.FULLSCREEN, но вам может потребоваться добавить дополнительные флаги полноэкранного режима.
    
    pygame.display.mode_ok()
    
    Выберите наиболее подходящую глубину цвета для режима отображения.
    
    mode_ok(size, flags=0, depth=0) -> depth
    
    Эта функция использует те же параметры, что и функция pygame.display.set_mode (). Обычно используется, чтобы определить, доступен ли режим отображения. Если режим отображения не может быть установлен, возвращается 0. В нормальных условиях возвращается требуемая для дисплея глубина пикселей.
    
    Обычно вас не волнует параметр глубины, если только некоторые платформы не поддерживают несколько глубин отображения, он подскажет, какая глубина цвета более подходящая.
    
    Наиболее полезными параметрами флагов являются pygame.HWSURFACE, pygame.DOUBLEBUF и pygame.FULLSCREEN. Если эти флаги не поддерживаются, функция возвращает 0.
    
    pygame.display.gl_get_attribute()
    
    Получить значение атрибута текущего интерфейса дисплея OpenGL.
    
    После вызова функции pygame.display.set_mode () с установленным флагом pygame.OPENGL рекомендуется проверять значения атрибутов OpenGL. Обратитесь к pygame.display.gl_set_attribute () для получения списка допустимых флагов.
    
    pygame.display.gl_set_attribute()
    
    Установите значение атрибута OpenGL для текущего режима отображения.
    
    gl_set_attribute(flag, value) -> None
    
    При вызове функции pygame.display.set_mode () с установленным флагом pygame.OPENGL Pygame автоматически устанавливает некоторые значения атрибутов OpenGL, такие как цвет и двойной буфер. OpenGL фактически предоставляет вам некоторые другие значения атрибутов. Передайте имя атрибута в параметре флага и установите его значение в параметре значения. Эта функция должна быть установлена перед pygame.display.set_mode ().
    
    Эти флаги OPENGL:
    
    GL_ALPHA_SIZE, GL_DEPTH_SIZE, GL_STENCIL_SIZE, GL_ACCUM_RED_SIZE,
    GL_ACCUM_GREEN_SIZE, GL_ACCUM_BLUE_SIZE, GL_ACCUM_ALPHA_SIZE,
    GL_MULTISAMPLEBUFFERS, GL_MULTISAMPLESAMPLES, GL_STEREO
    
    pygame.display.get_active()
    
    Верните True, когда на экране отображается текущий интерфейс дисплея.
    
    После вызова функции pygame.display.set_mode () на экране отобразится объект Surface. Большинство окон поддерживают скрытие, если отображается Surface Объект скрыт и свернут, тогда функция вернет False.
    
    pygame.display.iconify()
    
    Сверните отображаемое Surface Объект.
    
    Сверните или скройте отображаемый объект Surface. Не все операционные системы поддерживают интерфейс минимизированного дисплея. Если функция успешно вызвана, она возвращает True.
    
    Когда интерфейс дисплея свернут, pygame.display.get_active () возвращает False. Очередь событий получит событие ACTIVEEVENT.
    
    pygame.display.toggle_fullscreen()
    
    Переключение между полноэкранным и оконным режимами.
    
    Переключение между полноэкранным и оконным режимами. Эта функция работает только с драйвером дисплея unix x11. В большинстве случаев рекомендуется вызвать pygame.display.set_mode (), чтобы создать новый режим отображения для переключения.
    
    pygame.display.set_gamma()
    
    Измените гамма-рампу, отображаемую оборудованием.
    
    set_gamma(red, green=None, blue=None) -> bool
    
    Установите значения гаммы красного, зеленого и синего, отображаемые драйвером оборудования. Если зеленый и синий параметры не переданы, они будут равны значению красного. Не все операционные системы и оборудование поддерживают гамма-изменение. Если функция изменена успешно, она возвращает True.
    
    Значение гаммы 1.0 создает линейную таблицу цветов, более низкое значение затемняет экран, а более высокое значение делает экран переменной.
    
    pygame.display.set_gamma_ramp()
    
    Настроить и изменить гамма-рампу, отображаемую оборудованием
    
    set_gamma_ramp(red, green, blue) -> bool
    
    Используйте настраиваемую таблицу, чтобы установить красную, зеленую и синюю гамма-кривые, отображаемые драйвером оборудования. Каждый параметр должен быть списком 256-битных целых чисел. Каждое целое число должно быть от 0 до 0xffff. Не все операционные системы и оборудование поддерживают гамма-изменение. Если функция изменена успешно, она возвращает True.
    
    pygame.display.set_icon()
    
    Измените значок окна дисплея.
    
    Установите значок при открытии окна дисплея. Все операционные системы по умолчанию используют простой ЛОГОТИП Pygame в виде значка.
    
    Вы можете пройти в любой Surface Объект используется как значок, но для большинства операционных систем требуется, чтобы размер значка был 32 * 32. Значок может установить прозрачность цвета.
    
    Некоторые операционные системы не позволяют изменять значок окна на дисплее. Для этого типа операционной системы этой функции необходимо создать и установить значок перед вызовом pygame.display.set_mode ().
    
    pygame.display.set_caption()
    
    Установите строку заголовка текущего окна.
    
    set_caption(title, icontitle=None) -> None
    
    Если в окне дисплея есть строка заголовка, эта функция изменит текст строки заголовка окна. Некоторые операционные системы поддерживают переключение строки заголовка, когда окно свернуто, путем установки параметра icontitle.
    
    pygame.display.get_caption()
    
    Получить строку заголовка текущего окна.
    
    get_caption() -> (title, icontitle)
    
    Вернуть строку заголовка текущего окна и свернуть строку заголовка, обычно эти два значения совпадают.
    
    pygame.display.set_palette()
    
    Установите палитру интерфейса дисплея.
    
    Интеллектуальная рекомендация
    
    Android Gausso нечеткий реализация
    
    1, используйте скольжение Применимый сценарий: динамическая конфигурация фона изображения 2, на картину Гаусс, вам нужно передавать картинки на битовые объекты Не рекомендую: Используйте растровое изо.
    
    Установите Spark 2.2.1 под облачным сервером Alibaba centos7.2
    
    Выбор версии при установке Spark связан с версией hadoop. Нажмите, чтобы открыть ссылкуПосле ввода выберите подходящее изображение. При нормальных обстоятельствах можно использовать оба .
    
    Заставьте FireFox fieldset имитировать IE в закругленных углах
    
    Метка набора полей написана в Firefox, углы не закруглены, как в IE, что влияет на внешний вид. Мы можем установить стиль в fieldset: .
    
    Установка MongoDB и базовый синтаксис
    
    Метод вызова Notepad ++ и GVIM в Vivado
    
    Метод вызова Notepad ++ и GVIM в Vivado Позвоните Notepad ++ Позвоните в метод GVIM, это не на этом, потому что в середине программных файлов есть пространство Правильный способ установки его на диск .
    
    Читайте также: