[wxWidgets.git] / wxPython / tools / XRCed / xrced.py

# Name:         xrced.py
# Purpose:      XRC editor, main module
# Author:       Roman Rolinsky <rolinsky@mema.ucl.ac.be>
# Created:      20.08.2001
# RCS-ID:       $Id$

from wxPython.wx import *
from wxPython.xrc import *
from wxPython.html import wxHtmlWindow
from xml.dom import minidom
import os
import getopt

# Icons
import images

# Constants

# Return code from wxGetOsVersion
wxGTK = 9

if wxGetOsVersion()[0] == wxGTK:
    labelFont = wxFont(12, wxDEFAULT, wxNORMAL, wxBOLD)
    modernFont = wxFont(12, wxMODERN, wxNORMAL, wxNORMAL)
else:
    labelFont = wxFont(10, wxDEFAULT, wxNORMAL, wxBOLD)
    modernFont = wxFont(10, wxMODERN, wxNORMAL, wxNORMAL)

progname = 'XRCed'
version = '0.0.7-3'

# Local modules
from xxx import *

# Globals
testWin = None
testWinPos = wxDefaultPosition

# 1 adds CMD command to Help menu
debug = 0

helpText = """\
<HTML><H2>Welcome to XRCed!</H2><H3><font color="green">DON'T PANIC :)</font></H3>
To start select tree root, then popup menu with your right mouse button,
select "Append Child", and then any command.<P>
Enter XML ID, change properties, create children.<P>
To test your interface select Test command (View menu).<P>
Consult README file for the details.</HTML>
"""

defaultIDs = {xxxPanel:'PANEL', xxxDialog:'DIALOG', xxxFrame:'FRAME',
              xxxMenuBar:'MENUBAR', xxxMenu:'MENU', xxxToolBar:'TOOLBAR'}

# 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()

################################################################################

# Properties panel containing notebook
class Panel(wxNotebook):
    def __init__(self, parent, id = -1):
        wxNotebook.__init__(self, parent, id, style=wxNB_BOTTOM)
        sys.modules['params'].panel = self
        # 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, 'non visible')
    # 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 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 tree.selection:
                sizer.Add(wxStaticText(self.page1, -1, 'This item has no properties.'))
            else:                       # nothing selected
                # If first time, show some help
                if conf.panic:
                    html = wxHtmlWindow(self.page1, -1, wxDefaultPosition,
                                        wxDefaultSize, wxSUNKEN_BORDER)
                    html.SetPage(helpText)
                    sizer.Add(html, 1, wxEXPAND)
                    conf.panic = false
                else:
                    sizer.Add(wxStaticText(self.page1, -1, 'Select a tree item.'))
        else:
            SetCurrentXXX(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)
    def Clear(self):
        self.SetData(None)
    # Check if some parameter on some page has changed
    def IsModified(self):
        for p in self.pages:
            if p.IsModified(): return true
        return false
    # Reset changed state
    def SetModified(self, value):
        for p in self.pages: p.SetModified(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.modified = false
        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 = 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
            # Set modified flas
            self.SetModified(true)
        w.Enable(evt.IsChecked())
    # If some parameter has changed
    def IsModified(self):
        return self.modified
    def SetModified(self, value):
        self.modified = value
    def Apply(self):
        xxx = self.xxx
        # !!! Save undo info
#        if xxx.undo: xxx.undo.unlink()
#        xxx.undo = xxx.element.cloneNode(false)
        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)

################################################################################

# 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 = param in xxx.params
            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
        # Set values, checkboxes to false, disable defaults
        if xxx.hasName:
            self.controlName.SetValue(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)
            except KeyError:
                self.checks[param].SetValue(false)
                w.SetValue('')
                w.Enable(false)
        self.SetModified(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 = param in xxx.params.keys()
            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
        for param in xxx.styles:
            present = param in xxx.params.keys()
            check = self.checks[param]
            check.SetValue(present)
            w = self.controls[param]
            w.modified = false
            if present:
                w.SetValue(xxx.params[param].value())
            else:
                w.SetValue('')
            w.Enable(present)
        self.SetModified(false)

################################################################################

class HightLightBox:
    def __init__(self, pos, size):
        w = 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):
        self.lines[0].SetDimensions(pos.x, pos.y, size.x, 2, wxSIZE_ALLOW_MINUS_ONE)
        self.lines[1].SetDimensions(pos.x, pos.y, 2, size.y, wxSIZE_ALLOW_MINUS_ONE)
        self.lines[2].SetDimensions(pos.x + size.x - 2, pos.y, 2, size.y,
                                    wxSIZE_ALLOW_MINUS_ONE)
        self.lines[3].SetDimensions(pos.x, pos.y + size.y - 2, size.x, 2,
                                    wxSIZE_ALLOW_MINUS_ONE)
    # Remove it
    def Remove(self):
        map(wxWindow.Destroy, self.lines)
        testWin.highLight = None

################################################################################

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)

