How to enable selection of multiple rows in Tkinter listboxes?

Question

I'm using the class below to draw scrollable tables with selectable elements. When the user clicks on one of the item I need that entire row to get highlighted (which works). But at the moment you can only select one row at a time. How to modify the code below to allow selection (and highlighting) of multiple rows at a time?

from Tkinter import *
import Tkinter as tk


class MultiListbox_fuse(Frame):
    def __init__(self,master,lists):
        Frame.__init__(self,master,borderwidth=1,relief=SUNKEN)
        self.lists = []
        self.columns=[]
        for l,w in lists:
            frame = Frame(self); frame.pack(side=LEFT, expand=YES, fill=BOTH)
            Label(frame, text=l, borderwidth=1, relief=RAISED).pack(fill=X)
            lb = Listbox(frame, width=w, height=30, borderwidth=0, selectborderwidth=0,
             relief=FLAT, exportselection=FALSE, selectmode=MULTIPLE)
            lb.pack(expand=YES, fill=BOTH)
            self.lists.append(lb)
            lb.bind('<B1-Motion>', lambda e, s=self: s._select(e.y))
            lb.bind('<Button-1>', lambda e, s=self: s._select(e.y))
            lb.bind('<Leave>', lambda e: 'break')
            lb.bind('<B2-Motion>', lambda e, s=self: s._b2motion(e.x, e.y))
            lb.bind('<Button-2>', lambda e, s=self: s._button2(e.x, e.y))
            lb.bind('&lt;Button-4>', lambda e, s=self: s._scroll(SCROLL, 1, PAGES))
            lb.bind('&lt;Button-5>', lambda e, s=self: s._scroll(SCROLL, -1, PAGES))
            lb.bind("<MouseWheel>", self.OnMouseWheel)

            #self.add(frame)
        Label(master, borderwidth=1, relief=FLAT).pack(fill=X)
        sb = Scrollbar(master, orient=VERTICAL, command=self._scroll,borderwidth=1)
        sb.pack(fill=Y,side=RIGHT,expand=NO)
        for l in self.lists:
            l['yscrollcommand']=sb.set
        #self.add(frame)
        self.pack(expand=YES,fill=BOTH)
        self.sortedBy=-1
        self.previousWheel=0


    def _select(self, y,state=16):
        row = self.lists[0].nearest(y)
        if state==16:self.selection_clear(0, END)
        self.selection_set(row)
##        print self.curselection()
        return 'break'


    def _button2(self, x, y):
        for l in self.lists: l.scan_mark(x, y)
        return 'break'


    def _b2motion(self, x, y):
        for l in self.lists: l.scan_dragto(x, y)
        return 'break'


    def _scroll(self, *args):
        for l in self.lists:
            apply(l.yview, args)
        return 'break'

    def clickon(self,e):
        self._sortBy(self.columns.index(e.widget['text']))


    def _sortBy(self, column):
        """ Sort by a given column. """


        if column == self.sortedBy:
                    direction = -1 * self.direction
        else:
            direction = 1

        elements = self.get(0, END)
        self.delete(0, END)
        elements.sort(lambda x, y: self._sortAssist(column, direction, x, y))
        self.insert(END, *elements)

        self.sortedBy = column
        self.direction = direction


    def _sortAssist(self, column, direction, x, y):
        c = cmp(x[column], y[column])
        if c:
            return direction * c
        else:
            return direction * cmp(x, y)

    def curselection(self):
        return self.lists[0].curselection()


    def delete(self, first, last=None):
        for l in self.lists:
            l.delete(first, last)


    def get(self, first, last=None):
        result = []
        for l in self.lists:
            result.append(l.get(first,last))
        if last: return apply(map, [None] + result)
        return result


    def index(self, index):
        self.lists[0].index(index)


    def insert(self, index, *elements):
        for e in elements:
            i = 0
            for l in self.lists:
                l.insert(index, e[i])
                i = i + 1


    def size(self):
        return self.lists[0].size()


    def see(self, index):
        for l in self.lists:
            l.see(index)

    def selection_anchor(self, index):
        for l in self.lists:
            l.selection_anchor(index)

    def selection_clear(self, first, last=None):
        for l in self.lists:
            l.selection_clear(first, last)

    def selection_includes(self, index):
        return self.lists[0].selection_includes(index)


    def selection_set(self, first, last=None):
        for l in self.lists:
            l.selection_set(first, last)


    def OnMouseWheel(self, event):
        for l in self.lists:
            l.yview("scroll", event.delta,"units")
        # this prevents default bindings from firing, which
        # would end up scrolling the widget twice
        return "break"


root = Tk()
root.minsize(width=650, height=580)
root.maxsize(width=650, height=580)
w, h = root.winfo_screenwidth(), root.winfo_screenheight()
x = (w/2) - 300
y = (h/2) - 250
root.geometry('%dx%d+%d+%d' % (650, 550, x, y-80))
root.wm_title("Results displayed")

tabelka = MultiListbox_fuse(root, (('Costam1',8), ('Costam2',8)))
tabelka.pack()
for a in range(1,100):
    tabelka.insert(END, (str("abc1"), str("def2")))

root.mainloop()

Answer 1

This code was not easy to understand and has almost no comments. The labbdas in the bind statements does not meke it easier.

Getting error when I try to yse the scrollbar as opposed to using the mouse wheel:

Exception in Tkinter callback
Traceback (most recent call last):
  File "C:\Users\qwerty\AppData\Local\Programs\Python\Python36-32\lib\tkinter\__init__.py", line 1702, in __call__
    return self.func(*args)
  File "C:\Users\qwerty\Documents\Python\test.py", line 58, in _scroll
    apply(l.yview, args)
NameError: name 'apply' is not defined

Here is an attempt:

# Add binding in __init()__ with the other bindings
lb.bind('<Shift-Button-1>', self.more)

# Create the function to handle <Shift-Button-1>
def more(self, event):
    first = self.lists[0].curselection()[0]     # The previous selection
    last = self.lists[0].nearest(event.y)       # Current mouse click
    self.selection_set(first, last=last)        # Set selection

This marks the selection in all lists. I have not taken into account the possibility of first selection not existing etc.

Answer 2

In your _select method, you clear the selection before adding the clicked one:

def _select(self, y,state=16):
    row = self.lists[0].nearest(y)
    if state==16:self.selection_clear(0, END) # This clears the selection
    self.selection_set(row)
    ## print self.curselection()
    return 'break'

If you want to remove the item from the selection if it's already in there do something like:

def _select(self, y,state=16):
    row = self.lists[0].nearest(y)
    if row in self.curselection(): # Check if the row already is in the selection
        self.selection_clear(row) # If it is, remove it
    else:
        self.selection_set(row) # If it isn't, add it
    return 'break'

---

Because you've also bound this method to <B1-Motion> this does get a bit weird when moving over the same row, because it constantly adds and removes the same row. You could work around that with something like the following, which checks if you've moved to another row when dragging.

self.current_row = None

for l,w in lists:
    ...
    lb.bind('<B1-Motion>', lambda e, s=self: s.drag(e.y))
    ...

def _select(self, y,state=16):
    row = self.lists[0].nearest(y)
    if row in self.curselection():
        self.selection_clear(row)
    else:
        self.selection_set(row)
    self.current_row = row
    return 'break'

def drag(self, y):
    row = self.lists[0].nearest(y)
    if not row == self.current_row:
        self._select(y)