"""

def __init__(self, width=400, height=300, title="Rose Graphics",

color="black", canvas_color=None,

make_initial_canvas=True):

"""

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

# The _master_Tk controls the mainloop for ALL the RoseWindows.

# If this is the first RoseWindow constructed in this run,

# then construct the _master_Tk object.

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

global _master_Tk

if not _master_Tk:

_master_Tk = tkinter.Tk()

_master_Tk.withdraw()

else:

time.sleep(0.1) # Helps the window appear on TOP of Eclipse

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

# Has a tkinter.Toplevel, and a tkinter.Canvas on the Toplevel.

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

self.toplevel = tkinter.Toplevel(_master_Tk,

background=color,

width=width, height=height)

self.toplevel.title(title)

self._is_closed = False

self.toplevel.protocol("WM_DELETE_WINDOW", self.close)

# FIXME: The next two need to be properties to have

# setting happen correctly. Really belongs to RoseCanvas.

# See comments elsewhere on this.

self.width = width

self.height = height

if make_initial_canvas:

self.initial_canvas = RoseCanvas(self, width, height,

canvas_color)

else:

self.initial_canvas = None

self.widgets = [self.initial_canvas]

# FIXME: Do any other tailoring of the toplevel as desired,

# e.g. borderwidth and style...

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

# Catch mouse clicks and key presses.

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

self.mouse = Mouse()

self.keyboard = Keyboard()

self.toplevel.bind("<Button>", self._on_mouse_click)

self.toplevel.bind("<KeyPress>", self._on_key_press)

self.update()

def close(self):

""" Closes this RoseWindow. """

if self.toplevel:

self.toplevel.destroy()

self.toplevel = None

self.update()

self._is_closed = True

def update(self):

"""

global _master_Tk

_master_Tk.update()

def render(self, seconds_to_pause=None):

"""

for widget in self.widgets:

if type(widget) == RoseCanvas:

widget.render()

self.update()

if seconds_to_pause:

time.sleep(seconds_to_pause)

def close_on_mouse_click(self):

"""

message = "To exit, click anywhere in this window"

click_position = self.continue_on_mouse_click(message=message,

close_it=True)

return click_position

def continue_on_mouse_click(self,

message="To continue, click anywhere in this window",

x_position=None,

y_position=None,

close_it=False,

erase_it=True):

"""

if self._is_closed:

return

if x_position is None:

x_position = self.width / 2

if y_position is None:

y_position = self.height - 20

anchor_point = Point(x_position, y_position)

text = Text(anchor_point, message)

# FIXME: Really should do all this on a per-RoseCanvas basis.

if self.initial_canvas:

text.attach_to(self.initial_canvas)

self.initial_canvas._renderShape(text, render_NOW=True)

click_position = self.get_next_mouse_click()

if erase_it and self.initial_canvas:

text.detach_from(self.initial_canvas)

if close_it:

self.close() # then close the window

return click_position

def get_next_mouse_click(self):

"""

self.mouse.position = None

while True:

if self._is_closed:

return None

if self.mouse.position is not None:

break

self.update()

time.sleep(.05) # allow time for other events to be handled

click_point = self.mouse.position

self.mouse.position = None

return click_point

def _on_mouse_click(self, event):

self.mouse._update(event)

def _on_key_press(self, event):

self.keyboard._update(event)

def __serialize_shapes(self):

"""

"""

def __init__(self, window):

self._window = window

def get_window(self):

defaults = {"colors": [None, "yellow", "light blue", "dark grey"]}

count = 0

"""

def __init__(self, window, width=200, height=200,

background_color=0):

super().__init__(window)

RoseCanvas.count = RoseCanvas.count + 1

# FIXME: Deal with default background colors.

# FIXME: Store background color as a property

# so that modifying it changes the tkinter canvas.

# Ditto width and height.

tk_canvas = tkinter.Canvas(window.toplevel,

width=width, height=height,

background=background_color)

self._tkinter_canvas = tk_canvas

# FIXME: Automate gridding better.

self._tkinter_canvas.grid(padx=5, pady=5)

self.shapes = []

def render(self, seconds_to_pause=None):

