"""

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):

"""