Gallows

Szófejtő
A Tkinter modul által kínált lehetőségek egy részét bemutató program

Ajánlott irodalom
Gérard Swinnen : Tanuljunk meg programozni Python nyelven	pdf
An Introduction to Tkinter by Fredrik Lundh	online
A Comprehensive Introduction to Python Programming and GUI Design ...	online és pdf
A tervezett alkalmazás:
Az alkalmazás file-jai zip-pelve. (A .txt file-ok tartalmazzák a kitalálandó szavakat, illetve kifejezéseket.)
#! /usr/bin/env python
# -*- coding: iso-8859-2 -*-

# PyPendu - (c) 2003 Rachel Vaudron <rachel@lazaret.unice.fr>
#
#  A "Szófejtő játék" lényegében két ablakból áll: az egyikben maga a játék zajlik és a másikba fogjuk beirni az opciókat
#
# You're welcome to redistribute this software under the
# terms of the GNU General Public Licence version 2.0
# or, at your option, any higher version.
#
# You can read the complete GNU GPL in the file COPYING
# which should come along with this software, or visit
# the Free Software Foundation's WEB site http://www.fsf.org



from Tkinter import *
import string
import tkFileDialog 
import tkMessageBox
import tkColorChooser
import random

class Application:
    def __init__(self, master):
        """Az Application class inicializálása"""
        
        self.master = master

        # változók inicializálása<
        self.word_list = []
        self.new_word = ""
        self.cpt = 0
        self.fin = 0
        self.fin_mot = 0
        self.score_total = self.score_win = 0

        self.background_colour = "Black"
        self.text_colour = "Yellow"
        self.text_font = "Courier 16 bold"
        self.text_size = "16"
        self.name = "Jatekos"
        self.style_bold = ""
        self.style_italic = ""
        
        #egy frame widget létrehozása, ami a root ablak gyermeke
        self.frame = Frame(self.master, bg = self.background_colour, width = 600, height = 400)
	#a widget-eket a grid geometria manager-rel pozicionáljuk
        self.frame.grid(row=0, column=0)
                                            
        #menücsik konstruálása
        self.construct_menu(self.master)

	#szövegterület konstruálása, ahová az eredményt ki fogjuk irni
        self.display_word=Text(self.frame, height = 1, width=1 )
        
	#elkezdjük a partit
        self.partie()
        
###################################
        # LISTA_KINYERÉSE
###################################
    def recover_list(self):
        '''Megnyitja a szolistat tartalmazo file-t
           Kinyeri a listat a file-bol
           Veletlenszeruen valaszt egy szot'''

        #megnyitjuk olvasásra a szavak listáját tartalmazó file-t
        file = open(self.file, "r")
        
        self.word_list = []

        #kiolvassuk a file összes sorát
        lines = file.readlines()

	#mindegyik sor végéröl eltávolitjuk a CR karaktert
	#és a szólistához hozzátesszük a sort, ami egy szó vagy egy kifejezés
        for line in lines:
            self.word_list.append(line.strip())

        #nem felejtjük el lezárni a file-t
        file.close()

        # kisorsoljuk a szólista valamelyik szavának az indexét
        self.index_word = random.randint(0, len(self.word_list))
        
    def go(self):
        '''A partit a választasunk szerinti listával inditja'''
        self.file = self.askopenfile()
        self.recover_list()
        self.partie()
        
    def go_mots(self):
        '''A partit egy elöre definiált szavakból álló listával inditja'''
        self.file = "./word_list.txt"
        self.recover_list()
        self.partie()
        
    def go_expressions(self):
        '''A partit egy elöre definiált kifejezésekbol állo listával inditja'''
        self.file = "./expression_list.txt"
        self.recover_list()
        self.partie()
###################################
        # PARTI
