Bengt Richter wrote:

>  On Sun, 14 Jul 2002 13:17:09 +0200, JB
>  <jblazi@[...].com> wrote:
>  
> >Bengt Richter wrote:
> >
>  [...]
> >> (Is this like your data? Or how does it differ?)
> >
> >This is ok. The real data are much longer strings, but it
> >is ok.
>  A further question: What generates the "id" number, and
>  what do you need it for besides verifying order? Do you
>  need it as a key to other data locally or remotely? Or is
>  your concern just guaranteeing
>  unchanged order as the selection  narrows?

To tell you the truth, I do not know. Yesterday I noticed, 
that I did not need it, but it does not matter much. At the 
moment I use the following solution (it shows what I am 
after):

  #-------------------------------------------------------
  #self.rows is a list of QSimpleViewItem class 
  #instances.  The definition of this class is at the end
  #of this message. The lists <self.visible>  and
  #<self.hidden>  contain natural #numbers of the set
  #{0,1,...,N-1}, where N is the total number of elements
  #of self.rows. If we have an i with
  #0 <= i < N, then i is either in <self.visible>  or in
  #<self.hidden> .
  #-------------------------------------------------------
  # Only those rows are shown, for which the <c> -th
  # coloumn contains the string <s>  
  def filter_out(self,c,s):
    print 'filter (1)'
    tmp = []
    for v in self.visible:
      if string.find(self.rows[v].col[c],s) == -1:
        self.hidden.append(v)
      else:
        tmp.append(v)
    self.visible = tmp
    self.hidden.sort()
    print 'filter (2)'

    self.update_sb()    #update scrollbars
    self.update_view()
 #----------------------------------------------------
  def filter_in(self,c,s):
    print 'filter (1)'
    tmp = []
    for h in self.hidden:
      if string.find(self.rows[h].col[c],s) != -1:
        self.visible.append(h)
      else:
        tmp.append(h)
    self.hidden = tmp
    self.visible.sort()
    print 'filter (2)'

    self.update_sb()
    self.update_view()

So I use two functions. <filter_out>  is called when the 
search string gets longer and filter_in when it gets 
shorter. Even this is pretty fast. It seems to me that the 
append operations are expensive here (they take much time), 
but I always thought that Python lists are arrays...

>  
>  If it's just order, we can probably eliminate them, and
>  gain speed. If you need the id's, and the rest of the
>  tuple is just a single string item, then we will gain
>  speed by combining the id into the string, perhaps as a
>  suffix. The gain will come from having a list of
>  string-only elements so that we can search for substrings
>  without a subscript operation on a tuple for every
>  element, and being able to use map or filter using builtin
>  functions. This may allow simpler approaches with adequate
>  speed.

This I do not understand.

>  Well, maybe the question was a little too broad ;-)
>  My example searched first for 'B' then for 'Y' within the
>  results of the first search, but it did not search for
>  'BY'.

Oh! I do not want that.

>  This is an important distinction, since you will
>  presumably want to refine a search for, e.g., Bach by
>  incrementally refining based on 'B', 'Ba', 'Bac' and
>  'Bach', but if you want to find his Italian Concerto, you
>  don't want to continue refining results by searching them
>  for 'BachI', 'BachIt', 'Bachita', etc. I.e., you are
>  finished with Bach and should presumably refine further
>  based on 'I', 'It', 'Ita', etc. found anywhere in the
>  entries you have so far.

Or search for "italian" immediately. The QListView widget 
(if you are a bit familiar with Qt) already has an 
incremental search built in but it looks only for patterns 
the strings start with.

> >Of course, only 40 or so lines can be displayed at the
> >same time. It plays no rôle if I pass list or tuples of
> >strings.
> >
>  You mean no difference if you pass ('x','y','z') or
>  ['x','y','z']? But I was referring to tuples including the
>  integer id number. IOW, I wouldn't expect to pass
>  [(24,'x'), (25,'y'), (26,'z')] to a low level single
>  column dropdown list widget that I wanted to show x, y and
>  z. So the question is in what form your parameters need to
>  be passed.

This again I do not understand. I have defined a class:

class QSimpleViewItem:
  def __init__(self,id,color,tuple):
    self.id    = id     #for future use :)
    self.col   = tuple  #here are the strings
    self.sel   = 0      #selected or not selected
    self.color = color  #color of the line

In the <col>  tuple, I shall almost always use coloumn 2 for 
my searching. But I may want to use other colomns too.

When update_view is called, my widget takes a list of 
QSimpleViewItem-s and updates the screen.

>  As you notice, we are now a long way from discussing just
>  "Moving list entries from one list to another" ;-)

Yes, sorry.

-- 
Janos Blazi


-----------== Posted via Newsfeed.Com - Uncensored Usenet News ==----------
   http://www.newsfeed.com       The #1 Newsgroup Service in the World!
-----= Over 100,000 Newsgroups - Unlimited Fast Downloads - 19 Servers =-----
-- 
http://mail.python.org/mailman/listinfo/python-list