Thuban/UI/dock.py

# Copyright (c) 2003 by Intevation GmbH
# Authors:
# Jonathan Coles <[email protected]>
#
# This program is free software under the GPL (>=v2)
# Read the file COPYING coming with Thuban for details.

"""Classes for creating dockable windows"""

__version__ = "$Revision$"

import resource

from Thuban import _

from wxPython.wx import *

from Thuban.Lib.connector import Publisher

from dialogs import NonModalDialog

from messages import DOCKABLE_DOCKED, DOCKABLE_UNDOCKED, DOCKABLE_CLOSED

ID_BUTTON_DOCK = 4001
ID_BUTTON_CLOSE = 4002

PANEL_ID = 3141

DOCK_BMP   = "dock_12"
UNDOCK_BMP = "undock_12"
CLOSE_BMP  = "close_12"

class DockPanel(wxPanel):

    def __init__(self, parent, id):

        if not isinstance(parent, DockableWindow):
            raise TypeError("")

        wxPanel.__init__(self, parent.GetCurrentParent(), id)

        self.parent = parent

        #self.SetDockParent(None)
        #parent.SetPanel(self)

    def Create(self):
        self.parent.SetPanel(self)
        
    def SetDockParent(self, parent):
        self.__dockParent = parent

    def GetDockParent(self):
        return self.__dockParent

    def SetDock(self, dock):
        #if dock == self.IsDocked(): return

        if dock:
            self.Dock()
        else:
            self.UnDock()

    def Dock(self):
        self.GetDockParent().Dock()

    def UnDock(self):
        self.GetDockParent().UnDock()

    def IsDocked(self):
        return self.GetDockParent().IsDocked()

