Anfänger frage wheel of fortune

Fragen zu Tkinter.
Alfons Mittelmeyer
User
Beiträge: 1715
Registriert: Freitag 31. Juli 2015, 13:34

BlackJack hat geschrieben:Bezüglich Effbot: „This is the Tkinter introduction, last updated in November 2005.“
Genau! Effbot ist also zwar schön zu lesen, weil es tkinter behandelt, aber ist veraltet. Die tcl/tk Dokumentation aber ist up to date und sollte daher unbedingt auch gelesen werden. Allerdings, wer schon liest bei jeder neuen tkinter Version die Doku durch und vergleicht, ob etwas hinzugekommen ist?

Mein GuiDesigner liest die config aus und zeigt daher fast alle Parameter. Nicht allle, da sich einige nicht mehr nach Erzeugen des Widgets verändern lassen, wie etwa 'screen' bei tk.Tk oder 'class'. Und einige sind durch etwas anderes ersetzt, wie etwa 'photoimage' mit Angabe des Files statt 'image'.

Und neu hinzugekommene config Parameter finden sich unter der Rubrik 'other'. Sind also gleich zu sehen.
BlackJack

Die Referenzdokumentation von New Mexico Tech ist aktueller, wenn auch noch nicht bei 8.6: http://infohost.nmt.edu/tcc/help/pubs/t ... index.html

Normalerweise gibt es bei neuen Versionen von Software eine Dokumentation der Änderungen.
ganja
User
Beiträge: 189
Registriert: Mittwoch 3. Dezember 2014, 07:44

Keiner eine Idee für mein Problem?
Alfons Mittelmeyer
User
Beiträge: 1715
Registriert: Freitag 31. Juli 2015, 13:34

ganja hat geschrieben:Keiner eine Idee für mein Problem?
Wenn Du eine ganz einfache Lösung haben möchtest und wenn Du Pillow installiert hast, dann gibt es etwas sehr Simples:

Man nehme ein Bildchen. Man nehme einmal das hier:

Bild

Man speichere es als fortune.png ab.

Und dann braucht man auch keinen Canvas, sondern ein Label genügt:

Code: Alles auswählen

# -*- coding: utf-8 -*-

try:
    import tkinter as tk
except ImportError:
    import Tkinter as tk

from PIL import Image,ImageTk

class Application(tk.Tk):

    def __init__(self,**kwargs):
        tk.Tk.__init__(self,**kwargs)
        # widget definitions ===================================
        self.label_pil_img = Image.open('fortune.png')
        
        self.label = tk.Label(self)
        self.label.pack()
        self.angle=0
        self.img_rotate()
        

    def img_rotate(self):
        self.angle += 5
        self.img_new = ImageTk.PhotoImage(self.label_pil_img.rotate(self.angle))
        self.label['image'] = self.img_new
        self.after(1,self.img_rotate)

if __name__ == '__main__':
    Application().mainloop()
Na, was hältst Du davon?

Schöner natürlich wäre dies. Du bastelst mit Deinen Kindern so eine Scheibe, und ihr bemalt sie. Dann fotografierst Du sie ab und läßt sie dann auf dem Computer rotieren.
BlackJack

@Alfons Mittelmeyer: Die Lösung gab's vor einem Jahr bereits auf der ersten Seite dieses Themas, dritte Antwort, von kaytec. Das ist aber auch gar nicht mehr die aktuelle Frage.
ganja
User
Beiträge: 189
Registriert: Mittwoch 3. Dezember 2014, 07:44

Hallo @Alfons Mittelmeyer das habe ich schon alles gemacht, ich hab das Bild es läuft auch habe mich an @kayteec seins orientiert, mein Problem ist das ich etwas über die gpio ausführen will wenn das Rad zum stehen kommt und gewonnen, da habe ich mein Problem, ich weiß nicht wo ich abfragen soll wo steht es jetzt,

Gruß ganja
Alfons Mittelmeyer
User
Beiträge: 1715
Registriert: Freitag 31. Juli 2015, 13:34

ganja hat geschrieben:Hallo @Alfons Mittelmeyer das habe ich schon alles gemacht, ich hab das Bild es läuft auch habe mich an @kayteec seins orientiert, mein Problem ist das ich etwas über die gpio ausführen will wenn das Rad zum stehen kommt und gewonnen, da habe ich mein Problem, ich weiß nicht wo ich abfragen soll wo steht es jetzt,

Gruß ganja
Also da machst Du ein Dictionary und trägst zu den Winkeln den Wert ein. Den Winkel solltest Du doch wissen und über das Dictionary weißt Du dann, was es ist.

Das wäre dann noch ein Beispiel mit Turbo nach erstem Durchlauf:

Code: Alles auswählen

# -*- coding: utf-8 -*-

try:
    import tkinter as tk
except ImportError:
    import Tkinter as tk


from PIL import Image,ImageTk

class Application(tk.Tk):

    def __init__(self,**kwargs):
        tk.Tk.__init__(self,**kwargs)
        # widget definitions ===================================
        self.label_pil_img = Image.open('fortune.png')
        
        self.label = tk.Label(self)
        self.label.pack()
        self.angle=0
        self.img_dict = {}
        self.img_rotate()
        

    def img_rotate(self):
        self.angle += 5
        self.angle = self.angle % 360
        if self.angle not in self.img_dict:
            self.img_dict[self.angle] = ImageTk.PhotoImage(self.label_pil_img.rotate(self.angle))
            self.label['image'] = self.img_dict[self.angle]
            self.after(1,self.img_rotate)
        else:
            self.label['image'] = self.img_dict[self.angle]
            self.after(1,self.img_rotate)

if __name__ == '__main__':
    Application().mainloop()
ganja
User
Beiträge: 189
Registriert: Mittwoch 3. Dezember 2014, 07:44

dein beispiel ist gut @Alfons Mittelmeyer ganz wenig code , wie stoppt man es und wie startet man es, ich versuche jetzt eine Funktion zu schreiben das es dann nach 5 Sekunden stoppt und starten auch, self.img_dict = {} hier kommen dann die winkel z.b. 15,30 ... 360 oder?

Gruß
Alfons Mittelmeyer
User
Beiträge: 1715
Registriert: Freitag 31. Juli 2015, 13:34

ganja hat geschrieben:dein beispiel ist gut @Alfons Mittelmeyer ganz wenig code , wie stoppt man es und wie startet man es, ich versuche jetzt eine Funktion zu schreiben das es dann nach 5 Sekunden stoppt und starten auch, self.img_dict = {} hier kommen dann die winkel z.b. 15,30 ... 360 oder?

Gruß
Wie findest Du diese Stopp Idee?

Code: Alles auswählen

# -*- coding: utf-8 -*-

try:
    import tkinter as tk
except ImportError:
    import Tkinter as tk


from PIL import Image,ImageTk

