Simplificar codigo.

Ariel Nardelli pan_python en yahoo.com.ar
Jue Sep 1 06:41:49 CEST 2005 

GRACIAS Joaquin!!!

Te cuento que lo hice andar y ya estoy readaptando mi codigo :)
Hice un par de modificaciones que las pongo aca asi le puede servir a 
cualquiera :)

En los eventos va..

# p_apno -3-  (Razon Social)
EVT_TEXT_ENTER(self, 3,self.evt_get)
EVT_TEXT(self, 3,self.evt_get)
EVT_CHAR(self.tb_apno, lambda event: 
self.p_apno_ev_char(event,'tb_dire','tb_copo') )
EVT_SET_FOCUS(self.tb_apno,self.evt_skip) # toma foco... 
EVT_KILL_FOCUS(self.tb_apno,self.p_apno_ev_df) # deja el foco...

Donde tb_dire es el proximo tb a procesar y tb_copo es el tb anterior y 
despues en mi rutina tengo...

def p_apno_ev_char(self,event,sig,ant):
       # 353 es F12 y 352 es F11  (f12 avanza, f11 retrocede)
        key = event.GetKeyCode()
        if key == 9 or key == 353 or key == 13: # Tecla TAB o F12 Pasa foco.
            va = 'self.'+sig+'.SetFocus()'
            eval(va)
            event.Skip()
        if key == 352: # F11 retrocede
            va = 'self.'+ant+'.SetFocus()'
            eval(va)
            event.Skip()
        if key < WXK_SPACE or key == WXK_DELETE or key > 255:
            event.Skip()
            return
        event.Skip()

Asi se pone "en foco" el proximo o anterior segun las teclas pulsadas...

Espero que a alguien le sirva....
Joaquin Jose del Cerro Murciano wrote:

>El Miércoles, 31 de Agosto de 2005 07:05, Ariel Nardelli escribió:
>  
>
>>Hola!
>>Estoy haciendo un sistema de gestion (wx + python2.3) que tiene muchos
>>textbox que "levantan" info desde pantalla para grabar todos esos datos
>>en la base de datos.
>>
>>Haciendo el programa y tratando de afinar mas el codigo (sobre todo
>>sacar el codigo repetitivo) veo que una rutina sobre todo se me repite
>>constantemente solo me cambia 2 lineas pero los demas es siempre el
>>mismo y entonces se me ocurrio simplificar todo y tratar de usar solo
>>una rutina.
>>
>>Les explico con ejemplos, tengo dentro de programa los armados de
>>pantalla y despues los eventos, aca un ejemplo de 2 eventos...
>>
>>        # p_apno -3-  (Razon Social)
>>        EVT_TEXT_ENTER(self, 3,self.evt_get)
>>        EVT_TEXT(self, 3,self.evt_get)
>>        EVT_CHAR(self.tb_apno, self.p_apno_ev_char)
>>        EVT_SET_FOCUS(self.tb_apno,self.evt_skip) # toma foco...
>>        EVT_KILL_FOCUS(self.tb_apno,self.p_apno_ev_df) # deja el foco...
>>
>>        # p_dire -4-  (Direccion)
>>        EVT_TEXT_ENTER(self, 4,self.evt_get)
>>        EVT_TEXT(self, 4,self.evt_get)
>>        EVT_CHAR(self.tb_dire, self.p_dire_ev_char)
>>        EVT_SET_FOCUS(self.tb_dire,self.evt_skip) # toma foco...
>>        EVT_KILL_FOCUS(self.tb_dire,self.p_dire_ev_df) # deja el foco...
>>
>>Toman el evento de apno y dire y ejecutan segun lo que se pulsa las
>>rutinas, tengo 2 generales que solo sacan el enter y esas cosas que son
>>la evt_get y el evt_skip que ya lo tengo simplificado en una rutina,
>>despues tengo las otras dos, una donde asigno variables y verifico que
>>los datos cargados sea lo que quiero (fechas correctas y demases) que
>>esta siempre cuando pierdo el foco o sea verifico los datos y asigno
>>variables siempre que pierdo el foco no antes, por lo tanto esta rutina
>>siempre va a ser unica por cada texbox pero la que quiero "simplificar"
>>es la de evt_char, la que va verificando cada tecla pulsada, esto lo
>>hago porque en algunos casos necesito solo poner numeros o xx cosas
>>filtradas y uso estas rutinas para filtrar lo que me pulsan del teclado.
>>Pero una de las cosas por lo que mas la uso es que dependiendo lo que
>>pulse del teclado fuerzo a pasar al foco, para lograr que pulsando F12
>>se pase el foco al proximo texbox y pulsando F11 pase el foco al textbox
>>anterior, ese es el uso fundamental de las dos rutinas, aca las pongo:
>>
>>    # Eventos p_apno -3-
>>    def  p_apno_ev_df(self,event):  # Deja Foco.
>>        if len(self.tb_apno.GetValue()) <> 0:
>>            self.tm_apno = self.tb_apno.GetValue()
>>        else:
>>            self.tm_apno = ''
>>        event.Skip()
>>    def p_apno_ev_char(self,event):
>>       # 353 es F12 y 352 es F11  (f12 avanza, f11 retrocede)
>>        key = event.GetKeyCode()
>>        if key == 9 or key == 353 or key == 13: # Tecla TAB o F12 Pasa
>>foco. self.tb_dire.SetFocus()
>>            event.Skip()
>>        if key == 352: # F11 retrocede
>>            self.tb_ncli.SetFocus()
>>            event.Skip()
>>        if key < WXK_SPACE or key == WXK_DELETE or key > 255:
>>            event.Skip()
>>            return
>>        event.Skip()
>>
>>    # Eventos p_dire -4-
>>    def  p_dire_ev_df(self,event):  # Deja Foco.
>>        if len(self.tb_dire.GetValue()) <> 0:
>>            self.tm_dire = self.tb_dire.GetValue()
>>        else:
>>            self.tm_dire = ''
>>        event.Skip()
>>    def p_dire_ev_char(self,event):
>>       # 353 es F12 y 352 es F11  (f12 avanza, f11 retrocede)
>>        key = event.GetKeyCode()
>>        if key == 9 or key == 353 or key == 13: # Tecla TAB o F12 Pasa
>>foco. self.tb_copo.SetFocus()
>>            event.Skip()
>>        if key == 352: # F11 retrocede
>>            self.tb_apno.SetFocus()
>>            event.Skip()
>>        if key < WXK_SPACE or key == WXK_DELETE or key > 255:
>>            event.Skip()
>>            return
>>        event.Skip()
>>
>>Si la miran, lo unico que varia es si pulso tab, F12 o enter paso el
>>evento al siguiente tb o si pulso F11 paso el foco al tb anterior.
>>Esta rutina se repite en todos los tb salvo la parte que marca donde ir
>>segun estas teclas, entonces se me ocurrio simplificar todo y dejar una
>>sola rutina que lo haga.
>>Tengo ordenado todo por orden si se fijan al asignar los tb yo no uso -1
>>sino que pongo un numero asi puedo mantener un orden cuando cargo los
>>datos y "marcar" el orden con que voy tomando la informacion.
>>La cosa es, hay alguna manera en esta rutina de "detectar" en que orden
>>estoy? asi, simplemente cuando tengo que pasar el foco al orden
>>siguiente seria un setfocus +1 y cuando quiero pasar el orden al tb
>>anterior seria un setfocus -1 :).
>>    
>>
>
>Hola, no se mucho de wx, pero podrias probar con una lambda a la hora de 
>enlazar el evento, algo asi como
>
>         EVT_CHAR(
>           self.tb_apno, 
>           lambda event: self.p_apno_ev_char(event,self.tb_apno) 
>         )
>
>Y la funcion p_apno_ev_char la declaras que recive un segundo parametro que es 
>el ID. Si ahora tienes la precaucion de mantener una lista con los controles 
>que has ido añadiendo puedes indexar sobre ella y poner el foco al que le 
>toque (self.controles[index+-1].SetFocus()).
>
>No se si es muy wx, pero te hara lo que quieres.
>
>  
>
>>Lo que necesitaria saber es como detectar en que orden estoy y ademas
>>como hacer para pasar el foco no como lo estoy haciendo aca
>>(sef.tb.SetFocus()) sino hacerlo directamente sobre el orden algo asi
>>como self.orden.SetFocus().
>>
>>Bueno, Agradezco la ayuda y ademas si alguien tiene una mejor idea de
>>hacer esto y me lo cuenta le estare muy agradecido.
>>
>>    
>>
>
>Bueno, yo uso Tkinter, y la forma en que lo abordaria seria crenadome una 
>clase que deriba del textbox y encapsula todo esto. Pero por desgracia no se 
>siquiera si es factible hacerlo asi con wx (esta claro que todo es factible 
>pero a veces es peor el remedio que la enfermedad).
>
>Un saludo
>Joaquin
>
>  
>
>>Gracias!
>>Ariel
>>    
>>
>
>		
>______________________________________________ 
>Renovamos el Correo Yahoo! 
>Nuevos servicios, más seguridad 
>http://correo.yahoo.es
>_______________________________________________
>Python-es mailing list
>Python-es en aditel.org
>http://listas.aditel.org/listinfo/python-es
>  
>


-- 
Saludos
Panflin

NO al limite de adsl de TELECOM
Firma YA el petitorio NACIONAL para que TELECOM no nos estafe con el limite del ADSL, la direccion es:
http://peticionbandaancha.com/

www.reconquista.com.ar

Más información sobre la lista de distribución Python-es