class XML_Tree(wxTreeCtrl):
    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 wxGetOsVersion()[0] == 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(wxIconFromXPMData(images.getTreeRootData()))
        xxxObject.image = il.AddIcon(wxIconFromXPMData(images.getTreeDefaultData()))
        xxxPanel.image = il.AddIcon(wxIconFromXPMData(images.getTreePanelData()))
        xxxDialog.image = il.AddIcon(wxIconFromXPMData(images.getTreeDialogData()))
        xxxFrame.image = il.AddIcon(wxIconFromXPMData(images.getTreeFrameData()))
        xxxMenuBar.image = il.AddIcon(wxIconFromXPMData(images.getTreeMenuBarData()))
        xxxToolBar.image = il.AddIcon(wxIconFromXPMData(images.getTreeToolBarData()))
        xxxMenu.image = il.AddIcon(wxIconFromXPMData(images.getTreeMenuData()))
        xxxSizer.imageH = il.AddIcon(wxIconFromXPMData(images.getTreeSizerHData()))
        xxxSizer.imageV = il.AddIcon(wxIconFromXPMData(images.getTreeSizerVData()))
        xxxStaticBoxSizer.imageH = il.AddIcon(wxIconFromXPMData(images.getTreeStaticBoxSizerHData()))
        xxxStaticBoxSizer.imageV = il.AddIcon(wxIconFromXPMData(images.getTreeStaticBoxSizerVData()))
        xxxGridSizer.image = il.AddIcon(wxIconFromXPMData(images.getTreeSizerGridData()))
        xxxFlexGridSizer.image = il.AddIcon(wxIconFromXPMData(images.getTreeSizerFlexGridData()))
        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 = minidom.Document()
        self.dummyNode = self.dom.createComment('dummy node')
        # Create main node
        self.mainNode = self.dom.createElement('resource')
        self.dom.appendChild(self.mainNode)
        xxx = xxxMainNode(None, self.mainNode)
        self.root = self.AddRoot('XML tree', self.rootImage, data=wxTreeItemData(xxx))
        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.getElementsByTagName('resource')[0]
        xxx = xxxMainNode(None, self.mainNode)
        self.root = self.AddRoot('XML tree', self.rootImage, data=wxTreeItemData(xxx))
        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()
    # 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 == 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):
        if item == testWin.item: return testWin.panel
        itemParent = self.GetItemParent(item)
        # If top-level, return testWin (or panel if wxFrame)
        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
        n = 0                           # index of sibling
        prev = self.GetPrevSibling(item)
        while prev.IsOk():
            prev = self.GetPrevSibling(prev)
            n += 1
        child = parentWin.GetChildren()[n]
        # 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 panel.IsModified():
                self.Apply(xxx, oldItem)
                #if conf.autoRefresh:
                if testWin:
                    if testWin.highLight and not tree.IsHighlatable(oldItem):
                        testWin.highLight.Remove()
                    self.needUpdate = true
                status = 'Changes were applied'
        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
        panel.SetData(xxx)
        # Clear flag
        panel.SetModified(false)
        # Hightlighting is done in OnIdle
        tree.pendingHighLight = self.selection
    # Check if item is in testWin subtree
    def IsHighlatable(self, item):
        if item == testWin.item: return false
        while item != self.root:
            item = self.GetItemParent(item)
            if item == testWin.item: return true
        return false
    # Highlight selected item
    def HighLight(self, item):
        self.pendingHighLight = None
        if not testWin or self.GetPyData(testWin.item).className \
            not in ['wxDialog', 'wxPanel', 'wxFrame']:
            return
        # Top-level does not have highlight
        if item == testWin.item or item == tree.root:
            if testWin.highLight: testWin.highLight.Remove()
            return
        # If a control from another window is selected, remove highlight
        if not self.IsHighlatable(item):
            if testWin.highLight: 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 testWin.highLight:
            testWin.highLight.Replace(pos, size)
        else:
            testWin.highLight = HightLightBox(pos, size)
        testWin.highLight.item = item
    def ShowTestWindow(self, item):
        global testWin
        xxx = self.GetPyData(item)
        if 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
        if not treeObj.name:
            wxLogError("Can't display a noname element!")
            return
        # Show item in bold
        if testWin:
            self.SetItemBold(testWin.item, false)
        self.SetItemBold(item)
        self.CreateTestWin(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):
        global 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 0 is removed, refresh is broken (notebook not deleted?)
                if xxx.className == 'wxPanel':
                    if testWin.highLight:
                        testWin.pendingHighLight = highLight
                        testWin.highLight.Remove()
                    testWin.panel.Destroy()
                    testWin.panel = None
                else:
                    testWin.Destroy()
                    testWin = None
            else:
                testWin.Destroy()
                testWin = None
        else:
            pos = testWinPos
        # Save in memory FS
        memFile = MemoryFile('xxx.xrc')
        # Create partial XML file - faster for big files

        dom = minidom.Document()
        mainNode = dom.createElement('resource')
        dom.appendChild(mainNode)

        # Remove temporarily from old parent
        elem = xxx.element
        parent = elem.parentNode
        next = elem.nextSibling
        parent.replaceChild(self.dummyNode, elem)
        # Append to new DOM, write it
        mainNode.appendChild(elem)
        dom.writexml(memFile)
        # Put back in place
        mainNode.removeChild(elem)
        dom.unlink()
        parent.replaceChild(elem, self.dummyNode)
        memFile.close()                 # write to wxMemoryFS
        res = wxXmlResource('')
        res.Load('memory:xxx.xrc')
        if xxx.className == 'wxFrame':
            # Create new frame
            testWin = wxPreFrame()
            res.LoadFrame(testWin, frame, xxx.name)
            # Create status bar
            testWin.CreateStatusBar()
            testWin.panel = testWin
            testWin.SetPosition(pos)
            testWin.Show(true)
        elif xxx.className == 'wxPanel':
            # Create new frame
            if not testWin:
                testWin = wxFrame(frame, -1, 'Panel: ' + xxx.name, pos=pos)
            testWin.panel = res.LoadPanel(testWin, xxx.name)
            testWin.SetClientSize(testWin.panel.GetSize())
            testWin.Show(true)
        elif xxx.className == 'wxDialog':
            # Create new frame
            testWin = res.LoadDialog(None, xxx.name)
            testWin.panel = testWin
            testWin.Layout()
            testWin.SetPosition(pos)
            testWin.Show(true)
        elif xxx.className == 'wxMenuBar':
            testWin = wxFrame(frame, -1, 'MenuBar: ' + xxx.name, pos=pos)
            testWin.panel = None
            # Set status bar to display help
            testWin.CreateStatusBar()
            testWin.menuBar = res.LoadMenuBar(xxx.name)
            testWin.SetMenuBar(testWin.menuBar)
            testWin.Show(true)
        elif xxx.className == 'wxToolBar':
            testWin = wxFrame(frame, -1, 'ToolBar: ' + xxx.name, pos=pos)
            testWin.panel = None
            # Set status bar to display help
            testWin.CreateStatusBar()
            testWin.toolBar = res.LoadToolBar(testWin, xxx.name)
            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 tree.pendingHighLight:
            self.HighLight(highLight)
        wxEndBusyCursor()

    def OnCloseTestWin(self, evt):
        global testWin, testWinPos
        self.SetItemBold(testWin.item, false)
        testWinPos = testWin.GetPosition()
        testWin.Destroy()
        testWin = None

    # Return item index in parent
    def ItemIndex(self, parent, item):
        i = 0
        it, cookie = self.GetFirstChild(parent, 0)
        while it != item:
            i += 1
            it, cookie = self.GetNextChild(parent, cookie)
        return i

    # 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):
        # 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(pullDownMenu.ID_EXPAND, 'Expand', 'Expand tree')
            menu.Append(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 != tree.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):
        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
        frame.modified = true

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 = 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(tree, parent.OnPullDownHighlight)

################################################################################

# ScrolledMessageDialog - modified from wxPython lib to set fixed-width font
class ScrolledMessageDialog(wxDialog):
    def __init__(self, parent, msg, caption, pos = wxDefaultPosition, size = (500,300)):
        from wxPython.lib.layoutf import Layoutf
        wxDialog.__init__(self, parent, -1, caption, pos, size)
        text = wxTextCtrl(self, -1, msg, wxDefaultPosition,
                             wxDefaultSize, wxTE_MULTILINE | wxTE_READONLY)
        text.SetFont(modernFont)
        dc = wxWindowDC(text)
        w, h = dc.GetTextExtent(' ')
        ok = wxButton(self, wxID_OK, "OK")
        text.SetConstraints(Layoutf('t=t5#1;b=t5#2;l=l5#1;r=r5#1', (self,ok)))
        text.SetSize((w * 80 + 30, h * 40))
        ok.SetConstraints(Layoutf('b=b5#1;x%w50#1;w!80;h!25', (self,)))
        self.SetAutoLayout(TRUE)
        self.Fit()
        self.CenterOnScreen(wxBOTH)

