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, 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, "proveedores.glade", objeto, usuario=usuario)
connections = {
"b_salir/clicked": self.salir,
"b_pedidos/clicked": self.ver_pedidos,
"b_facturas/clicked": self.ver_facturas,
"b_productos/clicked": self.ver_productos,
"b_nuevo/clicked": self.crear_nuevo_proveedor,
"b_actualizar/clicked": self.actualizar_ventana,
"b_guardar/clicked": self.guardar,
"b_borrar/clicked": self.borrar,
"b_buscar/clicked": self.buscar_proveedor,
"b_listado/clicked": imprimir_listado,
"b_next/clicked": self.siguiente,
"b_back/clicked": self.anterior,
}
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 = 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,
'b_imagen/clicked': self.set_imagen,
'b_documentos/clicked': self.add_documento,
'b_prev/clicked': self.prev,
'b_next/clicked': self.next,
'b_get_baja/clicked': self.get_baja,
'b_quit_baja/clicked': self.quit_baja,
'b_precio_a_todos/clicked': self.aplicar_precio_a_todos
}
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_balas.glade', objeto, usuario = usuario)
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).
"""
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,
'cb_productoID/changed': self.mostrar_envases,
'sp_envases/changed': self.cambiar_produccion,
}
self.add_connections(connections)
self.inicializar_ventana()
if self.objeto == None:
self.ir_a_primero()
else:
self.ir_a(objeto)
self.wids['ventana'].resize(1, 1)
gtk.main()
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, usuario = usuario)
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).
"""
global fin
Ventana.__init__(self, os.path.join("ui", 'consulta_facturacion.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 = (('Factura','gobject.TYPE_STRING', False, True, True, None),
('Fecha','gobject.TYPE_STRING', False, False, False, None),
('Cliente', 'gobject.TYPE_STRING', False, True, False, None),
('Importe','gobject.TYPE_STRING', False, True, False, None),
('Pendiente', '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(3)
for cell in col.get_cell_renderers():
cell.set_property("xalign", 1)
col = self.wids['tv_datos'].get_column(4)
for cell in col.get_cell_renderers():
cell.set_property("xalign", 1)
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
Ventana.__init__(self, os.path.join("ui", '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
global fin
Ventana.__init__(self, os.path.join("ui", 'build_salarios.glade'), objeto)
connections = {'b_salir/clicked': self.salir,
'b_fecha/clicked': self.set_fecha,
'b_doit/clicked': self.generar}
self.add_connections(connections)
cols = (('Emeplado', 'gobject.TYPE_STRING', False, True, True, None),
('Jornal','gobject.TYPE_STRING', False, True, False, None),
('Generar', 'gobject.TYPE_BOOLEAN', True, True, False,
self.cambiar_generar),
('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", 0.5)
temp = time.localtime()
self.fin = str(temp[0])+'/'+str(temp[1])+'/'+str(temp[2])
self.wids['e_fecha'].set_text(utils.str_fecha(temp))
self.rellenar_widgets()
self.wids['ventana'].resize(800, 600)
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, os.path.join("ui", 'facturar_albaranes.glade'), objeto)
connections = {'b_salir/clicked': self.salir,
'b_doit/clicked': self.generar}
self.add_connections(connections)
cols = (('Número', 'gobject.TYPE_STRING', False, True, True, None),
('Cliente','gobject.TYPE_STRING', False, True, False, None),
('Fecha', 'gobject.TYPE_STRING', False, True, False, None),
('Importe', 'gobject.TYPE_STRING', False, True, False, None),
('Estado', 'gobject.TYPE_STRING', False, True, False, None),
('Facturar', 'gobject.TYPE_BOOLEAN', True, True, False,
self.cambiar_generar),
('id','gobject.TYPE_STRING', False, False, False, None))
utils.preparar_listview(self.wids['tv_datos'], cols)
self.wids['tv_datos'].connect("row-activated",
abrir_albaran,
self.usuario,
self)
col = self.wids['tv_datos'].get_column(3)
for cell in col.get_cell_renderers():
cell.set_property("xalign", 1.0)
col = self.wids['tv_datos'].get_column(4)
for cell in col.get_cell_renderers():
cell.set_property("xalign", 0.5)
self.rellenar_widgets()
self.wids['ventana'].resize(800, 600)
gtk.main()
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
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,
'b_add_src/clicked': self.add_from_src,
'b_drop_ldv/clicked': self.drop_ldv,
'b_vtos_defecto/clicked': self.crear_vtos_defecto,
'b_add_vto/clicked': self.add_vto,
'b_drop_vto/clicked': self.drop_vto,
'b_add_cobro/clicked': self.add_cobro,
'b_drop_cobro/clicked': self.drop_cobro,
'b_imprimir/clicked': self.imprimir}
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, 'ui/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.objeto = objeto
Ventana.__init__(self, 'consumo_balas_partida.glade',
self.objeto, usuario=usuario)
connections = {'b_salir/clicked': self.salir,
'b_partida/clicked': self.set_partida,
'b_imprimir/clicked': self.imprimir,
'b_drop_bala/clicked': self.drop_bala,
'b_add_balas/clicked': self.add_balas,
'b_add_producto/clicked': self.add_producto,
'b_add_partida_gtx/clicked': self.add_partida_gtx,
'b_drop_partida_gtx/clicked': self.drop_partida_gtx,
'b_albaran/clicked': self.crear_albaran_interno,
'b_phaser/clicked': self.descargar_de_terminal,
'b_fecha/clicked': self.buscar_fecha,
'b_from_pdp/clicked': self.fecha_from_pdp,
'b_from_albaran/clicked': self.fecha_from_albaran}
self.add_connections(connections)
cols = (('Nº Bala', 'gobject.TYPE_STRING', False, True, True, None),
('Peso', 'gobject.TYPE_FLOAT', True, True, False,
self.cambiar_peso_bala),
('ID', 'gobject.TYPE_INT64', False, False, False, None))
utils.preparar_listview(self.wids['tv_balas'], cols)
# Al loro porque me voy a cargar la mitad de lo que ha hecho el
# preparar_listview.
import gobject
model = gtk.ListStore(gobject.TYPE_STRING, gobject.TYPE_FLOAT,
gobject.TYPE_FLOAT, gobject.TYPE_INT64)
self.wids['tv_balas'].set_model(model)
self.wids['tv_balas'].get_selection().set_mode(gtk.SELECTION_MULTIPLE)
cell = gtk.CellRendererProgress()
column = gtk.TreeViewColumn('Consumido', cell)
column.add_attribute(cell, 'value', 2)
column.set_sort_column_id(2)
self.wids['tv_balas'].insert_column(column, 2)
cols = (("#Balas", "gobject.TYPE_INT64", False, True, False, None),
('Peso', 'gobject.TYPE_FLOAT', False, True, False, None),
("Lote", "gobject.TYPE_STRING", False, True, True, None),
("Fibra", "gobject.TYPE_STRING", False, True, False, None),
("ID", "gobject.TYPE_INT64", False, False, False, None))
utils.preparar_listview(self.wids['tv_resumen'], cols)
cols = (("Nª Partida", "gobject.TYPE_STRING", False, True, True, None),
("Producto", "gobject.TYPE_STRING", False, True, False, None),
("ID", "gobject.TYPE_STRING", False, False, False, None))
utils.preparar_listview(self.wids['tv_gtx'], cols)
self.wids['ch_api'] = gtk.CheckButton("Partida volcada a Murano")
self.wids['b_add_balas'].parent.add(self.wids['ch_api'])
self.wids['b_add_balas'].parent.show_all()
self.wids['ch_api'].set_sensitive(False)
if self.objeto is 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).
"""
global fin
Ventana.__init__(self, os.path.join("ui", 'consulta_precios.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, True, None)]
for p in pclases.ProductoVenta.select(orderBy = "nombre"):
cols.append((p.nombre, "gobject.TYPE_STRING",
False, False, False, None))
cols += [('id', 'gobject.TYPE_STRING', False, False, False, None)]
utils.preparar_listview(self.wids['tv_datos'], cols)
for i in range(1, len(cols)-1):
col = self.wids['tv_datos'].get_column(i)
for cell in col.get_cell_renderers():
cell.set_property("xalign", 1)
temp = mx.DateTime.localtime()
self.fin = utils.abs_mxfecha(temp)
self.wids['e_fechafin'].set_text(utils.str_fecha(temp))
self.wids['tv_datos'].set_size_request(700, 200)
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, os.path.join("ui",
'cobro_facturas_venta.glade'), objeto)
connections = {'b_salir/clicked': self.salir,
'b_add_cobro/clicked': self.add_cobro,
'b_remove_cobro/clicked': self.remove_cobro}
self.add_connections(connections)
cols = (('ID', 'gobject.TYPE_INT', False, True, True, None),
('Número', 'gobject.TYPE_STRING', False, True, True, None),
('Cliente', 'gobject.TYPE_STRING', False, True, False, None),
('Fecha', 'gobject.TYPE_STRING', False, True, False, None),
('Importe', 'gobject.TYPE_STRING', False, True, False, None),
('Estado', 'gobject.TYPE_STRING', False, True, False, None),
('Fecha vto', 'gobject.TYPE_STRING', False, True, False, None),
('Pagado en', 'gobject.TYPE_STRING', False, True, False, None),
('id', 'gobject.TYPE_STRING', False, False, False, None))
utils.preparar_listview(self.wids['tv_datos'], cols)
#self.wids['tv_datos'].connect("row-activated", self.abrir_factura,
# self.usuario, self)
col = self.wids['tv_datos'].get_column(3)
for cell in col.get_cell_renderers():
cell.set_property("xalign", 1.0)
col = self.wids['tv_datos'].get_column(4)
for cell in col.get_cell_renderers():
cell.set_property("xalign", 0.5)
self.rellenar_widgets()
self.wids['ventana'].resize(800, 600)
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, self.VENTANA, objeto)
self.inicializar_ventana()
self.add_connections({"b_salir/clicked": self.salir})
gtk.main()
def __init__(self, objeto = None, usuario = None, ventana_padre = None, locals_adicionales = {}):
try:
Ventana.__init__(self, 'trazabilidad.glade', objeto)
except: # Tal vez me estén llamando desde otro directorio
Ventana.__init__(self, os.path.join('formularios', 'trazabilidad.glade'), objeto)
connections = {'b_salir/clicked': self.salir,
'b_buscar/clicked': self.buscar}
self.add_connections(connections)
cols = (('ID', 'gobject.TYPE_STRING', False, False, False, None),
('campo', 'gobject.TYPE_STRING', False, False, False, None),
('valor', 'gobject.TYPE_STRING', True, False, True, self.cambiar_valor),
('clase', 'gobject.TYPE_STRING', False, False, False, None))
utils.preparar_treeview(self.wids['tv_datos'], cols)
self.wids['e_num'].connect("key_press_event", self.pasar_foco)
self.wids['tv_datos'].connect("row-expanded", self.expandir)
self.wids['tv_datos'].connect("row-collapsed", self.cerrar)
import pyconsole
vars_locales = locals()
for k in locals_adicionales:
vars_locales[k] = locals_adicionales[k]
consola = pyconsole.attach_console(self.wids['contenedor_consola'],
banner = "Consola python de depuración GINN",
script_inicio = """import os, pygtk, gtk, gtk.glade, utils
sys.path.append(os.path.join("framework"))
import pclases, mx, mx.DateTime
from seeker import VentanaGenerica as Ver
dir()
#Ver(self.objeto)
""",
locals = vars_locales)
if objeto != None:
self.rellenar_datos(objeto)
cmd_gtk = cmdgtk.CmdGTK()
cmd_gtk.attach_to(self.wids['boxcmd'])
#-----------------------------------------------------------------------------------------------#
def comprobar_que_no_me_hace_el_gato(paned, scrolltype_or_allocation_or_requisition = None): #
width = self.wids['ventana'].get_size()[0] #
MIN = width / 2 #
MAX = width - 100 #
posactual = paned.get_position() #
if posactual < MIN: #
paned.set_position(MIN) #
elif posactual > MAX: #
paned.set_position(MAX) #
#-----------------------------------------------------------------------------------------------#
self.wids['hpaned1'].connect("size_request", comprobar_que_no_me_hace_el_gato)
self.wids['ventana'].resize(800, 600)
self.wids['hpaned1'].set_position(self.wids['ventana'].get_size()[0] / 2)
self.wids['ventana'].set_position(gtk.WIN_POS_CENTER)
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, self.VENTANA, objeto)
self.add_connections({"b_salir/clicked": self.salir,
"b_imprimir/clicked": self.imprimir,
"b_exportar/clicked": self.exportar,
"cb_empleado/changed": self.mostrar_produccion})
self.inicializar_ventana()
if objeto != None:
utils.combo_set_from_db(self.wids['cb_empleado'], 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
self.clase = pclases.Trabajo
Ventana.__init__(self, os.path.join("ui", 'trabajo_empleados.glade'),
objeto)
connections = {'b_borrar/clicked': self.borrar_jornada,
'b_modificar/clicked': self.modificar_jornada,
'b_anticipo/clicked': self.dar_anticipo,
'b_save/clicked': self.guardar_jornada,
'b_quitar_seleccion/clicked': self.quitar_seleccion,
'b_imprimir/clicked': self.imprimir,
'mostrar_fecha/clicked': self.mostrar_calendario,
'rb_vista_diaria/clicked': self.rellenar_tabla_diaria,
'rb_vista_mensual/clicked': self.rellenar_tabla_mensual,
'entry_h_campo/changed': self.comprobar_numero_valido,
'entry_h_manipulacion/changed': self.comprobar_numero_valido,
'treeview_visual_diaria/cursor-changed': self.sel_empleado,
'treeview_visual_mensual/cursor-changed': self.sel_empleado,
'treeview_apuntar/cursor-changed': self.sel_empleado,
'combo_grupo/changed': self.filtrar_empleados,
'calendar/day-selected-double-click': self.sel_day_calendar}
# TODO cerrar el calendario a mano falla
self.add_connections(connections)
self.update_fecha()
utils.preparar_listview(self.wids['treeview_visual_mensual'],
self.get_cols_mensual())
utils.preparar_listview(self.wids['treeview_visual_diaria'],
self.get_cols_diaria())
utils.preparar_listview(self.wids['treeview_apuntar'],
self.get_cols_apuntar())
#col = self.wids['treeview_visual'].get_column(3)
#for cell in col.get_cell_renderers():
# cell.set_property("xalign", 1.0)
#col = self.wids['treeview_visual'].get_column(4)
#for cell in col.get_cell_renderers():
# cell.set_property("xalign", 1.0)
self.rellenar_tabla_diaria(self.wids['rb_vista_diaria'])
self.wids['combo_grupo'].set_active(0)
self.wids['entry_h_campo'].set_text("0")
self.wids['entry_h_manipulacion'].set_text("0")
self.wids['popup_w'].set_transient_for(self.wids['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
global fin
Ventana.__init__(self, 'consulta_vencimientos_cobro.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 = (('Factura','gobject.TYPE_STRING',False,True, False,None),
('Fecha vto.','gobject.TYPE_STRING',False,True,False,None),
('Importe','gobject.TYPE_STRING',False,False,False,None),
('Observaciones/Forma de cobro','gobject.TYPE_STRING',False,True, False,None),
('Cliente', 'gobject.TYPE_STRING', False, True, True, None),
('id','gobject.TYPE_STRING',False,False,False,None))
utils.preparar_listview(self.wids['tv_datos'], cols)
self.wids['tv_datos'].connect("row-activated", self.abrir_factura)
self.colorear(self.wids['tv_datos'])
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('button_press_event', self.button_clicked)
self.wids['tv_datos'].set_hover_selection(True)
cols = (('Año y mes','gobject.TYPE_STRING', False,True, True, None),
('Total','gobject.TYPE_STRING', False, True, False, None),
('nada','gobject.TYPE_STRING', False, False, False, None))
utils.preparar_treeview(self.wids['tv_totales'], cols)
col = self.wids['tv_totales'].get_column(1)
for cell in col.get_cell_renderers():
cell.set_property("xalign", 1)
temp = time.localtime()
self.fin = mx.DateTime.DateTimeFrom(day = temp[2], month = temp[1], year = temp[0])
self.wids['e_fechafin'].set_text(utils.str_fecha(temp))
self.inicio = mx.DateTime.DateTimeFrom(day = 1, month = mx.DateTime.localtime().month, year = mx.DateTime.localtime().year)
self.wids['e_fechainicio'].set_text(utils.str_fecha(self.inicio))
gtk.main()
def __init__(self, empleado_o_gasto, 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.empleado_o_gasto = empleado_o_gasto
self.clase = self.CLASE
Ventana.__init__(self, self.VENTANA, objeto)
connections = {'b_drop_adjunto/clicked': self.drop_adjunto,
'b_add_adjunto/clicked': self.add_adjunto,
'b_ver_adjunto/clicked': self.ver_adjunto,
'b_salir/clicked': self.salir,
}
self.add_connections(connections)
self.inicializar_ventana()
self.rellenar_documentos()
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, os.path.join("ui",
'consulta_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)
cols = (('Cliente', 'gobject.TYPE_STRING', False, True, True, None),
('Producto', 'gobject.TYPE_STRING', False, True, False, None),
('Media precio', 'gobject.TYPE_STRING',
False, True, False, None),
('Facturación', 'gobject.TYPE_STRING',
False, True, False, None),
('% facturación', 'gobject.TYPE_STRING',
False, True, False, None),
('kg facturados', 'gobject.TYPE_STRING',
False, True, False, None),
('id', 'gobject.TYPE_STRING', False, False, False, None))
utils.preparar_treeview(self.wids['tv_datos'], cols)
for i in range(2, 6):
col = self.wids['tv_datos'].get_column(i)
for cell in col.get_cell_renderers():
cell.set_property("xalign", 1)
col = self.wids['tv_datos'].get_column(1)
self.wids['tv_datos'].set_expander_column(col)
temp = mx.DateTime.localtime()
self.fin = utils.abs_mxfecha(temp)
self.wids['e_fechafin'].set_text(utils.str_fecha(temp))
ops = []
for s in pclases.SerieFacturasVenta.select():
ops.append((s.id, s.get_info()))
utils.rellenar_lista(self.wids['cb_serie'], ops)
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_consumo.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,
'e_fechainicio/focus-out-event': act_fecha,
'e_fechafin/focus-out-event': act_fecha,
"b_exportar/clicked": self.exportar}
self.add_connections(connections)
cols = (('Producto', 'gobject.TYPE_STRING', False, True, False, None),
('Cantidad consumida', 'gobject.TYPE_STRING',
False, True, False, None),
('A', 'gobject.TYPE_STRING',
False, True, False, None),
('B', 'gobject.TYPE_STRING',
False, True, False, None),
('C', 'gobject.TYPE_STRING',
False, True, False, None),
('Media diaria', 'gobject.TYPE_STRING',
False, True, False, None),
('ID', 'gobject.TYPE_STRING', False, False, False, None))
utils.preparar_treeview(self.wids['tv_datos'], cols)
for ncol in range(1, 4):
self.wids['tv_datos'].get_column(ncol).get_cell_renderers()[0].set_property("xalign", 1)
self.fin = mx.DateTime.today()
self.wids['e_fechafin'].set_text(utils.str_fecha(self.fin))
self.wids['e_fechainicio'].set_text(
utils.str_fecha(mx.DateTime.localtime()
- (7 * mx.DateTime.oneDay)))
self.inicio = utils.parse_fecha(self.wids['e_fechainicio'].get_text())
# self.wids['ch_fibra'].set_active(True)
self.wids['ch_geotextiles'].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, os.path.join("ui",
'cuadrillas.glade'), objeto)
connections = {'b_add/clicked': self.add_cuadrilla,
'b_remove/clicked': self.remove_cuadrilla,
'b_alta/clicked': self.alta_empleado,
'b_baja/clicked': self.baja_empleado,
'treeview_empleados/cursor-changed': self.sel_empleado}
self.add_connections(connections)
cols_empleados = (
('Empleado', 'gobject.TYPE_STRING', False, True, True, None),
('Alias', 'gobject.TYPE_STRING', False, True, True, None),
('Estado', 'gobject.TYPE_STRING', False, True, True, None),
('id', 'gobject.TYPE_INT', False, True, True, None))
cols_cuadrillas = (
('Sel', 'gobject.TYPE_BOOLEAN', True, True, False,
self.sel_cuadrilla),
('Cuadrilla', 'gobject.TYPE_STRING', False, True, True, None),
('Encargado', 'gobject.TYPE_BOOLEAN', True, True, False,
self.sel_encargado),
('id', 'gobject.TYPE_INT', False, True, True, None))
utils.preparar_listview(self.wids['treeview_empleados'],
cols_empleados)
utils.preparar_listview(self.wids['treeview_cuadrillas'],
cols_cuadrillas)
#self.wids['tv_datos'].connect("row-activated", self.abrir_factura,
# self.usuario, self)
#col = self.wids['tv_datos'].get_column(3)
#for cell in col.get_cell_renderers():
# cell.set_property("xalign", 1.0)
#col = self.wids['tv_datos'].get_column(4)
#for cell in col.get_cell_renderers():
# cell.set_property("xalign", 0.5)
self.rellenar_empleados()
self.wids['ventana'].resize(800, 600)
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, os.path.join("ui", "consulta_facturacion.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 = (
("Factura", "gobject.TYPE_STRING", False, True, True, None),
("Fecha", "gobject.TYPE_STRING", False, False, False, None),
("Cliente", "gobject.TYPE_STRING", False, True, False, None),
("Importe", "gobject.TYPE_STRING", False, True, False, None),
("kg", "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(3)
for cell in col.get_cell_renderers():
cell.set_property("xalign", 1)
col = self.wids["tv_datos"].get_column(4)
for cell in col.get_cell_renderers():
cell.set_property("xalign", 1)
temp = time.localtime()
self.fin = str(temp[0]) + "/" + str(temp[1]) + "/" + str(temp[2])
self.wids["e_fechafin"].set_text(utils.str_fecha(temp))
ops = []
for s in pclases.SerieFacturasVenta.select():
ops.append((s.id, s.get_info()))
utils.rellenar_lista(self.wids["cb_serie"], ops)
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,
"cb_campanna/changed": self.rellenar_tablas,
"b_add_practica_cutural/clicked":
self.add_practica_cutural,
"b_drop_practica_cutural/clicked":
self.drop_practica_cutural,
"b_add_cultivo/clicked": self.add_cultivo,
"b_drop_cultivo/clicked": self.drop_cultivo,
"b_add_fertilizacion/clicked": self.add_fertilizacion,
"b_drop_fertilizacion/clicked": self.drop_fertilizacion,
"b_add_enmienda/clicked": self.add_enmienda,
"b_drop_enmienda/clicked": self.drop_enmienda,
"b_add_fitosanitario/clicked": self.add_fitosanitario,
"b_drop_fitosanitario/clicked": self.drop_fitosanitario,
"b_plano/clicked": self.cambiar_plano
}
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, ventana_padre = None, locals_adicionales = {}, fichero_log = "ginn.log"):
self.fichero_log = fichero_log
try:
Ventana.__init__(self, 'trazabilidad.glade', objeto)
# Me vale el mismo glade. Modificaré dinámicamente lo que me
# estorbe.
except: # Tal vez me estén llamando desde otro directorio
Ventana.__init__(self, os.path.join('formularios', 'trazabilidad.glade'), objeto)
connections = {'b_salir/clicked': self._salir}
self.add_connections(connections)
self.wids['hbox1'].set_property("visible", False)
cols = (('Fecha', 'gobject.TYPE_STRING', False, True, True, None),
('Hora', 'gobject.TYPE_STRING', False, True, False, None),
('Tipo', 'gobject.TYPE_STRING', False, True, False, None),
('Usuario', 'gobject.TYPE_STRING', False, True, False, None),
('Texto', 'gobject.TYPE_STRING', False, True, False, None),
('Línea', 'gobject.TYPE_INT64', False, False, False, None))
utils.preparar_listview(self.wids['tv_datos'], cols)
self.colorear(self.wids['tv_datos'])
import pyconsole
vars_locales = locals()
for k in locals_adicionales:
vars_locales[k] = locals_adicionales[k]
consola = pyconsole.attach_console(self.wids['contenedor_consola'],
banner = "Consola python de depuración GINN",
script_inicio = """import os, pygtk, gtk, gtk.glade, utils
import pclases, mx, mx.DateTime
dir()
""",
locals = vars_locales)
self.wids['frame2'].set_property("visible", False)
self.wids['ventana'].set_title("LogViewer")
self.wids['ventana'].resize(800, 600)
self.wids['ventana'].set_position(gtk.WIN_POS_CENTER)
self.wids['vpaned1'].set_position(500)
self.tamanno_log = self.rellenar_widgets()
gobject.timeout_add(1000, self.check_log)
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, self.VENTANA, objeto)
try:
self.empleado = pclases.Empleado.select(orderBy = "-id")[0]
except IndexError:
self.empleado = None
self.add_connections({"b_salir/clicked": self.salir,
"b_actualizar/clicked": self.rellenar_widgets,
"b_buscar/clicked": self.buscar,
'b_prod_diaria/clicked': self.abrir_prod_diaria,
"b_atras/clicked": self.anterior,
"b_adelante/clicked": self.siguiente,
"cal_trabajo/day_selected":self.rellenar_widgets})
# TODO: De momento:
self.wids['b_imprimir'].set_property("visible", False)
self.inicializar_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).
"""
global fin
Ventana.__init__(self, os.path.join("ui", "consulta_gastos.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 = (
("Código", "gobject.TYPE_STRING", False, True, True, None),
("Producto", "gobject.TYPE_STRING", False, False, False, None),
("Kgs", "gobject.TYPE_STRING", False, True, False, None),
("Importe", "gobject.TYPE_STRING", False, True, False, None),
("Importe s/IVA", "gobject.TYPE_STRING", False, True, False, None),
("Importe menos gastos", "gobject.TYPE_STRING", False, True, False, None),
("Gastos generales", "gobject.TYPE_STRING", False, True, False, None),
("id", "gobject.TYPE_STRING", False, False, False, None),
)
utils.preparar_listview(self.wids["tv_datos"], cols)
for ncol in range(2, 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 = str(temp[0]) + "/" + str(temp[1]) + "/" + str(temp[2])
self.wids["e_fechafin"].set_text(utils.str_fecha(temp))
self.wids["ventana"].set_title("Consulta de ventas por producto")
gtk.main()