###################################
    def partie(self):
	'''menedzsel egy játékot'''
        if not self.word_list :    
            return
        
        # Az eredménysávot hozza létre
        score = "Score " + self.name.capitalize() + " : " + str(self.score_win) + " / " + str(self.score_total)
        self.score=Label(self.frame, relief="raised", height=2,  width=80, text=score, font = self.text_font, bg = self.background_colour, fg=self.text_colour )
        self.score.grid(row=8, columnspan=13, column=0)

        #Létrehozza a vásznat (canvas), ahová majd kirajzolja az akasztófát 
        self.can = Canvas(self.frame, bg = "white", width = 150, height = 200, cursor="pirate", border=2)
        self.can.grid(row=2, rowspan=7, column=13, columnspan=5)
            
        # minden szó számára saját változókat inicializálunk 
        self.counter_ok = 0
        self.counter_error = 0
        self.texte = ""
        self.new_word = ""

        # kinyerjük az új szót
        self.mot = self.word_list[self.index_word].upper()

        # egy listát generálunk, ami az abc betüit tartalmazza
        self.alphabet = []
        for i in range(26) :
            self.alphabet.append(chr(i + ord('A')))

        # betünként létrehozunk egy gombot
        for character in self.alphabet:
            namebutton = "button_%s" % character
	    # mindegyik gombot egy példány-attribútum formájában tárolunk, aminek a neve "button_", amit a megfelelö betű követ a setattr függvénynek köszönhetöen
	    
            setattr(self, namebutton, Button(self.frame, text=character))
            index = self.alphabet.index(character)

            if index < 13:
                colonne = index
                line = 6
            else:
                colonne = index - 13
                line = 7

	    #Kiiratjuk ezeket a gombokat. A getattr függvényt alkalmazzuk, ami lehetövé teszi a gombobjektumok kinyerését a setattr függvényekkel olymódon, hogy megadjuk a gombok számított nevét
            getattr(self, namebutton).grid(row=line, column=colonne)
	    # minden alkalommal, amikor a balegérgombbal kattintunk,
	    # hivni fogjuk a self.gallows metodust, aminek parameterként átadjuk a namebutton -t
            getattr(self, namebutton).bind("<Button-1>", self.gallows)

	#létrehozunk egy zónát, ahova kiirjuk az eredményül kapott szót
        for j in range(0, len(self.word_list[self.index_word])):
            if self.word_list[self.index_word][j] in (" ","'",",","-","_"):
                self.texte = self.texte + self.word_list[self.index_word][j]
                self.counter_ok = self.counter_ok + 1            
            else:
                self.texte = self.texte + "-"
        try :
            self.display_word.delete("0.0",END)
        except AttributeError, msg :    
            pass
	# kiíratjuk a szót esetleg kifejezést a szóközökkel vagy az aposztrofokkal
        self.display_word.config(width=len(self.word_list[self.index_word]), font="Courier 20 bold", relief="sunken", background = self.background_colour, foreground=self.text_colour, spacing1 = 10, spacing2 = 10)
        self.display_word.insert(INSERT, self.texte)
        self.display_word.grid(row=3, columnspan=13)
                        
#####################################
    # ASKOPENFILE
#####################################
    def askopenfile(self):
        '''kinyerjuk a kezelend? lista nevét'''
        file = tkFileDialog.askopenfilename(title = 'Megnyit egy létező file-t')
        return file
 
#######################################
    # GALLOWS - AKASZTÓFA