################################################################################

class Frame(wxFrame):
    def __init__(self, pos, size):
        global frame
        frame = self
        wxFrame.__init__(self, None, -1, '', pos, size)
        self.CreateStatusBar()
        icon = wxIcon(os.path.join(sys.path[0], 'xrced.ico'), wxBITMAP_TYPE_ICO)
        self.SetIcon(icon)

        # Idle flag
        self.inIdle = false

        # Make menus
        menuBar = wxMenuBar()

        menu = wxMenu()
        menu.Append(wxID_NEW, '&New\tCtrl-N', 'New file')
        menu.Append(wxID_OPEN, '&Open...\tCtrl-O', 'Open XRC file')
        menu.Append(wxID_SAVE, '&Save\tCtrl-S', 'Save XRC file')
        menu.Append(wxID_SAVEAS, 'Save &As...', 'Save XRC file under different name')
        menu.AppendSeparator()
        menu.Append(wxID_EXIT, '&Quit\tCtrl-Q', 'Exit application')
        menuBar.Append(menu, '&File')

        menu = wxMenu()
        menu.Append(wxID_UNDO, '&Undo\tCtrl-Z', 'Undo')
        menu.Append(wxID_REDO, '&Redo\tCtrl-Y', 'Redo')
        menu.AppendSeparator()
        menu.Append(wxID_CUT, 'Cut\tCtrl-X', 'Cut to the clipboard')
        menu.Append(wxID_COPY, '&Copy\tCtrl-C', 'Copy to the clipboard')
        menu.Append(wxID_PASTE, '&Paste\tCtrl-V', 'Paste from the clipboard')
        self.ID_DELETE = wxNewId()
        menu.Append(self.ID_DELETE, '&Delete\tCtrl-D', 'Delete object')
        menuBar.Append(menu, '&Edit')

        menu = wxMenu()
        self.ID_EMBED_PANEL = wxNewId()
        menu.Append(self.ID_EMBED_PANEL, '&Embed Panel',
                    'Toggle embedding properties panel in the main window', true)
        menu.Check(self.ID_EMBED_PANEL, conf.embedPanel)
        menu.AppendSeparator()
        self.ID_TEST = wxNewId()
        menu.Append(self.ID_TEST, '&Test\tF5', 'Test window')
        self.ID_REFRESH = wxNewId()
        menu.Append(self.ID_REFRESH, '&Refresh\tCtrl-R', 'Refresh test window')
        self.ID_AUTO_REFRESH = wxNewId()
        menu.Append(self.ID_AUTO_REFRESH, '&Auto-refresh\tCtrl-A',
                    'Toggle auto-refresh mode', true)
        menu.Check(self.ID_AUTO_REFRESH, conf.autoRefresh)
        menuBar.Append(menu, '&View')

        menu = wxMenu()
        menu.Append(wxID_ABOUT, '&About...', 'About XCRed')
        self.ID_README = wxNewId()
        menu.Append(self.ID_README, '&Readme...', 'View the README file')
        if debug:
            self.ID_DEBUG_CMD = wxNewId()
            menu.Append(self.ID_DEBUG_CMD, 'CMD', 'Python command line')
            EVT_MENU(self, self.ID_DEBUG_CMD, self.OnDebugCMD)
        menuBar.Append(menu, '&Help')

        self.menuBar = menuBar
        self.SetMenuBar(menuBar)

        # Create toolbar
        tb = self.CreateToolBar(wxTB_HORIZONTAL | wxNO_BORDER | wxTB_FLAT)
        tb.SetToolBitmapSize((24, 23))
        tb.AddSimpleTool(wxID_NEW, images.getNewBitmap(), 'New', 'New file')
        tb.AddSimpleTool(wxID_OPEN, images.getOpenBitmap(), 'Open', 'Open file')
        tb.AddSimpleTool(wxID_SAVE, images.getSaveBitmap(), 'Save', 'Save file')
        tb.AddControl(wxStaticLine(tb, -1, size=(-1,23), style=wxLI_VERTICAL))
        tb.AddSimpleTool(wxID_CUT, images.getCutBitmap(), 'Cut', 'Cut')
        tb.AddSimpleTool(wxID_COPY, images.getCopyBitmap(), 'Copy', 'Copy')
        tb.AddSimpleTool(wxID_PASTE, images.getPasteBitmap(), 'Paste', 'Paste')
        tb.AddControl(wxStaticLine(tb, -1, size=(-1,23), style=wxLI_VERTICAL))
        tb.AddSimpleTool(self.ID_TEST, images.getTestBitmap(), 'Test', 'Test window')
        tb.AddSimpleTool(self.ID_REFRESH, images.getRefreshBitmap(),
                         'Refresh', 'Refresh view')
        tb.AddSimpleTool(self.ID_AUTO_REFRESH, images.getAutoRefreshBitmap(),
                         'Auto-refresh', 'Toggle auto-refresh mode', true)
        if wxGetOsVersion()[0] == wxGTK:
            tb.AddSeparator()   # otherwise auto-refresh sticks in status line
        tb.ToggleTool(self.ID_AUTO_REFRESH, conf.autoRefresh)
        tb.Realize()
        self.tb = tb
        self.minWidth = tb.GetSize()[0] # minimal width is the size of toolbar

        # File
        EVT_MENU(self, wxID_NEW, self.OnNew)
        EVT_MENU(self, wxID_OPEN, self.OnOpen)
        EVT_MENU(self, wxID_SAVE, self.OnSaveOrSaveAs)
        EVT_MENU(self, wxID_SAVEAS, self.OnSaveOrSaveAs)
        EVT_MENU(self, wxID_EXIT, self.OnExit)
        # Edit
        EVT_MENU(self, wxID_UNDO, self.OnUndo)
        EVT_MENU(self, wxID_REDO, self.OnRedo)
        EVT_MENU(self, wxID_CUT, self.OnCut)
        EVT_MENU(self, wxID_COPY, self.OnCopy)
        EVT_MENU(self, wxID_PASTE, self.OnPaste)
        EVT_MENU(self, self.ID_DELETE, self.OnDelete)
        # View
        EVT_MENU(self, self.ID_EMBED_PANEL, self.OnEmbedPanel)
        EVT_MENU(self, self.ID_TEST, self.OnTest)
        EVT_MENU(self, self.ID_REFRESH, self.OnRefresh)
        EVT_MENU(self, self.ID_AUTO_REFRESH, self.OnAutoRefresh)
        # Help
        EVT_MENU(self, wxID_ABOUT, self.OnAbout)
        EVT_MENU(self, self.ID_README, self.OnReadme)

        # Update events
        EVT_UPDATE_UI(self, wxID_CUT, self.OnUpdateUI)
        EVT_UPDATE_UI(self, wxID_COPY, self.OnUpdateUI)
        EVT_UPDATE_UI(self, wxID_PASTE, self.OnUpdateUI)
        EVT_UPDATE_UI(self, self.ID_DELETE, self.OnUpdateUI)
        EVT_UPDATE_UI(self, self.ID_TEST, self.OnUpdateUI)
        EVT_UPDATE_UI(self, self.ID_REFRESH, self.OnUpdateUI)

        # Build interface
        sizer = wxBoxSizer(wxVERTICAL)
        sizer.Add(wxStaticLine(self, -1), 0, wxEXPAND)
        splitter = wxSplitterWindow(self, -1, style=wxSP_3DSASH)
        self.splitter = splitter
        splitter.SetMinimumPaneSize(100)
        # Create tree
        global tree
        tree = XML_Tree(splitter, -1)
        sys.modules['xxx'].tree = tree
        # !!! frame styles are broken
        # Miniframe for not embedded mode
        miniFrame = wxFrame(self, -1, 'Properties Panel',
                            (conf.panelX, conf.panelY),
                            (conf.panelWidth, conf.panelHeight))
        self.miniFrame = miniFrame
        sizer2 = wxBoxSizer()
        miniFrame.SetAutoLayout(true)
        miniFrame.SetSizer(sizer2)
        EVT_CLOSE(self.miniFrame, self.OnCloseMiniFrame)
        # Create panel for parameters
        global panel
        if conf.embedPanel:
            panel = Panel(splitter)
            # Set plitter windows
            splitter.SplitVertically(tree, panel, conf.sashPos)
        else:
            panel = Panel(miniFrame)
            sizer2.Add(panel, 1, wxEXPAND)
            miniFrame.Show(true)
            splitter.Initialize(tree)
        sizer.Add(splitter, 1, wxEXPAND)
        self.SetAutoLayout(true)
        self.SetSizer(sizer)

        # Init pull-down menu data
        global pullDownMenu
        pullDownMenu = PullDownMenu(self)
        # Mapping from IDs to element names
        self.createMap = {
            pullDownMenu.ID_NEW_PANEL: 'wxPanel',
            pullDownMenu.ID_NEW_DIALOG: 'wxDialog',
            pullDownMenu.ID_NEW_FRAME: 'wxFrame',
            pullDownMenu.ID_NEW_TOOL_BAR: 'wxToolBar',
            pullDownMenu.ID_NEW_TOOL: 'tool',
            pullDownMenu.ID_NEW_MENU_BAR: 'wxMenuBar',
            pullDownMenu.ID_NEW_MENU: 'wxMenu',
            pullDownMenu.ID_NEW_MENU_ITEM: 'wxMenuItem',
            pullDownMenu.ID_NEW_SEPARATOR: 'separator',

            pullDownMenu.ID_NEW_STATIC_TEXT: 'wxStaticText',
            pullDownMenu.ID_NEW_TEXT_CTRL: 'wxTextCtrl',

            pullDownMenu.ID_NEW_BUTTON: 'wxButton',
            pullDownMenu.ID_NEW_BITMAP_BUTTON: 'wxBitmapButton',
            pullDownMenu.ID_NEW_RADIO_BUTTON: 'wxRadioButton',
            pullDownMenu.ID_NEW_SPIN_BUTTON: 'wxSpinButton',

            pullDownMenu.ID_NEW_STATIC_BOX: 'wxStaticBox',
            pullDownMenu.ID_NEW_CHECK_BOX: 'wxCheckBox',
            pullDownMenu.ID_NEW_RADIO_BOX: 'wxRadioBox',
            pullDownMenu.ID_NEW_COMBO_BOX: 'wxComboBox',
            pullDownMenu.ID_NEW_LIST_BOX: 'wxListBox',

            pullDownMenu.ID_NEW_STATIC_LINE: 'wxStaticLine',
            pullDownMenu.ID_NEW_STATIC_BITMAP: 'wxStaticBitmap',
            pullDownMenu.ID_NEW_CHOICE: 'wxChoice',
            pullDownMenu.ID_NEW_SLIDER: 'wxSlider',
            pullDownMenu.ID_NEW_GAUGE: 'wxGauge',
            pullDownMenu.ID_NEW_SCROLL_BAR: 'wxScrollBar',
            pullDownMenu.ID_NEW_TREE_CTRL: 'wxTreeCtrl',
            pullDownMenu.ID_NEW_LIST_CTRL: 'wxListCtrl',
            pullDownMenu.ID_NEW_CHECK_LIST: 'wxCheckList',
            pullDownMenu.ID_NEW_NOTEBOOK: 'wxNotebook',
            pullDownMenu.ID_NEW_HTML_WINDOW: 'wxHtmlWindow',
            pullDownMenu.ID_NEW_CALENDAR: 'wxCalendar',

            pullDownMenu.ID_NEW_BOX_SIZER: 'wxBoxSizer',
            pullDownMenu.ID_NEW_STATIC_BOX_SIZER: 'wxStaticBoxSizer',
            pullDownMenu.ID_NEW_GRID_SIZER: 'wxGridSizer',
            pullDownMenu.ID_NEW_FLEX_GRID_SIZER: 'wxFlexGridSizer',
            pullDownMenu.ID_NEW_SPACER: 'spacer',
            }
        pullDownMenu.controls = [
            ['control', 'Various controls',
             (pullDownMenu.ID_NEW_STATIC_TEXT, 'Label', 'Create static label'),
             (pullDownMenu.ID_NEW_STATIC_LINE, 'Line', 'Create static line'),
             (pullDownMenu.ID_NEW_TEXT_CTRL, 'TextBox', 'Create text box control'),
             (pullDownMenu.ID_NEW_CHOICE, 'Choice', 'Create choice control'),
             (pullDownMenu.ID_NEW_SLIDER, 'Slider', 'Create slider control'),
             (pullDownMenu.ID_NEW_GAUGE, 'Gauge', 'Create gauge control'),
             (pullDownMenu.ID_NEW_SCROLL_BAR, 'ScrollBar', 'Create scroll bar'),
             (pullDownMenu.ID_NEW_TREE_CTRL, 'TreeCtrl', 'Create tree control'),
             (pullDownMenu.ID_NEW_LIST_CTRL, 'ListCtrl', 'Create list control'),
             (pullDownMenu.ID_NEW_HTML_WINDOW, 'HtmlWindow', 'Create HTML window'),
             (pullDownMenu.ID_NEW_CALENDAR, 'Calendar', 'Create calendar control'),
             (pullDownMenu.ID_NEW_PANEL, 'Panel', 'Create panel'),
             (pullDownMenu.ID_NEW_NOTEBOOK, 'Notebook', 'Create notebook control'),
             ],
            ['button', 'Buttons',
             (pullDownMenu.ID_NEW_BUTTON, 'Button', 'Create button'),
             (pullDownMenu.ID_NEW_BITMAP_BUTTON, 'BitmapButton', 'Create bitmap button'),
             (pullDownMenu.ID_NEW_RADIO_BUTTON, 'RadioButton', 'Create radio button'),
             (pullDownMenu.ID_NEW_SPIN_BUTTON, 'SpinButton', 'Create spin button'),
             ],
            ['box', 'Boxes',
             (pullDownMenu.ID_NEW_STATIC_BOX, 'StaticBox', 'Create static box'),
             (pullDownMenu.ID_NEW_CHECK_BOX, 'CheckBox', 'Create check box'),
             (pullDownMenu.ID_NEW_RADIO_BOX, 'RadioBox', 'Create radio box'),
             (pullDownMenu.ID_NEW_COMBO_BOX, 'ComboBox', 'Create combo box'),
             (pullDownMenu.ID_NEW_LIST_BOX, 'ListBox', 'Create list box'),
             (pullDownMenu.ID_NEW_CHECK_LIST, 'CheckListBox',
              'Create check list control'),
             ],
            ['sizer', 'Sizers',
             (pullDownMenu.ID_NEW_BOX_SIZER, 'BoxSizer', 'Create box sizer'),
             (pullDownMenu.ID_NEW_STATIC_BOX_SIZER, 'StaticBoxSizer',
              'Create static box sizer'),
             (pullDownMenu.ID_NEW_GRID_SIZER, 'GridSizer', 'Create grid sizer'),
             (pullDownMenu.ID_NEW_FLEX_GRID_SIZER, 'FlexGridSizer',
              'Create flexgrid sizer'),
             (pullDownMenu.ID_NEW_SPACER, 'Spacer', 'Create spacer'),
             ]
            ]
        pullDownMenu.menuControls = [
            (pullDownMenu.ID_NEW_MENU, 'Menu', 'Create menu'),
            (pullDownMenu.ID_NEW_MENU_ITEM, 'MenuItem', 'Create menu item'),
            (pullDownMenu.ID_NEW_SEPARATOR, 'Separator', 'Create separator'),
            ]
        pullDownMenu.toolBarControls = [
            (pullDownMenu.ID_NEW_TOOL, 'Tool', 'Create tool'),
            (pullDownMenu.ID_NEW_SEPARATOR, 'Separator', 'Create separator'),
            ['control', 'Various controls',
             (pullDownMenu.ID_NEW_STATIC_TEXT, 'Label', 'Create static label'),
             (pullDownMenu.ID_NEW_STATIC_LINE, 'Line', 'Create static line'),
             (pullDownMenu.ID_NEW_TEXT_CTRL, 'TextBox', 'Create text box control'),
             (pullDownMenu.ID_NEW_CHOICE, 'Choice', 'Create choice control'),
             (pullDownMenu.ID_NEW_SLIDER, 'Slider', 'Create slider control'),
             (pullDownMenu.ID_NEW_GAUGE, 'Gauge', 'Create gauge control'),
             (pullDownMenu.ID_NEW_SCROLL_BAR, 'ScrollBar', 'Create scroll bar'),
             (pullDownMenu.ID_NEW_LIST_CTRL, 'ListCtrl', 'Create list control'),
             ],
            ['button', 'Buttons',
             (pullDownMenu.ID_NEW_BUTTON, 'Button', 'Create button'),
             (pullDownMenu.ID_NEW_BITMAP_BUTTON, 'BitmapButton', 'Create bitmap button'),
             (pullDownMenu.ID_NEW_RADIO_BUTTON, 'RadioButton', 'Create radio button'),
             (pullDownMenu.ID_NEW_SPIN_BUTTON, 'SpinButton', 'Create spin button'),
             ],
            ['box', 'Boxes',
             (pullDownMenu.ID_NEW_STATIC_BOX, 'StaticBox', 'Create static box'),
             (pullDownMenu.ID_NEW_CHECK_BOX, 'CheckBox', 'Create check box'),
             (pullDownMenu.ID_NEW_RADIO_BOX, 'RadioBox', 'Create radio box'),
             (pullDownMenu.ID_NEW_COMBO_BOX, 'ComboBox', 'Create combo box'),
             (pullDownMenu.ID_NEW_LIST_BOX, 'ListBox', 'Create list box'),
             (pullDownMenu.ID_NEW_CHECK_LIST, 'CheckListBox',
              'Create check list control'),
             ],
            ]

        # Initialize
        self.Clear()

        # Other events
        EVT_IDLE(self, self.OnIdle)
        EVT_CLOSE(self, self.OnCloseWindow)

    def OnNew(self, evt):
        self.Clear()

    def OnOpen(self, evt):
        if not self.AskSave(): return
        dlg = wxFileDialog(self, 'Open', os.path.dirname(self.dataFile),
                           '', '*.xrc', wxOPEN | wxCHANGE_DIR)
        if dlg.ShowModal() == wxID_OK:
            path = dlg.GetPath()
            self.SetStatusText('Loading...')
            wxYield()
            wxBeginBusyCursor()
            try:
                self.Open(path)
                self.SetStatusText('Data loaded')
            except:
                self.SetStatusText('Failed')
                raise
            wxEndBusyCursor()
        dlg.Destroy()

    def OnSaveOrSaveAs(self, evt):
        if evt.GetId() == wxID_SAVEAS or not self.dataFile:
            if self.dataFile: defaultName = ''
            else: defaultName = 'UNTITLED.xrc'
            dlg = wxFileDialog(self, 'Save As', os.path.dirname(self.dataFile),
                               defaultName, '*.xrc',
                               wxSAVE | wxOVERWRITE_PROMPT | wxCHANGE_DIR)
            if dlg.ShowModal() == wxID_OK:
                path = dlg.GetPath()
                dlg.Destroy()
            else:
                dlg.Destroy()
                return
        else:
            path = self.dataFile
        self.SetStatusText('Saving...')
        wxYield()
        wxBeginBusyCursor()
        try:
            self.Save(path)
            self.dataFile = path
            self.SetStatusText('Data saved')
        except IOError:
            self.SetStatusText('Failed')
        wxEndBusyCursor()

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

    def OnUndo(self, evt):
        print '*** being implemented'
        return
        print self.lastOp, self.undo
        if self.lastOp == 'DELETE':
            parent, prev, elem = self.undo
            if prev.IsOk():
                xxx = MakeXXXFromDOM(tree.GetPyData(parent).treeObject(), elem)
                item = tree.InsertItem( parent, prev, xxx.treeObject().className,
                                        data=wxTreeItemData(xxx) )

    def OnRedo(self, evt):
        print '*** being implemented'

    def OnCut(self, evt):
        selected = tree.selection
        if not selected: return         # key pressed event
        # Undo info
        self.lastOp = 'CUT'
        self.undo = [tree.GetItemParent(selected), tree.GetPrevSibling(selected)]
        # Delete testWin?
        global testWin
        if testWin:
            # If deleting top-level item, delete testWin
            if selected == testWin.item:
                testWin.Destroy()
                testWin = None
            else:
                # Remove highlight, update testWin
                if not tree.IsHighlatable(selected):
                    if testWin.highLight: testWin.highLight.Remove()
                    tree.needUpdate = true
        self.clipboard = tree.RemoveLeaf(selected)
        tree.pendingHighLight = None
        tree.Unselect()
        panel.Clear()
        self.modified = true
        self.SetStatusText('Removed to clipboard')

    def OnCopy(self, evt):
        selected = tree.selection
        if not selected: return         # key pressed event
        xxx = tree.GetPyData(selected)
        self.clipboard = xxx.element.cloneNode(true)
        self.SetStatusText('Copied')

    def OnPaste(self, evt):
        selected = tree.selection
        if not selected: return         # key pressed event
        # For pasting with Ctrl pressed
        if evt.GetId() == pullDownMenu.ID_PASTE_SIBLING: appendChild = false
        else: appendChild = not tree.NeedInsert(selected)
        xxx = tree.GetPyData(selected)
        if not appendChild:
            # If has next item, insert, else append to parent
            nextItem = tree.GetNextSibling(selected)
            if nextItem.IsOk():
                # Insert before nextItem
                parentLeaf = tree.GetItemParent(selected)
            else:                   # last child: change selected to parent
                appendChild = true
                selected = tree.GetItemParent(selected)
        # Expanded container (must have children)
        elif tree.IsExpanded(selected) and tree.GetChildrenCount(selected, false):
            appendChild = false
            nextItem = tree.GetFirstChild(selected, 0)[0]
            parentLeaf = selected
        # Parent should be tree element or None
        if appendChild:
            parent = tree.GetPyData(selected)
        else:
            parent = tree.GetPyData(parentLeaf)
        if parent.hasChild: parent = parent.child

        # Create a copy of clipboard element
        elem = self.clipboard.cloneNode(true)
        # Tempopary xxx object to test things
        xxx = MakeXXXFromDOM(parent, elem)

        # Check compatibility
        error = false
        # Top-level
        x = xxx.treeObject()
        if x.__class__ in [xxxDialog, xxxFrame, xxxMenuBar, xxxToolBar]:
            if parent.__class__ != xxxMainNode: error = true
        elif x.__class__ == xxxPanel and parent.__class__ == xxxMainNode:
            pass
        elif x.__class__ == xxxSpacer:
            if not parent.isSizer: error = true
        elif x.__class__ == xxxSeparator:
            if not parent.__class__ in [xxxMenu, xxxToolBar]: error = true
        elif x.__class__ == xxxTool:
            if parent.__class__ != xxxToolBar: error = true
        elif x.__class__ == xxxMenuItem:
            if not parent.__class__ in [xxxMenuBar, xxxMenu]: error = true
        elif x.isSizer and parent.__class__ == xxxNotebook: error = true
        else:                           # normal controls can be almost anywhere
            if parent.__class__ == xxxMainNode or \
               parent.__class__ in [xxxMenuBar, xxxMenu]: error = true
        if error:
            if parent.__class__ == xxxMainNode: parentClass = 'root'
            else: parentClass = parent.className
            wxLogError('Incompatible parent/child: parent is %s, child is %s!' %
                       (parentClass, x.className))
            return

        # Check parent and child relationships.
        # If parent is sizer or notebook, child is of wrong class or
        # parent is normal window, child is child container then detach child.
        isChildContainer = isinstance(xxx, xxxChildContainer)
        if isChildContainer and \
           ((parent.isSizer and not isinstance(xxx, xxxSizerItem)) or \
           (isinstance(parent, xxxNotebook) and not isinstance(xxx, xxxNotebookPage)) or \
           not (parent.isSizer or isinstance(parent, xxxNotebook))):
            elem.removeChild(xxx.child.element) # detach child
            elem.unlink()           # delete child container
            elem = xxx.child.element # replace
            # This may help garbage collection
            xxx.child.parent = None
            isChildContainer = false
        # Parent is sizer or notebook, child is not child container
        if parent.isSizer and not isChildContainer and not isinstance(xxx, xxxSpacer):
            # Create sizer item element
            sizerItemElem = MakeEmptyDOM('sizeritem')
            sizerItemElem.appendChild(elem)
            elem = sizerItemElem
        elif isinstance(parent, xxxNotebook) and not isChildContainer:
            pageElem = MakeEmptyDOM('notebookpage')
            pageElem.appendChild(elem)
            elem = pageElem
        xxx = MakeXXXFromDOM(parent, elem)
        # Figure out if we must append a new child or sibling
        if appendChild:
            parent.element.appendChild(elem)
            newItem = tree.AppendItem(selected, xxx.treeName(), image=xxx.treeImage(),
                                      data=wxTreeItemData(xxx))
        else:
            node = tree.GetPyData(nextItem).element
            parent.element.insertBefore(elem, node)
            # Inserting before is difficult, se we insert after or first child
            index = tree.ItemIndex(parentLeaf, nextItem)
            newItem = tree.InsertItemBefore(parentLeaf, index,
                        xxx.treeName(), image=xxx.treeImage())
            tree.SetPyData(newItem, xxx)
