fork download
copy 
  1. # -*- encoding: utf-8 -*-
  2.  
  3. #-------------------------------------------------------------------------------
  4. # Name:        menu
  5. # Purpose:     Classe criadora de menus
  6. #
  7. # Author:      Mateus
  8. #
  9. # Created:     05/07/2011
  10. # Version:     beta 0.2
  11. # Copyright:   (c) Mateus 2011
  12. # Licence:     <your licence>
  13. #-------------------------------------------------------------------------------
  14. #!/usr/bin/env python
  15.  
  16. #-------------------------------------------------------------------------------
  17. # Importações
  18. #-------------------------------------------------------------------------------
  19. import os # Verificar OS
  20.  
  21. if os.environ['OS'] == "Windows_NT":
  22.     import msvcrt
  23.     sistOperacional = "Windows_NT"
  24.  
  25. else:
  26.     sistOperacional = "Linux"
  27.  
  28. #-------------------------------------------------------------------------------
  29.  
  30.  
  31. #-------------------------------------------------------------------------------
  32. # Métodos para futuras classes
  33. #-------------------------------------------------------------------------------
  34. def tipoVariavel(variavel):
  35.     """
  36.     Desc: Retorna o tipo que a 'variavel' é
  37.  
  38.     variavel = Mixed: Variável que você quer verificar
  39.  
  40.     return = Str: Tipo de variável
  41.     """
  42.     tipoVar = str(type(variavel))
  43.     tipoVar = tipoVar.split('\'')
  44.     tipoVar = tipoVar[1]
  45.  
  46.     return tipoVar
  47.  
  48.  
  49. def limparTela(sistOperacional):
  50.     """
  51.     Desc: Limpa a tela do prompt
  52.  
  53.     sistOperacional = Atribute: os.environ['OS']
  54.     """
  55.  
  56.     if sistOperacional == "Windows_NT":
  57.         os.system("cls")
  58.     else:
  59.         os.system("clear")
  60.  
  61.  
  62. #-------------------------------------------------------------------------------
  63. # Classe
  64. #-------------------------------------------------------------------------------
  65.  
  66. class Menu:
  67.  
  68.     global sistOperacional
  69.  
  70.     sisOperacional = sistOperacional
  71.     limparTela = True
  72.  
  73.     # ----------------------------------------
  74.     def __init__(self, titulo="Título", menuAnterior=None):
  75.         """
  76.         Desc: Método iniciador
  77.  
  78.         titulo       = Str: Rótulo do título
  79.         menuAnterior = Menu: Menu anterior
  80.         """
  81.  
  82.         # List menu
  83.         # [acho que é um id que não funciona, titulo, elementos do menu (itens)]
  84.         self.menu = [0, titulo, []]
  85.  
  86.         # Menu anterior
  87.         self.menuAnterior = menuAnterior
  88.  
  89.  
  90.     '''
  91.     def __repr__(self):
  92.         """
  93.         Desc: Retorna: Dados da classe
  94.         """
  95.         ' ''
  96.         self._retorno  = "Menu:\n"
  97.         self._retorno += "Classe criadora de menus\n\n"
  98.  
  99.         self._retorno += "Itens do menu:\n"
  100.         ' ''
  101.         self._retorno = str(self.menu)
  102.  
  103.         return self._retorno
  104.     '''
  105.  
  106.     # ----------------------------------------
  107.  
  108.     def iniciar(self):
  109.         """
  110.         Desc: Iniciar sistema
  111.         """
  112.         pass
  113.  
  114.  
  115.     # ----------------------------------------
  116.     def executar(self):
  117.  
  118.  
  119.         # Impressão
  120.         #  Cabeçalho
  121.         self._imprimirCabecalho()
  122.  
  123.         #  Listando os elementos
  124.         totalItens = self._imprimirItens()
  125.  
  126.         #  Se o menu não possui opções
  127.         if totalItens == 0:
  128.             print("Este menu não possui opções! \nVoltando ao menu anterior", end="\n\n")
  129.             self.menuAnterior.executar()
  130.             print()
  131.             return
  132.  
  133.         # Captura de tecla
  134.         print("escolha uma opção: ")
  135.         opcaoSelecionada = self._capturarTecla(totalItens)
  136.  
  137.         # Chamar função
  138.         self._executarFuncao(opcaoSelecionada)
  139.  
  140.  
  141.         '''
  142.         # Limpar a tela
  143.         if self.limparTela == True:
  144.             limparTela(self.sisOperacional)
  145.         '''
  146.  
  147.         # Quando executar um procedimento em vez de chamar um sub menu,
  148.         # deve-se retornar ao menu do procedimento
  149.         self.executar()
  150.  
  151.  
  152.  
  153.     # ----------------------------------------
  154.  
  155.  
  156.     # ----------------------------------------
  157.     #  Métodos de impressão
  158.     # ----------------------------------------
  159.  
  160.     def _imprimirCabecalho(self, nivel=0, tamBarra=30, caractere="*"):
  161.         """
  162.         Desc: Imprime o cabecalho do menu
  163.  
  164.         nivel     = Int: Nivel atual do menu
  165.         tamBarra  = Int: Total de caracteres no na perfumaria do menu
  166.         caractere = Str: Perfumaria a ser utilizada.
  167.                          O código pressupõe que o carartere só possua um carácter
  168.         """
  169.  
  170.         # Cálculos
  171.         varTemp = int((tamBarra - len(self.menu[1])-2)/2)
  172.  
  173.         if (tamBarra - len(self.menu[1])-2)%2 == 1:
  174.             varTemp2 = varTemp+1
  175.         else:
  176.             varTemp2 = varTemp
  177.  
  178.  
  179.         # Cabeçalho
  180.         print(caractere * tamBarra) # Barra
  181.         print(caractere * varTemp,  self.menu[1], caractere * varTemp2) # Titulo do menu
  182.         print(caractere * tamBarra) # Barra
  183.         print()
  184.  
  185.  
  186.     def _imprimirItens(self, numInicial=1, caractere="-"):
  187.         """
  188.         Desc: Imprime os elementos itens de 'self'
  189.  
  190.         numInicial = Int: Número inicial de listagem
  191.         caractere  = Str: Caractere separador
  192.  
  193.         return = Int: Total de itens dessa lista
  194.         """
  195.  
  196.         numItens = 0
  197.  
  198.         for elem in self.menu[2]:
  199.  
  200.             if tipoVariavel(elem) == "list":
  201.                 print(numInicial, caractere, elem[1])
  202.             else:
  203.                 print(numInicial, caractere, elem.menu[1])
  204.  
  205.             numInicial +=1
  206.             numItens +=1
  207.  
  208.         print()
  209.  
  210.         return numItens
  211.  
  212.     # ----------------------------------------
  213.  
  214.  
  215.     # ----------------------------------------
  216.     #  Métodos de captura de tecla
  217.     # ----------------------------------------
  218.  
  219.     def _capturarTecla(self, numFinal, numInicial=0):
  220.         """
  221.         Desc: Captura a tecla que o usuário final tecla para ativar a opção do menu
  222.  
  223.         numFinal   = Int: Número final de elementos da lista.
  224.                           O máximo que a classe suporta é "9"
  225.         numInicial = Int: Número inicial de contagem
  226.  
  227.         return = Int: Elemento selecionado dentro das opções possíveis
  228.         """
  229.  
  230.  
  231.         #  Método de captura depende do sistema operacional a ser utilizado
  232.         if self.sisOperacional == "Windows_NT":
  233.  
  234.             opcaoSelecionada = msvcrt.getch()
  235.  
  236.             #  Convertendo para formato utilizado pelo sistema
  237.             opcaoSelecionada = str(opcaoSelecionada)
  238.             opcaoSelecionada = ord(opcaoSelecionada[2])
  239.  
  240.             # Verificar se a tecla pressionada é uma opção
  241.             #    not (Tecla selecionada é um número)  (concatenado com) not (Selecionado uma das opções)
  242.             while (opcaoSelecionada <= ord(str(numInicial)) or opcaoSelecionada > ord(str(numFinal))):
  243.                 opcaoSelecionada = str(msvcrt.getch())
  244.                 opcaoSelecionada = ord(opcaoSelecionada[2])
  245.  
  246.             # Conversão para string
  247.             opcaoSelecionada = chr(opcaoSelecionada)
  248.  
  249.         else:
  250.             opcaoSelecionada = input()
  251.  
  252.  
  253.         # Conversão para inteiro
  254.         opcaoSelecionada = int(opcaoSelecionada)
  255.  
  256.         return opcaoSelecionada
  257.  
  258.     # ----------------------------------------
  259.  
  260.  
  261.     # ----------------------------------------
  262.     #  Métodos execução de procedimenos
  263.     # ----------------------------------------
  264.     def _executarFuncao(self, opcaoSelecionada):
  265.         """
  266.         Desc: Ativaa função do item selecionado do menu ('opcaoSelecionada')
  267.  
  268.         opcaoSelecionada = Int: Ítem do menu selecionado
  269.  
  270.         return = Int: Elemento selecionado dentro das opções possíveis
  271.         """
  272.  
  273.         elemSelecionado = self.menu[2][opcaoSelecionada - 1]
  274.  
  275.         print() # Perfumaria
  276.  
  277.         # Possuindo uma função para executar
  278.         if tipoVariavel(elemSelecionado) == "list":
  279.             '''
  280.             print()
  281.             print(' (LINHA 273: \nExecutar função de:', elemSelecionado[1]+") ")
  282.             print()
  283.             '''
  284.  
  285.             # Funções padrões do sistema
  286.             if elemSelecionado[2] == "retornar()":
  287.  
  288.                 if self.limparTela == True:
  289.                     limparTela(self.sisOperacional)
  290.  
  291.                 self.menuAnterior.executar()
  292.  
  293.  
  294.             else:
  295.                 exec(elemSelecionado[2])
  296.  
  297.         # É um menu
  298.         else:
  299.             '''
  300.             print()
  301.             print(' (LINHA 279: Sub item:) ')
  302.             print()
  303.             '''
  304.  
  305.             elemSelecionado.executar()
  306.  
  307.     # ----------------------------------------
  308.  
  309.  
  310.     # ----------------------------------------
  311.  
  312.  
  313.     def adicionarSubMenu(self, caminho, rotulo):
  314.         """
  315.         Desc: Adiciona um submenu a um menu
  316.  
  317.         caminho = List: []: Raiz
  318.         rotulo  = Str: Rótulo do item do menu
  319.         """
  320.         # Se for o menu principal
  321.         if caminho == []:
  322.             self._adicionandoElem(caminho, Menu(rotulo, self))
  323.  
  324.         # Se for um sub menu qualquer
  325.         else:
  326.             # Achar menu anterior
  327.             varTemp = self.menu[2]
  328.             for pos in caminho:
  329.                 varTemp = varTemp[pos]
  330.  
  331.             # Criando sub menu
  332.             self._adicionandoElem(caminho, Menu(rotulo, varTemp))
  333.  
  334.  
  335.  
  336.  
  337.     def adicionarItem(self, caminho, rotulo, funcao, *arg):
  338.         """
  339.         Desc: Adicionar item a um menu
  340.  
  341.         caminho = List: []: Raiz
  342.  
  343.         rotulo = Str: Rótulo do item do menu
  344.         funcao = Str: Nome da função
  345.         arg    = Argumentos da funcao
  346.         """
  347.  
  348.         self._adicionandoElem(caminho, [1, rotulo, funcao])
  349.  
  350.  
  351.     def _adicionandoElem(self, caminho, elemento):
  352.         """
  353.         Desc: Adicionar elemento a um menu
  354.  
  355.         caminho = List: []: Raiz
  356.         elemento = Conteudo que será inserido no menu
  357.         """
  358.  
  359.         if caminho == []:
  360.             self.menu[2].append(elemento)
  361.         else:
  362.             # Classe menu -> self.menu
  363.             # Primeiro []  -> Acesso aos elementos da Lista Menu.menu
  364.             #  [2]          -> PONTEIRO PARA: Itens do menu
  365.             # Segundo []   -> Acesso aos itens do menu
  366.             #  caminho[0]   -> PONTEIRO PARA: SubMenu pedido
  367.             # Classe menu -> [caminho[2]]
  368.             # Método -> _adicionandoElem()
  369.  
  370.             self._varTemp = caminho.pop(0)
  371.  
  372.             self.menu[2][self._varTemp]._adicionandoElem(caminho, elemento)
  373.  
  374.  
  375.  
  376.     # ----------------------------------------
  377.  
  378.  
  379.     def imprimir(self, menu=None):
  380.  
  381.         if menu == None:
  382.             menu = self.menu
  383.  
  384.         for valor in menu:
  385.             print('-', valor)
  386.  
  387.         print()
  388.  
  389.  
  390.     # ----------------------------------------
  391.  
  392. #-------------------------------------------------------------------------------
  393.  
  394.  
  395.  
  396.  
  397.  
  398.  
  399. #-------------------------------------------------------------------------------
  400. # Execução
  401. #-------------------------------------------------------------------------------
  402. def imprimir(imprimir="Eu que fiz essa função! xD"):
  403.  
  404.     print(imprimir)
  405.  
  406.     print()
  407.     input("LINHA 400 (Dentro do procedimento imprimir()): \
  408.            \nDigite Enter para finalizar este procedimento")
  409.     print()
  410.  
  411.  
  412.  
  413. if __name__ == '__main__':
  414.  
  415.     menu = Menu("Menu Principal")
  416.  
  417.     menu.adicionarSubMenu([], "Geometria plana")
  418.     menu.adicionarSubMenu([], "Geometria espacial")
  419.     menu.adicionarSubMenu([], "Geometria analítica")
  420.     menu.adicionarSubMenu([], "Sobre")
  421.     menu.adicionarItem([], "Sair", 'quit()')
  422.  
  423.     # Geomeria plana
  424.     menu.adicionarItem([0], "Lei dos Senos", "imprimir('Testando impressão da opção 1')")
  425.     menu.adicionarItem([0], "Teorema de pitagoras", "imprimir('Testando impressão da opção 2')")
  426.     menu.adicionarSubMenu([0], "SubMenu")
  427.     menu.adicionarItem([0], "Retornar ao menu anterior", "retornar()")
  428.  
  429.     #  Geometria plana -> SubMenu
  430.     menu.adicionarItem([0, 2], "Item 1", "imprimir()")
  431.     menu.adicionarItem([0, 2], "Item 2", "imprimir()")
  432.     menu.adicionarItem([0, 2], "Item 3", "imprimir()")
  433.     menu.adicionarItem([0, 2], "Retornar ao menu anterior", "retornar()")
  434.  
  435.  
  436.     # Geometria espacial
  437.     menu.adicionarItem([1], "Lambda", "imprimir()")
  438.     menu.adicionarItem([1], "Teorema de pitagoras", "imprimir()")
  439.     menu.adicionarItem([1], "Retornar ao menu anterior", 'retornar()')
  440.  
  441.  
  442.     # Sobre
  443.     menu.adicionarItem([3], "Autor", "imprimir('Paulo Mateus Moura da Silva')")
  444.     menu.adicionarItem([3], "Data do imprimir do desenvolvimento", "imprimir('05/07/2011')")
  445.     menu.adicionarItem([3], "Versão", "imprimir('Versão beta 0.1')")
  446.     menu.adicionarItem([3], "Retornar ao menu anterior", 'retornar()')
  447.  
  448.     '''
  449.     menu.imprimir()
  450.     menu.imprimir(menu.menu[2])
  451.     menu.imprimir(menu.menu[2][0].menu)
  452.     menu.imprimir(menu.menu[2][0].menu[2][2].menu)
  453.     '''
  454.     print("LINHA 448: Preciso desenvolver o sistema de bradcrumb!")
  455.     menu.executar()
Runtime error #stdin #stdout 0.03s 6168KB
comments (?)
stdin
copy 
Standard input is empty
stdout
copy 
Standard output is empty
https://ideone.com/eA0kg
language:
Python 3 (python  3.12)
created:
14 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!