class DockableWindow(Publisher):

    def __getattr__(self, attr):
        return getattr(self.__topWindow, attr)

    def __init__(self, parent, id, name, title, dockWindow, orient): 
        """Create the dockable window.

        Initially, the window is hidden, but in an undocked state.
        """

        if not isinstance(parent, DockFrame): raise TypeError("")

        self.__parent = parent
        self.__id     = id
        self.__name   = name

        self.__orientation = orient

        self.__dockWindow  = dockWindow
        self.__floatWindow = wxFrame(parent, id, title)

        self.__docked      = False
        if self.__docked:
            self.__topWindow = self.__dockWindow
        else:
            self.__topWindow = self.__floatWindow

        self.__floatSize     = None
        self.__floatPosition = None

        self.__dockPanel  = None
        self.__panel = None

        self.__dockWindow.Hide()
        self.__floatWindow.Hide()

        EVT_CLOSE(self, self._OnClose)

    ##
    # Public methods
    #

    def GetName(self):
        return self.__name

    def SetPanel(self, panel):

        if not isinstance(panel, DockPanel):
            raise TypeError("")

        self.__panel = panel
        self.__panel.SetDockParent(self)
        self.__CreateBorder()

        self.SetDock(self.__docked)

    def GetPanel(self):
        return self.__panel
        
    def GetCurrentParent(self):
        return self.__topWindow

    def SetDock(self, dock):

        self.__CheckAllGood()
 
        if dock:
            self.Dock()
        else:
            self.UnDock()

    def Dock(self):
        self.__CheckAllGood()

        wasVisible = self.IsShown()

        if wasVisible: self.Show(False)

        self.__docked = True

        #
        # save window information
        #
        self.__floatSize = self.GetSize()
        self.__floatPosition = self.GetPosition()

        #
        # reparent
        #
        self.__topWindow = self.__dockWindow
        self.__dockPanel.Reparent(self.__topWindow)

        self.__dockButton.SetBitmapLabel(self.__bmpUnDock)
        self.__dockButton.SetBitmapFocus(self.__bmpUnDock)
        self.__dockButton.SetBitmapSelected(self.__bmpUnDock)
        self.__dockButton.SetBitmapDisabled(self.__bmpUnDock)
        self.__dockButton.SetToolTip(wxToolTip(_("Undock")))

        self.SetDockSize(self.__dockWindow.GetSize())

        if wasVisible: self.Show(True)

        self.issue(DOCKABLE_DOCKED, self.__id, self)

    def UnDock(self):
        self.__CheckAllGood()

        wasVisible = self.IsShown()

        if wasVisible: self.Show(False)

        self.__docked = False
 
        #
        # reparent
        #
        self.__topWindow = self.__floatWindow
        self.__dockPanel.Reparent(self.__topWindow)

        self.__dockButton.SetBitmapLabel(self.__bmpDock)
        self.__dockButton.SetBitmapFocus(self.__bmpDock)
        self.__dockButton.SetBitmapSelected(self.__bmpDock)
        self.__dockButton.SetBitmapDisabled(self.__bmpDock)
        self.__dockButton.SetToolTip(wxToolTip(_("Dock")))

        if wasVisible: self.Show()

        #
        # restore window information
        #
        if self.__floatPosition is not None: 
            self.SetPosition(self.__floatPosition)
        if self.__floatSize is not None: 
            self.SetSize(self.__floatSize)

        self.__dockPanel.SetSize(self.__topWindow.GetClientSize())

        self.issue(DOCKABLE_UNDOCKED, self.__id, self)

    def IsDocked(self):
        self.__CheckAllGood()
        return self.__docked

    def Show(self, show = True):
        if show:
            self.__DoShow()
        else:
            self.__DoHide()

    def SetDockSize(self, rect = None):

        w0, h0 = self.__dockPanel.GetBestSize()
        w, h = self.__panel.GetBestSize()

        if (w, h) < (w0, h0):
            w = w0
            h = h0

        if rect is not None:
            rw = rect.width
            rh = rect.height
            if rw < w: rw = w
            if rh < h: rh = h
        else:
            rw = w
            rh = h
                                                                                       
        # these are to account for the border?!!?
        rw += 8 # XXX: without this the sash isn't visible!?!?!?!
        rh += 8 # XXX: without this the sash isn't visible!?!?!?!
                                                                                       
        self.__dockWindow.SetDefaultSize(wxSize(rw, rh))


    def Destroy(self):
        self.__panel.Destroy()
        self.__floatWindow.Destroy()
        self.__dockWindow.Destroy()
        self.__parent.OnDockDestroy(self)
        
    ##
    # Event handlers
    #

    def _OnButtonClose(self, event):
        #self.Close()
        self.Show(False)

    def _OnClose(self, force = False):
        self.Show(False)

    def _OnToggleDock(self, event):
        self.__CheckAllGood()

        self.SetDock(not self.IsDocked())

    ##
    # Private methods
    #

    def __CheckAllGood(self):
        if self.__panel is None:
            raise TypeError("")

    def __DoShow(self):
        if self.IsShown(): return

        self.__topWindow.Show()

        if self.__topWindow is self.__dockWindow:
            self.__parent._UpdateDocks()
            
    def __DoHide(self):
        if not self.IsShown(): return

        self.__topWindow.Show(False)

        if self.__topWindow is self.__dockWindow:
            self.__parent._UpdateDocks()

    def __CreateBorder(self):

        self.__dockPanel = wxPanel(self.__topWindow, -1, style=wxSUNKEN_BORDER)

        self.__panel.Reparent(self.__dockPanel)
        self.__panel.SetId(PANEL_ID)

        if self.__orientation == wxLAYOUT_VERTICAL:
            sizer = wxBoxSizer(wxVERTICAL)
            headerBoxOrient = wxHORIZONTAL
        else:
            sizer = wxBoxSizer(wxHORIZONTAL)
            headerBoxOrient = wxVERTICAL
        

        headerBox = wxStaticBoxSizer(
                        wxStaticBox(self.__dockPanel, -1, ""), headerBoxOrient)

        #
        # ideally, we should be able to rotate this text depending on
        # our orientation
        #
        text = wxStaticText(self.__dockPanel, -1, self.GetTitle(),
                             style = wxALIGN_CENTRE)
        font = text.GetFont()
        font.SetPointSize(10)
        text.SetFont(font)

        #
        # load the dock/undock/close bitmaps
        # and create the buttons
        #
        self.__bmpDock   = \
            resource.GetBitmapResource(DOCK_BMP, wxBITMAP_TYPE_XPM)
        self.__bmpUnDock = \
            resource.GetBitmapResource(UNDOCK_BMP, wxBITMAP_TYPE_XPM)

        if self.__docked:
            bmp = self.__bmpDock
        else:
            bmp = self.__bmpUnDock

        self.__dockButton = wxBitmapButton(
            self.__dockPanel, ID_BUTTON_DOCK, 
            bmp, 
            size = wxSize(bmp.GetWidth() + 4, bmp.GetHeight() + 4),
            style = wxBU_EXACTFIT | wxADJUST_MINSIZE)

        bmp = resource.GetBitmapResource(CLOSE_BMP, wxBITMAP_TYPE_XPM)

        closeX = wxBitmapButton(self.__dockPanel, ID_BUTTON_CLOSE, bmp, 
                          size = wxSize(bmp.GetWidth() + 4,
                                        bmp.GetHeight() + 4),
                          style = wxBU_EXACTFIT | wxADJUST_MINSIZE)
        closeX.SetToolTip(wxToolTip(_("Close")))

        #
        # fill in the sizer in an order appropriate to the orientation
        #
        if self.__orientation == wxLAYOUT_VERTICAL:
            headerBox.Add(text, 0, wxALIGN_LEFT | wxALIGN_CENTRE_VERTICAL, 0)
            headerBox.Add(1, 5, 1, wxGROW)
            headerBox.Add(self.__dockButton, 0, wxALIGN_RIGHT, 0)
            headerBox.Add(closeX, 0, wxALIGN_RIGHT | wxLEFT, 4)
        else:
            headerBox.Add(closeX, 0, wxALIGN_RIGHT | wxBOTTOM, 4)
            headerBox.Add(self.__dockButton, 0, wxALIGN_RIGHT, 0)
            headerBox.Add(text, 0, wxALIGN_LEFT | wxALIGN_CENTRE_VERTICAL, 0)

        sizer.Add(headerBox, 0, wxGROW, 0)
        sizer.Add(self.__panel, 1, wxGROW, 0)


        self.__dockPanel.SetAutoLayout(True)
        self.__dockPanel.SetSizer(sizer)
        sizer.SetSizeHints(self.__dockPanel)
        sizer.SetSizeHints(self.__floatWindow)

        EVT_BUTTON(self.__dockPanel, ID_BUTTON_DOCK, self._OnToggleDock)
        EVT_BUTTON(self.__dockPanel, ID_BUTTON_CLOSE, self._OnButtonClose)


