def choose_projection(cls, movie_id):
from view.menu import Menu
menu = """
1)Choose a projection
2)Cancel reservation
"""
while (True):
MovieController.show_projections_of_movie(movie_id)
kwargs = Menu.get_input(menu, option=None)
option = kwargs['option']
if option == '1':
try:
kwargs = Menu.get_input('', projection_by_id=None)
projection_id = kwargs['projection_by_id']
if cls.is_valid_id(projection_id, 'projection'):
return projection_id
else:
print("Invalid id\n")
except Exception:
print("Invalid input!\n")
elif option == '2':
raise Exception("Canceling reservation...")
else:
print('Invalid option\n')
def main() -> None:
try:
with open("resources/tracks.json") as file:
tracks = json.load(file)["tracks"]
except (IOError, IndexError):
raise IOError("Unable to load tracks from file")
window = Window(WINDOW_NAME,
WINDOW_SIZE,
resizable=True,
min_size=WINDOW_MIN_SIZE)
menu_options = {
"Track": Action(ActionType.CHANGE_VIEW, 1),
"Testing segment": Action(ActionType.CHANGE_VIEW, 2),
"Exit": Action(ActionType.SYS_EXIT),
}
menu = Menu(menu_options)
menu.background_image = pygame.image.load(
"resources/graphics/menu-background.png")
menu.logo_image = pygame.image.load("resources/graphics/logo.png")
tv1 = TrackView(Track.from_points(tracks[6]["points"]))
tv2 = TrackView(Track.from_points(tracks[3]["points"]))
window.add_view(menu, 0, True)
window.add_view(tv1, 1)
window.add_view(tv2, 2)
window.run()
def __init__(self):
self._matrizes = {
'A': None,
'B': None
} # inicialmente não há matrizes definidas
opcoes_sem_matrizes = {
0: 'Sair',
1: 'Criar Matriz A',
2: 'Criar Matriz B',
}
opcoes_com_matrizes = {
0: 'Sair',
1: 'Destruir Matriz A',
2: 'Destruir Matriz B',
3: 'Povoar Matriz A',
4: 'Povoar Matriz B',
5: 'Somar Matrizes A e B',
6: 'Multiplicar Matrizes A e B',
7: 'Analisar Matriz'
}
self._menu_sem_matrizes = Menu('Programa Matriz de Inteiros',
opcoes_sem_matrizes)
self._menu_com_matrizes = Menu('Programa Matriz de Inteiros',
opcoes_com_matrizes)
def __init__(self):
self._jogo = None # inicialmente não há jogo definido
opcoes_sem_jogo = {0: 'Sair', 1: 'Criar Jogo'}
opcoes_com_jogo = {0: 'Sair', 1: 'Destruir Jogo', 2: 'Iniciar Partida'}
self._menu_sem_jogo = Menu('Programa Jogo da Velha', opcoes_sem_jogo)
self._menu_com_jogo = Menu('Programa Jogo da Velha', opcoes_com_jogo)
def _interaja(self):
opcoes = {
0: 'Voltar',
1: 'Mostrar Dados Gerais',
2: 'Adicionar Guerreiro',
3: 'Remover Guerreiro',
4: 'Curar/Ferir Guerreiro',
5: 'Exibir Guerreiro',
6: 'Exibir Guerreiros vivos',
7: 'Exibir Guerreiros mortos'
}
menu = Menu('Gerenciando', opcoes)
voltar = False
while not voltar:
opcao = menu.pergunte()
if opcao == 0:
self._nao_continue()
voltar = True
elif opcao == 1:
self._mostre_dados_gerais()
elif opcao == 2:
self._adicione_guerreiro()
elif opcao == 3:
self._remova_guerreiro()
elif opcao == 4:
self._cure_fira_guerreiro()
elif opcao == 5:
self._exiba_guerreiro()
elif opcao == 6:
self._exiba_vivos()
elif opcao == 7:
self._exiba_mortos()
class Level:
def __init__(self, x, y, tiled):
pygame.init()
self.screen = pygame.display.set_mode((x, y), pygame.RESIZABLE)
self.screen.fill((255, 255, 255))
self.map_screen = pygame.Rect((0, 0, 640, 640))
self.info_panel = pygame.Rect((640, 0, 320, 640))
self.game_map = GameMap(tiled)
self.tile_map = TileMap(tiled, self.map_screen)
self.cursor = Cursor()
self.input_handler = InputHandler(self)
self.menu = Menu(self.screen, self.info_panel)
def set_cursor(self):
scale_x = (self.game_map.x -
self.tile_map.range[0][0]) * self.tile_map.scale
scale_y = (self.game_map.y -
self.tile_map.range[1][0]) * self.tile_map.scale
self.cursor.render(self.screen, scale_x, scale_y)
def render(self):
self.screen.fill((250, 250, 250), rect=self.info_panel)
self.tile_map.render(self.screen, self.map_screen)
self.set_cursor()
self.menu.render(self.game_map.get_current_tile())
pygame.display.flip()
def execute(self):
while True:
for event in pygame.event.get():
self.input_handler.handle_event(event)
def __init__(self, x, y, tiled):
pygame.init()
self.screen = pygame.display.set_mode((x, y), pygame.RESIZABLE)
self.screen.fill((255, 255, 255))
self.map_screen = pygame.Rect((0, 0, 640, 640))
self.info_panel = pygame.Rect((640, 0, 320, 640))
self.game_map = GameMap(tiled)
self.tile_map = TileMap(tiled, self.map_screen)
self.cursor = Cursor()
self.input_handler = InputHandler(self)
self.menu = Menu(self.screen, self.info_panel)
def main():
cn = Connector(conf["host"], conf["port"], conf["user"], conf["password"])
cn.connect()
fc = FamilyController([cn.driver])
menu = Menu([fc])
menu.show_display()
cn.close()
def __init__(self):
self._tribo = None # inicialmente não há tribo definida
opcoes_sem_tribo = {
0: 'Sair',
1: 'Criar Tribo',
}
opcoes_com_tribo = {
0: 'Sair',
1: 'Destruir Tribo',
2: 'Gerenciar Tribo'
}
self._menu_sem_tribo = Menu('Programa Tribo', opcoes_sem_tribo)
self._menu_com_tribo = Menu('Programa Tribo', opcoes_com_tribo)
def __init__(self):
opcoes = {
0: 'Voltar',
1: 'Encher balde A',
2: 'Encher balde B',
3: 'Esvaziar balde A',
4: 'Esvaziar balde B',
5: 'Derrame balde A em balde B',
6: 'Derrame balde B em balde A',
7: 'Balde A receba de balde B',
8: 'Balde B receba de balde A'
}
self._menu = Menu('Opções de Manipulação', opcoes)
def __init__(self, prefeitura):
opcoes = {
0: 'Voltar',
1: 'Quantidade de Cidadãos',
2: 'Renda Média',
3: 'Orçamento para Renda Mínima',
4: 'Renda Média de Faixa Etária',
5: 'Quantidade de Idosos',
6: 'Cidadãos com Mais Renda',
7: 'N Cidadãos com Menos Renda'
}
self._prefeitura = prefeitura
titulo = 'Analisando Prefeitura de {}'.format(prefeitura.nome())
self._menu = Menu(titulo, opcoes)
def __init__(self):
self._tabela_de_codigos = None # inicialmente não há tabela definida
opcoes_sem_tabela = {
0: 'Sair',
1: 'Criar Tabela de Códigos Pré-definida',
2: 'Criar Tabela de Códigos Manualmente',
}
opcoes_com_tabela = {
0: 'Sair',
1: 'Destruir Tabela de Códigos',
2: 'Enigma: Codificar/Decodificar Frase'
}
self._menu_sem_tabela = Menu('Programa Enigma', opcoes_sem_tabela)
self._menu_com_tabela = Menu('Programa Enigma', opcoes_com_tabela)
def __init__(self):
self._navio = None # inicialmente não há navio definido
opcoes_sem_navio = {
0: 'Sair',
1: 'Criar Navio',
}
opcoes_com_navio = {
0: 'Sair',
1: 'Afundar Navio',
2: 'Mostrar Navio',
3: 'Gerenciar Containers no Navio'
}
self._menu_sem_navio = Menu('Programa Navio', opcoes_sem_navio)
self._menu_com_navio = Menu('Programa Navio', opcoes_com_navio)
def __init__(self):
self._prefeitura = None # inicialmente não há prefeitura definida
opcoes_sem_prefeitura = {
0: 'Sair',
1: 'Criar Prefeitura com Dados Aleatórios',
2: 'Criar Prefeitura com Dados Digitados',
3: 'Criar Prefeitura com Dados Fixos'
}
opcoes_com_prefeitura = {
0: 'Sair',
1: 'Destruir Prefeitura',
2: 'Analisar Prefeitura'
}
self._menu_sem_prefeitura = Menu('Programa Prefeitura', opcoes_sem_prefeitura)
self._menu_com_prefeitura = Menu('Programa Prefeitura', opcoes_com_prefeitura)
def interaja(self):
opcoes = {
0: 'Voltar',
1: 'Codificar Frase',
2: 'Decodificar Frase'
}
menu = Menu('Enigma', opcoes)
continuar = True
while continuar:
opcao = menu.pergunte()
if opcao == 0:
continuar = False
else:
if opcao == 1:
self._codifique()
elif opcao == 2:
self._decodifique()
def manipule(self, relogio):
opcoes = {
0: 'Voltar',
1: 'Alterar Hora de Relógio',
2: 'Alterar Minuto de Relógio',
3: 'Alterar Segundo de Relógio',
4: 'Alterar Hora, Minuto e Segundo de Relógio',
5: 'Executar N ticks'
}
menu = Menu('Manipular Relógio', opcoes)
self._mostra_relogio(relogio)
opcao = menu.pergunte()
while opcao != 0:
if opcao == 1:
print('-- Alterar Hora do Relógio')
hora = int(input('Nova hora do relógio: '))
relogio.mude_hora(hora)
elif opcao == 2:
print('-- Alterar Minuto do Relógio')
minuto = int(input('Novo minuto do relógio: '))
relogio.mude_minuto(minuto)
elif opcao == 3:
print('-- Alterar Segundo do Relógio')
segundo = int(input('Novo segundo do relógio: '))
relogio.mude_segundo(segundo)
elif opcao == 4:
print('-- Alterar Hora, Minuto e Segundo do relógio')
hora = int(input('Nova hora do relógio: '))
minuto = int(input('Novo minuto do relógio: '))
segundo = int(input('Novo segundo do relógio: '))
relogio.mude_hms(hora, minuto, segundo)
elif opcao == 5:
print('-- Executar N ticks no relógio')
n = int(input('Quantos ticks: '))
self._mostra_relogio(relogio)
print('** iniciando ticks...')
for _ in range(n):
print('Tick!')
relogio.tick()
self._mostra_relogio(relogio)
print('** fim de ticks')
self._mostra_relogio(relogio)
opcao = menu.pergunte()
def choose_number_of_tickets(cls):
from view.menu import Menu
menu = """
1)Choose number of tickets
2)Cancel reservation
"""
while (True):
kwargs = Menu.get_input(menu, option=None)
option = kwargs['option']
if option == '1':
kwargs = Menu.get_input(None, number_of_tickets=None)
try:
num_tickets = int(kwargs['number_of_tickets'])
return num_tickets
except Exception:
print("Invalid number tickets\n")
elif option == '2':
raise Exception("Canceling reservation...")
else:
print("Invalid input!\n")
class PainelManipulaBaldes:
def __init__(self):
opcoes = {
0: 'Voltar',
1: 'Encher balde A',
2: 'Encher balde B',
3: 'Esvaziar balde A',
4: 'Esvaziar balde B',
5: 'Derrame balde A em balde B',
6: 'Derrame balde B em balde A',
7: 'Balde A receba de balde B',
8: 'Balde B receba de balde A'
}
self._menu = Menu('Opções de Manipulação', opcoes)
def manipule(self, baldeA, baldeB):
print('--- Manipula Baldes ---')
encerrar = False
while not encerrar:
self._mostre_baldes(baldeA, baldeB)
opcao = self._menu.pergunte()
if opcao == 0:
encerrar = True
elif opcao == 1:
baldeA.fique_cheio()
elif opcao == 2:
baldeB.fique_cheio()
elif opcao == 3:
baldeA.fique_vazio()
elif opcao == 4:
baldeB.fique_vazio()
elif opcao == 5:
baldeA.derrame_em(baldeB)
elif opcao == 6:
baldeB.derrame_em(baldeA)
elif opcao == 7:
baldeA.receba_de(baldeB)
elif opcao == 8:
baldeB.receba_de(baldeA)
def _mostre_baldes(self, baldeA, baldeB):
print('****** Situação Atual dos Baldes')
print('- Balde A')
self._mostre_balde(baldeA)
print('- Balde B')
self._mostre_balde(baldeB)
print('****************************\n')
def _mostre_balde(self, balde):
print('capacidade : {}'.format(balde.capacidade()))
print('quantidade : {}'.format(balde.quantidade()))
print('está cheio : {}'.format(balde.esta_cheio()))
print('está vazio : {}'.format(balde.esta_vazio()))
class InterfaceComUsuario:
def __init__(self):
self._tribo = None # inicialmente não há tribo definida
opcoes_sem_tribo = {
0: 'Sair',
1: 'Criar Tribo',
}
opcoes_com_tribo = {
0: 'Sair',
1: 'Destruir Tribo',
2: 'Gerenciar Tribo'
}
self._menu_sem_tribo = Menu('Programa Tribo', opcoes_sem_tribo)
self._menu_com_tribo = Menu('Programa Tribo', opcoes_com_tribo)
def interaja(self):
terminar = False
while not terminar:
painel = self._defina_painel()
if painel is None:
terminar = True
else:
painel.interaja()
def _defina_painel(self):
painel = None
if self._tribo is None:
opcao = self._menu_sem_tribo.pergunte()
if opcao == 1:
painel = PainelCriaTribo(self)
else:
opcao = self._menu_com_tribo.pergunte()
if opcao == 1:
painel = PainelDestroiTribo(self, self._tribo)
elif opcao == 2:
painel = PainelGerenciaTribo(self, self._tribo)
return painel
def armazene_tribo(self, tribo):
self._tribo = tribo
def __init__(self):
self._relogio = None # inicialmente não há relógio definido
opcoes_sem_relogio = {
0: 'Sair',
1: 'Criar Relógio Marcando 00:00:00',
2: 'Criar Relógio Marcando hh:00:00',
3: 'Criar Relógio Marcando 00:mm:00',
4: 'Criar Relógio Marcando 00:00:ss',
5: 'Criar Relógio Marcando hh:mm:00',
6: 'Criar Relógio Marcando 00:mm:ss',
7: 'Criar Relógio Marcando hh:00:ss',
8: 'Criar Relógio Marcando hh:mm:ss'
}
opcoes_com_relogio = {
0: 'Sair',
1: 'Destruir Relógio',
2: 'Manipular Relógio',
3: 'Comparar Relógios'
}
self._menu_sem_relogio = Menu('Programa Relógio', opcoes_sem_relogio)
self._menu_com_relogio = Menu('Programa Relógio', opcoes_com_relogio)
def obtain_movie_id(cls):
from view.menu import Menu
from controllers.controller import Controller
Controller.show_all_movies()
try:
kwargs = Menu.get_input("Choose a movie by id", movie_id=None)
movie_id = int(kwargs['movie_id'])
if cls.is_valid_id(movie_id, 'movie'):
return movie_id
else:
return None
except Exception:
print("Invalid id!\n")
def gerencie(self, navio):
opcoes = {
0: 'Voltar',
1: 'Carregar Container',
2: 'Descarregar Container',
3: 'Verificar se Carrega Container',
4: 'Procurar Containers por Peso'
}
menu = Menu('Gerenciando Containers', opcoes)
voltar = False
while not voltar:
opcao = menu.pergunte()
if opcao == 0:
voltar = True
else:
if opcao == 1:
self._carregue(navio)
elif opcao == 2:
self._descarregue(navio)
elif opcao == 3:
self._verifique(navio)
elif opcao == 4:
self._procure_por_peso(navio)
def reserve_a_seat(cls, proj_id, user):
from view.menu import Menu
seat_table = ProjectionController.show_seat_table(proj_id)
while (True):
menu = """
1)Reserve a seat
2)Cancel reservation
"""
kwargs = Menu.get_input(menu, option=None)
option = kwargs["option"]
if option == '1':
kwargs = Menu.get_input("enter row and col\n",
row=None,
col=None)
row, col = kwargs['row'], kwargs['col']
try:
row = int(row)
col = int(col)
if seat_table[row][col] == '.':
session.add(
Reservation(user_id=user.id,
projection_id=proj_id,
row=row,
col=col))
print("Seat reserved!\n")
break
else:
print("Seat is taken!\n")
except Exception:
print("Invalid input!\n")
elif option == '2':
raise Exception("Canceling reservation...")
else:
print("Invalid option!\n")
def finalize(cls):
from view.menu import Menu
menu = """
Finalize transaction?
1)Yes
2)No
"""
kwargs = Menu.get_input(menu, option=None)
option = kwargs['option']
if option == '1':
session.commit()
return True
else:
session.rollback()
return False
def _create_widgets(self) -> None:
self.__menu = Menu(self.__main_window)
self.__main_notebook = ttk.Notebook(self.__main_window,
style='Main.TNotebook')
self.__encoding_frame = EncodingTab(self.__main_notebook)
self.__instances_tab = InstancesTab(self.__main_notebook)
self.__vertical_notebook = ttk.Notebook(self.__encoding_frame,
style='Vertical.TNotebook')
self.__taxonomy_tab = TaxonomyTab(self.__vertical_notebook)
self.__associations_tab = AssociationsTab(self.__vertical_notebook)
self.__ports_tab = PortsTab(self.__vertical_notebook)
self.__resources_tab = ResourcesTab(self.__vertical_notebook)
self.__constraints_tab = ConstraintsTab(self.__vertical_notebook)
def __init__(self):
opcoes = {
0: ('Sair do Programa', None),
1: ('Média de três números', PainelMedia3),
2: ('Soma de três números', PainelSoma3),
3: ('Menor de três números', PainelMenor3),
4: ('Número Par', PainelPar),
5: ('Maior que', PainelMaiorQue),
6: ('Divisível por', PainelDivisivelPor),
7: ('Multiplica', PainelMultiplica),
8: ('Divisão Inteira', PainelDivide),
9: ('Ano Bissexto', PainelBissexto),
10: ('Máximo Divisor Comum', PainelMDC),
11: ('Soma dos Divisores', PainelSomaDivisores),
12: ('Números Amigos', PainelAmigos),
13: ('Número Primo', PainelPrimo),
14: ('Número Composto', PainelComposto)
}
menu = Menu('Exercício Cálculos', opcoes)
self._menu = menu
def choose_a_movie(cls):
from view.menu import Menu
menu = """
1)Choose a movie
2)Cancel reservation
"""
while (True):
MovieController.show_all_movies()
kwargs = Menu.get_input(menu, option=None)
option = kwargs['option']
if option == '1':
movie_id = cls.obtain_movie_id()
if movie_id:
return movie_id
else:
print("Invalid movie id!")
elif option == '2':
raise Exception("Canceling reservation...")
else:
print("Invalid option")
class PainelAnalisaPrefeitura:
def __init__(self, prefeitura):
opcoes = {
0: 'Voltar',
1: 'Quantidade de Cidadãos',
2: 'Renda Média',
3: 'Orçamento para Renda Mínima',
4: 'Renda Média de Faixa Etária',
5: 'Quantidade de Idosos',
6: 'Cidadãos com Mais Renda',
7: 'N Cidadãos com Menos Renda'
}
self._prefeitura = prefeitura
titulo = 'Analisando Prefeitura de {}'.format(prefeitura.nome())
self._menu = Menu(titulo, opcoes)
def analise(self):
terminar = False
while not terminar:
opcao = self._menu.pergunte()
if opcao == 0:
terminar = True
else:
if opcao == 1:
self._mostre_qtd_cidadaos()
elif opcao == 2:
self._mostre_renda_media()
elif opcao == 3:
self._mostre_orcamento_renda_minima()
elif opcao == 4:
self._mostre_renda_media_faixa_etaria()
elif opcao == 5:
self._mostre_qtd_idosos()
elif opcao == 6:
self._mostre_com_mais_renda()
elif opcao == 7:
self._mostre_com_menos_renda()
def _mostre_qtd_cidadaos(self):
msg = 'Quantidade de cidadãos: {}'.format(
self._prefeitura.qtd_cidadaos())
print(msg)
input('Tecle ENTER para continuar')
def _mostre_renda_media(self):
msg = 'Renda média (R$): {0:.2f}'.format(
self._prefeitura.renda_media())
print(msg)
input('Tecle ENTER para continuar')
def _mostre_orcamento_renda_minima(self):
continuar = True
while continuar:
renda_minima = int(input('Qual a renda mínima desejada? '))
(orcamento,
qtd) = self._prefeitura.orcamento_renda_minima(renda_minima)
percentual_atingido = (qtd / self._prefeitura.qtd_cidadaos()) * 100
print('Orçamento necessário (R$): {}'.format(orcamento))
print('Quantidade de pessoas beneficiadas: {0} ({1:.2f}%)'.format(
qtd, percentual_atingido))
continuar = 's' == input('Deseja novo cálculo? [s/n]')
def _mostre_renda_media_faixa_etaria(self):
continuar = True
while continuar:
idade_minima = int(input('Idade mínima: '))
idade_maxima = int(input('Idade máxima: '))
ano_atual = int(input('Ano desejado: '))
renda_media = self._prefeitura.renda_media_de_faixa_etaria(
idade_minima, idade_maxima, ano_atual)
if renda_media is None:
print('Nennhum cidadão encontrado para estes dados.')
else:
print('Renda Média (R$): {0:.2f}'.format(renda_media))
continuar = 's' == input('Deseja novo cálculo? [s/n]')
def _mostre_qtd_idosos(self):
continuar = True
while continuar:
idade_idoso = int(input('Idade mínima para ser idoso: '))
ano_atual = int(input('Ano desejado: '))
qtd = self._prefeitura.qtd_idosos(idade_idoso, ano_atual)
percentual_idosos = (qtd / self._prefeitura.qtd_cidadaos()) * 100
print('Quantidade de idosos em {0}: {1} ({2:.2f}%)'.format(
ano_atual, qtd, percentual_idosos))
continuar = 's' == input('Deseja novo cálculo? [s/n]')
def _mostre_com_mais_renda(self):
continuar = True
while continuar:
renda = int(input('Renda: '))
cidadaos = self._prefeitura.cidadaos_com_mais_renda_que(renda)
percentual_cidadaos = (len(cidadaos) /
self._prefeitura.qtd_cidadaos()) * 100
print(
'Quantidade de cidadãos com renda superior à {0}: {1} ({2:.2f}%)'
.format(renda, len(cidadaos), percentual_cidadaos))
if 's' == input('Mostrar os cidadãos? [s/n]'):
for c in cidadaos:
print(c)
continuar = 's' == input('Deseja novo cálculo? [s/n]')
def _mostre_com_menos_renda(self):
continuar = True
while continuar:
renda = int(input('Renda: '))
n = int(input('Quantos cidadãos encontrar: '))
cidadaos = self._prefeitura.n_cidadaos_com_menos_renda_que(
n, renda)
percentual_cidadaos = (len(cidadaos) /
self._prefeitura.qtd_cidadaos()) * 100
print(
'Quantidade de cidadãos com renda inferior à {0}: {1} ({2:.2f}&)'
.format(renda, len(cidadaos), percentual_cidadaos))
if 's' == input('Mostrar os cidadãos? [s/n]'):
for c in cidadaos:
print(c)
continuar = 's' == input('Deseja novo cálculo? [s/n]')
def main():
Database.create()
Menu.start()
def main():
if not os.path.isfile("cinema_reservation_management.db"):
create_database()
Menu().start()
def MainMenu():
return Menu.build_main_menu(Prefs)