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, '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).
     """
     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):
     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).
     """
     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
     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).
     """
     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):
     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):
     """
     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, 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
     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).
     """
     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).
     """
     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
     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).
     """
     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, 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):
     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, 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).
     """
     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, 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()