Python ventana.Ventana类代码示例

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