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


from wxPython.wx import *
from wxPython.gizmos import *
from wxPython.stc import *

#----------------------------------------------------------------------
# This is an example of the complex view that manages its own scrollbars
# as described in the overview below.

class TestView(wxStyledTextCtrl):
    def __init__(self, parent, ID, log):
        wxStyledTextCtrl.__init__(self, parent, ID, style=wxNO_BORDER)
        self.dyn_sash = parent
        self.log = log
        self.SetupScrollBars()
        self.SetMarginWidth(1,0)
        self.StyleSetFont(wxSTC_STYLE_DEFAULT,
                          wxFont(10, wxMODERN, wxNORMAL, wxNORMAL))
        EVT_DYNAMIC_SASH_SPLIT(self, -1, self.OnSplit)
        EVT_DYNAMIC_SASH_UNIFY(self, -1, self.OnUnify)


    def SetupScrollBars(self):
        # hook the scrollbars provided by the wxDynamicSashWindow
        # to this view
        v_bar = self.dyn_sash.GetVScrollBar(self)
        h_bar = self.dyn_sash.GetHScrollBar(self)
        EVT_SCROLL(v_bar, self.OnSBScroll)
        EVT_SCROLL(h_bar, self.OnSBScroll)
        EVT_SET_FOCUS(v_bar, self.OnSBFocus)
        EVT_SET_FOCUS(h_bar, self.OnSBFocus)

        # And set the wxStyledText to use these scrollbars instead
        # of its built-in ones.
        self.SetVScrollBar(v_bar)
        self.SetHScrollBar(h_bar)


    def __del__(self):
        self.log.write("TestView.__del__\n")

    def OnSplit(self, evt):
        self.log.write("TestView.OnSplit\n");
        newview = TestView(self.dyn_sash, -1, self.log)
        newview.SetDocPointer(self.GetDocPointer())     # use the same document
        self.SetupScrollBars()


    def OnUnify(self, evt):
        self.log.write("TestView.OnUnify\n");
        self.SetupScrollBars()


    def OnSBScroll(self, evt):
        # redirect the scroll events from the dyn_sash's scrollbars to the STC
        self.GetEventHandler().ProcessEvent(evt)

    def OnSBFocus(self, evt):
        # when the scrollbar gets the focus move it back to the STC
        self.SetFocus()


sampleText="""\
You can drag the little tabs above the vertical scrollbar, or to the
left of the horizontal scrollbar to split this view, and you can
continue splitting the new views as much as you like.  Try it and see.

In this case the views also share the same document so changes in one
are instantly seen in the others.  This is a feature of the
wxStyledTextCtrl that is used for the view class in this sample.
"""

#----------------------------------------------------------------------
# This one is simpler, but doesn't do anything with the scrollbars
# except the default wxDynamicSashWindow behaviour

class SimpleView(wxPanel):
    def __init__(self, parent, ID, log):
        wxPanel.__init__(self, parent, ID)
        self.dyn_sash = parent
        self.log = log
        self.SetBackgroundColour("LIGHT BLUE")
        EVT_DYNAMIC_SASH_SPLIT(self, -1, self.OnSplit)

    def OnSplit(self, evt):
        v = SimpleView(self.dyn_sash, -1, self.log)


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

def runTest(frame, nb, log):
    if 1:
        win = wxDynamicSashWindow(nb, -1, style = 0
                                  | wxCLIP_CHILDREN
                                  #| wxDS_MANAGE_SCROLLBARS
                                  #| wxDS_DRAG_CORNER
                                  )
        win.SetFont(wxFont(10, wxMODERN, wxNORMAL, wxNORMAL))
        view = TestView(win, -1, log)
        view.SetText(sampleText)
    else:
        win = wxDynamicSashWindow(nb, -1)
        view = SimpleView(win, -1, log)
    return win

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

