edit_sizers.py

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

# edit_sizers.py: hierarchy of Sizers supported by wxGlade
# $Id: edit_sizers.py,v 1.80 2007/08/07 12:21:55 agriggio Exp $
# 
# Copyright (c) 2002-2007 Alberto Griggio <[e-mail]>
# License: MIT (see license.txt)
# THIS PROGRAM COMES WITH NO WARRANTY

import wx
from widget_properties import *
from tree import Tree, WidgetTree
import common, config, misc
import math, sys, re

class SizerSlot:
    "a window to represent a slot in a sizer"
    def __init__(self, parent, sizer, pos=0):
        self.widget = None # reference to the widget resembling the slot
        self.sizer = sizer
        self.parent = parent
        self.pos = pos
        self.menu = None

    def create_widget(self):
        if misc.check_wx_version(2, 5, 2): style = wx.FULL_REPAINT_ON_RESIZE
        else: style = 0
        self.widget = wx.Window(self.parent.widget, -1, size=(20, 20),
                               style=style)
        self.widget.SetBackgroundColour(wx.LIGHT_GREY)
        self.widget.SetAutoLayout(True)
        wx.EVT_PAINT(self.widget, self.on_paint)
        wx.EVT_RIGHT_DOWN(self.widget, self.popup_menu)
        wx.EVT_LEFT_DOWN(self.widget, self.drop_widget)
        wx.EVT_MIDDLE_DOWN(self.widget, self.select_and_paste)
        wx.EVT_ENTER_WINDOW(self.widget, self.on_enter)
        wx.EVT_LEAVE_WINDOW(self.widget, self.on_leave)

        def on_key_down(event):
            evt_flags = 0
            if event.ControlDown(): evt_flags = wx.ACCEL_CTRL
            evt_key = event.GetKeyCode()
            for flags, key, function in misc.accel_table:
                if evt_flags == flags and evt_key == key:
                    misc.wxCallAfter(function)
                    break
            #event.Skip()
        wx.EVT_KEY_DOWN(self.widget, on_key_down)

    def show_widget(self, yes):
        if yes and not self.widget: self.create_widget()
        if self.widget: self.widget.Show(yes)

    def on_enter(self, event):
        # hack. definitely. but...
        misc._currently_under_mouse = self.widget
        if common.adding_widget and \
                (not common.adding_sizer or not self.sizer.is_virtual()):
            self.widget.SetCursor(wx.CROSS_CURSOR)
        else:
            self.widget.SetCursor(wx.STANDARD_CURSOR)
        event.Skip()

    def on_leave(self, event):
        # _currently_under_mouse is used to restore the normal cursor, if the
        # user cancelled the addition of a widget and the cursor is over this
        # slot
        misc._currently_under_mouse = None
        event.Skip()
        
    def on_paint(self, event):
        dc = wx.PaintDC(self.widget)
        dc.BeginDrawing()
        dc.SetBrush(wx.Brush("black", wx.FDIAGONAL_HATCH))
        dc.SetPen(wx.BLACK_PEN)
        w, h = self.widget.GetClientSize()
        dc.DrawRectangle(0, 0, w, h)
        dc.EndDrawing()

    def on_size(self, event):
        self.widget.Refresh()

    def popup_menu(self, event):
        if not self.menu:
            self.menu = wx.Menu(_('Options'))
            REMOVE_ID, PASTE_ID = wx.NewId(), wx.NewId()
            if not self.sizer.is_virtual():
                # we cannot remove items from virtual sizers
                misc.append_item(self.menu, REMOVE_ID, _('Remove\tDel'),
                                 wx.ART_DELETE)
            misc.append_item(self.menu, PASTE_ID, _('Paste\tCtrl+V'),
                             wx.ART_PASTE)
            def bind(method):
                return lambda e: misc.wxCallAfter(method)
            wx.EVT_MENU(self.widget, REMOVE_ID, bind(self.remove))
            wx.EVT_MENU(self.widget, PASTE_ID, bind(self.clipboard_paste))

            PREVIEW_ID = wx.NewId()
            self.menu.AppendSeparator()
            misc.append_item(self.menu, PREVIEW_ID, _('Preview'))
            wx.EVT_MENU(self.widget, PREVIEW_ID, bind(self.preview_parent))

        self.setup_preview_menu()
        self.widget.PopupMenu(self.menu, event.GetPosition())

    def remove(self, *args):
        if not self.sizer.is_virtual():
            self.sizer.remove_item(self)
            self.delete()

    def drop_widget(self, event):
        """\
        replaces self with a widget in self.sizer. This method is called
        to add every non-toplevel widget or sizer, and in turn calls the
        appropriate builder function (found in the ``common.widgets'' dict)
        """
        if not common.adding_widget:
            misc.focused_widget = self
            self.widget.SetFocus()
            return
        if common.adding_sizer and self.sizer.is_virtual():
            return
        common.adding_widget = False
        common.adding_sizer = False
        self.widget.SetCursor(wx.NullCursor)
        # call the appropriate builder
        common.widgets[common.widget_to_add](self.parent, self.sizer, self.pos)
        common.widget_to_add = None
        common.app_tree.app.saved = False # update the status of the app

    def clipboard_paste(self, *args):
        import clipboard
        if clipboard.paste(self.parent, self.sizer, self.pos):
            common.app_tree.app.saved = False # update the status of the app
            #print misc.focused_widget

    def select_and_paste(self, *args):
        """\
        Middle-click event handler: selects the slot and, if the clipboard is
        not empty, pastes its content here
        """
        misc.focused_widget = self
        self.widget.SetFocus()
        self.clipboard_paste()

    def delete(self, delete_widget=True):
        if self.menu: self.menu.Destroy()
        if misc._currently_under_mouse is self.widget:
            misc._currently_under_mouse = None
        if delete_widget and self.widget: self.widget.Destroy()
        if misc.focused_widget is self: misc.focused_widget = None
        common.app_tree.app.saved = False # update the status of the app

    def update_pos(self, value):
        """\
        called by self.sizer.change_item_pos to update the item's position
        when another widget is moved
        """
        self.pos = value

    def setup_preview_menu(self):
        p = misc.get_toplevel_widget(self.sizer)
        if p is not None:
            item = list(self.menu.GetMenuItems())[-1]
            if p.preview_is_visible():
                item.SetText(_('Close preview') + ' (%s)\tCtrl+P' % p.name)
            else:
                item.SetText(_('Preview') + ' (%s)\tCtrl+P' % p.name)        

    def preview_parent(self):
        p = misc.get_toplevel_widget(self.sizer)
        if p is not None:
            p.preview(None)

