def test_no_shared_state():
"""
See issue #11.
"""
grid_1 = drawing.Grid()
grid_2 = drawing.Grid()
i, j = 0, 0
grid_1.set_row_height(i, 1)
grid_2.set_row_height(i, 2)
assert grid_1.get_requested_row_height(i) == 1
assert grid_2.get_requested_row_height(i) == 2
grid_1.set_col_width(j, 1)
grid_2.set_col_width(j, 2)
assert grid_1.get_requested_col_width(j) == 1
assert grid_2.get_requested_col_width(j) == 2
rect_1, rect_2 = Rect.from_size(1, 1), Rect.from_size(2, 2)
assert rect_1 is not rect_2
grid_1.set_min_cell_rect(i, j, rect_1)
grid_2.set_min_cell_rect(i, j, rect_2)
assert grid_1.get_min_cell_rect(i, j) is rect_1
assert grid_2.get_min_cell_rect(i, j) is rect_2
def test_inner_padding():
cells = drawing.make_grid(
Rect.from_size(10, 10),
num_rows=1,
num_cols=1,
inner_padding=1,
)
assert cells == {
(0, 0): Rect(0, 0, 10, 10),
}
cells = drawing.make_grid(
Rect.from_size(10, 11),
num_rows=2,
num_cols=1,
inner_padding=1,
)
assert cells == {
(0, 0): Rect(0, 6, 10, 5),
(1, 0): Rect(0, 0, 10, 5),
}
cells = drawing.make_grid(Rect.from_size(11, 10),
num_rows=1,
num_cols=2,
inner_padding=1)
assert cells == {
(0, 0): Rect(0, 0, 5, 10),
(0, 1): Rect(6, 0, 5, 10),
}
def test_padding():
cells = drawing.make_grid(
Rect.from_size(10, 10),
num_rows=1,
num_cols=1,
padding=1,
)
assert cells == {
(0, 0): Rect(1, 1, 8, 8),
}
cells = drawing.make_grid(
Rect.from_size(10, 11),
num_rows=2,
num_cols=1,
padding=1,
)
assert cells == {
(0, 0): Rect(1, 6, 8, 4),
(1, 0): Rect(1, 1, 8, 4),
}
cells = drawing.make_grid(Rect.from_size(11, 10),
num_rows=1,
num_cols=2,
padding=1)
assert cells == {
(0, 0): Rect(1, 1, 4, 8),
(0, 1): Rect(6, 1, 4, 8),
}
def do_draw_hands(self):
# We're hard-coding the radii of the hands here. Probably it would be
# better to make separate attributes for these, but I think that would
# start to detract from the clarity of the example.
rects = {
'hour': Rect.from_size(self.custom_hour_hand_width,
self.radius / 2),
'min': Rect.from_size(self.custom_minute_hand_width, self.radius),
'sec': Rect.from_size(self.custom_second_hand_width, self.radius),
}
# The clock hands all start pointing towards 12:00, and the rotations
# are clockwise, so 90° is 3:00, 180° is 6:00, 270° is 9:00, etc.
now = datetime.datetime.now()
angles = {
'hour': 360 * now.hour / 12,
'min': 360 * now.minute / 60,
'sec': 360 * now.second / 60,
}
for k in self._hands:
rects[k].bottom = 0
rects[k].center_x = 0
self._hands[k].rect = rects[k]
self._hands[k].group.angle = angles[k]
self._hands[k].color = self._color
self._hands[k].show()
def do_draw_hands(self):
# We're hard-coding the radii of the hands here. Probably it would be
# better to make separate attributes for these, but I think that would
# start to detract from the clarity of the example.
rects = {
'hour': Rect.from_size(self.custom_hour_hand_width, self.radius/2),
'min': Rect.from_size(self.custom_minute_hand_width, self.radius),
'sec': Rect.from_size(self.custom_second_hand_width, self.radius),
}
# The clock hands all start pointing towards 12:00, and the rotations
# are clockwise, so 90° is 3:00, 180° is 6:00, 270° is 9:00, etc.
now = datetime.datetime.now()
angles = {
'hour': 360 * now.hour / 12,
'min': 360 * now.minute / 60,
'sec': 360 * now.second / 60,
}
for k in self._hands:
rects[k].bottom = 0
rects[k].center_x = 0
self._hands[k].rect = rects[k]
self._hands[k].group.angle = angles[k]
self._hands[k].color = self._color
self._hands[k].show()
def test_padding():
cells = drawing.make_grid(
Rect.from_size(10, 10),
num_rows=1,
num_cols=1,
padding=1,
)
assert cells == {
(0,0): Rect(1, 1, 8, 8),
}
cells = drawing.make_grid(
Rect.from_size(10, 11),
num_rows=2,
num_cols=1,
padding=1,
)
assert cells == {
(0,0): Rect(1, 6, 8, 4),
(1,0): Rect(1, 1, 8, 4),
}
cells = drawing.make_grid(
Rect.from_size(11, 10),
num_rows=1,
num_cols=2,
padding=1
)
assert cells == {
(0,0): Rect(1, 1, 4, 8),
(0,1): Rect(6, 1, 4, 8),
}
def test_bounding_rect_too_small():
# Just big enough, should not raise.
drawing.make_grid(
Rect.from_size(10, 10),
num_rows=1,
num_cols=1,
default_row_height=10,
default_col_width=10,
)
# Too narrow.
with pytest.raises(UsageError):
drawing.make_grid(
Rect.from_size(9, 10),
num_rows=1,
num_cols=1,
default_row_height=10,
default_col_width=10,
)
# Too short.
with pytest.raises(UsageError):
drawing.make_grid(
Rect.from_size(10, 9),
num_rows=1,
num_cols=1,
default_row_height=10,
default_col_width=10,
)
def test_no_shared_state():
"""
See issue #11.
"""
grid_1 = drawing.Grid()
grid_2 = drawing.Grid()
i, j = 0, 0
grid_1.set_row_height(i, 1)
grid_2.set_row_height(i, 2)
assert grid_1.get_requested_row_height(i) == 1
assert grid_2.get_requested_row_height(i) == 2
grid_1.set_col_width(j, 1)
grid_2.set_col_width(j, 2)
assert grid_1.get_requested_col_width(j) == 1
assert grid_2.get_requested_col_width(j) == 2
rect_1, rect_2 = Rect.from_size(1, 1), Rect.from_size(2, 2)
assert rect_1 is not rect_2
grid_1.set_min_cell_rect(i, j, rect_1)
grid_2.set_min_cell_rect(i, j, rect_2)
assert grid_1.get_min_cell_rect(i, j) is rect_1
assert grid_2.get_min_cell_rect(i, j) is rect_2
def test_inner_padding():
cells = drawing.make_grid(
Rect.from_size(10, 10),
num_rows=1,
num_cols=1,
inner_padding=1,
)
assert cells == {
(0,0): Rect(0, 0, 10, 10),
}
cells = drawing.make_grid(
Rect.from_size(10, 11),
num_rows=2,
num_cols=1,
inner_padding=1,
)
assert cells == {
(0,0): Rect(0, 6, 10, 5),
(1,0): Rect(0, 0, 10, 5),
}
cells = drawing.make_grid(
Rect.from_size(11, 10),
num_rows=1,
num_cols=2,
inner_padding=1
)
assert cells == {
(0,0): Rect(0, 0, 5, 10),
(0,1): Rect(6, 0, 5, 10),
}
def test_bounding_rect_too_small():
# Just big enough, should not raise.
drawing.make_grid(
Rect.from_size(10, 10),
num_rows=1,
num_cols=1,
default_row_height=10,
default_col_width=10,
)
# Too narrow.
with pytest.raises(UsageError):
drawing.make_grid(
Rect.from_size(9, 10),
num_rows=1,
num_cols=1,
default_row_height=10,
default_col_width=10,
)
# Too short.
with pytest.raises(UsageError):
drawing.make_grid(
Rect.from_size(10, 9),
num_rows=1,
num_cols=1,
default_row_height=10,
default_col_width=10,
)
def test_negative_sizes():
# Initially I thought this should be an error, but then I decided that it
# probably just works as you'd expect it to, and it might be a useful way
# to create an overlapping effect or to get rid of padding in certain
# places.
# row_heights can be negative.
cells = drawing.make_grid(
Rect.from_size(10, 10),
num_rows=2,
num_cols=1,
row_heights={0: -2},
)
assert cells == {
(0, 0): Rect(0, 12, 10, -2),
(1, 0): Rect(0, 0, 10, 12),
}
# default_row_height can be negative.
cells = drawing.make_grid(
Rect.from_size(10, 10),
num_rows=2,
num_cols=1,
row_heights={1: 'expand'},
default_row_height=-2,
)
assert cells == {
(0, 0): Rect(0, 12, 10, -2),
(1, 0): Rect(0, 0, 10, 12),
}
# col_widths can be negative.
cells = drawing.make_grid(
Rect.from_size(10, 10),
num_rows=1,
num_cols=2,
col_widths={0: -2},
)
assert cells == {
(0, 0): Rect(0, 0, -2, 10),
(0, 1): Rect(-2, 0, 12, 10),
}
# default_col_width can be negative.
cells = drawing.make_grid(
Rect.from_size(10, 10),
num_rows=1,
num_cols=2,
col_widths={1: 'expand'},
default_col_width=-2,
)
assert cells == {
(0, 0): Rect(0, 0, -2, 10),
(0, 1): Rect(-2, 0, 12, 10),
}
def test_negative_sizes():
# Initially I thought this should be an error, but then I decided that it
# probably just works as you'd expect it to, and it might be a useful way
# to create an overlapping effect or to get rid of padding in certain
# places.
# row_heights can be negative.
cells = drawing.make_grid(
Rect.from_size(10, 10),
num_rows=2,
num_cols=1,
row_heights={0: -2},
)
assert cells == {
(0,0): Rect(0, 12, 10, -2),
(1,0): Rect(0, 0, 10, 12),
}
# default_row_height can be negative.
cells = drawing.make_grid(
Rect.from_size(10, 10),
num_rows=2,
num_cols=1,
row_heights={1: 'expand'},
default_row_height=-2,
)
assert cells == {
(0,0): Rect(0, 12, 10, -2),
(1,0): Rect(0, 0, 10, 12),
}
# col_widths can be negative.
cells = drawing.make_grid(
Rect.from_size(10, 10),
num_rows=1,
num_cols=2,
col_widths={0: -2},
)
assert cells == {
(0,0): Rect(0, 0, -2, 10),
(0,1): Rect(-2, 0, 12, 10),
}
# default_col_width can be negative.
cells = drawing.make_grid(
Rect.from_size(10, 10),
num_rows=1,
num_cols=2,
col_widths={1: 'expand'},
default_col_width=-2,
)
assert cells == {
(0,0): Rect(0, 0, -2, 10),
(0,1): Rect(-2, 0, 12, 10),
}
def test_infer_grid_size():
cells = drawing.make_grid(
Rect.from_size(10, 10),
cells={
(0,0): Rect.null(),
},
)
assert cells == {
(0,0): Rect(0, 0, 10, 10),
}
cells = drawing.make_grid(
Rect.from_size(10, 10),
cells={
(0,0): Rect.null(),
(1,0): Rect.null(),
},
)
assert cells == {
(0,0): Rect(0, 5, 10, 5),
(1,0): Rect(0, 0, 10, 5),
}
cells = drawing.make_grid(
Rect.from_size(10, 10),
cells={
(0,0): Rect.null(),
(0,1): Rect.null(),
},
)
assert cells == {
(0,0): Rect(0, 0, 5, 10),
(0,1): Rect(5, 0, 5, 10),
}
cells = drawing.make_grid(
Rect.from_size(10, 10),
cells={
(0,0): Rect.null(),
(1,1): Rect.null(),
},
)
assert cells == {
(0,0): Rect(0, 5, 5, 5),
(0,1): Rect(5, 5, 5, 5),
(1,0): Rect(0, 0, 5, 5),
(1,1): Rect(5, 0, 5, 5),
}
def test_infer_grid_size():
cells = drawing.make_grid(
Rect.from_size(10, 10),
cells={
(0, 0): Rect.null(),
},
)
assert cells == {
(0, 0): Rect(0, 0, 10, 10),
}
cells = drawing.make_grid(
Rect.from_size(10, 10),
cells={
(0, 0): Rect.null(),
(1, 0): Rect.null(),
},
)
assert cells == {
(0, 0): Rect(0, 5, 10, 5),
(1, 0): Rect(0, 0, 10, 5),
}
cells = drawing.make_grid(
Rect.from_size(10, 10),
cells={
(0, 0): Rect.null(),
(0, 1): Rect.null(),
},
)
assert cells == {
(0, 0): Rect(0, 0, 5, 10),
(0, 1): Rect(5, 0, 5, 10),
}
cells = drawing.make_grid(
Rect.from_size(10, 10),
cells={
(0, 0): Rect.null(),
(1, 1): Rect.null(),
},
)
assert cells == {
(0, 0): Rect(0, 5, 5, 5),
(0, 1): Rect(5, 5, 5, 5),
(1, 0): Rect(0, 0, 5, 5),
(1, 1): Rect(5, 0, 5, 5),
}
def set_images(self, *, color=None, center=None, top=None, bottom=None,
left=None, right=None, top_left=None, top_right=None,
bottom_left=None, bottom_right=None, vtile=None, htile=None):
self._color = color
self._tile_images = {
ij: img for ij, img in {
(0,0): top_left,
(0,1): top,
(0,2): top_right,
(1,0): left,
(1,1): center,
(1,2): right,
(2,0): bottom_left,
(2,1): bottom,
(2,2): bottom_right,
}.items()
if img is not None}
self._grid.min_cell_rects={
ij: Rect.from_size(img.width, img.height)
for ij, img in self._tile_images.items()}
if vtile is not None: self._vtile = vtile
if htile is not None: self._htile = htile
self._update_tiles()
def test_one_cell():
cells = drawing.make_grid(
Rect.from_size(10, 10),
num_rows=1,
num_cols=1,
)
assert cells == {
(0, 0): Rect(0, 0, 10, 10),
}
def test_one_cell():
cells = drawing.make_grid(
Rect.from_size(10, 10),
num_rows=1,
num_cols=1,
)
assert cells == {
(0,0): Rect(0, 0, 10, 10),
}
def test_setters():
grid = drawing.Grid()
assert grid.make_claim() == (0, 0)
grid.num_rows = 1
grid.default_row_height = 10
assert grid.make_claim() == (0, 10)
grid.num_cols = 1
grid.default_col_width = 10
assert grid.make_claim() == (10, 10)
grid.padding = 1
assert grid.make_claim() == (12, 12)
grid.num_rows = 2
grid.num_cols = 2
assert grid.make_claim() == (23, 23)
grid.set_min_cell_rects({(0,0): Rect.from_size(20, 20)})
assert grid.make_claim() == (33, 33)
grid.del_min_cell_rects()
assert grid.make_claim() == (23, 23)
grid.set_min_cell_rect(0, 0, Rect.from_size(20, 20))
assert grid.make_claim() == (33, 33)
grid.del_min_cell_rect(0, 0)
assert grid.make_claim() == (23, 23)
grid.set_row_height(0, 20)
assert grid.make_claim() == (23, 33)
grid.del_row_height(0)
assert grid.make_claim() == (23, 23)
grid.set_col_width(0, 20)
assert grid.make_claim() == (33, 23)
grid.del_col_width(0)
assert grid.make_claim() == (23, 23)
def test_no_expandable_cells():
# If the grid can't fill all the space made available to it, it will pack
# against the top-left corner. I chose this corner arbitrarily (although
# other corners would've been slightly harder to implement). I decided
# against adding the ability to control how the grid fits in its bounding
# box for two reasons. First, you can get the same effect by simply adding
# expandable rows or columns. Second, you can just change the bounding
# box. Still, it's possible I'll change my mind about this behavior.
cells = drawing.make_grid(
Rect.from_size(10, 10),
num_rows=1,
num_cols=1,
row_heights={0: 2},
col_widths={0: 2},
)
assert cells == {
(0,0): Rect(0, 8, 2, 2),
}
cells = drawing.make_grid(
Rect.from_size(10, 10),
num_rows=1,
num_cols=1,
default_row_height=2,
default_col_width=2,
)
assert cells == {
(0,0): Rect(0, 8, 2, 2),
}
cells = drawing.make_grid(
Rect.from_size(10, 10),
cells={
(0,0): Rect.from_size(2, 2),
},
default_row_height=0,
default_col_width=0,
)
assert cells == {
(0,0): Rect(0, 8, 2, 2),
}
def test_setters():
grid = drawing.Grid()
assert grid.make_claim() == (0, 0)
grid.num_rows = 1
grid.default_row_height = 10
assert grid.make_claim() == (0, 10)
grid.num_cols = 1
grid.default_col_width = 10
assert grid.make_claim() == (10, 10)
grid.padding = 1
assert grid.make_claim() == (12, 12)
grid.num_rows = 2
grid.num_cols = 2
assert grid.make_claim() == (23, 23)
grid.set_min_cell_rects({(0, 0): Rect.from_size(20, 20)})
assert grid.make_claim() == (33, 33)
grid.del_min_cell_rects()
assert grid.make_claim() == (23, 23)
grid.set_min_cell_rect(0, 0, Rect.from_size(20, 20))
assert grid.make_claim() == (33, 33)
grid.del_min_cell_rect(0, 0)
assert grid.make_claim() == (23, 23)
grid.set_row_height(0, 20)
assert grid.make_claim() == (23, 33)
grid.del_row_height(0)
assert grid.make_claim() == (23, 23)
grid.set_col_width(0, 20)
assert grid.make_claim() == (33, 23)
grid.del_col_width(0)
assert grid.make_claim() == (23, 23)
def test_no_expandable_cells():
# If the grid can't fill all the space made available to it, it will pack
# against the top-left corner. I chose this corner arbitrarily (although
# other corners would've been slightly harder to implement). I decided
# against adding the ability to control how the grid fits in its bounding
# box for two reasons. First, you can get the same effect by simply adding
# expandable rows or columns. Second, you can just change the bounding
# box. Still, it's possible I'll change my mind about this behavior.
cells = drawing.make_grid(
Rect.from_size(10, 10),
num_rows=1,
num_cols=1,
row_heights={0: 2},
col_widths={0: 2},
)
assert cells == {
(0, 0): Rect(0, 8, 2, 2),
}
cells = drawing.make_grid(
Rect.from_size(10, 10),
num_rows=1,
num_cols=1,
default_row_height=2,
default_col_width=2,
)
assert cells == {
(0, 0): Rect(0, 8, 2, 2),
}
cells = drawing.make_grid(
Rect.from_size(10, 10),
cells={
(0, 0): Rect.from_size(2, 2),
},
default_row_height=0,
default_col_width=0,
)
assert cells == {
(0, 0): Rect(0, 8, 2, 2),
}
def test_two_cells():
cells = drawing.make_grid(
Rect.from_size(10, 10),
num_rows=2,
num_cols=1,
)
assert cells == {
(0,0): Rect(0, 5, 10, 5),
(1,0): Rect(0, 0, 10, 5),
}
cells = drawing.make_grid(
Rect.from_size(10, 10),
num_rows=1,
num_cols=2,
)
assert cells == {
(0,0): Rect(0, 0, 5, 10),
(0,1): Rect(5, 0, 5, 10),
}
def test_make_claim():
grid = drawing.Grid()
cells = {
(0,0): Rect.from_size(1, 2),
(1,1): Rect.from_size(3, 4),
}
assert grid.make_claim(cells) == (6, 8)
assert grid.make_claim() == (6, 8)
assert grid.min_width == 6
assert grid.min_height == 8
assert grid.min_bounding_rect == Rect(0, 0, 6, 8)
grid.default_row_height = 0
grid.default_col_width = 0
assert grid.make_claim(cells) == (4, 6)
assert grid.make_claim() == (4, 6)
assert grid.min_width == 4
assert grid.min_height == 6
assert grid.min_bounding_rect == Rect(0, 0, 4, 6)
def test_two_cells():
cells = drawing.make_grid(
Rect.from_size(10, 10),
num_rows=2,
num_cols=1,
)
assert cells == {
(0, 0): Rect(0, 5, 10, 5),
(1, 0): Rect(0, 0, 10, 5),
}
cells = drawing.make_grid(
Rect.from_size(10, 10),
num_rows=1,
num_cols=2,
)
assert cells == {
(0, 0): Rect(0, 0, 5, 10),
(0, 1): Rect(5, 0, 5, 10),
}
def test_make_claim():
grid = drawing.Grid()
cells = {
(0, 0): Rect.from_size(1, 2),
(1, 1): Rect.from_size(3, 4),
}
assert grid.make_claim(cells) == (6, 8)
assert grid.make_claim() == (6, 8)
assert grid.min_width == 6
assert grid.min_height == 8
assert grid.min_bounding_rect == Rect(0, 0, 6, 8)
grid.default_row_height = 0
grid.default_col_width = 0
assert grid.make_claim(cells) == (4, 6)
assert grid.make_claim() == (4, 6)
assert grid.min_width == 4
assert grid.min_height == 6
assert grid.min_bounding_rect == Rect(0, 0, 4, 6)
def set_appearance(self, *, color=None, outline=None, image=None,
center=None, top=None, bottom=None, left=None, right=None,
top_left=None, top_right=None, bottom_left=None, bottom_right=None,
vtile='auto', htile='auto'):
if image and center:
raise UsageError("""\
specifying both 'image' and 'center' is ambiguous.
Both of these options specify an image that should go in the middle of the
frame. The only difference is that, if 'htile' or 'vtile' are set to 'auto'
(the default value), 'center' enables tiling and 'image' doesn't.""")
# Decide whether the background should tile in either dimension.
auto_vtile = False
auto_htile = False
if top or bottom:
auto_vtile = True
if left or right:
auto_htile = True
if center and not (top or left or bottom or right):
auto_vtile = True
auto_htile = True
self._vtile = auto_vtile if vtile == 'auto' else vtile
self._htile = auto_htile if htile == 'auto' else htile
# Store the images in a grid-like data structure.
self._color = color
self._outline = outline
self._tile_images = {
ij: img for ij, img in {
(0,0): top_left,
(0,1): top,
(0,2): top_right,
(1,0): left,
(1,1): center or image,
(1,2): right,
(2,0): bottom_left,
(2,1): bottom,
(2,2): bottom_right,
}.items()
if img is not None}
self._grid.min_cell_rects = {
ij: Rect.from_size(img.width, img.height)
for ij, img in self._tile_images.items()}
self._update_tiles()
def do_resize_children(self):
grip_width, grip_height = self.grip.claimed_size
if self.bar.scale_grip:
scaled_width, scaled_height = self.bar._get_scaled_grip_size()
grip_width = clamp(scaled_width, grip_width, self.width)
grip_height = clamp(scaled_height, grip_height, self.height)
# Copied from `Mover.do_resize_children()`; refer there for
# details. Maybe should be more DRY...
child_rect = Rect.from_size(grip_width, grip_height)
self.child._resize(child_rect)
self._keep_child_in_rect()
def test_request_col_width():
cells = drawing.make_grid(
Rect.from_size(10, 10),
num_rows=1,
num_cols=2,
col_widths={0: 2},
)
assert cells == {
(0,0): Rect(0, 0, 2, 10),
(0,1): Rect(2, 0, 8, 10),
}
cells = drawing.make_grid(
Rect.from_size(10, 10),
num_rows=1,
num_cols=2,
col_widths={1: 2},
)
assert cells == {
(0,0): Rect(0, 0, 8, 10),
(0,1): Rect(8, 0, 2, 10),
}
def test_request_col_width():
cells = drawing.make_grid(
Rect.from_size(10, 10),
num_rows=1,
num_cols=2,
col_widths={0: 2},
)
assert cells == {
(0, 0): Rect(0, 0, 2, 10),
(0, 1): Rect(2, 0, 8, 10),
}
cells = drawing.make_grid(
Rect.from_size(10, 10),
num_rows=1,
num_cols=2,
col_widths={1: 2},
)
assert cells == {
(0, 0): Rect(0, 0, 8, 10),
(0, 1): Rect(8, 0, 2, 10),
}
def test_request_row_height():
cells = drawing.make_grid(
Rect.from_size(10, 10),
num_rows=2,
num_cols=1,
row_heights={0: 2},
)
assert cells == {
(0, 0): Rect(0, 8, 10, 2),
(1, 0): Rect(0, 0, 10, 8),
}
cells = drawing.make_grid(
Rect.from_size(10, 10),
num_rows=2,
num_cols=1,
row_heights={1: 2},
)
assert cells == {
(0, 0): Rect(0, 2, 10, 8),
(1, 0): Rect(0, 0, 10, 2),
}
def test_request_row_height():
cells = drawing.make_grid(
Rect.from_size(10, 10),
num_rows=2,
num_cols=1,
row_heights={0: 2},
)
assert cells == {
(0,0): Rect(0, 8, 10, 2),
(1,0): Rect(0, 0, 10, 8),
}
cells = drawing.make_grid(
Rect.from_size(10, 10),
num_rows=2,
num_cols=1,
row_heights={1: 2},
)
assert cells == {
(0,0): Rect(0, 2, 10, 8),
(1,0): Rect(0, 0, 10, 2),
}
def test_make_cells():
grid = drawing.Grid()
grid.num_rows = 2
grid.num_cols = 2
expected_results = [
(Rect.from_size(10, 10), {
(0, 0): Rect(0, 5, 5, 5),
(0, 1): Rect(5, 5, 5, 5),
(1, 0): Rect(0, 0, 5, 5),
(1, 1): Rect(5, 0, 5, 5),
}),
(Rect.from_size(20, 20), {
(0, 0): Rect(0, 10, 10, 10),
(0, 1): Rect(10, 10, 10, 10),
(1, 0): Rect(0, 0, 10, 10),
(1, 1): Rect(10, 0, 10, 10),
}),
]
for bbox, cells in expected_results:
assert grid.make_cells(bbox) == cells
assert grid.make_cells() == cells
assert grid.cell_rects == cells
assert grid.bounding_rect == bbox
def test_make_cells():
grid = drawing.Grid()
grid.num_rows = 2
grid.num_cols = 2
expected_results = [(
Rect.from_size(10, 10), {
(0, 0): Rect(0, 5, 5, 5),
(0, 1): Rect(5, 5, 5, 5),
(1, 0): Rect(0, 0, 5, 5),
(1, 1): Rect(5, 0, 5, 5),
}),(
Rect.from_size(20, 20), {
(0, 0): Rect(0, 10, 10, 10),
(0, 1): Rect(10, 10, 10, 10),
(1, 0): Rect(0, 0, 10, 10),
(1, 1): Rect(10, 0, 10, 10),
}),
]
for bbox, cells in expected_results:
assert grid.make_cells(bbox) == cells
assert grid.make_cells() == cells
assert grid.cell_rects == cells
assert grid.bounding_rect == bbox
def test_default_col_width():
cells = drawing.make_grid(
Rect.from_size(10, 10),
num_rows=1,
num_cols=2,
col_widths={0: 'expand'},
default_col_width=2,
)
assert cells == {
(0,0): Rect(0, 0, 8, 10),
(0,1): Rect(8, 0, 2, 10),
}
cells = drawing.make_grid(
Rect.from_size(10, 10),
num_rows=1,
num_cols=2,
col_widths={1: 'expand'},
default_col_width=2,
)
assert cells == {
(0,0): Rect(0, 0, 2, 10),
(0,1): Rect(2, 0, 8, 10),
}
def test_default_row_height():
cells = drawing.make_grid(
Rect.from_size(10, 10),
num_rows=2,
num_cols=1,
row_heights={0: 'expand'},
default_row_height=2,
)
assert cells == {
(0,0): Rect(0, 2, 10, 8),
(1,0): Rect(0, 0, 10, 2),
}
cells = drawing.make_grid(
Rect.from_size(10, 10),
num_rows=2,
num_cols=1,
row_heights={1: 'expand'},
default_row_height=2,
)
assert cells == {
(0,0): Rect(0, 8, 10, 2),
(1,0): Rect(0, 0, 10, 8),
}
def test_min_cell_rect_vs_row_height():
# If there is a cell larger than the specified row height, make the row big
# enough to fit that cell.
cells = drawing.make_grid(
Rect.from_size(10, 10),
cells={
(0, 0): Rect.from_size(2, 2),
},
num_rows=2,
num_cols=1,
row_heights={0: 0},
)
assert cells == {
(0, 0): Rect(0, 8, 10, 2),
(1, 0): Rect(0, 0, 10, 8),
}
# If the specified row height is larger than any of the cells in the row,
# make the row the specified height.
cells = drawing.make_grid(
Rect.from_size(10, 10),
cells={
(0, 0): Rect.from_size(2, 2),
},
num_rows=2,
num_cols=1,
row_heights={0: 4},
)
assert cells == {
(0, 0): Rect(0, 6, 10, 4),
(1, 0): Rect(0, 0, 10, 6),
}
# If there are multiple cells in the row, the row should be big enough for
# all of them.
cells = drawing.make_grid(
Rect.from_size(10, 10),
cells={
(0, 0): Rect.from_size(2, 2),
(0, 1): Rect.from_size(4, 4),
},
num_rows=2,
num_cols=2,
row_heights={0: 0},
)
assert cells == {
(0, 0): Rect(0, 6, 5, 4),
(0, 1): Rect(5, 6, 5, 4),
(1, 0): Rect(0, 0, 5, 6),
(1, 1): Rect(5, 0, 5, 6),
}
def test_min_cell_rect_vs_row_height():
# If there is a cell larger than the specified row height, make the row big
# enough to fit that cell.
cells = drawing.make_grid(
Rect.from_size(10, 10),
cells={
(0,0): Rect.from_size(2,2),
},
num_rows=2,
num_cols=1,
row_heights={0: 0},
)
assert cells == {
(0,0): Rect(0, 8, 10, 2),
(1,0): Rect(0, 0, 10, 8),
}
# If the specified row height is larger than any of the cells in the row,
# make the row the specified height.
cells = drawing.make_grid(
Rect.from_size(10, 10),
cells={
(0,0): Rect.from_size(2,2),
},
num_rows=2,
num_cols=1,
row_heights={0: 4},
)
assert cells == {
(0,0): Rect(0, 6, 10, 4),
(1,0): Rect(0, 0, 10, 6),
}
# If there are multiple cells in the row, the row should be big enough for
# all of them.
cells = drawing.make_grid(
Rect.from_size(10, 10),
cells={
(0,0): Rect.from_size(2,2),
(0,1): Rect.from_size(4,4),
},
num_rows=2,
num_cols=2,
row_heights={0: 0},
)
assert cells == {
(0,0): Rect(0, 6, 5, 4),
(0,1): Rect(5, 6, 5, 4),
(1,0): Rect(0, 0, 5, 6),
(1,1): Rect(5, 0, 5, 6),
}
def test_default_row_height():
cells = drawing.make_grid(
Rect.from_size(10, 10),
num_rows=2,
num_cols=1,
row_heights={0: 'expand'},
default_row_height=2,
)
assert cells == {
(0, 0): Rect(0, 2, 10, 8),
(1, 0): Rect(0, 0, 10, 2),
}
cells = drawing.make_grid(
Rect.from_size(10, 10),
num_rows=2,
num_cols=1,
row_heights={1: 'expand'},
default_row_height=2,
)
assert cells == {
(0, 0): Rect(0, 8, 10, 2),
(1, 0): Rect(0, 0, 10, 8),
}
def do_resize_children(self):
grip_width, grip_height = self.grip.claimed_size
# Don't try to calculate a scaled grip size if the scroll pane
# doesn't have a child yet. See #36.
if self.bar.scale_grip and self.pane.child:
scaled_width, scaled_height = self.bar._get_scaled_grip_size()
grip_width = clamp(scaled_width, grip_width, self.width)
grip_height = clamp(scaled_height, grip_height, self.height)
# Copied from `Mover.do_resize_children()`; refer there for
# details. Maybe should be more DRY...
child_rect = Rect.from_size(grip_width, grip_height)
self.child._resize(child_rect)
self._keep_child_in_rect()
def test_default_col_width():
cells = drawing.make_grid(
Rect.from_size(10, 10),
num_rows=1,
num_cols=2,
col_widths={0: 'expand'},
default_col_width=2,
)
assert cells == {
(0, 0): Rect(0, 0, 8, 10),
(0, 1): Rect(8, 0, 2, 10),
}
cells = drawing.make_grid(
Rect.from_size(10, 10),
num_rows=1,
num_cols=2,
col_widths={1: 'expand'},
default_col_width=2,
)
assert cells == {
(0, 0): Rect(0, 0, 2, 10),
(0, 1): Rect(2, 0, 8, 10),
}
def __init__(self):
super().__init__()
self.field = Rect.from_size(*self.field_size)
self.cards = {} # do not remove items
self.starter_card = None
self.pegging_stack = []
self.players = []
self.dealer = None
self.pone = None
self.active_player = None
self.phase = None
self.phase = None
def test_real_examples():
cells = drawing.make_grid(
Rect.from_size(640, 480),
cells={
(0,0): Rect(0, 0, 10, 10),
(0,1): Rect(0, 0, 310, 10),
(0,2): Rect(0, 0, 10, 10),
(0,3): Rect(0, 0, 10, 10),
},
col_widths={1: 0},
)
assert cells == {
(0,0): Rect( 0, 0, 110, 480),
(0,1): Rect(110, 0, 310, 480),
(0,2): Rect(420, 0, 110, 480),
(0,3): Rect(530, 0, 110, 480),
}
def test_real_examples():
cells = drawing.make_grid(
Rect.from_size(640, 480),
cells={
(0, 0): Rect(0, 0, 10, 10),
(0, 1): Rect(0, 0, 310, 10),
(0, 2): Rect(0, 0, 10, 10),
(0, 3): Rect(0, 0, 10, 10),
},
col_widths={1: 0},
)
assert cells == {
(0, 0): Rect(0, 0, 110, 480),
(0, 1): Rect(110, 0, 310, 480),
(0, 2): Rect(420, 0, 110, 480),
(0, 3): Rect(530, 0, 110, 480),
}
def test_min_cell_rect_vs_col_width():
cells = drawing.make_grid(
Rect.from_size(10, 10),
cells={
(0,0): Rect.from_size(2,2),
},
num_rows=1,
num_cols=2,
col_widths={0: 0},
)
assert cells == {
(0,0): Rect(0, 0, 2, 10),
(0,1): Rect(2, 0, 8, 10),
}
cells = drawing.make_grid(
Rect.from_size(10, 10),
cells={
(0,0): Rect.from_size(2,2),
},
num_rows=1,
num_cols=2,
col_widths={0: 4},
)
assert cells == {
(0,0): Rect(0, 0, 4, 10),
(0,1): Rect(4, 0, 6, 10),
}
# If there are multiple cells in the column, the column should be big
# enough for all of them.
cells = drawing.make_grid(
Rect.from_size(10, 10),
cells={
(0,0): Rect.from_size(2,2),
(1,0): Rect.from_size(4,4),
},
num_rows=2,
num_cols=2,
col_widths={0: 0},
)
assert cells == {
(0,0): Rect(0, 5, 4, 5),
(1,0): Rect(0, 0, 4, 5),
(0,1): Rect(4, 5, 6, 5),
(1,1): Rect(4, 0, 6, 5),
}
def test_min_cell_rect_vs_col_width():
cells = drawing.make_grid(
Rect.from_size(10, 10),
cells={
(0, 0): Rect.from_size(2, 2),
},
num_rows=1,
num_cols=2,
col_widths={0: 0},
)
assert cells == {
(0, 0): Rect(0, 0, 2, 10),
(0, 1): Rect(2, 0, 8, 10),
}
cells = drawing.make_grid(
Rect.from_size(10, 10),
cells={
(0, 0): Rect.from_size(2, 2),
},
num_rows=1,
num_cols=2,
col_widths={0: 4},
)
assert cells == {
(0, 0): Rect(0, 0, 4, 10),
(0, 1): Rect(4, 0, 6, 10),
}
# If there are multiple cells in the column, the column should be big
# enough for all of them.
cells = drawing.make_grid(
Rect.from_size(10, 10),
cells={
(0, 0): Rect.from_size(2, 2),
(1, 0): Rect.from_size(4, 4),
},
num_rows=2,
num_cols=2,
col_widths={0: 0},
)
assert cells == {
(0, 0): Rect(0, 5, 4, 5),
(1, 0): Rect(0, 0, 4, 5),
(0, 1): Rect(4, 5, 6, 5),
(1, 1): Rect(4, 0, 6, 5),
}
def _find_cell_rects(self):
self._cell_rects = {}
top_cursor = self._bounding_rect.top
for i in range(self._num_rows):
top_cursor -= self._padding
row_height = self._row_heights[i]
left_cursor = self._bounding_rect.left
for j in range(self._num_cols):
left_cursor += self._padding
col_width = self._col_widths[j]
self._cell_rects[i,j] = Rect.from_size(col_width, row_height)
self._cell_rects[i,j].top_left = left_cursor, top_cursor
left_cursor += col_width
top_cursor -= row_height
def __init__(self):
super().__init__()
# Initialize the game objects.
self.field = Rect.from_size(*self.field_size)
self.players = []
self.bullets = []
self.targets = []
self.final_target = None
self.obstacles = []
self.winner = None
# Initialize the 2D physics simulator.
self.space = pymunk.Space()
self.space.gravity = 0, 0
self.make_boundary()
def test_find_cell_under_mouse():
grid = drawing.Grid()
grid.num_rows = 2
grid.num_cols = 2
grid.padding = 1
grid.make_cells(Rect.from_size(5, 5))
expected_results = {
(0, 0): None,
(0, 1): None,
(0, 2): None,
(0, 3): None,
(0, 4): None,
(1, 0): None,
(1, 1): (1, 0),
(1, 2): (1, 0),
(1, 3): (0, 0),
(1, 4): (0, 0),
(2, 0): None,
(2, 1): (1, 0),
(2, 2): (1, 0),
(2, 3): (0, 0),
(2, 4): (0, 0),
(3, 0): None,
(3, 1): (1, 1),
(3, 2): (1, 1),
(3, 3): (0, 1),
(3, 4): (0, 1),
(4, 0): None,
(4, 1): (1, 1),
(4, 2): (1, 1),
(4, 3): (0, 1),
(4, 4): (0, 1),
}
for mouse, cell in expected_results.items():
assert grid.find_cell_under_mouse(*mouse) == cell
def _find_cell_rects(self):
self._row_tops = {}
self._col_lefts = {}
self._cell_rects = {}
top_cursor = self._bounding_rect.top
for i in range(self._num_rows):
top_cursor -= self._get_row_padding(i)
left_cursor = self._bounding_rect.left
row_height = self._row_heights[i]
self._row_tops[i] = top_cursor
for j in range(self._num_cols):
left_cursor += self._get_col_padding(j)
col_width = self._col_widths[j]
self._cell_rects[i, j] = Rect.from_size(col_width, row_height)
self._cell_rects[i, j].top_left = left_cursor, top_cursor
self._col_lefts[j] = left_cursor
left_cursor += col_width
top_cursor -= row_height
def do_resize_children(self):
# Consult the ``expand_horz`` and ``expand_vert`` member variables to
# decide how much space to give the child. If expansion is enabled,
# the child can occupy the whole mover depending on its alignment. The
# advantage of this is that the child can control its initial position
# using alignment. The downside is that widgets with the default
# "fill" alignment can't move, which is a gotcha. If expansion is
# disabled, the child is made as small as possible.
if self.expand_horz:
child_width = self.rect.width
else:
child_width = self.child.claimed_width
if self.expand_vert:
child_height = self.rect.height
else:
child_height = self.child.claimed_height
# Put the bottom left corner of the child's rectangle at the origin.
# This simplifies the offset calculations, relative to having the
# child's rectangle where the parent's is.
child_rect = Rect.from_size(child_width, child_height)
self.child._resize(child_rect)
self._keep_child_in_rect()
def do_resize_children(self):
# Consult the ``expand_horz`` and ``expand_vert`` member variables to
# decide how much space to give the child. If expansion is enabled,
# the child can occupy the whole mover depending on its alignment. The
# advantage of this is that the child can control its initial position
# using alignment. The downside is that widgets with the default
# "fill" alignment can't move, which is a gotcha. If expansion is
# disabled, the child is made as small as possible.
if self.expand_horz:
child_width = self.rect.width
else:
child_width = self.child.claimed_width
if self.expand_vert:
child_height = self.rect.height
else:
child_height = self.child.claimed_height
# Put the bottom left corner of the child's rectangle at the origin.
# This simplifies the offset calculations, relative to having the
# child's rectangle where the parent's is.
child_rect = Rect.from_size(child_width, child_height)
self.child._resize(child_rect)
self._keep_child_in_rect()
def test_find_cell_under_mouse():
grid = drawing.Grid()
grid.num_rows = 2
grid.num_cols = 2
grid.padding = 1
grid.make_cells(Rect.from_size(5, 5))
expected_results = {
(0, 0): None,
(0, 1): None,
(0, 2): None,
(0, 3): None,
(0, 4): None,
(1, 0): None,
(1, 1): (1, 0),
(1, 2): (1, 0),
(1, 3): (0, 0),
(1, 4): (0, 0),
(2, 0): None,
(2, 1): (1, 0),
(2, 2): (1, 0),
(2, 3): (0, 0),
(2, 4): (0, 0),
(3, 0): None,
(3, 1): (1, 1),
(3, 2): (1, 1),
(3, 3): (0, 1),
(3, 4): (0, 1),
(4, 0): None,
(4, 1): (1, 1),
(4, 2): (1, 1),
(4, 3): (0, 1),
(4, 4): (0, 1),
}
for mouse, cell in expected_results.items():
assert grid.find_cell_under_mouse(*mouse) == cell
def get_rect(self):
return Rect.from_size(self._width, self._height)
def get_min_rect(self):
return Rect.from_size(self._min_width, self._min_height)
#!/usr/bin/env python3
import pyglet
import glooey
import run_demos
from vecrec import Vector, Rect
window = pyglet.window.Window()
batch = pyglet.graphics.Batch()
rects = { #
'big': Rect.from_size(64*8, 64*6),
'small': Rect.from_size(64*4, 64*3),
}
images = { #
'green': pyglet.image.load('assets/64x64/green.png'),
'orange': pyglet.image.load('assets/64x64/orange.png'),
}
window_rect = Rect.from_pyglet_window(window)
for rect in rects.values():
rect.center = window_rect.center
artist = glooey.drawing.Tile(rects['big'],
images['green'],
vtile=True,
htile=True,
batch=batch)
@run_demos.on_space(window, batch)
def get_min_bounding_rect(self):
return Rect.from_size(self._min_width, self._min_height)
#!/usr/bin/env python3
import pyglet
import glooey
import run_demos
from vecrec import Rect
from pyglet.image import load
window = pyglet.window.Window()
batch = pyglet.graphics.Batch()
rect = Rect.from_size(64*8, 64*6)
rect.center = Rect.from_pyglet_window(window).center
bg = glooey.drawing.Background(rect=rect, batch=batch)
@run_demos.on_space(window, batch)
def test_background():
# Make sure colors can be set, updated, and removed.
bg.set_appearance(color='green')
yield "Show a solid green background."
bg.set_appearance(color='orange')
yield "Change to a solid orange background."
# Make sure outlines can be set, updated, and removed.
bg.set_appearance(outline='green')
yield "Show a solid green outline."
bg.set_appearance(outline='orange')
yield "Change to a solid orange outline."
# Make sure non-tiled images can be set, updated, and removed.
def set_appearance(self,
*,
color=None,
outline=None,
image=None,
center=None,
top=None,
bottom=None,
left=None,
right=None,
top_left=None,
top_right=None,
bottom_left=None,
bottom_right=None,
vtile='auto',
htile='auto'):
if image and center:
raise UsageError("""\
specifying both 'image' and 'center' is ambiguous.
Both of these options specify an image that should go in the middle of the
frame. The only difference is that, if 'htile' or 'vtile' are set to 'auto'
(the default value), 'center' enables tiling and 'image' doesn't.""")
# Decide whether the background should tile in either dimension.
auto_vtile = False
auto_htile = False
if top or bottom:
auto_vtile = True
if left or right:
auto_htile = True
if center and not (top or left or bottom or right):
auto_vtile = True
auto_htile = True
self._vtile = auto_vtile if vtile == 'auto' else vtile
self._htile = auto_htile if htile == 'auto' else htile
# Store the images in a grid-like data structure.
self._color = color
self._outline = outline
self._tile_images = {
ij: img
for ij, img in {
(0, 0): top_left,
(0, 1): top,
(0, 2): top_right,
(1, 0): left,
(1, 1): center or image,
(1, 2): right,
(2, 0): bottom_left,
(2, 1): bottom,
(2, 2): bottom_right,
}.items() if img is not None
}
self._grid.min_cell_rects = {
ij: Rect.from_size(img.width, img.height)
for ij, img in self._tile_images.items()
}
self._update_tiles()
#!/usr/bin/env python3
import pyglet
import glooey
import run_demos
from vecrec import Rect
from pyglet.image import load
window = pyglet.window.Window()
batch = pyglet.graphics.Batch()
rect = Rect.from_size(64 * 8, 64 * 6)
rect.center = Rect.from_pyglet_window(window).center
bg = glooey.drawing.Background(rect=rect, batch=batch)
@run_demos.on_space(window, batch)
def test_background():
# Make sure colors can be set, updated, and removed.
bg.set_appearance(color='green')
yield "Show a solid green background."
bg.set_appearance(color='orange')
yield "Change to a solid orange background."
# Make sure outlines can be set, updated, and removed.
bg.set_appearance(outline='green')
yield "Show a solid green outline."
bg.set_appearance(outline='orange')
yield "Change to a solid orange outline."