overview = """\
<html><body>
<h2>wxDynamicSashWindow</h2>
<p>
wxDynamicSashWindow widgets manages the way other widgets are viewed.
When a wxDynamicSashWindow is first shown, it will contain one child
view, a viewport for that child, and a pair of scrollbars to allow the
user to navigate the child view area.  Next to each scrollbar is a small
tab.  By clicking on either tab and dragging to the appropriate spot, a
user can split the view area into two smaller views separated by a
draggable sash.  Later, when the user wishes to reunify the two subviews,
the user simply drags the sash to the side of the window.
wxDynamicSashWindow will automatically reparent the appropriate child
view back up the window hierarchy, and the wxDynamicSashWindow will have
only one child view once again.
<p>
As an application developer, you will simply create a wxDynamicSashWindow
using either the Create() function or the more complex constructor
provided below, and then create a view window whose parent is the
wxDynamicSashWindow.  The child should respond to
wxDynamicSashSplitEvents -- perhaps with an OnSplit() event handler -- by
constructing a new view window whose parent is also the
wxDynamicSashWindow.  That's it!  Now your users can dynamically split
and reunify the view you provided.
<p>
If you wish to handle the scrollbar events for your view, rather than
allowing wxDynamicSashWindow to do it for you, things are a bit more
complex.  (You might want to handle scrollbar events yourself, if,
for instance, you wish to scroll a subwindow of the view you add to
your wxDynamicSashWindow object, rather than scrolling the whole view.)
In this case, you will need to construct your wxDynamicSashWindow without
the wxDS_MANAGE_SCROLLBARS style and  you will need to use the
GetHScrollBar() and GetVScrollBar() methods to retrieve the scrollbar
controls and call SetEventHanler() on them to redirect the scrolling
events whenever your window is reparented by wxDyanmicSashWindow.
You will need to set the scrollbars' event handler at three times:
<p>
<ul>
<li>  When your view is created
<li>  When your view receives a wxDynamicSashSplitEvent
<li>  When your view receives a wxDynamicSashUnifyEvent
</ul>
</body></html>
"""
Commit	Line	Data
ebf4302c RD	1
	2	from wxPython.wx import *
	3	from wxPython.gizmos import *
	4	from wxPython.stc import *
	5
	6	#----------------------------------------------------------------------
	7	# This is an example of the complex view that manages its own scrollbars
	8	# as described in the overview below.
	9
	10	class TestView(wxStyledTextCtrl):
	11	def __init__(self, parent, ID, log):
	12	wxStyledTextCtrl.__init__(self, parent, ID, style=wxNO_BORDER)
	13	self.dyn_sash = parent
	14	self.log = log
6e8a778a	15	self.SetupScrollBars()
ebf4302c RD	16	self.SetMarginWidth(1,0)
	17	self.StyleSetFont(wxSTC_STYLE_DEFAULT,
	18	wxFont(10, wxMODERN, wxNORMAL, wxNORMAL))
ebf4302c RD	19	EVT_DYNAMIC_SASH_SPLIT(self, -1, self.OnSplit)
	20	EVT_DYNAMIC_SASH_UNIFY(self, -1, self.OnUnify)
	21
	22
	23	def SetupScrollBars(self):
	24	# hook the scrollbars provided by the wxDynamicSashWindow
	25	# to this view
	26	v_bar = self.dyn_sash.GetVScrollBar(self)
	27	h_bar = self.dyn_sash.GetHScrollBar(self)
	28	EVT_SCROLL(v_bar, self.OnSBScroll)
	29	EVT_SCROLL(h_bar, self.OnSBScroll)
	30	EVT_SET_FOCUS(v_bar, self.OnSBFocus)
	31	EVT_SET_FOCUS(h_bar, self.OnSBFocus)
	32
	33	# And set the wxStyledText to use these scrollbars instead
	34	# of its built-in ones.
	35	self.SetVScrollBar(v_bar)
	36	self.SetHScrollBar(h_bar)
	37
	38
	39	def __del__(self):
	40	self.log.write("TestView.__del__\n")
	41
	42	def OnSplit(self, evt):
	43	self.log.write("TestView.OnSplit\n");
	44	newview = TestView(self.dyn_sash, -1, self.log)
	45	newview.SetDocPointer(self.GetDocPointer()) # use the same document
	46	self.SetupScrollBars()
	47
	48
	49	def OnUnify(self, evt):
	50	self.log.write("TestView.OnUnify\n");
	51	self.SetupScrollBars()
	52
	53
	54	def OnSBScroll(self, evt):
	55	# redirect the scroll events from the dyn_sash's scrollbars to the STC
	56	self.GetEventHandler().ProcessEvent(evt)
	57
	58	def OnSBFocus(self, evt):
	59	# when the scrollbar gets the focus move it back to the STC
	60	self.SetFocus()
	61
	62
	63	sampleText="""\
	64	You can drag the little tabs above the vertical scrollbar, or to the
	65	left of the horizontal scrollbar to split this view, and you can
	66	continue splitting the new views as much as you like. Try it and see.
	67
	68	In this case the views also share the same document so changes in one
	69	are instantly seen in the others. This is a feature of the
	70	wxStyledTextCtrl that is used for the view class in this sample.
	71	"""
	72
	73	#----------------------------------------------------------------------
	74	# This one is simpler, but doesn't do anything with the scrollbars
	75	# except the default wxDynamicSashWindow behaviour
	76
	77	class SimpleView(wxPanel):
	78	def __init__(self, parent, ID, log):
	79	wxPanel.__init__(self, parent, ID)
	80	self.dyn_sash = parent
	81	self.log = log
	82	self.SetBackgroundColour("LIGHT BLUE")
