[wxWidgets.git] / wxPython / demo / wxXmlResourceHandler.py


from wxPython.wx import *
from wxPython.xrc import *

#----------------------------------------------------------------------

resourceText = r'''<?xml version="1.0"?>
<resource>

<!-- Notice that the class is NOT a standard wx class -->

<object class="MyBluePanel" name="MyPanel">
    <size>200,100</size>
    <object class="wxStaticText" name="label1" subclass="wxPython.wx.wxPreStaticText">
        <label>This blue panel is a class derived from wxPanel,\nand is loaded by a custom wxXmlResourceHandler.</label>
        <pos>10,10</pos>
    </object>
</object>
</resource>
'''

#----------------------------------------------------------------------

class MyBluePanel(wxPanel):
    def __init__(self, parent, id, pos, size, style, name):
        wxPanel.__init__(self, parent, id, pos, size, style, name)

        # This is the little bit of customization that we do for this
        # silly example.  It could just as easily have been done in
        # the resource.
        self.SetBackgroundColour("BLUE")
        self.SetForegroundColour("WHITE")


# To do it the more complex way, (see below) we need to write the
# class a little differently...  This could obviously be done with a
# single class, but I wanted to make separate ones to make clear what
# the different requirements are.
class PreMyBluePanel(wxPanel):
    def __init__(self):
        p = wxPrePanel()
        self.this = p.this

    def Create(self, parent, id, pos, size, style, name):
        wxPanel.Create(self, parent, id, pos, size, style, name)
        self.SetBackgroundColour("BLUE")
        self.SetForegroundColour("WHITE")


#----------------------------------------------------------------------

class MyBluePanelXmlHandler(wxXmlResourceHandler):
    def __init__(self):
        wxXmlResourceHandler.__init__(self)
        # Specify the styles recognized by objects of this type
        self.AddStyle("wxNO_3D", wxNO_3D);
        self.AddStyle("wxTAB_TRAVERSAL", wxTAB_TRAVERSAL);
        self.AddStyle("wxWS_EX_VALIDATE_RECURSIVELY", wxWS_EX_VALIDATE_RECURSIVELY);
        self.AddStyle("wxCLIP_CHILDREN", wxCLIP_CHILDREN);
        self.AddWindowStyles();

    # This method and the next one are required for XmlResourceHandlers
    def CanHandle(self, node):
        return self.IsOfClass(node, "MyBluePanel")

    def DoCreateResource(self):
        # NOTE: wxWindows can be created in either a single-phase or
        # in a two-phase way.  Single phase is what you normally do,
        # and two-phase creates the instnace first, and then later
        # creates the actual window when the Create method is called.
        # (In wxPython the first phase is done using the wxPre*
        # function, for example, wxPreFrame, wxPrePanel, etc.)
        #
        # wxXmlResource supports either method, a premade instance can
        # be created and populated by xrc using the appropriate
        # LoadOn* method (such as LoadOnPanel) or xrc can create the
        # instance too, using the Load* method.  However this makes
        # the handlers a bit more complex.  If you can be sure that a
        # particular class will never be loaded using a pre-existing
        # instance, then you can make the handle much simpler.  I'll
        # show both methods below.

        if 1:
            # The simple method assumes that there is no existing
            # instance.  Be sure of that with an assert.
            assert self.GetInstance() is None

            # Now create the object
            panel = MyBluePanel(self.GetParentAsWindow(),
                                self.GetID(),
                                self.GetPosition(),
                                self.GetSize(),
                                self.GetStyle("style", wxTAB_TRAVERSAL),
                                self.GetName()
                                )
        else:
            # When using the more complex (but more flexible) method
            # the instance may already have been created, check for it
            panel = self.GetInstance()
            if panel is None:
                # if not, then create the instance (but not the window)
                panel = PreMyBluePanel()

            # Now call the panel's Create method to actually create the window
            panel.Create(self.GetParentAsWindow(),
                         self.GetID(),
                         self.GetPosition(),
                         self.GetSize(),
                         self.GetStyle("style", wxTAB_TRAVERSAL),
                         self.GetName()
                         )

        # These two things should be done in either case:
        # Set standard window attributes
        self.SetupWindow(panel)
        # Create any child windows of this node
        self.CreateChildren(panel)

        return panel


#----------------------------------------------------------------------


