def consultar_laboratorio(self):
obligatorio = True
codigo = util.leer_cadena(msg('laboratorio.ingrese.codigo'),
obligatorio)
try:
if not util.es_numerico(codigo):
raise Exception("La codigo debe ser numerica!")
laboratorio = ControladorLaboratorio().buscar_codigo(codigo)
return laboratorio
except Exception as e:
print(e)
class ListarLaboratorio(tk.PanedWindow):
__lista_lbl = None
__laboratorio_lbl = None
__controlador = ControladorLaboratorio()
def __init__(self, panel_master):
tk.PanedWindow.__init__(self, master=panel_master)
self.__panel_master = panel_master
self.inicializar()
self.pack()
def inicializar(self):
self.__panel_master.geometry('800x600')
self.__panel_master.title("Laboratorios")
self.get_lista_lbl()
self.get_listar()
def get_controlador(self):
return self.__controlador
def get_lista_lbl(self):
if not self.__lista_lbl:
self.__lista_lbl = tk.Label(master=self,
text="Lista de Laboratorios",
font=('Ubuntu', 16),
width=20)
self.__lista_lbl.grid(row=1, column=0)
return self.__lista_lbl
def get_listar(self):
if not self.__laboratorio_lbl:
i = 2
laboratorios = self.get_controlador().get_lista_objetos()
for lab in laboratorios:
self.__laboratorio_lbl = tk.Label(master=self,
text=lab.__str__())
self.__laboratorio_lbl.grid(row=i, column=0)
i = i + 1
else:
messagebox.showinfo("Info", "no hay disponibles")
#Programacion Funcional
import sys
sys.path.append("../") # referencia al directorio base
from controladores import ControladorDocente, ControladorLaboratorio, ControladorFicha
def buscar_por_cedula(cedula):
'''funcion que buscar a un docente por cedula'''
return [docente for docente in ControladorDocente().buscar_codigo(cedula) if cedula == docente.get_cedula()]
def listar_reservas(laboratorio):
'''funcion que lista las reservas de un solo laboratorio'''
return laboratorio.consultar()
if __name__ == "__main__":
#retorna una lista de laboratorios
laboratorios = ControladorLaboratorio().get_lista_objetos()
#recorremos los laboratorios
for laboratorio in laboratorios:
#preguntamos las reservas por laboratorio
for reserva in listar_reservas(laboratorio):
print(reserva.__str__())
try:
cedula = 1
print(buscar_por_cedula(cedula))
except Exception as e:
print (e)
class FormsReserva(tk.PanedWindow):
__laboratorio_lbl = None
__laboratorio_cbx = None
__laboratorio_dicc = None
__codigo_lbl = None
__codigo_entry = None
__cedula_docente_lbl = None
__cedula_docente_entry = None
__nombre_docente_entry = None
__crear_btn = None
__fecha_lbl = None
__fecha_entry = None
__hora_inicio_lbl = None
__hora_inicio_entry = None
__hora_fin_lbl = None
__hora_fin_entry = None
__asignatura_cbx = None
__verificar_btn = None
'''defino los controladores necesarios a ser utilizados'''
__controlador_ficha = ControladorFicha()
__controlador_laboratorio = ControladorLaboratorio()
__controlador_docente = ControladorDocente()
def __init__(self, panel_master):
tk.PanedWindow.__init__(self, master=panel_master)
self.__panel_master = panel_master
self.inicializar()
self.pack()
def inicializar(self):
self.__panel_master.geometry('800x600')
self.__panel_master.title("ABM Reservas")
self.get_laboratorio_lbl()
self.get_laboratorio_cbx()
self.get_codigo_lbl()
self.get_codigo_entry()
self.get_cedula_docente_lbl()
self.get_cedula_docente_entry()
self.get_fecha_lbl()
self.get_fecha_entry()
self.get_hora_inicio_lbl()
self.get_hora_inicio_entry()
self.get_hora_fin_lbl()
self.get_hora_fin_entry()
self.get_crear_btn()
self.get_verificar_btn()
def get_laboratorio_lbl(self):
'''etiqueta para desplegar los nombres de laboratorios'''
if not self.__laboratorio_lbl:
self.__laboratorio_lbl = tk.Label(master=self, text="LABORATORIO", width=20)
self.__laboratorio_lbl.grid(row=2, column=0)
return self.__laboratorio_lbl
def get_laboratorio_cbx(self):
'''Combobox que recupera los objetos del tipo laboratorio para poder mostrar sus nombres'''
if not self.__laboratorio_cbx:
self.__box_value = StringVar()
self.__laboratorio_cbx = ttk.Combobox(master=self,textvariable=self.__box_value, width=20, state='readonly')
#obtener la lista de laboratorios actual
laboratorios = self.__controlador_laboratorio.get_lista_objetos()
lista = []
self.__laboratorio_dicc = {}
for lab in laboratorios:
lista.append(lab.get_nombre())
self.__laboratorio_dicc[lab.get_nombre()] = lab
self.__laboratorio_cbx["value"] = lista
self.__laboratorio_cbx.focus()
self.__laboratorio_cbx.grid(row=2, column=1)
return self.__laboratorio_cbx
def get_codigo_lbl(self):
'''etiqueta para el codigo de una ficha'''
if not self.__codigo_lbl:
self.__codigo_lbl = tk.Label(master=self, text="CODIGO FICHA :", width=20)
self.__codigo_lbl.grid(row=3, column=0)
return self.__codigo_lbl
def get_codigo_entry(self):
'''campo que muestra en codigo de la ficha que sera autogenerado'''
if not self.__codigo_entry:
self.__codigo_entry = tk.Entry(master=self, width=20)
self.__codigo_entry.focus()
self.__codigo_entry.grid(row=3, column=1)
return self.__codigo_entry
def get_cedula_docente_lbl(self):
'''etiqueta para la cedula del docente'''
if not self.__cedula_docente_lbl:
self.__cedula_docente_lbl = tk.Label(master=self, text="CEDULA_DOCENTE :", width=20)
self.__cedula_docente_lbl.grid(row=4, column=0)
return self.__cedula_docente_lbl
def get_cedula_docente_entry(self):
'''guarda la cedula del docente'''
if not self.__cedula_docente_entry:
self.__cedula_docente_entry = tk.Entry(master=self, width=20)
self.__cedula_docente_entry.focus()
self.__cedula_docente_entry.grid(row=4, column=1)
return self.__cedula_docente_entry
def get_nombre_docente_entry(self):
'''guarda la nombre del docente'''
if not self.__nombre_docente_entry:
self.__nombre_docente_entry = tk.Entry(master=self, width=20)
#self.__nombre_docente_entry.focus()
self.__nombre_docente_entry.grid(row=4, column=2)
#recupero el codigo del docente
cedula = self.get_cedula_docente_entry().get()
#busco al docente en la base de datos
docente = ControladorDocente().buscar_codigo(cedula)
#inserto en nombre del docente al campo de entrada
self.__nombre_docente_entry.insert(0,docente.get_nombre())
return self.__nombre_docente_entry
def get_asignatura_cbx(self):
if not self.__asignatura_cbx:
self.__box_value = StringVar()
self.__asignatura_cbx = ttk.Combobox(master=self,textvariable=self.__box_value, width=20, state='readonly')
#obtener la lista de asignatura actual
docente = self.__controlador_docente.get_lista_objetos()
lista = []
dicc = {}
for doc in docente:
lista.append(doc.get_asignatura())
dicc[doc.get_asignatura()] = doc
self.__asignatura_cbx["value"] = lista
self.__asignatura_cbx.focus()
self.__asignatura_cbx.grid(row=4, column=3)
return self.__asignatura_cbx
def get_fecha_lbl(self):
'''etiqueta para la fecha a reservar'''
if not self.__fecha_lbl:
self.__fecha_lbl = tk.Label(master=self, text="FECHA PRESTAMO :", width=20)
self.__fecha_lbl.grid(row=5, column=0)
return self.__fecha_lbl
def get_fecha_entry(self):
'''guarda la fecha reservada por el docente'''
if not self.__fecha_entry:
self.__fecha_entry = tk.Entry(master=self, width=20)
self.__fecha_entry.focus()
self.__fecha_entry.grid(row=5, column=1)
return self.__fecha_entry
def get_hora_inicio_lbl(self):
'''etiqueta para la hora de inicio'''
if not self.__hora_inicio_lbl:
self.__hora_inicio_lbl = tk.Label(master=self, text="HORA_INICIO :", width=20)
self.__hora_inicio_lbl.grid(row=6, column=0)
return self.__hora_inicio_lbl
def get_hora_inicio_entry(self):
'''guarda la hora inicio reservada'''
if not self.__hora_inicio_entry:
self.__hora_inicio_entry = tk.Entry(master=self, width=20)
self.__hora_inicio_entry.focus()
self.__hora_inicio_entry.grid(row=6, column=1)
return self.__hora_inicio_entry
def get_hora_fin_lbl(self):
'''etiqueta para la hora de fin'''
if not self.__hora_fin_lbl:
self.__hora_fin_lbl = tk.Label(master=self, text="HORA_FIN :", width=20)
self.__hora_fin_lbl.grid(row=7, column=0)
return self.__hora_fin_lbl
def get_hora_fin_entry(self):
'''guarda la hora fin reservada'''
if not self.__hora_fin_entry:
self.__hora_fin_entry = tk.Entry(master=self, width=20)
self.__hora_fin_entry.focus()
self.__hora_fin_entry.grid(row=7, column=1)
return self.__hora_fin_entry
def get_crear_btn(self):
'''Boton utilizado para la creacion de un reserva'''
if not self.__crear_btn:
self.__crear_btn = tk.Button(master=self, text="CREAR", bg='orange3', command=self.crear_reserva)
self.__crear_btn.grid(row=8, column=1)
return self.__crear_btn
def get_verificar_btn(self):
'''Boton utilizado para la verificacion de datos del docente'''
if not self.__verificar_btn:
self.__verificar_btn = tk.Button(master=self, text="VERIFICAR CEDULA", bg='orange3', command=self.verificar_docente)
self.__verificar_btn.grid(row=8, column=2)
return self.__verificar_btn
'''Reservar laboratorio, consiste en que un docente debe poder seleccionar un laboratorio y poder realizar
dicha reserva de la siguiente manera'''
def crear_reserva(self):
#recupero los datos ingresados por el usuario, de manera a poder crear la ficha
nombre_lab = self.get_laboratorio_cbx().get()
codigo = self.get_codigo_entry().get()
cedula = self.get_cedula_docente_entry().get()
fecha = self.get_fecha_entry().get()
hora_inicio = self.get_hora_inicio_entry().get()
hora_fin = self.get_hora_fin_entry().get()
try:
if not self.verificar_docente():
raise Exception("Debe ingresar una cedula de docente valido!!")
else:
#creo la ficha para la reserva
ficha = Ficha(codigo, cedula, hora_inicio, hora_fin, fecha)
self.__controlador_ficha.crear(ficha)
#recuperar el laboratorio a asignar la reserva
laboratorio = self.__laboratorio_dicc[nombre_lab]
laboratorio.reserva(ficha)
messagebox.showinfo("Reserva", "Prestamo exitoso!!")
except Exception as e:
messagebox.showinfo("Exception", e)
'''Verifica la existencia de un docente en la base de datos'''
def verificar_docente(self):
#recupero la cedula ingresada
cedula = self.get_cedula_docente_entry().get()
try:
#verifico que la cedula este cargada
if not cedula:
raise Exception ("Debe ingresar una valor para la cedula")
#busco al docente en la base de datos
docente = ControladorDocente().buscar_codigo(cedula)
#recupero el nombre del docente
self.get_nombre_docente_entry()
#recupero las asignaturas del docente
self.get_asignatura_cbx()
return True
except Exception as e:
messagebox.showinfo("Opaa", e)
'''funcion utilizada para partes del programa que no estan en desarrollo'''
def accion(self):
messagebox.showinfo("Info", "No implementado")
class FormsLaboratorio(tk.PanedWindow):
'''Clase que permite realizar el formulario para introducir un laboratorio desde el
teclado'''
__codigo_etiqueta = None
__codigo_entry = None
__nombre_etiqueta = None
__nombre_entry = None
__cantidad_maquinas_etiqueta = None
__cantidad_maquinas_entry = None
__guardar_boton = None
__controlador = ControladorLaboratorio()
def __init__(self, panel_master):
tk.PanedWindow.__init__(self, master=panel_master)
self.__panel_master = panel_master
self.inicializar()
self.pack()
def inicializar(self):
self.__panel_master.geometry('800x600')
self.__panel_master.title("ABM Laboratorios")
self.get_codigo_etiqueta()
self.get_codigo_entry()
self.get_nombre_etiqueta()
self.get_nombre_entry()
self.get_cantidad_maquinas_etiqueta()
self.get_cantidad_maquinas_entry()
self.get_guardar_boton()
def get_controlador(self):
return self.__controlador
def get_codigo_etiqueta(self):
'''creo la etiqueta para la vista'''
if not self.__codigo_etiqueta:
self.__codigo_etiqueta = tk.Label(master=self, text="Codigo: ", width=20)
self.__codigo_etiqueta.grid(row=1, column=0)
return self.__codigo_etiqueta
def get_codigo_entry(self):
'''creo la caja de texto para cargar datos'''
if not self.__codigo_entry:
self.__codigo_entry = tk.Entry(master=self, width=20)
self.__codigo_entry.focus()
self.__codigo_entry.grid(row=1, column=1)
return self.__codigo_entry
def get_nombre_etiqueta(self):
'''creo la etiqueta para la vista'''
if not self.__nombre_etiqueta:
self.__nombre_etiqueta = tk.Label(master=self, text="Nombre: ", width=20)
self.__nombre_etiqueta.grid(row=2, column=0)
return self.__nombre_etiqueta
def get_nombre_entry(self):
'''creo la caja de texto para cargar datos'''
if not self.__nombre_entry:
self.__nombre_entry = tk.Entry(master=self, width=20)
self.__nombre_entry.grid(row=2, column=1)
return self.__nombre_entry
def get_cantidad_maquinas_etiqueta(self):
'''creo la etiqueta para la vista'''
if not self.__cantidad_maquinas_etiqueta:
self.__cantidad_maquinas_etiqueta = tk.Label(master=self, text="Cantidad de Maquinas: ", width=20)
self.__cantidad_maquinas_etiqueta.grid(row=3, column=0)
return self.__cantidad_maquinas_etiqueta
def get_cantidad_maquinas_entry(self):
'''creo la caja de texto para cargar datos'''
if not self.__cantidad_maquinas_entry:
self.__cantidad_maquinas_entry = tk.Entry(master=self, width=20)
self.__cantidad_maquinas_entry.grid(row=3, column=1)
return self.__cantidad_maquinas_entry
def get_guardar_boton(self):
if not self.__guardar_boton:
self.__guardar_boton = tk.Button(master=self, text="Guardar", command=self.guardar_laboratorio)
self.__guardar_boton.grid(row=8, column=1)
return self.__guardar_boton
def guardar_laboratorio(self):
codigo = self.get_codigo_entry().get()
nombre = self.get_nombre_entry().get()
cantidad_maquinas = self.get_cantidad_maquinas_entry().get()
try:
#creo el objeto del tipo docente
laboratorio = Laboratorio(codigo, nombre, cantidad_maquinas)
#lo creo por medio del controlador
self.get_controlador().crear(laboratorio)
messagebox.showinfo("Registro Laboratorio","Se creo el Laboratorio con exito")
except Exception as e:
messagebox.showinfo("Error", e)
class FormsConsulta(tk.PanedWindow):
__laboratorio_lbl = None
__laboratorio_cbx = None
__laboratorio_dicc = None
__consultar_btn = None
__title_lbl = None
__ficha_lbl = None
'''defino los controladores necesarios a ser utilizados'''
__controlador_ficha = ControladorFicha()
__controlador_laboratorio = ControladorLaboratorio()
def __init__(self, panel_master):
tk.PanedWindow.__init__(self, master=panel_master)
self.__panel_master = panel_master
self.inicializar()
self.pack()
def inicializar(self):
self.__panel_master.geometry('800x600')
self.__panel_master.title("ABM Consultas")
self.get_laboratorio_lbl()
self.get_laboratorio_cbx()
self.get_consultar_btn()
def get_laboratorio_lbl(self):
'''etiqueta para desplegar los nombres de laboratorios'''
if not self.__laboratorio_lbl:
self.__laboratorio_lbl = tk.Label(master=self,
text="LABORATORIO",
width=20)
self.__laboratorio_lbl.grid(row=2, column=0)
return self.__laboratorio_lbl
def get_laboratorio_cbx(self):
'''Combobox que recupera los objetos del tipo laboratorio para poder mostrar sus nombres'''
if not self.__laboratorio_cbx:
self.__box_value = StringVar()
self.__laboratorio_cbx = ttk.Combobox(
master=self,
textvariable=self.__box_value,
width=20,
state='readonly')
#obtener la lista de laboratorios actual
laboratorios = self.__controlador_laboratorio.get_lista_objetos()
lista = []
self.__laboratorio_dicc = {}
for lab in laboratorios:
lista.append(lab.get_nombre())
self.__laboratorio_dicc[lab.get_nombre()] = lab
self.__laboratorio_cbx["value"] = lista
self.__laboratorio_cbx.focus()
self.__laboratorio_cbx.grid(row=2, column=1)
return self.__laboratorio_cbx
def get_consultar_btn(self):
'''Boton utilizado para la creacion de un consulta'''
if not self.__consultar_btn:
self.__consultar_btn = tk.Button(master=self,
text="Consultar",
bg='orange3',
font=('Ubuntu', 11),
command=self.consultar)
self.__consultar_btn.grid(row=3, column=1)
return self.__consultar_btn
'''Consultar laboratorio, consiste en que un docente debe poder seleccionar un laboratorio y poder realizar
dicha consulta de la siguiente manera'''
def consultar(self):
#recupero los datos ingresados por el usuario, de manera a poder consultar la ficha
nombre_lab = self.get_laboratorio_cbx().get()
laboratorio = self.__laboratorio_dicc[nombre_lab]
fichas = laboratorio.consultar()
'''Si hay reservas en el laboratorio, listara las fichas de reservas'''
if nombre_lab == None:
messagebox.showinfo("Info", "Debe seleccionar ese laboratorio")
if fichas:
self.get_title_lbl()
if not self.__ficha_lbl:
fila = 5
for ficha in fichas:
self.__title_lbl = tk.Label(master=self,
text=ficha.__str__())
self.__title_lbl.grid(row=fila, column=1)
fila = fila + 1
else:
messagebox.showinfo("Info", "No hay reservas para ese laboratorio")
def get_title_lbl(self):
'''crea la etiqueta para el titulo'''
if not self.__title_lbl:
self.__title_lbl = tk.Label(master=self,
text="Lista de Fichas",
font=('Ubuntu', 11),
width=20)
self.__title_lbl.grid(row=4, column=1)
return self.__title_lbl
'''funcion utilizada para partes del programa que no estan en desarrollo'''
def accion(self):
messagebox.showinfo("Info", "No implementado")
class ModuloLaboratorio(Modulo):
__controlador = ControladorLaboratorio()
def __init__(self):
Modulo.__init__(self, msg('abm.laboratorio.menu.titulo'))
self.__menu_dict = None
def listar(self):
laboratorios = self.get_controlador().get_lista_objetos()
print(msg('abm.laboratorio.titulo.lista'))
for lab in laboratorios:
print(lab.__str__())
self.pausa()
def registrar(self):
print(msg('abm.laboratorio.titulo.registrar'))
obligatorio = True
codigo = util.leer_cadena(msg('laboratorio.ingrese.codigo'),
obligatorio)
nombre = str(
util.leer_cadena(msg('laboratorio.ingrese.nombre'), obligatorio))
cantidad_maquinas = str(
util.leer_cadena(msg('laboratorio.ingrese.cantidad_maquinas'),
obligatorio))
laboratorio = Laboratorio(codigo, nombre, cantidad_maquinas)
try:
self.get_controlador().crear(laboratorio)
print(msg("registro.creado"))
except Exception as e:
print(e)
self.pausa()
def borrar(self):
print(msg('abm.laboratorio.titulo.borrar'))
obligatorio = True
codigo = util.leer_cadena(msg('laboratorio.ingrese.codigo'),
obligatorio)
try:
laboratorio = self.get_controlador().buscar_codigo(codigo)
if not laboratorio:
print(msg('laboratorio.codigo.no.existe'), ":", codigo)
else:
self.get_controlador().borrar(laboratorio)
print(msg('laboratorio.borrado'))
except Exception as e:
print(e)
self.pausa()
def consultar_laboratorio(self):
obligatorio = True
codigo = util.leer_cadena(msg('laboratorio.ingrese.codigo'),
obligatorio)
try:
if not util.es_numerico(codigo):
raise Exception("La codigo debe ser numerica!")
laboratorio = ControladorLaboratorio().buscar_codigo(codigo)
return laboratorio
except Exception as e:
print(e)
def ir_menu_principal(self):
self.set_terminar_ejecucion(True)
def get_controlador(self):
return self.__controlador
def get_menu_dict(self):
#crear en caso de que aun no se haya creado
if not self.__menu_dict:
menu_listar = Menu(msg('abm.laboratorio.listar'), self.listar)
menu_registrar = Menu(msg('abm.laboratorio.registrar'),
self.registrar)
#menu_borrar = Menu(msg('abm.laboratorio.borrar'), self.borrar)
menu_principal = Menu(msg('abm.ir.menu.principal'),
self.ir_menu_principal)
menus = {1: menu_listar, 2: menu_registrar, 3: menu_principal}
self.__menu_dict = menus
return self.__menu_dict
class PanelPrincipal(tk.Frame):
"""Vista principal que es cargada cuando se verifica correctamente el acceso de los datos de usuario"""
__vista_actual = None
__controlador = ControladorLaboratorio()
def __init__(self, panel_master):
tk.Frame.__init__(self, panel_master)
self.__panel_master = panel_master
self.inicializar()
self.pack()
def get_controlador(self):
return self.__controlador
def inicializar(self):
#self.__panel_master.config(bg='skyblue')
self.__panel_master.geometry('800x600')
self.__panel_master.title("Reserva de Laboratorios")
menu_bar = tk.Menu(self.__panel_master)
self.__panel_master.config(menu=menu_bar)
informacion_menu = tk.Menu(menu_bar)
informacion_menu.add_command(label="Información",
command=self.informacion)
informacion_menu.add_command(label="Salir", command=self.salir)
informacion_menu.add_separator()
reservas_menu = tk.Menu(menu_bar)
reservas_menu.add_command(label="Reservar", command=self.reservar)
reservas_menu.add_command(label="Consultas", command=self.consultar)
reservas_menu.add_separator()
listar_laboratorio_menu = tk.Menu(menu_bar)
listar_laboratorio_menu.add_command(label='Listar Laboratorios',
command=self.listar_laboratorio)
docente_menu = tk.Menu(menu_bar)
docente_menu.add_command(label='Registrar Docente',
command=self.crear_docente)
laboratorio_menu = tk.Menu(menu_bar)
laboratorio_menu.add_command(label='Registrar Laboratorio',
command=self.crear_laboratorio)
funcionario_menu = tk.Menu(menu_bar)
funcionario_menu.add_command(label='Registrar Funcionario',
command=self.crear_funcionario)
funcionario_menu.add_command(label='Registrar Contacto',
command=self.crear_contacto)
menu_bar.add_cascade(label="Informacion", menu=informacion_menu)
menu_bar.add_cascade(label="Reservas y Consultas", menu=reservas_menu)
menu_bar.add_cascade(label='Lista de Laboratorios',
menu=listar_laboratorio_menu)
menu_bar.add_cascade(label='Docentes', menu=docente_menu)
menu_bar.add_cascade(label='Laboratorios', menu=laboratorio_menu)
menu_bar.add_cascade(label='Configuracion', menu=funcionario_menu)
'''llamo a la vista de reservas la cual pertirira crear reservas para los laboratorios'''
def reservar(self):
self.limpiar()
form = FormsReserva(self.__panel_master)
self.__vista_actual = form
def listar_laboratorio(self):
'''Lista los laboratorios registrados'''
self.limpiar()
lista = ListarLaboratorio(self.__panel_master)
self.__vista_actual = lista
def crear_docente(self):
'''Permite el registro de docentes'''
self.limpiar()
form = FormsDocente(self.__panel_master)
self.__vista_actual = form
def crear_laboratorio(self):
'''Permite el registro de laboratorios'''
self.limpiar()
form = FormsLaboratorio(self.__panel_master)
self.__vista_actual = form
def crear_funcionario(self):
'''Permite el registro de funcionarios'''
self.limpiar()
form = FormsFuncionario(self.__panel_master)
self.__vista_actual = form
def crear_contacto(self):
'''Permite el registro de contactos tanto para funcionarios y docentes'''
self.limpiar()
form = FormsContacto(self.__panel_master)
self.__vista_actual = form
def consultar(self):
self.limpiar()
form = FormsConsulta(self.__panel_master)
self.__vista_actual = form
def informacion(self):
self.limpiar()
form = Informacion(self.__panel_master)
self.__vista_actual = form
def salir(self):
self.quit()
def limpiar(self):
if self.__vista_actual:
self.__vista_actual.destroy()
def accion(self):
messagebox.showinfo("Info", "No implementado")