"""

self._update_shapes()

self._window.update()

if seconds_to_pause:

time.sleep(seconds_to_pause)

def _renderShape(self, shape, render_NOW=False):

"""Renders a shape."""

coordinates = shape._get_coordinates_for_drawing()

options = shape._get_options_for_drawing()

if shape.shape_id_by_canvas[self] is None:

shape.shape_id_by_canvas[self] = \

shape._method_for_drawing(self._tkinter_canvas, *coordinates)

try:

self._tkinter_canvas.coords(shape.shape_id_by_canvas[self],

*coordinates)

except tkinter.TclError:

msg = "Could not place the shape\n"

msg += "on the given window.\n"

msg += "Did you accidentally close a window\n"

msg += "that later needed to be rendered again?"

raise Exception(msg) from None

self._tkinter_canvas.itemconfigure(shape.shape_id_by_canvas[self],

options)

if render_NOW:

# redraw NOW

self._window.update()

def _draw(self, shape):

"""Queues a shape for being drawn. Does NOT draw it just yet."""

shapeInList = False

for listShape in self.shapes:

if listShape is shape:

shapeInList = True

break

if not shapeInList:

shape.shape_id_by_canvas[self] = None

self.shapes.append(shape)

def _undraw(self, shape):

if shape in self.shapes:

for i in range(len(self.shapes)):

if self.shapes[i] is shape:

self._tkinter_canvas.delete(shape.shape_id_by_canvas[self])

del self.shapes[i]

break

def _update_shapes(self):

for shape in self.shapes:

def __init__(self):

self.position = None

def _update(self, event):

def __init__(self):

self.key_pressed = None

def _update(self, event):

"""Prevents class variable assignment."""

def __setattr__(self, name, _ignored): # last parameter is the value

err = "You tried to set the instance variable "" + name + ""\n"

err += " on the CLASS "" + self.__name__ + """

err += ", which is not an OBJECT.\n"

err += " Did you forget the () after the word "

err += self.__name__ + ",\n"

err += " on the line where you constructed the object?"

"""

def __init__(self, method_for_drawing):

""" Arguments:

self._method_for_drawing = method_for_drawing

self.shape_id_by_canvas = {}

def __eq__(self, other):

"""

# check before we go deleting keys that may or may not exist

if(not isinstance(other, self.__class__)):

return False

self_dict = self.__dict__.copy()

other_dict = other.__dict__.copy()

del self_dict["shape_id_by_canvas"]

del other_dict["shape_id_by_canvas"]

return (self_dict == other_dict)

def __ne__(self, other):

return not self.__eq__(other)

def attach_to(self, window_or_canvas):

"""

if isinstance(window_or_canvas, RoseWindow):

window_or_canvas = window_or_canvas.initial_canvas

window_or_canvas._draw(self)

def detach_from(self, rose_canvas):

"""

if type(rose_canvas) == RoseWindow:

rose_canvas = rose_canvas.initial_canvas

"""

defaults = {"fill_color": None,

"outline_color": "black",

"outline_thickness": 1}

def _initialize_options(self):

self.fill_color = _ShapeWithOutline.defaults["fill_color"]

self.outline_color = _ShapeWithOutline.defaults["outline_color"]

self.outline_thickness = _ShapeWithOutline.defaults[

"outline_thickness"]

def _get_options_for_drawing(self):

options = {"fill": self.fill_color,

"outline": self.outline_color,

"width": self.outline_thickness}

# If a color is None, that means transparent here:

for option in ("fill", "outline"):

if not options[option]:

options[option] = ""

"""

defaults = {"color": "black",

"thickness": 1,

"arrow": None}

def _initialize_options(self):

self.color = _ShapeWithThickness.defaults["color"]

self.thickness = _ShapeWithThickness.defaults["thickness"]

self.arrow = _ShapeWithThickness.defaults["arrow"]

def _get_options_for_drawing(self):

options = {"fill": self.color,

"width": self.thickness,

"arrow": self.arrow}

# If a color is None, that means "black" here:

if options["fill"] is None:

options["fill"] = "black"

"""

# FIXME: Add more to the above docstring.

defaults = {"font_family": "helvetica",

"font_size": 14,

"weight": "normal",

"slant": "roman",

"underline": 0,

"overstrike": 0,

"justify": tkinter.CENTER,

"text_box_width": None,

"text_color": "black",

"text": ""}

def _initialize_options(self):

self.font_family = _ShapeWithText.defaults["font_family"]

self.font_size = _ShapeWithText.defaults["font_size"]

self.is_bold = _ShapeWithText.defaults["weight"] == "bold"

self.is_italic = _ShapeWithText.defaults["slant"] == "italic"

self.is_underline = _ShapeWithText.defaults["underline"] == 1

self.is_overstrike = _ShapeWithText.defaults["overstrike"] == 1

self.justify = _ShapeWithText.defaults["justify"]

self.text_box_width = _ShapeWithText.defaults["text_box_width"]

self.text_color = _ShapeWithText.defaults["text_color"]

self.text = _ShapeWithText.defaults["text"]

def _get_options_for_drawing(self):

weight = "bold" if self.is_bold else "normal"

slant = "italic" if self.is_italic else "roman"

underline = 1 if self.is_underline else 0

overstrike = 1 if self.is_overstrike else 0

font = tkinter_font.Font(family=self.font_family,

size=self.font_size,

weight=weight,

slant=slant,

underline=underline,

overstrike=overstrike)

options = {"font": font,

"justify": self.justify,

"fill": self.text_color,

"text": self.text}

if self.text_box_width:

options["width"] = self.text_box_width

"""

def __init__(self, center, method_for_drawing):

"""

# Clone the center argument, so that if the caller

# mutates the argument, it does NOT affect this Shape.

super().__init__(method_for_drawing)

self.center = center.clone()

def move_by(self, dx, dy):

"""

self.center.move_by(dx, dy)

def move_center_to(self, x, y):

"""

"""

def __init__(self, corner_1, corner_2, method_for_drawing):

"""

super().__init__(method_for_drawing)

self.corner_1 = corner_1.clone()

self.corner_2 = corner_2.clone()

self._update_corners()

def __repr__(self):

""" Returns a string representation of this shape. """

f_string = ""

f_string += "{}: corner_1=({}, {}), corner_2=({}, {}),"

f_string += " fill_color={},"

f_string += " outline_color={}, outline_thickness={}."

return f_string.format(self.__class__.__name__,

self.corner_1.x, self.corner_1.y,

self.corner_2.x, self.corner_2.y,

self.fill_color, self.outline_color,

self.outline_thickness)

def move_by(self, dx, dy):

"""

self.corner_1.x += dx

self.corner_1.y += dy

self.corner_2.x += dx

self.corner_2.y += dy

def clone(self):

"""

return self.__class__(self.corner_1.clone(),

self.corner_2.clone())

def get_upper_left_corner(self):

"""

self._update_corners()

return self._upper_left_corner

def get_lower_left_corner(self):

"""

self._update_corners()

return self._lower_left_corner

def get_upper_right_corner(self):

"""

self._update_corners()

return self._upper_right_corner

def get_lower_right_corner(self):

"""

self._update_corners()

return self._lower_right_corner

def get_center(self):

"""

return Point((self.corner_1.x + self.corner_2.x) / 2,

(self.corner_1.y + self.corner_2.y) / 2)

def get_height(self):

"""

return abs(self.corner_1.y - self.corner_2.y)

def get_width(self):

"""

return abs(self.corner_1.x - self.corner_2.x)

def get_bounding_box(self):

"""

return Rectangle(self.corner_1, self.corner_2)

def _update_corners(self):

min_x = min(self.corner_1.x, self.corner_2.x)

min_y = min(self.corner_1.y, self.corner_2.y)

max_x = max(self.corner_1.x, self.corner_2.x)

max_y = max(self.corner_1.y, self.corner_2.y)

self._upper_left_corner = Point(min_x, min_y)

self._upper_right_corner = Point(max_x, min_y)

self._lower_left_corner = Point(min_x, max_y)

self._lower_right_corner = Point(max_x, max_y)

def _get_coordinates_for_drawing(self):

return [self.get_upper_left_corner().x,

self.get_upper_left_corner().y,

self.get_lower_right_corner().x,

"""

def __init__(self, center, radius):

"""

# The following sets instance variable

# self.center

# to a clone (copy) of the given rg.Point.

super().__init__(center, tkinter.Canvas.create_oval)

# The following sets default values for:

# self.fill_color

# self.outline_color

# self.outline_thickness

super()._initialize_options()

# The radius is also stored in an instance variable:

self.radius = radius

def __repr__(self):

""" Returns a string representation of this Circle. """

f_string = ""

f_string += "Circle: center=({}, {}), radius={}, fill_color={}, "

f_string += "outline_color={}, outline_thickness={}."

return f_string.format(self.center.x, self.center.y,

self.radius,

self.fill_color, self.outline_color,

self.outline_thickness)

def clone(self):

""" Returns a copy of this Circle. """

return Circle(self.center, self.radius)

def get_bounding_box(self):

"""

c1 = Point(self.center.x - self.radius,

self.center.y - self.radius)

c2 = Point(self.center.x + self.radius,

self.center.y + self.radius)

return Rectangle(c1, c2)

def _get_coordinates_for_drawing(self):

"""