root/06/devel-old/kombilo.py

#! /usr/bin/env python
# File: kombilo.py

##   Copyright (C) 2001-6 Ulrich Goertz (u@g0ertz.de)

##   Kombilo 0.6 is a go database program.

##   This program is free software; you can redistribute it and/or modify
##   it under the terms of the GNU General Public License as published by
##   the Free Software Foundation; either version 2 of the License, or
##   (at your option) any later version.

##   This program is distributed in the hope that it will be useful,
##   but WITHOUT ANY WARRANTY; without even the implied warranty of
##   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
##   GNU General Public License for more details.

##   You should have received a copy of the GNU General Public License
##   along with this program (see doc/license.txt); if not, write to the Free Software
##   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
##   The GNU GPL is also currently available at
##   http://www.gnu.org/copyleft/gpl.html

from Tkinter import *
from tkMessageBox import *
from ScrolledText import ScrolledText
import tkFileDialog
from tkCommonDialog import Dialog
from tkSimpleDialog import askstring

try:
    import Pmw   # FIXME: also check Pmw version!
except:
    root=Tk()
    t = Text(root, wrap=WORD, width=70, height=12)
    t.pack()
    t.insert(END, 'Kombilo 0.6\n\n The Python Megawidgets (Pmw) library was not found. It is needed by Kombilo, ' + \
             'so you have to install it before you can use Kombilo. See the Kombilo tutorial at ' + \
             'http://www.u-go.net/kombilo/tutorial#installation or the Pmw web site at ' + \
             'http://pmw.sourceforge.net/ for more information.')
    root.mainloop()
    sys.exit()
    
import time
import os
import sys
import cPickle
from copy import copy, deepcopy
from string import split, find, join, strip, replace, digits, maketrans, translate, lower, upper
import glob
import re
from array import *
import webbrowser

try:
    from abstractBoard import *
except ImportError:
    print 'ouch' # FIXME
    from abstractBoardPY import *
from board import *
import v
try:
    from patternPY import *
except ImportError:
    print 'ouch pattern' # FIXME
    from patternPY import *
from searchPY import *
from aglPY import *
from algosPY import *

try:
    from sgfpars import Node, Cursor, SGFError, SGFescape
except:
    from sgfparser import Node, Cursor, SGFError, SGFescape
    
try:
    import matchC
    CimportSucceeded = 1
except:
    CimportSucceeded = 0

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

def wildcolor_to_char(color):
    return {'green': '*', 'black': 'x', 'white': 'o'}[color[1]]

def char_to_wildcolor(c):
    try:
        return {'*': 'green', 'x': 'black', 'o': 'white'}[c]
    except:
        print "DEBUG: char_to_wildcolor called with", c
        # FIXME


class BoardWC(Board):
    """
    Board with support for wildcards and selection
    of search-relevant region.
    """
    
    def __init__(self, master, boardsize, canvasSize, fuzzy, labelFontsize, fixedColor, smartFixedColor,
                 boardImg, blackImg, whiteImg):
        Board.__init__(self, master, boardsize, canvasSize, fuzzy, labelFontsize, 1, None,
                       boardImg, blackImg, whiteImg)

        self.wildcards = {}
        self.MSlabels = {}
        self.selection = ((0,0),(boardsize-1, boardsize-1))

        self.fixedColor = fixedColor
        self.smartFixedColor = smartFixedColor
        
        self.bound3 = self.bind('<Button-3>', self.selStart)
        self.bound3m = self.bind('<B3-Motion>', self.selDrag)
        self.bounds1 = self.bind('<Shift-1>', self.wildcard)

        self.invertSelection = IntVar()


    def resize(self, event = None, force=0):
        """ Resize the board. Take care of wildcards and selection here. """
        
        Board.resize(self, event, force)
        for x,y in self.wildcards.keys():
            x1, x2, y1, y2 = self.getPixelCoord((x,y),1)
            if self.canvasSize[1]<=7: margin = 5
            else: margin = 4
            self.wildcards[(x,y)] = self.create_oval(x1+margin, x2+margin, y1-margin, y2-margin, fill = 'green',
                                                     tags=('wildcard','non-bg'))

        self.delete('selection')
        if self.selection != ((0,0),(self.boardsize-1,self.boardsize-1)) and self.selection[1] != (-1,-1):
            p0 = self.getPixelCoord(self.selection[0],1)
            p1 = self.getPixelCoord((self.selection[1][0]+1, self.selection[1][1]+1), 1)
            min = self.getPixelCoord((0,0), 1)[0]+1
            max = self.getPixelCoord((self.boardsize,self.boardsize),1)[1]-1
            if self.canvasSize[1] <= 7:
                self.create_rectangle(p0[0], p0[1], p1[0], p1[1],
                                      tags=('selection', 'non-bg'))
            elif self.invertSelection.get():
                self.create_rectangle(p0[0], p0[1], p1[0], p1[1], fill='brown', stipple='gray50', outline='',
                                      tags='selection')
            else:
                if p0[1] > min:
                    self.create_rectangle(min, min, max, p0[1], fill='brown', stipple='gray50', outline='',
                                          tags='selection')
                if p0[0] > min and p0[1] < max:
                    self.create_rectangle(min, p0[1], p0[0], max, fill='brown', stipple='gray50', outline='',
                                          tags='selection')
                if p1[1] < max:
                    self.create_rectangle(p0[0], p1[1], p1[0], max, fill='brown', stipple='gray50', outline='',
                                          tags='selection')
                if p1[0] < max and p0[1] < max:
                    self.create_rectangle(p1[0], p0[1], max, max, fill='brown', stipple='gray50', outline='',
                                          tags='selection')
            self.tkraise('non-bg')
            
        self.update_idletasks()


    def wildcard(self, event):
        """ Place/delete a wildcard at position of click. """
        
        x, y = self.getBoardCoord((event.x, event.y), 1)
        if x==-1 or y==-1 or self.status.has_key((x,y)): return

        if self.wildcards.has_key((x,y)):
            if self.wildcards[(x,y)][1] == self.currentColor:
                self.delete(self.wildcards[(x,y)][0])
                color = self.invert(self.currentColor)
            elif self.wildcards[(x,y)][1] == 'green':
                self.delete(self.wildcards[(x,y)][0])
                color = self.currentColor
            else:
                self.delete(self.wildcards[(x,y)][0])
                del self.wildcards[(x,y)]
                self.changed.set(1)
                return
        else:
            color = 'green'
            
        x1, x2, y1, y2 = self.getPixelCoord((x,y),1)
        if self.canvasSize[1]<=7: margin = 5
        else: margin = 4
        self.wildcards[(x,y)] = (self.create_oval(x1+margin, x2+margin, y1-margin, y2-margin, fill = color,
                                                  tags=('wildcard','non-bg')),
                                 color)
        self.tkraise('label')
        self.changed.set(1)        


    def delWildcards(self):
        """ Delete all wildcards. """
        
        if self.wildcards: self.changed.set(1)
        self.delete('wildcard')
        self.wildcards = {}


    def placeLabel(self, pos, type, text=None, color=None):
        """ Place a label; take care of wildcards at same position. """
        
        if self.wildcards.has_key(pos):
            if self.widlcards[pos][1] in ['green', 'white']:
                override = ('black', '')
            else:
                override = ('white', '')
        else: override = None

        Board.placeLabel(self, pos, type, text, color, override)

        
    def placeMSLabel(self, pos, type, text):
        x1, x2, y1, y2 = self.getPixelCoord(pos, 1)
        self.create_text((x1+y1)/2,(x2+y2)/2, text=text, fill='red',
                         font = (self.labelFont[0].get(),
                                 self.labelFont[1].get() + self.canvasSize[1]/5,
                                 self.labelFont[2].get()),
                         tags=('non-bg', 'MSLabel'))


    def delMSLabels(self):
        self.delete('MSLabel')
        self.MSLabels = {}
                      
    # ---- selection of search-relevant section -----------------------------------

    def selStart(self, event):
        """ React to right-click. """
        self.delete('selection')
        x, y = self.getBoardCoord((event.x, event.y), 1)
        x = max(x, 0)
        y = max(y, 0)
        self.selection = ((x,y), (-1,-1))
        if self.smartFixedColor.get(): self.fixedColor.set(1)
        self.changed.set(1)


    def selDrag(self, event):
        """ React to right-mouse-key-drag. """
        pos = self.getBoardCoord((event.x, event.y), 1)
        if pos[0] >= self.selection[0][0] and pos[1] >= self.selection[0][1]:
            self.setSelection(self.selection[0], pos)
            

    def setSelection(self, pos0, pos1):
        self.selection = (pos0, pos1)
        self.delete('selection')
        p0 = self.getPixelCoord(pos0,1)
        p1 = self.getPixelCoord((pos1[0]+1, pos1[1]+1), 1)
        min = self.getPixelCoord((0,0), 1)[0]+1
        max = self.getPixelCoord((self.boardsize,self.boardsize),1)[1]-1
        if self.canvasSize[1] <= 7:
            self.create_rectangle(p0[0], p0[1], p1[0], p1[1],
                                  tags=('selection', 'non-bg'))
        elif self.invertSelection.get():
            self.create_rectangle(p0[0], p0[1], p1[0], p1[1], fill='brown', stipple='gray50', outline='',
                                  tags='selection')
        else:
            if p0[1] > min:
                self.create_rectangle(min, min, max, p0[1], fill='brown', stipple='gray50', outline='',
                                      tags='selection')
            if p0[0] > min and p0[1] < max:
                self.create_rectangle(min, p0[1], p0[0], max, fill='brown', stipple='gray50', outline='',
                                      tags='selection')
            if p1[1] < max:
                self.create_rectangle(p0[0], p1[1], p1[0], max, fill='brown', stipple='gray50', outline='',
                                      tags='selection')
            if p1[0] < max and p0[1] < max:
                self.create_rectangle(p1[0], p0[1], max, max, fill='brown', stipple='gray50', outline='',
                                      tags='selection')
            
        self.tkraise('non-bg')
        
        if self.smartFixedColor.get():
            if self.selection == ((0,0), (self.boardsize, self.boardsize-1)):
                self.fixedColor.set(1)
            else:
                self.fixedColor.set(0)
                
        
    def newPosition(self):
        """ Clear board, selection. """
        self.delete('selection')
        self.clear()
        self.delLabels()
        self.delMarks()
        self.delWildcards()
        self.selection = ((0,0),(self.boardsize-1,self.boardsize-1))

        if self.smartFixedColor.get(): self.fixedColor.set(1)

    # ---- snapshot & restore (for 'back' button)

    def snapshot(self):
        data = Board.snapshot(self) 
        data.extend([copy(self.wildcards), self.selection])
        return data

    def restore(self, data):
        self.wildcards = data[5]
        self.selection = data[6]
        Board.restore(self, data) # This does a self.resize(), which takes care of wildcards and selection in our case

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

