Separated xrced.py in 3 files

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/branches/WX_2_4_BRANCH@18130 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

wxPython/wxPython/tools/XRCed/panel.py

@@ -0,0 +1,351 @@
+# Name:         panel.py
+# Purpose:      XRC editor, Panel class and related
+# Author:       Roman Rolinsky <rolinsky@mema.ucl.ac.be>
+# Created:      02.12.2002
+# RCS-ID:       $Id$
+
+from xxx import *                       # xxx imports globals and params
+from undo import *
+
+# Properties panel containing notebook
+class Panel(wxNotebook):
+    def __init__(self, parent, id = -1):
+        wxNotebook.__init__(self, parent, id, style=wxNB_BOTTOM)
+        global panel
+        g.panel = panel = self
+        self.modified = false
+
+        # List of child windows
+        self.pages = []
+        # Create scrolled windows for pages
+        self.page1 = wxScrolledWindow(self, -1)
+        sizer = wxBoxSizer()
+        sizer.Add(wxBoxSizer())         # dummy sizer
+        self.page1.SetAutoLayout(true)
+        self.page1.SetSizer(sizer)
+        self.AddPage(self.page1, 'Properties')
+        # Second page
+        self.page2 = wxScrolledWindow(self, -1)
+        sizer = wxBoxSizer()
+        sizer.Add(wxBoxSizer())         # dummy sizer
+        self.page2.SetAutoLayout(true)
+        self.page2.SetSizer(sizer)
+        # Cache for already used panels
+        self.pageCache = {}             # cached property panels
+        self.stylePageCache = {}        # cached style panels
+        # Dummy parent window for cache pages
+        self.cacheParent = wxFrame(None, -1, 'i am invisible')
+    # Delete child windows and recreate page sizer
+    def ResetPage(self, page):
+        topSizer = page.GetSizer()
+        sizer = topSizer.GetChildren()[0].GetSizer()
+        for w in page.GetChildren():
+            sizer.RemoveWindow(w)
+            if isinstance(w, ParamPage):
+                # With SetParent, we wouldn't need this
+                w.Reparent(self.cacheParent)
+            else:
+                w.Destroy()
+        topSizer.RemoveSizer(sizer)
+        # Create new windows
+        sizer = wxBoxSizer(wxVERTICAL)
+        # Special case - resize html window
+        if g.conf.panic:
+            topSizer.Add(sizer, 1, wxEXPAND)
+        else:
+            topSizer.Add(sizer, 0, wxALL, 5)
+        return sizer
+    def SetData(self, xxx):
+        self.pages = []
+        # First page
+        # Set cached or new page
+        # Remove current objects and sizer
+        sizer = self.ResetPage(self.page1)
+        if not xxx or (not xxx.allParams and not xxx.hasName):
+            if g.tree.selection:
+                sizer.Add(wxStaticText(self.page1, -1, 'This item has no properties.'))
+            else:                       # nothing selected
+                # If first time, show some help
+                if g.conf.panic:
+                    html = wxHtmlWindow(self.page1, -1, wxDefaultPosition,
+                                        wxDefaultSize, wxSUNKEN_BORDER)
+                    html.SetPage(helpText)
+                    sizer.Add(html, 1, wxEXPAND)
+                    g.conf.panic = false
+                else:
+                    sizer.Add(wxStaticText(self.page1, -1, 'Select a tree item.'))
+        else:
+            g.currentXXX = xxx.treeObject()
+            try:
+                page = self.pageCache[xxx.__class__]
+                page.Reparent(self.page1)
+            except KeyError:
+                page = PropPage(self.page1, xxx.className, xxx)
+                self.pageCache[xxx.__class__] = page
+            page.SetValues(xxx)
+            self.pages.append(page)
+            sizer.Add(page, 1, wxEXPAND)
+            if xxx.hasChild:
+                # Special label for child objects - they may have different GUI
+                cacheID = (xxx.child.__class__, xxx.__class__)
+                try:
+                    page = self.pageCache[cacheID]
+                    page.Reparent(self.page1)
+                except KeyError:
+                    page = PropPage(self.page1, xxx.child.className, xxx.child)
+                    self.pageCache[cacheID] = page
+                page.SetValues(xxx.child)
+                self.pages.append(page)
+                sizer.Add(page, 0, wxEXPAND | wxTOP, 5)
+        self.page1.Layout()
+        size = self.page1.GetSizer().GetMinSize()
+        self.page1.SetScrollbars(1, 1, size.x, size.y, 0, 0, true)
+
+        # Second page
+        # Create if does not exist
+        if xxx and xxx.treeObject().hasStyle:
+            xxx = xxx.treeObject()
+            # Simplest case: set data if class is the same
+            sizer = self.ResetPage(self.page2)
+            try:
+                page = self.stylePageCache[xxx.__class__]
+                page.Reparent(self.page2)
+            except KeyError:
+                page = StylePage(self.page2, xxx.className + ' style', xxx)
+                self.stylePageCache[xxx.__class__] = page
+            page.SetValues(xxx)
+            self.pages.append(page)
+            sizer.Add(page, 0, wxEXPAND)
+            # Add page if not exists
+            if not self.GetPageCount() == 2:
+                self.AddPage(self.page2, 'Style')
+            self.page2.Layout()
+            size = self.page2.GetSizer().GetMinSize()
+            self.page2.SetScrollbars(1, 1, size.x, size.y, 0, 0, true)
+        else:
+            # Remove page if exists
+            if self.GetPageCount() == 2:
+                self.SetSelection(0)
+                self.page1.Refresh()
+                self.RemovePage(1)
+        self.modified = false
+    def Clear(self):
+        self.SetData(None)
+        self.modified = false
+    # If some parameter has changed
+    def IsModified(self):
+        return self.modified
+    def SetModified(self, value):
+        # Register undo object when modifying first time
+        if not self.modified and value:
+           g.undoMan.RegisterUndo(UndoEdit())
+        self.modified = value
+    def Apply(self):
+        for p in self.pages: p.Apply()
+
+################################################################################
+
+# General class for notebook pages
+class ParamPage(wxPanel):
+    def __init__(self, parent, xxx):
+        wxPanel.__init__(self, parent, -1)
+        self.xxx = xxx
+        # Register event handlers
+        for id in paramIDs.values():
+            EVT_CHECKBOX(self, id, self.OnCheckParams)
+        self.checks = {}
+        self.controls = {}              # save python objects
+        self.controlName = None
+    def OnCheckParams(self, evt):
+        xxx = self.xxx
+        param = evt.GetEventObject().GetName()
+        w = self.controls[param]
+        objElem = xxx.element
+        if evt.IsChecked():
+            # Ad  new text node in order of allParams
+            w.SetValue('')              # set empty (default) value
+            w.SetModified()             # mark as changed
+            elem = g.tree.dom.createElement(param)
+            # Some classes are special
+            if param == 'font':
+                xxx.params[param] = xxxParamFont(xxx.element, elem)
+            else:
+                xxx.params[param] = xxxParam(elem)
+            # Find place to put new element: first present element after param
+            found = false
+            paramStyles = xxx.allParams + xxx.styles
+            for p in paramStyles[paramStyles.index(param) + 1:]:
+                # Content params don't have same type
+                if xxx.params.has_key(p) and p != 'content':
+                    found = true
+                    break
+            if found:
+                nextTextElem = xxx.params[p].node
+                objElem.insertBefore(elem, nextTextElem)
+            else:
+                objElem.appendChild(elem)
+        else:
+            # Remove parameter
+            xxx.params[param].remove()
+            del xxx.params[param]
+            w.SetValue('')
+            w.modified = false          # mark as not changed
+        w.Enable(evt.IsChecked())
+        # Set modified flag (provokes undo storing is necessary)
+        panel.SetModified(true)
+    def Apply(self):
+        xxx = self.xxx
+        if self.controlName:
+            name = self.controlName.GetValue()
+            if xxx.name != name:
+                xxx.name = name
+                xxx.element.setAttribute('name', name)
+        for param, w in self.controls.items():
+            if w.modified:
+                paramObj = xxx.params[param]
+                value = w.GetValue()
+                if param in xxx.specials:
+                    xxx.setSpecial(param, value)
+                else:
+                    paramObj.update(value)
+    # Save current state
+    def SaveState(self):
+        self.origChecks = map(lambda i: (i[0], i[1].GetValue()), self.checks.items())
+        self.origControls = map(lambda i: (i[0], i[1].GetValue(), i[1].IsEnabled()),
+                            self.controls.items())
+        if self.controlName:
+            self.origName = self.controlName.GetValue()
+    # Return original values
+    def GetState(self):
+        if self.controlName:
+            return (self.origChecks, self.origControls, self.origName)
+        else:
+            return (self.origChecks, self.origControls)
+    # Set values from undo data
+    def SetState(self, state):
+        for k,v in state[0]:
+            self.checks[k].SetValue(v)
+        for k,v,e in state[1]:
+            self.controls[k].SetValue(v)
+            self.controls[k].Enable(e)
+            if e: self.controls[k].modified = true
+        if self.controlName:
+            self.controlName.SetValue(state[2])
+
+################################################################################
+
+# Panel for displaying properties
+class PropPage(ParamPage):
+    def __init__(self, parent, label, xxx):
+        ParamPage.__init__(self, parent, xxx)
+        box = wxStaticBox(self, -1, label)
+        box.SetFont(labelFont)
+        topSizer = wxStaticBoxSizer(box, wxVERTICAL)
+        sizer = wxFlexGridSizer(len(xxx.allParams), 2, 1, 1)
+        if xxx.hasName:
+            label = wxStaticText(self, -1, 'XML ID:', size=(100,-1))
+            control = ParamText(self, name='XML_name')
+            sizer.AddMany([ (label, 0, wxALIGN_CENTER_VERTICAL),
+                            (control, 0, wxALIGN_CENTER_VERTICAL) ])
+            self.controlName = control
+        for param in xxx.allParams:
+            present = xxx.params.has_key(param)
+            if param in xxx.required:
+                label = wxStaticText(self, paramIDs[param], param + ':',
+                                     size = (100,-1), name = param)
+            else:
+                # Notebook has one very loooooong parameter
+                if param == 'usenotebooksizer': sParam = 'usesizer:'
+                else: sParam = param + ':'
+                label = wxCheckBox(self, paramIDs[param], sParam,
+                                   size = (100,-1), name = param)
+                self.checks[param] = label
+            try:
+                typeClass = xxx.paramDict[param]
+            except KeyError:
+                try:
+                    # Standart type
+                    typeClass = paramDict[param]
+                except KeyError:
+                    # Default
+                    typeClass = ParamText
+            control = typeClass(self, param)
+            control.Enable(present)
+            sizer.AddMany([ (label, 0, wxALIGN_CENTER_VERTICAL),
+                            (control, 0, wxALIGN_CENTER_VERTICAL) ])
+            self.controls[param] = control
+        topSizer.Add(sizer, 1, wxALL | wxEXPAND, 3)
+        self.SetAutoLayout(true)
+        self.SetSizer(topSizer)
+        topSizer.Fit(self)
+    def SetValues(self, xxx):
+        self.xxx = xxx
+        self.origChecks = []
+        self.origControls = []
+        # Set values, checkboxes to false, disable defaults
+        if xxx.hasName:
+            self.controlName.SetValue(xxx.name)
+            self.origName = xxx.name
+        for param in xxx.allParams:
+            w = self.controls[param]
+            w.modified = false
+            try:
+                value = xxx.params[param].value()
+                w.Enable(true)
+                w.SetValue(value)
+                if not param in xxx.required:
+                    self.checks[param].SetValue(true)
+                    self.origChecks.append((param, true))
+                self.origControls.append((param, value, true))
+            except KeyError:
+                self.checks[param].SetValue(false)
+                w.SetValue('')
+                w.Enable(false)
+                self.origChecks.append((param, false))
+                self.origControls.append((param, '', false))
+
+################################################################################
+
+# Style notebook page
+class StylePage(ParamPage):
+    def __init__(self, parent, label, xxx):
+        ParamPage.__init__(self, parent, xxx)
+        box = wxStaticBox(self, -1, label)
+        box.SetFont(labelFont)
+        topSizer = wxStaticBoxSizer(box, wxVERTICAL)
+        sizer = wxFlexGridSizer(len(xxx.styles), 2, 1, 1)
+        for param in xxx.styles:
+            present = xxx.params.has_key(param)
+            check = wxCheckBox(self, paramIDs[param],
+                               param + ':', size = (100,-1), name = param)
+            check.SetValue(present)
+            control = paramDict[param](self, name = param)
+            control.Enable(present)
+            sizer.AddMany([ (check, 0, wxALIGN_CENTER_VERTICAL),
+                            (control, 0, wxALIGN_CENTER_VERTICAL) ])
+            self.checks[param] = check
+            self.controls[param] = control
+        topSizer.Add(sizer, 1, wxALL | wxEXPAND, 3)
+        self.SetAutoLayout(true)
+        self.SetSizer(topSizer)
+        topSizer.Fit(self)
+    # Set data for a cahced page
+    def SetValues(self, xxx):
+        self.xxx = xxx
+        self.origChecks = []
+        self.origControls = []
+        for param in xxx.styles:
+            present = xxx.params.has_key(param)
+            check = self.checks[param]
+            check.SetValue(present)
+            w = self.controls[param]
+            w.modified = false
+            if present:
+                value = xxx.params[param].value()
+            else:
+                value = ''
+            w.SetValue(value)
+            w.Enable(present)
+            self.origChecks.append((param, present))
+            self.origControls.append((param, value, present))
+

