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


import wx
import wx.combo
import os

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

class NullLog:
    def write(*args):
        pass


# This class is used to provide an interface between a ComboCtrl and a
# ListCtrl that is used as the popoup for the combo widget.  In this
# case we use multiple inheritance to derive from both wx.ListCtrl and
# wx.ComboPopup, but it also works well when deriving from just
# ComboPopup and using a has-a relationship with the popup control,
# you just need to be sure to return the control itself from the
# GetControl method.

class ListCtrlComboPopup(wx.ListCtrl, wx.combo.ComboPopup):
        
    def __init__(self, log=None):
        if log:
            self.log = log
        else:
            self.log = NullLog()
            
        
        # Since we are using multiple inheritance, and don't know yet
        # which window is to be the parent, we'll do 2-phase create of
        # the ListCtrl instead, and call its Create method later in
        # our Create method.  (See Create below.)
        self.PostCreate(wx.PreListCtrl())

        # Also init the ComboPopup base class.
        wx.combo.ComboPopup.__init__(self)
        

    def AddItem(self, txt):
        self.InsertStringItem(self.GetItemCount(), txt)

    def OnMotion(self, evt):
        item, flags = self.HitTest(evt.GetPosition())
        if item >= 0:
            self.Select(item)
            self.curitem = item

    def OnLeftDown(self, evt):
        self.value = self.curitem
        self.Dismiss()


    # The following methods are those that are overridable from the
    # ComboPopup base class.  Most of them are not required, but all
    # are shown here for demonstration purposes.


    # This is called immediately after construction finishes.  You can
    # use self.GetCombo if needed to get to the ComboCtrl instance.
    def Init(self):
        self.log.write("ListCtrlComboPopup.Init")
        self.value = -1
        self.curitem = -1


    # Create the popup child control.  Return true for success.
    def Create(self, parent):
        self.log.write("ListCtrlComboPopup.Create")
        wx.ListCtrl.Create(self, parent,
                           style=wx.LC_LIST|wx.LC_SINGLE_SEL|wx.SIMPLE_BORDER)
        self.Bind(wx.EVT_MOTION, self.OnMotion)
        self.Bind(wx.EVT_LEFT_DOWN, self.OnLeftDown)
        return True


    # Return the widget that is to be used for the popup
    def GetControl(self):
        #self.log.write("ListCtrlComboPopup.GetControl")
        return self

    # Called just prior to displaying the popup, you can use it to
    # 'select' the current item.
    def SetStringValue(self, val):
        self.log.write("ListCtrlComboPopup.SetStringValue")
        idx = self.FindItem(-1, val)
        if idx != wx.NOT_FOUND:
            self.Select(idx)

    # Return a string representation of the current item.
    def GetStringValue(self):
        self.log.write("ListCtrlComboPopup.GetStringValue")
        if self.value >= 0:
            return self.GetItemText(self.value)
        return ""

    # Called immediately after the popup is shown
    def OnPopup(self):
        self.log.write("ListCtrlComboPopup.OnPopup")
        wx.combo.ComboPopup.OnPopup(self)

    # Called when popup is dismissed
    def OnDismiss(self):
        self.log.write("ListCtrlComboPopup.OnDismiss")
        wx.combo.ComboPopup.OnDismiss(self)

    # This is called to custom paint in the combo control itself
    # (ie. not the popup).  Default implementation draws value as
    # string.
    def PaintComboControl(self, dc, rect):
        self.log.write("ListCtrlComboPopup.PaintComboControl")
        wx.combo.ComboPopup.PaintComboControl(self, dc, rect)

    # Receives key events from the parent ComboCtrl.  Events not
    # handled should be skipped, as usual.
    def OnComboKeyEvent(self, event):
        self.log.write("ListCtrlComboPopup.OnComboKeyEvent")
        wx.combo.ComboPopup.OnComboKeyEvent(self, event)

    # Implement if you need to support special action when user
    # double-clicks on the parent wxComboCtrl.
    def OnComboDoubleClick(self):
        self.log.write("ListCtrlComboPopup.OnComboDoubleClick")
        wx.combo.ComboPopup.OnComboDoubleClick(self)

    # Return final size of popup. Called on every popup, just prior to OnPopup.
    # minWidth = preferred minimum width for window
    # prefHeight = preferred height. Only applies if > 0,
    # maxHeight = max height for window, as limited by screen size
    #   and should only be rounded down, if necessary.
    def GetAdjustedSize(self, minWidth, prefHeight, maxHeight):
        self.log.write("ListCtrlComboPopup.GetAdjustedSize: %d, %d, %d" % (minWidth, prefHeight, maxHeight))
        return wx.combo.ComboPopup.GetAdjustedSize(self, minWidth, prefHeight, maxHeight)

    # Return true if you want delay the call to Create until the popup
    # is shown for the first time. It is more efficient, but note that
    # it is often more convenient to have the control created
    # immediately.    
    # Default returns false.
    def LazyCreate(self):
        self.log.write("ListCtrlComboPopup.LazyCreate")
        return wx.combo.ComboPopup.LazyCreate(self)
        