#            newItem = tree.InsertItem(parentLeaf, selected, 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):
                    tree.AddNode(newItem, treeObj, n)
        # Scroll to show new item
        tree.EnsureVisible(newItem)
        tree.SelectItem(newItem)
        if not tree.IsVisible(newItem):
            tree.ScrollTo(newItem)
            tree.Refresh()
        # Update view?
        if testWin and tree.IsHighlatable(newItem):
            if conf.autoRefresh:
                tree.needUpdate = true
                tree.pendingHighLight = newItem
            else:
                tree.pendingHighLight = None
        self.modified = true
        self.SetStatusText('Pasted')

    def OnDelete(self, evt):
        selected = tree.selection
        if not selected: return         # key pressed event
        # Undo info
        self.lastOp = 'DELETE'
        self.undo = [tree.GetItemParent(selected), tree.GetPrevSibling(selected)]
        # Delete testWin?
        global testWin
        if testWin:
            # If deleting top-level item, delete testWin
            if selected == testWin.item:
                testWin.Destroy()
                testWin = None
            else:
                # Remove highlight, update testWin
                if not tree.IsHighlatable(selected):
                    if testWin.highLight: testWin.highLight.Remove()
                    tree.needUpdate = true
        xnode = tree.RemoveLeaf(selected)
        # !!! cloneNode is broken, or something is wrong
