root/05/release-0.5i/kombilo.py

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

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

##   Kombilo 0.5i 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 tkFileDialog import askdirectory
from tkCommonDialog import Dialog
from tkSimpleDialog import askstring

try:
    import Pmw
except:
    root=Tk()
    t = Text(root, wrap=WORD, width=70, height=12)
    t.pack()
    t.insert(END, 'Kombilo 0.5i\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()

try: import Image
except: pass

import encodings.utf_8
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
import glob
import re
from array import *
import webbrowser

from board1 import *
import v

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

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

class BoardWC(Board):
    """ Board with support for wildcards and selection
        of search-relevant region. Furthermore, snapshot returns a dictionary which
        describes the current board position. It can then be restored with restore."""

    
    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.selection = ((1,1),(19,19))

        self.fixedColor = fixedColor
        self.smartFixedColor = smartFixedColor

#        self.boundM2_1 = self.bind('<M2-Button-1>', self.selStart)
#        self.boundM2_1m = self.bind('<M2-B1-Motion>', self.selDrag)
        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):
        """ Resize the board. Take care of wildcards and selection here. """
        
        Board.resize(self, event)
        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 != ((1,1),(19,19)) and self.selection[1] != (0,0):
            p0 = self.getPixelCoord(self.selection[0],1)
            p1 = self.getPixelCoord((self.selection[1][0]+1, self.selection[1][1]+1), 1)
            min = self.getPixelCoord((1,1), 1)[0]+1
            max = self.getPixelCoord((self.boardSize+1,self.boardSize+1),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 not x*y or self.status.has_key((x,y)): return

        if self.wildcards.has_key((x,y)):
            self.delete(self.wildcards[(x,y)])
            del self.wildcards[(x,y)]
        else:
            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.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): override = ('black', '')
        else: override = None

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

                              
    # ---- 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, 1)
        y = max(y, 1)
        self.selection = ((x,y), (0,0))
        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((1,1), 1)[0]+1
        max = self.getPixelCoord((self.boardSize+1,self.boardSize+1),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 == ((1,1), (19,19)):
                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 = ((1,1),(19,19))

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


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

    def snapshot(self):
        """ Return a dictionary which contains the data of all the objects
            currently displayed on the board, which are not stored in the SGF file.
            This means, at the moment: wildcards, and selection. """
        
        data = {}
        data['wildcards'] = copy(self.wildcards)
        data['selection'] = self.selection
        return data

    
    def restore(self, d):
        """ Restore the data from a 'snapshot' dictionary. """
        
        for x,y in d['wildcards'].keys():
            x1, x2, y1, y2 = self.getPixelCoord((x,y),1)
            self.wildcards[(x,y)] = self.create_oval(x1+4, x2+4, y1-4, y2-4, fill = 'green',
                                                     tags=('wildcard','non-bg'))

        if d['selection'] != ((1,1),(19,19)) and d['selection'][1] != (0,0):
            self.setSelection(d['selection'][0], d['selection'][1])


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

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.list.get(0, END), ' %%%\n'))
        else:
            self.text.insert(END, '\n\nGame list\n\n' + join(self.mster.gamelist.list.get(0, END), '\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(v.ScrolledList):
    """ This is a scrolled list which shows the game list. All the underlying data
        is contained in self.DBlist, which is a list of dictionaries containing the
        information for the single databases. self.DBlist[i] will contain the keys
        'name': name of the database, i.e. path to the *.db files
        'sgfpath': path to the SGF files
        'data': list of all games in the database.
                This is a list of tuples of the form
                (filename, namelistIndex, PB, PW, result, signature)
        '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 ...) 
        'numNewGames': number of games which were "append"ed, but not yet inserted into
                       the list (by addAppendedGames) 
        """
    
    def __init__(self, parent, master, noGamesLabel, winPercLabel, gameinfo):
        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.DBlist = []      # list of dicts

        self.noGamesLabel = noGamesLabel
        self.winPercLabel = winPercLabel
        self.gameinfo = gameinfo
        
        self.Bwins = 0
        self.Wwins = 0
        self.Owins = 0 # others: Jigo, Void, Left unfinished, ? (Unknown)

        self.appendClist = []

        self.references = {}

        self.sort = None
        self.gameIndex = []

        self.showFilename = 1
        self.showDate = 0


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

        DBindex, index = self.getIndex(index)
        if DBindex == -1: return

        # print self.DBlist[DBindex]['data'][self.DBlist[DBindex]['current'][index]][5]
        # return

        f1 = strip(os.path.join(self.DBlist[DBindex]['sgfpath'],
                                self.DBlist[DBindex]['data'][self.DBlist[DBindex]['current'][index]][0]))
        
        if find(f1, '[') != -1:
            f1, f2 = split(f1, '[')
            gameNumber = int(strip(f2)[:-1])
        else:
            gameNumber = 0

        filename = getFilename(f1)

        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:
            label = self.list.get(index)
            self.mster.openViewer(index, label)


    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], label)


    def sortCrit(self, index, c):
        dbIndex, j = self.getIndex(index)
        return self.DBlist[dbIndex]['data'][self.DBlist[dbIndex]['current'][j]][c]


    def sortlist(self, perDB, criterion):
        """ Sort the game list wrt the given criterion, and update it. """

        self.sort = []

        if criterion == 'PW': c = 3
        elif criterion == 'PB': c = 2
        elif criterion == 'DT': c = 6
        else: c = 0          # criterion == 'filename'

        self.appendClist = []

        if perDB and c == 0:
            for i in range(len(self.DBlist)):
                db = self.DBlist[i]
                if db['disabled']: continue
                if db.has_key('sort'): del db['sort']
                self.appendClist.extend([(i, db['current'][j], j) for j in xrange(len(db['current']))])
        elif perDB:
            for i in range(len(self.DBlist)):
                db = self.DBlist[i]
                if db['disabled']: continue
                if db.has_key('sort'): del db['sort']
                
                s = []
                s.extend([(db['data'][j][c], j) for j in range(len(db['data']))])

                s.sort()

                self.sort.extend([(i, j) for dummy, j in s])
        else:
            
            for i in range(len(self.DBlist)):
                db = self.DBlist[i]
                if db['disabled']: continue
                self.sort.extend([(db['data'][j][c], i, j) for j in range(len(db['data']))])

            self.sort.sort()
            
            self.sort = [(i, j) for dummy, i, j in self.sort]

        if not (perDB and c==0):

            for i in range(len(self.DBlist)):
                db = self.DBlist[i]
                db['sort'] = array('L', [0] * len(db['data']))

                for ii in range(len(self.sort)):
                    if self.sort[ii][0] == i: db['sort'][self.sort[ii][1]] = ii
                
                self.appendClist.extend([(i, db['current'][j], j) for j in xrange(len(db['current']))])
            
        self.list.delete(0, END)
        self.Bwins, self.Wwins, self.Owins = 0,0,0
        self.update()


    def getIndex(self, i):
        """ Returns dbIndex, j, such that self.DBlist[dbIndex]['current'][j] corresponds to the
        i-th line of the ScrolledList. """

        if i < len(self.gameIndex):
            return self.gameIndex[i]
        else:
            return -1, -1


    def clear(self):
        """ Clear the list. """

        self.update()

        for db in self.DBlist:
            if not db['disabled']:
                db['current'] = array('L')
                db['results'] = []
            
        self.Bwins = 0
        self.Wwins = 0
        self.Owins = 0 
        self.update()

        self.delete(0,END)
        self.list.update_idletasks()


    def append(self, i, d):
        """ Append an entry to the gamelist. """
        self.DBlist[i]['data'].append(d)

        if not self.DBlist[i]['disabled']: 
            self.DBlist[i]['numNewGames'] += 1

    def addAppendedGames(self):
        """ Display the games which were "append"ed in the list. """
        
        for i in range(len(self.DBlist)):
            db = self.DBlist[i]
            if db['numNewGames']:                              # display append'ed entries
                db['current'].extend(array('L', range(len(db['data'])-db['numNewGames'], len(db['data']))))
                self.gameIndex.extend([(i, j) for j in range(db['numNewGames'])])
            db['results'] = db['results'] + [''] * db['numNewGames']
            db['numNewGames'] = 0

        noOfG = self.noOfGames()
        self.noGamesLabel.config(text = `noOfG` + ' games')

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

        self.delete(0,END)
        self.sortlist(self.mster.options.sortPerDatabase.get(), self.mster.options.sortCriterion.get())
        

    def appendC(self, dbIndex, i, res = ''):
        """ Append an entry to self.current """

        db = self.DBlist[dbIndex]
        
        db['current'].append(i)
        db['results'].append(res)
        self.appendClist.append((dbIndex, i, len(db['current'])-1))


    def reset(self):
        """ Reset the list, s.t. it includes all the games from self.data. """
        
        for i in range(len(self.DBlist)):
            db = self.DBlist[i]
            if not db['disabled']:
                db['current'] = array('L', range(len(db['data'])))
                db['results'] = [''] * len(db['data'])
                self.appendClist += [ (i, j, j) for j in range(len(db['data']))]
            else:
                db['current'] = array('L')
                db['results'] = []
        self.delete(0, END)
        self.Bwins, self.Wwins, self.Owins = 0, 0, 0
        self.update()
        self.clearGameInfo()

        
    def update(self):
        """ Put the changes in data, current in effect in self.list. """
        
        if self.appendClist:         # display appendC'ed entries
            
            strl = []
            self.gameIndex = []

            if self.sort:
                self.appendClist = [ (self.DBlist[x[0]]['sort'][x[1]], x) for x in self.appendClist ]
                self.appendClist.sort()
                self.appendClist = map(lambda x: x[1], self.appendClist) 

            if self.mster.options.sortReverse.get():
                self.appendClist.reverse()

            for db, index, index1 in self.appendClist:
                d = self.DBlist[db]['data'][index]
                res = self.DBlist[db]['results'][index1]
                if d[4] == 'B': self.Bwins += 1
                elif d[4] == 'W': self.Wwins += 1
                else: self.Owins += 1

                li = [d[7]]
                if self.showFilename:
                    endFilename = find(d[0], '[')
                    if endFilename == -1: endFilename = len(d[0])
                
                    if d[0][endFilename-1] == '.':
                        filename = d[0][:endFilename-1] + d[0][endFilename:]
                    elif d[0][endFilename-2:endFilename] == '.m':
                        filename = d[0][:endFilename-2] + d[0][endFilename:]
                    else: filename = d[0]

                    li.append(filename + ': ')

                li.append(d[3] + ' - ' + d[2] + ' (' + d[4] + '), ')
                if self.showDate: li.append(d[6]+', ')
                li.append(res)
                strl.append(join(li, ''))
                self.gameIndex.append((db, index1))

            ti = time.time()
            self.insert(END, strl)
            
            self.appendClist = []

        noOfG = self.noOfGames()
        self.noGamesLabel.config(text = `noOfG` + ' games')

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

    def noOfGames(self):
        return reduce(lambda x,y:x+y, [ len(db['current']) for db in self.DBlist if not db['disabled'] ], 0)


    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

        DBindex, index = self.getIndex(index)
        if DBindex == -1: return
            
        f1 = strip(os.path.join(self.DBlist[DBindex]['sgfpath'],
                                self.DBlist[DBindex]['data'][self.DBlist[DBindex]['current'][index]][0]))

        if find(f1, '[') != -1:
            f1, f2 = split(f1, '[')
            gameNumber = int(strip(f2)[:-1])
        else:
            gameNumber = 0

        filename = getFilename(f1)

        try:
            f = open(filename)
            sgf = f.read()
            f.close()
            node = Cursor(sgf, 1).getRootNode(gameNumber)
        except:
            return

        t = ''
        
        if node.has_key('PW'): t = t + node['PW'][0]
        else: t = t + ' ?'
        if node.has_key('WR'): t = t + ', ' + node['WR'][0]