######################################
    def gallows(self, evenement):
	'''Kinyeri azt a betüt, amire rákattintottunk
           Ellenörzi, hogy szerepel-e a szoban
           es annak megfeleloen reagal'''

        character = None
	
        #mivel minden gomb ugyanahhoz a metódushoz van asszociálva
	#ezért ki kell nyernünk a lenyomott gombnak megfelelö betűt.
	#Ezért megkonstruálunk egy olyan listát, ami az összes olyan button típusú widget-et tartalmazza, aminek a neve "button" -nal kezdödik
        buttons = [attrib for attrib in dir(self) if attrib.startswith("button_")] 

	#utána bejárjuk ezt a listát és minden gombnévre kinyerjük 
	#a megfelelö (widget objektum) attribútumot.
        for b in buttons :
	    #az eseményt elindító objektummal összehasonlítjuk
	    #és ha egyenlöség áll fenn, akkor ismerjük a gomb nevét
	    #tehát kikövetkeztethetjük a választott betüt
            if evenement.widget is getattr(self, b) :        
                character =  b.split('_')[1]
                break

        # ha kinyertünk egy betüt
        # inaktiváljuk a betüvel asszociált gombot
        # a gombot nem-klikkelhetövé tesszük
        if character is not None :        
            evenement.widget.configure(state="disabled")
            evenement.widget.unbind("")
            
            #ha még nem találtuk meg a szó minden betüjét
            if self.counter_ok <= len(self.mot) and self.counter_error<6:
                found=0
                
                # a keresett szó minden betüjét bejárjuk
                for i in range(0, len(self.mot)):
                    # összehasonlítjuk öket azzal a betűvel, amit megadtunk
                    # ha az utóbbi benne van a szóban
                    # akkor 1-gyel megnöveljük a találatszámlálót
                    if character == self.mot[i]:
                        self.new_word = self.new_word + character
                        found=1
                        self.counter_ok = self.counter_ok + 1
                    # ha nem
                    else:                        
                        self.new_word = self.new_word + self.texte[i]
                # ha ezt a betüt nem tartalmazza a szó
                if found == 0 or self.new_word.find(character)==-1:
                    # ha nem, megnöveljük 1-gyel a hibaszámlálót
                    # és hívjuk az akasztófa egy darabját kirajzoló metódust
                    self.counter_error = self.counter_error + 1
                    self.draw_gallows(self.counter_error)

                #beszúrjuk a szövegzóna elejére a megtalált betüt vagy betüket
                #tartalmazó új szót
                self.display_word.insert("0.0", self.new_word)
                self.display_word.grid(row=3, columnspan=13)
                #reinicializáljuk a változóinkat
                self.texte = self.new_word
                self.new_word = ""
                #ellenörizzük, hogy hol tart a játék
                self.win_lose()

    def draw_gallows(self,cpt):
        '''A vasznon (canvas) elemrol elemre rajzolja az akasztofat'''
        if cpt == 1:
            self.can.create_rectangle(10,180,50,190, fill = 'black')
        elif cpt == 2:
            self.can.create_line(30,180,30,20, fill = 'black', width='2')
        elif cpt == 3:
            self.can.create_line(30,20,90,20, fill = 'black', width='2')
        elif cpt == 4:
            self.can.create_line(30,40,50,20, fill = 'black', width='2')
        elif cpt == 5:
            self.can.create_line(90,20,90,60, fill = 'black', width='2')
        elif cpt == 6:
            self.photo = PhotoImage(file = "tux_couleur.gif")
            p = self.can.create_image(90,110,image=self.photo)

           
#########################################
                # NYERT_VESZTETT