#        self.undo.append(xnode.cloneNode(true))
        xnode.unlink()
        tree.pendingHighLight = None
        tree.Unselect()
        panel.Clear()
        self.modified = true
        self.SetStatusText('Deleted')

    def OnEmbedPanel(self, evt):
        conf.embedPanel = evt.IsChecked()
        if conf.embedPanel:
            # Remember last dimentions
            conf.panelX, conf.panelY = self.miniFrame.GetPosition()
            conf.panelWidth, conf.panelHeight = self.miniFrame.GetSize()
            size = self.GetSize()
            pos = self.GetPosition()
            sizePanel = panel.GetSize()
            panel.Reparent(self.splitter)
            self.miniFrame.GetSizer().RemoveWindow(panel)
            wxYield()
            # Widen
            self.SetDimensions(pos.x, pos.y, size.x + sizePanel.x, size.y)
            self.splitter.SplitVertically(tree, panel, conf.sashPos)
            self.miniFrame.Show(false)
        else:
            conf.sashPos = self.splitter.GetSashPosition()
            pos = self.GetPosition()
            size = self.GetSize()
            sizePanel = panel.GetSize()
            self.splitter.Unsplit(panel)
            sizer = self.miniFrame.GetSizer()
            panel.Reparent(self.miniFrame)
            panel.Show(true)
            sizer.Add(panel, 1, wxEXPAND)
            self.miniFrame.Show(true)
            self.miniFrame.SetDimensions(conf.panelX, conf.panelY,
                                         conf.panelWidth, conf.panelHeight)
            wxYield()
            # Reduce width
            self.SetDimensions(pos.x, pos.y,
                               max(size.x - sizePanel.x, self.minWidth), size.y)

    def OnTest(self, evt):
        if not tree.selection: return   # key pressed event
        tree.ShowTestWindow(tree.selection)

    def OnRefresh(self, evt):
        # If modified, apply first
        selection = tree.selection
        if selection:
            xxx = tree.GetPyData(selection)
            if xxx and panel.IsModified():
                tree.Apply(xxx, selection)
        if testWin:
            # (re)create
            tree.CreateTestWin(testWin.item)
        tree.needUpdate = false

    def OnAutoRefresh(self, evt):
        conf.autoRefresh = evt.IsChecked()
        self.menuBar.Check(self.ID_AUTO_REFRESH, conf.autoRefresh)
        self.tb.ToggleTool(self.ID_AUTO_REFRESH, conf.autoRefresh)

    def OnAbout(self, evt):
        str = '%s %s\n\nRoman Rolinsky <rolinsky@mema.ucl.ac.be>' % \
              (progname, version)
        dlg = wxMessageDialog(self, str, 'About ' + progname, wxOK | wxCENTRE)
        dlg.ShowModal()
        dlg.Destroy()

    def OnReadme(self, evt):
        text = open(os.path.join(sys.path[0], 'README'), 'r').read()
        dlg = ScrolledMessageDialog(self, text, "XRCed README")
        dlg.ShowModal()
        dlg.Destroy()


    # Simple emulation of python command line
    def OnDebugCMD(self, evt):
        import traceback
        while 1:
            try:
                exec raw_input('C:\> ')
            except EOFError:
                print '^D'
                break
            except:
                (etype, value, tb) =sys.exc_info()
                tblist =traceback.extract_tb(tb)[1:]
                msg =string.join(traceback.format_exception_only(etype, value)
                        +traceback.format_list(tblist))
                print msg

    def OnCreate(self, evt):
        selected = tree.selection
        if tree.ctrl: appendChild = false
        else: appendChild = not tree.NeedInsert(selected)
        xxx = tree.GetPyData(selected)
        if not appendChild:
            # If insert before
            if tree.shift:
                # If has previous item, insert after it, else append to parent
                nextItem = selected
                parentLeaf = tree.GetItemParent(selected)
            else:
                # If has next item, insert, else append to parent
                nextItem = tree.GetNextSibling(selected)
                if nextItem.IsOk():
                    # Insert before nextItem
                    parentLeaf = tree.GetItemParent(selected)
                else:                   # last child: change selected to parent
                    appendChild = true
                    selected = tree.GetItemParent(selected)
        # Expanded container (must have children)
        elif tree.shift and tree.IsExpanded(selected) \
           and tree.GetChildrenCount(selected, false):
            appendChild = false
            nextItem = tree.GetFirstChild(selected, 0)[0]
            parentLeaf = selected
        # Parent should be tree element or None
        if appendChild:
            parent = tree.GetPyData(selected)
        else:
            parent = tree.GetPyData(parentLeaf)
        if parent.hasChild: parent = parent.child

        # Create element
        className = self.createMap[evt.GetId()]
        xxx = MakeEmptyXXX(parent, className)

        # Set default name for top-level windows
        if parent.__class__ == xxxMainNode:
            cl = xxx.treeObject().__class__
            frame.maxIDs[cl] += 1
            xxx.treeObject().name = '%s%d' % (defaultIDs[cl], frame.maxIDs[cl])
            xxx.treeObject().element.setAttribute('name', xxx.treeObject().name)

        # Figure out if we must append a new child or sibling
        elem = xxx.element
        if appendChild:
            # Insert newline for debug purposes
            parent.element.appendChild(elem)
            newItem = tree.AppendItem(selected, xxx.treeName(), image=xxx.treeImage(),
                                      data=wxTreeItemData(xxx))
        else:
            node = tree.GetPyData(nextItem).element
            parent.element.insertBefore(elem, node)
            # !!! There is a different behavious on Win and GTK
            # !!! On Win InsertItem(parent, parent, ...) inserts at the end.
            index = tree.ItemIndex(parentLeaf, nextItem)
            newItem = tree.InsertItemBefore(parentLeaf, index,
                        xxx.treeName(), image=xxx.treeImage())
#                       data=wxTreeItemData(xxx)) # does not work
            tree.SetPyData(newItem, xxx)
#            newItem = tree.InsertItem(parentLeaf, selected,
#                                      xxx.treeName(), image=xxx.treeImage(),
#                                      data=wxTreeItemData(xxx))
        tree.EnsureVisible(newItem)
        tree.SelectItem(newItem)
        if not tree.IsVisible(newItem):
            tree.ScrollTo(newItem)
            tree.Refresh()
        # Update view?
        if testWin and tree.IsHighlatable(newItem):
            if conf.autoRefresh:
                tree.needUpdate = true
                tree.pendingHighLight = newItem
            else:
                tree.pendingHighLight = None

    # Expand/collapse subtree
    def OnExpand(self, evt):
        if tree.selection: tree.ExpandAll(tree.selection)
        else: tree.ExpandAll(tree.root)
    def OnCollapse(self, evt):
        if tree.selection: tree.CollapseAll(tree.selection)
        else: tree.CollapseAll(tree.root)

    def OnPullDownHighlight(self, evt):
        menuId = evt.GetMenuId()
        if menuId != -1:
            menu = evt.GetEventObject()
            help = menu.GetHelpString(menuId)
            self.SetStatusText(help)
        else:
            self.SetStatusText('')

    def OnUpdateUI(self, evt):
        if evt.GetId() in [wxID_CUT, wxID_COPY, self.ID_DELETE]:
            evt.Enable(tree.selection != tree.root)
        elif evt.GetId() == wxID_PASTE:
            evt.Enable((self.clipboard and tree.selection) != None)
        elif evt.GetId() == self.ID_TEST:
            evt.Enable(tree.selection != tree.root)

    def OnIdle(self, evt):
        if self.inIdle: return          # Recursive call protection
        self.inIdle = true
        if tree.needUpdate:
            if conf.autoRefresh:
                if testWin:
                    self.SetStatusText('Refreshing test window...')
                    # (re)create
                    tree.CreateTestWin(testWin.item)
                    wxYield()
                    self.SetStatusText('')
                tree.needUpdate = false
        elif tree.pendingHighLight:
            tree.HighLight(tree.pendingHighLight)
        else:
            evt.Skip()
        self.inIdle = false

    # We don't let close panel window
    def OnCloseMiniFrame(self, evt):
        return

    def OnCloseWindow(self, evt):
        if not self.AskSave(): return
        if testWin: testWin.Destroy()
        # Destroy cached windows
        panel.cacheParent.Destroy()
        if not panel.GetPageCount() == 2:
            panel.page2.Destroy()
        conf.x, conf.y = self.GetPosition()
        conf.width, conf.height = self.GetSize()
        if conf.embedPanel:
            conf.sashPos = self.splitter.GetSashPosition()
        else:
            conf.panelX, conf.panelY = self.miniFrame.GetPosition()
            conf.panelWidth, conf.panelHeight = self.miniFrame.GetSize()
        evt.Skip()

    def Clear(self):
        self.dataFile = ''
        self.clipboard = None
        self.modified = false
        panel.SetModified(false)
        tree.Clear()
        panel.Clear()
        global testWin
        if testWin:
            testWin.Destroy()
            testWin = None
        self.SetTitle(progname)
        # Numbers for new controls
        self.maxIDs = {}
        self.maxIDs[xxxPanel] = self.maxIDs[xxxDialog] = self.maxIDs[xxxFrame] = \
        self.maxIDs[xxxMenuBar] = self.maxIDs[xxxMenu] = self.maxIDs[xxxToolBar] = 0

    def Open(self, path):
        # Try to read the file
        try:
            open(path)
            self.Clear()
            # Build wx tree
            dom = minidom.parse(path)
            tree.SetData(dom)
            self.dataFile = path
            self.SetTitle(progname + ': ' + os.path.basename(path))
        except:
            wxLogError('Error reading file: %s' % path)
            raise

    def Indent(self, node, indent = 0):
        # Copy child list because it will change soon
        children = node.childNodes[:]
        # Main node doesn't need to be indented
        if indent:
            text = self.domCopy.createTextNode('\n' + ' ' * indent)
            node.parentNode.insertBefore(text, node)
        if children:
            # Append newline after last child, except for text nodes
            if children[-1].nodeType == minidom.Node.ELEMENT_NODE:
                text = self.domCopy.createTextNode('\n' + ' ' * indent)
                node.appendChild(text)
            # Indent children which are elements
            for n in children:
                if n.nodeType == minidom.Node.ELEMENT_NODE:
                    self.Indent(n, indent + 2)

    def Save(self, path):
        try:
            # Apply changes
            self.OnRefresh(wxCommandEvent())
            f = open(path, 'w')
            # Make temporary copy
            # !!! We can't clone dom node, it works only once
            #self.domCopy = tree.dom.cloneNode(true)
            self.domCopy = minidom.Document()
            mainNode = self.domCopy.appendChild(tree.mainNode.cloneNode(true))
            self.Indent(mainNode)
            self.domCopy.writexml(f)
            f.close()
            self.domCopy.unlink()
            self.domCopy = None
            self.modified = false
            panel.SetModified(false)
        except:
            wxLogError('Error writing file: %s' % path)
            raise

    def AskSave(self):
        if not (self.modified or panel.IsModified()): return true
        flags = wxICON_EXCLAMATION | wxYES_NO | wxCANCEL | wxCENTRE
        dlg = wxMessageDialog( self, 'File is modified. Save before exit?',
                               'Save before too late?', flags )
        say = dlg.ShowModal()
        dlg.Destroy()
        if say == wxID_YES:
            self.OnSaveOrSaveAs(wxCommandEvent(wxID_SAVE))
            # If save was successful, modified flag is unset
            if not self.modified: return true
        elif say == wxID_NO:
            self.modified = false
            panel.SetModified(false)
            return true
        return false

