root/04/release-0.4e/kombilo.py

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

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

##   Kombilo 0.4e 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
import time
import os
import sys
import cPickle
from copy import copy, deepcopy
from string import split, find, join, strip, replace, digits
import glob
import re
from array import *
import webbrowser

from sgfparser import *
from board1 import *
import v

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):
        Board.__init__(self, master, boardSize, canvasSize, fuzzy, labelFontsize)

        self.wildcards = {}

        self.selection = ((1,1),(19,19))

        self.fixedColor = fixedColor
        self.smartFixedColor = smartFixedColor

        if sys.platform.startswith('darwin'):
            self.bind('<M2-Button-1>', self.selStart)
            self.bind('<M2-B1-Motion>', self.selDrag)
        else:
            self.bind('<Button-3>', self.selStart)
            self.bind('<B3-Motion>', self.selDrag)
        self.bind('<Shift-1>', self.wildcard)

    def resize(self, event):
        Board.resize(self, event)
        for x,y in self.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'))

        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)

            self.create_rectangle(p0[0], p0[1], p1[0], p1[1], fill='brown', stipple='gray50',
                                  tags='selection')
            self.tkraise('non-bg')
            
        self.update_idletasks()

    def wildcard(self, event):
        """ Place 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)) \
           or self.wildcards.has_key((x,y)): return

        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'))

        self.changed.set(1)
        

    def delWildcards(self):
        if self.wildcards: self.changed.set(1)
        self.delete('wildcard')
        self.wildcards = {}
                              
    # ---- 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)

        self.create_rectangle(p0[0], p0[1], p1[0], p1[1], fill='brown', stipple='gray50',
                              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. """
        
        data = {}
        data['status'] = copy(self.status)
        data['marks'] = copy(self.marks)
        data['labels'] = copy(self.labels)
        data['wildcards'] = copy(self.wildcards)
        data['selection'] = self.selection
        data['currentcolor'] = self.currentColor
        data['undostack'] = deepcopy(self.undostack)
        
        return data
    
    def restore(self, d):
        """ Restore a board position from a 'snapshot' dictionary. """
        
        self.newPosition()
        for x in d['status'].keys(): self.play(x, d['status'][x])
        for x in d['marks'].keys(): self.placeMark(x, d['marks'][x])
        for x in d['labels'].keys(): self.placeLabel(x, d['labels'][x][0], d['labels'][x][1])
        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):
            p0 = self.getPixelCoord(d['selection'][0],1)
            p1 = self.getPixelCoord((d['selection'][1][0]+1, d['selection'][1][1]+1),1)

            self.create_rectangle(p0[0], p0[1], p1[0], p1[1], fill='brown', stipple='gray50',
                                  tags='selection')
            self.tkraise('non-bg')
            self.selection = d['selection']

        self.currentColor = d['currentcolor']
        self.undostack = deepcopy(d['undostack'])

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

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(fill=BOTH, expand=YES)
        self.text.insert(END, t)

        self.buttonFrame = Frame(self.window)
        self.buttonFrame.pack(side=RIGHT)

        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)
        try:
            file = open(f, 'w')
            file.write(self.text.get('1.0', END))
            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.master = master
        self.style = style
        
        Button(self.buttonFrame, text='Include game list', command=self.includeGameList).pack(side=RIGHT)

    def includeGameList(self):
        if self.style == 'wiki':
            self.text.insert(END, '\n\n!Game list\n\n' + join(self.master.gamelist.list.get(0, END), ' %%%\n'))
        else:
            self.text.insert(END, '\n\nGame list\n\n' + join(self.master.gamelist.list.get(0, END), '\n'))
        

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

class ScrolledList(Frame):
    """ A listbox with vertical and horizontal scrollbars. """
    
    def __init__(self, parent, **kw):
        Frame.__init__(self, parent)

        self.sbar = Scrollbar(self)
        self.sbar1 = Scrollbar(self)

        if not kw: kw = {}

        for var, value in [('height', 12), ('width', 40), ('relief', SUNKEN),
                           ('selectmode', SINGLE), ('takefocus', 1)]:
            if not kw.has_key(var): kw[var] = value
        
        self.list = Listbox(self, kw)
        self.sbar.config(command = self.list.yview)
        self.sbar1.config(command = self.list.xview, orient='horizontal')
        self.list.config(xscrollcommand = self.sbar1.set, yscrollcommand = self.sbar.set)
        self.list.grid(row=0, column=0, sticky=NSEW)
        self.sbar.grid(row=0, column=1, sticky=NSEW)
        self.sbar1.grid(row=1, column=0, sticky=NSEW)

        self.rowconfigure(0, weight=1)
        self.columnconfigure(0, weight=1)

        self.focus_force()
        

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

