[wxWidgets.git] / utils / wxPython / lib / floatbar.py

#----------------------------------------------------------------------------
# Name:         floatbar.py
# Purpose:      Contains floating toolbar class
#
# Author:       Bryn Keller
#
# Created:      10/4/99
#----------------------------------------------------------------------------
from wxPython.wx import *

_DOCKTHRESHOLD = 25

class wxFloatBar(wxToolBar):
    """
    wxToolBar subclass which can be dragged off its frame and later
    replaced there.  Drag on the toolbar to release it, close it like
    a normal window to make it return to its original
    position. Programmatically, call SetFloatable(true) and then
    Float(true) to float, Float(false) to dock.
    """

    def __init__(self,*_args,**_kwargs):
        """
        In addition to the usual arguments, wxFloatBar accepts keyword
        args of: title(string): the title that should appear on the
        toolbar's frame when it is floating.  floatable(bool): whether
        user actions (i.e., dragging) can float the toolbar or not.
        """
        args = (self,) + _args
        apply(wxToolBar.__init__, args, _kwargs)
        if _kwargs.has_key('floatable'):
            self.floatable = _kwargs['floatable']
            assert type(self.floatable) == type(0)
        else:
            self.floatable = 0
        self.floating = 0
        if _kwargs.has_key('title'):
            self.title = _kwargs['title']
            assert type(self.title) == type("")
        else:
            self.title = ""
        EVT_MOUSE_EVENTS(self, self.OnMouse)
        self.parentframe = wxPyTypeCast(args[1], 'wxFrame')


    def IsFloatable(self):
        return self.floatable


    def SetFloatable(self, float):
        self.floatable = float
        #Find the size of a title bar.
        if not hasattr(self, 'titleheight'):
            test = wxMiniFrame(NULL, -1, "TEST")
            test.SetClientSize(wxSize(0,0))
            self.titleheight = test.GetSizeTuple()[1]
            test.Destroy()


    def IsFloating(self):
        return self.floating


    def Realize(self):
        wxToolBar.Realize(self)


    def GetTitle(self):
        return self.title


    def SetTitle(self, title):
        self.title = title
        if self.IsFloating():
            self.floatframe.SetTitle(self.title)


##     def GetHome(self):
##         """
##         Returns the frame which this toolbar will return to when
##         docked, or the parent if currently docked.
##         """
##         if hasattr(self, 'parentframe'):
##             return self.parentframe
##         else:
##             return wxPyTypeCast(self.GetParent(), 'wxFrame')


