def __init__(self, stage, elements):
self.stage = stage
self.layer = Layer()
self.elements_layer = Layer()
from yaml import load
data = load(file('data/common/backpack.yaml'))
self.elements = elements
self.close_button = stage.create_button(data["close"], self)[0]
self.next_button = stage.create_button(data["next"], self)[0]
self.previous_button = stage.create_button(data["previous"], self)[0]
self.description_text = stage.create_text(data["description"])[0]
self.element_count_text = stage.create_text_count(
data["element_count"], len(elements))[0]
self.previous_button.set_visible(False)
self.current_page = 0
self.create_elements(data, elements)
if len(elements) <= self.ITEMS_PER_PAGE:
self.next_button.set_visible(False)
self.set_elements()
self.other = stage.create_items_from_yaml(data["other"])
for other in self.other:
self.layer.add(other)
self.layer.add(self.close_button)
self.layer.add(self.next_button)
self.layer.add(self.previous_button)
self.layer.add(self.description_text)
self.layer.add(self.element_count_text)
self.current_items = []
def __init__(self, stage, tests):
self.layer = Layer()
self.stage = stage
self.tests = tests
data = DictClass(load(file('data/common/tests_viewer.yaml')))
layers = [test.get_layer() for test in tests]
self.paginator = Paginator(self.stage, layers,
data.get("pagination", None))
for item in self.stage.create_items_from_yaml(data.other, self):
self.layer.add(item)
def create_items(self, data):
items = DictClass()
layer = Layer()
self.stage._items_manager = self
for i in data:
item = items[i.name] = self.stage.create_item(i)[0]
item.data = i
layer.add(item)
self.stage._items_manager = None
items["layer"] = layer
return items
def __load_items(self, text, data, top, height):
self.items = []
def create_text(stage, next, text, top, height):
text_item = stage.create_text(data.text)[0]
text_item.break_text_into(next)
text_item.set_text(text)
text_item.set_top(top)
text_item.set_dimensions(data.text.width, height)
text_item.break_text_into(None)
return text_item
# Usamos una clase que tiene el metodo set_text para saber si hay que dividir el texto
class Next:
def __init__(self):
self.text = None
def set_text(self, text):
self.text = text
next = Next()
layer = Layer()
layer.add(create_text(self.stage, next, text, top, height))
self.items.append(layer)
while next.text:
layer = Layer()
layer.add(create_text(self.stage, next, next.text, top, height))
self.items.append(layer)
def view_post_web_cb(self, result):
if result.error:
self.error_try_again_later()
return
data = DictClass(result.data)
self.layers.view_post.title.set_text(self.title)
self.layers.view_post.author.set_text(data.author_name + ":")
# Usamos una clase que tiene el metodo set_text para saber si hay que dividir el texto
items = []
next = Next()
layer = Layer()
def create_text(stage, next, text, data):
text_item = stage.create_text(data)[0]
set_text(next, text, text_item)
return text_item
layer.add(
create_text(self.stage, next, data.text,
self.layers.view_post.post.data))
items.append(layer)
while next.text:
layer = Layer()
layer.add(
create_text(self.stage, next, next.text,
self.layers.view_post.post.data))
items.append(layer)
paginator = Paginator(self.stage, items, self.data.pager_post)
self.change_layer([self.layers.view_post.layer] +
paginator.get_layers() + [self.layers.logged.layer])
def create_layers(self, data):
class ExtraLayers:
pass
layers = ExtraLayers()
layer_list = []
for layer in data:
new_layer = Layer()
layer_list.append(new_layer)
if "name" in layer:
setattr(layers, layer["name"], new_layer)
items = self.create_items_from_yaml(layer["items"])
if items:
for item in items:
new_layer.add(item)
return layers, layer_list
class TestsViewer():
def __init__(self, stage, tests):
self.layer = Layer()
self.stage = stage
self.tests = tests
data = DictClass(load(file('data/common/tests_viewer.yaml')))
layers = [test.get_layer() for test in tests]
self.paginator = Paginator(self.stage, layers,
data.get("pagination", None))
for item in self.stage.create_items_from_yaml(data.other, self):
self.layer.add(item)
def handle_confirm(self, item, args):
failed = 0
for test in self.tests:
if not test.check():
failed += 1
if failed:
fail_dialog = Fail(self.stage, failed)
fail_dialog.start()
else:
self.stop()
win = Win(self.stage)
win.start()
def handle_close(self, item, args):
self.stop()
def exit(self):
self.paginator.exit()
self.paginator = None
self.stage = None
self.layer.exit()
self.layer = None
for test in self.tests:
test.exit()
self.tests = None
def stop(self):
for layer in self.paginator.get_layers():
self.stage.remove_layer(layer)
self.stage.close_dialog(self.layer)
def start(self):
self.stage.show_dialog(self.layer, None)
for layer in self.paginator.get_layers():
self.stage.add_layer(layer)
def __init__(self, stage, on_no=None):
self.stage = stage
layer = self.layer = Layer()
data = load(file('data/common/quit_dialog.yaml'))
items = stage.create_items_from_yaml(data['items'], self)
self.on_no = on_no
for item in items:
layer.add(item)
def __init__(self, stage, title, text):
self.layer = Layer()
self.stage = stage
data = DictClass(load(file('data/common/content_viewer.yaml')))
title_item = self.title_text = stage.create_text(data.title)[0]
title_item.set_top(data.container.top)
self.title_text.set_text(title)
text_top = title_item.get_top() + title_item.get_height() + 10
text_height = data.container.height - (text_top - data.container.top)
self.close = stage.create_button(data.close, self)[0]
self.__load_items(text, data, text_top, text_height)
self.paginator = Paginator(self.stage, self.items,
data.get("pagination", None))
for item in self.stage.create_items_from_yaml(data.other):
self.layer.add(item)
self.layer.add(self.title_text)
self.layer.add(self.close)
def show_items(self, items):
if items:
if hasattr(self, "actual_layer") and self.actual_layer:
self.actual_layer.exit()
self.actual_layer = Layer()
layer = self.actual_layer
for item in items:
layer.add(item)
self.add_layer(layer)
def __init__(self, stage, on_ok=None):
self.stage = stage
layer = self.layer = Layer()
data = self.get_data()
items = stage.create_items_from_yaml(data['items'], self)
self.on_ok = on_ok
self.items = DictClass()
for item in items:
layer.add(item)
self.message = stage.create_item(data["message"])[0]
layer.add(self.message)
def __init__(self, stage):
self.layer = Layer()
self.stage = stage
data = DictClass(load(file('data/common/games_viewer.yaml')))
for item in stage.create_items_from_yaml(data.other):
self.layer.add(item)
self.close = stage.create_button(data.close, self)[0]
self.layer.add(self.close)
quantity = stage.game.datastore.datamodel.unlocked_level - 1
if quantity == 1:
data.header['text'] = data.header.singular.pre + str(
quantity) + data.header.singular.pos
else:
data.header['text'] = data.header.plural.pre + str(
quantity) + data.header.plural.pos
self.header = stage.create_text(data.header)[0]
self.layer.add(self.header)
self.footer = stage.create_text(data.footer)[0]
for data_game in data.games:
Game(stage, self.layer, data_game, self.footer)
class Content():
def __init__(self, stage, title, text):
self.layer = Layer()
self.stage = stage
data = DictClass(load(file('data/common/content_viewer.yaml')))
title_item = self.title_text = stage.create_text(data.title)[0]
title_item.set_top(data.container.top)
self.title_text.set_text(title)
text_top = title_item.get_top() + title_item.get_height() + 10
text_height = data.container.height - (text_top - data.container.top)
self.close = stage.create_button(data.close, self)[0]
self.__load_items(text, data, text_top, text_height)
self.paginator = Paginator(self.stage, self.items,
data.get("pagination", None))
for item in self.stage.create_items_from_yaml(data.other):
self.layer.add(item)
self.layer.add(self.title_text)
self.layer.add(self.close)
def __load_items(self, text, data, top, height):
self.items = []
def create_text(stage, next, text, top, height):
text_item = stage.create_text(data.text)[0]
text_item.break_text_into(next)
text_item.set_text(text)
text_item.set_top(top)
text_item.set_dimensions(data.text.width, height)
text_item.break_text_into(None)
return text_item
# Usamos una clase que tiene el metodo set_text para saber si hay que dividir el texto
class Next:
def __init__(self):
self.text = None
def set_text(self, text):
self.text = text
next = Next()
layer = Layer()
layer.add(create_text(self.stage, next, text, top, height))
self.items.append(layer)
while next.text:
layer = Layer()
layer.add(create_text(self.stage, next, next.text, top, height))
self.items.append(layer)
def handle_close(self, item, args):
self.stop()
def stop(self):
for layer in self.paginator.get_layers():
self.stage.remove_layer(layer)
self.stage.close_dialog(self.layer)
def start(self):
self.stage.show_dialog(self.layer, None)
for layer in self.paginator.get_layers():
self.stage.add_layer(layer)
def prepare(self):
data = DictClass(load(file('data/map/common.yaml')))
self.gui = Layer()
for item in self.create_items_from_yaml(data.gui):
self.gui.add(item)
self.create_selected_map_character(data.character)
self.load_quadrant()
self.tests_counter = self.create_text(data.counters.tests)[0]
self.backpack_counter = self.create_text(data.counters.backpack)[0]
self.games_counter = self.create_text(data.counters.games)[0]
self.gui.add(self.tests_counter)
self.gui.add(self.backpack_counter)
self.gui.add(self.games_counter)
self.backpack_counter.set_text(
str(
len(self.game.datastore.datamodel.backpack[
self.game.datastore.datamodel.level - 1])))
self.tests_counter.set_text(
str(
len(self.game.datastore.levels[
self.game.datastore.datamodel.level].tests)))
self.games_counter.set_text(
str(self.game.datastore.datamodel.unlocked_level - 1))
def __init__(self, stage):
self.stage = stage
layer = self.layer = Layer()
data = DictClass(load(file('data/common/next_level.yaml')))
items = stage.create_items_from_yaml(data.other, self)
for item in items:
layer.add(item)
text = stage.create_text(data.text)[0]
text.set_text(
data.text.texts[self.stage.game.datastore.datamodel.level])
layer.add(text)
# Load the sound
item_found_sound = assets.load_sound('DGI_item_found.ogg')
item_found_sound.play()
def __init__(self, stage):
global DEFAULT_NAME, DEFAULT_ROOM
self.go_to_last = False
self.dialog = None
self.paginator = None
self.background = Layer()
self.foreground = Layer()
self.focus_group = FocusGroup()
self.stage = stage
self.current_callback = None
self.current_id = None
data = self.data = DictClass(load(file('data/common/activity.yaml')))
self.clock_image = ItemImage(0, 0, assets.load_image(data.clock.src))
layers = self.layers = DictClass()
for k, i in data.layers.items():
layers[k] = self.create_items(i)
self.layers.main.name_input.set_focus_group(self.focus_group)
self.layers.main.name_input.set_on_enter(self.handle_next)
self.layers.main.name_input.set_text(DEFAULT_NAME)
self.layers.main.room_input.set_focus_group(self.focus_group)
self.layers.main.room_input.set_on_enter(self.handle_next)
self.layers.main.room_input.set_text(DEFAULT_ROOM)
self.current_layers = [layers.main.layer]
text_box = self.layers.post.text_box = self.create_text_box(
data.text_box)
self.layers.post.layer.add(text_box)
for item in self.stage.create_items_from_yaml(data["background"],
self):
self.background.add(item)
for item in self.stage.create_items_from_yaml(data["foreground"],
self):
self.foreground.add(item)
self.stage.start_timer('msgclock', 15000, self.update_messages_tick)
def __init__(self, stage, amount):
self.stage = stage
layer = self.layer = Layer()
self.amount = amount
data = DictClass(load(file('data/common/fail_tests.yaml')))
text = stage.create_text(data.text)[0]
if amount == 1:
text.set_text(data.text.singular)
else:
text.set_text(data.text.plural % dict(amount=amount))
items = stage.create_items_from_yaml(data.other, self)
for item in items:
layer.add(item)
layer.add(text)
# Load the sound
wrong_sound = assets.load_sound('DGI_wrong.ogg')
wrong_sound.play()
def __init__(self, stage, title, description, data):
self.stage = stage
layer = self.layer = Layer()
if title:
title_item = stage.create_text(data.title)[0]
title.set_top(data.top_container.top)
title_item.set_text(title)
layer.add(title_item)
else:
title_item = Item(0, data.top_container.top, 0, 0)
if description:
description_item = self.description = stage.create_text(
data.description)[0]
extra = 0
if title:
extra = data.top_container.after_title
description_item.set_top(title_item.get_top() +
title_item.get_height() + extra)
description_item.set_text(description)
layer.add(description_item)
else:
self.description = Item(
0,
title_item.get_top() + title_item.get_height(), 0, 0)
class Intro:
def __init__(self, stage, data, next_cb):
self.next_cb = next_cb
self.layer = Layer()
self.stage = stage
self.layer.add(stage.create_image(data.intro)[0])
self.layer.add(stage.create_button(data.next, self)[0])
def stop(self):
self.stage.close_dialog(self.layer)
def start(self):
self.stage.show_dialog(self.layer, None)
def handle_next(self, *args, **kwargs):
self.stop()
self.next_cb()
self.next_cb = None
self.layer.exit()
self.stage = None
def __init__(self, stage, items, optional_data=None):
self.layer = Layer()
self.items_layer = Layer()
self.items = items
self.stage = stage
from yaml import load
data = load(file('data/common/pagination.yaml'))
if optional_data is not None:
data.update(optional_data)
self.current = 1
if len(self.items):
self.current_layer = self.items[0]
else:
self.current_layer = Layer()
self.min = 1
self.max = len(self.items)
self.count = len(self.items)
for item in items:
item.set_visible(False)
self.previous = stage.create_button(data["previous"], self)[0]
self.next = stage.create_button(data["next"], self)[0]
self.last = None
if "last" in data:
self.last = stage.create_button(data["last"], self)[0]
if "page_count" in data and data["page_count"]:
self.page_count_text = stage.create_text(data["page_count"])[0]
self.page_count_base_text = data["page_count"]["text"]
else:
self.page_count_text = None
self.update_page_count()
self.update_items()
self.update_buttons()
self.layer.add(self.previous)
self.layer.add(self.next)
if self.page_count_text:
self.layer.add(self.page_count_text)
if self.last:
self.layer.add(self.last)
class MemoryMinigame(GameStage):
GO_BACK_TIME = 3000
ONE_SECOND_INTERVAL = 1000
def __init__(self, game):
GameStage.__init__(self, game)
def initialize(self):
GameStage.initialize(self)
stream = file('data/fonts.yaml', 'r')
fonts = load(stream)
for font in fonts:
setattr(
self, font,
assets.load_font(fonts[font]['file_name'],
fonts[font]['size']))
self.data = DictClass(load(file('data/memory.yaml')))
self.game_over_layer = Layer()
image = assets.load_image(
self.data.game_over[self.game.datastore.datamodel.character].src)
item = ItemImage(self.data.game_over.left, self.data.game_over.top,
image)
self.game_over_layer.add(item)
self.main_layer = Layer()
self.top_layer = Layer()
self.time = self.data.time.max
self.timer = DictClass({})
image = assets.load_image(self.data.time.src)
self.timer['skin'] = ItemImage(self.data.time.left, self.data.time.top,
image)
self.timer['value'] = ItemText(self.data.time.left,
self.data.time.top,
self.font,
0,
format_time(self.time),
width=image.get_width(),
height=image.get_height(),
h_align=2,
v_align=2)
self.top_layer.add(self.timer.skin)
self.top_layer.add(self.timer.value)
self.score = 0
self.score_board = DictClass({})
image = assets.load_image(self.data.score.src)
self.score_board['skin'] = ItemImage(self.data.score.left,
self.data.score.top, image)
self.score_board['value'] = ItemText(self.data.score.left,
self.data.score.top,
self.font,
0,
str(self.score),
width=image.get_width(),
height=image.get_height(),
h_align=2,
v_align=2)
self.top_layer.add(self.score_board.skin)
self.top_layer.add(self.score_board.value)
self.deck = []
image_back = assets.load_image(self.data.board.card_back)
for k in range(0, len(self.data.board.cards)):
image = assets.load_image(self.data.board.cards[k])
self.deck.append([
Card(self, k, image, image_back),
Card(self, k, image, image_back)
])
self.range = self.data.start
self.cards = []
self.deal()
# Load the sound
self.card_flip_sound = assets.load_sound('DGI_card_flip.ogg')
self.item_found_sound = assets.load_sound('DGI_item_found.ogg')
self.wrong_sound = assets.load_sound('DGI_wrong.ogg')
self.lose_bell_sound = assets.load_sound('DGI_lose_bell.ogg')
self.lose_music_sound = assets.load_sound('DGI_lose_music.ogg')
def deal(self):
self.first = None
self.second = None
for k in range(0, self.range):
self.cards.append(self.deck[k][0])
self.cards.append(self.deck[k][1])
random.shuffle(self.cards)
d = ceil(sqrt(2 * self.range))
for i, card in zip(range(2 * self.range), self.cards):
card.item.set_left(self.data.board.left + card.item.get_width() *
(i % d))
card.item.set_top(self.data.board.top +
card.item.get_height() * int(i / d))
self.main_layer.add(card.item)
def select(self, card):
self.card_flip_sound.play()
if not self.second:
if self.first:
if self.first != card:
self.second = card
card.select()
self.start_timer(1, 500, self.check_match)
else:
self.first = card
card.select()
def check_match(self, key, data):
self.stop_timer(1)
if self.first.key == self.second.key:
self.item_found_sound.play()
self.cards.remove(self.first)
self.cards.remove(self.second)
self.main_layer.remove(self.first.item)
self.main_layer.remove(self.second.item)
self.score += self.data.score.points
self.score_board.value.set_text(str(self.score))
else:
self.wrong_sound.play()
self.first.unselect()
self.second.unselect()
self.first = self.second = None
if len(self.cards) == 2:
self.first = self.cards[0]
self.second = self.cards[1]
self.first.select()
self.second.select()
self.start_timer(1, 500, self.check_match)
elif not self.cards:
if self.range + self.data.step <= len(self.deck):
self.range += self.data.step
self.deal()
def prepare(self):
self.show_board()
dialog = Intro(self, self.data.intro, self.start_game)
dialog.start()
def start_game(self):
self.start_timer(0, self.ONE_SECOND_INTERVAL, self.update_time)
def update_time(self, key, data):
self.time -= 1
self.timer.value.set_text(format_time(self.time))
if not self.time:
self.game_over()
def show_board(self):
self.add_layer(self.main_layer)
self.add_layer(self.top_layer)
def game_over(self):
self.lose_bell_sound.play()
self.lose_music_sound.play()
self.stop_timer(0)
for card in self.cards:
card.item.remove_event_handler(ItemEvent.CLICK, card.handle_click)
self.add_layer(self.game_over_layer)
self.start_timer("go_back_timer", self.GO_BACK_TIME, self.go_back)
def exit(self, other_item):
GameStage.exit(self, other_item)
for card1, card2 in self.deck:
card1.exit()
card2.exit()
self.deck = None
self.cards = None
def go_back(self, *args, **kwargs):
from game.stages.map import Map
self.game.set_stage(Map(self.game))
def load_items(self, data, items):
layer = Layer()
left = self.data.post_box.left
top = self.data.post_box.top
cant_items = 0
i = 0
for item in data:
if cant_items >= self.data.post_box.items_per_page:
items.append(layer)
layer = Layer()
top = self.data.post_box.top
cant_items = 0
self.stage._items_manager = self
text_item = self.stage.create_item(self.data.post_item)[0]
text_item.data_item = item
text_item.set_top(top)
text_item.set_left(left)
def set_post_text(text_item, text):
next = Next()
set_text(next, text, text_item)
if next.text:
new_dict = dict(self.data.post_item)
new_dict["width"] = -1
ellipsis = self.stage.create_item(new_dict)[0]
ellipsis.set_text("...")
ellipsis.set_top(text_item.get_top())
ellipsis.set_left(text_item.get_left() +
text_item.lines[0])
return ellipsis
return None
def on_enter(text_item, *args, **kwargs):
item = text_item.data_item
text_item.set_text("&#c200,0,0!%s&#c!: %s" %
(item.author_name, item.text))
def on_leave(text_item, *args, **kwargs):
item = text_item.data_item
text_item.set_text("&#c58,129,188!%s&#c!: %s" %
(item.author_name, item.text))
text_item.add_event_handler(ItemEvent.MOUSE_ENTER, on_enter)
text_item.add_event_handler(ItemEvent.MOUSE_LEAVE, on_leave)
text_item.add_event_handler(ItemEvent.CLICK,
self.handle_post_click)
text_item.post_id = item.id
text_item.post_index = i
self.stage._items_manager = None
other_item = set_post_text(
text_item,
"&#c58,129,188!%s&#c!: %s" % (item.author_name, item.text))
if other_item:
layer.add(other_item)
layer.add(text_item)
top += self.data.post_box.inter_line
cant_items += 1
i += 1
if len(layer.items) > 0:
items.append(layer)
class Activity():
def __init__(self, stage):
global DEFAULT_NAME, DEFAULT_ROOM
self.go_to_last = False
self.dialog = None
self.paginator = None
self.background = Layer()
self.foreground = Layer()
self.focus_group = FocusGroup()
self.stage = stage
self.current_callback = None
self.current_id = None
data = self.data = DictClass(load(file('data/common/activity.yaml')))
self.clock_image = ItemImage(0, 0, assets.load_image(data.clock.src))
layers = self.layers = DictClass()
for k, i in data.layers.items():
layers[k] = self.create_items(i)
self.layers.main.name_input.set_focus_group(self.focus_group)
self.layers.main.name_input.set_on_enter(self.handle_next)
self.layers.main.name_input.set_text(DEFAULT_NAME)
self.layers.main.room_input.set_focus_group(self.focus_group)
self.layers.main.room_input.set_on_enter(self.handle_next)
self.layers.main.room_input.set_text(DEFAULT_ROOM)
self.current_layers = [layers.main.layer]
text_box = self.layers.post.text_box = self.create_text_box(
data.text_box)
self.layers.post.layer.add(text_box)
for item in self.stage.create_items_from_yaml(data["background"],
self):
self.background.add(item)
for item in self.stage.create_items_from_yaml(data["foreground"],
self):
self.foreground.add(item)
self.stage.start_timer('msgclock', 15000, self.update_messages_tick)
def create_items(self, data):
items = DictClass()
layer = Layer()
self.stage._items_manager = self
for i in data:
item = items[i.name] = self.stage.create_item(i)[0]
item.data = i
layer.add(item)
self.stage._items_manager = None
items["layer"] = layer
return items
def change_layer(self, new_layers):
for layer in self.current_layers:
self.stage.remove_layer(layer)
self.stage.remove_layer(self.foreground)
self.current_layers = new_layers
for layer in self.current_layers:
self.stage.add_layer(layer)
self.stage.add_layer(self.foreground)
def handle_back(self, *args, **kwargs):
if self.current_callback:
return
if self.layers.room.layer in self.current_layers:
self.change_layer([self.layers.main.layer])
if self.layers.post.layer in self.current_layers \
or self.layers.view_post.layer in self.current_layers:
self.change_layer([self.layers.room.layer] +
self.paginator.get_layers() +
[self.layers.logged.layer])
def handle_refresh(self, item, args):
self.refresh_messages()
def update_messages_tick(self, key, data):
if self.paginator != None:
self.refresh_messages(False)
def refresh_messages(self, show_clock=True):
callback = get_web_cb(self, self.refresh_cb, show_clock)
web.query(WEB_DIR_ACT % self.layers.main.room_input.get_text(),
callback=callback)
@web_callback
def refresh_cb(self, result):
if result.error:
return
data = [DictClass(item) for item in result.data["posts"]]
# Check if the data change, only update the screen if changed
if data != self.posts:
self.posts = data
items = []
self.load_items(self.posts, items)
current = self.paginator.get_current()
self.paginator = Paginator(self.stage, items, self.data.pager)
self.paginator.go_to(current)
self.change_layer([self.layers.room.layer] +
self.paginator.get_layers() +
[self.layers.logged.layer])
def handle_post(self, *args, **kwargs):
if self.current_callback:
return
web.send_data(WEB_DIR_NEW_POST %
self.layers.main.room_input.get_text(), {
"post[author_name]":
unicode(self.layers.main.name_input.get_text(),
"latin-1").encode("utf-8"),
"post[machine_id]":
"id",
"post[text]":
unicode(self.layers.post.text_box.get_text(),
"latin-1").encode("utf-8")
},
callback=get_web_cb(self, self.post_web_cb))
@web_callback
def post_web_cb(self, result):
if result.error:
self.error_try_again_later()
return
self.layers.post.text_box.text("")
self.go_to_last = True
self.go_to_room()
def go_to_room(self):
if self.current_callback:
return
global DEFAULT_NAME, DEFAULT_ROOM
DEFAULT_NAME = self.layers.main.name_input.get_text()
DEFAULT_ROOM = self.layers.main.room_input.get_text()
web.query(WEB_DIR_ACT % self.layers.main.room_input.get_text(),
callback=get_web_cb(self, self.go_to_room_web_cb))
@web_callback
def go_to_room_web_cb(self, result):
if result.error:
if result.error == web.Error.SERVER and result.code == 404:
self.the_room_doesnt_exist()
else:
self.error_try_again_later()
return
data = DictClass(result.data)
self.title = data.title
self.layers.room.title.set_text(self.title)
self.layers.room.description.set_text(data.description)
self.layers.room.code.set_text(self.layers.room.code.data.text %
self.layers.main.room_input.get_text())
self.layers.logged.login_name.set_text(
self.layers.main.name_input.get_text())
data = [DictClass(item) for item in data.posts]
self.posts = data
items = []
self.load_items(data, items)
self.paginator = Paginator(self.stage, items, self.data.pager)
if self.go_to_last:
self.go_to_last = False
self.paginator.go_to_last()
self.change_layer([self.layers.room.layer] +
self.paginator.get_layers() +
[self.layers.logged.layer])
def load_items(self, data, items):
layer = Layer()
left = self.data.post_box.left
top = self.data.post_box.top
cant_items = 0
i = 0
for item in data:
if cant_items >= self.data.post_box.items_per_page:
items.append(layer)
layer = Layer()
top = self.data.post_box.top
cant_items = 0
self.stage._items_manager = self
text_item = self.stage.create_item(self.data.post_item)[0]
text_item.data_item = item
text_item.set_top(top)
text_item.set_left(left)
def set_post_text(text_item, text):
next = Next()
set_text(next, text, text_item)
if next.text:
new_dict = dict(self.data.post_item)
new_dict["width"] = -1
ellipsis = self.stage.create_item(new_dict)[0]
ellipsis.set_text("...")
ellipsis.set_top(text_item.get_top())
ellipsis.set_left(text_item.get_left() +
text_item.lines[0])
return ellipsis
return None
def on_enter(text_item, *args, **kwargs):
item = text_item.data_item
text_item.set_text("&#c200,0,0!%s&#c!: %s" %
(item.author_name, item.text))
def on_leave(text_item, *args, **kwargs):
item = text_item.data_item
text_item.set_text("&#c58,129,188!%s&#c!: %s" %
(item.author_name, item.text))
text_item.add_event_handler(ItemEvent.MOUSE_ENTER, on_enter)
text_item.add_event_handler(ItemEvent.MOUSE_LEAVE, on_leave)
text_item.add_event_handler(ItemEvent.CLICK,
self.handle_post_click)
text_item.post_id = item.id
text_item.post_index = i
self.stage._items_manager = None
other_item = set_post_text(
text_item,
"&#c58,129,188!%s&#c!: %s" % (item.author_name, item.text))
if other_item:
layer.add(other_item)
layer.add(text_item)
top += self.data.post_box.inter_line
cant_items += 1
i += 1
if len(layer.items) > 0:
items.append(layer)
def handle_next(self, *args, **kwargs):
if self.dialog:
return
self.paginator = None
self.layers.main.name_input.set_text(
self.layers.main.name_input.get_text().strip())
self.layers.main.room_input.set_text(
self.layers.main.room_input.get_text().strip())
if not self.layers.main.name_input.get_text(
) or not self.layers.main.room_input.get_text():
self.fill_inputs()
return
self.go_to_room()
def handle_next_post(self, *args, **kwargs):
self.current_post += 1
self.update_post_buttons()
web.query(WEB_DIR_POST % (self.layers.main.room_input.get_text(),
self.posts[self.current_post].id),
callback=get_web_cb(self, self.view_post_web_cb))
def handle_previous_post(self, *args, **kwargs):
self.current_post -= 1
self.update_post_buttons()
web.query(WEB_DIR_POST % (self.layers.main.room_input.get_text(),
self.posts[self.current_post].id),
callback=get_web_cb(self, self.view_post_web_cb))
def update_post_buttons(self):
view_post = self.layers.view_post
if self.current_post > 0:
view_post.previous_post.set_visible(True)
else:
view_post.previous_post.set_visible(False)
if self.current_post < len(self.posts) - 1:
view_post.next_post.set_visible(True)
else:
view_post.next_post.set_visible(False)
view_post.post_count.set_text(self.data.pager.page_count.text % {
"page": self.current_post + 1,
"total": len(self.posts)
})
def handle_post_click(self, item, *args, **kwargs):
if self.current_callback:
return
self.current_post = item.post_index
self.update_post_buttons()
web.query(WEB_DIR_POST %
(self.layers.main.room_input.get_text(), item.post_id),
callback=get_web_cb(self, self.view_post_web_cb))
@web_callback
def post_message_cb(self, result):
if result.error:
self.error_try_again_later()
self.change_layer([self.layers.room.layer] +
self.paginator.get_layers() +
[self.layers.logged.layer])
return
self.go_to_room()
@web_callback
def view_post_web_cb(self, result):
if result.error:
self.error_try_again_later()
return
data = DictClass(result.data)
self.layers.view_post.title.set_text(self.title)
self.layers.view_post.author.set_text(data.author_name + ":")
# Usamos una clase que tiene el metodo set_text para saber si hay que dividir el texto
items = []
next = Next()
layer = Layer()
def create_text(stage, next, text, data):
text_item = stage.create_text(data)[0]
set_text(next, text, text_item)
return text_item
layer.add(
create_text(self.stage, next, data.text,
self.layers.view_post.post.data))
items.append(layer)
while next.text:
layer = Layer()
layer.add(
create_text(self.stage, next, next.text,
self.layers.view_post.post.data))
items.append(layer)
paginator = Paginator(self.stage, items, self.data.pager_post)
self.change_layer([self.layers.view_post.layer] +
paginator.get_layers() + [self.layers.logged.layer])
def handle_new_post(self, *args, **kwargs):
self.layers.post.title.set_text(self.title)
self.change_layer([self.layers.post.layer] +
[self.layers.logged.layer])
self.layers.post.text_box.begin()
pass
def handle_close(self, item, args):
self.current_id = None
self.stage.reset_mouse_cursor()
self.stop()
def create_text_box(self, data):
return TextBox(data.left, data.top, data.width, data.height,
getattr(self.stage, data.font), eval(data.color))
def stop(self):
for layer in self.current_layers:
self.stage.remove_layer(layer)
self.stage.remove_layer(self.foreground)
self.stage.close_dialog(self.background)
self.stage.stop_timer('msgclock')
def start(self):
self.stage.show_dialog(self.background, None)
for layer in self.current_layers:
self.stage.add_layer(layer)
self.stage.add_layer(self.foreground)
self.layers.main.room_input.set_editable(True)
self.layers.main.room_input.set_edit_on_click(
self.layers.main.room_input)
self.layers.main.name_input.set_editable(True)
self.layers.main.name_input.set_edit_on_click(
self.layers.main.name_input)
self.layers.main.name_input.begin_edit()
def on_exit_dialog(self):
self.dialog = None
def error_try_again_later(self):
self.dialog = dialog = ErrorDialog(self.stage, self.on_exit_dialog)
dialog.set_message(self.data.messages.unknown)
dialog.start()
def the_room_doesnt_exist(self):
self.dialog = dialog = ErrorDialog(self.stage, self.on_exit_dialog)
dialog.set_message(self.data.messages.no_activity)
dialog.start()
def fill_inputs(self):
self.dialog = dialog = ErrorDialog(self.stage, self.on_exit_dialog)
dialog.set_message(self.data.messages.fill_inputs)
dialog.start()
def initialize(self):
GameStage.initialize(self)
stream = file('data/fonts.yaml', 'r')
fonts = load(stream)
for font in fonts:
setattr(
self, font,
assets.load_font(fonts[font]['file_name'],
fonts[font]['size']))
self.data = DictClass(load(file('data/asteroids.yaml')))
self.game_over_layer = Layer()
image = assets.load_image(
self.data.game_over[self.game.datastore.datamodel.character].src)
item = ItemImage(self.data.game_over.left, self.data.game_over.top,
image)
self.game_over_layer.add(item)
self.main_layer = Layer()
self.top_layer = Layer()
self.time = self.data.time.max
self.timer = DictClass({})
image = assets.load_image(self.data.time.src)
self.timer['skin'] = ItemImage(self.data.time.left, self.data.time.top,
image)
self.timer['value'] = ItemText(self.data.time.left,
self.data.time.top,
self.font,
0,
format_time(self.time),
width=image.get_width(),
height=image.get_height(),
h_align=2,
v_align=2)
self.top_layer.add(self.timer.skin)
self.top_layer.add(self.timer.value)
self.score = 0
self.score_board = DictClass({})
image = assets.load_image(self.data.score.src)
self.score_board['skin'] = ItemImage(self.data.score.left,
self.data.score.top, image)
self.score_board['value'] = ItemText(self.data.score.left,
self.data.score.top,
self.font,
0,
str(self.score),
width=image.get_width(),
height=image.get_height(),
h_align=2,
v_align=2)
self.top_layer.add(self.score_board.skin)
self.top_layer.add(self.score_board.value)
self.level = self.data.start
self.asteroids = []
self.max_width = 0
self.max_height = 0
for a in self.data.asteroids:
item = assets.load_image(a)
if self.max_width < item.get_width():
self.max_width = item.get_width()
if self.max_height < item.get_height():
self.max_height = item.get_height()
self.max_col = int(SCREEN_WIDTH / self.max_width)
self.max_row = int(SCREEN_HEIGHT / self.max_height)
self.margin_left = (SCREEN_WIDTH % self.max_width) / 2
self.margin_top = (SCREEN_HEIGHT % self.max_height) / 2
# Load the sound
self.click_sound = assets.load_sound('DGI_Click.ogg')
self.item_found_sound = assets.load_sound('DGI_item_found.ogg')
self.wrong_sound = assets.load_sound('DGI_wrong.ogg')
self.lose_bell_sound = assets.load_sound('DGI_lose_bell.ogg')
self.lose_music_sound = assets.load_sound('DGI_lose_music.ogg')
def initialize(self):
GameStage.initialize(self)
stream = file('data/fonts.yaml', 'r')
fonts = load(stream)
for font in fonts:
setattr(
self, font,
assets.load_font(fonts[font]['file_name'],
fonts[font]['size']))
self.data = DictClass(load(file('data/memory.yaml')))
self.game_over_layer = Layer()
image = assets.load_image(
self.data.game_over[self.game.datastore.datamodel.character].src)
item = ItemImage(self.data.game_over.left, self.data.game_over.top,
image)
self.game_over_layer.add(item)
self.main_layer = Layer()
self.top_layer = Layer()
self.time = self.data.time.max
self.timer = DictClass({})
image = assets.load_image(self.data.time.src)
self.timer['skin'] = ItemImage(self.data.time.left, self.data.time.top,
image)
self.timer['value'] = ItemText(self.data.time.left,
self.data.time.top,
self.font,
0,
format_time(self.time),
width=image.get_width(),
height=image.get_height(),
h_align=2,
v_align=2)
self.top_layer.add(self.timer.skin)
self.top_layer.add(self.timer.value)
self.score = 0
self.score_board = DictClass({})
image = assets.load_image(self.data.score.src)
self.score_board['skin'] = ItemImage(self.data.score.left,
self.data.score.top, image)
self.score_board['value'] = ItemText(self.data.score.left,
self.data.score.top,
self.font,
0,
str(self.score),
width=image.get_width(),
height=image.get_height(),
h_align=2,
v_align=2)
self.top_layer.add(self.score_board.skin)
self.top_layer.add(self.score_board.value)
self.deck = []
image_back = assets.load_image(self.data.board.card_back)
for k in range(0, len(self.data.board.cards)):
image = assets.load_image(self.data.board.cards[k])
self.deck.append([
Card(self, k, image, image_back),
Card(self, k, image, image_back)
])
self.range = self.data.start
self.cards = []
self.deal()
# Load the sound
self.card_flip_sound = assets.load_sound('DGI_card_flip.ogg')
self.item_found_sound = assets.load_sound('DGI_item_found.ogg')
self.wrong_sound = assets.load_sound('DGI_wrong.ogg')
self.lose_bell_sound = assets.load_sound('DGI_lose_bell.ogg')
self.lose_music_sound = assets.load_sound('DGI_lose_music.ogg')
class AsteroidsMinigame(GameStage):
GO_BACK_TIME = 3000
ONE_SECOND_INTERVAL = 1000
MARGIN = 70
def __init__(self, game):
GameStage.__init__(self, game)
def initialize(self):
GameStage.initialize(self)
stream = file('data/fonts.yaml', 'r')
fonts = load(stream)
for font in fonts:
setattr(
self, font,
assets.load_font(fonts[font]['file_name'],
fonts[font]['size']))
self.data = DictClass(load(file('data/asteroids.yaml')))
self.game_over_layer = Layer()
image = assets.load_image(
self.data.game_over[self.game.datastore.datamodel.character].src)
item = ItemImage(self.data.game_over.left, self.data.game_over.top,
image)
self.game_over_layer.add(item)
self.main_layer = Layer()
self.top_layer = Layer()
self.time = self.data.time.max
self.timer = DictClass({})
image = assets.load_image(self.data.time.src)
self.timer['skin'] = ItemImage(self.data.time.left, self.data.time.top,
image)
self.timer['value'] = ItemText(self.data.time.left,
self.data.time.top,
self.font,
0,
format_time(self.time),
width=image.get_width(),
height=image.get_height(),
h_align=2,
v_align=2)
self.top_layer.add(self.timer.skin)
self.top_layer.add(self.timer.value)
self.score = 0
self.score_board = DictClass({})
image = assets.load_image(self.data.score.src)
self.score_board['skin'] = ItemImage(self.data.score.left,
self.data.score.top, image)
self.score_board['value'] = ItemText(self.data.score.left,
self.data.score.top,
self.font,
0,
str(self.score),
width=image.get_width(),
height=image.get_height(),
h_align=2,
v_align=2)
self.top_layer.add(self.score_board.skin)
self.top_layer.add(self.score_board.value)
self.level = self.data.start
self.asteroids = []
self.max_width = 0
self.max_height = 0
for a in self.data.asteroids:
item = assets.load_image(a)
if self.max_width < item.get_width():
self.max_width = item.get_width()
if self.max_height < item.get_height():
self.max_height = item.get_height()
self.max_col = int(SCREEN_WIDTH / self.max_width)
self.max_row = int(SCREEN_HEIGHT / self.max_height)
self.margin_left = (SCREEN_WIDTH % self.max_width) / 2
self.margin_top = (SCREEN_HEIGHT % self.max_height) / 2
# Load the sound
self.click_sound = assets.load_sound('DGI_Click.ogg')
self.item_found_sound = assets.load_sound('DGI_item_found.ogg')
self.wrong_sound = assets.load_sound('DGI_wrong.ogg')
self.lose_bell_sound = assets.load_sound('DGI_lose_bell.ogg')
self.lose_music_sound = assets.load_sound('DGI_lose_music.ogg')
def prepare(self):
self.show()
self.add_layer(self.main_layer)
self.add_layer(self.top_layer)
dialog = Intro(self, self.data.intro, self.start_game)
dialog.start()
def start_game(self):
self.start_timer(0, self.ONE_SECOND_INTERVAL, self.update_time)
def show(self):
if 'selector' in self.data.levels[self.level]:
selector = eval(self.data.levels[self.level].selector)
aux_seq = eval(self.data.levels[self.level][selector])
else:
aux_seq = eval(self.data.levels[self.level].range)
self.sequence = []
for value in range(0, self.data.levels[self.level].quantity):
value = random.choice(aux_seq)
aux_seq.remove(value)
self.sequence.append(value)
self.sequence = sorted(self.sequence)
self.sequence.reverse()
positions = range(0, self.max_col * self.max_row)
for value in self.sequence:
src = random.choice(self.data.asteroids)
asteroid = Asteroid(self, 0, 0, src, value)
position = random.choice(positions)
positions.remove(position)
i = int(position / self.max_col)
j = int(position % self.max_col)
left = self.margin_left + j * self.max_width + random.uniform(
0, self.max_width % asteroid.item.get_width())
top = self.margin_top + i * self.max_height + random.uniform(
0, self.max_height % asteroid.item.get_height())
asteroid.set_left(left)
asteroid.set_top(top)
self.asteroids.append(asteroid)
self.main_layer.add(asteroid.item)
self.main_layer.add(asteroid.text)
if self.level + self.data.step <= self.data.max:
self.level += self.data.step
def select(self, asteroid):
self.click_sound.play()
expected = self.sequence.pop()
if asteroid.value == expected:
self.item_found_sound.play()
self.score += self.data.score.points
self.score_board.value.set_text(str(self.score))
self.asteroids.remove(asteroid)
self.main_layer.remove(asteroid.item)
self.main_layer.remove(asteroid.text)
asteroid.exit()
else:
self.wrong_sound.play()
self.sequence.append(expected)
if not self.asteroids:
self.show()
def update_time(self, key, data):
self.time -= 1
self.timer.value.set_text(format_time(self.time))
if not self.time:
self.game_over()
def game_over(self):
self.lose_bell_sound.play()
self.lose_music_sound.play()
self.stop_timer(0)
for asteroid in self.asteroids:
asteroid.item.remove_event_handler(ItemEvent.CLICK,
asteroid.handle_click)
self.add_layer(self.game_over_layer)
self.start_timer("go_back_timer", self.GO_BACK_TIME, self.go_back)
def go_back(self, *args, **kwargs):
from game.stages.map import Map
self.game.set_stage(Map(self.game))
class BackPack:
ITEMS_PER_PAGE = 5
def __init__(self, stage, elements):
self.stage = stage
self.layer = Layer()
self.elements_layer = Layer()
from yaml import load
data = load(file('data/common/backpack.yaml'))
self.elements = elements
self.close_button = stage.create_button(data["close"], self)[0]
self.next_button = stage.create_button(data["next"], self)[0]
self.previous_button = stage.create_button(data["previous"], self)[0]
self.description_text = stage.create_text(data["description"])[0]
self.element_count_text = stage.create_text_count(
data["element_count"], len(elements))[0]
self.previous_button.set_visible(False)
self.current_page = 0
self.create_elements(data, elements)
if len(elements) <= self.ITEMS_PER_PAGE:
self.next_button.set_visible(False)
self.set_elements()
self.other = stage.create_items_from_yaml(data["other"])
for other in self.other:
self.layer.add(other)
self.layer.add(self.close_button)
self.layer.add(self.next_button)
self.layer.add(self.previous_button)
self.layer.add(self.description_text)
self.layer.add(self.element_count_text)
self.current_items = []
def create_elements(self, data, elements):
self.elements = []
start_top = data["elements_pos"]["top"]
inter = data["elements_pos"]["interspace"]
element_data = DictClass(load(file('data/common/books.yaml')))
current = 0
for page in xrange(0, len(elements) / self.ITEMS_PER_PAGE + 1):
start_left = 0
for element in elements[page * self.ITEMS_PER_PAGE:(page + 1) *
self.ITEMS_PER_PAGE]:
element_data[element.type]['action'] = 'click'
new = self.stage.create_button(element_data[element.type],
manager=self)[0]
new.set_top(start_top)
new.set_left(start_left)
new.add_event_handler(ItemEvent.MOUSE_ENTER,
self.handle_element_enter)
new.add_event_handler(ItemEvent.MOUSE_LEAVE,
self.handle_element_leave)
new.info = element
start_left += new.get_width() + inter
self.elements.append(new)
current += 1
start_left -= inter
new_left = (data["elements_pos"]["width"] -
start_left) / 2 + data["elements_pos"]["left"]
for element in self.elements[page *
self.ITEMS_PER_PAGE:(page + 1) *
self.ITEMS_PER_PAGE]:
element.set_left(element.get_left() + new_left)
def set_elements(self):
self.elements_layer.empty()
fromm = self.current_page * self.ITEMS_PER_PAGE
for element in self.elements[fromm:fromm + self.ITEMS_PER_PAGE]:
self.elements_layer.add(element)
def start(self):
self.stage.show_dialog(self.layer, None)
self.stage.add_layer(self.elements_layer)
def handle_close(self, item, args):
self.stage.remove_layer(self.elements_layer)
self.stage.close_dialog(self.layer)
self.layer.exit()
self.layer = None
self.close_button.exit()
self.next_button.exit()
self.previous_button.exit()
self.description_text.exit()
self.element_count_text.exit()
self.previous_button.exit()
for element in self.elements:
element.exit()
self.elements = None
self.elements_layer.exit()
self.elements_layer = None
def handle_next(self, item, args):
self.current_page += 1
if len(
self.elements
) - self.current_page * self.ITEMS_PER_PAGE <= self.ITEMS_PER_PAGE:
self.next_button.set_visible(False)
self.previous_button.set_visible(True)
self.set_elements()
def handle_previous(self, item, args):
self.current_page -= 1
if not self.current_page:
self.previous_button.set_visible(False)
if len(self.elements) > self.ITEMS_PER_PAGE:
self.next_button.set_visible(True)
self.set_elements()
def handle_element_enter(self, item, args):
self.description_text.set_text(item.info.title)
def handle_element_leave(self, item, args):
self.description_text.set_text("")
def handle_click(self, item, args):
paginate = Content(self.stage, item.info.title, item.info.text)
paginate.start()
def initialize(self):
GameStage.initialize(self)
stream = file('data/fonts.yaml', 'r')
fonts = load(stream)
for font in fonts:
setattr(
self, font,
assets.load_font(fonts[font]['file_name'],
fonts[font]['size']))
self.data = DictClass(load(file('data/invaders.yaml')))
self.good = self.data.start.good
self.velocity = self.data.start.velocity
self.interval = self.data.start.interval
self.game_over_layer = Layer()
image = assets.load_image(
self.data.bad[self.game.datastore.datamodel.character].src)
item = ItemImage(self.data.bad.left, self.data.bad.top, image)
self.game_over_layer.add(item)
image = assets.load_image(
self.data.game_over[self.game.datastore.datamodel.character].src)
item = ItemImage(self.data.game_over.left, self.data.game_over.top,
image)
self.game_over_layer.add(item)
image = assets.load_image(
self.data.good[self.game.datastore.datamodel.character].src)
self.good_indicator = ItemImage(self.data.good.left,
self.data.good.top, image)
self.text_indicators = []
self.main_layer = Layer()
self.top_layer = Layer()
self.score = 0
self.score_board = DictClass({})
image = assets.load_image(self.data.score.src)
self.score_board['skin'] = ItemImage(self.data.score.left,
self.data.score.top, image)
self.score_board['value'] = ItemText(self.data.score.left,
self.data.score.top,
self.font,
0,
str(self.score),
width=image.get_width(),
height=image.get_height(),
h_align=2,
v_align=2)
self.top_layer.add(self.score_board.skin)
self.top_layer.add(self.score_board.value)
data = DictClass(load(file('data/map/common.yaml')))
params = data.character[self.game.datastore.datamodel.character]
params['base'] = data.character.base[
self.game.datastore.datamodel.character].big
self.character_animation = Character(**params)
self.character = self.character_animation.item
self.character.set_left(
(SCREEN_WIDTH - self.character.get_width()) / 2)
self.character.set_top(SCREEN_HEIGHT - self.character.get_height())
left = self.character.get_left() + self.data.collision.left
top = self.character.get_top() + self.data.collision.top
width = self.character.get_width(
) - self.data.collision.left - self.data.collision.right
height = self.character.get_height(
) - self.data.collision.top - self.data.collision.bottom
if DEBUG:
self.debug_character = ItemRect(left,
top,
width,
height,
border=(255, 255, 255))
self.invaders = []
# Load the sound
self.item_found_sound = assets.load_sound('DGI_item_found.ogg')
self.lose_hit_sound = assets.load_sound('DGI_lose_hit.ogg')
self.lose_music_sound = assets.load_sound('DGI_lose_music.ogg')
def __init__(self, stage, data, next_cb):
self.next_cb = next_cb
self.layer = Layer()
self.stage = stage
self.layer.add(stage.create_image(data.intro)[0])
self.layer.add(stage.create_button(data.next, self)[0])
class Paginator():
def __init__(self, stage, items, optional_data=None):
self.layer = Layer()
self.items_layer = Layer()
self.items = items
self.stage = stage
from yaml import load
data = load(file('data/common/pagination.yaml'))
if optional_data is not None:
data.update(optional_data)
self.current = 1
if len(self.items):
self.current_layer = self.items[0]
else:
self.current_layer = Layer()
self.min = 1
self.max = len(self.items)
self.count = len(self.items)
for item in items:
item.set_visible(False)
self.previous = stage.create_button(data["previous"], self)[0]
self.next = stage.create_button(data["next"], self)[0]
self.last = None
if "last" in data:
self.last = stage.create_button(data["last"], self)[0]
if "page_count" in data and data["page_count"]:
self.page_count_text = stage.create_text(data["page_count"])[0]
self.page_count_base_text = data["page_count"]["text"]
else:
self.page_count_text = None
self.update_page_count()
self.update_items()
self.update_buttons()
self.layer.add(self.previous)
self.layer.add(self.next)
if self.page_count_text:
self.layer.add(self.page_count_text)
if self.last:
self.layer.add(self.last)
def exit(self):
self.layer.exit()
self.items_layer.exit()
for item in self.items:
item.exit()
self.items = None
self.stage = None
self.previous.exit()
self.previous = None
self.next.exit()
self.next = None
if self.last:
self.last.exit()
self.last = None
if self.page_count_text:
self.page_count_text.exit()
self.page_count_text = None
def update_page_count(self):
if self.page_count_text:
self.page_count_text.set_text(self.page_count_base_text % {
"page": self.current,
"total": self.max
})
def update_items(self):
self.current_layer.set_visible(False)
if len(self.items) > 0:
self.current_layer = self.items[self.current - 1]
self.current_layer.set_visible(True)
def update_buttons(self):
if self.current > self.min:
self.previous.set_visible(True)
else:
self.previous.set_visible(False)
if self.current < self.max:
self.next.set_visible(True)
else:
self.next.set_visible(False)
if self.last:
if self.current == self.max:
self.last.set_visible(False)
else:
self.last.set_visible(True)
def handle_previous(self, item, args):
if self.current > self.min:
self.current -= 1
self.update_buttons()
self.update_page_count()
self.update_items()
def handle_next(self, item, args):
if self.current < self.max:
self.current += 1
self.update_buttons()
self.update_page_count()
self.update_items()
def get_current(self):
return self.current
def go_to(self, current):
if current < self.max:
self.current = current
else:
self.current = current
self.update_buttons()
self.update_page_count()
self.update_items()
def go_to_last(self):
self.current = self.max
self.update_buttons()
self.update_page_count()
self.update_items()
def handle_go_to_last(self, item, args):
self.go_to_last()
def get_layers(self):
return [self.layer] + self.items