class Application(tk.Tk):

    def __init__(self,**kwargs):
        tk.Tk.__init__(self,**kwargs)
        # widget definitions ===================================
        self.label_pil_img = Image.open('fortune.png')
        
        self.label = tk.Label(self)
        self.bind('<Button 1>',self.wheel_stop)
        self.label.pack()
        self.angle=0
        self.img_dict = {}
        self.angle_step = 10
        self.img_rotate()

    def img_rotate(self):
        self.angle += self.angle_step
        self.angle = self.angle % 360
        if self.angle_step != 10:
            self.img = ImageTk.PhotoImage(self.label_pil_img.rotate(self.angle))
            self.label['image'] = self.img
            if not (self.angle % 15):
                self.angle_step -= 1
            if self.angle_step:
                self.after(1,self.img_rotate)
            else:
                print(self.angle)
        else:
            if self.angle not in self.img_dict:
                self.img_dict[self.angle] = ImageTk.PhotoImage(self.label_pil_img.rotate(self.angle))
            self.label['image'] = self.img_dict[self.angle]
            self.after(1,self.img_rotate)

    def wheel_stop(self,event):
        self.angle_step = 5

if __name__ == '__main__':
    Application().mainloop()
ganja
User
Beiträge: 189
Registriert: Mittwoch 3. Dezember 2014, 07:44

hi @Alfons Mittelmeyer, nicht schlecht aber nicht das was ich brauche möchte, du hast gerade ein lauf hier dein code mit meinen wünschen :D, vielleicht hast es auch schon so weit.
Danke für die bespiele

Code: Alles auswählen

 #!/usr/bin/env python   
# -*- coding: utf-8 -*

try:
	import tkinter as tk
except ImportError:
	import Tkinter as tk
 
 
from PIL import Image,ImageTk
 
class Application(tk.Tk):
	### so ist mein Bild aufgebaut wo packe ich das hin, um nachher irgend etwas auszuführen wenn Gewinn
	#WHEEL_TEXT = {45 : "GEWINN", 90 : "NICHTS", 135 : "GEWINN", 180 : "NICHTS", 225 : "GEWINN", 270 : "NICHTS", 315 : "GEWINN", 360 : "GEWINN"}
 
	def __init__(self,**kwargs):
		tk.Tk.__init__(self,**kwargs)
		# widget definitions ===================================
		self.label_pil_img = Image.open('Gluecksrad_750.png')
       
		self.label = tk.Label(self)
		self.bind('<Button 1>',self.wheel_stop)
		#self.bind.after(5,self.wheel_stop)
		self.label.pack()
		self.angle=0
		self.img_dict = {}
		self.angle_step = 10
		self.img_rotate()
		self.stop = False
		
		### hier mit starten mit space taste
		self.Button = tk.Button(self, text='START', font=("Helvetica bold", 80),  command=self.img_rotate
		).pack()
		### nach 5 secunden stoppen von alleine oder eine andere zeit muss ich erst sehen ob 5 zu kurz oder zu lang
 
	def img_rotate(self):
		self.angle += self.angle_step
		self.angle = self.angle % 360
		if self.angle_step != 10:
			self.img = ImageTk.PhotoImage(self.label_pil_img.rotate(self.angle))
			self.label['image'] = self.img
			if not (self.angle % 15):
				self.angle_step = max(0,self.angle_step-1)
			if self.angle_step:
				self.after(1,self.img_rotate)
			else:
				print(self.angle)
		else:
			if self.angle not in self.img_dict:
				self.img_dict[self.angle] = ImageTk.PhotoImage(self.label_pil_img.rotate(self.angle))
			self.label['image'] = self.img_dict[self.angle]
			self.after(1,self.img_rotate)
 
	def wheel_stop(self,event):
		self.angle_step = 5
		
	## die grösse möchte ich vom Fenster definieren so wie farbe etc
 
if __name__ == '__main__':
	Application().mainloop()
Alfons Mittelmeyer
User
Beiträge: 1715
Registriert: Freitag 31. Juli 2015, 13:34

ganja hat geschrieben:hi @Alfons Mittelmeyer, nicht schlecht aber nicht das was ich brauche möchte, du hast gerade ein lauf hier dein code mit meinen wünschen :D, vielleicht hast es auch schon so weit.
Musste leider weg und ob ich heute noch dazu komme, weiß ich nicht. Jedenfalls werde ich noch etwas probieren, auch um die Performance festzustellen und zu testen, ob es noch schneller uind besser geht.

Ach, so das Bild kannst du hier hochladen, wäre gut, wenn ich das habe: https://www.pic-upload.de/
ganja
User
Beiträge: 189
Registriert: Mittwoch 3. Dezember 2014, 07:44

@Alfons Mittelmeyer nur kein stress, ich bin dankbar für jeden Beispiel für jeden tipp wo ich etwas dabei lerne, bei dem Bild sind wir uns noch nicht einig ob es eins mit 24 Feldern oder mit 12 oder mit 9, ich denke das ist egal wieviele Felder, wichtig ist das ich es nachher selber verstehe und erweitern kann, wenn du aber Bild willst kann ich eins hochladen.

Danke
Gruß ganja
Alfons Mittelmeyer
User
Beiträge: 1715
Registriert: Freitag 31. Juli 2015, 13:34

ganja hat geschrieben:@Alfons Mittelmeyer nur kein stress, ich bin dankbar für jeden Beispiel für jeden tipp wo ich etwas dabei lerne, bei dem Bild sind wir uns noch nicht einig ob es eins mit 24 Feldern oder mit 12 oder mit 9, ich denke das ist egal wieviele Felder, wichtig ist das ich es nachher selber verstehe und erweitern kann, wenn du aber Bild willst kann ich eins hochladen.

Danke
Gruß ganja
Wenn Du eh noch nicht weißt, wieviel Felder, dann brauchst Du auch keines hochladen. Die Farbe kannst Du doch besimmen wie Du willst, das bleibt doch Dir überlassen. Ist es das, was Du Dir vorstellst? Das kann man auch mit Leertaste starten:

Code: Alles auswählen

#!/usr/bin/env python  
# -*- coding: utf-8 -*
 
try:
    import tkinter as tk
except ImportError:
    import Tkinter as tk
 
 
