1 

     2 '''

     3 

     4 wxPython Custom Widget Collection 20060207

     5 Written By: Edward Flick (eddy -=at=- cdf-imaging -=dot=- com)

     6             Michele Petrazzo (michele -=dot=- petrazzo -=at=- unipex -=dot=- it)

     7             Will Sadkin (wsadkin-=at=- nameconnector -=dot=- com)

     8 Copyright 2006 (c) CDF Inc. ( http://www.cdf-imaging.com )

     9 Contributed to the wxPython project under the wxPython project's license.

    10 

    11 '''

    12 

    13 import locale, wx, sys, cStringIO

    14 

    15 import  wx.lib.mixins.listctrl  as  listmix

    16 import cPickle

    17 from wx import ImageFromStream, BitmapFromImage

    18 #----------------------------------------------------------------------

    19 def getSmallUpArrowData():

    20     return \

    21 '\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x10\x08\x06\

    22 \x00\x00\x00\x1f\xf3\xffa\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\

    23 \x00\x00<IDAT8\x8dcddbf\xa0\x040Q\xa4{h\x18\xf0\xff\xdf\xdf\xffd\x1b\x00\xd3\

    24 \x8c\xcf\x10\x9c\x06\xa0k\xc2e\x08m\xc2\x00\x97m\xd8\xc41\x0c \x14h\xe8\xf2\

    25 \x8c\xa3)q\x10\x18\x00\x00R\xd8#\xec\xb2\xcd\xc1Y\x00\x00\x00\x00IEND\xaeB`\

    26 \x82'

    27 

    28 def getSmallUpArrowBitmap():

    29     return BitmapFromImage(getSmallUpArrowImage())

    30 

    31 def getSmallUpArrowImage():

    32     stream = cStringIO.StringIO(getSmallUpArrowData())

    33     return ImageFromStream(stream)

    34 

    35 

    36 def getSmallDnArrowData():

    37     return \

    38 "\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x10\x00\x00\x00\x10\x08\x06\

    39 \x00\x00\x00\x1f\xf3\xffa\x00\x00\x00\x04sBIT\x08\x08\x08\x08|\x08d\x88\x00\

    40 \x00\x00HIDAT8\x8dcddbf\xa0\x040Q\xa4{\xd4\x00\x06\x06\x06\x06\x06\x16t\x81\

    41 \xff\xff\xfe\xfe'\xa4\x89\x91\x89\x99\x11\xa7\x0b\x90%\ti\xc6j\x00>C\xb0\x89\

    42 \xd3.\x10\xd1m\xc3\xe5*\xbc.\x80i\xc2\x17.\x8c\xa3y\x81\x01\x00\xa1\x0e\x04e\

    43 ?\x84B\xef\x00\x00\x00\x00IEND\xaeB`\x82"

    44 

    45 def getSmallDnArrowBitmap():

    46     return BitmapFromImage(getSmallDnArrowImage())

    47 

    48 def getSmallDnArrowImage():

    49     stream = cStringIO.StringIO(getSmallDnArrowData())

    50     return ImageFromStream(stream)

    51 #----------------------------------------------------------------------

    52 

    53 class myListCtrl(wx.ListCtrl, listmix.ListCtrlAutoWidthMixin):

    54     def __init__(self, parent, ID=-1, pos=wx.DefaultPosition,

    55                  size=wx.DefaultSize, style=0):

    56         wx.ListCtrl.__init__(self, parent, ID, pos, size, style)

    57         listmix.ListCtrlAutoWidthMixin.__init__(self)

    58 

    59 class TextCtrlAutoComplete (wx.TextCtrl, listmix.ColumnSorterMixin ):

    60 

    61     def __init__ ( self, parent, colNames=None, choices = None,

    62                   multiChoices=None, showHead=True, dropDownClick=True,

    63                   colFetch=-1, colSearch=0, hideOnNoMatch=True,

    64                   selectCallback=None, entryCallback=None, matchFunction=None,

    65                   element_path=None, **therest) :

    66         '''

    67         Constructor works just like wx.TextCtrl except you can pass in a

    68         list of choices.  You can also change the choice list at any time

    69         by calling setChoices.

    70         '''

    71 

    72         if therest.has_key('style'):

    73             therest['style']=wx.TE_PROCESS_ENTER | therest['style']

    74         else:

    75             therest['style']=wx.TE_PROCESS_ENTER

    76 

    77         wx.TextCtrl.__init__(self, parent, **therest )

    78 

    79         #Some variables

    80         self._dropDownClick = dropDownClick

    81         self._colNames = colNames

    82         self._multiChoices = multiChoices

    83         self._showHead = showHead

    84         self._choices = choices

    85         self._lastinsertionpoint = 0

    86         self._hideOnNoMatch = hideOnNoMatch

    87         self._selectCallback = selectCallback

    88         self._entryCallback = entryCallback

    89         self._matchFunction = matchFunction

    90 

    91         self._screenheight = wx.SystemSettings.GetMetric( wx.SYS_SCREEN_Y )

    92         self.element_path = element_path

    93         #sort variable needed by listmix

    94         self.itemDataMap = dict()

    95 

    96         #widgets

    97         self.dropdown = wx.PopupWindow( self )

    98 

    99         #Control the style

   100         flags = wx.LC_REPORT | wx.LC_SINGLE_SEL | wx.LC_SORT_ASCENDING

   101         if not (showHead and multiChoices) :

   102             flags = flags | wx.LC_NO_HEADER

   103 

   104         #Create the list and bind the events

   105         self.dropdownlistbox = myListCtrl( self.dropdown, style=flags,

   106                                  pos=wx.Point( 0, 0) )

   107 

   108         #initialize the parent

   109         if multiChoices: ln = len(multiChoices)

   110         else: ln = 1

   111         #else: ln = len(choices)

   112         listmix.ColumnSorterMixin.__init__(self, ln)

   113 

   114         #load the data

   115         if multiChoices: self.SetMultipleChoices (multiChoices, colSearch=colSearch, colFetch=colFetch)

   116         else: self.SetChoices ( choices )

   117 

   118         #gp = self

   119         #while ( gp != None ) :

   120         #    gp.Bind ( wx.EVT_MOVE , self.onControlChanged, gp )

   121         #    gp.Bind ( wx.EVT_SIZE , self.onControlChanged, gp )

   122         #    gp = gp.GetParent()

   123 

   124         self.Bind( wx.EVT_KILL_FOCUS, self.onControlChanged, self )

   125         self.Bind( wx.EVT_TEXT , self.onEnteredText, self )

   126         self.Bind( wx.EVT_KEY_DOWN , self.onKeyDown, self )

   127 

   128         #If need drop down on left click

   129         if dropDownClick:

   130             self.Bind ( wx.EVT_LEFT_DOWN , self.onClickToggleDown, self )

   131             self.Bind ( wx.EVT_LEFT_UP , self.onClickToggleUp, self )

   132 

   133         self.dropdown.Bind( wx.EVT_LISTBOX , self.onListItemSelected, self.dropdownlistbox )

   134         self.dropdownlistbox.Bind(wx.EVT_LEFT_DOWN, self.onListClick)

   135         self.dropdownlistbox.Bind(wx.EVT_LEFT_DCLICK, self.onListDClick)

   136         self.dropdownlistbox.Bind(wx.EVT_LIST_COL_CLICK, self.onListColClick)

   137 

   138         self.il = wx.ImageList(16, 16)

   139 

   140         self.sm_dn = self.il.Add(getSmallDnArrowBitmap())

   141         self.sm_up = self.il.Add(getSmallUpArrowBitmap())

   142 

   143         self.dropdownlistbox.SetImageList(self.il, wx.IMAGE_LIST_SMALL)

   144         self._ascending = True

   145 

   146 

   147     #-- methods called from mixin class

   148     def GetSortImages(self):

   149         return (self.sm_dn, self.sm_up)

   150 

   151     def GetListCtrl(self):

   152         return self.dropdownlistbox

   153 

   154     # -- event methods

   155     def onListClick(self, evt):

   156         toSel, flag = self.dropdownlistbox.HitTest( evt.GetPosition() )

   157         #no values on poition, return

   158         if toSel == -1: return

   159         self.dropdownlistbox.Select(toSel)

   160 

   161     def onListDClick(self, evt):

   162         self._setValueFromSelected()

   163 

   164     def onListColClick(self, evt):

   165         col = evt.GetColumn()

   166 

   167         #reverse the sort

   168         if col == self._colSearch:

   169             self._ascending = not self._ascending

   170 

   171         self.SortListItems( evt.GetColumn(), ascending=self._ascending )

   172         self._colSearch = evt.GetColumn()

   173         evt.Skip()

   174 

   175     def onEnteredText(self, event):

   176         text = event.GetString()

   177 

   178         if self._entryCallback:

   179             self._entryCallback()

   180 

   181         if not text:

   182             # control is empty; hide dropdown if shown:

   183             if self.dropdown.IsShown():

   184                 self._showDropDown(False)

   185             event.Skip()

   186             return

   187 

   188 

   189         found = False

   190         if self._multiChoices:

   191             #load the sorted data into the listbox

   192             dd = self.dropdownlistbox

   193             choices = [dd.GetItem(x, self._colSearch).GetText()

   194                 for x in xrange(dd.GetItemCount())]

   195         else:

   196             choices = self._choices

   197 

   198         for numCh, choice in enumerate(choices):

   199             if self._matchFunction and self._matchFunction(text, choice):

   200                 found = True

   201             elif choice.lower().startswith(text.lower()) :

   202                 found = True

   203             if found:

   204                 self._showDropDown(True)

   205                 item = self.dropdownlistbox.GetItem(numCh)

   206                 toSel = item.GetId()

   207                 self.dropdownlistbox.Select(toSel)

   208                 break

   209 

   210         if not found:

   211             self.dropdownlistbox.Select(self.dropdownlistbox.GetFirstSelected(), False)

   212             if self._hideOnNoMatch:

   213                 self._showDropDown(False)

   214 

   215         self._listItemVisible()

   216 

   217         event.Skip ()

   218 

   219     def onKeyDown ( self, event ) :

   220         """ Do some work when the user press on the keys:

   221             up and down: move the cursor

   222             left and right: move the search

   223         """

   224         skip = True

   225         sel = self.dropdownlistbox.GetFirstSelected()

   226         visible = self.dropdown.IsShown()

   227 

   228         KC = event.GetKeyCode()

   229         if KC == wx.WXK_DOWN :

   230             if sel < (self.dropdownlistbox.GetItemCount () - 1) :

   231                 self.dropdownlistbox.Select ( sel+1 )

   232                 self._listItemVisible()

   233             self._showDropDown ()

   234             skip = False

   235         elif KC == wx.WXK_UP :

   236             if sel > 0 :

   237                 self.dropdownlistbox.Select ( sel - 1 )

   238                 self._listItemVisible()

   239             self._showDropDown ()

   240             skip = False

   241         elif KC == wx.WXK_LEFT :

   242             if not self._multiChoices: return

   243             if self._colSearch > 0:

   244                 self._colSearch -=1

   245             self._showDropDown ()

   246         elif KC == wx.WXK_RIGHT:

   247             if not self._multiChoices: return

   248             if self._colSearch < self.dropdownlistbox.GetColumnCount() -1:

   249                 self._colSearch += 1

   250             self._showDropDown()

   251 

   252         if visible :

   253             if event.GetKeyCode() == wx.WXK_RETURN :

   254                 self._setValueFromSelected()

   255                 skip = False

   256             if event.GetKeyCode() == wx.WXK_ESCAPE :

   257                 self._showDropDown( False )

   258                 skip = False

   259         if skip :

   260             event.Skip()

   261 

   262     def onListItemSelected (self, event):

   263         self._setValueFromSelected()

   264         event.Skip()

   265 

   266     def onClickToggleDown(self, event):

   267         self._lastinsertionpoint = self.GetInsertionPoint()

   268         event.Skip ()

   269 

   270     def onClickToggleUp ( self, event ) :

   271         if ( self.GetInsertionPoint() == self._lastinsertionpoint ) :

   272             self._showDropDown ( not self.dropdown.IsShown() )

   273         event.Skip ()

   274 

   275     def onControlChanged(self, event):

   276         res = self.GetValue()

   277         config = wx.ConfigBase.Get()

   278         listentries = cPickle.loads(str(config.Read(self.element_path, cPickle.dumps([]))))

   279         if len(res) and res not in listentries:

   280             config.Write(self.element_path, cPickle.dumps((listentries + [res])[-10:]))

   281             config.Flush()

   282             self.SetChoices((listentries + [res])[-10:])

   283         self._showDropDown( False )

   284         event.Skip()

   285 

   286 

   287     # -- Interfaces methods

   288     def SetMultipleChoices(self, choices, colSearch=0, colFetch=-1):

   289         ''' Set multi-column choice

   290         '''

   291         self._multiChoices = choices

   292         self._choices = None

   293         if not isinstance(self._multiChoices, list):

   294             self._multiChoices = [ x for x in self._multiChoices]

   295 

   296         flags = wx.LC_REPORT | wx.LC_SINGLE_SEL | wx.LC_SORT_ASCENDING

   297         if not self._showHead:

   298             flags |= wx.LC_NO_HEADER

   299         self.dropdownlistbox.SetWindowStyleFlag(flags)

   300 

   301         #prevent errors on "old" systems

   302         if sys.version.startswith("2.3"):

   303             self._multiChoices.sort(lambda x, y: cmp(x[0].lower(), y[0].lower()))

   304         else:

   305             self._multiChoices.sort(key=lambda x: locale.strxfrm(x[0]).lower() )

   306 

   307         self._updateDataList(self._multiChoices)

   308 

   309         lChoices = len(choices)

   310         if lChoices < 2:

   311             raise ValueError, "You have to pass me a multi-dimension list"

   312 

   313         for numCol, rowValues in enumerate(choices[0]):

   314 

   315             if self._colNames: colName = self._colNames[numCol]

   316             else: colName = "Select %i" % numCol

   317 

   318             self.dropdownlistbox.InsertColumn(numCol, colName)

   319 

   320         for numRow, valRow in enumerate(choices):

   321 

   322             for numCol, colVal in enumerate(valRow):

   323                 if numCol == 0:

   324                     index = self.dropdownlistbox.InsertImageStringItem(sys.maxint, colVal, -1)

   325                 self.dropdownlistbox.SetStringItem(index, numCol, colVal)

   326                 self.dropdownlistbox.SetItemData(index, numRow)

   327 

   328         self._setListSize()

   329         self._colSearch = colSearch

   330         self._colFetch = colFetch

   331 

   332     def SetChoices(self, choices):

   333         '''

   334         Sets the choices available in the popup wx.ListBox.

   335         The items will be sorted case insensitively.

   336         '''

   337         self._choices = choices

   338         self._multiChoices = None

   339         flags = wx.LC_REPORT | wx.LC_SINGLE_SEL | wx.LC_SORT_ASCENDING | wx.LC_NO_HEADER

   340         self.dropdownlistbox.SetWindowStyleFlag(flags)

   341                 

   342         #if not isinstance(choices, list):

   343         #    self._choices = [ x for x in choices if len(x)]

   344         self._choices = [ x for x in choices if len(x)]

   345         #prevent errors on "old" systems

   346         if sys.version.startswith("2.3"):

   347             self._choices.sort(lambda x, y: cmp(x.lower(), y.lower()))

   348         else:

   349             self._choices.sort(key=lambda x: locale.strxfrm(x).lower())

   350 

   351         self._updateDataList(self._choices)

   352 

   353         self.dropdownlistbox.InsertColumn(0, "")

   354 

   355         for num, colVal in enumerate(self._choices):

   356             index = self.dropdownlistbox.InsertImageStringItem(sys.maxint, colVal, -1)

   357 

   358             self.dropdownlistbox.SetStringItem(index, 0, colVal)

   359             self.dropdownlistbox.SetItemData(index, num)

   360 

   361         self._setListSize()

   362 

   363         # there is only one choice for both search and fetch if setting a single column:

   364         self._colSearch = 0

   365         self._colFetch = -1

   366 

   367     def GetChoices(self):

   368         if self._choices:

   369             return self._choices

   370         else:

   371             return self._multiChoices

   372 

   373     def SetSelectCallback(self, cb=None):

   374         self._selectCallback = cb

   375 

   376     def SetEntryCallback(self, cb=None):

   377         self._entryCallback = cb

   378 

   379     def SetMatchFunction(self, mf=None):

   380         self._matchFunction = mf

   381 

   382 

   383     #-- Internal methods

   384     def _setValueFromSelected( self ) :

   385          '''

   386          Sets the wx.TextCtrl value from the selected wx.ListCtrl item.

   387          Will do nothing if no item is selected in the wx.ListCtrl.

   388          '''

   389          sel = self.dropdownlistbox.GetFirstSelected()

   390          if sel > -1:

   391             if self._colFetch != -1: col = self._colFetch

   392             else: col = self._colSearch

   393 

   394             itemtext = self.dropdownlistbox.GetItem(sel, col).GetText()

   395             if self._selectCallback:

   396                 dd = self.dropdownlistbox

   397                 values = [dd.GetItem(sel, x).GetText()

   398                     for x in xrange(dd.GetColumnCount())]

   399                 self._selectCallback( values )

   400 

   401             self.SetValue (itemtext)

   402             self.SetInsertionPointEnd ()

   403             self.SetSelection ( -1, -1 )

   404             self._showDropDown ( False )

   405 

   406 

   407     def _showDropDown ( self, show = True ) :

   408         '''

   409         Either display the drop down list (show = True) or hide it (show = False).

   410         '''

   411         if show :

   412             size = self.dropdown.GetSize()

   413             width, height = self . GetSizeTuple()

   414             x, y = self . ClientToScreenXY ( 0, height )

   415             if size.GetWidth() != width :

   416                 size.SetWidth(width)

   417                 self.dropdown.SetSize(size)

   418                 self.dropdownlistbox.SetSize(self.dropdown.GetClientSize())

   419             if (y + size.GetHeight()) < self._screenheight :

   420                 self.dropdown . SetPosition ( wx.Point(x, y) )

   421             else:

   422                 self.dropdown . SetPosition ( wx.Point(x, y - height - size.GetHeight()) )

   423         self.dropdown.Show ( show )

   424 

   425     def _listItemVisible( self ) :

   426         '''

   427         Moves the selected item to the top of the list ensuring it is always visible.

   428         '''

   429         toSel =  self.dropdownlistbox.GetFirstSelected ()

   430         if toSel == -1: return

   431         self.dropdownlistbox.EnsureVisible( toSel )

   432 

   433     def _updateDataList(self, choices):

   434         #delete, if need, all the previous data

   435         if self.dropdownlistbox.GetColumnCount() != 0:

   436             self.dropdownlistbox.DeleteAllColumns()

   437             self.dropdownlistbox.DeleteAllItems()

   438 

   439         #and update the dict

   440         if choices:

   441             for numVal, data in enumerate(choices):

   442                 self.itemDataMap[numVal] = data

   443         else:

   444             numVal = 0

   445         self.SetColumnCount(numVal)

   446 

   447     def _setListSize(self):

   448         if self._multiChoices:

   449             choices = self._multiChoices

   450         else:

   451             choices = self._choices

   452 

   453         longest = 0

   454         for choice in choices :

   455             longest = max(len(choice), longest)

   456 

   457         longest += 3

   458         itemcount = min( len( choices ) , 7 ) + 2

   459         charheight = self.dropdownlistbox.GetCharHeight()

   460         charwidth = self.dropdownlistbox.GetCharWidth()

   461         self.popupsize = wx.Size( charwidth*longest, charheight*itemcount )

   462         self.dropdownlistbox.SetSize ( self.popupsize )

   463         self.dropdown.SetClientSize( self.popupsize )

   464 

   465     

   466 

   467 

   468 class test:

   469     def __init__(self):

   470         args = dict()

   471         if 1:

   472             args["colNames"] = ("col1", "col2")

   473             args["multiChoices"] = [ ("Zoey","WOW"), ("Alpha", "wxPython"),

   474                                     ("Ceda","Is"), ("Beta", "fantastic"),

   475                                     ("zoebob", "!!")]

   476             args["colFetch"] = 1

   477         else:

   478             args["choices"] = ["123", "cs", "cds", "Bob","Marley","Alpha"]

   479 

   480         args["selectCallback"] = self.selectCallback

   481 

   482         self.dynamic_choices = [

   483                         'aardvark', 'abandon', 'acorn', 'acute', 'adore',

   484                         'aegis', 'ascertain', 'asteroid',

   485                         'beautiful', 'bold', 'classic',

   486                         'daring', 'dazzling', 'debonair', 'definitive',

   487                         'effective', 'elegant',

   488                         'http://python.org', 'http://www.google.com',

   489                         'fabulous', 'fantastic', 'friendly', 'forgiving', 'feature',

   490                         'sage', 'scarlet', 'scenic', 'seaside', 'showpiece', 'spiffy',

   491                         'www.wxPython.org', 'www.osafoundation.org'

   492                         ]

   493 

   494 

   495         app = wx.PySimpleApp()

   496         frm = wx.Frame(None,-1,"Test",style=wx.TAB_TRAVERSAL|wx.DEFAULT_FRAME_STYLE)

   497         panel = wx.Panel(frm)

   498         sizer = wx.BoxSizer(wx.VERTICAL)

   499 

   500         self._ctrl = TextCtrlAutoComplete(panel, **args)

   501         but = wx.Button(panel,label="Set other multi-choice")

   502         but.Bind(wx.EVT_BUTTON, self.onBtMultiChoice)

   503         but2 = wx.Button(panel,label="Set other one-colum choice")

   504         but2.Bind(wx.EVT_BUTTON, self.onBtChangeChoice)

   505         but3 = wx.Button(panel,label="Set the starting choices")

   506         but3.Bind(wx.EVT_BUTTON, self.onBtStartChoices)

   507         but4 = wx.Button(panel,label="Enable dynamic choices")

   508         but4.Bind(wx.EVT_BUTTON, self.onBtDynamicChoices)

   509 

   510         sizer.Add(but, 0, wx.ADJUST_MINSIZE, 0)

   511         sizer.Add(but2, 0, wx.ADJUST_MINSIZE, 0)

   512         sizer.Add(but3, 0, wx.ADJUST_MINSIZE, 0)

   513         sizer.Add(but4, 0, wx.ADJUST_MINSIZE, 0)

   514         sizer.Add(self._ctrl, 0, wx.EXPAND|wx.ADJUST_MINSIZE, 0)

   515         panel.SetAutoLayout(True)

   516         panel.SetSizer(sizer)

   517         sizer.Fit(panel)

   518         sizer.SetSizeHints(panel)

   519         panel.Layout()

   520         app.SetTopWindow(frm)

   521         frm.Show()

   522         but.SetFocus()

   523         app.MainLoop()

   524 

   525     def onBtChangeChoice(self, event):

   526         #change the choices

   527         self._ctrl.SetChoices(["123", "cs", "cds", "Bob","Marley","Alpha"])

   528         self._ctrl.SetEntryCallback(None)

   529         self._ctrl.SetMatchFunction(None)

   530 

   531     def onBtMultiChoice(self, event):

   532         #change the choices

   533         self._ctrl.SetMultipleChoices( [ ("Test","Hello"), ("Other word","World"),

   534                                         ("Yes!","it work?") ], colFetch = 1 )

   535         self._ctrl.SetEntryCallback(None)

   536         self._ctrl.SetMatchFunction(None)

   537 

   538     def onBtStartChoices(self, event):

   539         #change the choices

   540         self._ctrl.SetMultipleChoices( [ ("Zoey","WOW"), ("Alpha", "wxPython"),

   541                                     ("Ceda","Is"), ("Beta", "fantastic"),

   542                                     ("zoebob", "!!")], colFetch = 1 )

   543         self._ctrl.SetEntryCallback(None)

   544         self._ctrl.SetMatchFunction(None)

   545 

   546     def onBtDynamicChoices(self, event):

   547         '''

   548         Demonstrate dynamic adjustment of the auto-complete list, based on what's

   549         been typed so far:

   550         '''

   551         self._ctrl.SetChoices(self.dynamic_choices)

   552         self._ctrl.SetEntryCallback(self.setDynamicChoices)

   553         self._ctrl.SetMatchFunction(self.match)

   554 

   555 

   556     def match(self, text, choice):

   557         '''

   558         Demonstrate "smart" matching feature, by ignoring http:// and www. when doing

   559         matches.

   560         '''

   561         t = text.lower()

   562         c = choice.lower()

   563         if c.startswith(t): return True

   564         if c.startswith(r'http://'): c = c[7:]

   565         if c.startswith(t): return True

   566         if c.startswith('www.'): c = c[4:]

   567         return c.startswith(t)

   568 

   569     def setDynamicChoices(self):

   570         ctrl = self._ctrl

   571         text = ctrl.GetValue().lower()

   572         current_choices = ctrl.GetChoices()

   573         choices = [choice for choice in self.dynamic_choices if self.match(text, choice)]

   574         if choices != current_choices:

   575             ctrl.SetChoices(choices)

   576 

   577     def selectCallback(self, values):

   578         """ Simply function that receive the row values when the

   579             user select an item

   580         """

   581         print "Select Callback called...:",  values

   582 

   583 

   584 if __name__ == "__main__":

   585     test()

   586