Упрощение работы в wxPython при помощи PyCrust

Эта глава включает:

• Взаимодействие с wxPython-программой

• Рассмотрение возможностей PyCrust

• Сопряжение PyCrust с wxPython-приложением

• Работа с GUI и вспомогательными модулями PyCrust

• Взаимодействие wxPython-программы с модулями PyCrust

PyCrust – это написанная на wxPython графическая оболочка, которую Вы можете использовать для анализа wxPython-программ.

Почему она названа PyCrust? Когда Патрик О'браен (Patrick O’Brien), используя wxPython, создавал диалоговую Python-оболочку, очевидно название «PyShell» уже было использовано. Вместо него выбор пал на «PyCrust».

PyCrust – это часть большого пакета Py, который включает дополнительные программы со связанными функциональными возможностями, включая PyFilling, PyAlaMode, PyAlaCarte и PyShell.

Общая идея этих программ - комбинация возможностей визуальной графической (point-and-click) среды, интерактивности wxPython и самоуправления (интроспективность) при выполнении. В отличие от любой из Py-программ, которые усиливают эту комбинацию, PyCrust представляет более полную реализацию этой идеи.

В этой главе, мы покажем Вам, что делают PyCrust и связанные с ним программы, и как Вы можете их использовать, чтобы сделать Вашу работу с потоком wxPython более равномерной. Сначала мы поговорим об обычной Python-оболочке, затем собственно о PyCrust, и, наконец, мы охватим остальные программы в пакете Py.

Как взаимодействовать с wxPython-программой?

Неизменная особенность Python в сравнении с другими языками программирования, состоит в том, что его можно использоваться двумя способами: Вы можете запускать на выполнение существующие Python-программы, или же запустить Python в интерактивном режиме командной строки. Выполнение Python в интерактивном режиме подобно диалогу с Python-интерпретатором. Вы вводите строку кода и нажимаете Enter. Python выполняет этот код, выдает ответ и запрашивает у Вас следующую строку. Такой интерактивный режим существенно отличает Python от таких языков, как C++, Visual Basic или Perl. Имея такой интерпретатор, нет необходимости, чтобы сделать простые вещи, писать в wxPython цельную программу. Фактически, Вы можете даже использовать диалоговый Python как настольный калькулятор.

В листинге 4.1 мы запустили Python в режиме командной строки и выполнили небольшие математические вычисления. Python стартует, отображая несколько строк информации, сопровождаемых его основным приглашением (>>>). Когда Вы введёте, что-нибудь, что потребует дополнительных строк кода, Python покажет вторичное приглашение (...).