################################################################################

def usage():
    print >> sys.stderr, 'usage: xrced [-dvh] [file]'

class App(wxApp):
    def OnInit(self):
        global debug, verbose
        # Process comand-line
        try:
            opts, args = getopt.getopt(sys.argv[1:], 'dvh')
        except getopt.GetoptError:
            print >> sys.stderr, 'Unknown option'
            usage()
            sys.exit(1)
        for o,a in opts:
            if o == '-h':
                usage()
                sys.exit(0)
            elif o == '-d':
                debug = true
            elif o == '-v':
                print 'XRCed version', version
                sys.exit(0)

        self.SetAppName('xrced')
        # Settings
        global conf
        conf = wxConfig(style = wxCONFIG_USE_LOCAL_FILE)
        conf.autoRefresh = conf.ReadInt('autorefresh', true)
        pos = conf.ReadInt('x', -1), conf.ReadInt('y', -1)
        size = conf.ReadInt('width', 800), conf.ReadInt('height', 600)
        conf.embedPanel = conf.ReadInt('embedPanel', true)
        conf.sashPos = conf.ReadInt('sashPos', 200)
        if not conf.embedPanel:
            conf.panelX = conf.ReadInt('panelX', -1)
            conf.panelY = conf.ReadInt('panelY', -1)
        else:
            conf.panelX = conf.panelY = -1
        conf.panelWidth = conf.ReadInt('panelWidth', 200)
        conf.panelHeight = conf.ReadInt('panelHeight', 200)
        conf.panic = not conf.HasEntry('nopanic')
        # Add handlers
        wxFileSystem_AddHandler(wxMemoryFSHandler())
        wxInitAllImageHandlers()
        # Create main frame
        frame = Frame(pos, size)
        frame.Show(true)
        # Load resources from XRC file (!!! should be transformed to .py later?)
        sys.modules['params'].frame = frame
        frame.res = wxXmlResource('')
        frame.res.Load(os.path.join(sys.path[0], 'xrced.xrc'))

        # Load file after showing
        if args:
            conf.panic = false
            frame.open = frame.Open(args[0])

        return true

    def OnExit(self):
        # Write config
        wc = wxConfigBase_Get()
        wc.WriteInt('autorefresh', conf.autoRefresh)
        wc.WriteInt('x', conf.x)
        wc.WriteInt('y', conf.y)
        wc.WriteInt('width', conf.width)
        wc.WriteInt('height', conf.height)
        wc.WriteInt('embedPanel', conf.embedPanel)
        if not conf.embedPanel:
            wc.WriteInt('panelX', conf.panelX)
            wc.WriteInt('panelY', conf.panelY)
        wc.WriteInt('sashPos', conf.sashPos)
        wc.WriteInt('panelWidth', conf.panelWidth)
        wc.WriteInt('panelHeight', conf.panelHeight)
        wc.WriteInt('nopanic', 1)
        wc.Flush()

def main():
    app = App()
    app.MainLoop()
    app.OnExit()

if __name__ == '__main__':
    main()