В этой главе рассказывается о том, как:

• создавать модальные диалоговые окна и окна с сообщениями
• использовать стандартные диалоги
• создавать помощников
• показывать советы при запуске
• создавать и использовать валидаторы

9.1 Работа с модальными диалогами

9.1.1 Как создать модальный диалог

import wx
class SubclassDialog(wx.Dialog):
    def __init__(self):              #инициируем диалог
        wx.Dialog.__init__(self, None, -1, 'Dialog Subclass',size=(300, 100))
        okButton = wx.Button(self, wx.ID_OK, "OK", pos=(15, 15))
        okButton.SetDefault()
        cancelButton = wx.Button(self, wx.ID_CANCEL, "Cancel",pos=(115, 15))
if __name__ == '__main__':
    app = wx.PySimpleApp()
    dialog = SubclassDialog()
    result = dialog.ShowModal()   #показываем модальный диалог
    if result == wx.ID_OK:
        print "OK"
    else:
        print "Cancel"
        dialog.Destroy()

1. когда нажимается wx.Button с ID равным wx.ID_OK, диалог закрывается и в точку вызова ShowModal() возвращается значение wx.ID_OK
2. аналогично действует нажатие на кнопку со значением wx.ID_CANCEL, возвращающая соответствующее значение

после чего приложению остаётся лишь корректно обработать значения кнопок.

9.1.2 Как вывести пользователю сообщение?

Листинг 9.2

import wx
if __name__ 
== "__main__":
    app = wx.PySimpleApp()
    # с использованием классов
    dlg = wx.MessageDialog(None, "Is this explanation OK?",
                           'A Message Box',wx.YES_NO | wx.ICON_QUESTION)
    retCode = dlg.ShowModal()
    if (retCode == wx.ID_YES):
        print "yes"
    else:
        print "no"
    dlg.Destroy()
    # с использованием функции
    retCode = wx.MessageBox("Is this way easier?", "Via Function",
                            wx.YES_NO | wx.ICON_QUESTION)

Использование функции wx.MessageBox()

9.1.3 Как получить короткий текст от пользователя?

Листинг9.3

import wx
if __name__ == "__main__":
    app = wx.PySimpleApp()
    dialog = wx.TextEntryDialog(None,
        "What kind of text would you like to enter?",
        "Text Entry", "Default Value", style=wx.OK|wx.CANCEL)
    if dialog.ShowModal() == wx.ID_OK:
        print "You entered: %s" % dialog.GetValue()
    dialog.Destroy()

9.2 Использование стандартных диалогов

9.2.1 Диалог выбора файла

Листинг 9.6

import wx
import os
if __name__ == "__main__":
    app = wx.PySimpleApp()
    wildcard = "Python source (*.py)|*.py|" 
        "Compiled Python (*.pyc)|*.pyc|" 
        "All files (*.*)|*.*"
    dialog = wx.FileDialog(None, "Choose a file", os.getcwd(),
        "", wildcard, wx.OPEN)
    if dialog.ShowModal() == wx.ID_OK:
        print dialog.GetPath()
    dialog.Destroy()

Выбор файла

Выбор папки

Листинг 9.7

import wx
if __name__ == "__main__":
    app = wx.PySimpleApp()
    dialog = wx.DirDialog(None, "Choose a directory:",
        style=wx.DD_DEFAULT_STYLE | wx.DD_NEW_DIR_BUTTON)
    if dialog.ShowModal() == wx.ID_OK:
        print dialog.GetPath()
    dialog.Destroy()

9.2.2 Диалог выбора шрифта

9.3 Создание мастеров

import wx
import wx.wizard
# создаём простую страницу
class TitledPage(wx.wizard.WizardPageSimple):
    def __init__(self, parent, title):
        wx.wizard.WizardPageSimple.__init__(self, parent)
        self.sizer = wx.BoxSizer(wx.VERTICAL)
        self.SetSizer(self.sizer)
        titleText = wx.StaticText(self, -1, title)
        titleText.SetFont(
        wx.Font(18, wx.SWISS, wx.NORMAL, wx.BOLD))
        self.sizer.Add(titleText, 0,
            wx.ALIGN_CENTRE | wx.ALL, 5)
        self.sizer.Add(wx.StaticLine(self, -1), 0,
            wx.EXPAND | wx.ALL, 5)
if __name__ == "__main__":
    app = wx.PySimpleApp()
    # создаём экземпляр мастера
    wizard = wx.wizard.Wizard(None, -1, "Simple Wizard")
    # создаём страницы мастера
    page1 = TitledPage(wizard, "Page 1")
    page2 = TitledPage(wizard, "Page 2")
    page3 = TitledPage(wizard, "Page 3")
    page4 = TitledPage(wizard, "Page 4")
    page1.sizer.Add(wx.StaticText(page1, -1,
        "Testing the wizard"))
    page4.sizer.Add(wx.StaticText(page4, -1,
        "This is the last page."))
    # задаём последовательность страниц
    wx.wizard.WizardPageSimple_Chain(page1, page2)
    wx.wizard.WizardPageSimple_Chain(page2, page3)
    wx.wizard.WizardPageSimple_Chain(page3, page4)
    # задаём размер мастера
    wizard.FitToPage(page1)
    # запускаем мастера
    if wizard.RunWizard(page1):
        print "Success"