##     def SetHome(self, frame):
##         """
##         Called when docked, this will remove the toolbar from its
##         current frame and attach it to another.  If called when
##         floating, it will dock to the frame specified when the toolbar
##         window is closed.
##         """
##         if self.IsFloating():
##             self.parentframe = frame
##             self.floatframe.Reparent(frame)
##         else:
##             parent = wxPyTypeCast(self.GetParent(), 'wxFrame')
##             self.Reparent(frame)
##             parent.SetToolBar(None)
##             size = parent.GetSize()
##             parent.SetSize(wxSize(0,0))
##             parent.SetSize(size)
##             frame.SetToolBar(self)
##             size = frame.GetSize()
##             frame.SetSize(wxSize(0,0))
##             frame.SetSize(size)


    def Float(self, bool):
        "Floats or docks the toolbar programmatically."
        if bool:
            self.parentframe = wxPyTypeCast(self.GetParent(), 'wxFrame')
            if self.title:
                useStyle = wxDEFAULT_FRAME_STYLE
            else:
                useStyle = 0 #wxTHICK_FRAME
            self.floatframe = wxMiniFrame(self.parentframe, -1, self.title,
                                          style = useStyle)

            self.Reparent(self.floatframe)
            self.parentframe.SetToolBar(None)
            self.floating = 1
            psize = self.parentframe.GetSize()
            self.parentframe.SetSize(wxSize(0,0))
            self.parentframe.SetSize(psize)
            self.floatframe.SetToolBar(self)
            self.oldcolor = self.GetBackgroundColour()

            w = psize.width
            h = self.GetSize().height
            if self.title:
                h = h + self.titleheight
            self.floatframe.SetSize(wxSize(w,h))
            self.floatframe.SetClientSize(self.GetSize())
            newpos = self.parentframe.GetPosition()
            newpos.y = newpos.y + _DOCKTHRESHOLD * 2
            self.floatframe.SetPosition(newpos)
            self.floatframe.Show(true)

            EVT_CLOSE(self.floatframe, self.OnDock)
            #EVT_MOVE(self.floatframe, self.OnMove)

        else:
            self.Reparent(self.parentframe)
            self.parentframe.SetToolBar(self)
            self.floating = 0
            self.floatframe.SetToolBar(None)
            self.floatframe.Destroy()
            size = self.parentframe.GetSize()
            self.parentframe.SetSize(wxSize(0,0))
            self.parentframe.SetSize(size)
            self.SetBackgroundColour(self.oldcolor)


    def OnDock(self, e):
        self.Float(0)
        if hasattr(self, 'oldpos'):
            del self.oldpos


    def OnMove(self, e):
        homepos = self.parentframe.ClientToScreen(wxPoint(0,0))
        floatpos = self.floatframe.GetPosition()
        if (abs(homepos.x - floatpos.x) < _DOCKTHRESHOLD and
            abs(homepos.y - floatpos.y) < _DOCKTHRESHOLD):
            self.Float(0)
        #homepos = self.parentframe.GetPositionTuple()
        #homepos = homepos[0], homepos[1] + self.titleheight
        #floatpos = self.floatframe.GetPositionTuple()
        #if abs(homepos[0] - floatpos[0]) < 35 and abs(homepos[1] - floatpos[1]) < 35:
        #    self._SetFauxBarVisible(true)
        #else:
        #    self._SetFauxBarVisible(false)


    def OnMouse(self, e):
        if not self.IsFloatable():
            e.Skip()
            return
        if e.ButtonDown() or e.ButtonUp() or e.ButtonDClick(1) or e.ButtonDClick(2) or e.ButtonDClick(3):
            e.Skip()
        if e.ButtonDown():
            self.CaptureMouse()
            self.oldpos = (e.GetX(), e.GetY())
        if e.Entering():
            self.oldpos = (e.GetX(), e.GetY())
        if e.ButtonUp():
            self.ReleaseMouse()
            if self.IsFloating():
                homepos = self.parentframe.ClientToScreen(wxPoint(0,0))
                floatpos = self.floatframe.GetPosition()
                if (abs(homepos.x - floatpos.x) < _DOCKTHRESHOLD and
                    abs(homepos.y - floatpos.y) < _DOCKTHRESHOLD):
                    self.Float(0)
                    return
        if self.IsFloatable():
            if e.Dragging():
                if not self.IsFloating():
                    self.Float(true)
                    self.oldpos = (e.GetX(), e.GetY())
                else:
                    if hasattr(self, 'oldpos'):
                        loc = self.floatframe.GetPosition()
                        pt = wxPoint(loc.x - (self.oldpos[0]-e.GetX()), loc.y - (self.oldpos[1]-e.GetY()))
                        self.floatframe.SetPosition(pt)


    def _SetFauxBarVisible(self, vis):
        return
        if vis:
            if self.parentframe.GetToolBar() == None:
                if not hasattr(self, 'nullbar'):
                    self.nullbar = wxToolBar(self.parentframe, -1)
                print "Adding fauxbar."
                self.nullbar.Reparent(self.parentframe)
                print "Reparented."
                self.parentframe.SetToolBar(self.nullbar)
                print "Set toolbar"
                col = wxNamedColour("GREY")
                self.nullbar.SetBackgroundColour(col)
                print "Set color"
                size = self.parentframe.GetSize()
                self.parentframe.SetSize(wxSize(0,0))
                self.parentframe.SetSize(size)
                print "Set size"
            else:
                print self.parentframe.GetToolBar()
        else:
            if self.parentframe.GetToolBar() != None:
                print "Removing fauxbar"
                self.nullbar.Reparent(self.floatframe)
                self.parentframe.SetToolBar(None)
                size = self.parentframe.GetSize()
                self.parentframe.SetSize(wxSize(0,0))
                self.parentframe.SetSize(size)
Commit	Line	Data
f0261a72 RD	1	#----------------------------------------------------------------------------
	2	# Name: floatbar.py
	3	# Purpose: Contains floating toolbar class
	4	#
	5	# Author: Bryn Keller
	6	#
	7	# Created: 10/4/99
	8	#----------------------------------------------------------------------------
	9	from wxPython.wx import *
	10
8c588298 RD	11	_DOCKTHRESHOLD = 25
8c588298 RD	12
f0261a72 RD	13	class wxFloatBar(wxToolBar):
	14	"""
	15	wxToolBar subclass which can be dragged off its frame and later
	16	replaced there. Drag on the toolbar to release it, close it like
	17	a normal window to make it return to its original
	18	position. Programmatically, call SetFloatable(true) and then
	19	Float(true) to float, Float(false) to dock.
	20	"""
944930d5	21
f0261a72 RD	22	def __init__(self,_args,*_kwargs):
	23	"""
	24	In addition to the usual arguments, wxFloatBar accepts keyword
	25	args of: title(string): the title that should appear on the
	26	toolbar's frame when it is floating. floatable(bool): whether
	27	user actions (i.e., dragging) can float the toolbar or not.
	28	"""
	29	args = (self,) + _args
	30	apply(wxToolBar.__init__, args, _kwargs)
	31	if _kwargs.has_key('floatable'):
	32	self.floatable = _kwargs['floatable']
	33	assert type(self.floatable) == type(0)
	34	else:
	35	self.floatable = 0
	36	self.floating = 0
	37	if _kwargs.has_key('title'):
	38	self.title = _kwargs['title']
	39	assert type(self.title) == type("")
	40	else:
	41	self.title = ""
	42	EVT_MOUSE_EVENTS(self, self.OnMouse)
	43	self.parentframe = wxPyTypeCast(args[1], 'wxFrame')
944930d5	44
8c588298	45
f0261a72 RD	46	def IsFloatable(self):
f0261a72 RD	47	return self.floatable
944930d5	48
8c588298	49
f0261a72 RD	50	def SetFloatable(self, float):
	51	self.floatable = float
	52	#Find the size of a title bar.
	53	if not hasattr(self, 'titleheight'):
8c588298	54	test = wxMiniFrame(NULL, -1, "TEST")
f0261a72 RD	55	test.SetClientSize(wxSize(0,0))
	56	self.titleheight = test.GetSizeTuple()[1]
	57	test.Destroy()
944930d5	58
8c588298	59
f0261a72 RD	60	def IsFloating(self):
f0261a72 RD	61	return self.floating
944930d5	62
8c588298	63
f0261a72 RD	64	def Realize(self):
f0261a72 RD	65	wxToolBar.Realize(self)
8c588298	66
944930d5	67
f0261a72 RD	68	def GetTitle(self):
f0261a72 RD	69	return self.title
944930d5	70
8c588298	71
f0261a72 RD	72	def SetTitle(self, title):
	73	self.title = title
	74	if self.IsFloating():
	75	self.floatframe.SetTitle(self.title)
944930d5	76
944930d5	77
8c588298 RD	78	## def GetHome(self):
	79	## """
	80	## Returns the frame which this toolbar will return to when
	81	## docked, or the parent if currently docked.
	82	## """
	83	## if hasattr(self, 'parentframe'):
	84	## return self.parentframe
	85	## else:
	86	## return wxPyTypeCast(self.GetParent(), 'wxFrame')
	87
	88
	89	## def SetHome(self, frame):
	90	## """
	91	## Called when docked, this will remove the toolbar from its
	92	## current frame and attach it to another. If called when
	93	## floating, it will dock to the frame specified when the toolbar
	94	## window is closed.
	95	## """
	96	## if self.IsFloating():
	97	## self.parentframe = frame
	98	## self.floatframe.Reparent(frame)
	99	## else:
	100	## parent = wxPyTypeCast(self.GetParent(), 'wxFrame')
	101	## self.Reparent(frame)
	102	## parent.SetToolBar(None)
	103	## size = parent.GetSize()
	104	## parent.SetSize(wxSize(0,0))
	105	## parent.SetSize(size)
	106	## frame.SetToolBar(self)
	107	## size = frame.GetSize()
	108	## frame.SetSize(wxSize(0,0))
	109	## frame.SetSize(size)
	110
944930d5	111
f0261a72 RD	112	def Float(self, bool):
	113	"Floats or docks the toolbar programmatically."
	114	if bool:
	115	self.parentframe = wxPyTypeCast(self.GetParent(), 'wxFrame')
944930d5 RD	116	if self.title:
	117	useStyle = wxDEFAULT_FRAME_STYLE
	118	else:
	119	useStyle = 0 #wxTHICK_FRAME
	120	self.floatframe = wxMiniFrame(self.parentframe, -1, self.title,
	121	style = useStyle)
8c588298	122
f0261a72 RD	123	self.Reparent(self.floatframe)
	124	self.parentframe.SetToolBar(None)
	125	self.floating = 1
8c588298	126	psize = self.parentframe.GetSize()
f0261a72	127	self.parentframe.SetSize(wxSize(0,0))
8c588298	128	self.parentframe.SetSize(psize)
f0261a72 RD	129	self.floatframe.SetToolBar(self)
f0261a72 RD	130	self.oldcolor = self.GetBackgroundColour()
8c588298 RD	131
	132	w = psize.width
	133	h = self.GetSize().height
	134	if self.title:
	135	h = h + self.titleheight
	136	self.floatframe.SetSize(wxSize(w,h))
	137	self.floatframe.SetClientSize(self.GetSize())
f0261a72	138	newpos = self.parentframe.GetPosition()
8c588298	139	newpos.y = newpos.y + _DOCKTHRESHOLD * 2
f0261a72 RD	140	self.floatframe.SetPosition(newpos)
f0261a72 RD	141	self.floatframe.Show(true)
8c588298	142
f0261a72	143	EVT_CLOSE(self.floatframe, self.OnDock)
8c588298 RD	144	#EVT_MOVE(self.floatframe, self.OnMove)
8c588298 RD	145
f0261a72 RD	146	else:
	147	self.Reparent(self.parentframe)
	148	self.parentframe.SetToolBar(self)
	149	self.floating = 0
8c588298	150	self.floatframe.SetToolBar(None)
f0261a72 RD	151	self.floatframe.Destroy()
	152	size = self.parentframe.GetSize()
	153	self.parentframe.SetSize(wxSize(0,0))
	154	self.parentframe.SetSize(size)
	155	self.SetBackgroundColour(self.oldcolor)
944930d5	156
8c588298	157
f0261a72 RD	158	def OnDock(self, e):
	159	self.Float(0)
	160	if hasattr(self, 'oldpos'):
	161	del self.oldpos
	162
8c588298	163
f0261a72	164	def OnMove(self, e):
8c588298 RD	165	homepos = self.parentframe.ClientToScreen(wxPoint(0,0))
	166	floatpos = self.floatframe.GetPosition()
	167	if (abs(homepos.x - floatpos.x) < _DOCKTHRESHOLD and
	168	abs(homepos.y - floatpos.y) < _DOCKTHRESHOLD):
	169	self.Float(0)
	170	#homepos = self.parentframe.GetPositionTuple()
	171	#homepos = homepos[0], homepos[1] + self.titleheight
	172	#floatpos = self.floatframe.GetPositionTuple()
	173	#if abs(homepos[0] - floatpos[0]) < 35 and abs(homepos[1] - floatpos[1]) < 35:
	174	# self._SetFauxBarVisible(true)
	175	#else:
	176	# self._SetFauxBarVisible(false)
	177
f0261a72 RD	178
	179	def OnMouse(self, e):
	180	if not self.IsFloatable():
	181	e.Skip()
	182	return
	183	if e.ButtonDown() or e.ButtonUp() or e.ButtonDClick(1) or e.ButtonDClick(2) or e.ButtonDClick(3):
	184	e.Skip()
	185	if e.ButtonDown():
944930d5	186	self.CaptureMouse()
f0261a72 RD	187	self.oldpos = (e.GetX(), e.GetY())
	188	if e.Entering():
	189	self.oldpos = (e.GetX(), e.GetY())
	190	if e.ButtonUp():
944930d5	191	self.ReleaseMouse()
f0261a72	192	if self.IsFloating():
8c588298 RD	193	homepos = self.parentframe.ClientToScreen(wxPoint(0,0))
	194	floatpos = self.floatframe.GetPosition()
	195	if (abs(homepos.x - floatpos.x) < _DOCKTHRESHOLD and
	196	abs(homepos.y - floatpos.y) < _DOCKTHRESHOLD):
f0261a72 RD	197	self.Float(0)
	198	return
	199	if self.IsFloatable():
	200	if e.Dragging():
	201	if not self.IsFloating():
	202	self.Float(true)
	203	self.oldpos = (e.GetX(), e.GetY())
	204	else:
	205	if hasattr(self, 'oldpos'):
	206	loc = self.floatframe.GetPosition()
	207	pt = wxPoint(loc.x - (self.oldpos[0]-e.GetX()), loc.y - (self.oldpos[1]-e.GetY()))
	208	self.floatframe.SetPosition(pt)
	209
8c588298	210
f0261a72	211	def _SetFauxBarVisible(self, vis):
944930d5	212	return
f0261a72 RD	213	if vis:
	214	if self.parentframe.GetToolBar() == None:
	215	if not hasattr(self, 'nullbar'):
	216	self.nullbar = wxToolBar(self.parentframe, -1)
	217	print "Adding fauxbar."
	218	self.nullbar.Reparent(self.parentframe)
	219	print "Reparented."
	220	self.parentframe.SetToolBar(self.nullbar)
	221	print "Set toolbar"
	222	col = wxNamedColour("GREY")
	223	self.nullbar.SetBackgroundColour(col)
	224	print "Set color"
	225	size = self.parentframe.GetSize()
	226	self.parentframe.SetSize(wxSize(0,0))
	227	self.parentframe.SetSize(size)
	228	print "Set size"
	229	else:
	230	print self.parentframe.GetToolBar()
	231	else:
	232	if self.parentframe.GetToolBar() != None:
	233	print "Removing fauxbar"
	234	self.nullbar.Reparent(self.floatframe)
	235	self.parentframe.SetToolBar(None)
	236	size = self.parentframe.GetSize()
	237	self.parentframe.SetSize(wxSize(0,0))
	238	self.parentframe.SetSize(size)
	239
	240
	241
	242
	243
	244
	245
	246
	247
	248
	249
	250
	251