pilas.actores.boton

Package pilas :: Package actores :: Module boton |
[hide private]
[frames] | no frames]

# Source Code for Module pilas.actores.boton

      1  # -*- encoding: utf-8 -*-
      2  # For Pilas engine - A video game framework.
      3  #
      4  # Copyright 2011 - Pablo Garrido
      5  # License: LGPLv3 (see http://www.gnu.org/licenses/lgpl.html)
      6  #
      7  # Website - http://www.pilas-engine.com.ar
      8  #
      9
     10
     11  from pilas.actores import Actor
     12  import pilas
     13
     14
     15 -class Boton(Actor):
     16      """Representa un boton que reacciona al ser presionado.
     17
     18      .. image:: images/actores/boton_normal.png
     19
     20      """
     21
     22 -    def __init__(self, x=0, y=0,
     23                  ruta_normal='boton/boton_normal.png',
     24                  ruta_press='boton/boton_press.png',
     25                  ruta_over='boton/boton_over.png',
     26                  ):
     27          """ Constructor del Boton.
     28
     29          :param x: Posición horizontal del Actor.
     30          :type x: int
     31          :param y: Posición vertical del Actor.
     32          :type y: int
     33          :param ruta_normal: Ruta de la imagen del boton en estado normal.
     34          :type ruta_normal: string
     35          :param ruta_press: Ruta de la imagen del boton cuando se presiona.
     36          :type ruta_press: string
     37          :param ruta_over: Ruta de la imagen del boton cuando el ratón pasa por encima.
     38          :type ruta_over: string
     39          """
     40
     41          self.ruta_normal = ruta_normal
     42          self.ruta_press = ruta_press
     43          self.ruta_over = ruta_over
     44
     45          self.funciones_normal = []
     46          self.funciones_press = []
     47          self.funciones_over = []
     48
     49          self.estado = True
     50
     51          Actor.__init__(self, ruta_normal, x=x, y=y)
     52          self._cargar_imagenes(self.ruta_normal, self.ruta_press, self.ruta_over)
     53
     54          self.escena.mueve_mouse.conectar(self.detection_move_mouse)
     55          self.escena.click_de_mouse.conectar(self.detection_click_mouse)
     56          self.escena.termina_click.conectar(self.detection_end_click_mouse)
     57
     58 -    def _cargar_imagenes(self, ruta_normal, ruta_press, ruta_over):
     59          self.ruta_normal = ruta_normal
     60          self.ruta_press = ruta_press
     61          self.ruta_over = ruta_over
     62
     63          self.imagen_over = pilas.imagenes.cargar(ruta_over)
     64          self.imagen_normal = pilas.imagenes.cargar(ruta_normal)
     65          self.imagen_press = pilas.imagenes.cargar(ruta_press)
     66
     67      #funciones que conectan evento(press, over, normal) a funciones
     68 -    def conectar_normal(self, funcion, arg="null"):
     69          """ Permite conectar un metodo para que sea ejecutado cuando el botón
     70          pase al estado normal.
     71
     72          >>> def cuando_deja_de_pulsar():
     73          >>>     b.pintar_normal()
     74          >>>
     75          >>> mi_boton.conectar_normal(cuando_deja_de_pulsar)
     76
     77          :param funcion: Método a llamar cuando el botón pase a estado Normal.
     78          :param arg: Argumentos a pasar a la funcion.
     79          """
     80          t = (funcion, arg)
     81          self.funciones_normal.append(t)
     82
     83 -    def conectar_presionado(self, funcion, arg="null"):
     84          """ Permite conectar un metodo para que sea ejecutado cuando el botón
     85          se presiona.
     86
     87          >>> def cuando_pulsan_el_boton():
     88          >>>     b.pintar_presionado()
     89          >>>
     90          >>> mi_boton.conectar_presionado(cuando_pulsan_el_boton)
     91
     92          :param funcion: Método a llamar cuando el botón pase a estado Normal.
     93          :param arg: Argumentos a pasar a la funcion.
     94          """
     95          t = (funcion, arg)
     96          self.funciones_press.append(t)
     97
     98 -    def conectar_sobre(self, funcion, arg="null"):
     99          """ Permite conectar un metodo para que sea ejecutado cuando el ratón
    100          pasa por encima del botón.
    101
    102          >>> def cuando_pasa_sobre_el_boton():
    103          >>>     b.pintar_sobre()
    104          >>>
    105          >>> mi_boton.conectar_sobre(cuando_pasa_sobre_el_boton)
    106
    107          :param funcion: Método a llamar cuando el botón pase a estado Normal.
    108          :param arg: Argumentos a pasar a la funcion.
    109          """
    110          t = (funcion, arg)
    111          self.funciones_over.append(t)
    112
    113 -    def desconectar_normal_todo(self):
    114          """ Elimina todas las funciones asociadas al estado normal del botón. """
    115          self.funciones_normal = []
    116
    117 -    def desconectar_presionado_todo(self):
    118          """ Elimina todas las funciones asociadas al estado presionado del botón. """
    119          self.funciones_press = []
    120
    121 -    def desconectar_sobre_todo(self):
    122          """ Elimina todas las funciones asociadas al estado sobre del botón. """
    123          self.funciones_over = []
    124
    125 -    def desconectar_normal(self, funcion, arg="null"):
    126          """ Elimina el método indicado asociado al estado normal del botón.
    127
    128          :param funcion: Método al que se llama cuando el botón pasa estado Normal.
    129          :param arg: Argumentos que se pasaban a la funcion.
    130          """
    131          t = (funcion, arg)
    132          self.funciones_normal.remove(t)
    133
    134 -    def desconectar_presionado(self, funcion, arg="null"):
    135          """ Elimina el método indicado asociado al estado presinado del botón.
    136
    137          :param funcion: Método al que se llama cuando el botón pasa estado Presionado.
    138          :param arg: Argumentos que se pasaban a la funcion.
    139          """
    140          t = (funcion, arg)
    141          self.funciones_press.remove(t)
    142
    143 -    def desconectar_sobre(self, funcion, arg="null"):
    144          """ Elimina el método indicado asociado al estado sobre del botón.
    145
    146          :param funcion: Método al que se llama cuando el botón pasa estado Sobre.
    147          :param arg: Argumentos que se pasaban a la funcion.
    148          """
    149          t = (funcion, arg)
    150          self.funciones_over.remove(t)
    151
    152 -    def ejecutar_funciones_normal(self):
    153          if self.estado == True:
    154              for i in self.funciones_normal:
    155                  if i[1] == "null":
    156                      i[0]()
    157                  else:
    158                      i[0](i[1])
    159
    160 -    def ejecutar_funciones_press(self):
    161          if self.estado == True:
    162              for i in self.funciones_press:
    163                  if i[1] == "null":
    164                      i[0]()
    165                  else:
    166                      i[0](i[1])
    167
    168 -    def ejecutar_funciones_over(self):
    169          if self.estado == True:
    170              for i in self.funciones_over:
    171                  if i[1] == "null":
    172                      i[0]()
    173                  else:
    174                      i[0](i[1])
    175
    176      # funciones para inactivar o activar las funciones conectadas
    177 -    def activar(self):
    178          self.estado = True
    179
    180 -    def desactivar(self):
    181          self.estado = False
    182
    183      # funciones que cambian la imagen del boton
    184 -    def pintar_normal(self):
    185          """ Dibuja el botón en estado normal. """
    186          self.definir_imagen(self.imagen_normal)
    187
    188 -    def pintar_presionado(self, ruta_press="null"):
    189          """ Dibuja el botón en estado presinado.
    190
    191          :param ruta_press: Opcional. Ruta de la imagen del boton presionado.
    192          :type ruta_press: string
    193          """
    194          if ruta_press == "null":
    195              self.imagen_press = pilas.imagenes.cargar(self.ruta_press)
    196          else:
    197              self.imagen_press = pilas.imagenes.cargar(ruta_press)
    198
    199          self.definir_imagen(self.imagen_press)
    200
    201 -    def pintar_sobre(self):
    202          """ Dibuja el botón en estado sobre. """
    203          self.definir_imagen(self.imagen_over)
    204
    205 -    def detection_move_mouse(self, evento):
    206          if self.colisiona_con_un_punto(evento.x, evento.y):
    207              self.ejecutar_funciones_over()
    208          else:
    209              self.ejecutar_funciones_normal()
    210
    211 -    def detection_click_mouse(self, click):
    212          if self.colisiona_con_un_punto(click.x, click.y):
    213              self.ejecutar_funciones_press()
    214
    215 -    def detection_end_click_mouse(self, end_click):
    216          pass
    217