elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: Trabajando con las ramas de git (tercera parte)


+  Foro de elhacker.net
|-+  Programación
| |-+  Scripting
| | |-+  python, GTK y MySQL
0 Usuarios y 1 Visitante están viendo este tema.
Páginas: [1] Ir Abajo Respuesta Imprimir
Autor Tema: python, GTK y MySQL  (Leído 2,833 veces)
gabymar

Desconectado Desconectado

Mensajes: 12



Ver Perfil
python, GTK y MySQL
« en: 5 Abril 2010, 18:34 pm »

   Bueno, pues para ir practicando con python, en entorno grafico GTK, y con bases de datos MySQL, he hecho estos widgets heredados de widgets GTK, para poder manejar tablas MySQL, no esta demasiado comentado, si a alguien le interesa el tema puede consultarme lo que quiera.
   Estoy preparando un programita ejemplo de uso de estos widgets, lo enviare proximamente.
   Tened en cuenta que os hace falta ademas del python, el motor de BD MySQL, GTK2 y las librerias de python para MySQL, mysqldb y para gtk pygtk.
   Ala, saludos : Gaby

Código
  1. #!/usr/bin/env python
  2.  
  3. import pygtk
  4. pygtk.require('2.0')
  5. import gtk
  6. import MySQLdb  
  7.  
  8.  
  9. class Database:
  10.    def __init__(self,database,usuario=None,password=None):
  11.        self.database_nombre=database
  12.  
  13.        self.conectada=False
  14.        if usuario!=None:
  15.            self.mysquser=usuario
  16.        else:            
  17.            self.mysquser='usuario' #podemos poner el valor en la clase si va a ser siempre el mismo
  18.        if password!=None:
  19.            self.mysqpasw=password
  20.        else:
  21.            self.mysqpasw='********' #podemos poner el password por defecto, igual que el usuario
  22.        self.conexion=None
  23.  
  24.    def conectar(self):
  25.        try:
  26.            self.conexion=MySQLdb.connect(host='localhost',user=self.mysquser,passwd=self.mysqpasw,db=self.database_nombre)
  27.            self.conectada=True
  28.            return self.conexion
  29.        except:
  30.            #error, sacamos dialogo y decimos que hagan configuracion
  31.            md=gtk.MessageDialog(None,gtk.DIALOG_DESTROY_WITH_PARENT,
  32.                        gtk.MESSAGE_ERROR,gtk.BUTTONS_CLOSE,"Error conectando a base de datos\n Compruebe configuracion\n o MySQL")
  33.            md.run()
  34.            md.destroy()
  35.            return False
  36.  
  37.    def set_dbdatos(self,usuario=None,password=None):
  38.  
  39.        if usuario!=None:
  40.            self.mysquser=usuario
  41.        if password!=None:
  42.            self.mysqpasw=password
  43.  
  44.  
  45.  
  46.  
  47. class Tabla:
  48.  
  49.  
  50.  
  51.    def __init__(self,tabla,basedatos):
  52. # los errores en valores de datos en el sql, no da error da warning, lo
  53. # pasamos a error para poder trabajar con try: except:
  54.        import warnings
  55.        warnings.simplefilter("error")
  56.  
  57.        self.database=basedatos
  58.        self.abierta=False
  59.        self.tabla=tabla
  60.        self.datos_tabla=[]
  61.        self.widgets=[]
  62.        self.descripcion_tabla=[]
  63.        self.nombre_campos=[]
  64.        self.tipo_campos=[]
  65.        self.long_campos=[]
  66.        self.num_campos=0
  67.        self.num_lineas=0
  68.        self.tablas_rel=[]
  69.        self.campos_rel=[]
  70.        self.estado='consultar'
  71.        self.linea_actual=[]
  72.        self.indexado=False
  73.        self.indice=''
  74.        self.abrir()
  75.  
  76.  
  77.  
  78.    def abrir(self):
  79.        #abre la tabla
  80.        res=self.abre_tabla()
  81.  
  82.        if res:
  83.                self.datos_tabla=self.cursor.fetchall()
  84.                self.num_lineas=len(self.datos_tabla)
  85.                self.linea_actual=self.datos_tabla[0]
  86.                self.linea_pos=0  
  87.                #num_campos lleva el numero de campos
  88.                self.num_campos=len(self.cursor.description)
  89.                for i in range(self.num_campos):
  90.                    self.nombre_campos.append(self.cursor.description[i][0])
  91.                    self.tipo_campos.append(self.cursor.description[i][1])
  92.                    self.long_campos.append(self.cursor.description[i][3])
  93.  
  94.        #cerramos la tabla y la base de datos, y trabajamos con los
  95.        #datos en la variable datos_tabla
  96.        self.cierra_tabla()
  97.        return res
  98.  
  99.  
  100.    def abre_tabla(self):
  101.  
  102.        #conectamos la base de datos
  103.        self.conn=self.database.conectar()
  104.        self.cursor=self.conn.cursor()  
  105.  
  106.        if self.database.conectada==True: #True si estamos conectados a la base de datos
  107.            try:
  108.                sql='select * from '+self.tabla
  109.                if self.indexado:
  110.                    sql=sql+' order by '+self.indice
  111.                self.cursor.execute(sql)
  112.                self.abierta=True
  113.                result=True
  114.            except:
  115.                #error, sacamos dialogo y decimos que hagan configuracion
  116.                md=gtk.MessageDialog(None,gtk.DIALOG_DESTROY_WITH_PARENT,
  117.                        gtk.MESSAGE_ERROR,gtk.BUTTONS_CLOSE,"Error abriendo tabla\n Compruebe configuracion\n o MySQL")
  118.                md.run()
  119.                md.destroy()
  120.                result=False
  121.        else:
  122.            #la base de datos no esta conectada
  123.                #error, sacamos dialogo y decimos que hagan configuracion
  124.                md=gtk.MessageDialog(None,gtk.DIALOG_DESTROY_WITH_PARENT,
  125.                        gtk.MESSAGE_ERROR,gtk.BUTTONS_CLOSE,"Base de datos no abierta\n Compruebe configuracion\n o MySQL")
  126.                md.run()
  127.                md.destroy()  
  128.                result=False  
  129.        return result
  130.  
  131.    def cierra_tabla(self):
  132.        self.cursor.close()
  133.        self.conn.close()
  134.  
  135.    def set_indice(self,indexado,*indice):
  136.        if indexado:
  137.            self.indexado=True
  138.            self.indice=indice[0]
  139.            self.abrir()
  140.        else:
  141.            self.indexado=False
  142.  
  143.    def set_tabla(self,tabla):
  144.        self.tabla=tabla
  145.        self.abrir()
  146.  
  147.    def adelante(self,widget):
  148.            # una fila adelante en la tabla.
  149.            if self.linea_pos<self.num_lineas-1:
  150.                self.linea_pos+=1
  151.                self.linea_actual=self.datos_tabla[self.linea_pos]
  152.                result=True
  153.                if self.linea_pos==self.num_lineas-1:
  154.                    result=False
  155.                self.actualizar()
  156.            else:
  157.                #hemos alcanzado final tabla
  158.                result=False
  159.            return result
  160.  
  161.    def atras(self,widget):
  162.            #una fila hacia atras, si es la primera, no cambia
  163.            if self.linea_pos>0:
  164.                self.linea_pos-=1
  165.                self.linea_actual=self.datos_tabla[self.linea_pos]
  166.                result=True
  167.                if self.linea_pos==0:
  168.                    result=False                
  169.                self.actualizar()
  170.            else:
  171.                #principio de tabla
  172.                result=False
  173.            return result
  174.  
  175.    def primero(self,widget):
  176.            self.linea_pos=0
  177.            self.linea_actual=self.datos_tabla[self.linea_pos]
  178.            self.actualizar()
  179.            return True
  180.  
  181.    def ultimo(self,widget):
  182.            self.linea_pos=self.num_lineas-1
  183.            self.linea_actual=self.datos_tabla[self.linea_pos]
  184.            self.actualizar()
  185.            return True
  186.  
  187.    def aplica_edicion(self):
  188.        #aqui salvamos los datos editados
  189.        #primero seleccionamos la fila de la tabla a cambiar
  190.        #los datos sin editar estan en la variable linea_actual[]
  191.        #hacemos el select con todos los campos, pues no sabemos
  192.        #si hay dos lineas con campos iguales.
  193.        #primero abrimos tabla
  194.        #pero antes guardamos el puntero que llevabamos
  195.        linea_antes=self.linea_pos
  196.        self.abre_tabla()
  197.        datos_antes=''
  198.        for i in range(self.num_campos):
  199.            campo=self.nombre_campos[i]
  200.            dato=str(self.linea_actual[i])
  201.            if dato!='' and dato!='None':
  202.                datos_antes=datos_antes+campo+' = "'+dato+'" AND '  
  203.        datos_antes=str(datos_antes[0:len(datos_antes)-4])    
  204.        sql='select * from '+self.tabla+' where '+datos_antes  
  205.        try:
  206.            self.cursor.execute(sql)
  207.        except:
  208.            #error, el registro a modificar tenia valores inconsistentes
  209.            md=gtk.MessageDialog(None,gtk.DIALOG_DESTROY_WITH_PARENT,
  210.                                gtk.MESSAGE_ERROR,gtk.BUTTONS_CLOSE,"Error en registro\n Debe arreglarlo desde\n Administrador MySQL\n")
  211.            md.run()
  212.            md.destroy()
  213.            return False
  214.  
  215.        #una vez seleccionada la linea a modificar, comprobamos que es una
  216.        # y solo una.
  217.        if self.cursor.rowcount != 1:
  218.            #error, sacamos dialogo y decimos que comprueben datos
  219.            md=gtk.MessageDialog(None,gtk.DIALOG_DESTROY_WITH_PARENT,
  220.                                gtk.MESSAGE_ERROR,gtk.BUTTONS_CLOSE,"Error al grabar datos\n Mas de un registro cambiado\n ")
  221.            md.run()
  222.            md.destroy()
  223.            return False
  224.        else:
  225.            #correcto, anotamos los nuevos valores
  226.            sql='update '+self.tabla+' set '
  227.            for i in range(self.num_campos):
  228.                campo=self.nombre_campos[i]
  229.                dato=self.widgets[i].get_text()
  230.                if dato!='':
  231.                    if i<self.num_campos-1:
  232.                        sql=sql+campo+' = "'+dato+'" , '
  233.                    else:
  234.                        sql=sql+campo+' = "'+dato+'"'
  235.                else:
  236.                    if i<self.num_campos-1:
  237.                        sql=sql+campo+' = NULL, '
  238.                    else:
  239.                        sql=sql+campo+' = NULL'            
  240.            sql=sql+' where '+datos_antes
  241.            try:
  242.                self.cursor.execute(sql)  
  243.                #abrir abre la tabla, carga las datos en variables y cierra tabla
  244.                self.abrir()
  245.                #dejamos en pantalla el registro modificado
  246.                self.linea_pos=linea_antes
  247.  
  248.                #quita el estado de edicion de los widgets
  249.                self.estado_consulta()
  250.                result=True        
  251.            except:
  252.                #error, sacamos dialogo y decimos que comprueben datos
  253.                md=gtk.MessageDialog(None,gtk.DIALOG_DESTROY_WITH_PARENT,
  254.                                     gtk.MESSAGE_ERROR,gtk.BUTTONS_CLOSE,"Error al grabar datos\n Compruebe datos \n o Cancele")
  255.                md.run()
  256.                md.destroy()
  257.                result=False
  258.  
  259.        return result
  260.  
  261.    def aplica_alta(self):
  262.        #anota nuevo registro en la tabla
  263.        #aqui salvamos los datos anotados
  264.        #primero abrimos tabla
  265.  
  266.        self.abre_tabla()
  267.        #correcto, anotamos los nuevos valores
  268.        sql='insert into '+self.tabla+' values ( '
  269.        vacio=True
  270.        for i in range(self.num_campos):
  271.            dato=self.widgets[i].get_text()
  272.            if dato != '':
  273.                vacio=False
  274.                if i<self.num_campos-1:
  275.                    sql=sql+'"'+dato+'" , '
  276.                else:
  277.                    sql=sql+'"'+dato+'" )'
  278.            else:
  279.                if i<self.num_campos-1:
  280.                    sql=sql+' NULL, '
  281.                else:
  282.                    sql=sql+' NULL )'    
  283.        if vacio:
  284.                #error, sacamos dialogo y decimos que comprueben datos
  285.                md=gtk.MessageDialog(None,gtk.DIALOG_DESTROY_WITH_PARENT,
  286.                                     gtk.MESSAGE_ERROR,gtk.BUTTONS_CLOSE,"No se puede guardar un\n Registro vacio\n")
  287.                md.run()
  288.                md.destroy()
  289.                return False    
  290.        try:
  291.            self.cursor.execute(sql)
  292.            result=True
  293.            self.abrir()
  294.            self.estado_consulta()            
  295.        except:
  296.            #error, sacamos dialogo y decimos que comprueben datos
  297.            md=gtk.MessageDialog(None,gtk.DIALOG_DESTROY_WITH_PARENT,
  298.                    gtk.MESSAGE_ERROR,gtk.BUTTONS_CLOSE,"Error al grabar datos\n Compruebe datos \n o Cancele")
  299.            md.run()
  300.            md.destroy()  
  301.            result=False            
  302.        return result
  303.  
  304.  
  305.    def borrar(self):
  306.        #primero seleccionamos la fila de la tabla a borrar
  307.        #los datos estan en la variable linea_actual[]
  308.        #hacemos el select con todos los campos, pues no sabemos
  309.        #si hay dos lineas con campos iguales.
  310.        #primero abrimos tabla
  311.        #pero antes guardamos el puntero que llevabamos
  312.        linea_antes=self.linea_pos
  313.        self.abre_tabla()
  314.        datos_antes=''
  315.        for i in range(self.num_campos):
  316.            campo=self.nombre_campos[i]
  317.            dato=str(self.linea_actual[i])
  318.            if dato!='' and dato!='None':
  319.                datos_antes=datos_antes+campo+' = "'+dato+'" AND '  
  320.        datos_antes=str(datos_antes[0:len(datos_antes)-4])    
  321.        sql='select * from '+self.tabla+' where '+datos_antes  
  322.        try:
  323.            self.cursor.execute(sql)
  324.  
  325.        except:
  326.            #error, el registro a modificar tenia valores inconsistentes
  327.            md=gtk.MessageDialog(None,gtk.DIALOG_DESTROY_WITH_PARENT,
  328.                                gtk.MESSAGE_ERROR,gtk.BUTTONS_CLOSE,"Error en registro\n Debe arreglarlo desde\n Administrador MySQL\n")
  329.            md.run()
  330.            md.destroy()
  331.            return False
  332.  
  333.        #una vez seleccionada la linea a borrar, comprobamos que es una
  334.        # y solo una.
  335.        if self.cursor.rowcount != 1:
  336.            #error, sacamos dialogo y decimos que comprueben datos
  337.            md=gtk.MessageDialog(None,gtk.DIALOG_DESTROY_WITH_PARENT,
  338.                                gtk.MESSAGE_ERROR,gtk.BUTTONS_CLOSE,"Error al borrar registro\n Mas de un registro seleccionado\n ")
  339.            md.run()
  340.            md.destroy()
  341.            return False
  342.        else:
  343.            #correcto, borramos la linea
  344.            sql='delete from '+self.tabla+' where '+datos_antes
  345.  
  346.            try:
  347.                self.cursor.execute(sql)  
  348.                #abrir abre la tabla, carga las datos en variables y cierra tabla
  349.                self.abrir()
  350.                #dejamos en pantalla el registro modificado
  351.                self.linea_pos=linea_antes
  352.                #quita el estado de edicion de los widgets
  353.                self.estado_consulta()
  354.                result=True        
  355.            except:
  356.                #error, sacamos dialogo y decimos que comprueben datos
  357.                md=gtk.MessageDialog(None,gtk.DIALOG_DESTROY_WITH_PARENT,
  358.                                     gtk.MESSAGE_ERROR,gtk.BUTTONS_CLOSE,"Error al borrar registro\n Compruebe datos \n o Cancele")
  359.                md.run()
  360.                md.destroy()
  361.                result=False
  362.  
  363.        return result
  364.  
  365.    def cancelar(self):
  366.        puntero=self.linea_pos
  367.        self.abrir()
  368.        self.linea_pos=puntero
  369.        self.linea_actual=self.datos_tabla[self.linea_pos]        
  370.        self.actualizar()  
  371.        self.estado_consulta()
  372.        return
  373.  
  374.    def buscar(self,campo,valor):
  375.        for n in range(self.num_campos):
  376.            if campo==self.nombre_campos[n]:
  377.                campo_index= n
  378.        encontrado=False  
  379.        for n in range(len(self.datos_tabla)):
  380.            if self.datos_tabla[n][campo_index]==valor:
  381.                self.linea_actual=self.datos_tabla[n]
  382.                encontrado=True
  383.                self.actualizar()
  384.                break
  385.        return encontrado
  386.  
  387.    def actualizar(self):
  388.            #isinstance(obj, int)
  389.            for w in self.widgets:
  390.                w.actualizar_widget()
  391.            self.actualizar_datos_relacionada()
  392.            return True
  393.  
  394.    def estado_consulta(self):
  395.        #pone los widgets en estado de consulta
  396.        self.estado='consultar'
  397.        for w in self.widgets:
  398.            w.set_editable(False)    
  399.  
  400.    def estado_editar(self):
  401.        #pone los widgets en estado de edicion
  402.        self.estado='editar'
  403.        for w in self.widgets:
  404.            w.set_editable(True)
  405.  
  406.    def estado_alta(self):
  407.        #pone los widgets en alta, en blanco
  408.        self.estado='alta'
  409.        for w in self.widgets:
  410.            w.set_text('')
  411.            w.set_editable(True)
  412.  
  413.    def widget_a_tabla(self,widget,campo):
  414.            self.widgets.append(widget)
  415.            result=-1
  416.            for n in range(self.num_campos):
  417.                if campo==self.nombre_campos[n]:
  418.                    result= n
  419.  
  420.            return result
  421.  
  422.    def relacionar(self,campoprop,tablarel,camporel):
  423.        #relaciona otra tabla con esta, recibe, campo propio
  424.        #tabla esclava a relacionar, y campo de la tabla a relacionar
  425.        result=-1
  426.        for n in range(self.num_campos):
  427.            if campoprop==self.nombre_campos[n]:
  428.                result= n
  429.                self.tablas_rel.append(tablarel)
  430.                self.campos_rel.append(n)
  431.                #envia a la tabla peticionaria, la identidad de esta tabla
  432.                #y el campo de la peticionaria
  433.                tablarel.relacionada(self,camporel)
  434.        return result  
  435.  
  436.    def relacionada(self,trelacion,camporel):
  437.        self.camporel=camporel
  438.        self.tablarelacion=trelacion
  439.  
  440.    def actualizar_datos_relacionada(self):
  441.            for t in range(len(self.tablas_rel)):
  442.                dato=self.linea_actual[self.campos_rel[t]]
  443.                tabla=self.tablas_rel[t]
  444.                tabla.actualizar_tabla(dato)
  445.            return True
  446.    def actualizar_tabla(self,dato):
  447.        self.buscar(self.camporel,dato)
  448.  
  449.  
  450.  
  451.  
  452. class DBLabel(gtk.Label):
  453.    #un label enlazado a una tabla y un campo de la misma
  454.    def __init__(self,tabla,campo=None,orden=None,titular=False):
  455.        #si no nos dan el campo, y se da el orden del campo,
  456.        #campo=None y orden = n, posicion en la tabla de la columna
  457.        #si titular=True, anteponemos el nombre del campo al label
  458.        gtk.Label.__init__(self)  
  459.        self.tabla=tabla
  460.        self.titular=titular
  461.  
  462.        if campo==None:
  463.            self.campo=self.tabla.nombre_campos[orden]
  464.        else:
  465.            self.campo=campo
  466.  
  467.        res=self.campo_index=tabla.widget_a_tabla(self,self.campo)
  468.        if res==-1:
  469.            #error, campo de tabla no encontrado
  470.                md=gtk.MessageDialog(None,gtk.DIALOG_DESTROY_WITH_PARENT,
  471.                                     gtk.MESSAGE_ERROR,gtk.BUTTONS_CLOSE,"Error, campo de tabla \n No existente \n")
  472.                md.run()
  473.                md.destroy()
  474.        self.titulo=self.campo+' : '                
  475.        self.show()
  476.        self.actualizar_widget()
  477.  
  478.    def set_titulo(self,titulo):
  479.        #pone el nombre que deseemos en titulo, en lugar del nombre del campo
  480.        self.titulo=titulo+' : '
  481.        self.titular=True
  482.  
  483.    def actualizar_widget(self):
  484.  
  485.        texto=self.tabla.linea_actual[self.campo_index]
  486.        if self.titular:
  487.            texto=self.titulo+str(texto)
  488.        self.set_text(str(texto))
  489.  
  490. class DBEntry(gtk.HBox):
  491.    #un label enlazado a una tabla y un campo de la misma
  492.    def __init__(self,tabla,campo=None,orden=None,titular=False):
  493.        #si no nos dan el campo, y se da el orden del campo,
  494.        #campo=None y orden = n, posicion en la tabla de la columna
  495.        #si titular=True, anteponemos el nombre del campo al label
  496.        gtk.HBox.__init__(self)  
  497.        self.set_size_request(500,40)
  498.        self.set_homogeneous(False)
  499.        self.entry=gtk.Entry()
  500.        self.entry.set_editable(False)
  501.        self.label=gtk.Label()
  502.        self.pack_start(self.label,False,False,False)
  503.        self.pack_end(self.entry,False,False,False)
  504.        self.entry.show()
  505.        self.label.show()
  506.        self.show()
  507.        self.tabla=tabla
  508.        self.titular=titular
  509.        if campo==None:
  510.            self.campo=self.tabla.nombre_campos[orden]
  511.        else:
  512.            self.campo=campo
  513.        #campo_index lleva el numero de campo en la tabla
  514.        res=self.campo_index=tabla.widget_a_tabla(self,self.campo)
  515.        if res==-1:
  516.            #error, campo de tabla no encontrado
  517.                md=gtk.MessageDialog(None,gtk.DIALOG_DESTROY_WITH_PARENT,
  518.                                     gtk.MESSAGE_ERROR,gtk.BUTTONS_CLOSE,"Error, campo de tabla \n No existente \n")
  519.                md.run()
  520.                md.destroy()
  521.  
  522.        self.titulo=self.campo+' : '
  523.        #poner anchura adaptada a la del campo
  524.        ancho=tabla.long_campos[self.campo_index]
  525.        self.entry.set_max_length(ancho)
  526.        self.entry.set_width_chars(ancho)
  527.        self.actualizar_widget()
  528.  
  529.    def set_titulo(self,titulo):
  530.        #pone el nombre que deseemos en titulo, en lugar del nombre del campo
  531.        self.titulo=titulo+' : '
  532.        self.titular=True
  533.  
  534.  
  535.    def set_editable(self,estado):
  536.        self.entry.set_editable(estado)
  537.  
  538.    def get_text(self):
  539.        return self.entry.get_text()
  540.  
  541.    def set_text(self,texto):
  542.        self.entry.set_text(texto)
  543.  
  544.    def actualizar_widget(self):
  545.  
  546.        texto=self.tabla.linea_actual[self.campo_index]
  547.        if self.titular:
  548.                self.label.set_text(self.titulo+' : ')
  549.                self.label.set_alignment(0,0.5)  
  550.        self.entry.set_text(str(texto))
  551.  
  552. class Navegador(gtk.HButtonBox):
  553.    def __init__(self,tabla,main=None):
  554.        #conjunto de botones para navegar y actuar sobre la tabla
  555.        gtk.HButtonBox.__init__(self)
  556.        self.main=main
  557.        self.tabla=tabla
  558.        self.estado='consultar'
  559.        self.set_homogeneous(False)
  560.        # METEMOS LOS BOTONES
  561.        self.principio=gtk.Button('<<')
  562.        self.add(self.principio)
  563.        self.principio.connect_object("clicked", self.movimiento, self.principio)
  564.        self.atras=gtk.Button('<')
  565.        self.add(self.atras)
  566.        self.atras.connect_object("clicked", self.movimiento, self.atras)
  567.        self.delante=gtk.Button('>')
  568.        self.add(self.delante)
  569.        self.delante.connect_object("clicked", self.movimiento, self.delante)
  570.        self.fin=gtk.Button('>>')
  571.        self.add(self.fin)
  572.        self.fin.connect_object("clicked", self.movimiento, self.fin)
  573.        self.editar=gtk.Button('Editar')
  574.        self.add(self.editar)
  575.        self.editar.connect_object("clicked", self.control, self.editar)
  576.        self.borrar=gtk.Button('Borrar')
  577.        self.add(self.borrar)
  578.        self.borrar.connect_object("clicked", self.control, self.borrar)
  579.        self.alta=gtk.Button('Alta')
  580.        self.add(self.alta)
  581.        self.alta.connect_object("clicked", self.control, self.alta)
  582.        self.aplicar=gtk.Button('Aplicar')
  583.        self.add(self.aplicar)
  584.        self.aplicar.connect_object("clicked", self.control, self.aplicar)  
  585.        self.cancelar=gtk.Button('Cancelar')
  586.        self.add(self.cancelar)
  587.        self.cancelar.connect_object("clicked", self.control, self.cancelar)
  588.        if main!=None:
  589.        #crea un toolbar en la ventana que contiene al navegador,
  590.        #donde representamos el numero de registro visualizado.
  591.            self.lestado=gtk.Label('inicio')  
  592.            labelitem=gtk.ToolItem()
  593.            labelitem.add(self.lestado)
  594.            self.toolb=gtk.Toolbar()
  595.            self.toolb.insert(labelitem,0)
  596.            main.vbox.pack_start(self.toolb,False,True)  
  597.            self.lestado.show()
  598.            labelitem.show()
  599.            self.toolb.show()  
  600.  
  601.        self.atras.show()
  602.        self.delante.show()
  603.        self.principio.show()
  604.        self.fin.show()
  605.        self.editar.show()
  606.        self.borrar.show()
  607.        self.alta.show()
  608.        self.show()
  609.        self.actualizar_widget()
  610.  
  611.    def actualizar_widget(self):
  612.        if self.tabla.linea_pos==0:
  613.            #primera linea
  614.            inicio=True
  615.            fin=False
  616.        elif self.tabla.linea_pos==len(self.tabla.datos_tabla)-1:
  617.            #ultima linea
  618.            fin=True
  619.            inicio=False
  620.        else:
  621.            inicio=False
  622.            fin=False  
  623.        if self.tabla.num_lineas==1:
  624.            #solo hay un registro, ni palante ni patras
  625.            inicio=True
  626.            fin=True
  627.        # oculta los botones que no estan operativos
  628.        if self.estado != 'consultar':
  629.            self.delante.hide()
  630.            self.fin.hide()  
  631.            self.atras.hide()
  632.            self.principio.hide()        
  633.            self.editar.hide()
  634.            self.alta.hide()
  635.            self.borrar.hide()
  636.            self.aplicar.show()
  637.            self.cancelar.show()
  638.            self.cancelar.grab_focus()
  639.            if self.main!=None:
  640.                self.lestado.set_text('Record : '+str(self.tabla.linea_pos)+' estado : '+self.estado)            
  641.        else:
  642.            self.delante.show()
  643.            self.fin.show()
  644.            self.atras.show()
  645.            self.principio.show()      
  646.            self.editar.show()
  647.            self.alta.show()
  648.            self.borrar.show()
  649.            self.aplicar.hide()
  650.            self.cancelar.hide()
  651.  
  652.            if self.main!=None:
  653.                self.lestado.set_text('Record : '+str(self.tabla.linea_pos))
  654.            if inicio:
  655.                self.atras.hide()
  656.                self.principio.hide()
  657.                # y anota en el label el numero de record mostrado
  658.                if self.main!=None:
  659.                    self.lestado.set_text('Record : '+str(self.tabla.linea_pos)+' Principio de fichero')            
  660.            if fin:
  661.                self.delante.hide()
  662.                self.fin.hide()
  663.                if self.main!=None:
  664.                    self.lestado.set_text('Record : '+str(self.tabla.linea_pos)+' Fin de fichero')
  665.  
  666.    def movimiento(self,widget):
  667.        if widget==self.delante:
  668.            self.tabla.adelante(widget)
  669.        elif widget==self.atras:
  670.            self.tabla.atras(widget)
  671.        elif widget==self.principio:
  672.            self.tabla.primero(widget)    
  673.        elif widget==self.fin:
  674.            self.tabla.ultimo(widget)  
  675.        self.actualizar_widget()
  676.  
  677.  
  678.    def control(self,widget):
  679.        res=True
  680.        if widget==self.editar:
  681.            self.estado='editar'
  682.            self.tabla.estado_editar()
  683.        elif widget==self.alta:
  684.            self.estado='alta'            
  685.            self.tabla.estado_alta()
  686.        elif widget==self.borrar:
  687.            self.tabla.estado='borrar'
  688.            self.estado='borrar'
  689.        elif widget==self.aplicar:
  690.            if self.estado=='editar':
  691.                #actualiza los datos en la tabla
  692.                res=self.tabla.aplica_edicion()
  693.                if res:
  694.                    self.estado='consultar'
  695.            elif self.estado=='alta':
  696.                res=self.tabla.aplica_alta()
  697.                if res:
  698.                    self.estado='consultar'
  699.            else:
  700.                self.tabla.borrar()
  701.                self.estado='consultar'
  702.  
  703.        elif widget==self.cancelar:
  704.            self.tabla.cancelar()
  705.            self.estado='consultar'
  706.        if res:
  707.            self.actualizar_widget()              
  708.  
  709.  
  710.  
  711.  
  712.  
  713.  


« Última modificación: 5 Abril 2010, 23:16 pm por Leo Gutiérrez. » En línea

Páginas: [1] Ir Arriba Respuesta Imprimir 

Ir a:  

Mensajes similares
Asunto Iniciado por Respuestas Vistas Último mensaje
[MySQL y Python]No guarda los datos en MySQL
Scripting
stuckey 3 1,871 Último mensaje 21 Noviembre 2013, 08:06 am
por Shell Root
Mysql en Python 3.4
Scripting
Akendore 3 1,688 Último mensaje 21 Septiembre 2015, 21:17 pm
por Akendore
Puerto mysql python
Scripting
Darui803 1 1,704 Último mensaje 13 Noviembre 2015, 23:39 pm
por 0roch1
[AYUDA] ¿Como conecto Python con Mysql?
Scripting
bdred 1 1,313 Último mensaje 4 Abril 2018, 15:04 pm
por engel lex
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines