Begin by copying (or downloading) the following modules:

• calculator.py
• test.py

Take a minute to review the contents of these files and note the following:

• The calculator:
  • There is a single (currently unused) instance variable. This is the variable that implements memory; you can ignore this until the extra-credit section below.
  • You can run the module to print the sum of 0 and 1. It gets the right answer but for the wrong reason.
• The unit tests:
  • The tests are implemented as a separate unit testing file.
  • You can run the test file as a “Python unit-test“.
  • Only the first test will pass, again for the same wrong reason.

Your job is to reimplement the calculate() method so that all of the tests pass. Note that you should not change the unit tests, only the calculator class.

Start building the GUI structure from top to bottom as follows:

1. Create a new module in your lab11 package named gui
2. We will use the tools in TKinter and the Calculator, so bring all of those tools into the current namespace using

   from tkinter import *
   from calculator import *

3. Add a driver script at the bottom of the module similar to the ones used in the text and class examples.

   if __name__ == '__main__':
       root = Tk()
       root.title('Calculator')
       app = Gui(root)
       root.mainloop()

   This creates the GUI application class, names it “Calculator” and starts the user event loop.

4. Create a class named Gui and add a constructor that receives a window object from its calling program and then creates and places widgets on that window as specified by this algorithm:
   1. Create an instance variable for the calculator object.

      self._calc = Calculator()

      This object will perform all the calculations for the GUI interface.

   2. Create a label and entry for the first number to be entered. You can use this code:

      input1_label = Label(window, text="Input 1:")
      input1_label.grid(row=0, column=0, sticky=E)
      input1_entry = Entry(window, width=6)
      input1_entry.grid(row=0, column=1, sticky=W)

   3. Create a similar label and entry for the second number to be entered.

This much should build the first two “lines” of the GUI structure. There are no associated commands, but it is a good first iteration. Check that the application works as expected before continuing.

Update your constructor to add radio buttons for choosing the operation, and labels to show what the chosen operation is at any time.

We may want to move the buttons around (or reformat them) as a group, so we'll create a substructure and put the operation buttons together there. Do this using the following algorithm:

1. Create a Frame object to attach to the window:

   operator_frame = Frame(window)
   operator_frame.grid(row=2, column=0, columnspan=2)

2. Create a new StringVar instance variable called self._operator that will be shared between all of the radio button objects. Give this variable a value of '+' using the set() method.
3. Create a new Button for the addition operation and attach it to the frame on the left side. You can use this code:

   add_button = Radiobutton(operator_frame, text="+", variable=self._operator, value='+')
   add_button.pack(side=LEFT)

4. Create buttons for subtraction (-), multiplication (*) and division (/) and put them in the frame.

Run your driver and verify the following:

• The default operation is addition.
• Choosing a new operation by clicking its radio button causes the label indicating the chosen operation to update appropriately.

Our goal in this step is to use the calculator that we have carefully tested in Exercise 11.1 to do our calculations. We also want these results to appear on the screen. Our calculator is ready to go (so it will not change!!), but the driver application needs some work. Start with the graphical structure by adding the following steps to the constructor algorithm started above:

1. Add a button to the main window (not to the radio button frame) to perform the calculation and put it in the fourth row, first column.
2. Add a label to the window with the text 'Result:' and put it in the fourth row, second column.
3. Create a StringVar called self._result
4. Create a Label whose text matches self._result, and put it in the fourth row to the right of its label. You can do this using this code:

   self.result_label = Label(window, textvariable=self._result, width=6)
   self.result_label.grid(row=3, column=2, sticky=W)

We are now (finally) ready to actually do something with our interface. In particular, we want to perform the calculation indicated by the text fields and chosen operation when the user presses the Calculate button.

1. Find your definition of input1_entry. We want to be able to access the value the user types in this field, so add a new instance variable called self._input1 which is an instance of StringVar. Associate this variable with input1_entry as you did before, by adding the argument textvariable=self._input1 to its constructor.
2. Repeat the previous step for input 2.
3. Find the code that creates the calculate button and add the argument command=self.do_calculation
4. Create a method called do_calculation that implements the following algorithm:
   1. Use the calculate() method of the self.calc object to perform the calculation specified by the interface. You can use this code (if you named your variables as specified earlier):

      result = self._calc.calculate(self._input1.get(), self._operator.get(), self._input2.get())

   2. Change the result label to match the value of result. You can use:

      self._result.set(result)

Check that your calculator GUI works!

Using the techniques you have practiced in earlier exercises, add a label to the bottom of the GUI that will indicate if any errors occur. This label should initially welcome the user (e.g. “Come on! Let’s calculate!”) and then be updated if an error occurs to give an indication of what went wrong. If no errors occur during a calculation, the label should remain (or return to) the initial greeting.

NOTE: you should handle the error by "wrapping" your code with a try: / except: block. The question is: what action causes the error to be generated? The answer: the call to do_calculation(). So, that is the place where you should handle the error and update the error message label.

Update the calculator class to access and change the memory instance variable. You must define an accessor and a mutator. Then, in the calculate method, if either of the operands is the letter “M”, the value in memory should be used. Add init tests that demonstrate the correctness of your implementation.

Over in the GUI, add a new row with a button that allows the user to store the current result into the calculator memory and a label that indicates the current value stored in memory.