# end of class SizerSlot

if 0: #wxPlatform != '__WXMAC__':
    Button = wx.Button
else:
    #from wxPython.lib.buttons import wxGenButton as Button
    from wx.lib.buttons import GenButton as Button

class SizerHandleButton(Button):
    """\
    Provides a ``handle'' to activate a Sizer and to access its popup menu 
    """
    def __init__(self, parent, id, sizer, menu):
        # menu: list of 2-tuples: (label, function)
        Button.__init__(self, parent.widget, id, '', size=(5, 5))
        self.sizer = sizer
        self.menu = menu
        self._rmenu = None
        try: self.SetUseFocusIndicator(False)
        except AttributeError: pass
##         # provide popup menu for removal
##         REMOVE_ID = wxNewId() 
##         self._rmenu = misc.wxGladePopupMenu(sizer.name)
##         #self._rmenu.Append(REMOVE_ID, 'Remove\tDel')
##         misc.append_item(self._rmenu, REMOVE_ID, 'Remove\tDel', 'remove.xpm')
##         EVT_MENU(self, REMOVE_ID, self._remove)
##         for item in menu:
##             id = wxNewId()
##             #self._rmenu.Append(id, item[0])
##             bmp = None
##             if len(item) > 2: bmp = item[2]
##             misc.append_item(self._rmenu, id, item[0], bmp)
##             EVT_MENU(self, id, item[1])
##         self.sizer._rmenu = self._rmenu
        wx.EVT_RIGHT_DOWN(self, self.popup_menu)