class TestPanel(wxPanel):
    def __init__(self, parent, log):
        self.log = log
        wxPanel.__init__(self, parent, -1)

        # make the components
        label = wxStaticText(self, -1, "The lower panel was built from this XML:")
        label.SetFont(wxFont(12, wxSWISS, wxNORMAL, wxBOLD))

        text = wxTextCtrl(self, -1, resourceText,
                          style=wxTE_READONLY|wxTE_MULTILINE)
        text.SetInsertionPoint(0)

        line = wxStaticLine(self, -1)

        # Load the resource
        res = wxEmptyXmlResource()
        res.InsertHandler(MyBluePanelXmlHandler())
        res.LoadFromString(resourceText)

        # Now create a panel from the resource data
        panel = res.LoadObject(self, "MyPanel", "MyBluePanel")

        # and do the layout
        sizer = wxBoxSizer(wxVERTICAL)
        sizer.Add(label, 0, wxEXPAND|wxTOP|wxLEFT, 5)
        sizer.Add(text, 1, wxEXPAND|wxALL, 5)
        sizer.Add(line, 0, wxEXPAND)
        sizer.Add(panel, 1, wxEXPAND|wxALL, 5)

        self.SetSizer(sizer)
        self.SetAutoLayout(True)


#----------------------------------------------------------------------

def runTest(frame, nb, log):
    win = TestPanel(nb, log)
    return win

#----------------------------------------------------------------------


overview = """<html><body>
<h2><center>wxXmlResourceHandler</center></h2>

Deriving a class from wxXmlResourceHandler allows you to specify your
own classes in XRC resources, and your handler class will then be used
to create instances of that class when the resource is loaded.

</body></html>
"""


if __name__ == '__main__':
    import sys,os
    import run
    run.main(['', os.path.basename(sys.argv[0])])
Commit	Line	Data
628c7f79 RD	1
	2	from wxPython.wx import *
	3	from wxPython.xrc import *
	4
	5	#----------------------------------------------------------------------
	6
	7	resourceText = r'''<?xml version="1.0"?>
	8	<resource>
	9
	10	<!-- Notice that the class is NOT a standard wx class -->
	11
	12	<object class="MyBluePanel" name="MyPanel">
	13	<size>200,100</size>
1fded56b	14	<object class="wxStaticText" name="label1" subclass="wxPython.wx.wxPreStaticText">
628c7f79 RD	15	<label>This blue panel is a class derived from wxPanel,\nand is loaded by a custom wxXmlResourceHandler.</label>
	16	<pos>10,10</pos>
	17	</object>
	18	</object>
	19	</resource>
	20	'''
	21
	22	#----------------------------------------------------------------------
	23
	24	class MyBluePanel(wxPanel):
	25	def __init__(self, parent, id, pos, size, style, name):
	26	wxPanel.__init__(self, parent, id, pos, size, style, name)
	27
	28	# This is the little bit of customization that we do for this
	29	# silly example. It could just as easily have been done in
	30	# the resource.
	31	self.SetBackgroundColour("BLUE")
4d5a7477	32	self.SetForegroundColour("WHITE")
628c7f79 RD	33
	34
	35	# To do it the more complex way, (see below) we need to write the
	36	# class a little differently... This could obviously be done with a
	37	# single class, but I wanted to make separate ones to make clear what
	38	# the different requirements are.
	39	class PreMyBluePanel(wxPanel):
	40	def __init__(self):
	41	p = wxPrePanel()
	42	self.this = p.this
	43
	44	def Create(self, parent, id, pos, size, style, name):
	45	wxPanel.Create(self, parent, id, pos, size, style, name)
	46	self.SetBackgroundColour("BLUE")
4d5a7477 RD	47	self.SetForegroundColour("WHITE")
4d5a7477 RD	48
628c7f79 RD	49
	50	#----------------------------------------------------------------------
	51
	52	class MyBluePanelXmlHandler(wxXmlResourceHandler):
	53	def __init__(self):
	54	wxXmlResourceHandler.__init__(self)
	55	# Specify the styles recognized by objects of this type
	56	self.AddStyle("wxNO_3D", wxNO_3D);
	57	self.AddStyle("wxTAB_TRAVERSAL", wxTAB_TRAVERSAL);
	58	self.AddStyle("wxWS_EX_VALIDATE_RECURSIVELY", wxWS_EX_VALIDATE_RECURSIVELY);
	59	self.AddStyle("wxCLIP_CHILDREN", wxCLIP_CHILDREN);
	60	self.AddWindowStyles();
	61
	62	# This method and the next one are required for XmlResourceHandlers
	63	def CanHandle(self, node):
	64	return self.IsOfClass(node, "MyBluePanel")
	65
	66	def DoCreateResource(self):
	67	# NOTE: wxWindows can be created in either a single-phase or
	68	# in a two-phase way. Single phase is what you normally do,
	69	# and two-phase creates the instnace first, and then later
	70	# creates the actual window when the Create method is called.
	71	# (In wxPython the first phase is done using the wxPre*
	72	# function, for example, wxPreFrame, wxPrePanel, etc.)
	73	#
	74	# wxXmlResource supports either method, a premade instance can
	75	# be created and populated by xrc using the appropriate
	76	# LoadOn* method (such as LoadOnPanel) or xrc can create the
	77	# instance too, using the Load* method. However this makes
	78	# the handlers a bit more complex. If you can be sure that a
	79	# particular class will never be loaded using a pre-existing
	80	# instance, then you can make the handle much simpler. I'll
	81	# show both methods below.
	82