class DockFrame(wxFrame):

    def __init__(self, parent, id, title, position, size):
        wxFrame.__init__(self, parent, id, title, position, size)

        self.openWindows = {}

        self.__update_lock = 0

        self.SetMainWindow(None)


        EVT_SIZE(self, self._OnSashSize)
        EVT_CLOSE(self, self.OnClose)

    layout2oppSash = { 
            wxLAYOUT_NONE   : wxSASH_NONE,
            wxLAYOUT_TOP    : wxSASH_BOTTOM,
            wxLAYOUT_LEFT   : wxSASH_RIGHT,
            wxLAYOUT_RIGHT  : wxSASH_LEFT,
            wxLAYOUT_BOTTOM : wxSASH_TOP }


    def OnClose(self, event):

        self.__update_lock += 1

        #
        # child windows are not notified when the parent is destroyed
        # as of v2.4.0.3 so we need to interate over our children
        # and tell them to go away.
        #
        for key in self.openWindows.keys():
            win = self.openWindows[key]
            win.Destroy()

        self.__update_lock -= 1

        # should really call _UpdateDocks() here but we don't need to
        # since we're going away

    def CreateDock(self, name, id, title, align):

        if align in (wxLAYOUT_NONE, wxLAYOUT_LEFT, wxLAYOUT_RIGHT):
            orient = wxLAYOUT_VERTICAL
        else:
            orient = wxLAYOUT_HORIZONTAL

        sash = wxSashLayoutWindow(self, id, style=wxNO_BORDER|wxSW_3D)
        sash.SetOrientation(orient)
        sash.SetAlignment(align)
        sash.SetSashVisible(DockFrame.layout2oppSash[align], True)
        sash.SetSashBorder(DockFrame.layout2oppSash[align], True)

        win = DockableWindow(self, id, name, title, sash, orient)

        self.__RegisterDock(name, win)
        EVT_SASH_DRAGGED(self, id, self._OnSashDragged)

        return win

    def FindRegisteredDock(self, name):
        return self.openWindows.get(name)

    def OnDockDestroy(self, win):
        del self.openWindows[win.GetName()]
        self._UpdateDocks()

    def SetMainWindow(self, main):
        self.__mainWindow = main
        self._UpdateDocks()
        
    def _UpdateDocks(self):
        if self.__update_lock == 0:
            wxLayoutAlgorithm().LayoutWindow(self, self.__mainWindow)

    def _OnSashDragged(self, event):
        if event.GetDragStatus() == wxSASH_STATUS_OUT_OF_RANGE:
            return

        id = event.GetId()
        sash = self.FindWindowById(id)
        #assert(isinstance(win, wxPanel))
        dockPanel = sash.GetChildren()[0]
        panel = dockPanel.FindWindowById(PANEL_ID)
        assert isinstance(panel, DockPanel)
        win = panel.GetDockParent()
        assert isinstance(win, DockableWindow)

        assert win.IsDocked()

        rect = event.GetDragRect()

        win.SetDockSize(rect)

        self._UpdateDocks()

    def _OnSashSize(self, event):
        self._UpdateDocks()

    def __RegisterDock(self, name, win):
        if self.FindRegisteredDock(name) is not None:
            raise ValueError(
                "A dockable window is already registered under the name '%s'" % name)

        self.openWindows[name] = win