#----------------------------------------------------------------------
# This class is a popup containing a TreeCtrl.  This time we'll use a
# has-a style (instead of is-a like above.)

class TreeCtrlComboPopup(wx.combo.ComboPopup):

    # overridden ComboPopup methods
    
    def Init(self):
        self.value = None
        self.curitem = None

        
    def Create(self, parent):
        self.tree = wx.TreeCtrl(parent, style=wx.TR_HIDE_ROOT
                                |wx.TR_HAS_BUTTONS
                                |wx.TR_SINGLE
                                |wx.TR_LINES_AT_ROOT
                                |wx.SIMPLE_BORDER)
        self.tree.Bind(wx.EVT_MOTION, self.OnMotion)
        self.tree.Bind(wx.EVT_LEFT_DOWN, self.OnLeftDown)
        

    def GetControl(self):
        return self.tree


    def GetStringValue(self):
        if self.value:
            return self.tree.GetItemText(self.value)
        return ""


    def OnPopup(self):
        if self.value:
            self.tree.EnsureVisible(self.value)
            self.tree.SelectItem(self.value)


    def SetStringValue(self, value):
        # this assumes that item strings are unique...
        root = self.tree.GetRootItem()
        if not root:
            return
        found = self.FindItem(root, value)
        if found:
            self.value = found
            self.tree.SelectItem(found)


    def GetAdjustedSize(self, minWidth, prefHeight, maxHeight):
        return wx.Size(minWidth, min(200, maxHeight))
                       

    # helpers
    
    def FindItem(self, parentItem, text):        
        item, cookie = self.tree.GetFirstChild(parentItem)
        while item:
            if self.tree.GetItemText(item) == text:
                return item
            if self.tree.ItemHasChildren(item):
                item = self.FindItem(item, text)
            item, cookie = self.tree.GetNextChild(parentItem, cookie)
        return wx.TreeItemId();


    def AddItem(self, value, parent=None):
        if not parent:
            root = self.tree.GetRootItem()
            if not root:
                root = self.tree.AddRoot("<hidden root>")
            parent = root

        item = self.tree.AppendItem(parent, value)
        return item

    
    def OnMotion(self, evt):
        # have the selection follow the mouse, like in a real combobox
        item, flags = self.tree.HitTest(evt.GetPosition())
        if item and flags & wx.TREE_HITTEST_ONITEMLABEL:
            self.tree.SelectItem(item)
            self.curitem = item
        evt.Skip()


    def OnLeftDown(self, evt):
        # do the combobox selection
        item, flags = self.tree.HitTest(evt.GetPosition())
        if item and flags & wx.TREE_HITTEST_ONITEMLABEL:
            self.curitem = item
            self.value = item
            self.Dismiss()
        evt.Skip()
        
        
#----------------------------------------------------------------------
# Here we subclass wx.combo.ComboCtrl to do some custom popup animation

CUSTOM_COMBOBOX_ANIMATION_DURATION = 200

class ComboCtrlWithCustomPopupAnim(wx.combo.ComboCtrl):
    def __init__(self, *args, **kw):
        wx.combo.ComboCtrl.__init__(self, *args, **kw)
        self.Bind(wx.EVT_TIMER, self.OnTimer)
        self.aniTimer = wx.Timer(self)


    def AnimateShow(self, rect, flags):
        self.aniStart = wx.GetLocalTimeMillis()
        self.aniRect = wx.Rect(*rect)
        self.aniFlags = flags

        dc = wx.ScreenDC()
        bmp = wx.EmptyBitmap(rect.width, rect.height)
        mdc = wx.MemoryDC(bmp)
        if "wxMac" in wx.PlatformInfo:
            pass
        else:
            mdc.Blit(0, 0, rect.width, rect.height, dc, rect.x, rect.y)
        del mdc
        self.aniBackBitmap = bmp

        self.aniTimer.Start(10, wx.TIMER_CONTINUOUS)
        self.OnTimer(None)
        return False
        

    def OnTimer(self, evt):
        stopTimer = False
        popup = self.GetPopupControl().GetControl()
        rect = self.aniRect
        dc = wx.ScreenDC()

        if self.IsPopupWindowState(self.Hidden):
            stopTimer = True
        else:
            pos = wx.GetLocalTimeMillis() - self.aniStart
            if pos < CUSTOM_COMBOBOX_ANIMATION_DURATION:
                # Actual animation happens here
                width = rect.width
                height = rect.height

                center_x = rect.x + (width/2)
                center_y = rect.y + (height/2)

                dc.SetPen( wx.BLACK_PEN )
                dc.SetBrush( wx.TRANSPARENT_BRUSH )

                w = (((pos*256)/CUSTOM_COMBOBOX_ANIMATION_DURATION)*width)/256
                ratio = float(w) / float(width)
                h = int(height * ratio)
                
                dc.DrawBitmap( self.aniBackBitmap, rect.x, rect.y )
                dc.DrawRectangle( center_x - w/2, center_y - h/2, w, h )
            else:
                stopTimer = True

        if stopTimer:
            dc.DrawBitmap( self.aniBackBitmap, rect.x, rect.y )
            popup.Move( (0, 0) )
            self.aniTimer.Stop()
            self.DoShowPopup( rect, self.aniFlags )

                
#----------------------------------------------------------------------
# FileSelectorCombo displays a dialog instead of a popup control, it
# also uses a custom bitmap on the combo button.

class FileSelectorCombo(wx.combo.ComboCtrl):
    def __init__(self, *args, **kw):
        wx.combo.ComboCtrl.__init__(self, *args, **kw)

        # make a custom bitmap showing "..."
        bw, bh = 14, 16
        bmp = wx.EmptyBitmap(bw,bh)
        dc = wx.MemoryDC(bmp)

        # clear to a specific background colour
        bgcolor = wx.Colour(255,254,255)
        dc.SetBackground(wx.Brush(bgcolor))
        dc.Clear()

        # draw the label onto the bitmap
        label = "..."
        font = wx.SystemSettings.GetFont(wx.SYS_DEFAULT_GUI_FONT)
        font.SetWeight(wx.FONTWEIGHT_BOLD)
        dc.SetFont(font)
        tw,th = dc.GetTextExtent(label)
        dc.DrawText(label, (bw-tw)/2, (bw-tw)/2)
        del dc

        # now apply a mask using the bgcolor
        bmp.SetMaskColour(bgcolor)

        # and tell the ComboCtrl to use it
        self.SetButtonBitmaps(bmp, True)
        

    # Overridden from ComboCtrl, called when the combo button is clicked
    def OnButtonClick(self):
        path = ""
        name = ""
        if self.GetValue():
            path, name = os.path.split(self.GetValue())
        
        dlg = wx.FileDialog(self, "Choose File", path, name,
                            "All files (*.*)|*.*", wx.FD_OPEN)
        if dlg.ShowModal() == wx.ID_OK:
            self.SetValue(dlg.GetPath())
        dlg.Destroy()
        self.SetFocus()

    # Overridden from ComboCtrl to avoid assert since there is no ComboPopup
    def DoSetPopupControl(self, popup):
        pass
    

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


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

        fgs = wx.FlexGridSizer(cols=3, hgap=10, vgap=10)

        cc = self.MakeLCCombo(log=self.log)
        fgs.Add(cc)
        fgs.Add((10,10))
        fgs.Add(wx.StaticText(self, -1, "wx.ComboCtrl with a ListCtrl popup"))

        cc = self.MakeLCCombo(style=wx.CB_READONLY)
        fgs.Add(cc)
        fgs.Add((10,10))
        fgs.Add(wx.StaticText(self, -1, "        Read-only"))

        cc = self.MakeLCCombo()
        cc.SetButtonPosition(side=wx.LEFT)
        fgs.Add(cc)
        fgs.Add((10,10))
        fgs.Add(wx.StaticText(self, -1, "        Button on the left"))

        cc = self.MakeLCCombo()
        cc.SetPopupMaxHeight(250)
        fgs.Add(cc)
        fgs.Add((10,10))
        fgs.Add(wx.StaticText(self, -1, "        Max height of popup set"))

        cc = wx.combo.ComboCtrl(self, size=(250,-1))
        tcp = TreeCtrlComboPopup()
        cc.SetPopupControl(tcp)
        fgs.Add(cc)
        fgs.Add((10,10))
        fgs.Add(wx.StaticText(self, -1, "TreeCtrl popup"))
        # add some items to the tree
        for i in range(5):
            item = tcp.AddItem('Item %d' % (i+1))
            for j in range(15):
                tcp.AddItem('Subitem %d-%d' % (i+1, j+1), parent=item)
                
        cc = ComboCtrlWithCustomPopupAnim(self, size=(250, -1))
        popup = ListCtrlComboPopup()
        cc.SetPopupMaxHeight(150)
        cc.SetPopupControl(popup)
        fgs.Add(cc)
        fgs.Add((10,10))
        fgs.Add(wx.StaticText(self, -1, "Custom popup animation"))
        for word in "How cool was that!?  Way COOL!".split():
            popup.AddItem(word)
        if "wxMac" in wx.PlatformInfo:
            cc.SetValue("Sorry, animation not working yet on Mac")


        cc = FileSelectorCombo(self, size=(250, -1))
        fgs.Add(cc)
        fgs.Add((10,10))
        fgs.Add(wx.StaticText(self, -1, "Custom popup action, and custom button bitmap"))

        box = wx.BoxSizer()
        box.Add(fgs, 1, wx.EXPAND|wx.ALL, 20)
        self.SetSizer(box)


    def MakeLCCombo(self, log=None, style=0):
        # Create a ComboCtrl
        cc = wx.combo.ComboCtrl(self, style=style, size=(250,-1))
        
        # Create a Popup
        popup = ListCtrlComboPopup(log)

        # Associate them with each other.  This also triggers the
        # creation of the ListCtrl.
        cc.SetPopupControl(popup)

        # Add some items to the listctrl.
        for x in range(75):
            popup.AddItem("Item-%02d" % x)

        return cc
        

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

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

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


overview = """<html><body>
<h2><center>wx.combo.ComboCtrl</center></h2>

A combo control is a generic combobox that allows a totally custom
popup. In addition it has other customization features. For instance,
position and size of the dropdown button can be changed.

</body></html>
"""


if __name__ == '__main__':
    import sys,os
    import run
    run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
Commit	Line	Data
84bc0d49 RD	1
	2	import wx
	3	import wx.combo
	4	import os
	5
	6	#----------------------------------------------------------------------
	7
	8	class NullLog:
	9	def write(*args):
	10	pass
	11
	12
	13	# This class is used to provide an interface between a ComboCtrl and a
	14	# ListCtrl that is used as the popoup for the combo widget. In this
	15	# case we use multiple inheritance to derive from both wx.ListCtrl and
	16	# wx.ComboPopup, but it also works well when deriving from just
	17	# ComboPopup and using a has-a relationship with the popup control,
	18	# you just need to be sure to return the control itself from the
	19	# GetControl method.
	20
	21	class ListCtrlComboPopup(wx.ListCtrl, wx.combo.ComboPopup):
	22
	23	def __init__(self, log=None):
	24	if log:
	25	self.log = log
	26	else:
	27	self.log = NullLog()
	28
	29
	30	# Since we are using multiple inheritance, and don't know yet
	31	# which window is to be the parent, we'll do 2-phase create of
	32	# the ListCtrl instead, and call its Create method later in
	33	# our Create method. (See Create below.)
	34	self.PostCreate(wx.PreListCtrl())
	35
	36	# Also init the ComboPopup base class.
	37	wx.combo.ComboPopup.__init__(self)
	38
	39
	40	def AddItem(self, txt):
	41	self.InsertStringItem(self.GetItemCount(), txt)
	42
	43	def OnMotion(self, evt):
	44	item, flags = self.HitTest(evt.GetPosition())
	45	if item >= 0:
	46	self.Select(item)
	47	self.curitem = item
	48
	49	def OnLeftDown(self, evt):
	50	self.value = self.curitem
	51	self.Dismiss()
	52
	53
	54	# The following methods are those that are overridable from the
	55	# ComboPopup base class. Most of them are not required, but all
	56	# are shown here for demonstration purposes.
	57
	58
	59	# This is called immediately after construction finishes. You can
	60	# use self.GetCombo if needed to get to the ComboCtrl instance.
	61	def Init(self):
	62	self.log.write("ListCtrlComboPopup.Init")
	63	self.value = -1
	64	self.curitem = -1
65
66
67	# Create the popup child control. Return true for success.
68	def Create(self, parent):
69	self.log.write("ListCtrlComboPopup.Create")
70	wx.ListCtrl.Create(self, parent,
3b339f10	71	style=wx.LC_LIST\|wx.LC_SINGLE_SEL\|wx.SIMPLE_BORDER)
84bc0d49 RD	72	self.Bind(wx.EVT_MOTION, self.OnMotion)
	73	self.Bind(wx.EVT_LEFT_DOWN, self.OnLeftDown)
	74	return True
	75
	76
	77	# Return the widget that is to be used for the popup
	78	def GetControl(self):
	79	#self.log.write("ListCtrlComboPopup.GetControl")
	80	return self
	81
	82	# Called just prior to displaying the popup, you can use it to
	83	# 'select' the current item.
	84	def SetStringValue(self, val):
	85	self.log.write("ListCtrlComboPopup.SetStringValue")
	86	idx = self.FindItem(-1, val)
	87	if idx != wx.NOT_FOUND:
	88	self.Select(idx)
	89
	90	# Return a string representation of the current item.
	91	def GetStringValue(self):
	92	self.log.write("ListCtrlComboPopup.GetStringValue")
	93	if self.value >= 0:
	94	return self.GetItemText(self.value)
	95	return ""
	96
	97	# Called immediately after the popup is shown
	98	def OnPopup(self):
	99	self.log.write("ListCtrlComboPopup.OnPopup")
	100	wx.combo.ComboPopup.OnPopup(self)
	101
	102	# Called when popup is dismissed
	103	def OnDismiss(self):
	104	self.log.write("ListCtrlComboPopup.OnDismiss")
	105	wx.combo.ComboPopup.OnDismiss(self)
	106
	107	# This is called to custom paint in the combo control itself
	108	# (ie. not the popup). Default implementation draws value as
	109	# string.
	110	def PaintComboControl(self, dc, rect):
	111	self.log.write("ListCtrlComboPopup.PaintComboControl")
	112	wx.combo.ComboPopup.PaintComboControl(self, dc, rect)
	113
	114	# Receives key events from the parent ComboCtrl. Events not
	115	# handled should be skipped, as usual.
	116	def OnComboKeyEvent(self, event):
	117	self.log.write("ListCtrlComboPopup.OnComboKeyEvent")
	118	wx.combo.ComboPopup.OnComboKeyEvent(self, event)
	119
	120	# Implement if you need to support special action when user
	121	# double-clicks on the parent wxComboCtrl.
	122	def OnComboDoubleClick(self):
	123	self.log.write("ListCtrlComboPopup.OnComboDoubleClick")
	124	wx.combo.ComboPopup.OnComboDoubleClick(self)
	125
	126	# Return final size of popup. Called on every popup, just prior to OnPopup.
	127	# minWidth = preferred minimum width for window
	128	# prefHeight = preferred height. Only applies if > 0,
	129	# maxHeight = max height for window, as limited by screen size
	130	# and should only be rounded down, if necessary.
	131	def GetAdjustedSize(self, minWidth, prefHeight, maxHeight):
	132	self.log.write("ListCtrlComboPopup.GetAdjustedSize: %d, %d, %d" % (minWidth, prefHeight, maxHeight))
	133	return wx.combo.ComboPopup.GetAdjustedSize(self, minWidth, prefHeight, maxHeight)
	134
	135	# Return true if you want delay the call to Create until the popup
136	# is shown for the first time. It is more efficient, but note that
137	# it is often more convenient to have the control created
138	# immediately.
139	# Default returns false.
140	def LazyCreate(self):
141	self.log.write("ListCtrlComboPopup.LazyCreate")
142	return wx.combo.ComboPopup.LazyCreate(self)
143
144
145
146	#----------------------------------------------------------------------
147	# This class is a popup containing a TreeCtrl. This time we'll use a
148	# has-a style (instead of is-a like above.)
149
150	class TreeCtrlComboPopup(wx.combo.ComboPopup):
151
152	# overridden ComboPopup methods
153
154	def Init(self):
155	self.value = None
156	self.curitem = None
157
158
159	def Create(self, parent):
160	self.tree = wx.TreeCtrl(parent, style=wx.TR_HIDE_ROOT
161	\|wx.TR_HAS_BUTTONS
162	\|wx.TR_SINGLE
163	\|wx.TR_LINES_AT_ROOT
164	\|wx.SIMPLE_BORDER)
165	self.tree.Bind(wx.EVT_MOTION, self.OnMotion)
166	self.tree.Bind(wx.EVT_LEFT_DOWN, self.OnLeftDown)
167
168
169	def GetControl(self):
170	return self.tree
171
172
173	def GetStringValue(self):
174	if self.value:
175	return self.tree.GetItemText(self.value)
176	return ""
177
178
179	def OnPopup(self):
180	if self.value:
181	self.tree.EnsureVisible(self.value)
182	self.tree.SelectItem(self.value)
183
184
185	def SetStringValue(self, value):
186	# this assumes that item strings are unique...
187	root = self.tree.GetRootItem()
188	if not root:
189	return
190	found = self.FindItem(root, value)
191	if found:
192	self.value = found
193	self.tree.SelectItem(found)
194
195
196	def GetAdjustedSize(self, minWidth, prefHeight, maxHeight):
197	return wx.Size(minWidth, min(200, maxHeight))
198
199
200	# helpers
201
202	def FindItem(self, parentItem, text):
203	item, cookie = self.tree.GetFirstChild(parentItem)
204	while item:
205	if self.tree.GetItemText(item) == text:
206	return item
207	if self.tree.ItemHasChildren(item):
208	item = self.FindItem(item, text)
209	item, cookie = self.tree.GetNextChild(parentItem, cookie)
210	return wx.TreeItemId();
211
212
213	def AddItem(self, value, parent=None):
214	if not parent:
215	root = self.tree.GetRootItem()
216	if not root:
217	root = self.tree.AddRoot("<hidden root>")
218	parent = root
219
220	item = self.tree.AppendItem(parent, value)
221	return item
222
223
224	def OnMotion(self, evt):
225	# have the selection follow the mouse, like in a real combobox
226	item, flags = self.tree.HitTest(evt.GetPosition())
227	if item and flags & wx.TREE_HITTEST_ONITEMLABEL:
228	self.tree.SelectItem(item)
229	self.curitem = item
230	evt.Skip()
231
232
233	def OnLeftDown(self, evt):
234	# do the combobox selection
235	item, flags = self.tree.HitTest(evt.GetPosition())
236	if item and flags & wx.TREE_HITTEST_ONITEMLABEL:
237	self.curitem = item
238	self.value = item
239	self.Dismiss()
240	evt.Skip()
241
242
243	#----------------------------------------------------------------------
244	# Here we subclass wx.combo.ComboCtrl to do some custom popup animation
245
246	CUSTOM_COMBOBOX_ANIMATION_DURATION = 200
247
248	class ComboCtrlWithCustomPopupAnim(wx.combo.ComboCtrl):
249	def __init__(self, args, *kw):
250	wx.combo.ComboCtrl.__init__(self, args, *kw)
251	self.Bind(wx.EVT_TIMER, self.OnTimer)
252	self.aniTimer = wx.Timer(self)
253
254
255	def AnimateShow(self, rect, flags):
256	self.aniStart = wx.GetLocalTimeMillis()
257	self.aniRect = wx.Rect(*rect)
258	self.aniFlags = flags
259
260	dc = wx.ScreenDC()
261	bmp = wx.EmptyBitmap(rect.width, rect.height)
262	mdc = wx.MemoryDC(bmp)
800bd336 RD	263	if "wxMac" in wx.PlatformInfo:
	264	pass
	265	else:
	266	mdc.Blit(0, 0, rect.width, rect.height, dc, rect.x, rect.y)