361cef5f	83	if 1:
628c7f79 RD	84	# The simple method assumes that there is no existing
	85	# instance. Be sure of that with an assert.
	86	assert self.GetInstance() is None
	87
	88	# Now create the object
	89	panel = MyBluePanel(self.GetParentAsWindow(),
	90	self.GetID(),
	91	self.GetPosition(),
	92	self.GetSize(),
	93	self.GetStyle("style", wxTAB_TRAVERSAL),
	94	self.GetName()
	95	)
	96	else:
	97	# When using the more complex (but more flexible) method
	98	# the instance may already have been created, check for it
	99	panel = self.GetInstance()
	100	if panel is None:
	101	# if not, then create the instance (but not the window)
	102	panel = PreMyBluePanel()
	103
	104	# Now call the panel's Create method to actually create the window
	105	panel.Create(self.GetParentAsWindow(),
	106	self.GetID(),
	107	self.GetPosition(),
	108	self.GetSize(),
	109	self.GetStyle("style", wxTAB_TRAVERSAL),
	110	self.GetName()
	111	)
	112
	113	# These two things should be done in either case:
	114	# Set standard window attributes
	115	self.SetupWindow(panel)
	116	# Create any child windows of this node
	117	self.CreateChildren(panel)
	118
	119	return panel
	120
	121
	122	#----------------------------------------------------------------------
	123
	124
	125	class TestPanel(wxPanel):
	126	def __init__(self, parent, log):
	127	self.log = log
	128	wxPanel.__init__(self, parent, -1)
	129
	130	# make the components
	131	label = wxStaticText(self, -1, "The lower panel was built from this XML:")
	132	label.SetFont(wxFont(12, wxSWISS, wxNORMAL, wxBOLD))
	133
	134	text = wxTextCtrl(self, -1, resourceText,
	135	style=wxTE_READONLY\|wxTE_MULTILINE)
	136	text.SetInsertionPoint(0)
	137
	138	line = wxStaticLine(self, -1)
	139
	140	# Load the resource
	141	res = wxEmptyXmlResource()
	142	res.InsertHandler(MyBluePanelXmlHandler())
	143	res.LoadFromString(resourceText)
	144
	145	# Now create a panel from the resource data
	146	panel = res.LoadObject(self, "MyPanel", "MyBluePanel")
	147
148	# and do the layout
149	sizer = wxBoxSizer(wxVERTICAL)
150	sizer.Add(label, 0, wxEXPAND\|wxTOP\|wxLEFT, 5)
151	sizer.Add(text, 1, wxEXPAND\|wxALL, 5)
152	sizer.Add(line, 0, wxEXPAND)
153	sizer.Add(panel, 1, wxEXPAND\|wxALL, 5)
154
155	self.SetSizer(sizer)
1e4a197e	156	self.SetAutoLayout(True)
628c7f79 RD	157
	158
	159	#----------------------------------------------------------------------
	160
	161	def runTest(frame, nb, log):
	162	win = TestPanel(nb, log)
	163	return win
	164
	165	#----------------------------------------------------------------------
	166
	167
	168
	169	overview = """<html><body>
	170	<h2><center>wxXmlResourceHandler</center></h2>
	171
	172	Deriving a class from wxXmlResourceHandler allows you to specify your
	173	own classes in XRC resources, and your handler class will then be used
	174	to create instances of that class when the resource is loaded.
	175
	176	</body></html>
	177	"""
	178
	179
	180
	181	if __name__ == '__main__':
	182	import sys,os
	183	import run
	184	run.main(['', os.path.basename(sys.argv[0])])
	185