Листинг 4.1 Пример интерактивного сеанса Python

   1 $ Python
   2 Python 2.3.3 (#1, Jan 25 2004, 11:06:18)
   3 [GCC 3.2.2 (Mandrake Linux 9.1 3.2.2-3mdk)] on linux2
   4 Type "help", "copyright", "credits" or "license" for more information.
   5 >>> 2 + 2
   6 4
   7 >>> 7 * 6
   8 42
   9 >>> 5 ** 3
  10 125
  11 >>> for n in range(5):
  12 ... print n * 9
  13 ...
  14 0
  15 9
  16 18
  17 27
  18 36
  19 >>>

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

PyCrust устанавливает стандарт оболочки Python

Когда Вы работаете с Python в интерактивном режиме, Вы работаете в среде, называемой Python-оболочкой, которая подобна другим средам, типа окна DOS на платформах Microsoft или командной строке bash в Unix-системах.

Основа всех Python-оболочек, которую Вы видите, когда запускаете Python из командной строки, такая же, как и в листинге 4.1. Хотя Python и полезная оболочка, она полностью ориентирована на текстовый, а не графический режим, и не обеспечивает всех клавиатурных комбинаций (shortcuts) или всплывающих подсказок (hints), которые способен предоставить Python. Чтобы предоставить эти дополнительные функциональные возможности, были специально разработаны несколько графических Python-оболочек. Наиболее общеизвестный является интегрированная среда разработки IDLE (Integrated DeveLopment Environment), которая является стандартной частью дистрибутива Python. Оболочка IDLE, как показано на рисунке 4.1, выглядит подобно оболочке командной строки Python, но имеет дополнительные графические возможности, подобные подсказкам о вызове (calltips).

Другие инструменты для разработки на Python, типа PythonWin или Boa Constructor, имеют графическую оболочку Python, подобную той, что и в IDLE. Существование всех этих оболочек, подтолкнуло к созданию PyCrust. Хотя каждая из инструментальных оболочек имеет некоторые полезные возможности, например, повторный вызов команды, автозавершение и подсказки о вызове, нет инструмента, который бы имел полный набор всех этих возможностей. Одна из целей PyCrust состоит в том, чтобы обеспечить полный набор возможностей всех существующих оболочек Python.

Рисунок 4.1 Оболочка IDLE предоставляет для функций и методов подсказки о вызове

Другой причиной, по которой был создан PyCrust, было то, что инструментальные средства, написанные при помощи одной GUI-библиотеки, часто не работают с кодом от другой GUI-библиотеки. Например, IDLE написан с помощью Tkinter, а не wxPython. До недавнего времени, если бы Вы попытались импортировать и использовать модуль wxPython из Python-оболочки IDLE, Вы бы получили конфликт между циклом событий wxPython и циклом событий Tkinter, что привело бы к останову или краху программы.

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

Какие у PyCrust полезные возможности?

Теперь мы рассмотрим некоторые возможности, которые предоставляет оболочка PyCrust. PyCrust выглядит знакомым, т. к. отображает те же самые строки информации и использует те же сообщения, что и командная строка оболочки Python. Рисунок 4.2 показывает открытый экран PyCrust.

Вы заметите, что фрейм PyCrust, содержащий элемент wx.SplitterWindow, разделен на две секции: верхняя секция напоминает обычную оболочку Python, нижняя секция содержит элемент управления Notebook, который включает разнообразные ярлыки, показывающие информацию о текущем пространстве имен (namespace). Верхняя секция (PyCrust-оболочка), имеет несколько полезных возможностей, обсуждаемых в следующих нескольких подразделах.

Рисунок 4.2 Запущенный PyCrust показывает оболочку и интерфейс на основе ярлыков записной книжки

Автозавершение

Когда Вы вводите имя объекта, завершаемое оператором-точкой, происходит автозавершение. PyCrust показывает алфавитный список всех известных атрибутов данного объекта. Если Вы введете дополнительные буквы, подсвеченный выбор в списке изменится, и будет соответствовать введенным Вами буквам. Если нужный Вам элемент выделен, нажмите клавишу Tab и PyCrust заполнит за Вас остальную часть имени атрибута.

На рисунке 4.3 PyCrust показывает список атрибутов для объекта строки. Список автозавершения включает все свойства и методы этого объекта.

Рисунок 4.3 Отображение атрибутов объекта при автозавершении

Подсказки о вызове (Calltip) и параметры по умолчанию

Когда Вы вводите левую круглую скобку после имени вызываемого объекта, PyCrust показывает окно подсказки о вызове (calltip) (см. рисунок 4.4) с информацией о передаваемых при вызове аргументах и справочной информацией по этому вызову (если она имеется).

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

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

Рисунок 4.4 Подсказка о вызове выводит информацию о вызываемом объекте

Выделение синтаксиса

При вводе кода в оболочку PyCrust изменяет цвет текста в зависимости от его значения. Например, ключевые слова Python появляются в одном цвете, значения текстовых строк в другом, а комментарии в третьем. Это обеспечивает визуальное подтверждение того, что Вы не пропустили каких-либо закрывающих кавычек или не написали с орфографической ошибкой ключевое слово Python.

Многие возможности PyCrust делают возможным поставляемое с wxPython мощное управление текстом. Компонент wx.stc.StyledTextCtrl - wxPython обертка на исходном коде компонента редактирования Scintilla, разработанная Нейлом Ходсоном (Neil Hodgson). Scintilla (www.scintilla.org) используется различными приложениями редактирования исходного кода, включая поставляемые с wxPython демонстрационные программы. Хотя и было бы не легко создать функциональность редактора исходного кода подобную оболочке wxPython, но создать PyCrust без Scintilla было бы практически невозможно.

Помощь по языку Python

PyCrust обеспечивает полную поддержку функций справочной системы по языку Python. Как показано на рисунке 4.5, функция помощи выводит информацию практически обо всех аспектах Python.

Рисунок 4.5 Использование внутри PyCrust функции помощи по Python

Функцию помощи по языку Python обеспечивает дополнительное приглашение (help). После использования помощи, введя quit в ответ на приглашение help, Вы можете покинуть этот режим и вернуться к обычному Python.

Повторный вызов команды

Есть много способов избежать ввода внутри PyCrust. Большинство из них включают в себя запоминание всего того, что Вы предварительно ввели, внесение необходимых изменений и отсылку результата интерпретатору Python. Например, PyCrust поддерживает историю всех команд, которые Вы ввели в текущем сеансе работы. Вы можете повторно вызвать из истории команд любую предварительно введенную команду Python (однострочную или многострочную). Таблица 4.1 показывает список клавиатурных комбинаций, которые касаются этих функциональных возможностей.

Таблица 4.1 Клавиатурные комбинации повторного вызова команд оболочки PyCrust

Как Вы видите, отдельные команды для восстановления и вставки старых команд различаются тем, как PyCrust обращается с текстом, введенным в текущем запросе wxPython. Для замены введенного Вами текста используйте одну из комбинаций, которая извлекает элемент истории. Используйте одну из комбинаций для вставки элемента истории, чтобы вставить старую команду в позицию каретки.

Вставка строки в середину многострочной команды работает по-другому, чем вставка в команду однострочной команды. Нажимая клавишу Enter, Вы не можете вставить строку в многострочную команду, потому что она посылает текущую команду интерпретатору Python. Вместо этого, чтобы вставить разрыв на текущей строке, нажмите Ctrl+Enter. Если Вы находитесь в конце строки, за текущей строкой вставляется пустая строка. Этот процесс похож на вырезание и вставку текста в обычном текстовом редакторе.

Заключительный метод повторного вызова команды состоит в том, чтобы просто переместить каретку на команду, которую Вы хотите вызвать и нажать Enter. PyCrust скопирует эту команду в текущую позицию ввода Python, и поместит каретку в конец. Вы сможете затем изменить команду или снова нажать Enter и послать команду интерпретатору.

Эти клавиатурные комбинации позволяют Вам быстрее разрабатывать код, проверяя на каждом шаге созданный код. Например, Вы можете определить новый класс Python, создать экземпляр этого класса и посмотреть, как он себя ведет. Затем Вы можете вернуться к определению класса, добавить дополнительные методы или редактировать существующие методы и создать новый экземпляр. Повторяя это столько, сколько Вам нужно, Вы сможете развить определение класса до такой степени, что оно будет достаточно хорошим, чтобы его вырезать и вставлять в исходном коде программы. И это приведет нас к нашей следующей возможности.

Вырезание (Cut) и вставка (Paste)

Иногда Вам может потребоваться использовать разработанный в оболочке код без необходимости его повторного ввода. В других случаях, Вы можете найти образец кода, возможно в онлайновом руководстве и использовать его в Python-оболочке. PyCrust предоставляет несколько простых операций вырезания и вставки, перечисленных в таблице 4.2.

Таблица 4.2 Клавиатурные комбинации вырезания и вставки оболочки PyCrust

Другая особенность операции вставки состоит в том, что PyCrust распознает и автоматически удаляет из любого кода, вставляемого в PyCrust-оболочку, стандартные приглашения Python (>>>). Это облегчает копирование образцов кода из руководства или почтового сообщения, вставку и использование его в PyCrust без необходимости делать ручную чистку.

Иногда, когда Вы копируете код, Вам может понадобиться удалить приглашения PyCrust, как например, при копировании кода в ваши исходные файлы. В другой раз, Вы захотите сохранить приглашения, например, когда Вы копируете примеры в какой-либо документ или отправляете в группу новостей. PyCrust обеспечивает оба варианта при копировании текста из оболочки.

Стандартное окружение оболочки

В максимально возможной степени в пределах среды wxPython, PyCrust ведет себя так же, как и Python-оболочка командной строки. Имеются в виду некоторые необычные ситуации, как например, травление (pickling) экземпляров классов, которые определены в рамках сеанса оболочки. Единственная область, где PyCrust даёт сбой, кроется в его способности замещать функциональные возможности командной строки, являющиеся клавиатурными прерываниями. Как только код Python введен в PyCrust-оболочку, нет возможности прервать его выполнение. Например, предположим, Вы закодировали в PyCrust бесконечный цикл, как в следующем примере:

   1 >>> while True:
   2 ...    print "Hello"
   3 ...

После того, как Вы нажмете Enter, и код отправится интерпретатору Python, PyCrust приостановит ответную реакцию. Чтобы прерывать бесконечный цикл, завершите программу PyCrust. Этот недостаток PyCrust - отличие от Python-оболочки командной строки, которая сохраняет способность обрабатывать клавиатурное прерывание (Ctrl+C). В Python-оболочке командной строки Вы увидели бы следующее поведение:

   1 >>> while True:
   2 ...    print "Hello"
   3 ...
   4 Hello
   5 Hello
   6 Hello
   7 Hello
   8 Hello
   9 Hello
  10 Hello
  11 Hello
  12 Hello
  13 Hello
  14 Hello
  15 Traceback (most recent call last):
  16   File "<stdin>", line 2, in ?
  17 KeyboardInterrupt
  18 >>>

Механизм обработки событий в GUI среде чрезвычайно затрудняет решение, которое позволило бы PyCrust преодолеть бесконечный цикл или прервать любую длительно исполняемую последовательность введенного в приглашение оболочки кода. Будущая версия PyCrust может обеспечить решение этого вопроса. Между тем, помните об этом поведении. К счастью, это единственное известное различие между PyCrust и стандартной командной оболочкой. Во всех других отношениях, оболочка PyCrust работает точно так же, как и оболочка командной строки Python.

Динамическое обновление

После запуска оболочки PyCrust все ее возможности динамически обновляются, и такие свойства как автозавершение и подсказка о вызове будут доступными даже для объектов, определяемых при непосредственном вводе команд и данных в строке приглашения оболочки. Например, посмотрите показанные на рисунках 4.6 и 4.7 сеансы, где мы определяем и используем класс.

На рисунке 4.6 PyCrust показывает доступные для нового класса варианты автозавершения.

На рисунке 4.7 PyCrust показывает подсказку о вызове для недавно определенного метода класса.

Рисунок 4.6 Динамически генерированная PyCrust информация автозавершения

Рисунок 4.7 Динамически генерированная PyCrust информация подсказки о вызове

Это иллюстрирует реализуемый PyCrust способ динамического выполнения Python, который невозможен в других языках программирования со статическим вводом и компиляцией.

Каково назначение страниц PyCrust?

В нижней половине интерфейса PyCrust расположен элемент наподобие блокнота (notebook), который включает несколько страниц полезной информации. Появляющаяся при старте страница PyCrust – это Namespace (пространство имен).

Страница Namespace (Пространство имен)

Показанная на рисунке 4.8 страница Namespace, разделена на две части, где снова используется элемент wx.SplitterWindow. Левая сторона содержит элемент управления деревом, который отображает текущее пространство имен, а правая сторона отображает информацию о текущем объекте, выбранном в дереве пространства имен.

Рисунок 4.8 Дерево пространства имен PyCrust позволяет погружаться в объекты и инспектировать их атрибуты

Дерево Namespace представляет иерархический вид всех объектов в текущем пространстве имен. В нем содержатся пункты, которые возвращаются при работе встроенной функции Python locals(). На рисунке 4.8, мы импортировали пакет wx и выбрали его в дереве пространства имен. Правая сторона отображает имя выбранного элемента, его тип и текущее значение. Если объект имеет ассоциированный с ним исходный код, PyCrust также его отображает. В этом случае, wx является пакетом wxPython, поэтому PyCrust отображает исходный код из файла init.py, который находится в директории wx. Первая строка экрана предоставляет имя объекта, полностью пригодное, для операций вырезания и вставки в оболочку PyCrust или в исходный код Вашего приложения. Например, если Вы импортируете и откроете модуль locale, Вы можете достичь элементов этого модуля, сохраненных внутри атрибута словаря encoding_alias. Как только Вы выберете один из этих элементов, Вы можете вырезать и вставлять его отображаемое имя непосредственно в оболочку PyCrust, например следующим образом:

   1 >>> import locale
   2 >>> locale.encoding_alias['en']
   3 'ISO8859-1'
   4 >>>

В этом случае, PyCrust снабдил нас полностью пригодным именем (locale.encoding_alias['en']), использующим индексную нотацию Python (['en']) для ссылки на определенный пункт словаря encoding_alias. Этот механизм также работает и для списков. Если Вы что-то указываете в дереве пространства имен для ссылки в своем коде, PyCrust даёт Вам точный синтаксис для выполнения этой задачи.

Страница Display (Экран)

Страница Display отображает красивый вид объекта. PyCrust имеет встроенную функцию pp(), которая использует модуль качественной печати Python (pprint) для выполнения хорошо отформатированного вида любого объекта wxPython. Информация на странице Display корректируется при каждом обновлении отображаемого объекта, не требуя от Вас явного импортирования и многократного использования pprint.

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

Страница Calltip (Подсказка о вызове)

Страница Calltip отображает содержание последней подсказки о вызове Python-оболочки. Выберите страницу Calltip, если Вы работаете с вызываемыми объектами, которые требуют большого количества передаваемых им параметров. При использовании пакета wxPython существует много классов, которые могут иметь много методов, принимающих множество параметров. Например, для создания wx.Button, Вы можете передать вплоть до восьми параметров, один из которых обязателен, тогда как другие семь имеют значение по умолчанию. Страница Calltip отображает следующую информацию о конструкторе wx.Button:

   1 __init__(self, Window parent, int id=-1, String label=EmptyString,
   2    Point pos=DefaultPosition, Size size=DefaultSize,
   3    long style=0, Validator validator=DefaultValidator,
   4    String name=ButtonNameStr) -> Button
   5 Create and show a button. The preferred way to create standard buttons
   6 is to use a standard ID and an empty label. In this case wxWigets will
   7 automatically use a stock label that corresponds to the ID given. In
   8 addition, the button will be decorated with stock icons under GTK+2.

Поскольку классы wxPython в действительности надстроены над классами C++, информация для подсказок о вызове основывается только на документации класса (docstrings). Она сгенерирована, чтобы показать требуемые базовому классу C++ состав передаваемых параметров и их тип (int, string, point и т.д.). Вот почему подсказка о вызове конструктора wx.Button показывается таким способом.

PyCrust инспектирует объекты, полностью определенные на языке Python, полагаясь на характер их аргументов.

Страница Session (Сеанс)

Страница Session (в новых версиях – History (История)) является простым текстовым элементом, который перечисляет все команды, введенные в текущем сеансе оболочки. Это облегчает вырезание и вставку команд для использования где-нибудь еще, при этом нет необходимости удалять отклик, который возвращается интерпретатором wxPython.

Страница Dispatcher (Диспетчер)

PyCrust включает модуль, названный dispatcher, предоставляющий механизм для свободного связывания объектов внутри приложения. PyCrust использует диспетчер, чтобы держать аспекты своего интерфейса актуальными, когда команды посылаются из оболочки в интерпретатор Python. Страница Dispatcher (рисунок 4.9) содержит информацию о сигналах, проходящих через механизм диспетчеризации. Прежде всего это полезно при работе непосредственно с PyCrust.

Страница Dispatcher также иллюстрирует, как добавить другую страницу в элемент wx.Notebook. Приведенный ниже исходный код отображаемого на странице Dispatcher элемента управления текстом, показывает, как может быть использован модуль диспетчера:

   1 class DispatcherListing(wx.TextCtrl):
   2     """Text control containing all dispatches for session."""
   3     def __init__(self, parent=None, id=-1):
   4         style = (wx.TE_MULTILINE | wx.TE_READONLY |
   5             wx.TE_RICH2 | wx.TE_DONTWRAP)
   6         wx.TextCtrl.__init__(self, parent, id, style=style)
   7         dispatcher.connect(receiver=self.spy)
   8     def spy(self, signal, sender):
   9         """Receiver for Any signal from Any sender."""
  10         text = '%r from %s' % (signal, sender)
  11         self.SetInsertionPointEnd()
  12         start, end = self.GetSelection()
  13         if start != end:
  14             self.SetSelection(0, 0)
  15         self.AppendText(text + '\n')

Теперь, когда Вы увидели, что может делать PyCrust как автономная оболочка Python и инспектор пространства имен, давайте взглянем на некоторые приемы использования PyCrust в Ваших собственных программах wxPython.

Рисунок 4.9 Диспетчер PyCrust информирует о том, каким образом команды передаются интерпретатору Python

Как связать PyCrust с моим wxPython-приложением?

Допустим, Вы использовали wxPython для создания программы, Ваша программа работает, и теперь Вы хотели бы лучше понять, как именно она работает. В этой главе Вы увидели возможности PyCrust и они могут оказаться очень полезными для понимания функционирования Вашей программы. Но Вам не хотелось бы изменять программу только для того, чтобы использовать ее с PyCrust. Что же делать в этом случае?

Передавая имя Вашей программы утилите PyWrap, Вы сможете без изменений ее запустить под оболочкой PyCrust. Листинг 4.2 показывает программу spare.py, которую мы подготовили для связи с PyCrust.

Листинг 4.2 Программа spare.py, подготовленная для связи с PyCrust

   1 #!/usr/bin/env python
   2 """Spare.py is a starting point for simple wxPython programs."""
   3 import wx
   4 
   5 class Frame(wx.Frame):
   6     pass
   7 class App(wx.App):
   8     def OnInit(self):
   9          self.frame = Frame(parent=None, id=-1, title='Spare')
  10          self.frame.Show()
  11          self.SetTopWindow(self.frame)
  12          return True
  13 if __name__ == '__main__':
  14     app = App()
  15     app.MainLoop()

Для запуска этой программы в окружении PyCrust, передайте имя программы в PyWrap из каталога, где находится spare.py. Командная строка под Linux выглядит так:

$ pywrap spare.py

Когда PyWrap стартует, он попытается импортировать модуль, включенный в командную строку. Затем PyWrap ищет в этом модуле подкласс wx.App и создает экземпляр этого класса. После этого создает окно PyWrap wx.py.crust.CrustFrame с оболочкой, открывает прикладной объект в дереве пространства имен PyCrust и запускает цикл событий wxPython.

Полный исходный код для PyWrap приведен в листинге 4.3. Это пример того, как много функциональных возможностей можно добавить в Вашу программу, используя небольшое количество дополнительного кодекса.

Листинг 4.3 Исходный код PyWrap.py

   1 """PyWrap is a command line utility that runs a python
   2 program with additional runtime tools, such as PyCrust."""
   3 __author__ = "Patrick K. O'Brien <pobrien@orbtech.com>"
   4 __cvsid__ = "$Id: PyCrust.txt,v 1.15 2005/03/29 23:39:27 robind Exp $"
   5 __revision__ = "$Revision: 1.15 $"[11:-2]
   6 import os
   7 import sys
   8 import wx
   9 from wx.py.crust import CrustFrame
  10 def wrap(app):
  11     wx.InitAllImageHandlers()
  12     frame = CrustFrame()
  13     frame.SetSize((750, 525))
  14     frame.Show(True)
  15     frame.shell.interp.locals['app'] = app
  16     app.MainLoop()
  17 def main(modulename=None):
  18     sys.path.insert(0, os.curdir)
  19     if not modulename:
  20         if len(sys.argv) < 2:
  21              print "Please specify a module name."
  22              raise SystemExit
  23         modulename = sys.argv[1]
  24         if modulename.endswith('.py'):
  25              modulename = modulename[:-3]
  26     module = __import__(modulename)
  27     # Find the App class.
  28     App = None
  29     d = module.__dict__
  30     for item in d.keys():
  31         try:
  32              if issubclass(d[item], wx.App):
  33                   App = d[item]
  34         except (NameError, TypeError):
  35              pass
  36     if App is None:
  37         print "No App class was found."
  38         raise SystemExit
  39     app = App()
  40     wrap(app)
  41 if __name__ == '__main__':
  42     main()

После запуска команды PyWrap будут отображены как простой фрейм из spare.py, так и фрейм PyCrust.

PyCrust в действии

Теперь давайте посмотрим, что мы можем сделать с прикладным фреймом из оболочки PyCrust. Рисунок 4.10 отображает результат. Сначала мы spare.py импортируем wx и добавим в наш фрейм панель:

   1 >>> import wx
   2 >>> app.frame.panel = wx.Panel(parent=app.frame)
   3 >>> app.frame.panel.SetBackgroundColour('White')
   4 True
   5 >>>

Рисунок 4.10 Использование PyWrap для оптимизации выполнения wxPython-программы

Добавленная к фрейму панель имеет по умолчанию серый цвет, затем он изменен на белый. Однако, установка цвета фона панели не проявляется немедленно. Для этого нужно инициировать событие, которое заставит панель перерисовать себя на основании свойства ее нового фонового цвета. Единственный способ инициировать это событие – потребовать, чтобы панель себя обновила:

   1 >>> app.frame.panel.Refresh()

Теперь белая панель отображена, и мы на один шаг ближе к пониманию деталей того, как действительно работает wxPython.

Давайте добавим еще и строку состояния (status bar):

   1 >>> app.frame.statusbar = app.frame.CreateStatusBar(number=3)
   2 >>> app.frame.statusbar.SetStatusText("Left", 0)
   3 >>> app.frame.statusbar.SetStatusText("Center", 1)
   4 >>> app.frame.statusbar.SetStatusText("Right", 2)

Заметьте, как строка состояния появляется в пределах фрейма, не изменяя самые крайние размеры фрейма. Также, обратите внимание, что добавленный в каждую из трех секций текст строки состояния появляется немедленно и не требует обновления. Теперь давайте добавим меню и строку меню (menubar):

   1 >>> app.frame.menubar = wx.MenuBar()
   2 >>> menu = wx.Menu()
   3 >>> app.frame.menubar.Append(menu, "Primary")
   4 True
   5 >>> app.frame.SetMenuBar(app.frame.menubar)
   6 >>> menu.Append(wx.NewId(), "One", "First menu item")
   7 <wx.core.MenuItem; proxy of C++ wxMenuItem instance at
   8   _d8043d08_p_wxMenuItem>
   9 >>> menu.Append(wx.NewId(), "Two", "Second menu item")
  10 <wx.core.MenuItem; proxy of C++ wxMenuItem instance at
  11   _40a83e08_p_wxMenuItem>
  12 >>>

Когда Вы манипулируете своими wxPython-объектами в оболочке PyCrust, помните о влиянии этих изменений на Вашу выполняемую программу. Попытайтесь ответить на следующие вопросы. Когда меню действительно появляется в пределах фрейма? Какие атрибуты меню Вы можете изменить, пока выполняется программа? Можете ли Вы добавить дополнительные пункты меню? Можете ли Вы удалить их? Можете ли Вы их блокировать? Изучение всех этих возможностей должно помочь лучше понять wxPython и обеспечить Вас большей уверенностью, когда придет время записи фактического программного кода.

Теперь, когда мы потратили большую часть главы на обсуждение PyCrust, мы готовы пойти на прогулку через остальную часть компонентов пакета Py.

Что еще имеется в пакете Py?

Все программы PyCrust просто используют включенные в пакет Py модули Python, например, такие как shell.py, crust.py, introspect.py и interpreter.py. Эти программы являются строительными блоками, которые использованы для создания PyCrust и Вы можете использовать их раздельно или вместе.

Считайте, что PyCrust представляет одно направление трансляции битов и частей функционального наполнения, содержащегося в пакете Py. PyShell представляет другое направление, а PyAlaMode - третье. В каждом из этих случаев, большая часть основного кода является общей для всех них с некоторым отдаленным изменением контейнеров. Поэтому считайте пакет Py библиотекой модулей, которые Вы можете собрать, как Вам нравится, и где бы Вы хотели отобразить оболочку wxPython, в редакторе кода или в информации времени выполнения в пределах Вашей программы.

Внутри пакета Py существует четкое разделение между модулями, обеспечивающими функциональность интерфейса пользователя и другими модулями. Такое разделение значительно облегчает использование этих модулей в Ваших собственных программах. Все модули, начинающиеся с Py, например, PyCrust, PyShell, PyAlaMode и PyAlaCarte – это GUI программы конечного пользователя. У вас не будет необходимости импортировать в Ваши программы какой-нибудь из этих модулей. Следующий параграф описывает модули конечного пользователя.

Работа с GUI-программами

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

Таблица 4.3 Программы конечного пользователя, включенные в пакет Py

Работа с модулями поддержки

Модули поддержки обеспечивает базовую функциональность программ конечного пользователя, и могут быть импортированы в Ваши собственные программы. Эти модули являются по существу строительными блоками для создания Py-программ пользовательского уровня. Таблица 4.4 содержит перечень модулей поддержки, являющихся частью пакета Py, вместе с их кратким описанием.

Таблица 4.4 Модули поддержки пакета Py

Перевод: Савицкий Юрий