from PIL import Image,ImageTk
from random import random 
class Application(tk.Tk):
    ### so ist mein Bild aufgebaut wo packe ich das hin, um nachher irgend etwas auszuführen wenn Gewinn
    #WHEEL_TEXT = {45 : "GEWINN", 90 : "NICHTS", 135 : "GEWINN", 180 : "NICHTS", 225 : "GEWINN", 270 : "NICHTS", 315 : "GEWINN", 360 : "GEWINN"}
 
    def __init__(self,**kwargs):
        tk.Tk.__init__(self,**kwargs)
        # widget definitions ===================================
        self.label_pil_img = Image.open('fortune.png')
       
        self.label = tk.Label(self)
        self.label.bind('<space>',self.start_rotate)
        self.bind('<space>',self.start_rotate)
        self.label.pack(expand=1,fill='both')
        self.angle=0
        self.img_dict = {}
        self.angle_step = 0
        self.load_angle = 0
        self.step = 20
       
        ### hier mit starten mit space taste
        self.Button = tk.Button(self, text='START', font=("Helvetica bold", 80),  command=self.start_rotate)
        self.Button.pack()
        self.Button.bind('<space>',self.start_rotate)
        ### nach 5 secunden stoppen von alleine oder eine andere zeit muss ich erst sehen ob 5 zu kurz oder zu lang

        self.load_image()
        self.label['image'] = self.img_dict[0]
        self.load_images()
        

    def start_rotate(self,event=None):
        if not self.angle_step:
            self.angle_step = 10
            self.angle = self.angle// 10 * 10
            self.img_rotate()
            self.Button['state'] = 'disabled'
            self.after(int(4500+random()*1000),self.wheel_stop)

    def load_images(self):
        if self.load_angle < 360:
            self.load_image()
            self.after(1,self.load_images)


    def load_image(self):
        self.img_dict[self.load_angle] = ImageTk.PhotoImage(self.label_pil_img.rotate(self.load_angle))
        self.load_angle += 10

    def img_rotate(self):
        self.angle += self.angle_step
        self.angle = self.angle % 360
        if self.angle_step != 10:
            self.img = ImageTk.PhotoImage(self.label_pil_img.rotate(self.angle))
            self.label['image'] = self.img
            if not (self.angle % 15):
                self.angle_step = max(0,self.angle_step-1)
            if self.angle_step:
                self.after(self.step,self.img_rotate)
            else:
                self.Button['state'] = 'normal'
                print(self.angle)
        else:
            if self.angle not in self.img_dict:
                self.img_dict[self.angle] = ImageTk.PhotoImage(self.label_pil_img.rotate(self.angle))
            self.label['image'] = self.img_dict[self.angle]
            self.after(self.step,self.img_rotate)
 
    def wheel_stop(self,event=None):
        self.angle_step = 5
       
    ## die grösse möchte ich vom Fenster definieren so wie farbe etc
 
if __name__ == '__main__':
    Application().mainloop()
Die Stopzeit ist jetzt 4,5 bis 5,5 Sekunden. Und zu Beginn gibt es auch nicht mehr die langsame Phase.
Benutzeravatar
kaytec
User
Beiträge: 608
Registriert: Dienstag 13. Februar 2007, 21:57

Hallo,

habe es schon letztes Jahr weiter gemacht, doch es wurde immer komplexer und ich habe mich im Aufbau verbastelt. Hier ist mal was ich habe uns ihr könnt es zerfleddern.

Ganja --> die Anzahl der Teilungen des Vollwinkels und das Hochzählen in der Logik ist auch gleichzeitig die aktuelle Stellung des Rades. Aus dieser
Stellung kannst du den aktuellen Wert ermitteln, den du bei mir in "WHEEL_TEXT" stehen hast. Jeder Teil des Vollwinkels ist ein
"Indexsprung" in der TEXT_LISTE.

Code: Alles auswählen

#!/usr/bin/env python
# coding: utf-8
import random
import Tkinter as tk
from PIL import Image, ImageTk, ImageDraw, ImageFont
import StringIO
import base64 
from functools import partial


ANSWERS = {"SPORTS" : (("NORTH AMERICAN ",
                        "  WATER POLO   ",
                        "   REGIONALS   "),
                       ("   ICE STICK   ", 
                        "    SHOOTING   ")),
           "POLITICS" : (("  RECEP TAYYIP ",
                          "    ERDOGAN    "), 
                         (" ANGELA MERKEL "),
                         ("    WLADIMIR   ", 
                          "WLADIMIROWITSCH", 
                          "     PUTIN     "), 
                         ("HEINRICH LUEBKE")),
           "PROVERBS" : (("    ANY HINZ   ", 
                          "    AND KUNZ   "),
                         ("   NACHTIGAL   ",
                          "    ICK HOER    ",
                          "  DIR TRAPSEN  ")),
           "BANDS": ((("  BACK STREET  ", 
                       "      BOYS     ")), 
                     (("   THE TEENS   ")), 
                     (("MODERN TALKING ")))}
                     
ALPHABET = (("A", "B", "C", "D", "E", "F", "G", "H", "I", "J"), 
            ("K", "L", "M", "N", "O", "P", "Q", "R", "S", "T"),
            ("U", "V", "W", "X", "Y", "Z"))
            
VOWELS = ("A", "E", "I", "O", "U")
             
PLAYERS = [{"name" : "Kaytec", "score" : 0, "status" : "rotate",
            "extra_status" : list()},
           {"name" : "Nina", "score" : 0, "status" : "rotate", 
            "extra_status" : list()},
            {"name" : "Maren", "score" : 0, "status" : "rotate", 
            "extra_status" : list()}, 
            {"name" : "Peter", "score" : 0, "status" : "rotate", 
            "extra_status" : list()}]
            