9.4 Отображение подсказок при запуске

Листинг 9.12

import wx
if __name__ == "__main__":
    app = wx.PySimpleApp()
    provider = wx.CreateFileTipProvider("tips.txt", 0)
    wx.ShowTip(None, provider, True)

Автор: Ishayahu Lastov

9.5 Использование валидаторов

9.5.1 Как с помощью валидатора убедиться, что я получил верные данные?

import wx
about_txt = """
Валидатор, используемый в этом примере проверяет наличие текста в
текстовых полях при нажатии на кнопку "ок" и не даёт Вам закрыть диалог,
если это условие не выполняется."""

# создаём подкласс валидатора
class NotEmptyValidator(wx.PyValidator):
    def __init__(self):
        wx.PyValidator.__init__(self)

    def Clone(self):
        """
        Обратите внимание, что каждый валидатор должен реализовать метод Clone().
        """
        return NotEmptyValidator()

    # метод проверки
    def Validate(self, win):
        textCtrl = self.GetWindow()
        text = textCtrl.GetValue()

        if len(text) == 0:
            wx.MessageBox("This field must contain some text!", "Error")
            textCtrl.SetBackgroundColour("pink")
            textCtrl.SetFocus()
            textCtrl.Refresh()
            return False
        else:
            textCtrl.SetBackgroundColour(
                wx.SystemSettings_GetColour(wx.SYS_COLOUR_WINDOW))
            textCtrl.Refresh()
            return True

    def TransferToWindow(self):
        return True

    def TransferFromWindow(self):
        return True

class MyDialog(wx.Dialog):
    def __init__(self):
            wx.Dialog.__init__(self, None, -1, "Validators: validating")
            
            # Создаём поля для ввода текста
            about = wx.StaticText(self, -1, about_txt)
            name_l = wx.StaticText(self, -1, "Name:")
            email_l = wx.StaticText(self, -1, "Email:")
            phone_l = wx.StaticText(self, -1, "Phone:")
            
            # используем валидаторы
            name_t = wx.TextCtrl(self, validator=NotEmptyValidator())
            email_t = wx.TextCtrl(self, validator=NotEmptyValidator())
            phone_t = wx.TextCtrl(self, validator=NotEmptyValidator())

            # Используем стандартные ID кнопок
            okay = wx.Button(self, wx.ID_OK)
            okay.SetDefault()
            cancel = wx.Button(self, wx.ID_CANCEL)

            # размещаем виджеты с помощью координаторов
            sizer = wx.BoxSizer(wx.VERTICAL)
            sizer.Add(about, 0, wx.ALL, 5)
            sizer.Add(wx.StaticLine(self), 0, wx.EXPAND|wx.ALL, 5)

            fgs = wx.FlexGridSizer(3, 2, 5, 5)
            fgs.Add(name_l, 0, wx.ALIGN_RIGHT)
            fgs.Add(name_t, 0, wx.EXPAND)
            fgs.Add(email_l, 0, wx.ALIGN_RIGHT)
            fgs.Add(email_t, 0, wx.EXPAND)
            fgs.Add(phone_l, 0, wx.ALIGN_RIGHT)
            fgs.Add(phone_t,
0, wx.EXPAND)
            fgs.AddGrowableCol(1)
            sizer.Add(fgs, 0, wx.EXPAND|wx.ALL, 5)

            btns = wx.StdDialogButtonSizer()
            btns.AddButton(okay)
            btns.AddButton(cancel)
            btns.Realize()
            sizer.Add(btns, 0, wx.EXPAND|wx.ALL, 5)

            self.SetSizer(sizer)
            sizer.Fit(self)

app = wx.PySimpleApp()

dlg = MyDialog()
dlg.ShowModal()
dlg.Destroy()

app.MainLoop()

1. Метод Validate() проверяет, что связанные с ним виджеты содержат какой-нибудь текст. Если же это не так, то цвет их фона меняется на розовый
2. Для использования валидатора мы прикрепляем его к виджету, передавая в качестве аргумента конструктора виджета экземпляр нашего класса

9.5.2 Передача данных с помощью валидаторов

import wx
import pprint

about_txt = """
В данном примере валидатор используется для демонстрации
возможности автоматической передачи данных в и из текстового поля
при открытии и закрытии диалога."""

# объявляем валидатор
class DataXferValidator(wx.PyValidator):
    def __init__(self, data, key):
        wx.PyValidator.__init__(self)
        self.data = data
        self.key = key

def Clone(self):
    """
    Будьте внимательны: каждый валидатор должен реализовать метод Clone()
    """
    return DataXferValidator(self.data, self.key)