##         def remove():
##             if common.focused_widget is not None:
##                 common.focused_widget.remove()
##         table = [(0, WXK_DELETE, remove)]
        def on_key_down(event):
            evt_flags = 0
            if event.ControlDown(): evt_flags = wx.ACCEL_CTRL
            evt_key = event.GetKeyCode()
            for flags, key, function in misc.accel_table:
                if evt_flags == flags and evt_key == key:
                    misc.wxCallAfter(function)
                    break
            #event.Skip()
        wx.EVT_KEY_DOWN(self, on_key_down)

        def on_set_focus(event):
            misc.focused_widget = self
            event.Skip()
        wx.EVT_SET_FOCUS(self, on_set_focus)

    def set_menu_title(self, title):
        if self._rmenu: self._rmenu.SetTitle(title)

    def popup_menu(self, event):
        if not self._rmenu:
            # provide popup menu for removal
            REMOVE_ID = wx.NewId() 
            self._rmenu = misc.wxGladePopupMenu(self.sizer.name)
            def bind(method):
                return lambda e: misc.wxCallAfter(method)
            #self._rmenu.Append(REMOVE_ID, 'Remove\tDel')
            misc.append_item(self._rmenu, REMOVE_ID, _('Remove\tDel'),
                             wx.ART_DELETE)
            wx.EVT_MENU(self, REMOVE_ID, bind(self._remove))
            for item in self.menu:
                id = wx.NewId()
                #self._rmenu.Append(id, item[0])
                bmp = None
                if len(item) > 2: bmp = item[2]
                misc.append_item(self._rmenu, id, item[0], bmp)
                wx.EVT_MENU(self, id, bind(item[1]))
            self._rmenu.AppendSeparator()
            PREVIEW_ID = wx.NewId()
            misc.append_item(self._rmenu, PREVIEW_ID, _('Preview'))
            wx.EVT_MENU(self, PREVIEW_ID, bind(self.preview_parent))
            self.sizer._rmenu = self._rmenu
            del self.menu
        self.setup_preview_menu()
        self.PopupMenu(self._rmenu, event.GetPosition())

    def _remove(self, *args):
        # removes the sizer from his parent, if it has one
        if self.sizer.toplevel:
            window = self.sizer.window
            common.app_tree.remove(self.sizer.node)
            window.set_sizer(None)
            return
        self.sizer.sizer.free_slot(self.sizer.pos)
        common.app_tree.remove(self.sizer.node)
    # needed for consistency (common.focused_widget.remove)
    remove = _remove

    def Destroy(self):
        if self._rmenu: self._rmenu.Destroy()
        Button.Destroy(self)
        if misc.focused_widget is self: misc.focused_widget = None

    def setup_preview_menu(self):
        p = misc.get_toplevel_widget(self.sizer)
        if p is not None:
            item = list(self._rmenu.GetMenuItems())[-1]
            if p.preview_is_visible():
                item.SetText(_('Close preview') + ' (%s)\tCtrl+P' % p.name)
            else:
                item.SetText(_('Preview') + ' (%s)\tCtrl+P' % p.name)        

    def preview_parent(self):
        p = misc.get_toplevel_widget(self.sizer)
        p.preview(None)

# end of class SizerHandleButton


class SizerItem:
    """\
    Represents a child of a sizer
    """
    def __init__(self, item, pos, option=0, flag=0, border=0, size=None):
        self.item = item
        self.item.pos = pos
        self.option = option
        self.flag = flag
        self.border = border
        self.size = size

# end of class SizerItem


#---------- 2002-10-07 --------------------------------------------------------

class SizerClassDialog:
    choices = [
        ('EditBoxSizerV', 'wxBoxSizer (wxVERTICAL)'),
        ('EditBoxSizerH', 'wxBoxSizer (wxHORIZONTAL)'),
        ('EditStaticBoxSizerV', 'wxStaticBoxSizer (wxVERTICAL)'),
        ('EditStaticBoxSizerH', 'wxStaticBoxSizer (wxHORIZONTAL)'),
        ('EditGridSizer', 'wxGridSizer'),
        ('EditFlexGridSizer', 'wxFlexGridSizer')
        ]
    def __init__(self, owner, parent):
        self.owner = owner
        self.parent = parent
        self.dialog = None

    def ShowModal(self):
        name = self.owner.__class__.__name__
        if hasattr(self.owner, 'orient'):
            if self.owner.orient == wx.HORIZONTAL: name += 'H'
            else: name += 'V'
        choices = [ b for a, b in self.choices if a != name ]
        self.dialog = wx.SingleChoiceDialog(self.parent, _("Select sizer type"),
                                           _("Select sizer type"), choices)
        self.dialog.CenterOnScreen()
        return self.dialog.ShowModal()

    def get_value(self):
        return self.dialog.GetStringSelection()

# end of class SizerClassDialog