#########################################
    def win_lose(self):
        '''Megvizsgálja, hogy a játékos gyözött-e,
	vesztett-e vagy éppen egy szót keres'''

        #ha nincs még 6 hibánk
        if self.counter_error < 6:

            #ha még nem találtuk meg a betüket, folytatjuk
            if self.counter_ok < len(self.word_list[self.index_word]):
                self.new_word = ""
                
            elif  self.counter_ok == len(self.word_list[self.index_word]) :
                # ha nem, amennyiben a számláló megfelelö
                # gratulálunk és megnyitunk egy párbeszéddobozt,  
                # hogy megtudjuk ugyanazzal a szólistával folytassuk-e
                if tkMessageBox.askyesno("Nyert !", "Bravo !!! Akarja folytatni ?"):
                    #véletlenszerüen választunk egy szót a listából
                    self.index_word = random.randint(0, len(self.word_list) - 1)
                    #a szamlalot 0-ra állítjuk
                    self.counter_ok = self.counter_error = 0
                    self.new_word = ""
                    self.texte = ""

                    #megnöveljuk a pontszámot
                    self.score_total = self.score_total + 1
                    self.score_win = self.score_win + 1

                    #töröljük az akasztófát és tux-ot
                    self.can.delete(ALL)

                    #újra kezdjük a partit
                    self.partie()
                    
                # ha nem, mindent leállítunk és leromboljuk a föablakot
                else:
                    self.master.destroy()

        else:
            #ha nem, akkor már túl sokat hibáztunk
            # azt mondjuk kár és megkérdezzük akarja-e a játékot folytatni
            if tkMessageBox.askyesno("Vesztett !", " A megfejtendö szó : %s volt, Kár !!! Akarja folytatni ?" % self.word_list[self.index_word].upper()):
                #ugyanabból a listából véletlenszerűen kiválasztunk egy szót
                self.index_word = random.randint(0, len(self.word_list) - 1)
                #reinicializálunk
                self.counter_ok = self.counter_error = 0
                self.new_word = ""
                self.texte = ""

                #az összpontszámot megnöveljuk 1-gyel
                self.score_total = self.score_total + 1

                #töröljük az akasztófát és tux-ot
                self.can.delete(ALL)

                #újra kezdjük a partit
                self.partie()
                
            # ha nem, mindent leállítunk és leromboljuk a föablakot
            else:
                self.master.destroy()
    