# не проверяем данные
def Validate(self, win):
    return True

# вызывается при открытии диалога
def TransferToWindow(self):
    textCtrl = self.GetWindow()
    textCtrl.SetValue(self.data.get(self.key, ""))
    return True

# вызывается при закрытии диалога
def TransferFromWindow(self):
    textCtrl = self.GetWindow()
    self.data[self.key] = textCtrl.GetValue()
    return True

class MyDialog(wx.Dialog):
    def __init__(self, data):
        wx.Dialog.__init__(self, None, -1, "Validators: data transfer")

        about = wx.StaticText(self, -1, about_txt)
        name_l = wx.StaticText(self, -1, "Name:")
        email_l = wx.StaticText(self, -1, "Email:")
        phone_l = wx.StaticText(self, -1, "Phone:")

        name_t = wx.TextCtrl(self,
            validator=DataXferValidator(data, "name"))
        email_t = wx.TextCtrl(self,
            validator=DataXferValidator(data, "email"))
        phone_t = wx.TextCtrl(self,
            validator=DataXferValidator(data, "phone"))

        okay = wx.Button(self, wx.ID_OK)
        okay.SetDefault()
        cancel = wx.Button(self, wx.ID_CANCEL)

        sizer = wx.BoxSizer(wx.VERTICAL)
        sizer.Add(about, 0, wx.ALL, 5)
        sizer.Add(wx.StaticLine(self), 0, wx.EXPAND|wx.ALL, 5)

        fgs = wx.FlexGridSizer(3, 2, 5, 5)
        fgs.Add(name_l, 0, wx.ALIGN_RIGHT)
        fgs.Add(name_t, 0, wx.EXPAND)
        fgs.Add(email_l, 0, wx.ALIGN_RIGHT)
        fgs.Add(email_t, 0, wx.EXPAND)
        fgs.Add(phone_l, 0, wx.ALIGN_RIGHT)
        fgs.Add(phone_t, 0, wx.EXPAND)
        fgs.AddGrowableCol(1)
        sizer.Add(fgs, 0, wx.EXPAND|wx.ALL, 5)

        btns = wx.StdDialogButtonSizer()
        btns.AddButton(okay)
        btns.AddButton(cancel)
        btns.Realize()
        sizer.Add(btns, 0, wx.EXPAND|wx.ALL, 5)

        self.SetSizer(sizer)
        sizer.Fit(self)

app = wx.PySimpleApp()

data = { "name" : "Jordyn Dunn" }
dlg = MyDialog(data)
dlg.ShowModal()
dlg.Destroy()

wx.MessageBox("You entered these values:nn" +
        pprint.pformat(data))
app.MainLoop()

9.5.3 Как проверять данные в процессе ввода?

import wx
import string

about_txt = """
Валидатор, используемый в данном примере проверяет "на лету" ввод данных
пользователем и не ждёт нажатия кнопки "ок". Первое поле не допускает
ввода цифр, во второе поле можно ввести всё, что угодно, а в третье - 
всё, кроме букв.
"""

class CharValidator(wx.PyValidator):
    def __init__(self, flag):
        wx.PyValidator.__init__(self)
        self.flag = flag
        # связываем функцию с событием ввода символа
        self.Bind(wx.EVT_CHAR, self.OnChar)

    def Clone(self):
        """
        Будьте внимательны: каждый валидатор должен реализовать метод Clone()
        """
        return CharValidator(self.flag)

    def Validate(self, win):
        return True

    def TransferToWindow(self):
        return True

    def TransferFromWindow(self):
        return True

    # обработчик ввода данных в виджет
    def OnChar(self, evt):
        key = chr(evt.GetKeyCode())
        if self.flag == "no-alpha" and key in string.letters:
            return
        if self.flag == "no-digit" and key in string.digits:
            return
        evt.Skip()