84bc0d49 RD	267	del mdc
	268	self.aniBackBitmap = bmp
	269
	270	self.aniTimer.Start(10, wx.TIMER_CONTINUOUS)
	271	self.OnTimer(None)
	272	return False
	273
	274
	275	def OnTimer(self, evt):
	276	stopTimer = False
	277	popup = self.GetPopupControl().GetControl()
	278	rect = self.aniRect
	279	dc = wx.ScreenDC()
	280
	281	if self.IsPopupWindowState(self.Hidden):
	282	stopTimer = True
	283	else:
	284	pos = wx.GetLocalTimeMillis() - self.aniStart
	285	if pos < CUSTOM_COMBOBOX_ANIMATION_DURATION:
	286	# Actual animation happens here
	287	width = rect.width
	288	height = rect.height
	289
	290	center_x = rect.x + (width/2)
	291	center_y = rect.y + (height/2)
	292
	293	dc.SetPen( wx.BLACK_PEN )
	294	dc.SetBrush( wx.TRANSPARENT_BRUSH )
	295
	296	w = (((pos256)/CUSTOM_COMBOBOX_ANIMATION_DURATION)width)/256
	297	ratio = float(w) / float(width)
	298	h = int(height * ratio)
	299
	300	dc.DrawBitmap( self.aniBackBitmap, rect.x, rect.y )
	301	dc.DrawRectangle( center_x - w/2, center_y - h/2, w, h )
	302	else:
	303	stopTimer = True
	304
	305	if stopTimer:
	306	dc.DrawBitmap( self.aniBackBitmap, rect.x, rect.y )
	307	popup.Move( (0, 0) )
	308	self.aniTimer.Stop()
	309	self.DoShowPopup( rect, self.aniFlags )
	310
	311
	312	#----------------------------------------------------------------------
	313	# FileSelectorCombo displays a dialog instead of a popup control, it
	314	# also uses a custom bitmap on the combo button.
	315
	316	class FileSelectorCombo(wx.combo.ComboCtrl):
	317	def __init__(self, args, *kw):
	318	wx.combo.ComboCtrl.__init__(self, args, *kw)
	319
	320	# make a custom bitmap showing "..."
3b339f10	321	bw, bh = 14, 16
84bc0d49 RD	322	bmp = wx.EmptyBitmap(bw,bh)
	323	dc = wx.MemoryDC(bmp)
	324
	325	# clear to a specific background colour
3b339f10	326	bgcolor = wx.Colour(255,254,255)
84bc0d49 RD	327	dc.SetBackground(wx.Brush(bgcolor))
	328	dc.Clear()
	329
	330	# draw the label onto the bitmap
	331	label = "..."
	332	font = wx.SystemSettings.GetFont(wx.SYS_DEFAULT_GUI_FONT)
	333	font.SetWeight(wx.FONTWEIGHT_BOLD)
	334	dc.SetFont(font)
	335	tw,th = dc.GetTextExtent(label)
84bc0d49 RD	336	dc.DrawText(label, (bw-tw)/2, (bw-tw)/2)
	337	del dc
	338
	339	# now apply a mask using the bgcolor
	340	bmp.SetMaskColour(bgcolor)
	341
	342	# and tell the ComboCtrl to use it
	343	self.SetButtonBitmaps(bmp, True)
	344
	345
	346	# Overridden from ComboCtrl, called when the combo button is clicked
	347	def OnButtonClick(self):
	348	path = ""
	349	name = ""
	350	if self.GetValue():
	351	path, name = os.path.split(self.GetValue())
	352
	353	dlg = wx.FileDialog(self, "Choose File", path, name,
	354	"All files (.)\|.", wx.FD_OPEN)
	355	if dlg.ShowModal() == wx.ID_OK:
	356	self.SetValue(dlg.GetPath())
	357	dlg.Destroy()
