Python Ventana.__init__方法代码示例

# 需要导入模块: from formularios.ventana import Ventana [as 别名]
# 或者: from formularios.ventana.Ventana import __init__ [as 别名]
 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()

# 需要导入模块: from formularios.ventana import Ventana [as 别名]
# 或者: from formularios.ventana.Ventana import __init__ [as 别名]
 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()

# 需要导入模块: from formularios.ventana import Ventana [as 别名]
# 或者: from formularios.ventana.Ventana import __init__ [as 别名]
 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()

# 需要导入模块: from formularios.ventana import Ventana [as 别名]
# 或者: from formularios.ventana.Ventana import __init__ [as 别名]
 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()

# 需要导入模块: from formularios.ventana import Ventana [as 别名]
# 或者: from formularios.ventana.Ventana import __init__ [as 别名]
 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()

# 需要导入模块: from formularios.ventana import Ventana [as 别名]
# 或者: from formularios.ventana.Ventana import __init__ [as 别名]
 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()

# 需要导入模块: from formularios.ventana import Ventana [as 别名]
# 或者: from formularios.ventana.Ventana import __init__ [as 别名]
 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()

# 需要导入模块: from formularios.ventana import Ventana [as 别名]
# 或者: from formularios.ventana.Ventana import __init__ [as 别名]
 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()

# 需要导入模块: from formularios.ventana import Ventana [as 别名]
# 或者: from formularios.ventana.Ventana import __init__ [as 别名]
 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()

# 需要导入模块: from formularios.ventana import Ventana [as 别名]
# 或者: from formularios.ventana.Ventana import __init__ [as 别名]
 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()

# 需要导入模块: from formularios.ventana import Ventana [as 别名]
# 或者: from formularios.ventana.Ventana import __init__ [as 别名]
 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()

# 需要导入模块: from formularios.ventana import Ventana [as 别名]
# 或者: from formularios.ventana.Ventana import __init__ [as 别名]
 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()

# 需要导入模块: from formularios.ventana import Ventana [as 别名]
# 或者: from formularios.ventana.Ventana import __init__ [as 别名]
 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()

# 需要导入模块: from formularios.ventana import Ventana [as 别名]
# 或者: from formularios.ventana.Ventana import __init__ [as 别名]
 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()

# 需要导入模块: from formularios.ventana import Ventana [as 别名]
# 或者: from formularios.ventana.Ventana import __init__ [as 别名]
 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()