menubar.py

用python写的ide开发环境,巨强大,不过需要wxpython的支持

            self.widget.SetBackgroundColour(self._mb.GetBackgroundColour())
            import os
            icon = wx.EmptyIcon()
            xpm = os.path.join(common.wxglade_path, 'icons', 'menubar.xpm')
            icon.CopyFromBitmap(misc.get_xpm_bitmap(xpm))
            self.widget.SetIcon(icon)
            wx.EVT_CLOSE(self.widget, lambda e: self.hide_widget())
        wx.EVT_LEFT_DOWN(self.widget, self.on_set_focus)
        self.set_menus(self.menus) # show the menus

    def create_properties(self):
        EditBase.create_properties(self)
        page = self._common_panel
        sizer = page.GetSizer()
        self.properties['menus'].display(page)
        if not sizer:
            sizer = wx.BoxSizer(wx.VERTICAL)
            sizer.Add(self.name_prop.panel, 0, wx.EXPAND)
            sizer.Add(self.klass_prop.panel, 0, wx.EXPAND)
            page.SetAutoLayout(1)
            page.SetSizer(sizer)
        sizer.Add(self.properties['menus'].panel, 0, wx.ALL|wx.EXPAND, 3)
        sizer.Fit(page)
        page.SetSize(self.notebook.GetClientSize())
        sizer.Layout()
        self.notebook.AddPage(page, _("Common"))
        if self.parent is not None:
            self.property_window.Layout()
        else:
            PreviewMixin.create_properties(self)
        
    def __getitem__(self, key):
        return self.access_functions[key]

    def get_menus(self):
        return self.menus

    def set_menus(self, menus):
        self.menus = menus
        if not self._mb: return # nothing left to do
        for i in range(self._mb.GetMenuCount()):
            self._mb.Remove(0)
        def append(menu, items):
            for item in items:
                if misc.streq(item.name, '---'): # item is a separator
                    menu.AppendSeparator()
                elif item.children:
                    m = wx.Menu()
                    append(m, item.children)
                    menu.AppendMenu(wx.NewId(), misc.wxstr(item.label), m,
                                    misc.wxstr(item.help_str))
                else:
                    check_radio = 0
                    try:
                        if int(item.checkable):
                            check_radio = 1
                    except:
                        check_radio = 0
                    if not check_radio:
                        try:
                            if int(item.radio):
                                check_radio = 2
                        except:
                            check_radio = 0
                    menu.Append(wx.NewId(), misc.wxstr(item.label),
                                misc.wxstr(item.help_str), check_radio)
        first = self._mb.GetMenuCount()
        for menu in self.menus:
            m = wx.Menu()
            append(m, menu.root.children)
            if first:
                self._mb.Replace(0, m, misc.wxstr(menu.root.label))
                first = 0
            else: self._mb.Append(m, misc.wxstr(menu.root.label))
        self._mb.Refresh()
      
    def remove(self, *args, **kwds):
        if self.parent is not None:
            self.parent.properties['menubar'].set_value(0)
            if kwds.get('gtk_do_nothing', False) and wx.Platform == '__WXGTK__':
                # workaround to prevent some segfaults on GTK: unfortunately,
                # I'm not sure that this works in all cases, and moreover it
                # could probably leak some memory (but I'm not sure)
                self.widget = None
            else:
                if self.parent.widget:
                    if wx.Platform == '__WXGTK__' and \
                           not misc.check_wx_version(2, 5):
                        self.widget.Reparent(EditMenuBar.__hidden_frame)
                        self.widget.Hide()
                    self.parent.widget.SetMenuBar(None)
        else:
            if self.widget:
                self.widget.Destroy()
                self.widget = None
        EditBase.remove(self)

    def popup_menu(self, event):
        if self.parent is not None:
            return # do nothing in this case
        if self.widget:
            if not self._rmenu:
                REMOVE_ID, HIDE_ID = [wx.NewId() for i in range(2)]
                self._rmenu = misc.wxGladePopupMenu(self.name)
                misc.append_item(self._rmenu, REMOVE_ID, _('Remove\tDel'),
                                 wx.ART_DELETE)
                misc.append_item(self._rmenu, HIDE_ID, _('Hide'))
                def bind(method):
                    return lambda e: misc.wxCallAfter(method)
                wx.EVT_MENU(self.widget, REMOVE_ID, bind(self.remove))
                wx.EVT_MENU(self.widget, HIDE_ID, bind(self.hide_widget))
                
            self.widget.PopupMenu(self._rmenu, event.GetPosition())

    def hide_widget(self, *args):
        if self.widget and self.widget is not self._mb:
            self.widget.Hide()
            common.app_tree.expand(self.node, False)
            common.app_tree.select_item(self.node.parent)
            common.app_tree.app.show_properties()

##     def show_widget(self, yes):
##         EditBase.show_widget(self, yes)
##         if self._frame:
##             self._frame.Show(yes)

    def set_name(self, name):
        EditBase.set_name(self, name)
        if self.widget is not self._mb:
            self.widget.SetTitle(misc.design_title(misc.wxstr(self.name)))

    def get_property_handler(self, name):
        class MenuHandler:
            itemattrs = ['label', 'id', 'name', 'help_str',
                         'checkable', 'radio', 'handler']
            def __init__(self, owner):
                self.owner = owner
                self.menu_items = []
                self.curr_menu = []
                self.curr_item = None
                self.curr_index = 0
                self.menu_depth = 0
            def start_elem(self, name, attrs):
                if name == 'menus': return
                if name == 'menu':
                    self.menu_depth += 1
                    label = misc._encode(attrs['label'])
                    if self.menu_depth == 1:
                        t = MenuTree(attrs['name'], label,
                                     attrs.get('itemid', ''),
                                     attrs.get('help_str', ''),
                                     handler=attrs.get('handler', ''))
                        self.curr_menu.append( (t.root,) )
                        self.owner.menus.append(t)
                        return
                    node = MenuTree.Node(label=label, name=attrs['name'],
                                         id=attrs.get('itemid', ''),
                                         help_str=attrs.get('help_str', ''),
                                         handler=attrs.get('handler', ''))
                    cm = self.curr_menu[-1]
                    cm[0].children.append(node)
                    node.parent = cm[0]
                    menu = wx.Menu()
                    self.curr_menu.append( (node, menu) )
                elif name == 'item':
                    self.curr_item = MenuTree.Node()
                else:
                    try: self.curr_index = self.itemattrs.index(name)
                    except ValueError:
                        # ignore unknown attributes...
                        self.curr_index = -1
                        pass
##                         from xml_parse import XmlParsingError
##                         raise XmlParsingError, _("invalid menu item attribute")
            def end_elem(self, name):
                if name == 'item':
                    try: cm = self.curr_menu[-1]
                    except IndexError:
                        from xml_parse import XmlParsingError
                        raise XmlParsingError, _("menu item outside a menu")
                    cm[0].children.append(self.curr_item)
                    self.curr_item.parent = cm[0]
                elif name == 'menu':
                    self.menu_depth -= 1
                    self.curr_menu.pop()
                elif name == 'menus':
                    self.owner.set_menus(self.owner.menus)
                    return True
            def char_data(self, data):
                setattr(self.curr_item, self.itemattrs[self.curr_index], data)
                
        if name == 'menus':
            return MenuHandler(self)
        return None

# end of class EditMenuBar


def builder(parent, sizer, pos, number=[0]):
    """\
    factory function for EditMenuBar objects.
    """
    class Dialog(wx.Dialog):
        def __init__(self):
            wx.Dialog.__init__(self, None, -1, _('Select menubar class'))
            if common.app_tree.app.get_language().lower() == 'xrc':
                self.klass = 'wxMenuBar'
            else:
                if not number[0]: self.klass = 'MyMenuBar'
                else: self.klass = 'MyMenuBar%s' % number[0]
                number[0] += 1
            klass_prop = TextProperty(self, 'class', self, label=_('class'))
            szr = wx.BoxSizer(wx.VERTICAL)
            szr.Add(klass_prop.panel, 0, wx.EXPAND)
            sz2 = wx.BoxSizer(wx.HORIZONTAL)
            sz2.Add(wx.Button(self, wx.ID_OK, _('OK')), 0, wx.ALL, 3)
            sz2.Add(wx.Button(self, wx.ID_CANCEL, _('Cancel')), 0, wx.ALL, 3)
            szr.Add(sz2, 0, wx.ALL|wx.ALIGN_CENTER, 3)
            self.SetAutoLayout(True)
            self.SetSizer(szr)
            szr.Fit(self)
            if self.GetBestSize()[0] < 150:
                self.SetSize((150, -1))
            self.CenterOnScreen()

        def undo(self):
            if number[0] > 0:
                number[0] -= 1

        def __getitem__(self, value):
            if value == 'class':
                def set_klass(c): self.klass = c
                return (lambda : self.klass, set_klass)
    # end of inner class

    dialog = Dialog()
    if dialog.ShowModal() == wx.ID_CANCEL:
        # cancel the operation
        dialog.undo()
        dialog.Destroy()
        return
    
    name = 'menubar_%d' % (number[0] or 1)
    while common.app_tree.has_name(name):
        number[0] += 1
        name = 'menubar_%d' % number[0]

    mb = EditMenuBar(name, dialog.klass, parent, common.property_panel)
    mb.node = Tree.Node(mb)
    common.app_tree.add(mb.node)
    mb.show_widget(True)
    mb.show_properties()
    

def xml_builder(attrs, parent, sizer, sizeritem, pos=None):
    """\
    factory to build EditMenuBar objects from an xml file
    """
    name = attrs.get('name')
    if parent is not None:
        if name:
            parent.menubar.set_name(name)
            parent.menubar.name_prop.set_value(name)
        return parent.menubar
    else:
        mb = EditMenuBar(name, attrs.get('class', 'wxMenuBar'), None,
                         common.property_panel)
        mb.node = Tree.Node(mb)
        common.app_tree.add(mb.node)
        return mb


def initialize():
    """\
    initialization function for the module: returns a wx.BitmapButton to be
    added to the main palette.
    """
    cwx = common.widgets_from_xml
    cwx['EditMenuBar'] = xml_builder
    common.widgets['EditMenuBar'] = builder
    
    return common.make_object_button('EditMenuBar', 'icons/menubar.xpm', 1)