class Wheel_of_Fortune(object):
    START_INTERVAL = 20
    SLOW_DOWN_STEP = 1
    FONT_SIZE = 50
    CIRCULAR_SEGMENT = 15
    ROTATE_STEP_DEGREES = 7.5
    FULL_ROTATION_STEPS = 360 / ROTATE_STEP_DEGREES
    VOWEL_PRICE = 1000
                         
    WHEEL_TEXT = ("MISS A TURN", "400", "200", "900", "500", "200", 
                  "BANKRUPT", "700", "450", "200", "400", "FREE SPIN", 
                  "750", "400", "200", "600", "400", "150", "1000", 
                  "800", "250", "500 GAMBLES", "300", "200")

    def __init__(self, answers, alphabet, VOWELS, players):
        #self.wheel =  Image.open(StringIO.StringIO(base64.decodestring(
            #WHEEL))).convert("RGBA")
        self.wheel =  Image.open("wheel.gif").convert("RGBA")
        self.font = ImageFont.truetype(
            "ALGER.TTF", 
            self.FONT_SIZE)
        self.full_rotation_steps = self.FULL_ROTATION_STEPS
        self.alphabet = alphabet
        self.vowels = VOWELS
        self.players = players
        self.answers = answers
        category = random.choice(self.answers.keys())
        answer = random.choice(self.answers[category])
        self.attributes = {"images" : list(), "speed" : self.START_INTERVAL,
            "run" : True, "rotate" : False, "player" : self.next_player(True), 
            "answer" : {"category" : category, "answer" : answer },
            "width" : self.wheel.size[0], "height" : self.wheel.size[1], 
            "chosen_letters" : list(), "prize" : 0}
        self.attributes["images"].append([(self.attributes["width"] / 2, 
            self.attributes["height"] / 2),  ImageTk.PhotoImage(self.wheel)])
        random_index = random.choice(range(len(self.WHEEL_TEXT)))
        self.text_img = self.create_text_img(random_index)
        self.new_text_image_size = self.text_img.size[0]
        self.random_degrees = random_index * self.CIRCULAR_SEGMENT
        self.text_rotate_degrees = 0
        self.degrees = 0
        
    def set_positions(self):
        self.attributes["images"] = list()
        self.attributes["images"].append([(self.attributes["width"]/ 2, 
            self.attributes["height"] / 2), 
            ImageTk.PhotoImage(self.wheel.rotate(self.degrees))])
        if self.attributes["player"]["status"] == "rotate":
            if self.attributes["rotate"]:
                self.rotate_wheel()
        else:
            for status in ("BANKRUPT", "FREE SPIN", "500 GAMBLES", 
                    "MISS A TURN"):
                if status == self.attributes["player"]["status"]:
                    if self.attributes["player"]["status"] == "BANKRUPT":
                        self.attributes["player"]["status"] = "rotate"
                        if "FREE SPIN" in self.attributes["player"][
                            "extra_status"]:
                            self.attributes["player"]["extra_status"].remove(
                                "FREE SPIN")
                        else:
                            self.attributes["player"]["score"] = 0
                            self.attributes["player"] = self.next_player()
                    elif self.attributes["player"]["status"] == "FREE SPIN":
                        self.attributes["player"]["extra_status"].append(
                            "FREE SPIN")
                        self.attributes["player"]["status"] = "rotate"
                    elif self.attributes["player"]["status"] == "MISS A TURN":
                        self.attributes["player"]["status"] = "rotate"
                        if "FREE SPIN" in self.attributes["player"][
                                "extra_status"]:
                            self.attributes["player"]["extra_status"].remove(
                                "FREE SPIN")
                        else:
                            self.attributes["player"] = self.next_player()
                    elif self.attributes["player"]["status"]== "500 GAMBLES":
                        self.attributes["player"]["extra_status"].append(
                            "500 GAMBLES")
                        self.attributes["player"]["status"] = "rotate"
        
    def start_wheel(self):
        if self.attributes["rotate"] == False:
            self.attributes["rotate"] = True
            
    def choose_letter(self, chosen_letter):
        if self.attributes["player"]["status"] == "choose_letter":
            old_letters = list()
            for letter in self.attributes["chosen_letters"]:
                old_letters.append(letter)
            if chosen_letter in self.vowels:
                old_score = self.attributes["player"]["score"] 
                new_score = old_score - self.VOWEL_PRICE
                if new_score < 0:
                    chosen_letter = None
                else:
                    self.attributes["player"]["score"] = new_score
            for answer_part in self.attributes["answer"]["answer"]:
                if len(answer_part) > 0:
                    for letter in answer_part:
                        if letter == chosen_letter:
                            if letter not in self.vowels:
                                self.attributes["player"]["score"] \
                                    += self.attributes["prize"]
                            self.attributes["chosen_letters"].append(letter)
                else:
                    if answer_part == chosen_letter:
                        if letter not in self.vowels:
                            self.attributes["player"]["score"] \
                                += self.attributes["prize"]
                        self.attributes["chosen_letters"].append(letter)
            if len(self.attributes["chosen_letters"]) == len(old_letters) \
                and chosen_letter is not None:
                if "FREE SPIN" in self.attributes["player"]["extra_status"]:
                    self.attributes["player"]["extra_status"].remove(
                        "FREE SPIN")
                else:
                    self.attributes["player"]["status"] = "rotate"
                    self.attributes["player"] = self.next_player()
            else:
                if chosen_letter is None:
                    self.attributes["player"]["status"] = "choose_letter"
                else:
                    self.attributes["player"]["status"] = "rotate"

    def rotate_wheel(self):
        if self.degrees != self.random_degrees +\
            self.full_rotation_steps * self.ROTATE_STEP_DEGREES:
            if self.degrees != self.random_degrees:
                self.attributes["speed"] += self.SLOW_DOWN_STEP
            self.degrees += self.ROTATE_STEP_DEGREES
        else:
            if self.text_rotate_degrees != self.ROTATE_STEP_DEGREES \
                * self.text_img.size[0]:
                self.attributes["speed"] = self.START_INTERVAL
                self.attributes["images"].append([(self.attributes["width"] 
                    / 2, self.attributes["height"] / 2), ImageTk.PhotoImage(
                    self.text_img.rotate(self.text_rotate_degrees).resize((
                    self.new_text_image_size, self.new_text_image_size)))])
                self.text_rotate_degrees += self.ROTATE_STEP_DEGREES
                self.new_text_image_size -= 1
            else: 
                if self.WHEEL_TEXT[self.random_degrees / 
                    self.CIRCULAR_SEGMENT] not in ("BANKRUPT", "FREE SPIN", 
                    "500 GAMBLES", "MISS A TURN"):
                    self.attributes["player"]["status"] = "choose_letter"
                    self.attributes["prize"] = int(float(self.WHEEL_TEXT[
                    self.random_degrees / self.CIRCULAR_SEGMENT]))
                    
                else:
                    self.attributes["player"]["status"] = self.WHEEL_TEXT[
                    self.random_degrees / self.CIRCULAR_SEGMENT]
                self.text_rotate_degrees = 0
                random_index = random.choice(range(len(self.WHEEL_TEXT)))
                self.text_img = self.create_text_img(random_index)
                self.new_text_image_size = self.text_img.size[0]
                self.random_degrees = random_index * self.CIRCULAR_SEGMENT
                self.text_rotate_degrees = 0
                self.degrees -= self.FULL_ROTATION_STEPS \
                    * self.ROTATE_STEP_DEGREES * 2
                self.attributes["rotate"] = False
                    
    def create_text_img(self, index):
        text = self.WHEEL_TEXT[index]
        text_img = Image.new("RGBA", (self.font.getsize(text)[0], 
            self.font.getsize(text)[0]))
        draw = ImageDraw.Draw(text_img)
        draw.text((0, self.font.getsize(text)[0] / 2 
            - self.font.getsize(text)[1] / 2 - 5), 
            text, (255, 255, 255), font = self.font)
        return text_img
        
    def next_player(self, first_start = False):
        if first_start:
            random.shuffle(self.players)
        else:
            self.players.reverse()
            last_player = self.players.pop()
            self.players.reverse()
            self.players.append(last_player)
        return self.players[0]


class Wheel_of_Fortune_Gui(object):

    def __init__(self, root):
        self.root = root
        self.letter_buttons = dict()
        self.answer_labels = list()
        self.wheel_of_fortune = Wheel_of_Fortune(ANSWERS, ALPHABET, 
            VOWELS, PLAYERS)
        self.canvas = tk.Canvas(root, width=self.wheel_of_fortune.attributes[
            "width"],height=self.wheel_of_fortune.attributes["height"])
        self.canvas.grid(row=0, column=0, padx=4, pady=4)
        for attributes in self.wheel_of_fortune.attributes["images"]:
            pos, img = attributes
            x, y = pos
            self.canvas.create_image(x, y, image=img)
        control_frame = tk.LabelFrame(root, relief=tk.FLAT)
        control_frame.grid(row=0, column=1)
        self.player_frame = tk.LabelFrame(control_frame,
            text=self.wheel_of_fortune.attributes[
            "player"]["name"],relief=tk.SOLID)
        self.player_frame.grid(row=0, column=0, sticky=tk.W+tk.E+tk.N+tk.S, 
            padx=4, pady=4)
        self.score_label = tk.Label(self.player_frame, 
            text=self.wheel_of_fortune.attributes["player"]["score"])
        self.score_label.pack(side=tk.TOP)
        answers_frame = tk.LabelFrame(control_frame, relief=tk.SOLID,
            text=self.wheel_of_fortune.attributes["answer"]["category"])
            
        def create_label(frame, letter, row, column):
            if letter == " ":
                relief = tk.FLAT
            else:
                relief = tk.SOLID
            label=tk.Label(frame, text="", width=2, relief=relief,
                font="Arial 11")
            label.grid(row=row, column=column, padx=2, pady=4)
            return label
            
        row = 0
        for column, answer_parts in enumerate(self.wheel_of_fortune.attributes[
            "answer"]["answer"]):
            if len(answer_parts) > 1:
                labels = list()
                row += 1
                for column, letter in enumerate(answer_parts):
                    labels.append(create_label(answers_frame, letter, row, 
                        column))
                self.answer_labels.append(labels)
            else:
                self.answer_labels.append(create_label(answers_frame, 
                    answer_parts, row, column))
        answers_frame.grid(row=1, column=0, sticky=tk.W+tk.E+tk.N+tk.S, padx=4, 
            pady=4)
        letter_frame = tk.LabelFrame(control_frame, text="Letters", 
            relief=tk.SOLID)
        for row, letters in enumerate(ALPHABET):
            for column, letter in enumerate(letters):
                button = tk.Button(letter_frame, text=letter, width=1,
                command=partial(self.choose_letter, letter))
                button.grid(row=row, column=column)
                if letter in VOWELS:
                    button.config(fg = "red")
                self.letter_buttons[letter] = button
        letter_frame.grid(row=2, column=0, padx=4, pady=4)
        tk.Button(control_frame, text='ROTATE WHEEL', 
            command=self.wheel_of_fortune.start_wheel).grid(row=3,
            column=0)
        self.after_id = None
            
    def start_wheel(self):
        self.wheel_of_fortune.start_wheel()
        
    def choose_letter(self, letter):
        self.wheel_of_fortune.choose_letter(letter)
        
    def run(self):
        self.wheel_of_fortune.set_positions()
        self.canvas.delete(tk.ALL)
        for attributes in self.wheel_of_fortune.attributes["images"]:
            pos, img = attributes
            x, y = pos
            self.canvas.create_image(x, y, image=img)
        self.score_label.config(text=self.wheel_of_fortune.attributes[
            "player"]["score"])
        self.player_frame.config(text=self.wheel_of_fortune.attributes[
            "player"]["name"])
        for labels, answer_part in zip(self.answer_labels, 
            self.wheel_of_fortune.attributes["answer"]["answer"]):
            if len(answer_part) > 1:
                for letter, label in zip(answer_part, labels):
                    if letter in self.wheel_of_fortune.attributes[
                        "chosen_letters"]:
                        label.config(text=letter, fg="black")
            else:
                if answer_part in self.wheel_of_fortune.attributes[
                    "chosen_letters"]:
                    labels.config(text=answer_part, fg="black")
        for letter in self.wheel_of_fortune.attributes["chosen_letters"]:
            self.letter_buttons[letter].config(state=tk.DISABLED)
        if self.wheel_of_fortune.attributes["run"]:
            self.after_id = self.root.after(self.wheel_of_fortune.attributes[
                "speed"], self.run)
        else:
            self.root.after_cancel(self.after_id)
            self.after_id = None
            
    def release(self):
        self.root.after_cancel(self.after_id)
        self.root.destroy()
            
def main():
    root = tk.Tk()
    root.title('WHEEL OF FORTUNE')
    wheel_of_fortune_gui = Wheel_of_Fortune_Gui(root)
    wheel_of_fortune_gui.run()
    root.protocol("WM_DELETE_WINDOW", wheel_of_fortune_gui.release)
    root.mainloop()
if __name__ == '__main__':
    main()
Gruß Frank
ganja
User
Beiträge: 189
Registriert: Mittwoch 3. Dezember 2014, 07:44

Guten Morgen, @ kaytec Vielen Dank ist echt umfangreich geworden Danke.

Guten Morgen @Alfons Mittelmeyer das ist es, ich möchte es jetzt in ein Frame haben, ich versuche ob es klappt.
class Application()

class Gui()

Da ich noch ein paar Labels seitlich anzeigen möchte und die Größe Farbe etc insgesamt möchte ich ändern können

VIelen Dank
ganja
User
Beiträge: 189
Registriert: Mittwoch 3. Dezember 2014, 07:44

@Alfons Mittelmeyer könntest du nochmal schauen, so stelle ich es mir vor, ganz oben der Pfeil der zeigt wo es anhält vielleicht kann man das auch mit label anstatt canvas hin bekommen ich weiss es leider nicht,

Code: Alles auswählen

#!/usr/bin/env python  
# -*- coding: utf-8 -*
     
try:
	import tkinter as tk
except ImportError:
	import Tkinter as tk
     
     
from PIL import Image,ImageTk
from random import random

class Application(object):
	def __init__(self):
		tk.Tk.__init__(self)
                self.label_pil_img = Image.open('fortune.png')
		
		self.label = tk.Label(self,root)
		self.label.bind('<space>',self.start_rotate)
		self.bind('<space>',self.start_rotate)
		self.label.pack(expand=1,fill='both')
		self.angle=0
		self.img_dict = {}
		self.angle_step = 0
		self.load_angle = 0
		self.step = 20
           
		self.Button = tk.Button(self,root, text='START', font=("Helvetica bold", 80),  command=self.start_rotate)
		self.Button.pack()
		self.Button.bind('<space>',self.start_rotate)
     
		self.load_image()
		self.label['image'] = self.img_dict[0]
		self.load_images()
	
	def start_rotate(self,event=None):
		if not self.angle_step:
			self.angle_step = 10
			self.angle = self.angle// 10 * 10
			self.img_rotate()
			self.Button['state'] = 'disabled'
			self.after(int(4500+random()*1000),self.wheel_stop)
	
	
	def load_images(self):
		if self.load_angle < 360:
			self.load_image()
			self.after(1,self.load_images)
     
	def load_image(self):
		self.img_dict[self.load_angle] = ImageTk.PhotoImage(self.label_pil_img.rotate(self.load_angle))
		self.load_angle += 10
		
	 
	def img_rotate(self):
		self.angle += self.angle_step
		self.angle = self.angle % 360
		if self.angle_step != 10:
			self.img = ImageTk.PhotoImage(self.label_pil_img.rotate(self.angle))
			self.label['image'] = self.img
			if not (self.angle % 15):
				self.angle_step = max(0,self.angle_step-1)
			if self.angle_step:
				self.after(self.step,self.img_rotate)
			else:
				self.Button['state'] = 'normal'
				print(self.angle)
		else:
			if self.angle not in self.img_dict:
				self.img_dict[self.angle] = ImageTk.PhotoImage(self.label_pil_img.rotate(self.angle))
			self.label['image'] = self.img_dict[self.angle]
			self.after(self.step,self.img_rotate)
     
	def wheel_stop(self,event=None):
		self.angle_step = 5


