def __init__(self, clase, objeto = None, usuario = None):
"""
Recibe la clase base para construir la ventana.
Opcionalmente recibe un objeto para mostrar en la misma y
el usuario registrado en el sistema.
Construye la ventana e inicia el bucle Gtk.
"""
self.usuario = usuario
self.clase = clase
self.objeto = objeto
ventana_marco = os.path.join('..', 'formularios', 'ventana_generica.glade')
Ventana.__init__(self, ventana_marco, objeto, usuario)
# Botones genéricos:
connections = {'b_salir/clicked': self.salir,
'b_actualizar/clicked': self.actualizar_ventana,
'b_nuevo/clicked': self.nuevo,
'b_borrar/clicked': self.borrar,
'b_buscar/clicked': self.buscar,
'b_guardar/clicked': self.guardar
}
self.add_connections(connections)
self.inicializar_ventana()
if self.objeto == None:
self.ir_a_primero()
else:
self.ir_a(self.objeto)
gtk.main()
def __init__(self, objeto = None, usuario = None):
"""
Constructor. objeto puede ser un objeto de pclases con el que
comenzar la ventana (en lugar del primero de la tabla, que es
el que se muestra por defecto).
"""
self.usuario = usuario
Ventana.__init__(self, 'albaranes_de_entrada_repuestos.glade', objeto, usuario = self.usuario)
connections = {'b_nuevo/clicked': self.crear_nuevo_albaran,
'b_actualizar/clicked': self.actualizar_ventana,
'b_guardar/clicked': self.guardar,
'b_buscar/clicked': self.buscar_albaran,
'b_fecha/clicked': self.buscar_fecha,
'b_add_ldv/clicked': self.add_repuesto,
'b_drop_ldv/clicked': self.drop_producto,
'b_add_pedido/clicked': self.add_pedido,
'b_borrar/clicked': self.borrar_albaran,
'b_imprimir/clicked': self.imprimir,
'b_salir/clicked': self.salir,
'cbe_almacen/changed': self.guardar
}
self.add_connections(connections)
self.inicializar_ventana()
if self.objeto == None:
self.ir_a_primero()
else:
self.ir_a(objeto)
gtk.main()
def __init__(self):
# self.generarVias()
self.ventana = Ventana({'ancho': self.anchoVentana, 'alto': self.alturaVentana})
# self.ventana.crearDesdeGrafo()
self.ventana.inicializar()
self.tiempomaximo = int(self.ventana.gui.tiempo) * 120
self.definirArea()
def __init__(self, objeto = None, usuario = None, fini = None, ffin = None):
"""
Constructor. objeto puede ser un objeto de pclases con el que
comenzar la ventana (en lugar del primero de la tabla, que es
el que se muestra por defecto).
"""
self.usuario = usuario
Ventana.__init__(self, 'facturacion_por_cliente_y_fechas.glade', objeto)
connections = {'b_salir/clicked': self.salir,
'b_imprimir/clicked': self.imprimir,
'cbe_cliente/changed': self.cambiar_cliente,
'b_fechaini/clicked': self.cambiar_fechaini,
'b_fechafin/clicked': self.cambiar_fechafin,
'b_export/clicked': self.exportar_a_csv, }
#'tv_facturas/row-expanded': self.expandir_subramas}
self.add_connections(connections)
self.wids['tv_facturas'].connect("row-expanded",
self.expandir_subramas)
self.inicializar_ventana()
if fini:
self.wids['e_fechaini'].set_text(utils.str_fecha(fini))
if ffin:
self.wids['e_fechafin'].set_text(utils.str_fecha(ffin))
if objeto != None:
utils.combo_set_from_db(self.wids['cbe_cliente'], objeto.id)
gtk.main()
def __init__(self, objeto = None, usuario = None):
"""
Constructor. objeto puede ser un objeto de pclases con el que
comenzar la ventana (en lugar del primero de la tabla, que es
el que se muestra por defecto).
"""
self.usuario = usuario
Ventana.__init__(self, 'up_consulta_clientes_por_mes.glade', objeto)
connections = {'b_salir/clicked': self.salir,
'b_buscar/clicked': self.buscar,
'b_imprimir/clicked': self.imprimir,
'b_fechainicio/clicked': self.set_inicio,
'b_fechafin/clicked': self.set_fin,
'b_exportar/clicked': self.exportar}
self.add_connections(connections)
cols = (('Mes', 'gobject.TYPE_STRING', False, True, False, None),
('Cliente', 'gobject.TYPE_STRING', False, True, True, None),
('Clases a las que asistió',
'gobject.TYPE_STRING', False, True, False, None),
('PUDI_cliente', 'gobject.TYPE_STRING',
False, False, False, None))
utils.preparar_treeview(self.wids['tv_datos'], cols)
col = self.wids['tv_datos'].get_column(2)
for cell in col.get_cell_renderers():
cell.set_property("xalign", 1)
hoy = datetime.date.today()
self.fechainicio = datetime.date(hoy.year, hoy.month, 1)
for i in range(28, 32):
try:
self.fechafin = datetime.date(hoy.year, hoy.month, i)
except ValueError:
pass
self.wids['e_fechainicio'].set_text(utils.str_fecha(self.fechainicio))
self.wids['e_fechafin'].set_text(utils.str_fecha(self.fechafin))
gtk.main()
def __init__(self, objeto = None, usuario = None):
"""
Constructor. objeto puede ser un objeto de pclases con el que
comenzar la ventana (en lugar del primero de la tabla, que es
el que se muestra por defecto).
"""
global fin
Ventana.__init__(self, 'consulta_albaranesFacturados.glade', objeto)
connections = {'b_salir/clicked': self.salir,
'b_buscar/clicked': self.buscar,
'b_imprimir/clicked': self.imprimir,
'b_fecha_inicio/clicked': self.set_inicio,
'b_fecha_fin/clicked': self.set_fin,
"b_exportar/clicked": self.exportar}
self.add_connections(connections)
cols = (('Fecha','gobject.TYPE_STRING', False, True, False, None),
('Nº Albarán','gobject.TYPE_STRING', False, True, True, None),
('Cliente','gobject.TYPE_STRING', False, True, False, None),
('Num. Factura','gobject.TYPE_STRING', False, True, False,None),
('Idalbaran','gobject.TYPE_INT64', False, False, False, None))
utils.preparar_listview(self.wids['tv_datos'], cols)
self.wids['tv_datos'].connect("row-activated", self.abrir_albaran)
temp = time.localtime()
self.fin = str(temp[0])+'/'+str(temp[1])+'/'+str(temp[2])
self.wids['e_fechafin'].set_text(utils.str_fecha(temp))
self.wids['rb_salida'].set_active(True)
gtk.main()
def __init__(self, objeto = None, usuario = None):
"""
Constructor. objeto puede ser un objeto de pclases con el que
comenzar la ventana (en lugar del primero de la tabla, que es
el que se muestra por defecto).
"""
self.usuario = usuario
Ventana.__init__(self, 'resultados_fibra.glade', objeto, usuario = usuario)
connections = {'b_salir/clicked': self._salir,
'b_lote/clicked': self.set_loteCem,
'b_fecha/clicked': self.fecha,
'b_add/clicked': self.add,
'b_drop/clicked': self.drop,
'sp_tolerancia/value-changed': self.cambiar_tolerancia,
'b_guardar_obs/clicked': self.guardar_obs,
'b_imprimir/clicked': self.imprimir,
'ventana/delete_event': self._salir
}
self.add_connections(connections)
self.activar_widgets(False)
self.inicializar_ventana()
if objeto == None:
self.loteCem = None
else:
self.loteCem = objeto
self.actualizar_ventana()
gtk.main()
def __init__(self, objeto = None, usuario = None):
"""
Constructor. objeto puede ser un objeto de pclases con el que
comenzar la ventana (en lugar del primero de la tabla, que es
el que se muestra por defecto).
"""
self.usuario = usuario
Ventana.__init__(self, 'tarifas_de_precios.glade', objeto, usuario = usuario)
connections = {'b_salir/clicked': self.salir,
'b_nueva_tarifa/clicked': self.crear_nueva_tarifa,
'b_anadir_producto_tarifa/clicked':
self.annadir_producto_a_tarifa,
'b_borrar_producto_tarifa/clicked':
self.borrar_producto_de_tarifa,
'b_borrar_tarifa/clicked': self.borrar_tarifa_actual,
'cb_nombre_tarifa/changed': self.seleccionar_tarifa,
'b_cambiar_nombre_tarifa/clicked':
self.cambiar_nombre_tarifa,
'b_actualizar/clicked': self.actualizar,
'b_guardar/clicked': self.guardar,
'b_imprimir/clicked': self.imprimir,
'b_periodo_validez_ini/clicked': self.set_validez,
'b_periodo_validez_fin/clicked': self.set_validez
}
self.add_connections(connections)
self.inicializar_ventana()
gtk.main()
def __init__(self, objeto = None, usuario = None):
self.usuario = usuario
Ventana.__init__(self, 'horas_trabajadas_dia.glade', objeto, usuario = usuario)
connections = {'b_salir/clicked': self.salir,
'b_fecha/clicked': self.set_fecha,
'b_consultar/clicked': self.rellenar_horas,
'b_actualizar/clicked': self.actualizar,
'b_imprimir/clicked': self.imprimir,
'b_exportar/clicked': self.exportar}
self.add_connections(connections)
cols = (('Empleado', 'gobject.TYPE_STRING', False, True, True, None),
('Centro trabajo', 'gobject.TYPE_STRING', False, True, False, None),
('H. inicio','gobject.TYPE_STRING', False, True, False, None),
('H. fin','gobject.TYPE_STRING', False, True, False, None),
('Total hrs.','gobject.TYPE_STRING', False, True, False, None),
('Nocturnidad','gobject.TYPE_BOOLEAN', False, True, False, None),
('H. extra','gobject.TYPE_STRING', False, True, False, None),
('Prod. gtx.','gobject.TYPE_STRING', False, True, False, None),
('Prod. fibra','gobject.TYPE_STRING', False, True, False, None),
('Prod. geocomp.','gobject.TYPE_STRING', False, True, False, None),
('Mant. gtx.','gobject.TYPE_STRING', False, True, False, None),
('Mant. fibra','gobject.TYPE_STRING', False, True, False, None),
('Mant. geocomp.','gobject.TYPE_STRING', False, True, False, None),
('Almacén','gobject.TYPE_STRING', False, True, False, None),
('Varios','gobject.TYPE_STRING', False, True, False, None),
('Observaciones','gobject.TYPE_STRING', False, True, False, None),
('ID', 'gobject.TYPE_INT64', False, False, False, None))
utils.preparar_treeview(self.wids['tv_horas'], cols)
self.wids['e_fecha'].set_text(mx.DateTime.localtime().strftime('%d/%m/%Y'))
self.wids['tv_horas'].connect('row-activated', self.abrir_item)
self.rellenar_horas()
self.colorear()
gtk.main()
def __init__(self, objeto = None, usuario = None):
"""
Constructor. objeto puede ser un objeto de pclases con el que
comenzar la ventana (en lugar del primero de la tabla, que es
el que se muestra por defecto).
"""
Ventana.__init__(self, 'ventana_usuario.glade', objeto)
connections = {'b_salir/clicked': self.salir,
'b_actualizar/clicked': self.actualizar_ventana,
'b_guardar/clicked': self.guardar,
'b_nuevo/clicked': self.crear_nuevo_usuario,
'b_borrar/clicked': self.borrar_usuario,
'b_buscar/clicked': self.buscar_usuario,
'b_enviar/clicked': self.enviar_mensaje,
'b_passw/clicked': self.nueva_contrasenna,
'b_drop/clicked': self.borrar_mensaje
}
self.add_connections(connections)
self.inicializar_ventana()
if self.objeto == None:
self.ir_a_primero()
utils.dialogo_info(titulo = "NO SE PUDO DETERMINAR SU USUARIO",
texto = "No se pudo determinar su nombre de usuario.\nAsegúrese de haber iniciado sesión correctamente y vuelva a intentarlo.",
padre = self.wids['ventana'])
self.logger.error("ventana_usuario::__init__:No se pudo determinar nombre de usuario.")
else:
self.ir_a(objeto)
self.wids['ventana'].maximize()
gtk.main()
def __init__(self, objeto = None, usuario = None):
"""
Constructor. objeto puede ser un objeto de pclases con el que
comenzar la ventana (en lugar del primero de la tabla, que es
el que se muestra por defecto).
"""
self.usuario = usuario
Ventana.__init__(self, 'lineas_sin_pedido.glade', objeto)
connections = {'b_salir/clicked': self.salir,
'b_agregar/clicked': self.crear_nuevo_pedido,
'b_borrar/clicked': self.eliminar_linea_sin_pedido,
'b_modificar/clicked': self.agregar_a_pedido}
self.add_connections(connections)
cols = [('Nombre','gobject.TYPE_STRING',False,True,False,None),
('Descripción','gobject.TYPE_STRING',False,True,False,None),
('Cantidad','gobject.TYPE_DOUBLE',False,True,False,None),
('Fecha Hora','gobject.TYPE_STRING',False,True,False,None),
('Albarán', 'gobject.TYPE_STRING', False, True, False, None),
('Factura', 'gobject.TYPE_STRING', False, True, False, None),
('Idlinea_sin_pedido','gobject.TYPE_INT64',False,False,False,None)]
if pclases.Ticket.select().count():
cols.insert(-2, ('Ticket', 'gobject.TYPE_STRING', False, True, False, None))
utils.preparar_listview(self.wids['tv_tipos'], cols)
self.rellenar_tabla()
gtk.main()
def __init__(self, objeto = None, usuario = None):
"""
Constructor. objeto puede ser un objeto de pclases con el que
comenzar la ventana (en lugar del primero de la tabla, que es
el que se muestra por defecto).
"""
Ventana.__init__(self, 'lab_resultados_lote.glade', objeto)
connections = {'b_salir/clicked': self.salir,
'b_lote/clicked': self.lote,
'b_add_elongacion/clicked': self.add_elongacion,
'b_drop_elongacion/clicked': self.drop_elongacion,
'b_add_tenacidad/clicked': self.add_tenacidad,
'b_drop_tenacidad/clicked': self.drop_tenacidad,
'b_add_encogimiento/clicked': self.add_encogimiento,
'b_drop_encogimiento/clicked': self.drop_encogimiento,
'b_calcular/clicked': self.calcular
}
self.add_connections(connections)
self.ws = ['e_rizo_entrada','b_add_elongacion','b_drop_elongacion','b_add_tenacidad','b_drop_tenacidad','b_add_encogimiento','b_drop_encogimiento','b_calcular']
self.activar_widgets(self.ws,False)
self.inicializar_ventana()
self.lote = None
self.rizo = []
self.tenacidad = []
self.elongacion = []
self.encogimiento = []
gtk.main()
def __init__(self, objeto = None, usuario = None):
"""
Constructor. objeto puede ser un objeto de pclases con el que
comenzar la ventana (en lugar del primero de la tabla, que es
el que se muestra por defecto).
"""
self.usuario = usuario
Ventana.__init__(self, 'contadores.glade', objeto, usuario = usuario)
connections = {'b_salir/clicked': self.salir,
'b_agregar/clicked': self.crear_nuevo_contador,
'b_borrar/clicked': self.eliminar_contador,
'b_modificar/clicked': self.modificar_contador,
'b_actualizar_contador/clicked': self.cambiar_contador}
self.add_connections(connections)
cols = (('Prefijo', 'gobject.TYPE_STRING', False, True, False, None),
('Valor actual', 'gobject.TYPE_STRING',
True, True, False, self.cambiar_valor_contador),
('Sufijo', 'gobject.TYPE_STRING',
False, True, False, None),
('Siguiente factura', 'gobject.TYPE_STRING',
False, True, False, None),
('Última creada', 'gobject.TYPE_STRING',
False, True, False, None),
('Fecha última factura', 'gobject.TYPE_STRING',
False, True, False, None),
('Facturas de la serie', 'gobject.TYPE_INT64',
False, True, False, None),
('Clientes asignados', 'gobject.TYPE_INT64',
False, True, False, None),
('Idcontador', 'gobject.TYPE_INT64', False, False, False, None))
utils.preparar_listview(self.wids['tv_tipos'], cols)
self.rellenar_widgets()
gtk.main()
def __init__(self, objeto = None, usuario = None):
"""
Constructor. objeto puede ser un objeto de pclases con el que
comenzar la ventana (en lugar del primero de la tabla, que es
el que se muestra por defecto).
"""
self.usuario = usuario
Ventana.__init__(self, 'listado_balas.glade', objeto)
connections = {'b_salir/clicked': self.salir,
'b_fecha_inicio/clicked': self.set_inicio,
'b_fecha_fin/clicked': self.set_fin,
'b_buscar/clicked': self.buscar_balas,
'b_imprimir/clicked': self.imprimir,
'b_etiquetas/clicked': self.etiquetar,
'b_exportar/clicked': self.exportar}
self.add_connections(connections)
cols = (('Código', 'gobject.TYPE_STRING', False, True, False, None),
('Fecha Fab.','gobject.TYPE_STRING',False,True,False,None),
('Peso', 'gobject.TYPE_STRING', False, True, False, None),
('Lote','gobject.TYPE_STRING',False,True,False,None),
('Albarán','gobject.TYPE_STRING',False,True,False,None),
('Partida','gobject.TYPE_STRING',False,True,False,None),
('Analizada', 'gobject.TYPE_BOOLEAN',False,True,False,None),
('Clase B', 'gobject.TYPE_BOOLEAN', False, True, False, None),
('Almacén', 'gobject.TYPE_STRING', False, True, False, None),
('PUID', 'gobject.TYPE_STRING', False, False, False, None))
utils.preparar_treeview(self.wids['tv_balas'], cols)
self.wids['tv_balas'].get_selection().set_mode(gtk.SELECTION_MULTIPLE)
self.wids['tv_balas'].connect("row-activated", abrir_trazabilidad,
self.usuario)
temp = time.localtime()
self.fin = mx.DateTime.localtime()
self.inicio = None
self.wids['e_fechafin'].set_text(utils.str_fecha(temp))
gtk.main()
def __init__(self, objeto = None, usuario = None):
"""
Constructor. objeto puede ser un objeto de pclases con el que
comenzar la ventana (en lugar del primero de la tabla, que es
el que se muestra por defecto).
"""
global fin
Ventana.__init__(self, 'consulta_albaranes_clientes.glade', objeto)
connections = {'b_salir/clicked': self.salir,
'b_buscar/clicked': self.buscar,
'b_imprimir/clicked': self.imprimir,
'b_fecha_inicio/clicked': self.set_inicio,
'b_fecha_fin/clicked': self.set_fin,
'b_exportar/clicked': self.exportar}
self.add_connections(connections)
utils.rellenar_lista(self.wids['cmbe_cliente'], [(c.id, c.nombre) for c in pclases.Cliente.select(orderBy='nombre')])
cols = (('Cliente','gobject.TYPE_STRING',False,True,False,None),
('Fecha','gobject.TYPE_STRING',False,True,False,None),
('Albarán','gobject.TYPE_STRING',False,True,False,None),
('Destinatario','gobject.TYPE_STRING',False,True,False,None),
('Facturado', 'gobject.TYPE_BOOLEAN', False, True, False, None),
('Facturas', 'gobject.TYPE_STRING', False, True, False, None),
('Idalbaran','gobject.TYPE_INT64',False,False,False,None))
utils.preparar_listview(self.wids['tv_datos'], cols)
self.wids['tv_datos'].connect("row-activated", self.abrir_albaran)
temp = time.localtime()
self.fin = str(temp[0])+'/'+str(temp[1])+'/'+str(temp[2])
self.wids['e_fechafin'].set_text(utils.str_fecha(temp))
gtk.main()
def __init__(self, objeto = None, usuario = None):
"""
Constructor. objeto puede ser un objeto de pclases con el que
comenzar la ventana (en lugar del primero de la tabla, que es
el que se muestra por defecto).
"""
self.usuario = usuario
global fin
Ventana.__init__(self, 'listado_productos.glade', objeto, usuario = usuario)
connections = {'b_salir/clicked': self.salir,
'b_limpiar/clicked': self.limpiar_tv,
'b_buscar/clicked': self.buscar,
'b_imprimir/clicked': self.imprimir,
'b_exportar/clicked': self.exportar}
self.add_connections(connections)
cols = (('Código', 'gobject.TYPE_STRING', False, True, False, None),
('Descripción', 'gobject.TYPE_STRING', False,True,False,None),
('PVP', 'gobject.TYPE_STRING', False,True,False,None),
('ID', 'gobject.TYPE_STRING', False, False, False, None))
utils.preparar_listview(self.wids['tv_datos'], cols)
col = self.wids['tv_datos'].get_column(2)
for cell in col.get_cell_renderers():
cell.set_property("xalign", 1)
self.wids['tv_datos'].connect("row-activated", self.abrir_producto)
self.wids['e_buscar'].grab_focus()
gtk.main()
def __init__(self, objeto = None, usuario = None):
"""
Constructor. objeto puede ser un objeto de pclases con el que
comenzar la ventana (en lugar del primero de la tabla, que es
el que se muestra por defecto).
"""
self.usuario = usuario
Ventana.__init__(self, 'consulta_facturas_sin_doc_pago.glade',
objeto)
connections = {'b_salir/clicked': self.salir,
'b_buscar/clicked': self.buscar,
'b_imprimir/clicked': self.imprimir,
'b_exportar/clicked': self.exportar,
'b_fechaini/clicked': self.set_fecha_ini,
'b_fechafin/clicked': self.set_fecha_fin}
self.add_connections(connections)
cols = [('Cliente', 'gobject.TYPE_STRING', False, True, False, None),
('Nº. Factura', 'gobject.TYPE_STRING', False, True, True, None),
('Fecha', 'gobject.TYPE_STRING', False, True, False, None),
('Vencimiento', 'gobject.TYPE_STRING',False,True,False,None),
("Importe pendiente", "gobject.TYPE_STRING",
False, True, False, None),
#("Contacto", "gobject.TYPE_STRING", False, True, False, None),
('idvto', 'gobject.TYPE_INT64', False, False, False, None)]
utils.preparar_treeview(self.wids['tv_datos'], cols)
self.wids['tv_datos'].connect("row-activated", self.abrir_factura)
self.wids['tv_datos'].get_column(4).get_cell_renderers()[0].set_property('xalign', 1)
self.wids['tv_datos'].get_column(3).get_cell_renderers()[0].set_property('xalign', 0.5)
#self.wids['ventana'].maximize()
self.wids['e_fechaini'].set_text("")
self.wids['e_fechafin'].set_text(
utils.str_fecha(mx.DateTime.localtime()))
gtk.main()
def __init__(self, objeto = None, usuario = None):
"""
Constructor. objeto puede ser un objeto de pclases con el que
comenzar la ventana (en lugar del primero de la tabla, que es
el que se muestra por defecto).
"""
global fin
Ventana.__init__(self, 'consulta_entradas_almacen.glade', objeto)
connections = {'b_salir/clicked': self.salir,
'b_buscar/clicked': self.buscar,
'b_imprimir/clicked': self.imprimir,
'b_fecha_inicio/clicked': self.set_inicio,
'b_producto/clicked': self.buscar_producto,
'b_fecha_fin/clicked': self.set_fin}
self.add_connections(connections)
utils.rellenar_lista(self.wids['cmbe_proveedor'], [(c.id, c.nombre) for c in pclases.Proveedor.select(orderBy='nombre')])
cols = (('Proveedor', 'gobject.TYPE_STRING', False, True, False, None),
('Albarán', 'gobject.TYPE_STRING', False, True, True, None),
('Fecha', 'gobject.TYPE_STRING', False, True, False, None),
('Producto', 'gobject.TYPE_STRING', False, True, True, None),
('Cantidad', 'gobject.TYPE_FLOAT', False, True, False, None),
('Precio', 'gobject.TYPE_FLOAT', False, True, False, None),
('Subtotal', 'gobject.TYPE_FLOAT', False, True, False, None),
('idldc','gobject.TYPE_STRING',False,False,False,None))
utils.preparar_listview(self.wids['tv_datos'], cols)
for ncol in (4, 5, 6):
col = self.wids['tv_datos'].get_column(ncol)
for cell in col.get_cell_renderers():
cell.set_property("xalign", 1)
temp = time.localtime()
self.fin = datetime.date(day = temp[2], month = temp[1], year = temp[0])
self.wids['e_fechafin'].set_text(utils.str_fecha(temp))
self.producto = None
gtk.main()
def __init__(self, objeto = None, usuario = None):
"""
Constructor. objeto puede ser un objeto de pclases con el que
comenzar la ventana (en lugar del primero de la tabla, que es
el que se muestra por defecto).
"""
self.usuario = usuario
self.clase = self.CLASE
Ventana.__init__(self, self.VENTANA, objeto)
self.dic_campos = self.__build_dic_campos()
self.adaptador = adapter.adaptar_clase(self.clase, self.dic_campos)
connections = {'b_salir/clicked': self.salir,
'b_nuevo/clicked': self.nuevo,
'b_borrar/clicked': self.borrar,
'b_actualizar/clicked': self.actualizar_ventana,
'b_guardar/clicked': self.guardar,
'b_buscar/clicked': self.buscar,
# XXX: Más widgets y señales si se necesitan.
}
self.add_connections(connections)
self.inicializar_ventana()
if self.objeto == None:
self.ir_a_primero()
else:
self.ir_a(objeto)
gtk.main()
def __init__(self, user = None, passwd = None):
"""
Constructor.
"""
Ventana.__init__(self, 'autenticacion.glade', None)
connections = {'b_aceptar/clicked': self.login_from_ventana,
'e_usuario/activate': self.pasar_a_pass,
'e_passwd/activate': self.login_from_ventana,
'b_cancelar/clicked': self.salir
}
self.add_connections(connections)
self.wids['e_usuario'].grab_focus()
self.wids['image1'].set_from_file(
os.path.join('..', 'imagenes', 'llave.png'))
self.contador = 0 # Contador de intentos fallidos
self.__success = False
self.__usuario = None
if user != None and passwd != None:
self.__success, self.__usuario = self.do_login(user, passwd)
else:
if user != None:
self.wids['e_usuario'].set_text(user)
self.wids['e_passwd'].grab_focus()
if passwd != None:
self.wids['e_passwd'].set_text(passwd)
if self.__success:
self.wids['ventana'].hide()
else:
gtk.main()
def __init__(self, objeto = None, usuario = None):
"""
Constructor. objeto puede ser un objeto de pclases con el que
comenzar la ventana (en lugar del primero de la tabla, que es
el que se muestra por defecto).
"""
self.usuario = usuario
self.clase = pclases.CuentaOrigen
self.dic_campos = {"nombre": "e_nombre",
"banco": "e_banco",
"ccc": "e_ccc",
"observaciones": "e_observaciones",
"contacto": "e_contacto",
"fax": "e_fax",
"telefono": "e_telefono"}
Ventana.__init__(self, 'cuentas_origen.glade', objeto)
connections = {'b_salir/clicked': self.salir,
'b_nuevo/clicked': self.nuevo,
'b_borrar/clicked': self.borrar,
'b_actualizar/clicked': self.actualizar_ventana,
'b_guardar/clicked': self.guardar,
'b_buscar/clicked': self.buscar
}
self.add_connections(connections)
self.inicializar_ventana()
if self.objeto == None:
self.ir_a_primero()
else:
self.ir_a(objeto)
gtk.main()
def __init__(self, objeto = None, usuario = None):
"""
Constructor. objeto puede ser un objeto de pclases con el que
comenzar la ventana (en lugar del primero de la tabla, que es
el que se muestra por defecto).
"""
self.usuario = usuario
Ventana.__init__(self, 'listado_rollos_defectuosos.glade', objeto)
connections = {'b_salir/clicked': self.salir,
'b_fecha_inicio/clicked': self.set_inicio,
'b_fecha_fin/clicked': self.set_fin,
'b_buscar/clicked': self.buscar_rollos,
'b_imprimir/clicked': self.imprimir,
'b_etiquetas/clicked': self.etiquetar,
'b_exportar/clicked': self.exportar
}
self.add_connections(connections)
cols = (('Código rollo','gobject.TYPE_STRING',False,True,False,None),
('Fecha Fab.','gobject.TYPE_STRING',False,True,False,None),
('Fecha parte.','gobject.TYPE_STRING',False,True,False,None),
('Partida','gobject.TYPE_STRING',False,True,False,None),
('Albarán','gobject.TYPE_STRING',False,True,False,None),
('Metros l.', 'gobject.TYPE_STRING', False, True, False, None),
('Id','gobject.TYPE_INT64',False,False,False,None))
utils.preparar_treeview(self.wids['tv_rollos'], cols)
self.wids['tv_rollos'].get_selection().set_mode(gtk.SELECTION_MULTIPLE)
self.wids['tv_rollos'].connect("row-activated", self.mostrar_rollo)
self.colorear(self.wids['tv_rollos'])
self.wids['tv_rollos'].connect("cursor-changed", self.mostrar_hora_parte)
# self.rellenar_tabla()
temp = time.localtime()
self.fin = mx.DateTime.localtime()
self.inicio = None
self.wids['e_fechafin'].set_text(utils.str_fecha(temp))
gtk.main()
def __init__(self, objeto = None, usuario = None):
"""
Constructor. objeto puede ser un objeto de pclases con el que
comenzar la ventana (en lugar del primero de la tabla, que es
el que se muestra por defecto).
"""
self.usuario = usuario
global fin
Ventana.__init__(self, 'consulta_pedidos_clientes.glade', objeto, usuario = usuario)
connections = {'b_salir/clicked': self.salir,
'b_buscar/clicked': self.buscar,
'b_imprimir/clicked': self.imprimir,
'b_fecha_inicio/clicked': self.set_inicio,
'b_fecha_fin/clicked': self.set_fin,
'b_exportar/clicked': self.exportar}
self.add_connections(connections)
utils.rellenar_lista(self.wids['cmbe_cliente'], [(c.id, c.nombre) for c in pclases.Cliente.select(orderBy='nombre')])
cols = (('Código', 'gobject.TYPE_STRING', False, True, False, None),
('Descripción', 'gobject.TYPE_STRING', False,True,False,None),
('Precio s/IVA', 'gobject.TYPE_STRING', False,True,False,None),
('ID', 'gobject.TYPE_STRING', False, False, False, None))
utils.preparar_listview(self.wids['tv_datos'], cols)
col = self.wids['tv_datos'].get_column(2)
for cell in col.get_cell_renderers():
cell.set_property("xalign", 1)
self.wids['tv_datos'].connect("row-activated", self.abrir_producto)
temp = time.localtime()
self.fin = str(temp[0])+'/'+str(temp[1])+'/'+str(temp[2])
self.wids['e_fecha_fin'].set_text(utils.str_fecha(temp))
if objeto != None:
utils.combo_set_from_db(self.wids["cmbe_cliente"], objeto.id)
self.wids["b_buscar"].clicked()
self.wids['hbox4'].set_property("visible", False)
self.wids['ventana'].set_title("Productos facturados al cliente")
gtk.main()
def __init__(self, objeto = None, usuario = None):
Ventana.__init__(self, 'consulta_beneficio.glade', objeto)
connections = {'b_salir/clicked': self.salir,
'b_buscar/clicked': self.buscar,
'b_imprimir/clicked': self.imprimir,
'b_exportar/clicked': self.exportar,
'b_fecha_inicio/clicked': self.set_inicio,
'b_fecha_fin/clicked': self.set_fin}
self.add_connections(connections)
cols = (('Fecha','gobject.TYPE_STRING', False, True, False, None),
('Nº Factura','gobject.TYPE_STRING', False, True, True, None),
('Cliente','gobject.TYPE_STRING', False, True, False, None),
('Importe','gobject.TYPE_STRING', False, True, False, None),
('Base imponible','gobject.TYPE_STRING',
False, True, False, None),
('Beneficio sobre tarifa','gobject.TYPE_STRING',
False, True, False, None),
('Idfactura','gobject.TYPE_INT64', False, False, False, None))
utils.preparar_treeview(self.wids['tv_datos'], cols)
for col in (self.wids['tv_datos'].get_columns()[0:2]
+ self.wids['tv_datos'].get_columns()[3:]):
for cell in col.get_cell_renderers():
cell.set_property("xalign", 1.0)
col.set_alignment(0.5)
self.fin = datetime.date.today()
self.inicio = datetime.date(day = 1, month = self.fin.month, year = self.fin.year)
self.wids['e_fechafin'].set_text(utils.str_fecha(self.fin))
self.wids['e_fechainicio'].set_text(utils.str_fecha(self.inicio))
gtk.main()
def __init__(self, objeto = None, usuario = None):
self.usuario = usuario
Ventana.__init__(self, 'consulta_ventas_ticket.glade', objeto, usuario = usuario)
connections = {'b_salir/clicked': self.salir,
'b_buscar/clicked': self.buscar,
'b_imprimir/clicked': self.imprimir,
'b_exportar/clicked': self.exportar,
'b_fecha_inicio/clicked': self.set_inicio,
'b_fecha_fin/clicked': self.set_fin}
self.add_connections(connections)
cols = (('Fecha', 'gobject.TYPE_STRING', False, True, False, None),
('Ticket', 'gobject.TYPE_STRING',False,True,True,None),
('Imp. total', 'gobject.TYPE_STRING',False,True,False,None),
('Imp. (s/IVA)','gobject.TYPE_STRING',False,True,False,None),
('Ben. sobre tarifa', 'gobject.TYPE_STRING',
False, True, False, None),
('ID','gobject.TYPE_STRING', False, False, False, None))
utils.preparar_treeview(self.wids['tv_datos'], cols)
for col in self.wids['tv_datos'].get_columns()[2:]:
for cell in col.get_cell_renderers():
cell.set_property("xalign", 1.0)
col.set_alignment(0.5)
self.wids['tv_datos'].connect("row-activated", self.abrir_producto)
self.fin = mx.DateTime.today()
#self.inicio = mx.DateTime.DateTimeFrom(day = 1, month = self.fin.month, year = self.fin.year)
self.inicio = self.fin
self.wids['e_fechafin'].set_text(utils.str_fecha(self.fin))
self.wids['e_fechainicio'].set_text(utils.str_fecha(self.inicio))
self.wids['hbox1'].set_property("visible", False)
self.wids['hbox6'].set_property("visible", False)
gtk.main()
def __init__(self, objeto = None, usuario = None):
"""
Constructor. objeto puede ser un objeto de pclases con el que
comenzar la ventana (en lugar del primero de la tabla, que es
el que se muestra por defecto).
"""
self.usuario = usuario
Ventana.__init__(self, 'usuarios.glade', objeto, usuario=self.usuario)
connections = {'b_salir/clicked': self.salir,
'b_actualizar/clicked': self.actualizar_ventana,
'b_guardar/clicked': self.guardar,
'b_nuevo/clicked': self.crear_nuevo_usuario,
'b_borrar/clicked': self.borrar_usuario,
'b_buscar/clicked': self.buscar_usuario,
'b_enviar/clicked': self.enviar_mensaje,
'b_passw/clicked': self.nueva_contrasenna,
'b_drop/clicked': self.borrar_mensaje,
'b_modulo_clean/clicked': self.limpiar_modulo,
'b_ventana_clean/clicked': self.limpiar_ventana,
'b_add_vm/clicked': self.add_ventana_a_modulo,
'b_add_modulo/clicked': self.add_modulo,
'b_drop_modulo/clicked': self.drop_modulo,
'b_add_ventana/clicked': self.add_ventana,
'b_drop_ventana/clicked': self.drop_ventana
}
self.add_connections(connections)
self.inicializar_ventana()
if self.objeto == None:
self.ir_a_primero()
else:
self.ir_a(objeto)
# self.wids['ventana'].maximize()
self.wids['ventana'].resize(800, 600)
self.rellenar_tab_modulos() # Esto siempre debe hacerse al menos 1 vez aunque no haya usuarios.
gtk.main()
def __init__(self, objeto = None, usuario = None):
"""
Constructor. objeto puede ser un objeto de pclases con el que
comenzar la ventana (en lugar del primero de la tabla, que es
el que se muestra por defecto).
"""
self.usuario = usuario
self._objetoreciencreado = None
Ventana.__init__(self, 'productos_de_venta_rollos_geocompuestos.glade', objeto, usuario = usuario)
connections = {'b_salir/clicked': self.salir,
'b_anterior/clicked':self.ir_a_anterior,
'b_siguiente/clicked':self.ir_a_siguiente,
'b_contar/clicked' : self.muestra_stock,
'b_fichas/clicked': self.ver_ficha,
'b_articulos/clicked': self.ver_articulos,
'b_tarifas/clicked': self.ver_tarifas,
'b_nuevo/clicked': self.crear_nuevo_producto,
'b_borrar/clicked': self.borrar_producto,
'b_actualizar/clicked': self.actualizar_ventana,
'b_guardar/clicked': self.guardar,
'b_add_campoesp/clicked': self.add_campoesp,
'b_drop_campoesp/clicked': self.drop_campoesp,
'b_change_campoesp/clicked': self.change_campoesp,
'b_buscar/clicked': self.buscar_producto}
self.add_connections(connections)
self.inicializar_ventana()
if self.objeto == None:
self.ir_a_primero()
else:
self.ir_a(objeto)
gtk.main()
def __init__(self, objeto = None, usuario = None):
"""
Constructor. objeto puede ser un objeto de pclases con el que
comenzar la ventana (en lugar del primero de la tabla, que es
el que se muestra por defecto).
"""
self.usuario = usuario
self.clase = pclases.CuentaDestino
self.dic_campos = {"nombre": "e_nombre",
"observaciones": "e_observaciones",
"banco": "e_banco",
"swif": "e_swif",
"iban": "e_iban",
"cuenta": "e_cuenta",
"nombreBanco": "e_nombre_banco",
"proveedorID": "cbe_proveedor",
}
Ventana.__init__(self, 'cuentas_destino.glade', objeto)
connections = {'b_salir/clicked': self.salir,
'b_nuevo/clicked': self.nuevo,
'b_borrar/clicked': self.borrar,
'b_actualizar/clicked': self.actualizar_ventana,
'b_guardar/clicked': self.guardar,
'b_buscar/clicked': self.buscar
}
self.add_connections(connections)
self.inicializar_ventana()
if self.objeto == None:
self.ir_a_primero()
else:
self.ir_a(objeto)
gtk.main()
def __init__(self, objeto = None, usuario = None):
"""
Constructor. objeto puede ser un objeto de pclases con el que
comenzar la ventana (en lugar del primero de la tabla, que es
el que se muestra por defecto).
"""
self.usuario = usuario
self.clase = pclases.Pago
self.dic_campos = {"importe": "e_importe",
"proveedorID": "cbe_proveedor",
"cuentaOrigenID": "cbe_origen",
"cuentaDestinoID": "cbe_destino",
"fecha": "e_fecha",
"conceptoLibre": "e_concepto",
}
Ventana.__init__(self, 'transferencias.glade', objeto)
connections = {'b_salir/clicked': self.salir,
'b_nuevo/clicked': self.nuevo,
'b_borrar/clicked': self.borrar,
'b_actualizar/clicked': self.actualizar_ventana,
'b_guardar/clicked': self.guardar,
'b_buscar/clicked': self.buscar,
'b_fecha/clicked': self.set_fecha,
'b_factura/clicked': self.set_factura,
'b_imprimir/clicked': self.imprimir,
'b_nuevo_destino/clicked': self.crear_nueva_cuenta_destino
}
self.add_connections(connections)
self.inicializar_ventana()
if self.objeto == None:
self.ir_a_primero()
else:
self.ir_a(objeto)
gtk.main()
def __init__(self, objeto = None, usuario = None, fecha = None):
"""
Constructor. objeto puede ser un objeto de pclases con el que
comenzar la ventana (en lugar del primero de la tabla, que es
el que se muestra por defecto).
"""
if not isinstance(objeto, (list, tuple)):
self.lista_empleados = [objeto]
else:
self.lista_empleados = objeto
self.fecha = fecha
Ventana.__init__(self, 'up_asistencia.glade', objeto)
self.usuario = usuario
connections = {'b_salir/clicked': self.salir,
'b_imprimir/clicked': self.imprimir,
'cb_empleadoID/changed': self.actualizar,
'b_refrescar/clicked': self.actualizar,
'b_fecha/clicked': self.set_fecha,
}
self.inicializar_ventana()
self.wids['e_fecha'] = utils.str_fecha(datetime.date.today())
self.dia_seleccionado = self.get_fecha_mostrada()
self.add_connections(connections)
self.actualizar()
gtk.main()
def __init__(self, objeto = None, usuario = None):
"""
Constructor. objeto puede ser un objeto de pclases con el que
comenzar la ventana (en lugar del primero de la tabla, que es
el que se muestra por defecto).
"""
global fin
Ventana.__init__(self, 'consulta_incidencias.glade', objeto)
connections = {'b_salir/clicked': self.salir,
'b_buscar/clicked': self.buscar,
'b_imprimir/clicked': self.imprimir,
'b_fecha_inicio/clicked': self.set_inicio,
'b_fecha_fin/clicked': self.set_fin,
"b_exportar/clicked": self.exportar}
self.add_connections(connections)
cols = (('Tipo','gobject.TYPE_STRING',False,True,False,None),
('Inicio','gobject.TYPE_STRING',False,True,False,None),
('Fin','gobject.TYPE_STRING',False,True,False,None),
('Fecha parte','gobject.TYPE_STRING',False,True,False,None),
('Turno parte','gobject.TYPE_STRING',False,True,False,None),
('Observaciones','gobject.TYPE_STRING',False,True,False,None),
('Idincidencia','gobject.TYPE_INT64',False,False,False,None))
utils.preparar_listview(self.wids['tv_datos'], cols)
cols = (('Tipo', 'gobject.TYPE_STRING', False, True, True, None),
('Tiempo', 'gobject.TYPE_STRING', False, True, False, None),
('NADA', 'gobject.TYPE_STRING', False, False, False, None))
utils.preparar_listview(self.wids['tv_resumen'], cols)
temp = time.localtime()
self.fin = str(temp[0])+'/'+str(temp[1])+'/'+str(temp[2])
self.wids['e_fechafin'].set_text(utils.str_fecha(temp))
import custom_widgets
self.wids['velocimetro'] = custom_widgets.Velocimetro(0.0, 100.0, 0.0)
self.wids['hbox8'].pack_end(self.wids['velocimetro'], False, False, 5)
self.wids['velocimetro'].show_all()
gtk.main()
def main(**args):
ventana = Ventana((800, 600))
canvas = Canvas((800, 450), (0, 150))
particula = Particula()
canvas.add_particula(particula, 0)
ventana.add_canvas(canvas, "0")
ventana.run()
class Simulador:
anchoVentana = 1000
alturaVentana = 600
def __init__(self):
self.ventana = Ventana({
'ancho': self.anchoVentana,
'alto': self.alturaVentana
})
def generar(self, cantidadParticulas=15):
self.vehiculos = []
for i in xrange(0, cantidadParticulas):
self.generateColor()
vehiculo = Vehiculo(self.ventana.via, self.vehiculos,
self.anchoVentana, self.color, i)
self.vehiculos.append(vehiculo)
espera = np.random.poisson()
time.sleep(espera)
pass
# ....Hilo.....
def moverParticulas(self):
while True:
#self.ventana.dibujarVias()
for x in xrange(0, len(self.vehiculos)):
self.vehiculos[x].mover()
pass
self.ventana.dibujarOvalos(self.vehiculos)
time.sleep(0.01)
def mostrarVentana(self):
self.ventana.mostrar()
def generateColor(self):
data = [
'red', 'blue', 'black', 'white', 'green', 'yellow', 'gray', 'pink'
]
self.color = data[random.randrange(len(data))]
superficie=self.superficie,
color=PARTICULA_VECTOR_X_COLOR,
grosor=PARTICULA_VECTOR_X_GROSOR)
VectorGrafico(Punto(pos_x, pos_y),
vector.get_vector_y()).render( #velocidad y
superficie=self.superficie,
color=PARTICULA_VECTOR_Y_COLOR,
grosor=PARTICULA_VECTOR_X_GROSOR)
VectorGrafico(Punto(pos_x, pos_y),
vector).render( #velocidad resultante
superficie=self.superficie,
color=PARTICULA_VECTOR_COLOR,
grosor=PARTICULA_VECTOR_X_GROSOR)
#acomoda la pantalla para que se vea bien el tiro
self.superficie.blit(pygame.transform.rotate(self.superficie, 180),
(0, 0))
self.superficie.blit(
pygame.transform.flip(self.superficie, True, False), (0, 0))
#----PRUEBAS
if __name__ == '__main__':
from ventana import Ventana
v = Ventana((600, 400))
canvas = Canvas((600, 200), (0, 10))
v.add_canvas(canvas, "0")
v.run()
self._superficie = superficie
self._boton.surface = superficie
def update(self, event):
"""Solo es una función de redirección que llama al método react
del atributo menu
"""
self._menu.react(event)
def render(self):
"""Renderiza al menu de elementos
"""
self._menu.refresh_population()
self._menu.blit_and_update()
#pruebas
if __name__ == '__main__':
from canvas import Canvas
from ventana import Ventana
from vector import Vector
from particula import Particula
import pygame
ventana = Ventana((800, 600))
canvas = Canvas((800, 450), (0, 150))
particula = Particula()
canvas.add_particula(particula, 0)
ventana.add_canvas(canvas, "0")
ventana.run()
def __init__(self):
self.ventana = Ventana({
'ancho': self.anchoVentana,
'alto': self.alturaVentana
})
import gi
gi.require_version("Gtk", "3.0")
from gi.repository import Gtk
from ventana import Ventana
window = Ventana()
window.connect("destroy", Gtk.main_quit)
window.show_all()
Gtk.main()
class Simulador:
anchoVentana = 1000
alturaVentana = 600
tiempo = 0
estado = 0
def __init__(self):
# self.generarVias()
self.ventana = Ventana({'ancho': self.anchoVentana, 'alto': self.alturaVentana})
# self.ventana.crearDesdeGrafo()
self.ventana.inicializar()
self.tiempomaximo = int(self.ventana.gui.tiempo) * 120
self.definirArea()
def generarVias(self):
self.vias = []
x = random.randrange(100, 300, 100)
y = random.randrange(100, 300, 100)
via = Via(x, y)
self.vias.append(via)
if via.posicion == 1:
x = via.limiteInferior + random.randrange(100, 300, 100)
else:
y = via.limiteInferior + random.randrange(100, 300, 100)
while(x < self.anchoVentana and y < self.alturaVentana):
via = Via(x, y)
self.vias.append(via)
if via.posicion == 1:
x = via.limiteInferior + random.randrange(100, 300, 100)
else:
y = via.limiteInferior + random.randrange(100, 300, 100)
def generar(self, cantidadParticulas=50):
self.vehiculos = []
for i in xrange(0, cantidadParticulas):
#origen = self.ventana.gui.vertices.vertices[0]
origen = self.seleccionarOrigen()
destino = self.ventana.gui.vertices.vertices[random.randrange(0, len(self.ventana.gui.vertices.vertices))]
vehiculo = Vehiculo(self.estado, origen, destino, self.vehiculos, self.anchoVentana, self.alturaVentana, self.ventana.gui.vertices.vertices, self.ventana, self.ventana.peatones)
# self.ventana.vias[random.randrange(0, len(self.ventana.vias))]
vehiculo.setVia(self.ventana.seleccionarDestino(origen, None))
vehiculo.recorrido = vehiculo.recorrido + 1
hiloVerificador = threading.Thread(target=vehiculo.reaccionar)
hiloVerificador.daemon = True
hiloVerificador.start()
self.vehiculos.append(vehiculo)
espera = np.random.uniform(0.1, 5)
if self.estado == 1:
print "SIMULACION TERMINADA"
sys.exit()
time.sleep(espera)
pass
# if origen == via.inicio:
# return via.fin
# else:
# return via.iniciio
def seleccionarOrigen(self):
origenes = self.ventana.gui.origenes
cantidadOrigenes = len(origenes)
index = random.randrange(0, cantidadOrigenes)
return origenes[index]
# ....Hilo.....
def moverParticulas(self):
while True:
self.tiempo = self.tiempo + 1
self.ventana.dibujarOvalos(self.vehiculos)
if (self.tiempo / 100) > self.tiempomaximo:
self.estado = 1
print "SIMULACION TERMINADA"
sys.exit()
time.sleep(0.01)
def actualizarSemaforos(self):
while True:
self.ventana.actualizarSemaforos()
time.sleep(30)
def mostrarVentana(self):
self.ventana.mostrar()
def definirArea(self):
self.xmax = self.ventana.gui.vertices.vertices[0].position['x']
self.xmin = self.ventana.gui.vertices.vertices[0].position['x']
self.ymin = self.ventana.gui.vertices.vertices[0].position['y']
self.ymax = self.ventana.gui.vertices.vertices[0].position['y']
for vertice in self.ventana.gui.vertices.vertices:
if vertice.position['x'] > self.xmax:
self.xmax = vertice.position['x']
elif vertice.position['x'] < self.xmin:
self.xmin = vertice.position['x']
elif vertice.position['y'] > self.ymax:
self.ymax = vertice.position['y']
elif vertice.position['y'] < self.ymin:
self.ymin = vertice.position['y']
def crearPersonas(self):
while True:
self.ventana.crearPeatones(self.xmax, self.xmin, self.ymax, self.ymin)
time.sleep(5)
def moverPersonas(self):
while True:
self.ventana.moverPeatones()
time.sleep(0.1)