class MyDialog(wx.Dialog):
    def __init__(self):
        wx.Dialog.__init__(self, None, -1, "Validators: behavior
            modification")

        # Создаём поля для ввода текста
        about = wx.StaticText(self, -1, about_txt)
        name_l = wx.StaticText(self, -1, "Name:")
        email_l = wx.StaticText(self, -1, "Email:")
        phone_l = wx.StaticText(self, -1, "Phone:")

        # добавляем валидатор
        name_t = wx.TextCtrl(self, validator=CharValidator("no-digit"))
        email_t = wx.TextCtrl(self, validator=CharValidator("any"))
        phone_t = wx.TextCtrl(self, validator=CharValidator("no-alpha"))
        okay = wx.Button(self, wx.ID_OK)
        okay.SetDefault()
        cancel = wx.Button(self, wx.ID_CANCEL)
        sizer = wx.BoxSizer(wx.VERTICAL)
        sizer.Add(about, 0, wx.ALL, 5)
        sizer.Add(wx.StaticLine(self), 0, wx.EXPAND|wx.ALL, 5)

        fgs = wx.FlexGridSizer(3, 2, 5, 5)
        fgs.Add(name_l, 0, wx.ALIGN_RIGHT)
        fgs.Add(name_t, 0, wx.EXPAND)
        fgs.Add(email_l, 0, wx.ALIGN_RIGHT)
        fgs.Add(email_t, 0, wx.EXPAND)
        fgs.Add(phone_l, 0, wx.ALIGN_RIGHT)
        fgs.Add(phone_t, 0, wx.EXPAND)
        fgs.AddGrowableCol(1)
        sizer.Add(fgs, 0, wx.EXPAND|wx.ALL, 5)

        btns = wx.StdDialogButtonSizer()
        btns.AddButton(okay)
        btns.AddButton(cancel)
        btns.Realize()
        sizer.Add(btns, 0, wx.EXPAND|wx.ALL, 5)

        self.SetSizer(sizer)
        sizer.Fit(self)

app = wx.PySimpleApp()

dlg = MyDialog()
dlg.ShowModal()
dlg.Destroy()

app.MainLoop()

В этой главе Вы узнаете:

1. Как создавать меню
2. Как работать с элементами меню
3. Как добавлять подменю, всплывающие меню и собственные виды меню
4. Как создавать удобные меню

10.1 Создаём меню

• Создать полосу меню (menu bar)
• Добавить полосу меню к фрейму
• Создать отдельные меню
• Добавить эти меню к полосе меню или к родительскому меню
• Создать отдельные пункты меню
• Добавить эти пункты к соответствующим меню
• Создать привязку (binding) для событий каждого пункта меню

10.1.1 Как создать полосу меню и прикрепить её к фрейму.

10.1.2 Как создать меню и прикрепить его к полосе меню?

import wx
class MyFrame(wx.Frame):
    def __init__(self):
        wx.Frame.__init__(self, None, -1, "Simple Menu Example")
        p = wx.Panel(self)
        # создаём панель меню
        menuBar = wx.MenuBar()
        # создаём меню
        menu = wx.Menu()
        # добавляем меню к панели меню
        menuBar.Append(menu, "Left Menu")
        menu2 = wx.Menu()
        menuBar.Append(menu2, "Middle Menu")
        menu3 = wx.Menu()
        menuBar.Append(menu3, "Right Menu")
        self.SetMenuBar(menuBar)
if __name__ == "__main__":
    app = wx.PySimpleApp()
    frame = MyFrame()
    frame.Show()
    app.MainLoop()

10.1.3 Как добавить элементы в выпадающее меню?

import wx
class MyFrame(wx.Frame):
    def __init__(self):
        wx.Frame.__init__(self, None, -1,
            "Menu Example with StatusBar")
        p = wx.Panel(self)
        self.CreateStatusBar()
        menu = wx.Menu()
        simple = menu.Append(-1, "Simple menu item",
            "This is some help text")
        menu.AppendSeparator()
        exit = menu.Append(-1, "Exit",
            "Selecting this item will exit the program")
        self.Bind(wx.EVT_MENU, self.OnSimple, simple)
        self.Bind(wx.EVT_MENU, self.OnExit, exit)
        menuBar = wx.MenuBar()
        menuBar.Append(menu, "Menu")
        self
.SetMenuBar(menuBar)
    def OnSimple(self, event):
        wx.MessageBox("You selected the simple menu item")
    def OnExit(self, event):
        self.Close()

if __name__ == "__main__":
    app = wx.PySimpleApp()
    frame = MyFrame()
    frame.Show()
    app.MainLoop()

import wx
class MyFrame(wx.Frame):
    def __init__(self):
        wx.Frame.__init__(self, None, -1,
            "Add Menu Items")
        p = wx.Panel(self)
        self.txt = wx.TextCtrl(p, -1, "new item")
        btn = wx.Button(p, -1, "Add Menu Item")
        # связываем метод с событием кнопки
        self.Bind(wx.EVT_BUTTON, self.OnAddItem, btn)

        sizer = wx.BoxSizer(wx.HORIZONTAL)
        sizer.Add(self.txt, 0, wx.ALL, 20)
        sizer.
Add(btn, 0, wx.TOP|wx.RIGHT, 20)
        p.SetSizer(sizer)

        self.menu = menu = wx.Menu()
        simple = menu.Append(-1, "Simple menu item")
        menu.AppendSeparator()
        exit = menu.Append(-1, "Exit")
        self.Bind(wx.EVT_MENU, self.OnSimple, simple)
        self.Bind(wx.EVT_MENU, self.OnExit, exit)

        menuBar = wx.MenuBar()
        menuBar.Append(menu, "Menu")
        self.SetMenuBar(menuBar)

    def OnSimple(self, event):
        wx.MessageBox("You selected the simple menu item")

    def OnExit(self, event):
        self.Close()

    def OnAddItem(self, event):
        # добавляем элемент меню
        item = self.menu.Append(-1, self.txt.GetValue())
        # связываем его с методом
        self.Bind(wx.EVT_MENU, self.OnNewItemSelected, item)

    def OnNewItemSelected(self, event):
        wx.MessageBox("You selected a new item")

if __name__ == "__main__":
    app = wx.PySimpleApp()
    frame = MyFrame()
    frame.Show()
    app.MainLoop()

10.1.4 Как отвечать на события меню?

10.2 Работа с элементами меню

10.2.1 Как найти определённый элемент меню в меню?

import wx

class MyFrame(wx.Frame):
    def __init__(self):
        wx.Frame.__init__(self, None, -1,
            "Find Item Example")
        p = wx.Panel(self)
        self.txt = wx.TextCtrl(p, -1, "new item")
        btn = wx.Button(p, -1, "Add Menu Item")
        self.Bind(wx.EVT_BUTTON, self.OnAddItem, btn)

        sizer = wx.BoxSizer(wx.HORIZONTAL)
        sizer.Add(self.txt, 0, wx.ALL, 20)
        sizer.Add(btn, 0, wx.TOP|wx.RIGHT, 20)
        p.SetSizer(sizer)

        self.menu = menu = wx.Menu()
        simple = menu.Append(-1, "Simple menu item")
        menu.AppendSeparator()
        exit = menu.Append(-1, "Exit")
        self.Bind(wx.EVT_MENU, self.OnSimple, simple)
        self.Bind(wx.EVT_MENU, self.OnExit, exit)

        menuBar = wx.MenuBar()
        menuBar.Append(menu, "Menu")
        self.SetMenuBar(menuBar)

    def OnSimple(self, event):
        wx.MessageBox("You selected the simple menu item")

    def OnExit(self, event):
        self.Close()

    def OnAddItem(self, event):
        item = self.menu.Append(-1, self.txt.GetValue())
        self.Bind(wx.EVT_MENU, self.OnNewItemSelected, item)

    def OnNewItemSelected(self, event):
        # получаем элемент меню
        item = self.GetMenuBar().FindItemById(event.GetId())
        text = item.GetText()
        wx.MessageBox("You selected the '%s' item" % text)

if __name__ == "__main__":
    app = wx.PySimpleApp()
    frame = MyFrame()
    frame.Show()
    app.MainLoop()

def FindMenuInMenuBar(menuBar, title):
    pos = menuBar.FindMenu(title)
    if pos == wx.NOT_FOUND:
        return None
    return menuBar.GetMenu(pos)

10.2.2 Как я могу активировать или деактивировать элемент меню?

import wx

ID_SIMPLE = wx.NewId()

class MyFrame(wx.Frame):
    def __init__(self):
        wx.Frame.__init__(self, None, -1,
            "Enable/Disable Menu Example")
        p = wx.Panel(self)
        self.btn = wx.Button(p, -1, "Disable Item", (20,20))
        self.Bind(wx.EVT_BUTTON, self.OnToggleItem, self.btn)

        menu = wx.Menu()
        menu.Append(ID_SIMPLE, "Simple menu item")
        self.Bind(wx.EVT_MENU, self.OnSimple, id=ID_SIMPLE)

        menu.AppendSeparator()
        menu.Append(wx.ID_EXIT, "Exit")
        self.Bind(wx.EVT_MENU, self.OnExit, id=wx.ID_EXIT)

        menuBar = wx.MenuBar()
        menuBar.Append(menu, "Menu")
        self.SetMenuBar(menuBar)

    def OnSimple(self, event):
        wx.MessageBox("You selected the simple menu item")
    def OnExit(self, event):
        self.Close()
    def OnToggleItem(self, event):
        menubar = self.GetMenuBar()
        enabled = menubar.IsEnabled(ID_SIMPLE)
        menubar.Enable(ID_SIMPLE, not enabled)
        self.btn.SetLabel(
            (enabled and "Enable" or "Disable") + " Item")

if __name__ == "__main__":
    app = wx.PySimpleApp()
    frame = MyFrame()
    frame.Show()
    app.MainLoop()

10.2.3 Как прикрепить к элементу меню акселератор (горячую клавишу)

import wx

class MyFrame(wx.Frame):
    def __init__(self):
        wx.Frame.__init__(self, None, -1,
            "Accelerator Example")
        p = wx.Panel(self)
        menu = wx.Menu()
        # создаём мнемонику
        simple = menu.Append(-1, "Simple &menu item")
        # создаём акселератор
        accel = menu.Append(-1, "&AcceleratedtCtrl-A")

        menu.AppendSeparator()
        exit = menu.Append(-1, "E&xit")

        self.Bind(wx.EVT_MENU, self.OnSimple, simple)
        self.Bind(wx.EVT_MENU, self.OnAccelerated, accel)
        self.Bind(wx.EVT_MENU, self.OnExit, exit)

        menuBar = wx.MenuBar()
        menuBar.Append(menu, "&Menu")
        self.SetMenuBar(menuBar)

        # используем таблицу акселераторов
        acceltbl = wx.AcceleratorTable( [
                (wx.ACCEL_CTRL, ord('Q'), exit.GetId())
            ])
        self.SetAcceleratorTable(acceltbl)

    def OnSimple(self, event):
        wx.MessageBox("You selected the simple menu item")

    def OnAccelerated(self, event):
        wx.MessageBox("You selected the accelerated menu item")

    def OnExit(self, event):
        self.Close()

if __name__ == "__main__":
    app = wx.PySimpleApp()
    frame = MyFrame()
    frame.Show()
    app.MainLoop()

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

Рисунок 10.4

Листинг 10.7

import wx

class MyFrame(wx.Frame):
    def __init__(self):
        wx.Frame.__init__(self, None, -1,
            "Toggle Items Example")
        p = wx.Panel(self)
        menuBar = wx.MenuBar()
        menu = wx.Menu()
        exit = menu.Append(-1, "Exit")
        self.Bind(wx.EVT_MENU, self.OnExit, exit)
        menuBar.Append(menu, "Menu")

        menu = wx.Menu()
        menu.AppendCheckItem(-1,"Check Item 1")
        menu.AppendCheckItem(-1,"Check Item 2")
        menu.AppendCheckItem(-1,"Check Item 3")
        menu.AppendSeparator()
        menu.AppendRadioItem(-1,"Radio Item 1")
        menu.AppendRadioItem(-1,"Radio Item 2")
        menu.AppendRadioItem(-1, "Radio Item 3")
        menuBar.Append(menu, "Toggle Items")

        self.SetMenuBar(menuBar)
    def OnExit(self, event):
        self.Close()

if __name__ == "__main__":
    app = wx.PySimpleApp()
    frame = MyFrame()
    frame.Show()
    app.MainLoop()

Как Вы можете увидеть в листинге, чекбоксы добавляются при помощи метода AppendCheckItem(id, item, helpString=»»), который похож на Append(). Аргументами являются идентификатор wxPython, отображаемое имя и строка помощи для отображения в строке статуса. Кроме того, Вы можете использовать PrependCheckItem(id, item, helpString=»») и InsertCheckItem(pos, id, item, helpString=»»), которые ведут себя так, как Вы от них и ожидаете.

Для добавления переключателей используйте AppendRadioItem(id, item, helpString=»»), PrependRadioItem(id, item, helpString=»») и InsertRadioItem(pos, id, item, helpString=»»). Набор последовательных переключателей образуют группу и из этой группы только один переключатель может быть выбран. Для того, чтобы создать новую группу надо добавить любой другой элемент меню или сепаратор. По умолчанию выбранным является первый переключатель в группе.

Кроме того, различные элементы меню можно создать и при помощи обычного метода Append(), если передать в качестве значения параметра kind wx.ITEM_CHECK, wx.ITEM_NORMAL, wx.ITEM_RADIO или wx.ITEM_SEPARATOR. Это полезно, если вы создаёте меню автоматически на основании каких-либо данных, так как Вы можете создавать любые варианты элементов меню (только учтите, что для создания сепаратора необходимо в качестве id передать wx.ID_SEPARATOR).

Более того, Вы можете создать элемент меню при помощи конструктора wx.MenuItem c использованием данных констант, а потом передать полученный элемент одному из этих методов: AppendItem(), PrependItem() или InsertItem().

Для того, чтобы определить тип элемента меню используйте IsCheckable(), который возвращает True, если это чекбокс или переключатель; или используйте IsChecked(), который возвращает True, если элемент может изменять состояние и на данный момент выбран. Вы можете задать состояние переключаемого элемента при помощи метода Check(check), который принимает логический аргумент, отражающий новое состояние элемента. Если же элемент является переключателем, то автоматически поменяются состояния других элементов группы.

Кроме того, Вы можете получить состояние элемента меню из меню или из строки меню используя метод IsChecked(id), которому надо
передать идентификатор элемента, который Вы хотите проверить. Кончено, тут есть ожидаемые ограничения — метод полосы меню работает только если она уже прикреплена к фрейму, а метод меню работает для элементов, которые находятся в этом меню. Для установки состояния можно использовать их методы Check(id, check) c очевидными аргументами.

import wx

class MyFrame(wx.Frame):
    def __init__(self):
        wx.Frame.__init__(self, None, -1,
            "Sub-menu Example")
        p = wx.Panel(self)
        menu = wx.Menu()
        
        submenu = wx.Menu()
        submenu.Append(-1, "Sub-item 1")
        submenu.Append(-1, "Sub-item 2")
        # добавляем подменю
        menu.AppendMenu(-1, "Sub-menu", submenu)
        
        menu.AppendSeparator()
        exit = menu.Append(-1, "Exit")
        self.Bind(wx.EVT_MENU, self.OnExit, exit)

        menuBar = wx.MenuBar()
        menuBar.Append(menu, "Menu")
        self.SetMenuBar(menuBar)

    def OnExit(self, event):
        self.Close()

if __name__ == "__main__":
    app = wx.PySimpleApp()
    frame = MyFrame()
    frame.Show()
    app.MainLoop()

10.3.2 Как создавать всплывающие меню?

Рисунок 10.6
Листинг 10.9

import wx

class MyFrame(wx.Frame):
    def __init__(self):
        wx.Frame.__init__(self, None, -1,
            "Popup Menu Example")
        self.panel = p = wx.Panel(self)
        menu = wx.Menu()
        exit = menu.Append(-1, "Exit")
        self.Bind(wx.EVT_MENU, self.OnExit, exit)

        menuBar = wx.MenuBar()
        menuBar.Append(menu, "Menu")
        self.SetMenuBar(menuBar)

        wx.StaticText(p, -1,
            "Right-click on the panel to show a popup menu",
            (25,25))

        # создаём меню
        self.popupmenu = wx.Menu()
        # наполняем его
        for text in "one two three four five".split():
            item = self.popupmenu.Append(-1, text)
            self.Bind(wx.EVT_MENU, self.OnPopupItemSelected, item)
        # связываем всплывающее меню с событием для его вызова
        p.Bind(wx.EVT_CONTEXT_MENU, self.OnShowPopup)

        # показываем всплывающее меню
        def OnShowPopup(self, event):
            pos = event.GetPosition()
            pos = self.panel.ScreenToClient(pos)
            sel
f.panel.PopupMenu(self.popupmenu, pos)

        def OnPopupItemSelected(self, event):
            item = self.popupmenu.FindItemById(event.GetId())
            text = item.GetText()
            wx.MessageBox("You selected item '%s'" % text)

        def OnExit(self, event):
            self.Close()

if __name__ == "__main__":
    app = wx.PySimpleApp()
    frame = MyFrame()
    frame.Show()
    app.MainLoop()

Всплывающие меню создаются так же как и любые другие меню (обратите внимание на использование цикла для быстрого создания элементов меню). Но вместо того, чтобы прикреплять его к полосе меню мы сохраняем его в self.popupmenu. После этого мы связываем метод OnShowPopup() c событием wx.EVT_CONTEXT_MENU, которое вызывается тогда, когда в данной ОС должно вызываться контекстное меню. В Windows и GTK это нажатие правой кнопкой мыши, в Mac OS это нажатие на control.

В результате, когда пользователь вызывает контекстное меню срабатывает метод-обработчик OnShowPopup(). Во-первых, он определяет координаты для отображения меню. Координаты, передаваемые в экземпляре wx.ContextMenuEvent отражают абсолютные значения для экрана, так что нам надо перевести их в относительные значения для нашей панели. Для этого мы используем метод ScreenToClient().

После того, отображается контекстное меню с помощью метода PopupMenu(menu, pos) или PopupMenuXY(menu, x, y). Данная функция возвращает значение только после того, как будет выбран элемент меню или меню будет закрыто нажатием кнопки escape или кликом вне пределов меню. Если был выбран какой-либо элемент меню, его обработчик вызывается стандартным образом (то есть, Вы должны связать обработчик этого элемента с событием EVT_MENU), и лишь после завершения обработчика управление перейдёт к следующему оператору после вызова PopupMenu(). Этот метод возвращает не интересующее нас логическое значение, так что единственный способ обработать выбор элемента меню — использовать стандартный механизм обработки событий.

Всплывающее меню может иметь заголовок, который отображается вверху меню, когда оно появляется на экране. Заголовок управляется при помощи свойств wx.Menu.SetTitle(title) и wx.Menu.GetTitle().

10.3.3 Как создавать забавные меню

Если обычные элементы меню выглядят не очень интересно, то Вы можете добавить к ним свой рисунок для отображения рядом с этим элементом меню (или использовать какой-то значок). Кроме того, в Windows Вы можете изменить шрифт или цвет элемента меню. На рисунке 10.7 приведён пример такого меню:

Рисунок 10.7

Листинг 10.10 содержит код для получения такого меню. Для определения платформы, на которой запускается ваша программа можно проверить наличие wxMSW в кортеже wx.PlatformInfo.

Листинг 10.10

import wx


class MyFrame(wx.Frame):
    def __init__(self):
        wx.Frame.__init__(self, None, -1,
            «Fancier Menu Example»)
        p = wx.Panel(self)
        menu = wx.Menu()


        bmp = wx.Bitmap(«open.png», wx.BITMAP_TYPE_PNG)
        item = wx.MenuItem(menu, -1, «Has Open Bitmap»)
        # добавляем собственную картинку
        item.SetBitmap(bmp)
        menu.AppendItem(item)


        if 'wxMSW' in wx.PlatformInfo:
            font = wx.SystemSettings.GetFont(
                wx.SYS_DEFAULT_GUI_FONT)
            font.SetWeight(wx.BOLD)
            item = wx.MenuItem(menu, -1, «Has Bold Font»)
            # изменяем шрифт
            item.SetFont(font)
            menu.AppendItem(item)


            item = wx.MenuItem(menu, -1, «Has Red Text»)
            # изменяем цвет
            item.SetTextColour(«red»)
            menu.AppendItem(item)


        menu.AppendSeparator()
        exit = menu.Append(-1, «Exit»)
        self.Bind(wx.EVT_MENU, self.OnExit, exit)

        menuBar = wx.MenuBar()

        menuBar.Append(menu, «Menu»)

        self.SetMenuBar(menuBar)

    def OnExit(self, event):

        self.Close()

if __name__ == «__main__»:

    app = wx.PySimpleApp()

    frame = MyFrame()

    frame.Show()

    app.MainLoop()

Изменение цвета или стиля элемента меню достигается манипуляциями со свойствами этого элемента. Единственным кроссплатформенным свойством является картинка, которая управляется методом GetBitmap(), возвращающим элемент типа wx.Bitmap. Для этого свойства есть два установщика. Первый, работающий на всех платформах, это SetBitmap(bmp). Он устанавливает картинку, отображаемую рядом с элементом меню. Если Вы работаете на Windows и хотите установить картинку для переключаемых меню, Вы можете использовать SetBitmap(checked, unchecked=wx.NullBitmap), который устанавливает одну картинку для отображения рядом с отмеченным элементом и другую для отображения рядом с не отмеченными.

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

Методы	Описание
GetBackgroundColour() SetBackgroundColour(colour)	Тип свойства — wx.Colour. Установщику так же можно передать строку с именем цвета wxPython. Управляет фоновым цветом элемента меню.
GetFont() SetFont(font)	Управляет шрифтом элемента. Тип — wx.Font
GetTextColour() SetTextColour(colour)	Управляет цветом шрифта элемента. Тип как и у методов для цвета фона

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

10.4 Как создавать «правильные» меню

Д
ля сложных приложений полоса меню — главная точка взаимодействия пользователя с вашим приложением. Правильно составленное меню может значительно облегчить работу с вашей программой; неверная же компоновка может сделать её использование невозможным. Принимая во внимание сказанное выше, приступим к обсуждению советов по созданию меню.

10.4.1 Поддержка одинаковой длины меню

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

10.4.2 Логичная группировка элементов

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

Твёрдо придерживайтесь стандартов при упорядочивании меню

Вы всегда должны придерживаться стандарта при определении порядка расположения меню. Самое левое меню — FILE, содержащее такие элементы, как new, open, save, print и exit, обычно именно в таком порядке. Если Вам нужно добавить сюда ещё какие-то возможности — лучше всего поместить их между print и exit. Такое расположение Вы встретите почти в каждом приложении. Следующим меню идёт EDIT, содержащий такие пункты как undeo, cut, copy, paaste и обычно find, в зависимости от вашего приложения. Меню HELP всегда является самым правым меню, а рядом с ним обычно находится меню WINODWS. Между этими крайними точками Вы можете располагать те меню, которые сочтёте нужным.
Предоставьте простой доступ для часто используемых элементов
Пользователю всегда проще использовать те элементы меню, которые расположены выше, чем те, что расположены ниже, поэтому наиболее часто используемые элементы должны находиться вверху меню. Единственное исключение в том, что эксперимент показывает, что второй сверху элемент доступнее первого.
Используйте понятные названия для меню
Помните, что ширина меню в полосе меню пропорциональна длине имени меню, а ширина меню определяется по элементу меню с самым длинным именем. Постарайтесь не давать меню верхнего уровня имена короче четырёх букв. Мы рекомендуем, за исключением общепринятых обозначений, давать настолько длинные имена, чтобы суть их была однозначна ясна. Не бойтесь длинных имен для меню, но и не забывайте, что читать 30-40 символом может быть утомительно.
Помните про многоточия, когда элемент ведёт к диалоговому окну
Все элементы меню, которые вызывают диалоговые окна, должны заканчиваться на многоточие (…)
Придерживайтесь стандартных горячих клавиш
Для горячих клавиш используйте общепринятые стандарты соответствия комбинаций клавиш действиям, приведённые в таблице 10.8
Для возврата действия нет общепринятой комбинации; Вы можете встретить как ctrl+y так и alt+z, или другие наборы клавиш. Если Вы предоставляете большое количество дополнительных горячих клавиш, то рекомендуется дать пользователю возможность их переназначать. Горячие клавиши особенно полезны в приложениях, гд пользователю приходится много печатать, например в текстовых редакторах, и они могут быть бесполезны там, где пользователь много работает мышкой.

Таблица 10.8

Комбинация клавиш	Функция
Crtl+a	Выделить всё
Crtl+c	Копировать
Crtl+f	Искать
Crtl+g	Искать далее
Crtl+n	Новое
Crtl+o	Открыть
Crtl+p	Печатать
Crtl+q	Выйти
Crtl+s	Сохранить
Crtl+v	Вставить
Crtl+w	Закрыть
Crtl+x	Вырезать
Crtl+z	Отменить

Показывайте текущий статус переключателей

Когда Вы создаёте элемент меню, переключающий что-то из одного состояния в другое, обратите внимание на несколько вещей. Во первы