1	jonathan	561	# Copyright (c) 2003 by Intevation GmbH
2			# Authors:
3			# Jonathan Coles <[email protected]>
4			#
5			# This program is free software under the GPL (>=v2)
6			# Read the file COPYING coming with Thuban for details.
7
8			"""Classes for creating dockable windows"""
9
10			__version__ = "$Revision$"
11
12	jonathan	651	import resource
13
14	jonathan	561	from Thuban import _
15
16			from wxPython.wx import *
17
18			from Thuban.Lib.connector import Publisher
19
20	jonathan	566	from dialogs import NonModalDialog
21
22	jonathan	561	from messages import DOCKABLE_DOCKED, DOCKABLE_UNDOCKED, DOCKABLE_CLOSED
23
24			ID_BUTTON_DOCK = 4001
25	jonathan	571	ID_BUTTON_CLOSE = 4002
26	jonathan	561
27	jonathan	571	PANEL_ID = 3141
28
29	jonathan	651	DOCK_BMP = "dock_12"
30			UNDOCK_BMP = "undock_12"
31			CLOSE_BMP = "close_12"
32
33	jonathan	561	class DockPanel(wxPanel):
34
35			def __init__(self, parent, id):
36
37	jonathan	571	if not isinstance(parent, DockableWindow):
38			raise TypeError("")
39	jonathan	561
40	jonathan	571	wxPanel.__init__(self, parent.GetCurrentParent(), id)
41	jonathan	561
42	jonathan	659	self.parent = parent
43
44	jonathan	571	#self.SetDockParent(None)
45	jonathan	659	#parent.SetPanel(self)
46	jonathan	571
47	jonathan	659	def Create(self):
48			self.parent.SetPanel(self)
49
50	jonathan	561	def SetDockParent(self, parent):
51	jonathan	571	self.__dockParent = parent
52	jonathan	561
53			def GetDockParent(self):
54	jonathan	571	return self.__dockParent
55	jonathan	561
56	jonathan	571	def SetDock(self, dock):
57			#if dock == self.IsDocked(): return
58
59			if dock:
60			self.Dock()
61			else:
62			self.UnDock()
63
64	jonathan	561	def Dock(self):
65			self.GetDockParent().Dock()
66
67			def UnDock(self):
68			self.GetDockParent().UnDock()
69
70			def IsDocked(self):
71			return self.GetDockParent().IsDocked()
72
73	jonathan	571	class DockableWindow(Publisher):
74	jonathan	561
75	jonathan	571	def __getattr__(self, attr):
76			return getattr(self.__topWindow, attr)
77
78	jonathan	659	def __init__(self, parent, id, name, title, dockWindow, orient):
79			"""Create the dockable window.
80	jonathan	561
81	jonathan	659	Initially, the window is hidden, but in an undocked state.
82			"""
83
84	jonathan	571	if not isinstance(parent, DockFrame): raise TypeError("")
85	jonathan	561
86	jonathan	571	self.__parent = parent
87			self.__id = id
88			self.__name = name
89	jonathan	561
90	jonathan	571	self.__orientation = orient
91	jonathan	561
92	jonathan	571	self.__dockWindow = dockWindow
93			self.__floatWindow = wxFrame(parent, id, title)
94	jonathan	561
95	jonathan	571	self.__docked = False
96			if self.__docked:
97			self.__topWindow = self.__dockWindow
98			else:
99			self.__topWindow = self.__floatWindow
100	jonathan	561
101	jonathan	571	self.__floatSize = None
102			self.__floatPosition = None
103
104	jonathan	659	self.__dockPanel = None
105	jonathan	571	self.__panel = None
106
107			self.__dockWindow.Hide()
108			self.__floatWindow.Hide()
109
110			EVT_CLOSE(self, self._OnClose)
111
112			##
113			# Public methods
114			#
115
116			def GetName(self):
117			return self.__name
118
119			def SetPanel(self, panel):
120
121	jonathan	561	if not isinstance(panel, DockPanel):
122			raise TypeError("")
123
124	jonathan	571	self.__panel = panel
125			self.__panel.SetDockParent(self)
126	jonathan	561	self.__CreateBorder()
127	jonathan	571
128			self.SetDock(self.__docked)
129
130			def GetPanel(self):
131			return self.__panel
132	jonathan	561
133	jonathan	571	def GetCurrentParent(self):
134			return self.__topWindow
135
136	jonathan	561	def SetDock(self, dock):
137	jonathan	571
138			self.__CheckAllGood()
139
140	jonathan	561	if dock:
141			self.Dock()
142			else:
143			self.UnDock()
144
145			def Dock(self):
146	jonathan	571	self.__CheckAllGood()
147	jonathan	561
148	jonathan	571	wasVisible = self.IsShown()
149	jonathan	561
150	jonathan	571	if wasVisible: self.Show(False)
151	jonathan	561
152	jonathan	571	self.__docked = True
153	jonathan	561
154	jonathan	571	#
155			# save window information
156			#
157			self.__floatSize = self.GetSize()
158			self.__floatPosition = self.GetPosition()
159	jonathan	561
160	jonathan	571	#
161			# reparent
162			#
163			self.__topWindow = self.__dockWindow
164			self.__dockPanel.Reparent(self.__topWindow)
165	jonathan	561
166	jonathan	667	self.__dockButton.SetBitmapLabel(self.__bmpUnDock)
167			self.__dockButton.SetBitmapFocus(self.__bmpUnDock)
168			self.__dockButton.SetBitmapSelected(self.__bmpUnDock)
169			self.__dockButton.SetBitmapDisabled(self.__bmpUnDock)
170	jonathan	666	self.__dockButton.SetToolTip(wxToolTip(_("Undock")))
171	jonathan	561
172	jonathan	571	self.SetDockSize(self.__dockWindow.GetSize())
173	jonathan	561
174	jonathan	571	if wasVisible: self.Show(True)
175
176			self.issue(DOCKABLE_DOCKED, self.__id, self)
177
178	jonathan	561	def UnDock(self):
179	jonathan	571	self.__CheckAllGood()
180	jonathan	561
181	jonathan	571	wasVisible = self.IsShown()
182	jonathan	561
183	jonathan	571	if wasVisible: self.Show(False)
184
185			self.__docked = False
186	jonathan	561
187	jonathan	571	#
188			# reparent
189			#
190			self.__topWindow = self.__floatWindow
191			self.__dockPanel.Reparent(self.__topWindow)
192	jonathan	561
193	jonathan	667	self.__dockButton.SetBitmapLabel(self.__bmpDock)
194			self.__dockButton.SetBitmapFocus(self.__bmpDock)
195			self.__dockButton.SetBitmapSelected(self.__bmpDock)
196			self.__dockButton.SetBitmapDisabled(self.__bmpDock)
197	jonathan	666	self.__dockButton.SetToolTip(wxToolTip(_("Dock")))
198	jonathan	561
199	jonathan	571	if wasVisible: self.Show()
200	jonathan	561
201	jonathan	571	#
202			# restore window information
203			#
204	jonathan	666	if self.__floatPosition is not None:
205			self.SetPosition(self.__floatPosition)
206			if self.__floatSize is not None:
207			self.SetSize(self.__floatSize)
208	jonathan	561
209	jonathan	620	self.__dockPanel.SetSize(self.__topWindow.GetClientSize())
210
211	jonathan	571	self.issue(DOCKABLE_UNDOCKED, self.__id, self)
212	jonathan	561
213			def IsDocked(self):
214	jonathan	571	self.__CheckAllGood()
215			return self.__docked
216	jonathan	561
217	jonathan	571	def Show(self, show = True):
218			if show:
219			self.__DoShow()
220			else:
221			self.__DoHide()
222	jonathan	561
223	jonathan	571	def SetDockSize(self, rect = None):
224	jonathan	561
225	jonathan	571	w0, h0 = self.__dockPanel.GetBestSize()
226			w, h = self.__panel.GetBestSize()
227	jonathan	561
228	jonathan	571	if (w, h) < (w0, h0):
229			w = w0
230			h = h0
231	jonathan	659
232	jonathan	571	if rect is not None:
233			rw = rect.width
234			rh = rect.height
235			if rw < w: rw = w
236			if rh < h: rh = h
237			else:
238			rw = w
239			rh = h
240
241			# these are to account for the border?!!?
242			rw += 8 # XXX: without this the sash isn't visible!?!?!?!
243			rh += 8 # XXX: without this the sash isn't visible!?!?!?!
244
245			self.__dockWindow.SetDefaultSize(wxSize(rw, rh))
246	jonathan	561
247
248	jonathan	577	def Destroy(self):
249			self.__panel.Destroy()
250	jonathan	571	self.__floatWindow.Destroy()
251			self.__dockWindow.Destroy()
252	jonathan	631	self.__parent.OnDockDestroy(self)
253	jonathan	577
254	jonathan	571	##
255			# Event handlers
256			#
257	jonathan	561
258	jonathan	571	def _OnButtonClose(self, event):
259	jonathan	583	#self.Close()
260	jonathan	631	self.Show(False)
261	jonathan	561
262	jonathan	571	def _OnClose(self, force = False):
263	jonathan	631	self.Show(False)
264	jonathan	561
265	jonathan	571	def _OnToggleDock(self, event):
266			self.__CheckAllGood()
267	jonathan	561
268	jonathan	571	self.SetDock(not self.IsDocked())
269	jonathan	561
270	jonathan	571	##
271			# Private methods
272			#
273	jonathan	561
274	jonathan	571	def __CheckAllGood(self):
275			if self.__panel is None:
276			raise TypeError("")
277	jonathan	561
278	jonathan	571	def __DoShow(self):
279			if self.IsShown(): return
280	jonathan	561
281	jonathan	571	self.__topWindow.Show()
282	jonathan	561
283	jonathan	571	if self.__topWindow is self.__dockWindow:
284			self.__parent._UpdateDocks()
285
286			def __DoHide(self):
287			if not self.IsShown(): return
288	jonathan	666
289	jonathan	571	self.__topWindow.Show(False)
290
291			if self.__topWindow is self.__dockWindow:
292			self.__parent._UpdateDocks()
293
294			def __CreateBorder(self):
295
296			self.__dockPanel = wxPanel(self.__topWindow, -1, style=wxSUNKEN_BORDER)
297
298	jonathan	657	self.__panel.Reparent(self.__dockPanel)
299			self.__panel.SetId(PANEL_ID)
300
301	jonathan	571	if self.__orientation == wxLAYOUT_VERTICAL:
302			sizer = wxBoxSizer(wxVERTICAL)
303			headerBoxOrient = wxHORIZONTAL
304	jonathan	561	else:
305	jonathan	571	sizer = wxBoxSizer(wxHORIZONTAL)
306			headerBoxOrient = wxVERTICAL
307
308	jonathan	561
309	jonathan	571	headerBox = wxStaticBoxSizer(
310			wxStaticBox(self.__dockPanel, -1, ""), headerBoxOrient)
311	jonathan	561
312	jonathan	571	#
313			# ideally, we should be able to rotate this text depending on
314			# our orientation
315			#
316			text = wxStaticText(self.__dockPanel, -1, self.GetTitle(),
317	jonathan	620	style = wxALIGN_CENTRE)
318	jonathan	651	font = text.GetFont()
319			font.SetPointSize(10)
320			text.SetFont(font)
321
322	jonathan	561	#
323	jonathan	666	# load the dock/undock/close bitmaps
324			# and create the buttons
325	jonathan	561	#
326	jonathan	657	self.__bmpDock = \
327	jonathan	651	resource.GetBitmapResource(DOCK_BMP, wxBITMAP_TYPE_XPM)
328	jonathan	657	self.__bmpUnDock = \
329	jonathan	651	resource.GetBitmapResource(UNDOCK_BMP, wxBITMAP_TYPE_XPM)
330	jonathan	561
331	jonathan	666	if self.__docked:
332			bmp = self.__bmpDock
333	jonathan	651	else:
334	jonathan	666	bmp = self.__bmpUnDock
335	jonathan	561
336	jonathan	666	self.__dockButton = wxBitmapButton(
337			self.__dockPanel, ID_BUTTON_DOCK,
338			bmp,
339			size = wxSize(bmp.GetWidth() + 4, bmp.GetHeight() + 4),
340			style = wxBU_EXACTFIT \| wxADJUST_MINSIZE)
341	jonathan	561
342	jonathan	651	bmp = resource.GetBitmapResource(CLOSE_BMP, wxBITMAP_TYPE_XPM)
343
344			closeX = wxBitmapButton(self.__dockPanel, ID_BUTTON_CLOSE, bmp,
345			size = wxSize(bmp.GetWidth() + 4,
346			bmp.GetHeight() + 4),
347			style = wxBU_EXACTFIT \| wxADJUST_MINSIZE)
348			closeX.SetToolTip(wxToolTip(_("Close")))
349
350	jonathan	666	#
351			# fill in the sizer in an order appropriate to the orientation
352			#
353	jonathan	571	if self.__orientation == wxLAYOUT_VERTICAL:
354			headerBox.Add(text, 0, wxALIGN_LEFT \| wxALIGN_CENTRE_VERTICAL, 0)
355	jonathan	651	headerBox.Add(1, 5, 1, wxGROW)
356			headerBox.Add(self.__dockButton, 0, wxALIGN_RIGHT, 0)
357			headerBox.Add(closeX, 0, wxALIGN_RIGHT \| wxLEFT, 4)
358	jonathan	571	else:
359	jonathan	651	headerBox.Add(closeX, 0, wxALIGN_RIGHT \| wxBOTTOM, 4)
360			headerBox.Add(self.__dockButton, 0, wxALIGN_RIGHT, 0)
361	jonathan	571	headerBox.Add(text, 0, wxALIGN_LEFT \| wxALIGN_CENTRE_VERTICAL, 0)
362	jonathan	561
363	jonathan	571	sizer.Add(headerBox, 0, wxGROW, 0)
364			sizer.Add(self.__panel, 1, wxGROW, 0)
365	jonathan	561
366	jonathan	666
367	jonathan	659	self.__dockPanel.SetAutoLayout(True)
368			self.__dockPanel.SetSizer(sizer)
369			sizer.SetSizeHints(self.__dockPanel)
370	jonathan	666	sizer.SetSizeHints(self.__floatWindow)
371	jonathan	571
372			EVT_BUTTON(self.__dockPanel, ID_BUTTON_DOCK, self._OnToggleDock)
373			EVT_BUTTON(self.__dockPanel, ID_BUTTON_CLOSE, self._OnButtonClose)
374
375
376			class DockFrame(wxFrame):
377
378			def __init__(self, parent, id, title, position, size):
379			wxFrame.__init__(self, parent, id, title, position, size)
380
381			self.openWindows = {}
382
383	jonathan	577	self.__update_lock = 0
384	jonathan	571
385			self.SetMainWindow(None)
386
387	jonathan	577
388			EVT_SIZE(self, self._OnSashSize)
389	jonathan	973	EVT_CLOSE(self, self.OnClose)
390	jonathan	577
391	jonathan	571	layout2oppSash = {
392			wxLAYOUT_NONE : wxSASH_NONE,
393			wxLAYOUT_TOP : wxSASH_BOTTOM,
394			wxLAYOUT_LEFT : wxSASH_RIGHT,
395			wxLAYOUT_RIGHT : wxSASH_LEFT,
396			wxLAYOUT_BOTTOM : wxSASH_TOP }
397
398	jonathan	577
399	jonathan	973	def OnClose(self, event):
400	jonathan	577
401			self.__update_lock += 1
402
403			#
404			# child windows are not notified when the parent is destroyed
405			# as of v2.4.0.3 so we need to interate over our children
406			# and tell them to go away.
407			#
408			for key in self.openWindows.keys():
409			win = self.openWindows[key]
410			win.Destroy()
411
412			self.__update_lock -= 1
413
414			# should really call _UpdateDocks() here but we don't need to
415			# since we're going away
416
417	jonathan	571	def CreateDock(self, name, id, title, align):
418
419			if align in (wxLAYOUT_NONE, wxLAYOUT_LEFT, wxLAYOUT_RIGHT):
420			orient = wxLAYOUT_VERTICAL
421			else:
422			orient = wxLAYOUT_HORIZONTAL
423
424			sash = wxSashLayoutWindow(self, id, style=wxNO_BORDER\|wxSW_3D)
425			sash.SetOrientation(orient)
426			sash.SetAlignment(align)
427			sash.SetSashVisible(DockFrame.layout2oppSash[align], True)
428			sash.SetSashBorder(DockFrame.layout2oppSash[align], True)
429
430			win = DockableWindow(self, id, name, title, sash, orient)
431
432			self.__RegisterDock(name, win)
433			EVT_SASH_DRAGGED(self, id, self._OnSashDragged)
434
435			return win
436
437			def FindRegisteredDock(self, name):
438			return self.openWindows.get(name)
439
440	jonathan	631	def OnDockDestroy(self, win):
441	jonathan	571	del self.openWindows[win.GetName()]
442			self._UpdateDocks()
443
444			def SetMainWindow(self, main):
445			self.__mainWindow = main
446			self._UpdateDocks()
447
448			def _UpdateDocks(self):
449	jonathan	577	if self.__update_lock == 0:
450			wxLayoutAlgorithm().LayoutWindow(self, self.__mainWindow)
451	jonathan	571
452			def _OnSashDragged(self, event):
453			if event.GetDragStatus() == wxSASH_STATUS_OUT_OF_RANGE:
454			return
455
456			id = event.GetId()
457			sash = self.FindWindowById(id)
458			#assert(isinstance(win, wxPanel))
459			dockPanel = sash.GetChildren()[0]
460			panel = dockPanel.FindWindowById(PANEL_ID)
461	jonathan	605	assert isinstance(panel, DockPanel)
462	jonathan	571	win = panel.GetDockParent()
463	jonathan	605	assert isinstance(win, DockableWindow)
464	jonathan	571
465	jonathan	605	assert win.IsDocked()
466	jonathan	571
467			rect = event.GetDragRect()
468
469			win.SetDockSize(rect)
470
471			self._UpdateDocks()
472
473			def _OnSashSize(self, event):
474			self._UpdateDocks()
475
476			def __RegisterDock(self, name, win):
477			if self.FindRegisteredDock(name) is not None:
478			raise ValueError(
479			"A dockable window is already registered under the name '%s'" % name)
480
481			self.openWindows[name] = win
482
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision