0

Hello.
I recently finished my 1. semester in Computer Science, and got a good fundamental idea on programming in Python.
Our exam assignment whas to create a game where we had to smash robots by clicking around with the mouse.

The GUI was provided by our instructor.
Now we newer learned about binding, but now that the class is finished, i really want to know how this is possible to do.

I found this code on the internet:

from tkinter import *

root = Tk()
listen = []

def key(event):
    print ("pressed", repr(event.char))
    listen.append(event.char)

def callback(event):
    frame.focus_set()
    print ("clicked at", event.x, event.y)

frame = Frame(root, width=500, height=500)
frame.bind("<Key>", key)
frame.bind("<Button-1>", callback)
frame.pack()

root.mainloop()

Here is the GUI we got for the assignement

import threading
import time

try:
    # For python 3
    from tkinter import Frame,Canvas,Tk,Label,Entry,Button,END
except ImportError:
    # Fall back for python 2 
    from Tkinter import Frame,Canvas,Tk,Label,Entry,Button,END

class GameGUI(Frame):
    # The GUI is not alive to begin with
    _alive = False

    def _teleport(self):
        """Internal function to handle teleport clicks"""
        # Sanity checks
        if not self._alive:
            print("GUI cannot be used, it is dead!")
            return None

        # Acquire the click-lock
        self._click_condition.acquire()

        # Inform the other threads that a click has happened
        self._clicked = True
        self._last_click = ("teleport", "teleport")
        self._click_condition.notifyAll()

        # Release the click-lock
        self._click_condition.release()

    def _button_click(self, event):
        """Internal function to handle button clicks"""
        # Sanity checks
        if not self._alive:
            print("GUI cannot be used, it is dead!")
            return None

        # Acquire the click-lock
        self._click_condition.acquire()

        # Inform the other threads that a click has happened
        self._clicked = True
        self._last_click = (max(0,min(event.x//self.pixels,self.cols-1)),max(0,min(event.y//self.pixels, self.rows-1)))
        self._click_condition.notifyAll()

        # Release the click-lock
        self._click_condition.release()

    def _clear_command_queue(self):
        """Internal function to clear the command queue"""
        while self._command_queue:
            command, args = self._command_queue.pop()
            if command == "text":
                self._label.config(text=args)
            elif command == "color":
                c,r,color = args
                self._canvas.itemconfig(self._squares[(c,r)], fill=color)
            elif command == "ask":
                self._text_label.config(text=args)
                self._text_entry.delete(0, END)
                self._text_frame.pack()
                self._text_entry.focus()
        if self._alive:
            self._root.after(10, self._clear_command_queue)

    def _start(self):
        """Internal function to setup the frame"""
        # Create the window
        self._root = Tk()
        self._root.protocol("WM_DELETE_WINDOW", self._on_destroy)
        Frame.__init__(self, self._root)
        self.pack()

        # Create the click-lock 
        self._click_condition = threading.Condition()

        # Create the lock for the label
        self._text_lock = threading.Lock()

        # Create the canvas
        self._canvas = Canvas(self, width=self.pixels*self.cols+1, height=self.pixels*self.rows+1)
        self._canvas.bind("<ButtonRelease-1>", self._button_click)
        self._canvas.pack()

        # Create the teleport button
        self._teleport = Button(self, text="Teleport", command=self._teleport)
        self._teleport.pack()

        # Create the colored squares
        self._squares = {}
        for c in range(self.cols):
            for r in range(self.rows):
                self._squares[(c,r)] = self._canvas.create_rectangle(
                            self.pixels*c+1,        # x-left
                            self.pixels*r+1,        # y-upper
                            self.pixels*(c+1)+1,    # x-right
                            self.pixels*(r+1)+1,    # y-lower
                            fill="white")           # color

        # Creates the label
        self._label = Label(self, text="", font=("Comic Sans MS", 12))
        self._label.pack()

        # Text input widgets
        self._text_frame = Frame(self)
        self._text_label = Label(self._text_frame)
        self._text_button = Button(self._text_frame, text="Gem", command=self._text_save)
        self._text_entry = Entry(self._text_frame, text="")
        self._text_entry.bind("<Key-Return>", self._text_save)
        self._text_label.grid (row=0,column=0)
        self._text_entry.grid (row=0,column=1)
        self._text_button.grid(row=0,column=2)

        # Sets up the command queue
        self._command_queue = []

        # The GUI is now alive
        self._alive = True

        # Clear the command queue and continue doing it
        self._clear_command_queue()

        # Run the main loop
        self.mainloop()

    def _wait_and_callback(self, callback=None):
        # Wait for it to finish initializing
        while not self._alive:
            time.sleep(0.01)

        if callback != None:
            threading.Thread(target=callback, args=[self]).start()


    def __init__(self, cols=10, rows=10, pixels=35, callback=None):
        """Constructor for the GameGUI. It takes the following arguments:
            - cols/rows, which specify the desired size of the board
            - pixels, which is the pixel-size of a square
            - a callback function, which is called when initialization is done
            - a bool, which specifies whether the mainloop should be run by __init__
        """

        # Same values
        self.cols = cols
        self.rows = rows
        self.pixels = pixels

        if callback == None:
            # If no callback is given, start another thread for the main-loop
            threading.Thread(target=self._start).start()
            self._wait_and_callback()
        else:
            # If a callback is given, run the main-loop in this thread
            threading.Thread(target=self._wait_and_callback, args=[callback]).start()
            self._start()


    def _on_destroy(self):
        """Called when the GUI is destroyed."""

        # The GUI is no longer alive
        self._alive = False

        # Wait a bit for things to exit cleanly
        time.sleep(0.05)

        # When the window is destroyed, make sure
        # that all remaining calls to get_click
        # returns with ("dead", "dead")
        click_condition = self._click_condition
        self._click_condition.acquire()
        self._clicked = True
        self._last_click = ("dead", "dead")
        self._click_condition.notifyAll()
        self._click_condition.release()

        # Then pass on the destroy-event
        self._root.destroy()

    def get_click(self):
        """Waits for the user to click a square, then returns which square was clicked
           as a tuple. If the teleport button is clicked, returns ("teleport", "teleport").
           If the gui is destroyed before a click is gotten, return ("dead", "dead")."""

        # Sanity checks
        if not self._alive:
            print("GUI cannot be used, it is dead!")
            return None

        # Acquire the condition-lock
        self._click_condition.acquire()

        # Set the condition to false, and wait for
        # it to become True
        self._clicked = False
        while not self._clicked:
            self._click_condition.wait()

        # Return the last click-value and release the lock
        retval = self._last_click
        self._click_condition.release()

        return retval


    def set_label(self, text):
        """Sets the label-text."""

        # Sanity checks
        if not self._alive:
            print("GUI cannot be used, it is dead!")
            return None
        if type(text) != type(""):
            print("In set_label: text must be a string!")
            return None

        self._command_queue.append(("text", text))

    def set_color(self, col, row, color="white"):
        """Sets the color of a square."""
        # Sanity checks
        if not self._alive:
            print("GUI cannot be used, it is dead!")
            return None
        if type(col) != type(0):
            print("In set_color: col must be a number!")
            return None
        if type(row) != type(0):
            print("In set_color: row must be a number!")
            return None
        if type(color) != type(""):
            print("In set_color: color must be a string!")
            return None

        self._command_queue.append(("color", (col, row, color)))

    def is_alive(self):
        """Returns whether the GUI is alive."""
        return self._alive

    def _text_save(self, event=None):
        """Internal function to save the text-result and remove the text-frame."""
        self._text_result = self._text_entry.get()
        self._text_frame.pack_forget()

    def ask_user(self, text):
        """Asks the user for some text-input. Returns None, if the GUI dies before a result is entered."""
        # Sanity checks
        if not self._alive:
            print("GUI cannot be used, it is dead!")
            return None
        if type(text) != type(""):
            print("In ask_user: text must be a string!")
            return None

        self._text_lock.acquire()
        self._text_result = None
        self._command_queue.append(("ask", text))

        while self._alive and self._text_result == None:
            time.sleep(0.01)

        retval = self._text_result

        self._text_lock.release()

        return retval

def test_main():
    GameGUI(6,10, callback=test_main_callback)

def test_main_callback(gui):
    gui.set_label(gui.ask_user("test"))
    teleport_count = 0
    while gui.is_alive():
        (r,c) =  gui.get_click()
        if r == "teleport":
            teleport_count += 1
            gui.set_label("Teleports: " + str(teleport_count))
        else:
            gui.set_color(r,c,"red")

if __name__ == "__main__":
    test_main()

I really want to know how i can implement the binding feature in this GUI, so that it returns a key when the keyboard is pressed (just like the mouse in this case).
Since i don't have much understanding in how the GUI is made, i would really like if someone could come up with a step by step tutorial on how i can do it myself, or just do it for me, so i can go through the code and learn by looking.

Hope someone has the time to help. Thanks.

2
Contributors
1
Reply
3
Views
4 Years
Discussion Span
Last Post by Lucaci Andrew
This topic has been dead for over six months. Start a new discussion instead.
Have something to contribute to this discussion? Please be thoughtful, detailed and courteous, and be sure to adhere to our posting rules.