class Application_Gui(tk.Canvas):
	def __init__(self, root):
		tk.Canvas.__init__(self, root, highlightthickness=0)
		canvas_width = 50
		canvas_height =50
		python_green = "black"
		w = tk.Canvas(root,  width=canvas_width, height=canvas_height,highlightthickness=0)
		w.pack()
		points = [0,25,canvas_width,canvas_height/2, 25, canvas_height]
		w.create_polygon(points, outline=python_green, 
			fill='black', width=3)
		
def main():
	root = tk.Tk()
	root.title('WHEEL OF FORTUNE')
	application_gui = Application_Gui(root)
	application_gui.pack()
	root.geometry("1200x815+0+0")
	root.mainloop()
	
if __name__ == '__main__':
	main()
Alfons Mittelmeyer
User
Beiträge: 1715
Registriert: Freitag 31. Juli 2015, 13:34

ganja hat geschrieben:ich möchte es jetzt in ein Frame haben, ich versuche ob es klappt.
Besser wäre, das Image in einem Canvas unterzubringen. Da kannst Da dann auch nämlich noch so einen Zeiger unterbringen, der in das Wheel reinragt.

Als fortune.png habe ich jetzt folgende Größe genommen:

Bild

Und das ist mit cavas und Zeiger. Als Zeiger könnte man natürlich auch ein Bild nehmen:

Code: Alles auswählen

#!/usr/bin/env python  
# -*- coding: utf-8 -*
 
try:
    import tkinter as tk
except ImportError:
    import Tkinter as tk
 
 
from PIL import Image,ImageTk
from random import random
class Application(tk.Tk):
    ### so ist mein Bild aufgebaut wo packe ich das hin, um nachher irgend etwas auszuführen wenn Gewinn
    #WHEEL_TEXT = {45 : "GEWINN", 90 : "NICHTS", 135 : "GEWINN", 180 : "NICHTS", 225 : "GEWINN", 270 : "NICHTS", 315 : "GEWINN", 360 : "GEWINN"}
 
    def __init__(self,**kwargs):
        tk.Tk.__init__(self,**kwargs)
        # widget definitions ===================================
        self.label_pil_img = Image.open('fortune.png')

        self.canvas = Canvas_1(self,name='#0_canvas')
        self.canvas.pack()
        self.canvas.bind('<space>',self.start_rotate)
        self.bind('<space>',self.start_rotate)
        self.angle=0
        self.img_dict = {}
        self.angle_step = 0
        self.load_angle = 0
        self.step = 20
       
        ### hier mit starten mit space taste
        self.Button = tk.Button(self, text='START', font=("Helvetica bold", 80),  command=self.start_rotate)
        self.Button.pack()
        self.Button.bind('<space>',self.start_rotate)
        ### nach 5 secunden stoppen von alleine oder eine andere zeit muss ich erst sehen ob 5 zu kurz oder zu lang
 
        self.load_image()
        self.canvas.itemconfig('wheel',image= self.img_dict[0])

        self.load_images()
       
 
    def start_rotate(self,event=None):
        if not self.angle_step:
            self.angle_step = 10
            self.angle = self.angle// 10 * 10
            self.img_rotate()
            self.Button['state'] = 'disabled'
            self.after(int(4500+random()*1000),self.wheel_stop)
 
    def load_images(self):
        if self.load_angle < 360:
            self.load_image()
            self.after(1,self.load_images)
 
 
    def load_image(self):
        self.img_dict[self.load_angle] = ImageTk.PhotoImage(self.label_pil_img.rotate(self.load_angle))
        self.load_angle += 10
 
    def img_rotate(self):
        self.angle += self.angle_step
        self.angle = self.angle % 360
        if self.angle_step != 10:
            self.img = ImageTk.PhotoImage(self.label_pil_img.rotate(self.angle))
            self.canvas.itemconfig('wheel',image= self.img)
            if not (self.angle % 15):
                self.angle_step = max(0,self.angle_step-1)
            if self.angle_step:
                self.after(self.step,self.img_rotate)
            else:
                self.Button['state'] = 'normal'
                print(self.angle)
        else:
            if self.angle not in self.img_dict:
                self.img_dict[self.angle] = ImageTk.PhotoImage(self.label_pil_img.rotate(self.angle))
            self.canvas.itemconfig('wheel',image= self.img_dict[self.angle])
            self.after(self.step,self.img_rotate)
 
    def wheel_stop(self,event=None):
        self.angle_step = 5
       
    ## die grösse möchte ich vom Fenster definieren so wie farbe etc

class Canvas_1(tk.Canvas):

    def __init__(self,master,**kwargs):
        tk.Canvas.__init__(self,master,**kwargs)
        self.config(height='550', width='500')
        # widget definitions ===================================
        coords = (252,274)
        item_wheel = self.create_image(*coords)
        self.image_1 = ImageTk.PhotoImage(Image.open('fortune.png'))
        self.itemconfig(item_wheel,image = self.image_1,tags='wheel')

        coords = (188,3,316,125)
        item = self.create_arc(*coords)
        self.itemconfig(item,start = '75.0',extent = '30.0',fill = 'orange',width = '3.0')
 
if __name__ == '__main__':
    Application().mainloop()
Benutzeravatar
wuf
User
Beiträge: 1529
Registriert: Sonntag 8. Juni 2003, 09:50

Hi ganja

Hier noch eine andere Variante zum ausprobieren:

Code: Alles auswählen

#!/usr/bin/env python
# -*- coding: utf-8 -*-

from functools import partial
from random import randint, uniform

try:
    import Tkinter as tk
except ImportError:
    import tkinter as tk

from PIL import Image,ImageTk

APP_TITLE = "The Wheel of Fortune"
APP_XPOS = 100
APP_YPOS = 100
APP_WIDTH = 300
APP_HEIGHT = 200

TEXT_FONT = ('Helvetica', 20, 'bold')
TEXT_FG = 'gray'