83	EVT_DYNAMIC_SASH_SPLIT(self, -1, self.OnSplit)
84
85	def OnSplit(self, evt):
86	v = SimpleView(self.dyn_sash, -1, self.log)
87
88
89	#----------------------------------------------------------------------
90
91	def runTest(frame, nb, log):
92	if 1:
93	win = wxDynamicSashWindow(nb, -1, style = 0
94	\| wxCLIP_CHILDREN
95	#\| wxDS_MANAGE_SCROLLBARS
96	#\| wxDS_DRAG_CORNER
97	)
98	win.SetFont(wxFont(10, wxMODERN, wxNORMAL, wxNORMAL))
99	view = TestView(win, -1, log)
100	view.SetText(sampleText)
101	else:
102	win = wxDynamicSashWindow(nb, -1)
103	view = SimpleView(win, -1, log)
104	return win
105
106	#----------------------------------------------------------------------
107
108	overview = """\
109	<html><body>
110	<h2>wxDynamicSashWindow</h2>
111	<p>
112	wxDynamicSashWindow widgets manages the way other widgets are viewed.
113	When a wxDynamicSashWindow is first shown, it will contain one child
114	view, a viewport for that child, and a pair of scrollbars to allow the
115	user to navigate the child view area. Next to each scrollbar is a small
116	tab. By clicking on either tab and dragging to the appropriate spot, a
117	user can split the view area into two smaller views separated by a
118	draggable sash. Later, when the user wishes to reunify the two subviews,
119	the user simply drags the sash to the side of the window.
120	wxDynamicSashWindow will automatically reparent the appropriate child
121	view back up the window hierarchy, and the wxDynamicSashWindow will have
122	only one child view once again.
123	<p>
124	As an application developer, you will simply create a wxDynamicSashWindow
125	using either the Create() function or the more complex constructor
126	provided below, and then create a view window whose parent is the
127	wxDynamicSashWindow. The child should respond to
128	wxDynamicSashSplitEvents -- perhaps with an OnSplit() event handler -- by
129	constructing a new view window whose parent is also the
130	wxDynamicSashWindow. That's it! Now your users can dynamically split
131	and reunify the view you provided.
132	<p>
133	If you wish to handle the scrollbar events for your view, rather than
134	allowing wxDynamicSashWindow to do it for you, things are a bit more
135	complex. (You might want to handle scrollbar events yourself, if,
136	for instance, you wish to scroll a subwindow of the view you add to
137	your wxDynamicSashWindow object, rather than scrolling the whole view.)
138	In this case, you will need to construct your wxDynamicSashWindow without
139	the wxDS_MANAGE_SCROLLBARS style and you will need to use the
140	GetHScrollBar() and GetVScrollBar() methods to retrieve the scrollbar
141	controls and call SetEventHanler() on them to redirect the scrolling
142	events whenever your window is reparented by wxDyanmicSashWindow.
143	You will need to set the scrollbars' event handler at three times:
144	<p>
145	<ul>
146	<li> When your view is created
147	<li> When your view receives a wxDynamicSashSplitEvent
148	<li> When your view receives a wxDynamicSashUnifyEvent
149	</ul>
150	</body></html>
151	"""