#!/usr/bin/python
import gtk
import gobject

DELAY = 10

class MyApp():
    
    def __init__(self):
        window = gtk.Window()
        hbox = gtk.HBox()
        vbox = gtk.VBox()
        
        #asignacion de variables a widgest de gtk
        self.vadjustment = gtk.Adjustment()
        self.hadjustment = gtk.Adjustment()
        
        #asignacion de valores por defecto
        self.vadjustment.set_upper(100)
        self.vadjustment.set_value(0)
        self.hadjustment.set_upper(100)
        self.hadjustment.set_value(0)
        
        #asignacion de propiedades de widgets
        self.vslide = gtk.VScale(self.vadjustment)
        self.hslide = gtk.HScale(self.hadjustment)
        self.vslide.set_digits(0)
        self.hslide.set_digits(0)
        self.vslide.set_draw_value(False)
        self.hslide.set_draw_value(False)
        
        #variable global para desplazamiento del slide
        self.increment_x = 1
        self.increment_y = 1
        self.indicator_x = -1
        self.indicator_y = -1
        
        #asignacion de variables a widgest de gtk
        self.drawing_area = gtk.DrawingArea()
        self.drawing_area.set_size_request(600, 600)

        self.pixbuf = gtk.gdk.pixbuf_new_from_file('images/arco.jpg')

        window.connect('destroy', self.destroy)
        self.drawing_area.connect('configure_event', self.__configure_cb)
        self.drawing_area.connect('expose-event', self.__expose_cb)
        
        #eventos de widgets
        window.connect('key-press-event', self.__key_press_event_cb)
        #self.hslide.connect('key-press-event', self.__capturar_valor_hslider_cb)
        #self.vslide.connect('key-press-event', self.__capturar_valor_vslider_cb)

        #a;andiendo widgets dentro del contenedor principal
        window.add(hbox)
        hbox.add(vbox)
        vbox.add(self.drawing_area)
        vbox.add(self.hslide)
    	hbox.add(self.vslide)
        
        #mostrando los widgets
        window.show_all()
        
        #invocacion de la funcion que realiza loop del slider horizontal
        gobject.timeout_add(DELAY, self.__hslider_move_cb)
        
        
    #funcion que verifica el estado de los indicadores
    def __key_press_event_cb(self, window, event):
        gobject.timeout_add(DELAY, self.__vslider_move_cb)
        if self.indicator_x == 0:
            self.capturar_valor_vslider_cb()
        else:
            self.capturar_valor_hslider_cb()
            
        
    #funcion que hace el loop de los valores del slider vertical   
    def __hslider_move_cb(self):
        if self.indicator_x < 0:
            self.hadjustment.value += self.increment_x
        
            if self.hadjustment.value >= 100:
    	        self.increment_x *= -1
            elif self.hadjustment.value <= 0:
    	        self.increment_x *= -1
            return True
        else:
            return False
    
    #funcion que hace el loop de los valores del slider vertical
    def __vslider_move_cb(self):
        if self.indicator_y < 0:
            self.vadjustment.value += self.increment_y
        
            if self.vadjustment.value >= 100:
    	        self.increment_y *= -1
            elif self.vadjustment.value <= 0:
    	        self.increment_y *= -1
            return True
        else:
            return False
            
    #funcion que captura el valor del slider horizontal al pulsar una tecla    
    def capturar_valor_hslider_cb(self):
        #variable en donde se captura el valor al presionar un tecla
        self.hslide_value = self.hslide.get_value()

        #convierte el valor de changed_value a int
        self.cv_x = (((int(self.hslide_value)) * 600) / 100)
        
        #detener el slider
        self.indicator_x = 0
        #impresion temporal de prueba
        print self.cv_x
    
    #funcion que captura el valor del slider vertical al pulsar una tecla    
    def capturar_valor_vslider_cb(self):
        #variable en donde se captura el valor al presionar un tecla
        self.vslide_value = self.vslide.get_value()
        #valida el estilo del area de dibujo
        self.style = self.drawing_area.get_style()
        self.gc = self.style.fg_gc[gtk.STATE_NORMAL]
        #convierte el valor de changed_value a int
        self.cv_y = (((int(self.vslide_value)) * 600) / 100)
        #invoca a la funcion que dibuja la pelota de acuerdo a los valores del slider
        self.draw_ball(self.cv_x,self.cv_y)

        #detener el slider
        self.indicator_y = 0
        #impresion temporal de prueba
        print self.cv_y
        
    #funcion que dibuja la pelota
    def draw_ball(self, x, y):
        self.drawing_area.window.draw_arc(self.gc, False, x, y, 70, 70, 0, 360*64)

    def destroy(self, window, data=None):
        gtk.main_quit()

    def __configure_cb(self, drawing_area, data=None):
        x, y, width, height = drawing_area.get_allocation()

        canvas = drawing_area.window
        self.pixmap = gtk.gdk.Pixmap(canvas, width, height)

        self.pixmap.draw_pixbuf(None, self.pixbuf, 0, 0, 0, 0, -1, -1,
                                gtk.gdk.RGB_DITHER_NONE, 0, 0)
        return True

    def __expose_cb(self, drawing_area, data=None):
        x, y, width, height = data.area
        context = drawing_area.get_style().fg_gc[gtk.STATE_NORMAL]

        canvas = drawing_area.window
        canvas.draw_drawable(context, self.pixmap, x, y, x, y, width, height)

        return False

if __name__ == "__main__":
    my_app = MyApp()
    gtk.main()