800bd336	358	self.SetFocus()
84bc0d49 RD	359
	360	# Overridden from ComboCtrl to avoid assert since there is no ComboPopup
	361	def DoSetPopupControl(self, popup):
	362	pass
	363
	364
	365	#----------------------------------------------------------------------
	366
	367
	368	class TestPanel(wx.Panel):
	369	def __init__(self, parent, log):
	370	self.log = log
	371	wx.Panel.__init__(self, parent, -1)
	372
	373	fgs = wx.FlexGridSizer(cols=3, hgap=10, vgap=10)
	374
	375	cc = self.MakeLCCombo(log=self.log)
	376	fgs.Add(cc)
	377	fgs.Add((10,10))
	378	fgs.Add(wx.StaticText(self, -1, "wx.ComboCtrl with a ListCtrl popup"))
	379
	380	cc = self.MakeLCCombo(style=wx.CB_READONLY)
	381	fgs.Add(cc)
	382	fgs.Add((10,10))
	383	fgs.Add(wx.StaticText(self, -1, " Read-only"))
	384
	385	cc = self.MakeLCCombo()
	386	cc.SetButtonPosition(side=wx.LEFT)
	387	fgs.Add(cc)
	388	fgs.Add((10,10))
	389	fgs.Add(wx.StaticText(self, -1, " Button on the left"))
	390
	391	cc = self.MakeLCCombo()
	392	cc.SetPopupMaxHeight(250)
	393	fgs.Add(cc)
	394	fgs.Add((10,10))
	395	fgs.Add(wx.StaticText(self, -1, " Max height of popup set"))
	396
	397	cc = wx.combo.ComboCtrl(self, size=(250,-1))
	398	tcp = TreeCtrlComboPopup()
	399	cc.SetPopupControl(tcp)
	400	fgs.Add(cc)
	401	fgs.Add((10,10))
	402	fgs.Add(wx.StaticText(self, -1, "TreeCtrl popup"))
	403	# add some items to the tree
	404	for i in range(5):
	405	item = tcp.AddItem('Item %d' % (i+1))
	406	for j in range(15):
	407	tcp.AddItem('Subitem %d-%d' % (i+1, j+1), parent=item)
	408
	409	cc = ComboCtrlWithCustomPopupAnim(self, size=(250, -1))
	410	popup = ListCtrlComboPopup()
	411	cc.SetPopupMaxHeight(150)
	412	cc.SetPopupControl(popup)
	413	fgs.Add(cc)
	414	fgs.Add((10,10))
	415	fgs.Add(wx.StaticText(self, -1, "Custom popup animation"))
	416	for word in "How cool was that!? Way COOL!".split():
	417	popup.AddItem(word)
800bd336 RD	418	if "wxMac" in wx.PlatformInfo:
800bd336 RD	419	cc.SetValue("Sorry, animation not working yet on Mac")
84bc0d49 RD	420
	421
	422	cc = FileSelectorCombo(self, size=(250, -1))
	423	fgs.Add(cc)
	424	fgs.Add((10,10))
	425	fgs.Add(wx.StaticText(self, -1, "Custom popup action, and custom button bitmap"))
84bc0d49 RD	426
	427	box = wx.BoxSizer()
	428	box.Add(fgs, 1, wx.EXPAND\|wx.ALL, 20)
	429	self.SetSizer(box)
	430
	431
	432	def MakeLCCombo(self, log=None, style=0):
	433	# Create a ComboCtrl
	434	cc = wx.combo.ComboCtrl(self, style=style, size=(250,-1))
	435
	436	# Create a Popup
	437	popup = ListCtrlComboPopup(log)
	438
	439	# Associate them with each other. This also triggers the
	440	# creation of the ListCtrl.
	441	cc.SetPopupControl(popup)
	442
	443	# Add some items to the listctrl.
	444	for x in range(75):
	445	popup.AddItem("Item-%02d" % x)
	446
	447	return cc
	448
	449
	450	#----------------------------------------------------------------------
	451
	452	def runTest(frame, nb, log):
	453	win = TestPanel(nb, log)
	454	return win
	455
	456	#----------------------------------------------------------------------
	457
	458
	459
	460	overview = """<html><body>
	461	<h2><center>wx.combo.ComboCtrl</center></h2>
	462
3b339f10 RD	463	A combo control is a generic combobox that allows a totally custom
	464	popup. In addition it has other customization features. For instance,
	465	position and size of the dropdown button can be changed.
	466
84bc0d49 RD	467	</body></html>
	468	"""
	469
	470
	471
	472	if __name__ == '__main__':
	473	import sys,os
	474	import run
	475	run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])