##############################################################
#       AZ OPCIÓABLAK LÉTREHOZÁSA
##############################################################

    def option(self):
    #################
        '''Létrehozza az Options ablakot'''
        # létrehozunk egy ablakot, adunk neki egy cimet
        self.window_option = Toplevel(self.master)
        self.window_option.title("Beállítások módosítása")
        self.window_option.grid()

        # a háttérszín kiválasztásához létrehozunk egy promptot
        self.txt = Label(self.window_option,text="Háttérszín")
        self.txt.grid(row=0, column=0)
        #létrehozunk egy gombot, ami lehetövé teszi a színválasztó indítását
        self.background_button = Button(self.window_option,text=" ", command=self.choose_background_colour, bg=self.background_colour)       
        self.background_button.grid(row=0, column=1)        

        #az ablakot alkotó különbözö metódusokat hívjuk
        self.choose_text_colour()        
        self.choose_text_style()
        self.choose_text_size()
        self.entrer_name()
        
        #létrehozzuk az  "Valider" gombot, ami ha rákattintunk
        #hívni fogja a recover_option_value függvényt
        button_ok = Button(self.window_option, text="Valider", command=self.recover_option_value)
        button_ok.grid(row= 12 , column = 2)


    def recover_option_value(self):
    ##############################
        '''Kinyeri és megismétli az opciók ablakbeli változások eredményét'''
	
        #kinyerjük a checkbutton-ok értékét
        if self.state_button_bold.get() == "ok_bold":
                self.style_bold = "bold"

        if self.state_button_italic.get() == "ok_italic":
                self.style_italic = "italic"

        #kinyerjük a rádiógomb értékét
        self.text_colour = self.colour_text_var.get()

	#a méretlistából kiválasztott értéket nyerjük ki
        #Figyelem : a curselection metódus a kiválasztott tételek indexeinek a listáját adja visszatérési értékül
        selection = self.list_size.curselection()
        if selection:
            self.text_size = self.list[int(selection[0])]
            
        #kinyerjük a nevet
        name = self.entry_name.get()
        if name != '':
            self.name = name      

        #kiszámoljuk az új szövegstílust
        self.text_font = "Courier " + self.text_size + " " + self.style_bold + " " + self.style_italic
        #végül zárjuk a beállítások ablakot, hogy visszatérjünk a föablakba
        self.window_option.destroy()

        #leromboljuk a menüt és újra létrehozzuk
        #azért, hogy minden módosítás figyelembe legyen véve
        self.menu.destroy()
        self.construct_menu(self.master)
        #leromboljuk a frame-et
        self.frame.configure(bg=self.background_colour)
        #és hívjuk a partie() metódust, ami újra létrehozza a frame-et
        self.partie()

    def choose_background_colour(self):
    ###############################
        '''A háttérszín választást lehetövé tevö zónát hozza létre.
        Hívja az askcolor metódust'''

        #az askcolor() metódus visszatérési értékét
        #a result változóban tároljuk. Ez a következöre hasonlit :"{192 81 192} #c051c0"
        result = tkColorChooser.askcolor()
        # a második tuple-t választjuk
        self.background_colour = result[1]
        self.background_button.configure(bg=self.background_colour)
        
    def choose_text_colour(self):
    ################################
        '''Kiíratja a szövegszín kiválasztását lehetövé tevö rádiógombokat'''
        #a prompt generálása
        self.txt = Label(self.window_option,text="A szöveg színe :")
        self.txt.grid(row=2, column=0)

        #gombok létrehozása
        self.colour_list=[('Fekete','Black'),('Kék','Blue'),('Piros','Red'),('Sárga','Yellow')]
        #a valasztott szin kinyeresehez létrehozunk egy string tipusu valtozot
        self.colour_text_var = StringVar()
        #ez lesz az aktuális szín, ami alapértelmezetten van választva
        self.colour_text_var.set(self.text_colour)

        i = 0
        for (colour,color) in self.colour_list:
            self.radio = Radiobutton(self.window_option, text=colour, variable=self.colour_text_var, value=color, padx=1)
            self.radio.grid(row=i + 2, column=1)
            i=i+1

    def choose_text_style(self):
    ##############################
        '''Kiiratja a checkbutton-okat, amik 
	lehetövé teszik a szövegstílus kiválasztását'''
        #a prompt létrehozása
        self.label_style = Label(self.window_option, text = "Szövegstílus:")
        self.label_style.grid(row=7, column=0)

        #a 'bold' checkbutton létrehozása
	#létrehozunk egy string típusú változót a gomb értékének kinyeréséhez
        self.state_button_bold = StringVar()
        button_style_bold = Checkbutton(self.window_option, text="Szöveg: bold", variable=self.state_button_bold, onvalue="ok_bold", offvalue="not_bold", justify=LEFT)
        button_style_bold.grid(row=7, column=2) 

        #az'italic' checkbutton létrehozása
        self.state_button_italic = StringVar()
        button_style_italic = Checkbutton(self.window_option, text="Szövegstílus: italic", variable=self.state_button_italic, onvalue="ok_italic", offvalue="not_italic", justify=LEFT)
        button_style_italic.grid(row=8, column=2) 

    def choose_text_size(self):
    ###############################
        '''Kiir egy görgetösávval ellátott listát,
	ami a szövegméret kiválasztására való'''
        #a prompt létrehozása
        self.label_size = Label(self.window_option, text = "Szövegméret:")
        self.label_size.grid(row=9, column=0)

        #Listbox-ot hoz létre
        self.list_size =  Listbox(self.window_option)
        self.list_size.grid(row=9, column=2)
        self.list = ["10","12","14","16","18","20","22","24","26"]
        for size in self.list:
            self.list_size.insert(END,size)
            
        #ennek a listának a konfigurálása
        self.list_size.configure(height=4)
        
        #az alapértelmezetten választott hossz 16 lesz
        self.list_size.activate(self.list.index("16"))

        #görgetösávot hoz létre
        self.scroll = Scrollbar(self.window_option, command = self.list_size.yview)
        self.list_size.configure(yscrollcommand = self.scroll.set)
        self.scroll.grid(row=9, column=3)

    def entrer_name(self):
    #####################
        '''Létrehozza az "Irja be a nevet prompt-ot:" és
         leétrehoz egy adatbeviteli mezöt'''
        self.label_name = Label(self.window_option, text = "Írja be a nevét:")
        self.label_name.grid(row=11, column=0)
        self.entry_name = Entry(self.window_option)
        self.entry_name.grid(row=11, column=2) 