class GameList(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 (=path) of the database
        '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 ...) 
        'stringlist': A list of strings from entries in 'data' which are not yet
                      displayed in the ScrolledList (to speed things up by inserting
                      many entries at once into the ScrolledList)
        """
    
    def __init__(self, parent, master, noGamesLabel, winPercLabel, gameinfo):
        ScrolledList.__init__(self, parent)
        self.list.config(width=52, height=10)
        self.list.bind('<Button-1>', self.printGameInfo)

        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('<Button-3>', self.rightMouseButton)

        self.master = 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 = []


    def rightMouseButton(self, event):
        
        index = self.list.nearest(event.y)
        if index == -1: return
        DBindex = 0
        while index >= len(self.DBlist[DBindex]['current']):
            index -= len(self.DBlist[DBindex]['current'])
            DBindex += 1
        if DBindex >= len(self.DBlist) or index > len(self.DBlist[DBindex]['current']): return
            
        filename = strip(os.path.join(self.DBlist[DBindex]['name'],
                                      self.DBlist[DBindex]['data'][self.DBlist[DBindex]['current'][index]][0] + '.sgf'))

        try:
            file = open(filename)
            sgf = file.read()
            file.close()
            c = Cursor(sgf)
            rootNode = c.getRootNode()
        except:
            return

        backup = copy(rootNode)

        newRootNode = self.master.gameinfo(rootNode)
        if backup != newRootNode:
            c.updateRootNode(newRootNode)
            try:
                file = open(filename, 'w')
                file.write(c.output())
                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.master.openViewer(index, label)


    def up(self, event):
        if not self.list.curselection(): return
        index = int(self.list.curselection()[0])
        if index != 0:
            self.list.select_clear(index)
            self.list.select_set(index-1)
            self.list.see(index-1)
            self.printGameInfo(None, index-1)

    def down(self, event):
        if not self.list.curselection(): return
        index = int(self.list.curselection()[0])
        if index != self.list.size()-1:
            self.list.select_clear(index)
            self.list.select_set(index+1)
            self.list.see(index+1)
            self.printGameInfo(None, index+1)

    def pgup(self, event):
        if not self.list.curselection(): return
        index = int(self.list.curselection()[0])
        if index >= 10:
            self.list.select_clear(index)
            self.list.select_set(index-10)
            self.list.see(index-10)
            self.printGameInfo(None, index-10)
        elif self.list.size():
            self.list.select_clear(index)
            self.list.select_set(0)
            self.list.see(0)
            self.printGameInfo(None, 0)

    def pgdown(self, event):
        if not self.list.curselection(): return
        index = int(self.list.curselection()[0])
        if index <= self.list.size()-10:
            self.list.select_clear(index)
            self.list.select_set(index+10)
            self.list.see(index+10)
            self.printGameInfo(None, index+10)
        elif self.list.size():
            self.list.select_clear(index)
            self.list.select_set(self.list.size()-1)
            self.list.see(END)
            self.printGameInfo(None, self.list.size()-1)

    def delete(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.list.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']: 

            if d[4] == 'B': self.Bwins = self.Bwins + 1
            elif d[4] == 'W': self.Wwins = self.Wwins + 1
            else: self.Owins = self.Owins + 1
        
            s = d[0] + ': ' + d[3] + ' - ' + d[2] + ' (' + d[4] + ') ' # filename: PW-PB (RES)
            self.DBlist[i]['stringlist'].append(s)


    def appendC(self, db, i, res = ''):
        """ Append an entry to self.current """
        
        db['current'].append(i)
        db['results'].append(res)
        self.appendClist.append((db['data'][i], res))


    def reset(self):
        """ Reset the list, s.t. it includes all the games from self.data. """
        for db in self.DBlist:
            if not db['disabled']:
                db['current'] = array('L', range(len(db['data'])))
                db['results'] = [''] * len(db['data'])
                self.appendClist += map(None, db['data'], db['results'])
            else:
                db['current'] = array('L')
                db['results'] = []
        self.list.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 = []
            
            for d, res in self.appendClist:
                if d[4] == 'B': self.Bwins = self.Bwins + 1
                elif d[4] == 'W': self.Wwins = self.Wwins + 1
                else: self.Owins = self.Owins + 1
        
                s = d[0] + ': ' + d[3] + ' - ' + d[2] + ' (' + d[4] + ') ' + res
                strl.append(s)
            apply(self.list.insert, [END] + strl)

            self.appendClist = []

        for db in self.DBlist:
            if db['stringlist']:                              # display append'ed entries
                apply(self.list.insert, [END] + db['stringlist'])

                db['current'].extend(array('L', range(len(db['data'])-len(db['stringlist']), len(db['data']))))
            db['results'] = db['results'] + [''] * len(db['stringlist'])
            db['stringlist'] = []

        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)

        if index == -1:
            return

        DBindex = 0

        while index >= len(self.DBlist[DBindex]['current']):
            index -= len(self.DBlist[DBindex]['current'])
            DBindex += 1

        if DBindex >= len(self.DBlist) or index > len(self.DBlist[DBindex]['current']): return
            
        filename = strip(os.path.join(self.DBlist[DBindex]['name'],
                                      self.DBlist[DBindex]['data'][self.DBlist[DBindex]['current'][index]][0] + '.sgf'))

        try:
            f = open(filename)
            sgf = f.read()
            f.close()
            
            node = Cursor(sgf).getRootNode()
            
        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]

        t = t + ' - '

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

        if node.has_key('RE'): t = t + ', ' + node['RE'][0]
        if node.has_key('KM'): t = t + ' (Komi ' + node['KM'][0] + ')'
        if node.has_key('HA'): t = t + ' (Hcp ' + node['HA'][0] + ')'

        t = t + '\n'

        if node.has_key('EV'): t = t + node['EV'][0] + ', '
        if node.has_key('RO'): t = t + node['RO'][0] + ', '
        if node.has_key('DT'): t = t + node['DT'][0] + '\n'

        if node.has_key('GC'):
            gc = node['GC'][0]
            gc = replace(gc, '\n\r', ' ')
            gc = replace(gc, '\r\n', ' ')
            gc = replace(gc, '\r', ' ')
            gc = replace(gc, '\n', ' ')
            
            t = t + gc

        self.gameinfo.config(state=NORMAL)
        self.gameinfo.delete('1.0', END)
        self.gameinfo.insert('1.0', t)
        self.gameinfo.config(state=DISABLED)

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

    def readDB(self, dbpath):
        """ Read the database files containing the information for a pattern search. """

        try:
            posTable = array('L')
            mainlistArr = array('B')
            finalpos = array('B')
            hashT = array('l')
            hash = array('B')

            filelist = [(mainlistArr, 'lists'), (posTable, 'posTable'),
                        (finalpos, 'finalpos'), 
                        (hashT, 'hashT'), (hash, 'hash')]

            for var, filename in filelist:
                file = open(os.path.join(dbpath, filename+'.db'), 'rb')
                while 1:
                    try: var.fromfile(file, 1000000)
                    except EOFError: break
                file.close()

            return tuple([x[0] for x in filelist])
                        
        except IOError:
            showwarning('Error', 'Database files not found: '+dbpath)
            return None, None, None, None, None

    def checkDuplicate(self, sig, pos, strict):                                   
        """ Check if a game with Dyer signature sig and final position pos
            occurs among the games in self.data. """
        
        duplist = []
        for db in self.DBlist:
            if db['disabled']: continue
            for g in db['data']:
                if sig == g[5]:
                    if not strict:
                        duplist.append(os.path.join(db['name'], g[0]))
                    else:
                        mainlistArr, posTable, finalpos, hashT, hash = self.readDB(db['name'])
                        if not finalpos: continue
                        if pos == finalpos[150*g[1]:150*g[1]+100]:
                            duplist.append(os.path.join(db['name'], g[0]))
        return duplist


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

class PrevSearchesStack:

    """ This class is a stack which contains the data of the previous searches,
    s.t. one can return to the previous search with the back button. This is a
    little bit tricky since we have to distinguish if we want to return
    to the very last search (if after it something changed on the board)
    or to the search before that. Thus the very last search is stored in
    self.previous, and the rest in a list self.data. """

    def __init__(self, maxLength, boardChanged):
        self.data = []
        self.previous = ()
        self.maxLength = maxLength
        self.boardChanged = boardChanged
        
    def append(self, s):
        if self.previous:
            if len(self.data) >= self.maxLength.get() > 0 :
                del self.data[0]
            self.data.append(self.previous)
        self.boardChanged.set(0)
        
        self.previous = s

    def pop(self):
        if not self.previous: return

        if not self.boardChanged.get() or not self.previous[0]:
            if not self.data:
                self.previous = ()
            else:
                self.previous = self.data.pop()

        return self.previous

    def clear(self):
        self.data = []
        self.previous = ()

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

class Message(ScrolledText):
    """ A ScrolledText widget which is usually DISABLED (i.e. the user cannot
        enter any text), and which automatically scrolls down upon insertion. """

    def __init__(self, window):
        ScrolledText.__init__(self, window, height=8, width=75, relief=SUNKEN, wrap=WORD)
        self.config(state=DISABLED)

    def insert(self, pos, text):
        self.config(state=NORMAL)
        ScrolledText.insert(self, pos, text)
        self.see(END)
        self.config(state=DISABLED)

    def delete(self, pos1, pos2):
        self.config(state=NORMAL)
        ScrolledText.delete(self, pos1, pos2)
        self.config(state=DISABLED)

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

class ProgressBar(Canvas):
    """ A simple progress bar. """
    
    def __init__(self, parent, width=390, font = None, colors = None):
        if not font:
            self.font = (StringVar(), IntVar(), StringVar())
            self.font[0].set('Helvetica')
            self.font[1].set(8)
            self.font[2].set('')
        else: self.font = font
        if not colors:
            self.colors = (StringVar(), StringVar())
            self.colors[0].set('black')
            self.colors[1].set('white')
        else: self.colors = colors
        self.width = width
        Canvas.__init__(self, parent, height=15, width=width, highlightthickness=0,
                        borderwidth=2, relief=RIDGE)

        self.current, self.previous = -1, -1
        
    def redraw(self, percent):
        self.delete(ALL)
        x = int(self.width*percent+3)
        self.create_rectangle(0,0,x,18, fill=self.colors[0].get(), outline='')
        self.update()
        

    def clear(self):
        self.delete(ALL)
        
    def write(self, text):
        self.create_text(self.width-10,9, text=text, fill=self.colors[1].get(),
                         font=(self.font[0].get(), self.font[1].get(), self.font[2].get()), anchor=E)
        
# ---------------------------------------------------------------------------------------



class customMenus:

    def __init__(self, master):
        self.mainMenu = master.mainMenu
        self.master = master
        self.htmlpath = os.curdir
        self.windowOpen = 0
        self.path = os.curdir

    def compare(self, entry1, entry2):
        if entry1['name'] < entry2['name']: return -1
        elif entry1['name'] == entry2['name']: return 0
        elif entry1['name'] > entry2['name']: return 1 

    def buildMenus(self, reload=1, alternativePath = ''):
        """
        format of menuList entries:
        { 'name' : name (which will be displayed in the menu,
          'entries': [list of entries]
          'subm' : [list of submenus]  }

        format of entry:
        { 'name' : name which will be displayed in the menu,
          'file' : name of a html file which will be displayed upon clicking
                   this entry (or empty),
          'gisearch' : parameters of a game info search to be done when
                       this is chosen,
          'psearch' : pattern and options for a pattern search }

        format of submenu: {} as before
        """

        if reload:

            try:
                file = open(os.path.join(self.path, 'menus.def'))      
                self.customMenuList = cPickle.load(file)
                file.close()
            except IOError:
                if alternativePath:
                    try:
                        file = open(os.path.join(alternativePath, 'menus.def'))      
                        self.customMenuList = cPickle.load(file)
                        file.close()
                    except IOError:
                        self.customMenuList = []
                else:
                    self.customMenuList = []
                    
        self.noOfMenus = len(self.customMenuList)
        
        # build menus

        self.customMenuCommands = []

        self.mmIndex = 3

        self.customMenuList.sort(self.compare)

        for item in self.customMenuList:
            m = Menu(self.mainMenu)
            self.mainMenu.insert_cascade(self.mmIndex, menu=m, label = item['name'])
            self.mmIndex += 1
   
            self.addMenu(item['subm'], m)

            item['entries'].sort(self.compare)
            
            for e in item['entries']:
        
                m.add_command(label=e[