NUM_OF_FIELDS = 24
STEP_SIZE = 360 / NUM_OF_FIELDS
MARK_WIDTH = 40
MARK_HEIGHT = MARK_WIDTH
MARK_COLOR = 'gray70'
POLYGON_POINTS = [(0, 0), (MARK_WIDTH, 0), (MARK_WIDTH/2, MARK_HEIGHT), (0, 0)]


class Application(tk.Frame):

    def __init__(self, master):
        self.master = master
        self.master.protocol("WM_DELETE_WINDOW", self.close)
        tk.Frame.__init__(self, master)
        
        self.wheel_pos = 0
        
        self.cv_mark = tk.Canvas(self, width=50, height=50)
        self.cv_mark.pack(pady=2)
        self.cv_mark.create_polygon(POLYGON_POINTS, fill=MARK_COLOR,
            tag='mark')
            
        self.wheel = tk.Label(self)
        self.wheel.pack(expand=True, fill='both')

        self.start_button = tk.Button(self, relief='flat', font=TEXT_FONT, 
            fg=TEXT_FG, activebackground=self['bg'], text='Push the wheel',
            bd=0, activeforeground='green', command=self.run)
        self.start_button.pack(pady=5)
        
        self.wheel_pil_img = Image.open('wheel_of_fortune.png')
        self.wheel_tk_img = ImageTk.PhotoImage(self.wheel_pil_img)
        self.wheel['image'] = self.wheel_tk_img
        
        self.run_flag = False
        self.seed = 0.0
        
    def run(self):
        if not self.run_flag:
            self.run_flag = True
            self.seed = uniform(0.05, 0.15)
            self.focus_set()
            self.cv_mark.itemconfigure('mark', fill=self['bg'])
            self.start_button['fg'] = 'red'
            self.start_button['activeforeground'] = 'red'
            self.rotate_wheel()

    def rotate_wheel(self, tmcol=5.0, time_step=5):
        tmcol += float(time_step) * self.seed
        time_step = int(tmcol)

        if time_step > 500: 
            self.run_flag = False
            self.cv_mark.itemconfigure('mark', fill=MARK_COLOR)
            self.start_button['fg'] = TEXT_FG
            self.start_button['activeforeground'] = 'green'
            return
            
        self.wheel_tk_img = ImageTk.PhotoImage(self.wheel_pil_img.rotate(
            self.set_wheel_pos()))
        self.wheel['image'] = self.wheel_tk_img
        
        self.after(time_step, self.rotate_wheel, tmcol, time_step)

    def set_wheel_pos(self):
        self.wheel_pos -= STEP_SIZE
        if self.wheel_pos == 360: self.wheel_pos = 0
        return self.wheel_pos
            
    def close(self):
        print("Application-Shutdown")
        self.master.destroy()

        
def main():
    app_win = tk.Tk()
    app_win.title(APP_TITLE)
    app_win.geometry("+{}+{}".format(APP_XPOS, APP_YPOS))
    app_win.option_add("*highlightThickness", 0)
    app = Application(app_win).pack(fill='both', expand=True, padx=6, pady=6)
    
    app_win.mainloop()
 
 
if __name__ == '__main__':
    main()      
Gruss wuf :wink:
Take it easy Mates!
ganja
User
Beiträge: 189
Registriert: Mittwoch 3. Dezember 2014, 07:44

@Alfons Mittelmeyer das vorherige beispiel ist für mich besser, ich muss mit wenigen griffen die größe anpassen können, ich möchte es mal am Laptop laufen lassen und mal am 46" Monitor, mein Beispiel wo ich gepostet habe wäre das richtige, aber ich bekomme es nicht zu laufen. Ich möchte die Fenstergröße beliebig anpassen Farbe auch und dann die Größe vom Bild, auf einem 46" brauche ich wahrscheinlich ein sehr größer Bild. es wäre auch nicht schlecht wenn das Label mit dem Bild in einem frame wäre so das ich z.b den Abstand zwischen button und label nach belieben einstellen kann, ist das möglich ich bin an meine grenzen gestoßen ich bekomme das unten einfach nicht hin.
kann man das hier anpassen das es läuft(dann würde ich selber weiter versuchen, in class Application_Gui muss doch was rein aus class Application):

Code: Alles auswählen

#!/usr/bin/env python  
# -*- coding: utf-8 -*
     
try:
	import tkinter as tk
except ImportError:
	import Tkinter as tk
     
     
from PIL import Image,ImageTk
from random import random

class Application(object):
	def __init__(self):
		tk.Tk.__init__(self)
		#self.label_pil_img = Image.open('Gluecksrad_750.png')
                self.label_pil_img = Image.open('fortune.png')
		
		self.label = tk.Label(self,root)
		self.label.bind('<space>',self.start_rotate)
		self.bind('<space>',self.start_rotate)
		self.label.pack(expand=1,fill='both')
		self.angle=0
		self.img_dict = {}
		self.angle_step = 0
		self.load_angle = 0
		self.step = 20
           
		self.Button = tk.Button(self,root, text='START', font=("Helvetica bold", 80),  command=self.start_rotate)
		self.Button.pack()
		self.Button.bind('<space>',self.start_rotate)
     
		self.load_image()
		self.label['image'] = self.img_dict[0]
		self.load_images()
	
	def start_rotate(self,event=None):
		if not self.angle_step:
			self.angle_step = 10
			self.angle = self.angle// 10 * 10
			self.img_rotate()
			self.Button['state'] = 'disabled'
			self.after(int(4500+random()*1000),self.wheel_stop)
	
	
	def load_images(self):
		if self.load_angle < 360:
			self.load_image()
			self.after(1,self.load_images)
     
	def load_image(self):
		self.img_dict[self.load_angle] = ImageTk.PhotoImage(self.label_pil_img.rotate(self.load_angle))
		self.load_angle += 10
		
	 
	def img_rotate(self):
		self.angle += self.angle_step
		self.angle = self.angle % 360
		if self.angle_step != 10:
			self.img = ImageTk.PhotoImage(self.label_pil_img.rotate(self.angle))
			self.label['image'] = self.img
			if not (self.angle % 15):
				self.angle_step = max(0,self.angle_step-1)
			if self.angle_step:
				self.after(self.step,self.img_rotate)
			else:
				self.Button['state'] = 'normal'
				print(self.angle)
		else:
			if self.angle not in self.img_dict:
				self.img_dict[self.angle] = ImageTk.PhotoImage(self.label_pil_img.rotate(self.angle))
			self.label['image'] = self.img_dict[self.angle]
			self.after(self.step,self.img_rotate)
     
	def wheel_stop(self,event=None):
		self.angle_step = 5