################################################
#                 MENÜ
################################################
    def construct_menu(self, master):
        '''Menüsort hoz létre a címsor alatt'''
        #létrehozzuk a Menü  widget-et, ami a frame-ünk gyermeke.
        self.menu = Menu(master, font = self.text_font, bg=self.background_colour, fg=self.text_colour)
        master.config(menu = self.menu)

        #Megkonstruáljuk a self.menu -höz kapcsolt 'Játék' menüt.
        ######################################################
        self.menu_game = Menu(self.menu, font = self.text_font, bg=self.background_colour, fg=self.text_colour)
        self.menu.add_cascade(label = 'Játék', menu = self.menu_game,)
        
        #Hozzáadjuk az elsö menüpontot
        self.menu_game.add_command(label = 'Megnyitunk egy szólistát', command=self.go)
        
        #Utána létrehozzuk az 'Elöre definiált listák' almenüt.
        #-------------------------------------------------
        self.menu_game.menu = Menu(self.menu_game)
        self.menu_game.menu.predefini = Menu(self.menu_game.menu, font = self.text_font, bg=self.background_colour, fg=self.text_colour)

        #Majd ennek az almenünek két menüpontját definiáljuk.
        self.menu_game.menu.predefini.add_command(label = 'Játék a szavakkal', command=self.go_mots)#("./word_list.txt"))
        self.menu_game.menu.predefini.add_command(label = 'Játék a kifejezésekkel', command=self.go_expressions)#("./liste_expressions.txt"))
	#Egy második menüpontot adunk a 'Játék' fömenühoz.
        self.menu_game.add_cascade(label = 'Elöre definiált szavak listái', menu = self.menu_game.menu.predefini)         
	#és a harmadik - master.destroy - utasitást, ami megöli a master widget-et es bezárja a föablakot
        self.menu_game.add_command(label = 'Kilépés', command = master.destroy)

        #létrehozzuk a 'Beállitások' cascade menüt
        #################################
        #hozzákapcsoljuk a self.menu -höz ugyanhoz a szinthez, mint amin a 'Játék' menü van
        self.menu_option = Menu(self.menu, font=self.text_font, bg=self.background_colour, fg=self.text_colour)
        self.menu.add_cascade(label = 'Beállítások', menu = self.menu_option)
        self.menu_option.add_command(label = 'Föopciók', command = self.option)

        #létrehozzuk a Help menüt
        ##########################
        self.menu_help = Menu(self.menu, font=self.text_font, bg=self.background_colour, fg=self.text_colour)
        self.menu.add_cascade(label = 'Help', menu = self.menu_help)
        self.menu_help.add_command(label = 'A propos...', command = self.apropos)

    def apropos(self):
        '''Az apropos ablakot hozza létre'''
        self.window_apropos = Toplevel(self.master)
        self.window_apropos.title("A propos...")
        self.window_apropos.grid()
        self.txt=Text(self.window_apropos, height = 4, width=60, font=self.text_font, bg = self.background_colour, fg = self.text_colour)
        self.txt.insert(END, "Üdvözöllek a szófejtő játékban\nEz egy példaprogram a Planéte Linux számára\n")
        self.txt.insert(END, "Copyright 2003 Rachel Vaudron\nKöszönet Fleur-nek és Véronique-nak")
        self.txt.grid(row=1, column=1)


#####################################
#       FOPROGRAM
#####################################
# játékonként egyetlen root widget generálása
root = Tk()
root.title("Szófejtő")

# létrehozzuk az application class egy példányát,
# aminek az a hatása, hogy automatikusan elinditja a __példány init__ metódusát
myapplication = Application(root)

# létrehozzuk a Tkinter eseményfigyelöjét. Ez ami minden eseményt megvizsgál, melyeket a billentyüzettel vagy
# az egérrel generálunk
root.mainloop()
Szófejtő A Tkinter modul által kínált lehetőségek egy részét bemutató program

Szófejtő
A Tkinter modul által kínált lehetőségek egy részét bemutató program
