import time

import math

import os

class Clock(Canvas):

    """ This is a simple stop watch displayed on a Tkinter canvas.

            Does not work while the clock is running. """

        if not self.running:

            window = Toplevel()

                       variable = self.maxTime, from_=0, to = 480,

                       tickinterval = 60, showvalue=YES, orient='horizontal')

            sc.pack()

#!/usr/bin/python

# File: uligo.py

##   This is the main part of uliGo 0.3, a program for practicing

from math import sqrt

import webbrowser

from sgfparser import *

import clock

    def __init__(self, master):

        p = os.path.join(sys.path[0],'gifs')

        self.label = Label(self, bd=1, anchor=W)

        self.label.pack(fill=X)

    def set(self, status=None):

        if   status == 'solved1':

            if self.gifsFound: self.label.config(image = self.solved1)

        elif status == 'solved2':

            if self.gifsFound: self.label.config(image = self.solved2)

        elif status == 'wrong':

            if self.gifsFound: self.label.config(image = self.wrong)

        elif status == 'end':

            if self.gifsFound: self.label.config(image = self.end)

        else                    :

            if self.gifsFound: self.label.config(image = self.empty)

            else:              self.label.config(text='')

            rightPercentage = ' (' + str(self.noRight*100/self.pbmsAsked) + ' % )'

            wrongPercentage = ' (' + str(100 - (self.noRight*100/self.pbmsAsked) ) + ' % )'

        else: rightPercentage = wrongPercentage = ''

                      + rightPercentage + '\n' \

                      + wrongPercentage + '\n' \

            pickle.dump((self.noOfPbms, self.pbmsAsked, self.noRight, self.noWrong, \

                         self.current, self.handleCurrent, help, self.list),f)

            f.close()

    def changeModeQuit(self,w,h1,h2,e):

            the problems. """

        window = Toplevel()

        f1 = Frame(window)

        f2 = Frame(window)

        h1 = IntVar()

        h1.set(self.modeVar.get())

                         command=lambda e=e: e.config(state=DISABLED))

                         variable=h1, value=1,

                         command=lambda e=e: e.config(state=DISABLED))

                         variable=h1, value=2,

                         command=lambda e=e: e.config(state=NORMAL))

        h2 = IntVar()

        h2.set(0)

                          command = lambda s=self, w=window, h1=h1, h2=h2, e=e: s.changeModeQuit(w, h1, h2, e))

        b1.grid(row=0, column=0, sticky=NW)

        b2.grid(row=1, column=0, sticky=NW)

            cf = os.path.basename(self.currentFile)

        else:

            cf = 'None'

        self.statisticsText.set(s)

                self.statusbar.set('empty')

        except SGFError:

            return

                    self.board.placeMark(self.convCoord(c[color][0], self.orientation),'red')

                n = n.down

        except SGFError:

    def markAll(self):

                self.board.placeMark(self.convCoord(c[color][0], self.orientation),'blue')

                n = n.down

        except SGFError:

    def navSolutionNextMove(self, p):

                        self.cursor.previous()

        except SGFError:

    def undo2(self):

                    self.noMovesMade = self.noMovesMade - 1

        except SGFError:

    def undoTryVar(self):

                    self.noMovesMade = self.noMovesMade - 1

        except SGFError:

    def showSolution(self):

                self.noSolMoves=0

        except SGFError:

    def giveHint(self):

            self.board.state('normal', self.nextMove)

        except SGFError:

    def findNextParenthesis(self,s,i):

                s = f.read()

                f.close()

            except IOError:

                return

        else:

            self.currentFile = ''

            if self.currentFile: f.write('f '+self.currentFile +'\n')

            f.close()

        except IOError:

        self.saveOptions()

        self.frame.quit()

        try:

            c = EnhancedCursor(self.pbms[n], self.comments)

        except SGFError:

            return

        self.statusbar.set('empty')

        try:

            self.setup(c, ' ('+str(n+1)+')', 1, co, ori) # display problem

        except SGFError:

            return

        self.setWhoseTurn(self.inputColor)

    def setWhoseTurn(self, c):

        self.whoseTurnCanv.delete(ALL)

        if self.BsTurn:

        else:

    def backProblem(self):

            try:

                c = EnhancedCursor(self.pbms[n], self.comments)

            except SGFError:

                return

            self.statusbar.set('empty')

            try:

                self.setup(c, ' ('+str(n+1)+')', 1, co, ori) # display problem

            except SGFError:

                return

            self.setWhoseTurn(self.inputColor)

            self.cursor.reset()

            self.setup(self.cursor, ' ('+str(self.pbmRec.current+1)+')', changeOri) # display problem

        except SGFError:

            return

        self.setWhoseTurn(self.inputColor)

        try:

            os.remove(os.path.join(path, filename))

        except IOError:

        self.pbmRec = None

        self.readProblemColl(path, filename[:-4]+'.sgf')

                self.board.state('disabled')

        except SGFError:

    def restartGM(self):

                s = f.read()

                f.close()

            except IOError:

            self.board.clear()

            self.board.delMarks()

            cursor = EnhancedCursor(s, self.comments)

            self.setup(cursor, '', 0, self.invertColor, self.orientation)

        except SGFError:

            return

        self.whoseTurnCanv.delete(ALL)

                if d.has_key(tag): self.gameInfoCanv.create_text(10, 20+20*i, text=label+d[tag][0], anchor='w')

                i += 1

        except SGFError:

            return

        self.changeModeGM()

                self.board.undo()                                         # then delete it

                self.guessFailure(right_pos, (x,y))

        except SGFError:

    def guessSuccess(self):

        self.guessModeCanvas.create_text(110, 40, text = `perc` + '%', tags='non-bg')

        if self.cursor.atEnd:

    def guessFailure(self, right, pos):

                           100.0/(self.guessRightWrong[0] + self.guessRightWrong[1]))

                self.guessModeCanvas.create_text(110, 40, text = `perc` + '%', tags='non-bg')

            except ZeroDivisionError: pass

            return

        if not right or not pos:

        self.options.windowGeom = StringVar()

        self.options.windowGeom.set(self.master.geometry())

        self.options.saveToDisk(os.path.join(self.optionspath,'uligo.opt'),

    def loadOptions(self):

        t = t + 'The images of the board and the stones were created by Patrice Fontaine.'

        window = Toplevel()

        canv = Canvas(window, width=400,height=200, highlightthickness=0)

        canv.pack()

        text.config(state=DISABLED)

        text.pack()

        b.pack(side=RIGHT)

        window.update_idletasks()

        text.config(state=DISABLED)

        text.pack()

        b.pack(side=RIGHT)

        window.update_idletasks()

        self.guessModeCanvas = Canvas(self.clockFrame, height=80, width=150)

        self.options.modeVarGM = StringVar()

        self.options.modeVarGM.set('BW')

        self.BbuttonGM = Radiobutton(self.guessModeButtonFrame, text='B', variable=self.options.modeVarGM,

                                     indicatoron=0,

                                     command=self.changeModeGM, value='B')

        master.config(menu=menu)

        filemenu = Menu(menu)

        filemenu.add_separator()

        filemenu.add_separator()

        self.optionsmenu = Menu(menu)

        self.options.fuzzy = self.board.fuzzy    # make 'save options' easy

                                         variable=self.options.fuzzy, command=self.board.fuzzyStones)

        self.options.shadedStoneVar = self.board.shadedStoneVar

        self.options.shadedStoneVar.set(1)

                                         variable=self.options.shadedStoneVar)

        self.options.allowInvertColorVar = IntVar()

        self.options.allowInvertColorVar.set(1)

                                         variable=self.options.allowInvertColorVar)

        self.options.allowRotatingVar = IntVar()

        self.options.allowRotatingVar.set(1)

                                         variable=self.options.allowRotatingVar)

        self.options.animateSolVar = IntVar()

        self.options.animateSolVar.set(1)

        animSolMenu = Menu(self.optionsmenu)

        self.options.replaySpeedVar = IntVar()

        self.options.replaySpeedVar.set(2)

        replaySp = Menu(self.optionsmenu)

                                     command=self.clock.changeMaxtime)

        wrongmenu = Menu(self.optionsmenu)

        self.options.wrongVar = IntVar()

        self.options.wrongVar.set(1)

                                         variable=self.options.wrongVar, value=0)

                                         variable=self.options.wrongVar, value=1)

                                         variable=self.options.wrongVar, value=2)

                                     state=DISABLED)

        self.options.modeVar = IntVar()

        self.options.modeVar.set(0)

                                         command=self.board.resize)

        self.helpmenu = Menu(menu, name='help')

        # The buttons

        bframe = Frame(leftFrame)

        bframe.pack(side=TOP)

                                 underline=0)

                                 underline=0)

                                 underline = 0)

        self.frame.bind('<n>', lambda e, s=self.nextButton: s.invoke())

        self.frame.bind('<q>', lambda e, self=self: self.quit())

        b1frame.pack(side=TOP)

        self.showSolVar = IntVar()

                                              underline=0,

                                              indicatoron=0, variable=self.showSolVar, command=self.showSolution)

        self.frame.bind('<s>', lambda e, s=self.showSolutionButton: s.invoke())

        b2frame = Frame(leftFrame)

        b2frame.pack(side=TOP)

                                 underline=0)

        self.frame.bind('<u>', lambda e, s=self.undoButton: s.invoke())

        self.tryVarVar = IntVar()

                                        indicatoron=0, variable=self.tryVarVar, command=self.tryVariation)

        self.frame.bind('<t>', lambda e, s=self.tryVarButton: s.invoke())

        # try to load button images

        self.tkImages = []

        try:

            im = PhotoImage(file = os.path.join(self.uligopath, 'gifs', 'bgd.gif'))

            self.guessModeCanvas.create_image(75,40, image=im)

        self.statisticsWindow = Toplevel()

        self.statisticsWindow.withdraw()

        self.statisticsText = StringVar()

        Label(self.statisticsWindow, height=10, width=50, justify=LEFT, font = ('Courier', 11),

               textvariable=self.statisticsText).pack()

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

root = Tk()

root.withdraw()

try:

    root.option_readfile(os.path.join(sys.path[0], 'uligo.app'))

except TclError:

app = App(root)

root.protocol('WM_DELETE_WINDOW', app.quit)

root.resizable(1,1)

root.tkraise()

root.mainloop()