class chooseDirectory(Dialog):
    """ A wrapper tor the Tk chooseDirectory widget. """
    
    command = "tk_chooseDirectory"

    def _fixresult(self, widget, result):
        if result:
            self.options["initialdir"] = result
        self.directory = result
        return result


def askdirectory(**options): 
    return apply(chooseDirectory, (), options).show()

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

class TextEditor:
    """ A very simple text editor, based on the Tkinter ScrolledText widget.
    You can perform very limited editing, and save the result to a file. """

    def __init__(self, t = '', defpath='', font = None):

        if font is None:
            font = (StringVar(), IntVar(), StringVar())
            font[0].set('Courier')
            font[1].set(10)
            font[2].set('')
            
        self.window = Toplevel()
        self.window.protocol('WM_DELETE_WINDOW', self.quit)
        self.text = ScrolledText(self.window, width=70, height=30,
                                 font=(font[0].get(), font[1].get(), font[2].get()))
        self.text.pack(side=BOTTOM, fill=BOTH, expand=YES)
        self.text.insert(END, t)

        self.buttonFrame = Frame(self.window)
        self.buttonFrame.pack(side=TOP, expand=NO, fill=X)

        Button(self.buttonFrame, text='Quit', command=self.quit).pack(side=RIGHT)
        Button(self.buttonFrame, text='Save as', command=self.saveas).pack(side=RIGHT)

        # self.window.tkraise()
        self.window.focus_force()

        if defpath:
            self.defpath = defpath
        else:
            self.defpath = os.curdir

            
    def saveas(self):
        f = tkFileDialog.asksaveasfilename(initialdir = self.defpath)
        if not f: return
        try:
            file = open(f, 'w')
            file.write(self.text.get('1.0', END).encode('utf-8','ignore'))
            file.close()
        except IOError:
            showwarning('IO Error', 'Cannot write to ' + f)


    def quit(self):
        self.window.destroy()


class ESR_TextEditor(TextEditor):
    """
    The text editor which is used by the exportSearchResults function.
    It adds a button to include the complete game list to the TextEditor.
    """

    def __init__(self, master, style, t='', defpath='', font=None):
        TextEditor.__init__(self, t, defpath, font)
        self.mster = master
        self.style = style
        
        Button(self.buttonFrame, text='Include game list', command=self.includeGameList).pack(side=LEFT)


    def includeGameList(self):
        if self.style: # wiki
            self.text.insert(END, '\n\n!Game list\n\n' + join(self.mster.gamelist.getAllStrings(), ' %%%\n'))
        else:
            self.text.insert(END, '\n\nGame list\n\n' + join(self.mster.gamelist.getAllStrings(), '\n'))    

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

class DataWindow(v.DataWindow):

    def __init__(self, master):

        v.DataWindow.__init__(self, master)

        self.prevSF = Pmw.ScrolledFrame(self.prevSearchF, usehullsize=1, hull_width=300, hull_height=135,
                                        hscrollmode='static', vscrollmode='none', vertflex='elastic')
        self.prevSF.pack(expand=YES, fill=X)
        self.prevSV = IntVar()
        self.prevSV.set(1)

        b1 = Checkbutton(self.toolbarF, text = 'History', variable = self.prevSV,
                         command = self.togglePrevSearches, indicatoron=0)
        b1.grid(row=0, column=6)

        self.win.setnaturalsize()

        
    def initPanes(self):
        """ Create the panes in the data window. """

        self.toolbarF = self.win.add(name='toolb', min=28, max=28)
        self.filelistF = self.win.add(name='filel', min=0.01, max=1.0, size=65)
        self.gamelistF = self.win.add(name='gamel', min=0.01, max=1.0, size=65)
        self.gameinfoF = self.win.add(name='gamei', min=0.01, max=1.0, size=75)
        self.editToolsF = self.win.add(name='editt', min=1, max=30, size=30) 
        self.gametreeF = self.win.add(name='gamet', min=0.01, max=1.0, size=90) 
        self.commentsF = self.win.add(name='comm', min=0.01, max=1.0, size=80) 
        self.prevSearchF = self.win.add('prse', min=1, max=1.0, size=135)


    def get_geometry(self):
        """ Return a list of current sizes of the panes. """
        
        l = [ self.filelistV.get(), self.win._size['filel'],
              self.gamelistV.get(), self.win._size['gamel'],
              self.gameinfoV.get(), self.win._size['gamei'],
              self.editToolsV.get(), self.win._size['editt'],
              self.gametreeV.get(), self.win._size['gamet'],
              self.commentsV.get(), self.win._size['comm'],
              self.prevSV.get(), self.win._size['prse']]
        l1 = [ `x` for x in l ]
        l1.append(self.window.geometry())

        return join(l1, '|%')

        
    def set_geometry(self, s):
        """ Reset the sizes of the panes to the given ones. """
        
        l = split(s, '|%')
        
        l1 = [ self.filelistV, 
               self.gamelistV, 
               self.gameinfoV, 
               self.editToolsV,
               self.gametreeV, 
               self.commentsV,
               self.prevSV ]
               
        for i in range(len(l)/2):
            l1[i].set(int(l[2*i]))
            if int(l[2*i]):
                self.win.configurepane(i+1, min=10, max=1.0, size = int(l[2*i+1]))
            else:
                self.win.configurepane(i+1, min=0.0, max=0.0, size = 0.0)
        self.win.updatelayout()
        self.window.geometry(l[-1])


    def gamelistRelease(self, event):
        index1, index2 = v.DataWindow.gamelistRelease(self, event)
        if index1:
            self.mster.prevSearches.exchangeGames(self.mster.cursor, index1, index2)
        

    def togglePrevSearches(self):
        if self.prevSV.get():
            s = self.window.geometry()
            x1, x2, x3 = split(s, '+')
            x, y = split(x1, 'x')
            y = `int(y)+135`
            self.window.geometry('%sx%s+%s+%s' % (x, y, x2, x3))
            self.win.configurepane(7, min=10, max=1.0, size=135)
        else:
            s = self.window.geometry()
            x1, x2, x3 = split(s, '+')
            x, y = split(x1, 'x')
            y = `int(y)-self.win._size['prse']`
            self.window.geometry('%sx%s+%s+%s' % (x, y, x2, x3))
            self.win.configurepane(7, min=0.0, max=0.0, size=0.0)
        self.win.updatelayout()
        
# -------------------------------------------------------------------------------------

class GameList(abstractGameList, v.ScrolledList):
    """
    This is a scrolled list which shows the game list. All the underlying data
    is contained in self.DBlist['9'], self.DBlist['13'], self.DBlist['19'], which are
    lists of dictionaries containing the information for the single databases.
    self.DBlist[`boardsize`][i] will contain the attributes
    name: name of the database, i.e. path to the *.db files
    sgfpath: path to the SGF files
    namelist: list of all games in the database.
              This is a list of tuples of the form
              (filename, PB, PW, result, signature, date)
    current: a list of the indices of the games in data which are in the current
             game list
    results: for each game in current, the list of matches found in the previous
             search (If there are lots of matches, this list will consume a lot
             of memory. Maybe at some time I will get around to fix this ...) 
    """
    
    def __init__(self, parent, master, noGamesLabel, winPercLabel, gameinfo):
        abstractGameList.__init__(self)
        v.ScrolledList.__init__(self, parent)
        self.list.config(width=52, height=6) 

        self.onSelectionChange = self.printGameInfo
        self.list.bind('<Button-1>', self.onSelectionChange)

        self.bind('<Up>', self.up)
        self.bind('<Down>', self.down)
        self.bind('<Prior>', self.pgup)
        self.bind('<Next>', self.pgdown)
        self.bind('<Return>', self.handleDoubleClick)
        self.list.bind('<Double-1>', self.handleDoubleClick)
        self.list.bind('<Shift-1>', self.handleShiftClick)
        self.list.bind('<Button-3>', self.rightMouseButton)

        self.mster = master
        self.options = self.mster.options
        self.datapath = self.mster.datapath # FIXME !?
        
        self.noGamesLabel = noGamesLabel
        self.winPercLabel = winPercLabel
        self.gameinfo = gameinfo

        
    def rightMouseButton(self, event):
        
        index = self.list.nearest(event.y)
        if index == -1: return
        filename, gameNumber = self.getFilename(index)

        try:
            file = open(filename)
            sgf = file.read()
            file.close()
            c = Cursor(sgf, 1)
            rootNode = c.getRootNode(gameNumber)
        except IOError:
            showwarning('Error', 'I/O Error')
            return
        except SGFError:
            showwarning('Error', 'SGF error')
            return
        
        backup = copy(rootNode)

        newRootNode = self.mster.gameinfo(rootNode)
        if backup != newRootNode:
            c.updateRootNode(newRootNode, gameNumber)
            try:
                s = c.output()
                file = open(filename, 'w')
                file.write(s)
                file.close()
            except IOError:
                showwarning('I/O Error', 'Could not write to file ' + filename)


    def handleDoubleClick(self, event):
        """ This is called upon double-clicks."""
        
        index = self.list.curselection()
        if index: self.mster.openViewer(index)


    def handleShiftClick(self, event):
        index = self.list.nearest(event.y)
        index1 = self.list.curselection()
        if index1: self.list.select_clear(index1[0])
        self.list.select_set(index)
        self.onSelectionChange(event)
        try:
            label = self.list.get(index)
        except:
            return
        self.mster.altOpenViewer(index)


    def reset(self):

        abstractGameList.reset(self)
        self.sync()


    def changeBoardSize(self, boardsize):
        abstractGameList.changeBoardSize(self, boardsize)
        self.sync()


    def sync(self):
        """ Put the changes in abstractGamelist in effect in self.list. """
        numOfG = self.numOfGames()
        self.noGamesLabel.config(text = `numOfG` + ' games')

        if self.numOfGames():
            Bperc = self.Bwins * 100.0 / numOfG
            Wperc = self.Wwins * 100.0 / numOfG
            self.winPercLabel.config(text='B: %1.1f%%, W: %1.1f%%' % (Bperc, Wperc))
        else: self.winPercLabel.config(text='')

        self.delete(0, END)
        self.insert(END, self.getAllStrings())


    def printGameInfo(self, event, index = -1):
        """ Print game info of selected game. """

        if index == -1:
            index = self.list.nearest(event.y)
            self.focus()
        if index == -1:
            return

        t, t2 = abstractGameList.getGameInfo(self, index)
        
        self.gameinfo.config(state=NORMAL)
        self.gameinfo.delete('1.0', END)
        self.gameinfo.insert('1.0', t)
        if t2:
            if t[-1]!='\n': self.gameinfo.insert(END, '\n')
            self.gameinfo.insert(END, t2, 'blue')
        self.gameinfo.config(state=DISABLED)


    def clearGameInfo(self):
        self.gameinfo.config(state=NORMAL)
        self.gameinfo.delete('1.0', END)
        self.gameinfo.config(state=DISABLED)

    # ---- administration of DBlist ----------------------------------------------------

    def addDB(self, window):
        self.editDB_OK.config(state=DISABLED)
        self.saveProcMess.config(state=DISABLED)
        self.stopAddDBButton.config(state=NORMAL)

        if self.options.oldTkVar.get():
            dbp = tkFileDialog.askopenfilename(initialdir = self.datapath)

            if dbp and os.path.isfile(dbp):
                dbp = os.path.split(dbp)[0]
                dbp = os.path.normpath(dbp)
            else:
                self.editDB_OK.config(state=NORMAL)
                self.saveProcMess.config(state=NORMAL)
                self.stopAddDBButton.config(state=DISABLED)
                return
        else:
            try:
                dbp = str(askdirectory(initialdir = self.datapath))
            except TclError:
                self.options.oldTkVar.set(1)
                dbp = tkFileDialog.askopenfilename(initialdir = self.datapath)

                if dbp and os.path.isfile(dbp): dbp = os.path.split(dbp)[0]
                else:
                    self.editDB_OK.config(state=NORMAL)
                    self.saveProcMess.config(state=NORMAL)
                    self.stopAddDBButton.config(state=DISABLED)
                    return
                
            if not dbp:
                self.editDB_OK.config(state=NORMAL)
                self.saveProcMess.config(state=NORMAL)
                self.stopAddDBButton.config(state=DISABLED)
                return
            else: dbp = os.path.normpath(dbp)
            
        self.datapath = os.path.split(dbp)[0]

        if self.options.storeDatabasesSeparately.get() and self.options.whereToStoreDatabases.get():
            datap = (self.options.whereToStoreDatabases.get(), '')
            if os.path.exists(datap[0]) and not os.path.isdir(datap[0]):
                showwarning('Error', datap[0] + ' is not a directory.')
                self.editDB_OK.config(state=NORMAL)
                self.saveProcMess.config(state=NORMAL)
                self.stopAddDBButton.config(state=DISABLED)
                return
            elif not os.path.exists(datap[0]):
                if askyesno('Error', 'Directory ' + datap[0] + ' does not exist. Create it?'):
                    try:
                        os.makedirs(datap[0])
                    except:
                        showwarning('Error', datap[0] + ' could not be created.')
                        self.editDB_OK.config(state=NORMAL)
                        self.saveProcMess.config(state=NORMAL)
                        self.stopAddDBButton.config(state=DISABLED)
                        return
                else:
                   self.editDB_OK.config(state=NORMAL)
                   self.saveProcMess.config(state=NORMAL)
                   self.stopAddDBButton.config(state=DISABLED)
                   return          
        else:
            datap = ('', '#') # this means: same as dbpath

        abstractGameList.addDB(self, dbp, datap, self.processMessages, 0, 15,
                               '*.sgf', 1, 1, 0)
        self.sync()
        self.editDB_OK.config(state=NORMAL)
        self.saveProcMess.config(state=NORMAL)
        self.stopAddDBButton.config(state=DISABLED)


    def addOneDB(self, arguments, dbpath, dummy):
        abstractGameList.addOneDB(self, arguments, dbpath, dummy)
        self.sync()
        self.db_list.insert(END, dbpath)
        self.db_list.list.see(END)        

     
    def removeDB(self):
        toBeRemoved = []
        while self.db_list.list.curselection():
            index = self.db_list.list.curselection()[0]
            self.db_list.delete(index)
            i = int(index)
            toBeRemoved.append(i)

        abstractGameList.removeDB(self, toBeRemoved, self.processMessages)
        self.sync()
        self.mster.prevSearches.clear()
        self.mster.currentSearchPattern = None
                                 

    def reprocessDB(self):
        toBeReprocessed = []
        self.editDB_OK.config(state=DISABLED)
        self.mster.prevSearches.clear()
        self.mster.currentSearchPattern = None
        
        for index in self.db_list.list.curselection():
            i = int(index)
            toBeReprocessed.append(i)

        algos = None # FIXME
        failed = abstractGameList.reprocessDB(self, toBeReprocessed, self.processMessages, algos)

        for i in failed:
            self.db_list.delete(i)

        self.sync()
        self.editDB_OK.config(state=NORMAL)


    def toggleDisabled(self):
        for index in self.db_list.list.curselection():
            i = int(index)
        
            db = self.DBlist[`self.boardsize`][i]
            if db.disabled:
                db.disabled = 0
                self.db_list.delete(i)
                self.db_list.insert(i, db.sgfpath)
                self.db_list.list.select_set(i)
                self.db_list.list.see(i)
            else:
                db.disabled = 1
                self.db_list.delete(i)
                self.db_list.insert(i, 'DISABLED - ' + db.sgfpath)
                self.db_list.list.select_set(i)
                self.db_list.list.see(i)
        self.reset()
        self.mster.prevSearches.clear()
        self.mster.currentSearchPattern = None
        

    def saveMessagesEditDBlist(self):
        filename = tkFileDialog.asksaveasfilename(initialdir = os.curdir)
        try:
            file = open(filename, 'w')
            file.write(self.processMessages.get('1.0', END))
            file.close()
        except IOError:
            showwarning('Error', 'Could not write to ' + filename)

    # ---- FIXME: move click, drag, (release) to DnDScrolledList (?!)

    def DBlistClick(self, event):
        self.db_list.clickedLast = self.db_list.list.nearest(event.y)
        self.db_list.dragLast = -1


    def DBlistDrag(self, event):
        i = self.db_list.list.nearest(event.y)
        if self.db_list.dragLast == -1:
            if self.db_list.clickedLast == i: return
            else: self.db_list.dragLast = self.db_list.clickedLast        
        if self.db_list.dragLast != i:
            s = self.db_list.list.get(self.db_list.dragLast)
            self.db_list.delete(self.db_list.dragLast)
            self.db_list.insert(i, s)
            self.db_list.list.select_set(i)
            self.db_list.dragLast = i 
        return 'break'


    def DBlistRelease(self, event):
        if self.db_list.dragLast == -1:
            return
        
        i = self.db_list.list.nearest(event.y)

        if self.db_list.dragLast != i:
            s = self.db_list.list.get(self.db_list.dragLast)
            self.db_list.delete(self.db_list.dragLast)
            self.db_list.insert(i, s)
            self.db_list.list.select_set(i)
            self.db_list.dragLast = i

        if self.db_list.clickedLast != i:
            db = self.gamelist.DBlist[`self.boardsize`][self.db_list.clickedLast]
            del self.gamelist.DBlist[`self.boardsize`][self.db_list.clickedLast]
            self.gamelist.DBlist[`self.boardsize`].insert(i, db)
            self.gamelist.sortlist(self.options.sortPerDatabase.get(), self.options.sortCriterion.get())
            self.gamelist.reset()
            self.prevSearches.clear()
            self.currentSearchPattern = None


    def browseDatabases(self):
        initdir = self.options.whereToStoreDatabases.get() or os.curdir
        filename = str(askdirectory(initialdir = initdir))
        self.options.whereToStoreDatabases.set(filename)
        

    def toggleWhereDatabases(self):
        if self.options.storeDatabasesSeparately.get():
            self.whereDatabasesEntry.config(state=NORMAL)
            if not self.options.whereToStoreDatabases.get(): self.browseDatabases()
        else:
            self.whereDatabasesEntry.config(state=DISABLED)

        
    def editDBlistWindow(self):

        self.clearGameInfo()
        self.stopAddDBVar = IntVar()
        window = Toplevel()
        window.transient(self.master)
        window.title('Edit database list')

        f1 = Frame(window)
        f1.grid(row=0, sticky=NSEW)
        f2 = Frame(wind