class Application_Gui(tk.Canvas):
	def __init__(self, root):
		tk.Canvas.__init__(self, root, highlightthickness=0)
		canvas_width = 50
		canvas_height =50
		python_green = "black"
		w = tk.Canvas(root,  width=canvas_width, height=canvas_height,highlightthickness=0)
		w.pack()
		points = [0,25,canvas_width,canvas_height/2, 25, canvas_height]
		w.create_polygon(points, outline=python_green, 
			fill='black', width=3)
		
def main():
	root = tk.Tk()
	root.title('WHEEL OF FORTUNE')
	application_gui = Application_Gui(root)
	application_gui.pack()
	root.geometry("1200x815+0+0")
	root.mainloop()
	
if __name__ == '__main__':
	main()
Alfons Mittelmeyer
User
Beiträge: 1715
Registriert: Freitag 31. Juli 2015, 13:34

ganja hat geschrieben:@Alfons Mittelmeyer könntest du nochmal schauen, so stelle ich es mir vor, ganz oben der Pfeil der zeigt wo es anhält vielleicht kann man das auch mit label anstatt canvas hin bekommen ich weiss es leider nicht,
Nein, mit Label geht es nicht, denn Widgets kann man in tkinter nicht durchsichtig machen. Das Image und der Pfeil müssen daher in den selben Canvas.

Du wolltest noch Label anbringen? OK dies zeigt, wie das geht. Nimm einfach ein Grid Layout. Den Pfeil mußt Du selber richtig positionieren. Die x Koordinate sollte für dieses Glücksrad stimmen. Die y Koordinate mußt Du selber anpassen:

Code: Alles auswählen

# -*- coding: utf-8 -*-

try:
    import tkinter as tk
except ImportError:
    import Tkinter as tk
from PIL import Image,ImageTk
from random import random


# === general grid table definition =================
def grid_general_rows(container,rows,**kwargs):
    for row in range(rows):
        container.rowconfigure(row,**kwargs)

def grid_general_cols(container,columns,**kwargs):
    for column in range(columns):
        container.columnconfigure(column,**kwargs)


class Application(tk.Tk):

    def __init__(self,**kwargs):
        tk.Tk.__init__(self,**kwargs)
        # general grid definition ==============================
        grid_general_rows(self,12, minsize = 37, pad = 0, weight = 0)
        grid_general_cols(self,3, minsize = 100, pad = 0, weight = 0)
        # widget definitions ===================================
        self.label1 = tk.Label(self,text='label1')
        self.label1.grid(row=0, sticky='nesw')
        self.label2 = tk.Label(self,text='label2')
        self.label2.grid(row=1, sticky='nesw')
        self.label3 = tk.Label(self,text='label3')
        self.label3.grid(row=2, sticky='nesw')
        self.label4 = tk.Label(self,text='label4')
        self.label4.grid(row=3, sticky='nesw')
        self.label5 = tk.Label(self,text='label5')
        self.label5.grid(row=4, sticky='nesw')
        self.label6 = tk.Label(self,text='label6')
        self.label6.grid(row=5, sticky='nesw')
        self.label7 = tk.Label(self,text='label7')
        self.label7.grid(row=6, sticky='nesw')
        self.label8 = tk.Label(self,text='label8')
        self.label8.grid(row=7, sticky='nesw')
        self.button = tk.Button(self,font='{Helvetica bold} 80', text='START')
        self.button.grid(row=11, columnspan=3, sticky='nesw')
        self.label9 = tk.Label(self,text='label9')
        self.label9.grid(row=10)
        self.label10 = tk.Label(self,text='label10')
        self.label10.grid(row=10, column=2)
        self.Wheel_of_Fortune = tk.Label(self,text='Wheel of Fortune', font='TkDefaultFont 32 {bold }')
        self.Wheel_of_Fortune.grid(row=0, column=1)

        self.canvas = Canvas_1(self)
        self.canvas.grid(row=1, sticky='nesw', column=1, rowspan=10)


        self.label_pil_img = Image.open('fortune.png')
        self.canvas.bind('<space>',self.start_rotate)
        self.bind('<space>',self.start_rotate)
        self.angle=0
        self.img_dict = {}
        self.angle_step = 0
        self.load_angle = 0
        self.step = 20
       
        ### hier mit starten mit space taste
        self.button.bind('<space>',self.start_rotate)
        self.button['command']=self.start_rotate
        ### nach 5 secunden stoppen von alleine oder eine andere zeit muss ich erst sehen ob 5 zu kurz oder zu lang
 
        self.load_image()
        self.canvas.itemconfig('wheel',image= self.img_dict[0])

        self.load_images()
       
 
    def start_rotate(self,event=None):
        if not self.angle_step:
            self.angle_step = 10
            self.angle = self.angle// 10 * 10
            self.img_rotate()
            self.button['state'] = 'disabled'
            self.after(int(4500+random()*1000),self.wheel_stop)
 
    def load_images(self):
        if self.load_angle < 360:
            self.load_image()
            self.after(1,self.load_images)
 
 
    def load_image(self):
        self.img_dict[self.load_angle] = ImageTk.PhotoImage(self.label_pil_img.rotate(self.load_angle))
        self.load_angle += 10
 
    def img_rotate(self):
        self.angle += self.angle_step
        self.angle = self.angle % 360
        if self.angle_step != 10:
            self.img = ImageTk.PhotoImage(self.label_pil_img.rotate(self.angle))
            self.canvas.itemconfig('wheel',image= self.img)
            if not (self.angle % 15):
                self.angle_step = max(0,self.angle_step-1)
            if self.angle_step:
                self.after(self.step,self.img_rotate)
            else:
                self.button['state'] = 'normal'
                print(self.angle)
        else:
            if self.angle not in self.img_dict:
                self.img_dict[self.angle] = ImageTk.PhotoImage(self.label_pil_img.rotate(self.angle))
            self.canvas.itemconfig('wheel',image= self.img_dict[self.angle])
            self.after(self.step,self.img_rotate)
 
    def wheel_stop(self,event=None):
        self.angle_step = 5
       
    ## die grösse möchte ich vom Fenster definieren so wie farbe etc

class Canvas_1(tk.Canvas):

    def __init__(self,master,**kwargs):
        tk.Canvas.__init__(self,master,**kwargs)
        self.config(height='550', width='500')
        # widget definitions ===================================
        coords = (252,274)
        item_wheel = self.create_image(*coords)
        self.image_1 = ImageTk.PhotoImage(Image.open('fortune.png'))
        self.itemconfig(item_wheel,image = self.image_1,tags='wheel')

        canvas_width = 50
        canvas_height =25
        python_green = "black"
        x = 225
        y = 25

        points = [x,y,x+canvas_width,y, x+canvas_width/2, y+canvas_height]
        self.create_polygon(points, outline=python_green,
            fill='black', width=3)


        #coords = (188,3,316,125)
        #item = self.create_arc(*coords)
        #self.itemconfig(item,start = '75.0',extent = '30.0',fill = 'orange',width = '3.0')

if __name__ == '__main__':
    Application().mainloop()
Antworten