wxPython/wxPython/tools/XRCed/tree.py

@@ -0,0 +1,692 @@
+# Name:         tree.py
+# Purpose:      XRC editor, XML_tree class
+# Author:       Roman Rolinsky <rolinsky@mema.ucl.ac.be>
+# Created:      02.12.2002
+# RCS-ID:       $Id$
+
+from xxx import *                       # xxx imports globals and params
+from wxPython.xrc import *
+
+# Icons
+import images
+
+class MemoryFile:
+    def __init__(self, name):
+        self.name = name
+        self.buffer = ''
+    def write(self, data):
+        self.buffer += data.encode()
+    def close(self):
+        wxMemoryFSHandler_AddFile(self.name, self.buffer)
+
+################################################################################
+
+# Redefine writing to include encoding
+class MyDocument(minidom.Document):
+    def __init__(self):
+        minidom.Document.__init__(self)
+        self.encoding = ''
+    def writexml(self, writer, indent="", addindent="", newl="", encoding=""):
+        if encoding: encdstr = 'encoding="%s"' % encoding
+        else: encdstr = ''
+        writer.write('<?xml version="1.0" %s?>\n' % encdstr)
+        for node in self.childNodes:
+            node.writexml(writer, indent, addindent, newl)
+
+################################################################################
+
+class PullDownMenu:
+    ID_NEW_PANEL = wxNewId()
+    ID_NEW_DIALOG = wxNewId()
+    ID_NEW_FRAME = wxNewId()
+    ID_NEW_TOOL_BAR = wxNewId()
+    ID_NEW_TOOL = wxNewId()
+    ID_NEW_MENU_BAR = wxNewId()
+    ID_NEW_MENU = wxNewId()
+
+    ID_NEW_STATIC_TEXT = wxNewId()
+    ID_NEW_TEXT_CTRL = wxNewId()
+
+    ID_NEW_BUTTON = wxNewId()
+    ID_NEW_BITMAP_BUTTON = wxNewId()
+    ID_NEW_RADIO_BUTTON = wxNewId()
+    ID_NEW_SPIN_BUTTON = wxNewId()
+
+    ID_NEW_STATIC_BOX = wxNewId()
+    ID_NEW_CHECK_BOX = wxNewId()
+    ID_NEW_RADIO_BOX = wxNewId()
+    ID_NEW_COMBO_BOX = wxNewId()
+    ID_NEW_LIST_BOX = wxNewId()
+
+    ID_NEW_STATIC_LINE = wxNewId()
+    ID_NEW_STATIC_BITMAP = wxNewId()
+    ID_NEW_CHOICE = wxNewId()
+    ID_NEW_SLIDER = wxNewId()
+    ID_NEW_GAUGE = wxNewId()
+    ID_NEW_SCROLL_BAR = wxNewId()
+    ID_NEW_TREE_CTRL = wxNewId()
+    ID_NEW_LIST_CTRL = wxNewId()
+    ID_NEW_CHECK_LIST = wxNewId()
+    ID_NEW_NOTEBOOK = wxNewId()
+    ID_NEW_HTML_WINDOW = wxNewId()
+    ID_NEW_CALENDAR_CTRL = wxNewId()
+    ID_NEW_GENERIC_DIR_CTRL = wxNewId()
+    ID_NEW_SPIN_CTRL = wxNewId()
+    ID_NEW_UNKNOWN = wxNewId()
+
+    ID_NEW_BOX_SIZER = wxNewId()
+    ID_NEW_STATIC_BOX_SIZER = wxNewId()
+    ID_NEW_GRID_SIZER = wxNewId()
+    ID_NEW_FLEX_GRID_SIZER = wxNewId()
+    ID_NEW_SPACER = wxNewId()
+    ID_NEW_TOOL_BAR = wxNewId()
+    ID_NEW_TOOL = wxNewId()
+    ID_NEW_MENU = wxNewId()
+    ID_NEW_MENU_ITEM = wxNewId()
+    ID_NEW_SEPARATOR = wxNewId()
+    ID_NEW_LAST = wxNewId()
+    ID_EXPAND = wxNewId()
+    ID_COLLAPSE = wxNewId()
+    ID_PASTE_SIBLING = wxNewId()
+
+    def __init__(self, parent):
+        self.ID_DELETE = parent.ID_DELETE
+        EVT_MENU_RANGE(parent, self.ID_NEW_PANEL,
+                       self.ID_NEW_LAST, parent.OnCreate)
+        EVT_MENU(parent, self.ID_COLLAPSE, parent.OnCollapse)
+        EVT_MENU(parent, self.ID_EXPAND, parent.OnExpand)
+        EVT_MENU(parent, self.ID_PASTE_SIBLING, parent.OnPaste)
+        # We connect to tree, but process in frame
+        EVT_MENU_HIGHLIGHT_ALL(g.tree, parent.OnPullDownHighlight)
+
+################################################################################
+
+# Set menu to list items.
+# Each menu command is a tuple (id, label, help)
+# submenus are lists [id, label, help, submenu]
+# and separators are any other type
+def SetMenu(m, list):
+    for l in list:
+        if type(l) == types.TupleType:
+            apply(m.Append, l)
+        elif type(l) == types.ListType:
+            subMenu = wxMenu()
+            SetMenu(subMenu, l[2:])
+            m.AppendMenu(wxNewId(), l[0], subMenu, l[1])
+        else:                           # separator
+            m.AppendSeparator()
+
+################################################################################
+
+class HighLightBox:
+    def __init__(self, pos, size):
+        if size.x == -1: size.x = 0
+        if size.y == -1: size.y = 0
+        w = g.testWin.panel
+        l1 = wxWindow(w, -1, pos, wxSize(size.x, 2))
+        l1.SetBackgroundColour(wxRED)
+        l2 = wxWindow(w, -1, pos, wxSize(2, size.y))
+        l2.SetBackgroundColour(wxRED)
+        l3 = wxWindow(w, -1, wxPoint(pos.x + size.x - 2, pos.y), wxSize(2, size.y))
+        l3.SetBackgroundColour(wxRED)
+        l4 = wxWindow(w, -1, wxPoint(pos.x, pos.y + size.y - 2), wxSize(size.x, 2))
+        l4.SetBackgroundColour(wxRED)
+        self.lines = [l1, l2, l3, l4]
+    # Move highlight to a new position
+    def Replace(self, pos, size):
+        if size.x == -1: size.x = 0
+        if size.y == -1: size.y = 0
+        self.lines[0].SetDimensions(pos.x, pos.y, size.x, 2)
+        self.lines[1].SetDimensions(pos.x, pos.y, 2, size.y)
+        self.lines[2].SetDimensions(pos.x + size.x - 2, pos.y, 2, size.y)
+        self.lines[3].SetDimensions(pos.x, pos.y + size.y - 2, size.x, 2)
+    # Remove it
+    def Remove(self):
+        map(wxWindow.Destroy, self.lines)
+        g.testWin.highLight = None
+
+################################################################################
+
+class XML_Tree(wxTreeCtrl):
+    # Constant to define standart window name
+    stdName = '_XRCED_T_W'
+    def __init__(self, parent, id):
+        wxTreeCtrl.__init__(self, parent, id, style = wxTR_HAS_BUTTONS)
+        self.SetBackgroundColour(wxColour(224, 248, 224))
+        EVT_TREE_SEL_CHANGED(self, self.GetId(), self.OnSelChanged)
+        # One works on Linux, another on Windows
+        if wxPlatform == '__WXGTK__':
+            EVT_TREE_ITEM_ACTIVATED(self, self.GetId(), self.OnItemActivated)
+        else:
+            EVT_LEFT_DCLICK(self, self.OnDClick)
+        EVT_RIGHT_DOWN(self, self.OnRightDown)
+
+        self.needUpdate = false
+        self.pendingHighLight = None
+        self.ctrl = self.shift = false
+        self.dom = None
+        # Create image list
+        il = wxImageList(16, 16, true)
+        self.rootImage = il.AddIcon(images.getTreeRootIcon())
+        xxxObject.image = il.AddIcon(images.getTreeDefaultIcon())
+        xxxPanel.image = il.AddIcon(images.getTreePanelIcon())
+        xxxDialog.image = il.AddIcon(images.getTreeDialogIcon())
+        xxxFrame.image = il.AddIcon(images.getTreeFrameIcon())
+        xxxMenuBar.image = il.AddIcon(images.getTreeMenuBarIcon())
+        xxxToolBar.image = il.AddIcon(images.getTreeToolBarIcon())
+        xxxMenu.image = il.AddIcon(images.getTreeMenuIcon())
+        xxxSizer.imageH = il.AddIcon(images.getTreeSizerHIcon())
+        xxxSizer.imageV = il.AddIcon(images.getTreeSizerVIcon())
+        xxxStaticBoxSizer.imageH = il.AddIcon(images.getTreeStaticBoxSizerHIcon())
+        xxxStaticBoxSizer.imageV = il.AddIcon(images.getTreeStaticBoxSizerVIcon())
+        xxxGridSizer.image = il.AddIcon(images.getTreeSizerGridIcon())
+        xxxFlexGridSizer.image = il.AddIcon(images.getTreeSizerFlexGridIcon())
+        self.il = il
+        self.SetImageList(il)
+
+    def Unselect(self):
+        self.selection = None
+        wxTreeCtrl.Unselect(self)
+
+    def ExpandAll(self, item):
+        if self.ItemHasChildren(item):
+            self.Expand(item)
+            i, cookie = self.GetFirstChild(item, 0)
+            children = []
+            while i.IsOk():
+                children.append(i)
+                i, cookie = self.GetNextChild(item, cookie)
+            for i in children:
+                self.ExpandAll(i)
+    def CollapseAll(self, item):
+        if self.ItemHasChildren(item):
+            i, cookie = self.GetFirstChild(item, 0)
+            children = []
+            while i.IsOk():
+                children.append(i)
+                i, cookie = self.GetNextChild(item, cookie)
+            for i in children:
+                self.CollapseAll(i)
+            self.Collapse(item)
+
+    # Clear tree
+    def Clear(self):
+        self.DeleteAllItems()
+        # Add minimal structure
+        if self.dom: self.dom.unlink()
+        self.dom = MyDocument()
+        self.dummyNode = self.dom.createComment('dummy node')
+        # Create main node
+        self.mainNode = self.dom.createElement('resource')
+        self.dom.appendChild(self.mainNode)
+        self.rootObj = xxxMainNode(self.dom)
+        self.root = self.AddRoot('XML tree', self.rootImage,
+                                 data=wxTreeItemData(self.rootObj))
+        self.SetItemHasChildren(self.root)
+        self.Expand(self.root)
+        self.Unselect()
+
+    # Clear old data and set new
+    def SetData(self, dom):
+        self.DeleteAllItems()
+        # Add minimal structure
+        if self.dom: self.dom.unlink()
+        self.dom = dom
+        self.dummyNode = self.dom.createComment('dummy node')
+        # Find 'resource' child, add it's children
+        self.mainNode = dom.documentElement
+        self.rootObj = xxxMainNode(self.dom)
+        self.root = self.AddRoot('XML tree', self.rootImage,
+                                 data=wxTreeItemData(self.rootObj))
+        self.SetItemHasChildren(self.root)
+        nodes = self.mainNode.childNodes[:]
+        for node in nodes:
+            if IsObject(node):
+                self.AddNode(self.root, None, node)
+            else:
+                self.mainNode.removeChild(node)
+                node.unlink()
+        self.Expand(self.root)
+        self.Unselect()
+
+    # Add tree item for given parent item if node is DOM element node with
+    # 'object' tag. xxxParent is parent xxx object
+    def AddNode(self, itemParent, xxxParent, node):
+        # Set item data to current node
+        try:
+            xxx = MakeXXXFromDOM(xxxParent, node)
+        except:
+            print 'ERROR: MakeXXXFromDom(%s, %s)' % (xxxParent, node)
+            raise
+        treeObj = xxx.treeObject()
+        # Append tree item
+        item = self.AppendItem(itemParent, treeObj.treeName(),
+                               image=treeObj.treeImage(),
+                               data=wxTreeItemData(xxx))
+        # Try to find children objects
+        if treeObj.hasChildren:
+            nodes = treeObj.element.childNodes[:]
+            for n in nodes:
+                if IsObject(n):
+                    self.AddNode(item, treeObj, n)
+                elif n.nodeType != minidom.Node.ELEMENT_NODE:
+                    treeObj.element.removeChild(n)
+                    n.unlink()
+    # Insert new item at specific position
+    def InsertNode(self, itemParent, parent, elem, nextItem):
+        # Insert in XML tree and wxWin
+        xxx = MakeXXXFromDOM(parent, elem)
+        # If nextItem is None, we append to parent, otherwise insert before it
+        if nextItem.IsOk():
+            node = self.GetPyData(nextItem).element
+            parent.element.insertBefore(elem, node)
+            # Inserting before is difficult, se we insert after or first child
+            index = self.ItemIndex(nextItem)
+            newItem = self.InsertItemBefore(itemParent, index,
+                        xxx.treeName(), image=xxx.treeImage())
+            self.SetPyData(newItem, xxx)
+        else:
+            parent.element.appendChild(elem)
+            newItem = self.AppendItem(itemParent, xxx.treeName(), image=xxx.treeImage(),
+                                      data=wxTreeItemData(xxx))
+        # Add children items
+        if xxx.hasChildren:
+            treeObj = xxx.treeObject()
+            for n in treeObj.element.childNodes:
+                if IsObject(n):
+                    self.AddNode(newItem, treeObj, n)
+        return newItem
+            
+    # Remove leaf of tree, return it's data object
+    def RemoveLeaf(self, leaf):
+        xxx = self.GetPyData(leaf)
+        node = xxx.element
+        parent = node.parentNode
+        parent.removeChild(node)
+        self.Delete(leaf)
+        # Reset selection object
+        self.selection = None
+        return node
+    # Find position relative to the top-level window
+    def FindNodePos(self, item):
+        # Root at (0,0)
+        if item == g.testWin.item: return wxPoint(0, 0)
+        itemParent = self.GetItemParent(item)
+        # Select NB page
+        obj = self.FindNodeObject(item)
+        if self.GetPyData(itemParent).treeObject().__class__ == xxxNotebook:
+            notebook = self.FindNodeObject(itemParent)
+            # Find position
+            for i in range(notebook.GetPageCount()):
+                if notebook.GetPage(i) == obj:
+                    if notebook.GetSelection() != i: notebook.SetSelection(i)
+                    break
+        # Find first ancestor which is a wxWindow (not a sizer)
+        winParent = itemParent
+        while self.GetPyData(winParent).isSizer:
+            winParent = self.GetItemParent(winParent)
+        parentPos = self.FindNodePos(winParent)
+        # Position (-1,-1) is really (0,0)
+        pos = obj.GetPosition()
+        if pos == (-1,-1): pos = (0,0)
+        return parentPos + pos
+    # Find window (or sizer) corresponding to a tree item.
+    def FindNodeObject(self, item):
+        testWin = g.testWin
+        # If top-level, return testWin (or panel its panel)
+        if item == testWin.item: return testWin.panel
+        itemParent = self.GetItemParent(item)
+        xxx = self.GetPyData(item).treeObject()
+        parentWin = self.FindNodeObject(itemParent)
+        # Top-level sizer? return window's sizer
+        if xxx.isSizer and isinstance(parentWin, wxWindowPtr):
+            return parentWin.GetSizer()
+        # Otherwise get parent's object and it's child
+        child = parentWin.GetChildren()[self.ItemIndex(item)]
+        # Return window or sizer for sizer items
+        if child.GetClassName() == 'wxSizerItem':
+            if child.IsWindow(): child = child.GetWindow()
+            elif child.IsSizer():
+                child = child.GetSizer()
+                # Test for notebook sizers
+                if isinstance(child, wxNotebookSizerPtr):
+                    child = child.GetNotebook()
+        return child
+    def OnSelChanged(self, evt):
+        # Apply changes
+        # !!! problem with wxGTK - GetOldItem is Ok if nothing selected
+        #oldItem = evt.GetOldItem()
+        status = ''
+        oldItem = self.selection
+        if oldItem:
+            xxx = self.GetPyData(oldItem)
+            # If some data was modified, apply changes
+            if g.panel.IsModified():
+                self.Apply(xxx, oldItem)
+                #if conf.autoRefresh:
+                if g.testWin:
+                    if g.testWin.highLight:
+                        g.testWin.highLight.Remove()
+                    self.needUpdate = true
+                status = 'Changes were applied'
+        g.frame.SetStatusText(status)
+        # Generate view
+        self.selection = evt.GetItem()
+        if not self.selection.IsOk():
+            self.selection = None
+            return
+        xxx = self.GetPyData(self.selection)
+        # Update panel
+        g.panel.SetData(xxx)
+        # Hightlighting is done in OnIdle
+        self.pendingHighLight = self.selection
+    # Check if item is in testWin subtree
+    def IsHighlatable(self, item):
+        if item == g.testWin.item: return false
+        while item != self.root:
+            item = self.GetItemParent(item)
+            if item == g.testWin.item: return true
+        return false
+    # Highlight selected item
+    def HighLight(self, item):
+        self.pendingHighLight = None
+        # Can highlight only with some top-level windows
+        if not g.testWin or self.GetPyData(g.testWin.item).treeObject().__class__ \
+            not in [xxxDialog, xxxPanel, xxxFrame]:
+            return
+        # If a control from another window is selected, remove highlight
+        if not self.IsHighlatable(item):
+            if g.testWin.highLight: g.testWin.highLight.Remove()
+            return
+        # Get window/sizer object
+        obj, pos = self.FindNodeObject(item), self.FindNodePos(item)
+        size = obj.GetSize()
+        # Highlight
+        # Nagative positions are not working wuite well
+        if g.testWin.highLight:
+            g.testWin.highLight.Replace(pos, size)
+        else:
+            g.testWin.highLight = HighLightBox(pos, size)
+        g.testWin.highLight.item = item
+    def ShowTestWindow(self, item):
+        xxx = self.GetPyData(item)
+        if g.panel.IsModified():
+            self.Apply(xxx, item)       # apply changes
+        treeObj = xxx.treeObject()
+        if treeObj.className not in ['wxFrame', 'wxPanel', 'wxDialog',
+                                     'wxMenuBar', 'wxToolBar']:
+            wxLogMessage('No view for this element (yet)')
+            return
+        # Show item in bold
+        if g.testWin:     # Reset old
+            self.SetItemBold(g.testWin.item, false)
+        self.CreateTestWin(item)
+        # Maybe an error occured, so we need to test
+        if g.testWin: self.SetItemBold(g.testWin.item)
+    # Double-click on Linux
+    def OnItemActivated(self, evt):
+        if evt.GetItem() != self.root:
+            self.ShowTestWindow(evt.GetItem())
+    # Double-click on Windows
+    def OnDClick(self, evt):
+        item, flags = self.HitTest(evt.GetPosition())
+        if flags in [wxTREE_HITTEST_ONITEMBUTTON, wxTREE_HITTEST_ONITEMLABEL]:
+            if item != self.root: self.ShowTestWindow(item)
+        else:
+            evt.Skip()
+    # (re)create test window
+    def CreateTestWin(self, item):
+        testWin = g.testWin
+        wxBeginBusyCursor()
+        # Create a window with this resource
+        xxx = self.GetPyData(item).treeObject()
+        # Close old window, remember where it was
+        highLight = None
+        if testWin:
+            pos = testWin.GetPosition()
+            if item == testWin.item:
+                # Remember highlight if same top-level window
+                if testWin.highLight:
+                    highLight = testWin.highLight.item
+                if xxx.className == 'wxPanel':
+                    if testWin.highLight:
+                        testWin.pendingHighLight = highLight
+                        testWin.highLight.Remove()
+                    testWin.panel.Destroy()
+                    testWin.panel = None
+                else:
+                    testWin.Destroy()
+                    testWin = g.testWin = None
+            else:
+                testWin.Destroy()
+                testWin = g.testWin = None
+        else:
+            pos = g.testWinPos
+        # Save in memory FS
+        memFile = MemoryFile('xxx.xrc')
+        # Create partial XML file - faster for big files
+
+        dom = MyDocument()
+        mainNode = dom.createElement('resource')
+        dom.appendChild(mainNode)
+
+        # Remove temporarily from old parent
+        elem = xxx.element
+        # Change window id to _XRCED_T_W. This gives some name for
+        # unnamed windows, and for named gives the possibility to
+        # write sawfish scripts.
+        if not xxx.name:
+            name = 'noname'
+        else:
+            name = xxx.name
+        elem.setAttribute('name', self.stdName)
+        parent = elem.parentNode
+        next = elem.nextSibling
+        parent.replaceChild(self.dummyNode, elem)
+        # Append to new DOM, write it
+        mainNode.appendChild(elem)
+        dom.writexml(memFile, encoding=self.rootObj.params['encoding'].value())
+        # Put back in place
+        mainNode.removeChild(elem)
+        dom.unlink()
+        parent.replaceChild(elem, self.dummyNode)
+        # Remove temporary name or restore changed
+        if not xxx.name:
+            elem.removeAttribute('name')
+        else:
+            elem.setAttribute('name', xxx.name)
+        memFile.close()                 # write to wxMemoryFS
+        res = wxXmlResource('')
+        res.Load('memory:xxx.xrc')
+        if xxx.__class__ == xxxFrame:
+            # Frame can't have many children,
+            # but it's first child possibly can...
+            child = self.GetFirstChild(item, 0)[0]
+            if child.IsOk() and self.GetPyData(child).__class__ == xxxPanel:
+                # Clean-up before recursive call or error
+                wxMemoryFSHandler_RemoveFile('xxx.xrc')
+                wxEndBusyCursor()
+                self.CreateTestWin(child)
+                return
+            # This currently works under GTK, but not under MSW
+            testWin = g.testWin = wxPreFrame()
+            res.LoadOnFrame(testWin, g.frame, self.stdName)
+            # Create status bar
+            testWin.CreateStatusBar()
+            testWin.panel = testWin
+            testWin.SetPosition(pos)
+            testWin.Show(true)
+        elif xxx.__class__ == xxxPanel:
+            # Create new frame
+            if not testWin:
+                testWin = g.testWin = wxFrame(g.frame, -1, 'Panel: ' + name, pos=pos)
+            testWin.panel = res.LoadPanel(testWin, self.stdName)
+            testWin.SetClientSize(testWin.panel.GetSize())
+            testWin.Show(true)
+        elif xxx.__class__ == xxxDialog:
+            testWin = g.testWin = res.LoadDialog(None, self.stdName)
+            testWin.panel = testWin
+            testWin.Layout()
+            testWin.SetPosition(pos)
+            testWin.Show(true)
+        elif xxx.__class__ == xxxMenuBar:
+            testWin = g.testWin = wxFrame(g.frame, -1, 'MenuBar: ' + name, pos=pos)
+            testWin.panel = None
+            # Set status bar to display help
+            testWin.CreateStatusBar()
+            testWin.menuBar = res.LoadMenuBar(self.stdName)
+            testWin.SetMenuBar(testWin.menuBar)
+            testWin.Show(true)
+        elif xxx.__class__ == xxxToolBar:
+            testWin = g.testWin = wxFrame(g.frame, -1, 'ToolBar: ' + name, pos=pos)
+            testWin.panel = None
+            # Set status bar to display help
+            testWin.CreateStatusBar()
+            testWin.toolBar = res.LoadToolBar(testWin, self.stdName)
+            testWin.SetToolBar(testWin.toolBar)
+            testWin.Show(true)
+        wxMemoryFSHandler_RemoveFile('xxx.xrc')
+        testWin.item = item
+        EVT_CLOSE(testWin, self.OnCloseTestWin)
+        EVT_BUTTON(testWin, wxID_OK, self.OnCloseTestWin)
+        EVT_BUTTON(testWin, wxID_CANCEL, self.OnCloseTestWin)
+        testWin.highLight = None
+        if highLight and not self.pendingHighLight:
+            self.HighLight(highLight)
+        wxEndBusyCursor()
+
+    def OnCloseTestWin(self, evt):
+        self.SetItemBold(g.testWin.item, false)
+        g.testWinPos = g.testWin.GetPosition()
+        g.testWin.Destroy()
+        g.testWin = None
+
+    # Return item index in parent
+    def ItemIndex(self, item):
+        n = 0                           # index of sibling
+        prev = self.GetPrevSibling(item)
+        while prev.IsOk():
+            prev = self.GetPrevSibling(prev)
+            n += 1
+        return n
+
+    # Full tree index of an item - list of positions
+    def ItemFullIndex(self, item):
+        if not item.IsOk(): return None
+        l = []
+        while item != self.root:
+            l.insert(0, self.ItemIndex(item))
+            item = self.GetItemParent(item)
+        return l
+    # Get item position from full index
+    def ItemAtFullIndex(self, index):
+        if index is None: return wxTreeItemId()
+        item = self.root
+        for i in index:
+            item = self.GetFirstChild(item, 0)[0]
+            for k in range(i): item = self.GetNextSibling(item)
+        return item
+    
+    # True if next item should be inserted after current (vs. appended to it)
+    def NeedInsert(self, item):
+        xxx = self.GetPyData(item)
+        if item == self.root: return false        # root item
+        if xxx.hasChildren and not self.GetChildrenCount(item, false):
+            return false
+        return not (self.IsExpanded(item) and self.GetChildrenCount(item, false))
+
+    # Pull-down
+    def OnRightDown(self, evt):
+        pullDownMenu = g.pullDownMenu
+        # select this item
+        pt = evt.GetPosition();
+        item, flags = self.HitTest(pt)
+        if item.Ok() and flags & wxTREE_HITTEST_ONITEM:
+            self.SelectItem(item)
+
+        # Setup menu
+        menu = wxMenu()
+
+        item = self.selection
+        if not item:
+            menu.Append(g.pullDownMenu.ID_EXPAND, 'Expand', 'Expand tree')
+            menu.Append(g.pullDownMenu.ID_COLLAPSE, 'Collapse', 'Collapse tree')
+        else:
+            self.ctrl = evt.ControlDown() # save Ctrl state
+            self.shift = evt.ShiftDown()  # and Shift too
+            m = wxMenu()                  # create menu
+            if self.ctrl:
+                needInsert = true
+            else:
+                needInsert = self.NeedInsert(item)
+            if item == self.root or needInsert and self.GetItemParent(item) == self.root:
+                m.Append(pullDownMenu.ID_NEW_PANEL, 'Panel', 'Create panel')
+                m.Append(pullDownMenu.ID_NEW_DIALOG, 'Dialog', 'Create dialog')
+                m.Append(pullDownMenu.ID_NEW_FRAME, 'Frame', 'Create frame')
+                m.AppendSeparator()
+                m.Append(pullDownMenu.ID_NEW_TOOL_BAR, 'ToolBar', 'Create toolbar')
+                m.Append(pullDownMenu.ID_NEW_MENU_BAR, 'MenuBar', 'Create menubar')
+                m.Append(pullDownMenu.ID_NEW_MENU, 'Menu', 'Create menu')
+            else:
+                xxx = self.GetPyData(item).treeObject()
+                # Check parent for possible child nodes if inserting sibling
+                if needInsert: xxx = xxx.parent
+                if xxx.__class__ == xxxMenuBar:
+                    m.Append(pullDownMenu.ID_NEW_MENU, 'Menu', 'Create menu')
+                elif xxx.__class__ in [xxxToolBar, xxxTool] or \
+                     xxx.__class__ == xxxSeparator and xxx.parent.__class__ == xxxToolBar:
+                    SetMenu(m, pullDownMenu.toolBarControls)
+                elif xxx.__class__ in [xxxMenu, xxxMenuItem]:
+                    SetMenu(m, pullDownMenu.menuControls)
+                else:
+                    SetMenu(m, pullDownMenu.controls)
+                    if xxx.__class__ == xxxNotebook:
+                        m.Enable(m.FindItem('sizer'), false)
+                    elif not (xxx.isSizer or xxx.parent and xxx.parent.isSizer):
+                        m.Enable(pullDownMenu.ID_NEW_SPACER, false)
+            # Select correct label for create menu
+            if not needInsert:
+                if self.shift:
+                    menu.AppendMenu(wxNewId(), 'Insert Child', m,
+                                    'Create child object as the first child')
+                else:
+                    menu.AppendMenu(wxNewId(), 'Append Child', m,
+                                    'Create child object as the last child')
+            else:
+                if self.shift:
+                    menu.AppendMenu(wxNewId(), 'Create Sibling', m,
+                                    'Create sibling before selected object')
+                else:
+                    menu.AppendMenu(wxNewId(), 'Create Sibling', m,
+                                    'Create sibling after selected object')
+            menu.AppendSeparator()
+            # Not using standart IDs because we don't want to show shortcuts
+            menu.Append(wxID_CUT, 'Cut', 'Cut to the clipboard')
+            menu.Append(wxID_COPY, 'Copy', 'Copy to the clipboard')
+            if self.ctrl and item != self.root:
+                menu.Append(pullDownMenu.ID_PASTE_SIBLING, 'Paste Sibling',
+                            'Paste from the clipboard as a sibling')
+            else:
+                menu.Append(wxID_PASTE, 'Paste', 'Paste from the clipboard')
+            menu.Append(pullDownMenu.ID_DELETE,
+                                'Delete', 'Delete object')
+            if self.ItemHasChildren(item):
+                menu.AppendSeparator()
+                menu.Append(pullDownMenu.ID_EXPAND, 'Expand', 'Expand subtree')
+                menu.Append(pullDownMenu.ID_COLLAPSE, 'Collapse', 'Collapse subtree')
+        self.PopupMenu(menu, evt.GetPosition())
+        menu.Destroy()
+
+    # Apply changes
+    def Apply(self, xxx, item):
+        g.panel.Apply()
+        # Update tree view
+        xxx = xxx.treeObject()
+        if xxx.hasName and self.GetItemText(item) != xxx.name:
+            self.SetItemText(item, xxx.treeName())
+        # Change tree icon for sizers
+        if isinstance(xxx, xxxBoxSizer):
+            self.SetItemImage(item, xxx.treeImage())
+        # Set global modified state
+        g.frame.modified = true
+