def abrir_ventana(self, archivo, clase):
if archivo.endswith('.py'): # Al importar no hay que indicar extensión
archivo = archivo[:archivo.rfind('.py')]
if clase == 'gajim' and archivo == 'gajim':
utils.escribir_barra_estado(self.statusbar,
"Iniciar: gajim...",
self.logger,
self.usuario.usuario)
self.abrir_gajim()
elif clase == 'acerca_de' and archivo == 'acerca_de':
utils.escribir_barra_estado(self.statusbar,
'Abrir: "acerca de..."',
self.logger,
self.usuario.usuario)
self.acerca_de()
elif 'usuario' in archivo:
utils.escribir_barra_estado(self.statusbar,
"Cargar: %s.py" % archivo,
self.logger,
self.usuario.usuario)
self.abrir_ventana_usuario(archivo)
elif "pruebas_periodicas" in clase:
utils.escribir_barra_estado(self.statusbar,
"Pruebas de coherencia de datos",
self.logger,
self.usuario.usuario)
self.abrir_pruebas_coherencia()
else:
utils.escribir_barra_estado(self.statusbar,
"Cargar: %s.py" % archivo,
self.logger,
self.usuario.usuario)
self.abrir_ventana_modulo_python(archivo, clase)
def mostrar_item_seleccionado(self, icon_view, model):
selected = icon_view.get_selected_items()
if len(selected) == 0: return
i = selected[0][0]
descripcion_icono_seleccionado = model[i][0]
descripcion_icono_seleccionado = descripcion_icono_seleccionado.replace('\n', ' ')
utils.escribir_barra_estado(self.statusbar, descripcion_icono_seleccionado, self.logger, self.usuario.usuario)
def _abrir(self, action):
"""
Abre la ventana de la entrada de menú recibida.
"""
import pclases, utils
idventana = int(action.get_name().replace("V", ""))
ventana = pclases.Ventana.get(idventana)
clase = ventana.clase
archivo = ventana.fichero
if archivo.endswith('.py'):
# Al importar no hay que indicar extensión
archivo = archivo[:archivo.rfind('.py')]
if clase == 'gajim' and archivo == 'gajim':
utils.escribir_barra_estado(self.wids['barra_estado'], "Iniciar: gajim...", self.logger, self.__usuario.usuario)
self.abrir_gajim()
elif clase == 'acerca_de' and archivo == 'acerca_de':
utils.escribir_barra_estado(self.wids['barra_estado'], 'Abrir: "acerca de..."', self.logger, self.__usuario.usuario)
self.acerca_de()
elif 'usuario' in archivo:
self.wids['ventana'].window.set_cursor(gtk.gdk.Cursor(gtk.gdk.WATCH))
utils.escribir_barra_estado(self.wids['barra_estado'], "Cargar: %s.py" % archivo, self.logger, self.__usuario.usuario)
exec "import %s" % archivo
v = None
gobject.timeout_add(100, self.volver_a_cursor_original)
if archivo == "usuarios":
v = usuarios.Usuarios(self.__usuario)
elif archivo == "ventana_usuario":
v = ventana_usuario.Usuarios(self.__usuario)
else:
try:
self.wids['ventana'].window.set_cursor(gtk.gdk.Cursor(gtk.gdk.WATCH))
utils.escribir_barra_estado(self.wids['barra_estado'], "Cargar: %s.py" % archivo, self.logger, self.__usuario.usuario)
while gtk.events_pending(): gtk.main_iteration(False)
try:
exec "reload(%s)" % archivo
except NameError:
exec "import %s" % archivo
v = None
gobject.timeout_add(100, self.volver_a_cursor_original)
# Solo se permite una instancia de cada tipo de ventana. It's not a bug. It's a feature! (sí, ya :P)
v = eval('%s.%s' % (archivo, clase))
v(usuario = self.__usuario)
except Exception, msg:
self.logger.error("ventana.py::_abrir -> Excepción importando fichero ventana: %s" % msg)
self.wids['ventana'].window.set_cursor(None)
utils.escribir_barra_estado(self.wids['barra_estado'], "Error detectado. Iniciando informe por correo.", self.logger, self.__usuario.usuario)
print "Se ha detectado un error"
texto = ''
for e in sys.exc_info():
texto += "%s\n" % e
tb = sys.exc_info()[2]
texto += "Línea %s\n" % tb.tb_lineno
from menu import Metaf, enviar_correo
info = Metaf()
import traceback
traceback.print_tb(tb, file = info)
texto += "%s\n" % info
enviar_correo(texto, self.__usuario)
def __init__(self, user = None, passwd = None):
"""
user: Usuario. Si es None se solicitará en la ventana de
autentificación.
passwd: Contraseña. Si es None, se solicitaré en la ventana de
autentificación.
Si user y passwd son distintos a None, no se mostrará la ventana de
autentificación a no ser que sean incorrectos.
"""
import gestor_mensajes, autenticacion
login = autenticacion.Autenticacion(user, passwd)
pclases = import_pclases()
if pclases.VERBOSE:
print "Cargando gestor de mensajes..."
self.logger = login.logger
if not login.loginvalido():
sys.exit(1)
self.usuario = login.loginvalido()
# Configuración del correo para informes de error:
if self.usuario.cuenta:
gtkexcepthook.feedback = self.usuario.cuenta
gtkexcepthook.password = self.usuario.cpass
if not self.usuario.smtpserver:
gtkexcepthook.smtphost = "smtp.gmail.com"
gtkexcepthook.ssl = True
gtkexcepthook.port = 587
else:
gtkexcepthook.smtphost = self.usuario.smtpserver
gtkexcepthook.ssl = False
gtkexcepthook.port = 25
gtkexcepthook.devs_to = "*****@*****.**"\
", [email protected]"
# Continúo con el gestor de mensajes y resto de ventana menú.
self.__gm = gestor_mensajes.GestorMensajes(self.usuario)
# DONE: Dividir la ventana en expansores con los módulos del programa
# (categorías) y dentro de ellos un IconView con los iconos de cada
# ventana. Poner también en lo alto del VBox el icono de la aplicación.
# (Ya va siendo hora de un poquito de eyecandy).
if pclases.VERBOSE:
print "Cargando menú principal..."
self.construir_ventana()
utils.escribir_barra_estado(self.statusbar,
"Menú iniciado",
self.logger,
self.usuario.usuario)
def on_select(self, icon_view, model=None):
pclases = import_pclases()
selected = icon_view.get_selected_items()
if len(selected) == 0: return
i = selected[0][0]
category = model[i][0]
if self.current_frame is not None:
self.content_box.remove(self.current_frame)
self.current_frame.destroy()
self.current_frame = None
if category != "Favoritos":
modulo = pclases.Modulo.select(
pclases.Modulo.q.nombre == category)[0]
else:
modulo = "Favoritos"
self.current_frame = self.create_frame(modulo)
utils.escribir_barra_estado(self.statusbar, category, self.logger, self.usuario.usuario)
self.content_box.pack_end(self.current_frame, fill=True, expand=True)
self.ventana.show_all()
def abrir_ventana_modulo_python(self, archivo, clase):
try:
self.ventana.window.set_cursor(gtk.gdk.Cursor(gtk.gdk.WATCH))
while gtk.events_pending(): gtk.main_iteration(False)
# HACK: Debe haber una forma mejor de hacerlo. De momento me
# aprovecho de que el mainloop no va a atender al
# timeout aunque se cumpla el tiempo, ya que está
# ocupado en abrir la ventana, con lo que el cursor
# sale del "busy" justo cuando debe, al abrirse la
# ventana.
v = None
gobject.timeout_add(100, self.volver_a_cursor_original)
# NOTA: OJO: TODO: Usuario harcoded. Cambiar en cuanto sea
# posible.
if ((self.get_usuario().usuario == "geotextil" or
self.get_usuario().usuario == "fibra" or
self.get_usuario().nivel >= 3)
and "partes_de_fabricacion" in archivo
and self.get_usuario().usuario != "cemento"):
exec "import %s" % archivo
v = eval('%s.%s' % (archivo, clase))
try:
v(permisos = "rx", usuario = self.get_usuario())
except TypeError: # La ventana no soporta el modelo
# antiguo de permisos.
v(usuario = self.get_usuario())
else:
try:
self.lanzar_ventana(archivo, clase)
except Exception, e:
print e
sys.stderr.write(`e`)
self._lanzar_ventana(archivo, clase)
except:
self.ventana.window.set_cursor(None)
utils.escribir_barra_estado(self.statusbar,
"Error detectado. Iniciando informe por correo.",
self.logger,
self.usuario.usuario)
self.enviar_correo_error_ventana()
def __init__(self, glade, objeto = None, usuario = None):
"""
Constructor.
glade es una cadena con el nombre del fichero .glade a cargar.
objeto es el objeto principal de la ventana.
Si usuario se recibe, se guarda en un atributo privado de la
clase que servirá únicamente para crear un menú superior en
la ventana con las opciones de menú disponibles para el usuario.
Si el usuario es None, no se crea ningún menú.
"""
if isinstance(usuario, int):
usuario = pclases.Usuario.get(usuario)
self.__usuario = usuario
self._is_fullscreen = False
import logging
self.logger = logging.getLogger('GINN')
hdlr = logging.FileHandler('ginn.log')
formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s')
hdlr.setFormatter(formatter)
self.logger.addHandler(hdlr)
# self.logger.setLevel(logging.INFO)
self.wids = Widgets(glade)
self.handlers_id = dict([(w, {}) for w in self.wids.keys()])
for w in self.wids.keys():
if isinstance(self.wids[w], gtk.Entry):
h_id = self.wids[w].connect("activate", self.refocus_entry)
try:
self.handlers_id[w]["activate"].append(h_id)
except KeyError:
self.handlers_id[w]["activate"] = [h_id]
config = ConfigConexion()
try:
self.wids['ventana'].set_border_width(5)
# TODO:Cambiar por uno correspondiente al logo de la configuración.
logo_xpm = gtk.gdk.pixbuf_new_from_file('logo_w.xpm')
self.wids['ventana'].set_icon(logo_xpm)
self.wids['barra_estado'] = gtk.Statusbar()
label_statusbar = self.wids['barra_estado'].get_children()[0].child
font = pango.FontDescription("Monospace oblique 7")
label_statusbar.modify_font(font)
label_statusbar.modify_fg(gtk.STATE_NORMAL,
label_statusbar.get_colormap().alloc_color("darkgray"))
contenido_anterior = self.wids['ventana'].get_child()
self.wids['ventana'].remove(contenido_anterior)
self.wids['contenedor_exterior'] = gtk.VBox()
self.wids['ventana'].add(self.wids['contenedor_exterior'])
self.wids['menu_superior'] = self.build_menu_superior()
self.wids['contenedor_exterior'].pack_start(
self.wids['menu_superior'], False)
self.wids['contenedor_exterior'].add(contenido_anterior)
self.wids['contenedor_exterior'].pack_end(
self.wids['barra_estado'], False)
self.wids['contenedor_exterior'].show()
self.wids['barra_estado'].show()
info_conexion = "%s://%s:xxxxxxxx@%s:%s/%s" % (config.get_tipobd(),
config.get_user(),
config.get_host(),
config.get_puerto(),
config.get_dbname())
info_usuario = ""
if hasattr(self, "usuario") and self.usuario != None:
info_usuario = " usuario: %s." % (self.usuario.usuario)
if self.__usuario != None:
info_usuario = " __usuario: %s." % (self.__usuario.usuario)
utils.escribir_barra_estado(self.wids['barra_estado'], "Conectado a %s.%s" % (info_conexion, info_usuario))
except Exception, msg:
txt = "ventana.py::__init__ -> No se pudo establecer ancho de borde, icono de ventana o barra de estado. Excepción: %s." % (msg)
self.logger.warning(txt)
def set_texto_estado(self, texto):
utils.escribir_barra_estado(self.barra_estado, texto)
def abrir(self, iview, path, model):
clase = model[path][3]
archivo = model[path][2]
pclases = import_pclases()
pclases.Estadistica.incrementar(self.usuario, archivo)
if archivo.endswith('.py'): # Al importar no hay que indicar extensión
archivo = archivo[:archivo.rfind('.py')]
if clase == 'gajim' and archivo == 'gajim':
utils.escribir_barra_estado(self.statusbar,
"Iniciar: gajim...",
self.logger,
self.usuario.usuario)
self.abrir_gajim()
elif clase == 'acerca_de' and archivo == 'acerca_de':
utils.escribir_barra_estado(self.statusbar,
'Abrir: "acerca de..."',
self.logger,
self.usuario.usuario)
self.acerca_de()
elif 'usuario' in archivo:
self.ventana.window.set_cursor(gtk.gdk.Cursor(gtk.gdk.WATCH))
utils.escribir_barra_estado(self.statusbar,
"Cargar: %s.py" % archivo,
self.logger,
self.usuario.usuario)
exec "import %s" % archivo
v = None
gobject.timeout_add(100, self.volver_a_cursor_original)
if archivo == "usuarios":
v = usuarios.Usuarios(self.get_usuario())
elif archivo == "ventana_usuario":
v = ventana_usuario.Usuarios(self.get_usuario())
elif "pruebas_periodicas" in clase:
self.abrir_pruebas_coherencia()
else:
try:
self.ventana.window.set_cursor(gtk.gdk.Cursor(gtk.gdk.WATCH))
utils.escribir_barra_estado(self.statusbar, "Cargar: %s.py" % archivo, self.logger, self.usuario.usuario)
while gtk.events_pending(): gtk.main_iteration(False)
try:
exec "reload(%s)" % archivo
# PLAN: Esto no funciona como esperaba debido a que aunque se cierre la ventana, hay
# referncias por ahí rulando y el reload no recompila y vuelve a cargar el módulo.
# Ver: http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/160164 o
# http://aspn.activestate.com/ASPN/Mail/Message/python-list/907876 y usar cuando lo
# tenga suficientemente testeado.
except NameError:
exec "import %s" % archivo
# HACK: Debe haber una forma mejor de hacerlo. De momento me aprovecho de que el mainloop no
# va a atender al timeout aunque se cumpla el tiempo, ya que está ocupado en abrir la
# ventna, con lo que el cursor sale del "busy" justo cuando debe, al abrirse la ventana.
v = None
gobject.timeout_add(100, self.volver_a_cursor_original)
v = eval('%s.%s' % (archivo, clase))
v(usuario = self.get_usuario())
# Podría incluso guardar los objetos ventana que se van
# abriendo para controlar... no sé, algo, contar las ventanas
# abiertas o algo.
except:
self.ventana.window.set_cursor(None)
utils.escribir_barra_estado(self.statusbar,
"Error detectado. Iniciando informe por correo.",
self.logger,
self.usuario.usuario)
print "Se ha detectado un error"
texto = ''
for e in sys.exc_info():
texto += "%s\n" % e
tb = sys.exc_info()[2]
texto += "Línea %s\n" % tb.tb_lineno
info = MetaF()
traceback.print_tb(tb, file = info)
texto += "%s\n" % info
enviar_correo(texto, self.get_usuario())
