Esempio n. 1
0
class PlayButton(ButtonBehavior, AsyncImage):
    angle = NumericProperty()

    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        self.source = 'play.png'
        self.anim = Animation(angle=360, duration=2)
        self.anim += Animation(angle=360, duration=2)
        self.anim.repeat = True
        self.running = False

    def on_press(self):
        self.source = 'play_blue.png'

    def start(self):
        self.running = True
        self.anim.start(self)
        self.source = 'cog.png'
        self.disabled = True

    def ready(self):
        self.anim.cancel(self)
        self.disabled = False
        self.source = 'play.png'
        self.angle = 0

    def on_angle(self, instance, values):
        """ Only needed so spinner goes after 360. """
        self.angle %= 360
Esempio n. 2
0
class MDCheckbox(ThemableBehavior, CircularRippleBehavior,
                 ToggleButtonBehavior, Label):
    active = BooleanProperty(False)

    _checkbox_icon = StringProperty(
        u"{}".format(md_icons['square-o']))
    _radio_icon = StringProperty(u"{}".format(md_icons['circle-o']))
    _icon_active = StringProperty(u"{}".format(md_icons['check-square']))

    def __init__(self, **kwargs):
        super(MDCheckbox, self).__init__(**kwargs)
        self.register_event_type('on_active')
        self.check_anim_out = Animation(font_size=0, duration=.1, t='out_quad')
        self.check_anim_in = Animation(font_size=sp(24), duration=.1,
                                       t='out_quad')
        self.check_anim_out.bind(
            on_complete=lambda *x: self.check_anim_in.start(self))

    def on_state(self, *args):
        if self.state == 'down':
            self.check_anim_in.cancel(self)
            self.check_anim_out.start(self)
            self._radio_icon = u"{}".format(md_icons['dot-circle'])
            self._checkbox_icon = u"{}".format(md_icons['check-square'])
            self.active = True
        else:
            self.check_anim_in.cancel(self)
            self.check_anim_out.start(self)
            self._radio_icon = u"{}".format(md_icons['circle-o'])
            self._checkbox_icon = u"{}".format(
                md_icons['square-o'])
            self.active = False

    def on_active(self, instance, value):
        self.state = 'down' if value else 'normal'
Esempio n. 3
0
class MDCheckbox(ThemableBehavior, CircularRippleBehavior,
                 ToggleButtonBehavior, Label):
	active = BooleanProperty(False)

	_checkbox_icon = StringProperty(
		u"{}".format(md_icons['md-check-box-outline-blank']))
	_radio_icon = StringProperty(u"{}".format(md_icons['md-radio-button-off']))
	_icon_active = StringProperty(u"{}".format(md_icons['md-check-box']))

	def __init__(self, **kwargs):
		super(MDCheckbox, self).__init__(**kwargs)
		self.register_event_type('on_active')
		self.check_anim_out = Animation(font_size=0, duration=.1, t='out_quad')
		self.check_anim_in = Animation(font_size=sp(24), duration=.1,
		                               t='out_quad')
		self.check_anim_out.bind(
			on_complete=lambda *x: self.check_anim_in.start(self))

	def on_state(self, *args):
		if self.state == 'down':
			self.check_anim_in.cancel(self)
			self.check_anim_out.start(self)
			self._radio_icon = u"{}".format(md_icons['md-radio-button-on'])
			self._checkbox_icon = u"{}".format(md_icons['md-check-box'])
			self.active = True
		else:
			self.check_anim_in.cancel(self)
			self.check_anim_out.start(self)
			self._radio_icon = u"{}".format(md_icons['md-radio-button-off'])
			self._checkbox_icon = u"{}".format(
					md_icons['md-check-box-outline-blank'])
			self.active = False

	def on_active(self, instance, value):
		self.state = 'down' if value else 'normal'
Esempio n. 4
0
class KivyPlayer(FloatLayout):
    def __init__(self, **kwargs):
        super(self.__class__, self).__init__(**kwargs)

    def hide_bars(self, instance, playing):
        if playing:
            self.list_button.state = 'normal'
            self.animationAB = Animation(y=self.height)
            self.action_bar.disabled = True
            self.animationAB.start(self.action_bar)
        else:
            self.action_bar.disabled = False
            self.action_bar.top = self.height
            if hasattr(self, 'animationAB'):
                self.animationAB.cancel(self.action_bar)

    def toggle_mute(self, instance, state):
        if state == 'down':
            self.video_controller.video.volume = 0
        else:
            self.video_controller.video.volume = 1

    def show_load_list(self):
        content = LoadDialog(load=self.load_list, cancel=self.dismiss_popup)
        self._popup = Popup(title="Load a file list",
                            content=content,
                            size_hint=(1, 1))
        self._popup.open()

    def load_list(self, path, filename):
        json_data = open(os.path.join(path, filename[0]))
        data = json.load(json_data)
        json_data.close()
        self.load_from_json(data)
        self.dismiss_popup()

    def load_from_json(self, data):
        self.playlist.clear_widgets()
        for val in data['results']:
            t = val['talk']
            video = self.video_controller.video
            meta = _meta % (t['id'], _api)
            surl = _surl % t['id']
            item = ListItem(video, meta, surl, text=t['name'])
            self.playlist.add_widget(item)
        self.list_button.state = 'down'

    def dismiss_popup(self):
        self._popup.dismiss()

    def search(self, text):
        url = _search % (text, _api)
        req = UrlRequest(url, self.got_search)

    def got_search(self, req, results):
        self.load_from_json(results)
Esempio n. 5
0
class MessagePopup(ModalView):
    
    _max = 3
    slots = [None for _ in range(_max)]
    replace = 0
    
    def __init__(self, **kwargs):
        self.message = kwargs.pop("message")
        self.fade = None
        self.dismiss_schedule = None
        super().__init__(**kwargs)
        
        # find a vacant slot or create one
        for i in range(self._max):
            if not self.slots[i]:
                empty_slot = i
                break
        else:
            empty_slot = MessagePopup.replace
            MessagePopup.replace += 1
            if MessagePopup.replace >= self._max:
                MessagePopup.replace = 0
            self.slots[empty_slot].dismiss()
        self.slot_index = empty_slot
        self.pos_hint = {"center_x": .5,
                         "center_y": .15 + .05 * empty_slot}
        self.slots[empty_slot] = self
    
    def on_touch_down(self, touch):
        pass
    
    def on_touch_move(self, touch):
        pass
    
    def on_touch_up(self, touch):
        pass
    
    def open(self, *largs, **kwargs):
        super().open(*largs, **kwargs)
        # schedule fading animation
        self.dismiss_schedule = Clock.schedule_once(self.close, 1.6)
    
    def close(self, *args):
        # start fading animation
        self.fade = Animation(opacity=0, t="in_sine", duration=0.6)
        self.fade.start(self)
        # fully dismiss popup after animation
        self.dismiss_schedule = Clock.schedule_once(self.dismiss, 0.6)
    
    def dismiss(self, *largs, **kwargs):
        super().dismiss(*largs, **kwargs)
        if self.fade:
            self.fade.cancel(self)
        if self.dismiss_schedule:
            self.dismiss_schedule.cancel()
        self.slots[self.slot_index] = None
Esempio n. 6
0
class Arrow(ButtonBehavior, Image):

    color = ListProperty([.761, .761, .761, 1])

    lwidth = NumericProperty(1.)

    duration = NumericProperty(.1)

    transition = OptionProperty('linear',
                                options=[
                                    'linear', 'out_elastic', 'out_back',
                                    'in_out_back', 'in_elastic', 'in_back',
                                    'in_bounce', 'in_out_bounce',
                                    'in_out_expo', 'out_quart', 'out_sine'
                                ])
    direction = OptionProperty(None, options=['left', 'right', 'up', 'down'])

    _anim = ObjectProperty()
    _radius = NumericProperty()
    _transition = StringProperty('linear')

    def on_transition(self, *args):
        self._transition = args[1]

    def on_direction(self, *args):

        if args[1] == 'right':
            self.source = 'images/arrow-right.png'
        elif args[1] == 'left':
            self.source = 'images/arrow-left.png'
        elif args[1] == 'up':
            self.source = 'images/arrow-up.png'
        elif args[1] == 'down':
            self.source = 'images/arrow-down.png'

    def on_touch_down(self, touch):

        if self.collide_point(*touch.pos):
            if not self._radius:
                self._anim = Animation(_radius=self.height * 1.2,
                                       d=self.duration,
                                       t=self._transition)
                self._anim.start(self)
        return super().on_touch_down(touch)

    def on_touch_up(self, touch):

        if self._radius:
            self._anim.cancel(self)
            self._radius = 0
        return super().on_touch_up(touch)
Esempio n. 7
0
class GameOverScreen(Screen):

    def __init__(self, **kwargs):
        super(GameOverScreen, self).__init__(**kwargs)
        self.rising_text = Animation(y=0, duration=2, t='out_bounce') # t is the transition, bouncy for meme value.
    
    def on_touch_down(self, touch, *args):
        self.manager.restart()

    def on_pre_enter(self):
        self.rising_text.start(self.txt)
    
    def on_leave(self):
        self.rising_text.cancel(self.txt) # Stop the animation before leaving
        self.txt.y = self.text_y
Esempio n. 8
0
class DevouredAccident(Accident):
    name = 'Devoured'

    headlines = [
        "devoured by the infamous slug monster. Bad luck!",
        "just swallowed by the terrible slug monster!",
        "next on the long list of the slug monster's victims!",
        "has never suspected he's gonna end up as a snack!",
        "devoured by the legendary slug monster from the nearby swamps!"
    ]

    sound = 'assets/sounds/Accidents/Devoured.mp3'
    image = 'atlas://assets/accidents/accidents/slug monster'

    def __init__(self, **kwargs):
        super().__init__(name=self.name,
                         headlines=self.headlines,
                         sound=self.sound,
                         image=self.image,
                         **kwargs)

    def happen(self):
        super().happen()
        self.monster = Image(source=self.image)
        self.monster.size_hint = (2, 2)
        self.monster.x = self.slug.body.x - 800
        self.monster.y = self.slug.body.y - 15
        self.slug.add_widget(self.monster)
        self.monster_animation = Animation(x=500, d=self.slug.running_time / 6)
        self.monster_animation.bind(on_progress=self.chase)
        self.monster_animation.start(self.monster)

    def chase(self, animation, monster, progression):
        if monster.x >= self.slug.body.x - 20 and not self.slug.devoured:
            self.slug.devoured = True
            self.slug.run_animation.stop(self.slug)
            self.monster_animation.cancel(self.monster)

    def reset(self):
        # Set the devoured property of the slug to False.
        self.slug.devoured = False

        # Check if the sound is still playing and if it is, stop it.
        if self.sound.state == 'play':
            self.sound.stop()

        # Remove the monster widget.
        self.slug.remove_widget(self.monster)
Esempio n. 9
0
class StartScreen(Screen):
    click_sound = SoundLoader.load('sound/Water Drop Low-SoundBible.com-1501529809.mp3')
    
    def on_pre_enter(self):
        if self.manager.music.state == 'stop':
            self.manager.music.play()
        self.bounce = Animation(size_hint= (0.35, 0.35))\
                + Animation(size_hint= (0.3,0.3))
        self.bounce.repeat = True
        self.bounce.start(self.ids.owl)
        self.bounce.start(self.ids.questions)
    def on_leave(self):
        self.bounce.cancel(self.ids.owl)
        self.bounce.cancel(self.ids.questions)

    def onClickSound(self):
        self.click_sound.play()
Esempio n. 10
0
class ChooseQuiz(Screen):
    click_sound = SoundLoader.load('sound/Water Drop Low-SoundBible.com-1501529809.mp3')
    
    def on_pre_enter(self):
        self.animate_buttons = Animation(size_hint = (0.0, 0.0))\
                            + Animation(size_hint = (1.0,1.0))
        self.animate_buttons.start(self.ids.layout)
 
    def setOption(self, text):
        self.parent.option = text
    
    def onClickSound(self):
        self.click_sound.play()

    def on_leave(self):
        if self.manager.music.state == 'play':
            self.manager.music.stop()
        self.animate_buttons.cancel(self.ids.layout)
Esempio n. 11
0
class HeadunitWidget(Widget):
    anim = 0
    bt_connected_anim = 0
    greeting = StringProperty('صباح الخير')
    lang = StringProperty('ar')
    is_greeting_visible = BooleanProperty(False)

    def update(self, dt):
        self.time_and_date.update(dt)

    def toggle(self, dt):
        if (self.is_greeting_visible):
            self.hide_greeting()
            self.is_greeting_visible = False
        else:
            self.show_greeting()
            self.is_greeting_visible = True

    def handle_bt_connected(self, dt):
        self.bt_connected()


    def hide_greeting(self):
        if (self.anim):
            self.anim.cancel(self.time_and_date)

        self.anim = Animation(scale=1, duration=0.3, t='in_out_cubic')
        self.anim &= Animation(y=0, duration=0.3, t='in_out_cubic')
        self.anim.start(self.time_and_date)

    def show_greeting(self):
        if (self.anim):
            self.anim.cancel(self.time_and_date)

        self.anim = Animation(scale=0.6, duration=0.3, t='in_out_cubic')
        self.anim &= Animation(y=dp(150), duration=0.3, t='in_out_cubic')
        self.anim.start(self.time_and_date)

    def bt_connected(self):
        if (self.bt_connected_anim):
            self.bt_connected_anim.cancel(self.bt_connection)

        self.anim = Animation(scale=0.6, duration=0.3, t='in_out_cubic')
        self.anim.start(self.bt_connection)
Esempio n. 12
0
class KoalaPaw(Image):

    def __init__(self, parent):
        super(KoalaPaw, self).__init__()
        self.size = PANDA_SIZE
        y = parent.pos[1] + Window.height / 50.0

        if parent.pos[0] < Window.width // 2:
            self.direction = 1
            self.pos = [-self.size[0], y]
        else:
            self.direction = -1
            self.pos = [Window.width, y]
            self.source = 'img/koalas/%s'
        self.source = 'img/koalas/%s.png' % self.direction

    def animation(self):
        if self.direction == 1:
            x = self.parent.x
        else:
            x = self.parent.right + self.parent.width / 4.0

        x -= self.parent.width / 2.0
        y = self.parent.y - self.parent.height / 2
        self.anim = Animation(x=x, y=y, d=0.5)
        self.anim.bind(on_complete=self.reverse_animation)
        self.anim.start(self)

    def reverse_animation(self, *args):
        self.parent.grab()
        self.source = 'img/koalas/p_%s.png' % self.direction

        if self.direction == 1:
            x = - self.width
        else:
            x = Window.width + self.width

        anim = Animation(x=x, y=self.parent.y - self.parent.height, d=0.5)
        anim.start(self)

    def game_over(self):
        self.anim.cancel(self)
        self.parent.remove_widget(self)
Esempio n. 13
0
class VideoController(FloatLayout):
    playing = ObjectProperty(None)

    def on_playing(self, instance, value):
        if value:
            self.animationVB = Animation(top=0)
            self.control_bar.disabled = True
            self.animationVB.start(self.control_bar)
        else:
            self.play_pause.state = 'normal'
            self.control_bar.disabled = False
            self.control_bar.y = 0

    def on_touch_down(self, touch):
        if self.collide_point(*touch.pos):
            if hasattr(self, 'animationVB'):
                self.animationVB.cancel(self.control_bar)
            self.play_pause.state = 'normal'
        return super(self.__class__, self).on_touch_down(touch)
Esempio n. 14
0
class KoalaPaw(Image):
    def __init__(self, parent):
        super(KoalaPaw, self).__init__()
        self.size = PANDA_SIZE
        y = parent.pos[1] + Window.height / 50.0

        if parent.pos[0] < Window.width // 2:
            self.direction = 1
            self.pos = [-self.size[0], y]
        else:
            self.direction = -1
            self.pos = [Window.width, y]
            self.source = 'img/koalas/%s'
        self.source = 'img/koalas/%s.png' % self.direction

    def animation(self):
        if self.direction == 1:
            x = self.parent.x
        else:
            x = self.parent.right + self.parent.width / 4.0

        x -= self.parent.width / 2.0
        y = self.parent.y - self.parent.height / 2
        self.anim = Animation(x=x, y=y, d=0.5)
        self.anim.bind(on_complete=self.reverse_animation)
        self.anim.start(self)

    def reverse_animation(self, *args):
        self.parent.grab()
        self.source = 'img/koalas/p_%s.png' % self.direction

        if self.direction == 1:
            x = -self.width
        else:
            x = Window.width + self.width

        anim = Animation(x=x, y=self.parent.y - self.parent.height, d=0.5)
        anim.start(self)

    def game_over(self):
        self.anim.cancel(self)
        self.parent.remove_widget(self)
Esempio n. 15
0
class motor_controller(App):
    angle = NumericProperty(360)
    max_speed = NumericProperty(_MAXSPEED)

    def __init__(self, motor, **kwargs):
        super(motor_controller, self).__init__(**kwargs)
        self.motor = motor
        self.anim = Animation(angle=0, duration=2)
        self.anim += Animation(angle=0, duration=2)
        self.anim.repeat = True

    def build(self):
        return MotorController()

    def set_speed(self):
        speed_value = self.root.ids.speed_value
        self.motor.speed = speed_value.value

    def power_button(self, instance, value):
        speed_value = self.root.ids.speed_value
        self.motor.power = value
        speed_value.disabled = not value
        if value:
            self.anim.start(self)
        else:
            self.anim.cancel(self)

    def change_direction(self):
        direction = self.root.ids.direction
        self.motor.change_dir()
        if self.motor.forward:
            direction.background_down = "reverse.png"
            direction.background_normal = "forward.png"

        else:
            direction.background_down = "forward.png"
            direction.background_normal = "reverse.png"

    def on_angle(self, item, angle):

        if angle == 0:
            item.angle = 360 if self.motor.forward else -360
Esempio n. 16
0
class InfoLabel(ShortLabel):
    """Special label widget that automatically displays a message from the app class and blinks when the text is changed."""

    bgcolor = ListProperty([1, 1, 0, 0])
    blinker = ObjectProperty()

    def on_text(self, instance, text):
        del instance
        app = App.get_running_app()
        if self.blinker:
            self.stop_blinking()
        if text:
            no_bg = [.5, .5, .5, 0]
            yes_bg = app.theme.info_background
            self.blinker = Animation(bgcolor=yes_bg, duration=0.33) + Animation(bgcolor=no_bg, duration=0.33) + Animation(bgcolor=yes_bg, duration=0.33) + Animation(bgcolor=no_bg, duration=0.33) + Animation(bgcolor=yes_bg, duration=0.33) + Animation(bgcolor=no_bg, duration=0.33) + Animation(bgcolor=yes_bg, duration=0.33) + Animation(bgcolor=no_bg, duration=0.33) + Animation(bgcolor=yes_bg, duration=0.33) + Animation(bgcolor=no_bg, duration=0.33) + Animation(bgcolor=yes_bg, duration=0.33) + Animation(bgcolor=no_bg, duration=0.33) + Animation(bgcolor=yes_bg, duration=0.33) + Animation(bgcolor=no_bg, duration=0.33)
            self.blinker.start(self)

    def stop_blinking(self, *_):
        if self.blinker:
            self.blinker.cancel(self)
        self.bgcolor = [1, 1, 0, 0]
Esempio n. 17
0
class SpinnerLabel(FloatLayout):
    angle = NumericProperty(0)
    color = StringProperty("#FFFFFF")
    icon = StringProperty('spinner')

    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        self.anim = Animation(angle=360, duration=1)
        self.anim += Animation(angle=360, duration=1)
        self.anim.repeat = True
        self.anim.start(self)

    def on_angle(self, item, angle):
        if angle == 360:
            item.angle = 0

    def stop_anim(self):
        self.anim.cancel(self)

    def start_anim(self):
        self.anim.start(self)
Esempio n. 18
0
class QuestionPanel(PanelBase):
    answerPanel=ObjectProperty(None)
    def animate(self):
        self.anim=Animation(y=self.parent.top,d=self.levelSpeed/2,t="linear")
        self.anim.bind(on_complete=self.next_question)
        self.anim.start(self)
        if self.answerPanel.disabled:
            self.answerPanel.disabled=False
    def endPros(self):
        if hasattr(self,"anim"):
            self.anim.cancel(self)
        anim=Animation(opacity=0,d=self.levelSpeed/10,t="linear")
        anim.bind(on_complete=self.go_wait)
        anim.start(self)
    def go_wait(self,ins,val):
        self.y=-self.height-10
        self.opacity=1
    def next_question(self,instance,val):
        self.answerPanel.disabled=True
        self.y=-self.height-10
        self.opacity=1
        self.answerPanel.animate()
Esempio n. 19
0
class MessageBox(RelativeLayout):

    padding = ListProperty([12, 12])
    color   = ListProperty([1, 1, 1, 1])
    text    = StringProperty('')

    def __init__(self, **kwargs):
        self._anim = None
        super(MessageBox, self).__init__(**kwargs)

    def show(self, text='', duration=10):
        self.hide()
        self.text = text
        self._anim  = Animation(opacity=1, d=1, t='in_out_expo')
        self._anim += Animation(opacity=0, d=max(1, duration-1), t='in_out_expo')
        self._anim.start(self)

    def hide(self):
        if self._anim is not None:
            self._anim.cancel(self)
            self._anim = None
        self.opacity = 0
Esempio n. 20
0
class IncrediblyCrudeClock(Label):
    a = NumericProperty(60)  # seconds

    def set_time(self, time):
        self.a = time

    def start(self):
        Animation.cancel_all(self)  # stop any current animations
        self.anim = Animation(a=0, duration=self.a)

        def finish_callback(animation, incr_crude_clock):
            create_simple_popup(
                "No More Time",
                "No Time Remaining, Please Talk to an Associate for More Time"
            ).open()
            if self.parent.name == 'mygrid':
                self.parent.playbutton.disabled = True

        self.anim.bind(on_complete=finish_callback)
        self.anim.start(self)

    def pause(self):
        self.anim.cancel(self)

    def add_time(self, time):
        self.anim.cancel(self)
        self.a += time
        if self.parent.name == 'mygrid':
            self.parent.playbutton.disabled = False

        self.start()

    def on_a(self, instance, value):
        hours = math.floor(value / 3600)
        minutes = math.floor((value % 3600) / 60)
        seconds = math.floor((value % 60))
        self.text = "{:02d}".format(hours) + ":" + "{:02d}".format(
            minutes) + ":" + "{:02d}".format(seconds)
Esempio n. 21
0
class LevelUpScreen(Screen):

    def __init__(self, **kwargs):
        super(LevelUpScreen, self).__init__(**kwargs)
        self.rising_text = Animation(y=0, duration=2, t='out_bounce') # t is the transition, bouncy for meme value.

    def on_touch_up(self, touch, **kwargs):

        """#def game_start(dt):
            #self.parent.game.update_loop = Clock.schedule_interval(self.parent.game.update, 1/UPDATE_RATE)

        game_start = self.parent.game.game_start
        
        Clock.schedule_once(game.game_start, self.parent.transition.duration) # Restarts update loop, put this before transition or risk memes.
        self.parent.current = 'game'"""
        self.parent.game_start()

    def on_pre_enter(self):
        self.rising_text.start(self.txt)
    
    def on_leave(self):
        self.rising_text.cancel(self.txt) # Stop the animation before leaving
        self.txt.y = -400
Esempio n. 22
0
class KivyPlayer(FloatLayout):
    def hide_bars(self, instance, playing):
        if playing:
            self.list_button.state = "normal"
            self.animationAB = Animation(y=self.height)
            self.action_bar.disabled = True
            self.animationAB.start(self.action_bar)
        else:
            self.action_bar.disabled = False
            self.action_bar.top = self.height
            if hasattr(self, "animationAB"):
                self.animationAB.cancel(self.action_bar)
    def toggle_mute(self, instance, state):
        if state == "down":
            self.video_controller.video.volume = 0
        else:
            self.video_controller.video.volume = 1

    def show_load_list(self):
        pass

    def search(self, text):
        pass
Esempio n. 23
0
class Score(TitleScreen):
    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        self.press_ok_anim2 = None
        self.out_anim_1 = None
        self.out_anim_2 = None
        App.get_running_app().add_callback(
            CEC_CMD_MAP["OK"], "score",
            partial(self.goto_func,
                    App.get_running_app().load_game))
        App.get_running_app().add_callback(
            CEC_CMD_MAP["RED"], "score",
            partial(
                self.goto_func,
                partial(App.get_running_app().goto_screen, s_name='options')))

    def start_secondary_anims(self, anim, widget, direction):
        if direction == 'in':
            # The "Press OK" label is animated manually, because it has a special fade-in
            # animation. However, we want it to fade out just like the other widgets. Hence,
            # we set auto_anim to True after it has been animated it. Later, we override the
            # reset_widgets function to set auto_anim back to False after calling super's
            # reset_widgets.
            self.press_ok_anim2 = Animation(opacity=1) + Animation(opacity=0.5)
            self.press_ok_anim2.repeat = True
            Clock.schedule_once(
                lambda dt: self.press_ok_anim2.start(self.ids.press_ok), 0.2)
        else:
            self.ids.press_ok.auto_anim = True
            self.press_ok_anim2.cancel(self.ids.press_ok)
        return super().start_secondary_anims(anim, widget, direction)

    def reset_widgets(self):
        # See explanation above
        super().reset_widgets()
        self.ids.press_ok.auto_anim = False
Esempio n. 24
0
class MessageBox(RelativeLayout):

    padding = ListProperty([12, 12])
    color = ListProperty([1, 1, 1, 1])
    text = StringProperty('')

    def __init__(self, **kwargs):
        self._anim = None
        super(MessageBox, self).__init__(**kwargs)

    def show(self, text='', duration=10):
        self.hide()
        self.text = text
        self._anim = Animation(opacity=1, d=1, t='in_out_expo')
        self._anim += Animation(opacity=0,
                                d=max(1, duration - 1),
                                t='in_out_expo')
        self._anim.start(self)

    def hide(self):
        if self._anim is not None:
            self._anim.cancel(self)
            self._anim = None
        self.opacity = 0
Esempio n. 25
0
class AnswerPanel(PanelBase):
    ready=False
    centerx=None
    centery=None
    questionPanel=ObjectProperty(None)
    statePanel=ObjectProperty(None)
    level="Basic"
    stage=NumericProperty(1)
    def on_stage(self,ins,val):
        if not val or val==0:
            return
        if val==1:
            self.levelSpeed=12
            self.questionPanel.levelSpeed=12
        elif val==2:
            self.levelSpeed=10
            self.questionPanel.levelSpeed=10
        elif val==3:
            self.levelSpeed=9
            self.questionPanel.levelSpeed=9
        elif val==4:
            self.levelSpeed=8
            self.questionPanel.levelSpeed=8
        self.stage=val
    def animate(self):
        self.anim=Animation(x=-self.width,d=self.levelSpeed/4,t="in_sine")
        self.anim.bind(on_complete=self.next_answer)
        self.anim.start(self)
    def generateNextAnswer(self,a,b,c,d,ranswer):
        self.abtn.text=str(a)
        self.bbtn.text=str(b)
        self.cbtn.text=str(c)
        self.dbtn.text=str(d)
        self.reanswer=str(ranswer)
    def answerClick(self):
        self.disabled=True
        if hasattr(self,"anim"):
            self.anim.cancel(self)
        if hasattr(self.questionPanel,"anim"):
            self.questionPanel.endPros()
    def makeAnswerPanel(self,ans):
        idx=randint(0,3)
        for a in range(len(ans)):
            if idx==a:
                tmp=ans[a]
                ans[a]=ans[3]
                ans[3]=tmp
        self.generateNextAnswer(ans[0],ans[1],ans[2],ans[3],ans[idx])
    def next_answer(self,instance,val):
        self.prepare_next(dt=None)
    @mainthread
    def prepare_next(self,dt):
        self.generateGameQuestion(self.level)
        self.y=self.parent.height/2-self.height/1.5
        self.x=-self.width-10
        anim=Animation(x=10,d=self.levelSpeed/4,t="in_out_back")
        anim.bind(on_complete=self.prepareQuestionPanel)
        anim.start(self)
    def prepareQuestionPanel(self,ins,val):
        if hasattr(self.questionPanel,"anim"):
            self.questionPanel.go_wait(ins=None,val=None)
        self.questionPanel.opacity=1
        self.questionPanel.animate()
    @mainthread
    def showRightAns(self):
        MediaPlayer().play("pick")
        self.parent.score +=5
        self.statePanel.qLabel.text="[color=#00FFFF]Doğru Bildiniz!Tebrikler[/color]"
        self.statePanel.showAnim()
        anim=Animation(y=-self.height,d=self.levelSpeed/5)
        anim.bind(on_complete=self.next_answer)
        anim.start(self)
    @mainthread
    def showWrongAns(self):
        MediaPlayer().play("loose")
        self.statePanel.qLabel.text="[color=#d62d20]Bilemediniz!! "+str(self.reanswer)+"[/color]"
        self.statePanel.showAnim()
        self.animate()
    @mainthread
    def generateGameQuestion(self,level=None):
        self.disabled=True
        if self.stage<=2:
            ky=KyMath()
            ky.generateStage(level=level)
            ky.findSolution()
            ans1,ans2,ans3=ky.generateRandomAns(self.level)
            ans=[]
            ans.append(ans1)
            ans.append(ans2)
            ans.append(ans3)
            ans.append(ky.solution)
            self.parent.ans=ky.solution
            txt="("+str(ky.num1)+")"+ky.taskToStr(ky.task)+"("+str(ky.num2)+")=?"
            self.questionPanel.qLabel.text=txt
            self.makeAnswerPanel(ans)
        elif self.stage>2:
            ky=KyEquationResolver()
            ky.generateRandomNum(self.level)
            ky.generateTask()
            numx,num=ky.findSolutions()
            num1x,num1,num2x,num2,num3x,num3=ky.generateRandomAns(numx,num)
            ans=[]
            str1=self.checkZeroAnOne(ky,num1x,num1)
            str2=self.checkZeroAnOne(ky,num2x,num2)
            str3=self.checkZeroAnOne(ky,num3x,num3)
            soli=self.checkZeroAnOne(ky,numx,num)
            ans.append(str1)
            ans.append(str2)
            ans.append(str3)
            ans.append(soli)
            self.parent.ans=soli
            txt1=self.checkZeroAnOne(ky,ky.num1,ky.num2)
            txt2=self.checkZeroAnOne(ky,ky.num3,ky.num4)
            txt="("+txt1+")+("+txt2+")"
            self.questionPanel.qLabel.text=txt
            self.makeAnswerPanel(ans)

        else:
            self.parent.game_end=True

    def checkZeroAnOne(self,ky,xnum,num):
        if num==0 and xnum==0:
            return "0"
        elif xnum==0 and num!=0:
            return ky.markerToStr(num)+str(abs(num))
        elif xnum!=0 and num==0:
            return ky.markerToStr(xnum)+str(abs(xnum))+"x"
        elif (xnum==1 or xnum==-1) and num!=0:
            return ky.markerToStr(xnum)+"x"+ky.markerToStr(num)+str(abs(num))
        elif (xnum==1 or xnum==-1) and num==0:
            return ky.markerToStr(xnum)+"x"
        else:
            return  str(xnum)+"x"+ky.markerToStr(num)+str(abs(num))
Esempio n. 26
0
class ImmersiveLayout(StencilView):
    immersed = BooleanProperty(None)
    '''State of the layout. If True, the dock is hidden. '''
    auto_show = BooleanProperty(True)
    '''Boolean specifying whether input events trigger the ImmersiveLayout to exit immersive mode.'''
    auto_hide = BooleanProperty(True)
    '''Boolean specifying whether the dock will hide after **timeout** seconds.'''
    timeout = NumericProperty(5)
    '''Time after the last input event (keyboard, touch, mouse) after which the dock is hidden. If set to 0, the layout
    will stay opened until manually closed.'''
    animation_duration = NumericProperty(0.75)
    '''Speed at which the dock opens, in seconds. '''
    max_dock_size = NumericProperty(0.2)
    '''Maximum dock size as a fraction of the ImmersiveLayout's size. '''
    fade = BooleanProperty(True)
    '''Boolean specifying whether the dock fades into view when opening. '''
    transition = StringProperty('in_out_sine')
    '''The name of the animation transition type to use when animating. Defaults to 'out_cubic'.'''
    _anim_progress = NumericProperty(1 * (not immersed))
    ''' Internal parameter monitoring the progress of the dock's opening animation. 1 is opened, 0 is closed.'''
    _anim = ObjectProperty(None)
    '''Animation. '''
    _scheduled_close = ObjectProperty(None, allownone=True)
    '''Scheduled close event. '''
    main_panel = ObjectProperty(None, allownone=True)
    '''Automatically bound to whatever widget is added as the main panel.'''
    dock = ObjectProperty(None, allownone=True)
    '''Automatically bound to whatever widget is added as the dock.'''
    def __init__(self, **kwargs):
        super(ImmersiveLayout, self).__init__(**kwargs)
        self._anim = Animation(_anim_progress=1 * (not self.immersed),
                               duration=self.animation_duration,
                               t=self.transition)
        Window.bind(on_keyboard=self._keyboard_handler)
        self.register_event_type('on_enter_immersive')
        self.register_event_type('on_exit_immersive')
        self.register_event_type('on_finished_entering')
        self.register_event_type('on_finished_exiting')

    def _keyboard_handler(self, window, key, *args):
        """
        If auto_show is True. The first keyboard event will open the dock and block. If the dock is opened, then the
        key events will be passed
        """
        if self.auto_show:
            immersed = self.immersed
            #self.immersed = False
            self.exit_immersive_mode()
            self._schedule_close()
            # If the dock was opened, pass on the event, otherwise block it from the system
            return immersed

    def add_widget(self, widget, index=0):
        """
        The first two widget we add are the containers for the main panel and dock, _main_panel and _dock, this is done
        automatically by instantiating the class. After, when the user adds widgets to the ImmersiveLayout, we add the
        first widget supplied to the the _main_panel and the second widget to the _dock.
        """
        if len(self.children) == 0:
            super(ImmersiveLayout, self).add_widget(widget)
            self._main_panel = widget
        elif len(self.children) == 1:
            super(ImmersiveLayout, self).add_widget(widget)
            self._dock = widget
        elif self.main_panel is None:
            self._main_panel.add_widget(widget)
            self.main_panel = widget
        elif self.dock is None:
            self._dock.add_widget(widget)
            self.dock = widget

    def cancel_scheduled_close(self):
        """
        Cancel a scheduled close and schedule a new one.
        """
        if self._scheduled_close:
            self._scheduled_close.cancel()

    def _schedule_close(self, *args):
        """
        Schedules a close event for the dock.
        """
        if self.timeout > 0:
            self.cancel_scheduled_close()
            self._scheduled_close = Clock.schedule_once(
                self.enter_immersive_mode, self.timeout)

    def toggle_state(self, *args):
        """
        Toggle the state of immersion
        """
        if self.immersed:
            self.exit_immersive_mode()
        else:
            self.enter_immersive_mode()

    def enter_immersive_mode(self, *args):
        """
        Enter immersive mode.
        """
        self._anim.cancel(self)
        self._anim = Animation(_anim_progress=0,
                               duration=self.animation_duration,
                               t=self.transition)
        self._anim.start(self)
        self._anim.bind(
            on_complete=lambda *x: self.dispatch('on_finished_entering'))
        self.immersed = True
        self.dispatch('on_enter_immersive')

    def exit_immersive_mode(self, *args):
        """
        Exit immersive mode.
        """
        self._anim.cancel(self)
        self._anim = Animation(_anim_progress=1,
                               duration=self.animation_duration,
                               t=self.transition)
        self._anim.start(self)
        self.immersed = False
        self._anim.bind(
            on_complete=lambda *x: self.dispatch('on_finished_exiting'))
        self.dispatch('on_exit_immersive')
        # Schedule a close event if auto_hide is enabled.
        if self.auto_hide:
            self._schedule_close()

    def on_enter_immersive(self, *args):
        """
        Signals the beginning of the event to enter immersive mode.
        """
        pass

    def on_finished_entering(self, *args):
        """
        Signals the end of the event to enter immersive mode.
        """
        pass

    def on_exit_immersive(self, *args):
        """
        Signals the beginning of the event to leave immersive mode.
        """
        pass

    def on_finished_exiting(self, *args):
        """
        Signals the end of the event to exit immersive mode.
        """
        pass

    def on_auto_hide(self, *args):
        if self.timeout > 0:
            # Store the value of the timeout in case we turn on auto_hide again.
            self._timeout = self.timeout
        if self._scheduled_close:
            self._scheduled_close.cancel()
        self.timeout = self._timeout * self.auto_hide
        if self.auto_hide:
            self._schedule_close()

    def on_touch_down(self, touch):
        if self.auto_show:
            immersed = self.immersed
            if not self.immersed:
                self.cancel_scheduled_close()
            self.exit_immersive_mode()
            # While the dock is hidden, do not pass the touch event through.
            if immersed:
                return
            else:
                super(ImmersiveLayout, self).on_touch_down(touch)
        else:
            super(ImmersiveLayout, self).on_touch_down(touch)
Esempio n. 27
0
class Cow(Image):

    alpha = NumericProperty(0)
    source = StringProperty('')

    def __init__(self, x, index, on_horizon=False):
        super(Cow, self).__init__()

        self.size = [COW_WIDTH, COW_HEIGHT]
        self.direction = random.choice((-1, 1))
        self.file = 'img/cows/cow_0{0}/'.format(random.randint(1, 2))
        self.balloon = None
        self.index = index
        self.expression = None
        # self.answer = None
        self.is_flying = False

        if on_horizon:
            y = BOTTOM_BORDER
            self.source = self.file + '{0}.png'.format(self.direction)
            self.pos = [x, y]
            self.__move()
        else:
            y = random.randint(
                int(2 * BOTTOM_BORDER), int(Window.height - COW_HEIGHT))
            # print int(2 * BOTTOM_BORDER), Window.height - COW_HEIGHT, 'sdsd'
            self.pos = [x, y]
            self.fall()

        # I guess there is another word for stealing cows.
        # Maybe it's 'stealing?'
        # Anyway i put it this way ^_^
        # self.horizon = horizon

        Clock.schedule_interval(
            self.__reduce_transparency, VELOCITY_UPDATE_TIME)

    def __reduce_transparency(self, timing=None):
        # print 'alpha', self.alpha
        if self.alpha >= 1:
            return False
        self.alpha += 0.05

    def fall(self, *args):
        try:
            self.fly_anim.cancel(self)
            # self.remove_widget(self.balloon)
        except AttributeError:
            pass

        self.source = self.file + 'fall_{0}.png'.format(self.direction)

        duration = 0.6 if self.center[1] <= Window.height / 2 else 1.3
        anim = Animation(x=self.x, y=BOTTOM_BORDER, d=duration)
        anim.bind(on_complete=lambda *args: self.__move())
        anim.start(self)

    def __fly(self, *args):
        # self.is_flying = True

        self.source = self.file + '{0}.png'.format(self.direction)
        self.fly_anim = Animation(
            x=self.x, y=Window.height, d=FLYING_TIME, t='in_quad')
        # self.fly_anim.bind(on_complete=lambda *args: self.fall())
        self.fly_anim.bind(on_progress=self.__check_if_flew_away)
        self.fly_anim.start(self)

    def __move(self, *args):
        self.is_flying = False
        if random.random() <= 0.8:
            self.direction = random.choice((-1, 1))
            self.source = self.file + '{0}.zip'.format(self.direction)
            self.anim_delay = 0.1

            dx = self.direction * \
                random.randint(0.3 * COW_WIDTH, 0.9 * COW_WIDTH)
            x = int(self.x + dx)
            self.move_anim = Animation(x=x, y=BOTTOM_BORDER)
            self.move_anim.bind(on_complete=self.__move)
            self.move_anim.start(self)
        else:
            self.stop()

    def __check_if_flew_away(self, *args):
        if self.y >= Window.height:
            try:
                self.fly_anim.cancel(self)
                self.parent.lose_the_cow(self)
                # print 'flew away'
            except AttributeError:
                pass
            return

    def check_collision_with(self, another_cow=None):
        if self.is_flying:
            return
        # or another_cow.is_flying:
                # print self.parent
                # print self.index
                # self.parent.lose_the_cow(self)
                # del self
                # self.parent.lose_the_cow(self)

        # if self.x <= another_cow.right and self.right >= another_cow.x:
        #     collision = True, True
        #     self.x -= 3
        # elif self.x >= another_cow.x and self.x <= another_cow.right:
        #     self.x += 3
        #     collision = True, True
        # else:
        #     collision = False, False

        collision = False
        if self.x <= 0:
            self.x = 3
            collision = True
        elif self.right >= Window.width:
            self.x -= 3
            collision = True

        if collision:
            self.stop()

    def stop(self):
        try:
            self.move_anim.cancel(self)
        except AttributeError:
            pass
        self.source = self.file + '{0}.png'.format(self.direction)
        Clock.schedule_once(self.__move, random.uniform(0.5, 1.5))

    def get_kidnapped(self):
        self.is_flying = True
        try:
            self.move_anim.cancel(self)
        except AttributeError:
            pass

        if self.balloon:
            return

        Clock.unschedule(self.__move)
        self.balloon = Balloon()
        self.balloon.center = self.center[0], self.top + COW_WIDTH / 2
        self.add_widget(self.balloon)
        # self.balloons.append(balloon)
        self.balloon.inflate()
        self.__fly()

    def check_answer(self, value):
        if self.balloon and self.balloon.answer == value:
            self.remove_widget(self.balloon)
            self.balloon = None
            self.fall()
            return True

        return False

    def collide_point(self, x, y=None):
        if (not self.is_flying and x >= self.x - COW_WIDTH
                and x <= self.right + 10):
            # print self.x, x
            return True
        else:
            return False

    def game_over(self):
        self.remove_widget(self.balloon)
        self.balloon = None
        self.fall()
Esempio n. 28
0
class ZIScatter(Scatter):
    zoom_image = ObjectProperty(Widget())
    init_pos = ObjectProperty((75, 70))

    def __init__(self, **kwargs):
        super(ZIScatter, self).__init__(**kwargs)
        self.anim = Animation()  # Physics simple animation on touch up
        Clock.schedule_interval(self.clear_canvas, 0)
        Clock.schedule_interval(self.control_pos, 0)

    def clear_canvas(self, dt):
        self.canvas.clear()

    def is_leaving_its_box(self):
        #check if scatter is leaving its box
        s = self.scale
        x, y = self.pos
        w, h = self.size
        container = c = self.zoom_image
        #check every corner
        limitx = limity = False
        if (x > c.x or x + w * s < c.x + c.width):
            limitx = True
        if (y > c.y or y + h * s < c.y + c.height):
            limity = True
        return (limitx, limity)

    def fix_after_leaving_its_box(self):
        #check if scatter is leaving its box
        s = self.scale
        x, y = self.pos
        w, h = self.size
        container = c = self.zoom_image
        #check every corner
        limitx = limity = False
        if x > c.x:
            x = c.x
        if x + w * s < c.x + c.width:
            x = c.x + c.width - w * s
        if y > c.y:
            y = c.y
        if y + h * s < c.y + c.height:
            y = c.y + c.height - h * s
        self.pos = (x, y)

    def control_pos(self, dt):
        if self.scale <= 1.03:
            self.reset()
            pass
        #avoid scatter leaving its box while physics animation is going on (after touch up)
        if len(self._touches) > 0:
            return
        limitx, limity = self.is_leaving_its_box()
        if limitx == True or limity == True:
            self.anim.cancel(self)
            self.fix_after_leaving_its_box()

    def transform_with_touch(self, touch):
        init_pos = self.center
        init_scale = self.scale
        init_touch_len = len(self._touches)
        #super(ZIScatter, self).transform__with__touch(touch)

        # just do a simple one finger drag
        if len(self._touches
               ) == 1 and self.scale > 1.05:  #THIS IS NOT IN ORIGINAL SCATTER:
            # _last_touch_pos has last pos in correct parent space,
            # just like incoming touch
            dx = (touch.x - self._last_touch_pos[touch][0]) \
                    * self.do_translation_x
            dy = (touch.y - self._last_touch_pos[touch][1]) \
                    * self.do_translation_y
            self.apply_transform(Matrix().translate(dx, dy, 0))
            #return

        elif len(
                self._touches
        ) == 1 and self.scale < 1.05:  #THIS IS NOT IN ORIGINAL SCATTER:
            return

        else:  #TO AVOID RETURN IN ORIGINAL SCATTER
            # we have more than one touch...
            points = [Vector(self._last_touch_pos[t]) for t in self._touches]

            # we only want to transform if the touch is part of the two touches
            # furthest apart! So first we find anchor, the point to transform
            # around as the touch farthest away from touch
            anchor = max(points, key=lambda p: p.distance(touch.pos))

            # now we find the touch farthest away from anchor, if its not the
            # same as touch. Touch is not one of the two touches used to transform
            farthest = max(points, key=anchor.distance)
            if points.index(farthest) != self._touches.index(touch):
                return

            # ok, so we have touch, and anchor, so we can actually compute the
            # transformation
            old_line = Vector(*touch.ppos) - anchor
            new_line = Vector(*touch.pos) - anchor

            angle = radians(new_line.angle(old_line)) * self.do_rotation
            self.apply_transform(Matrix().rotate(angle, 0, 0, 1),
                                 anchor=anchor)

            if self.do_scale:
                scale = new_line.length() / old_line.length()
                new_scale = scale * self.scale
                if new_scale < self.scale_min or new_scale > self.scale_max:
                    scale = 1.0
                self.apply_transform(Matrix().scale(scale, scale, scale),
                                     anchor=anchor)

        #avoid scatter leaving its box
        limitx, limity = self.is_leaving_its_box()
        if limitx or limity:
            #cancel previous apply_transform
            if init_touch_len == 1:
                ddx = ddy = 0
                if limitx: ddx = -dx
                if limity: ddy = -dy
                self.apply_transform(Matrix().translate(ddx, ddy, 0))
            else:
                if self.do_scale:
                    #self.apply_transform(Matrix().scale(scale/init_scale, scale/init_scale, scale/init_scale),
                    #             anchor=anchor)
                    # control
                    #limitx, limity = self.is_leaving_its_box()
                    #if limitx or limity:
                    self.fix_after_leaving_its_box()

    def on_touch_down(self, touch):
        ret = super(ZIScatter, self).on_touch_down(touch)
        x, y = touch.x, touch.y
        #if not self.zoom_image.image.collide_point(x,y):
        #    # did not touch the mask area
        #    return True

        # if the touch isnt on the widget we do nothing
        if self.zoom_image.collide_point(x, y):
            if touch.is_double_tap:
                self.reset()

        #if not self.parent.image.collide_point(x,y):
        #    # did not touch the mask area
        #    touch.ud["outside"] = True
        #    return False

        return ret

    def on_touch_up(self, touch):
        if touch.grab_current is not self:
            return super(ZIScatter, self).on_touch_up(touch)
        """
        x, y = touch.x, touch.y
        # if the touch isnt on the widget we do nothing
        if self.zoom_image.collide_point(x, y):
            super(ZIScatter, self).on_touch_up(touch)
        """

        ###TAKEN FROM ORIGINAL SCATTER
        x, y = touch.x, touch.y
        # if the touch isnt on the widget we do nothing, just try children
        if self.zoom_image.collide_point(x, y):  #MODIFIED ORIGINAL SCATTER !!
            if not touch.grab_current == self:
                touch.push()
                touch.apply_transform_2d(self.to_local)
                if super(Scatter, self).on_touch_up(touch):
                    touch.pop()
                    return True
                touch.pop()

        # remove it from our saved touches
        if touch in self._touches and touch.grab_state:
            touch.ungrab(self)
            del self._last_touch_pos[touch]
            self._touches.remove(touch)

        # stop propagating if its within our bounds
        if self.collide_point(x, y):
            pass  #eturn True #MODIFIED ORIGINAL SCATTER !!

        # physics behaviour on touch up, fade speed down on the same direction
        return False

        duration = d = 1.5
        dx = touch.dx * 3 * d
        dy = touch.dy * 3 * d
        #print dx, dy
        adx = abs(dx)
        ady = abs(dy)
        if adx > 0 and ady > 0:
            #if adx > 400 :
            #if ady > 400 :
            V = Vector(self.center)
            Vd = Vector((dx, dy))
            destination = V + Vd

            anim = Animation(center=destination, d=d, t='out_expo', s=1 / 150.)
            self.anim.stop(self)
            self.anim = anim
            self.anim.start(self)
            self.previous_anim_dest = destination
        return False

    def reset(self):
        self.center = self.init_pos
        self.scale = 1
Esempio n. 29
0
class MainScreen(Screen):
    list = DictProperty(dictionary)

    def __init__(self, **kwargs):
        super(MainScreen, self).__init__(**kwargs)
        self._keyboard = Window.request_keyboard(self._keyboard_closed, self)
        self._keyboard.bind(on_key_down=self._on_keyboard_down)
        self.motConVehicleVelocity = '0'
        self.server_address = "/tmp/mySocket"
        self.sock = socket.socket()
        self.data = {}
        self.left_turn_signal = True
        self.right_turn_signal = True
        self.light_one = Animation(color=[.92, .73, .44, 1]) + Animation(
            color=[.33, .33, .33, 1])
        self.light_one.repeat = True
        self.light_two = Animation(color=[.92, .73, .44, .75]) + Animation(
            color=[.33, .33, .33, 1])
        self.light_two.repeat = True
        self.light_three = Animation(color=[.92, .73, .44, .5]) + Animation(
            color=[.33, .33, .33, 1])
        self.light_three.repeat = True
        Clock.schedule_once(self._finish_init)

    def _finish_init(self, dt):
        logging.info("Kivy has finished loading.")
        logging.info("Starting thread to read from socket : " +
                     self.server_address)
        Thread(target=self.main).start()

    def main(self):
        # Create a UDS socket
        sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)

        # Connect the socket to the port where the server is listening
        # print ('connecting to %s' % server_address, file=sys.stderr)
        try:
            sock.connect(self.server_address)
            logging.info("Socket connected to: " + self.server_address)
        except socket.error as msg:
            logging.critical(msg)
            sys.exit(1)

        try:

            # Send data
            # message = b'This is the message.  It will be repeated.'
            # print ('sending "%s"' % message, file=sys.stderr)
            # sock.sendall(message)

            amount_received = 0
            # amount_expected = len(message)

            # while amount_received < amount_expected:
            while True:
                data = sock.recv(4096)
                # amount_received += len(data)
                try:
                    self.data = loads(data.decode())
                    self.list = self.data
                    self.update(self.data)
                except:
                    logging.critical("ERROR loading data")
        finally:
            # print ('closing socket', file=sys.stderr)
            sock.close()
            logging.info("Socket Closed" + self.server_address)
            # pass

    def animate_left_lights(self, data):

        self.left_turn_signal = False
        self.light_one.start(self.ids.left1)
        self.light_two.start(self.ids.left2)
        self.light_three.start(self.ids.left3)

    def animate_right_lights(self, data):

        self.right_turn_signal = False
        self.light_one.start(self.ids.right1)
        self.light_two.start(self.ids.right2)
        self.light_three.start(self.ids.right3)

    def stop_animate_right_lights(self, data):

        self.light_one.cancel(self.ids.right1)
        self.light_two.cancel(self.ids.right2)
        self.light_three.cancel(self.ids.right3)
        self.ids.right1.color = [1, 1, 1, 1]
        self.ids.right2.color = [.92, .73, .44, 0]
        self.ids.right3.color = [.92, .73, .44, 0]
        self.right_turn_signal = True

    def stop_animate_left_lights(self, data):

        self.light_one.cancel(self.ids.left1)
        self.light_two.cancel(self.ids.left2)
        self.light_three.cancel(self.ids.left3)
        self.ids.left1.color = [1, 1, 1, 1]
        self.ids.left2.color = [.92, .73, .44, 0]
        self.ids.left3.color = [.92, .73, .44, 0]
        self.left_turn_signal = True

    def set_lights(self, turn_signal):
        self.turn_signal = turn_signal

    net_gauge = ListProperty([1, 1, 1, 1])
    soc = ListProperty([1, 1, 1, 1])

    @mainthread
    def update(self, data):
        if self.data['gpio5'] == 1 and self.right_turn_signal:
            self.animate_right_lights(data)
        elif self.data['gpio5'] == 0:
            self.stop_animate_right_lights(data)
        if self.data['gpio6'] == 1 and self.left_turn_signal:
            self.animate_left_lights(data)
        elif self.data['gpio6'] == 0:
            self.stop_animate_left_lights(data)

        self.soc = self.soc_color(data['soc'])
        self.net_gauge = percentColor(self.data['netPower'])
        # ---------------------------------

        self.manager.raw_data_screen.populate(data)
        self.manager.dev_screen.update(data)
        App.get_running_app().update(data)
        self.net_gauge = percentColor(self.data['netPower'])

    def soc_color(self, num):
        range_key_dict = RangeKeyDict({
            (0, 26): [.99, .40, .34, 1],
            (26, 51): [.99, .71, .36, 1],
            (51, 76): [.99, .84, .21, 1],
            (76, 101): [.36, .83, .59, 1]
        })
        return range_key_dict[num]

    def _keyboard_closed(self):
        self._keyboard.unbind(on_key_down=self._on_keyboard_down)
        self._keyboard = None

    def _on_keyboard_down(self, keyboard, keycode, text, modifiers):
        if keycode[1] == '1':
            self.manager.current = 'settings_screen_name'
        elif keycode[1] == '2':
            self.manager.current = 'main_screen_name'
        elif keycode[1] == '3':
            self.manager.current = 'dev_screen_name'
        elif keycode[1] == '4':
            self.manager.current = 'raw_data_screen_name'
        elif keycode[1] == '5':
            self.manager.current = 'error_screen_name'
        elif keycode[1] == '9':
            App.get_running_app().stop()
        return True
Esempio n. 30
0
class AtomWidget(BoardItem, Widget):
    bg_color = ListProperty(Colors.BLACK(0.0))
    color = ListProperty(Colors.BLACK())
    color_alpha = ListProperty(Colors.BLACK(0.33))
    anim = ObjectProperty(None, allownone=True)
    spacing = NumericProperty(0)
    status = NumericProperty(0)
    atom = ObjectProperty(None, rebind=True)
    index = ObjectProperty(None)

    def __init__(self, **kwargs):
        Widget.__init__(self, **kwargs)
        self.bind(index=self.move_to)
        # BoardItem.__init__(self, *args, **kwargs)#, atom, index, status)

    def move_to(self, *args):
        if self.anim:
            self.anim.cancel(self)
            self.anim = None
        self.anim = Animation(pos=self.parent.index_to_pos(self.index),
                              transition="out_bounce",
                              d=VERY_FAST)
        self.anim.start(self)

    def to_string(self):
        return u"{}[sub]{}[/sub]".format(
            self.atom.atom,
            self.atom.number
            if self.atom.number > 1 else "")

    def select(self):
        if self.status == BoardItemStatus.EMPTY:
            if self.anim:
                self.anim.cancel(self)
                self.anim = None
            self.anim = Animation(bg_color=self.color_alpha, d=FAST)
            self.anim.start(self)
            self.marked()
            self.status = BoardItemStatus.MARKED

    def unselect(self):
        if self.status == BoardItemStatus.MARKED:
            if self.anim:
                self.anim.cancel(self)
                self.anim = None
            self.anim = Animation(bg_color=Colors.BLACK(0.0), d=VERY_FAST)
            self.anim.start(self)
            self.empty()
            self.status = BoardItemStatus.EMPTY

    def deactivate(self):
        if self.status == BoardItemStatus.MARKED:
            if self.anim:
                    self.anim.cancel(self)
                    self.anim = None
            self.anim = Animation(bg_color=Colors.BLACK(0.0), d=VERY_FAST)
            self.anim.start(self)
            self.checked()
            self.status = BoardItemStatus.CHECKED

    def collide_point(self, x, y):
        return (self.center_x - x) ** 2 + \
               (self.center_y - y) ** 2 <= \
               ((self.width - 3 * self.spacing) / 2) ** 2
Esempio n. 31
0
# animaçoes em paralelo, duas animacoes ao mesmo tempo
anim = Animation(pos=(80, 10))
anim &= Animation(size=(800, 800), duration=2.)
anim.start(widget)

# animacao em que se repete ao terminar
anim = Animation(x=50) + Animation(size=(80, 80), duration=2.)
anim.repeat = True
anim.start(widget)
Animation.cancel_all(widget, 'x')  #cancelar todas animacoes

# CARACTERISTICAS
anim.start(widget)  #inicia uma animacao
anim.stop(widget)  #para uma animacao
anim.cancel(widget)  #apara a animacaoe evento on_complete noa sera executado
Animation.stop_all(widget, 'x')  #para e afeta todas a s animacoes
Animation.cancel_all(widget, 'y')  #para e afeta todas a s animacoes
stop_property(widget, 'x')  #para e remove a propriedade da animacao do widget
cancel_property(widget,
                'y')  #para e remove a propriedade da animacao do widget
anim.duration = 2.0  # tempo duracao de animacao
anim.transition = 'in_quad'  # funcao de transicao, pode ser da propeia classe que vc criou
anim.step = 1.0 / 30.0  # 30 FPS na animacao
anim.have_properties_to_animate  #retona true se widget tem uma animacao

#EVENTOS
anim.on_start  #dispara quando a niamacaoe iniciada
anim.on_complete  #dispara quandoa  animacao termina
anim.on_progress  #dispara euqnato a animcao seta sendo executada
Esempio n. 32
0
class FrontPanel(GridLayout):

    pasttime   = StringProperty('00:00:00')
    nexttime   = StringProperty('00:00:00')

    duration   = NumericProperty(-1)
    position   = NumericProperty(0)
    volume     = NumericProperty(1.0)
    state      = OptionProperty('stop', options=('play', 'pause', 'stop'))

    controller = ObjectProperty(None, allownone=True)

    def __init__(self, **kwargs):
        self._anim = None
        super(FrontPanel, self).__init__(**kwargs)
        self.bind(position=self._on_seektime, duration=self._on_seektime)

    def show(self, duration=20):
        if self._anim is not None:
            self._anim.cancel(self)
            self._anim = None
        self._anim  = Animation(opacity=1, d=1, t='in_out_expo')
        self._anim += Animation(opacity=1, d=max(1, duration-4), t='linear')
        self._anim += Animation(opacity=0, d=max(1, duration-7), t='in_out_expo')
        self._anim.start(self)

    def hide(self):
        if self._anim is not None:
            self._anim.cancel(self)
            self._anim = None
        self.opacity = 0

    def seek(self, percent):
        if self.controller is None:
            return
        self.controller.seek(percent)

    def dispatch(self, event_type, *largs):

        if self.is_event_type(event_type):
            return super(FrontPanel, self).dispatch(event_type, *largs)

        controller = self.controller
        if controller is not None and controller.is_event_type(event_type):
            return controller.dispatch(event_type, *largs)

    def on_touch_down(self, touch):
        if self.opacity < .8:
            return True
        return super(FrontPanel, self).on_touch_down(touch)

    def on_touch_move(self, touch):
        if self.opacity < .8:
            return True
        return super(FrontPanel, self).on_touch_move(touch)

    def on_touch_up(self, touch):
        if self.opacity < .8:
            return True
        return super(FrontPanel, self).on_touch_up(touch)

    def on_controller(self, instance, value):

        controller = value
        if controller is None:
            return

        controller.bind(state=self.setter('state'),
                        duration=self.setter('duration'),
                        position=self.setter('position'),
                        volume=self.setter('volume'))

        self.bind(state=controller.setter('state'),
                  volume=controller.setter('volume'))

    def _on_seektime(self, *largs):

        if self.controller is None or self.duration == 0:
            self.pasttime = '00:00:00'
            self.nexttime = '00:00:00'
            return

        def seektime(seek):
            hours   = int(seek / 3600)
            minutes = int(seek / 60) - (hours * 60)
            seconds = int(seek) - (hours * 3600 + minutes * 60)
            return '%02d:%02d:%02d' % (hours, minutes, seconds)

        seek = self.position / float(self.duration)
        self.pasttime = seektime(self.duration * seek)
        self.nexttime = seektime(self.duration * (1. - seek))
Esempio n. 33
0
class Leaf(Image):

    expression = StringProperty()
    source = StringProperty('')

    def __init__(self, pos, size, difficulty):
        super(Leaf, self).__init__()

        self.pos = pos
        self.size = size
        self.difficulty = difficulty
        self.truth = True
        self.taken = False

        if pos[0] < Window.width / 2:
            source = random.choice(('Leaf_1.png', 'Leaf_4.png'))
            self.left = True
        else:
            source = random.choice(('Leaf_2.png', 'Leaf_3.png'))
            self.left = False

        self.source = 'img/koalas/' + source

        self.add_expression()
        self.start_animation()

    def add_expression(self):
        if random.random() <= 0.5:
            self.truth = True
        else:
            self.truth = False

        if random.random() <= 0.7:
            expression = generator.get_expression(self.truth, self.difficulty)
        else:
            expression = generator.get_bool_expression(
                self.truth, self.difficulty)

        self.expression = expression

    def start_animation(self):
        self.anim = Animation(x=self.x, y=-self.height, d=6)
        self.anim.bind(on_complete=self.reach_bottom)
        self.anim.start(self)

    def reach_bottom(self, *args):
        if self.truth:
            self.parent.remove_life()
        else:
            self.parent.add_points()

        self.destroy()

    def eat_leaf(self):
        if self.truth:
            self.parent.add_points()
        else:
            self.parent.remove_life()

        koala = KoalaPaw(self)
        self.add_widget(koala)
        koala.animation()

    def on_touch_down(self, touch):
        if self.collide_point(touch.x, touch.y) and not self.taken:
            self.eat_leaf()
            self.taken = True

    def grab(self, *args):
        self.anim.cancel(self)
        if self.left:
            x = -self.width
        else:
            x = Window.width + self.width

        y = self.y - self.height
        anim = Animation(x=x, y=y, d=0.5)
        anim.start(self)

    def destroy(self, *args):
        self.anim.cancel(self)
        try:
            self.parent.remove_widget(self)
        except AttributeError:
            pass

    def game_over(self):
        for child in self.children:
            if isinstance(child, KoalaPaw):
                child.game_over()

        anim = Animation(x=self.x, y=-self.height, d=0.5)
        anim.bind(on_complete=self.destroy)
        anim.start(self)
Esempio n. 34
0
class TransitionBase(EventDispatcher):
    """Transition class is used to animate 2 screens within the
    :class:`ScreenManager`. This class act as a base for others implementation,
    like :class:`SlideTransition`, :class:`SwapTransition`.

    :Events:
        `on_progress`: Transition object, progression float
            Fired during the animation of the transition
        `on_complete`: Transition object
            Fired when the transition is fininshed.
    """

    screen_out = ObjectProperty()
    """Property that contain the screen to hide.
    Automatically set by the :class:`ScreenManager`.

    :class:`screen_out` is a :class:`~kivy.properties.ObjectProperty`, default
    to None.
    """

    screen_in = ObjectProperty()
    """Property that contain the screen to show.
    Automatically set by the :class:`ScreenManager`.

    :class:`screen_in` is a :class:`~kivy.properties.ObjectProperty`, default
    to None.
    """

    duration = NumericProperty(0.7)
    """Duration in seconds of the transition.

    :class:`duration` is a :class:`~kivy.properties.NumericProperty`, default to
    .7 (= 700ms)
    """

    manager = ObjectProperty()
    """Screen manager object, set when the screen is added within a manager.

    :data:`manager` is a :class:`~kivy.properties.ObjectProperty`, default to
    None, read-only.
    """

    is_active = BooleanProperty()
    """Indicate if the transition is currently active

    :data:`is_active` is a :class:`~kivy.properties.BooleanProperty`, default to
    False, read-only.
    """

    # privates

    _anim = ObjectProperty(allownone=True)

    def __init__(self, **kw):
        self.register_event_type("on_progress")
        self.register_event_type("on_complete")
        super(TransitionBase, self).__init__(**kw)

    def start(self, manager):
        """(internal) Start the transition. This is automatically called by the
        :class:`ScreenManager`.
        """
        self.manager = manager
        self._anim = Animation(d=self.duration, s=0)
        self._anim.bind(on_progress=self._on_progress, on_complete=self._on_complete)

        self.add_screen(self.screen_in)
        self.screen_in.transition_progress = 0.0
        self.screen_in.transition_mode = "in"
        self.screen_out.transition_progress = 0.0
        self.screen_out.transition_mode = "out"

        self.is_active = True
        self._anim.start(self)
        self.dispatch("on_progress", 0)

    def stop(self):
        """(internal) Stop the transition. This is automatically called by the
        :class:`ScreenManager`.
        """
        if self._anim:
            self._anim.cancel(self)
            self.dispatch("on_complete")
            self._anim = None
        self.is_active = False

    def add_screen(self, screen):
        """(internal) Used to add a screen into the :class:`ScreenManager`
        """
        self.manager.real_add_widget(screen)

    def remove_screen(self, screen):
        """(internal) Used to remove a screen into the :class:`ScreenManager`
        """
        self.manager.real_remove_widget(screen)

    def on_complete(self):
        self.remove_screen(self.screen_out)

    def on_progress(self, progression):
        pass

    def _on_progress(self, *l):
        progress = l[-1]
        self.screen_in.transition_progress = progress
        self.screen_out.transition_progress = 1.0 - progress
        self.dispatch("on_progress", progress)

    def _on_complete(self, *l):
        self.is_active = False
        self.dispatch("on_complete")
        self._anim = None
Esempio n. 35
0
class DoorScreen(Screen):

    poll_for_resume = None
    return_to_screen = 'home'

    countdown_image = ObjectProperty()
    spindle_raise_label = ObjectProperty()

    def __init__(self, **kwargs):

        super(DoorScreen, self).__init__(**kwargs)
        self.sm = kwargs['screen_manager']
        self.m = kwargs['machine']
        self.jd = kwargs['job']
        self.db = kwargs['database']
        self.l = kwargs['localization']

        self.header_label.text = self.l.get_bold('Interrupt bar pushed!')

        self.anim_spindle_label = Animation(
            opacity=1,
            duration=1.5) + Animation(opacity=0, duration=0.5) + Animation(
                opacity=0, duration=1.5) + Animation(opacity=1, duration=0.5)
        self.anim_countdown_img = Animation(
            opacity=0,
            duration=1.5) + Animation(opacity=1, duration=0.5) + Animation(
                opacity=1, duration=1.5) + Animation(opacity=0, duration=0.5)
        self.anim_stop_bar = Animation(x=150, duration=0.3) + Animation(
            x=153, duration=0.2) + Animation(x=151, duration=0.2) + Animation(
                x=152,
                duration=0.2) + Animation(x=152, duration=0.2) + Animation(
                    x=152, duration=0.2) + Animation(
                        x=152, duration=1.6) + Animation(
                            x=140, duration=2) + Animation(x=140, duration=2)
        self.anim_stop_img = Animation(opacity=0, duration=0.3) + Animation(
            opacity=1,
            duration=0.2) + Animation(opacity=0.8, duration=0.2) + Animation(
                opacity=1, duration=0.2) + Animation(
                    opacity=0.8, duration=0.2) + Animation(
                        opacity=1, duration=0.2) + Animation(
                            opacity=1, duration=1.6) + Animation(
                                opacity=0, duration=2) + Animation(opacity=0,
                                                                   duration=2)

        self.anim_spindle_label_end = Animation(opacity=0, duration=0.5)
        self.anim_countdown_img_end = Animation(opacity=0, duration=0.5)

    def on_pre_enter(self):
        self.resume_button.disabled = True
        self.cancel_button.disabled = True
        self.resume_button.opacity = 0
        self.cancel_button.opacity = 0

    def on_enter(self):

        if not str(self.m.state()).startswith('Door:0'):
            print(str(self.m.state()))
            self.anim_countdown_img.repeat = True
            self.anim_spindle_label.repeat = True
            Clock.schedule_once(self.start_spindle_label_animation, 1.4)
            self.poll_for_resume = Clock.schedule_interval(
                lambda dt: self.check_spindle_has_raised(), 0.2)

        else:
            Clock.schedule_once(self.ready_to_resume, 0.2)

        self.db.send_event(
            1, "Job paused",
            "Paused job (Interrupt bar pushed): " + self.jd.job_name, 3)
        self.start_x_beam_animation(0)

    def on_pre_leave(self):
        if self.poll_for_resume != None: Clock.unschedule(self.poll_for_resume)
        self.anim_stop_bar.repeat = False
        self.anim_stop_img.repeat = False

    def on_leave(self):
        self.spindle_raise_label.text = self.l.get_str(
            'Preparing to resume, please wait') + '...'

    def start_x_beam_animation(self, dt):
        self.anim_stop_bar.start(self.x_beam)
        self.anim_stop_img.start(self.stop_img)

    def start_spindle_label_animation(self, dt):
        if not str(self.m.state()).startswith('Door:0'):
            self.anim_spindle_label.start(self.spindle_raise_label)
            self.anim_countdown_img.start(self.countdown_image)

    def check_spindle_has_raised(self):

        if (str(self.m.state()).startswith('Door:0')
                or not (str(self.m.state()).startswith('Door'))):

            Clock.unschedule(self.poll_for_resume)
            self.anim_spindle_label.repeat = False
            self.anim_countdown_img.repeat = False
            self.anim_spindle_label.cancel(self.spindle_raise_label)
            self.anim_countdown_img.cancel(self.countdown_image)
            self.anim_countdown_img_end.start(self.countdown_image)

            Clock.schedule_once(self.ready_to_resume, 0.2)
            self.start_x_beam_animation(1.5)

    def ready_to_resume(self, dt):
        self.resume_button.opacity = 1
        self.cancel_button.opacity = 1
        self.resume_button.disabled = False
        self.cancel_button.disabled = False
        self.anim_stop_bar.repeat = True
        self.anim_stop_img.repeat = True
        self.spindle_raise_label.text = '...' + self.l.get_str(
            'ready to resume')
        self.spindle_raise_label.opacity = 1

    def resume_stream(self):
        # Job resumed, send event
        self.db.send_event(0, 'Job resumed',
                           'Resumed job: ' + self.jd.job_name, 4)
        self.m.resume_after_a_hard_door()
        self.return_to_app()

    def cancel_stream(self):
        if self.return_to_screen == 'go':
            self.sm.get_screen('job_incomplete').prep_this_screen(
                'cancelled', event_number=False)
            self.return_to_screen = 'job_incomplete'

        else:
            self.m.s.cancel_sequential_stream(reset_grbl_after_cancel=False)

        self.m.cancel_after_a_hard_door()
        self.return_to_app()

    def return_to_app(self):
        if self.sm.has_screen(self.return_to_screen):
            self.sm.current = self.return_to_screen
        else:
            self.sm.current = 'lobby'
Esempio n. 36
0
class InventoryItem(BoxLayout):
    btn_save = ObjectProperty()
    btn_delete = ObjectProperty()

    def __init__(self, **kwargs):

        super(InventoryItem, self).__init__(**kwargs)

        self.btn_delete = ImageButton(source="delete.png", on_release=self.deleteInventory)
        self.btn_save = ImageButton(source="save.png", on_release=self.saveInventory)

    def editInventory(self):
        print "Edit inventory"
        self.txt_clave.disabled = False
        self.txt_producto.disabled = False
        self.txt_existencias.disabled = False
        self.txt_minimo.disabled = False
        self.txt_maximo.disabled = False
        self.txt_precio.disabled = False

        self.txt_producto.focus = True

        self.lay_buttons.remove_widget(self.btn_edit)

        self.lay_buttons.add_widget(self.btn_delete)
        self.lay_buttons.add_widget(self.btn_save)

    def saveInventory(self, w):

        if not hasattr(self, "dataitem"):
            self.dataitem = Inventarios()

        self.dataitem.Clave = self.txt_clave.text
        self.dataitem.Producto = self.txt_producto.text
        self.dataitem.Existencias = self.txt_existencias.text
        self.dataitem.Minimo = self.txt_minimo.text
        self.dataitem.Maximo = self.txt_maximo.text
        self.dataitem.Precio = self.txt_precio.text
        self.dataitem.PUser = app.root.user

        # inventoryitem.save()
        AsyncSave(callback=self.item_saved, objsave=self.dataitem)

        self.lay_buttons.remove_widget(self.btn_delete)
        self.lay_buttons.remove_widget(self.btn_save)

        self.loading = RotatedImage(source="newloading.png")
        self.anim = Animation(angle=360, duration=5)
        self.anim.bind(on_complete=self.item_timeout)
        self.anim.start(self.loading)

        self.lay_buttons.add_widget(self.loading)

    def item_saved(self, dt):
        self.anim.cancel(self.loading)
        self.lay_buttons.remove_widget(self.loading)
        self.lay_buttons.add_widget(self.btn_edit)

        # disable all
        self.txt_clave.disabled = True
        self.txt_producto.disabled = True
        self.txt_existencias.disabled = True
        self.txt_minimo.disabled = True
        self.txt_maximo.disabled = True
        self.txt_precio.disabled = True

    def item_timeout(self, anim, w):
        print "SAVE TIMEOUT"

    def deleteInventory(self, w):
        print "Deleting"
        self.dataitem.delete()

        app.root.inventario.lst_inventory.remove_widget(self)
Esempio n. 37
0
class ImmersiveLayout(StencilView):
    immersed = BooleanProperty(None)
    '''State of the layout. If True, the dock is hidden. '''
    auto_show = BooleanProperty(True)
    '''Boolean specifying whether input events trigger the ImmersiveLayout to exit immersive mode.'''
    auto_hide = BooleanProperty(True)
    '''Boolean specifying whether the dock will hide after **timeout** seconds.'''
    timeout = NumericProperty(5)
    '''Time after the last input event (keyboard, touch, mouse) after which the dock is hidden. If set to 0, the layout
    will stay opened until manually closed.'''
    animation_duration = NumericProperty(0.75)
    '''Speed at which the dock opens, in seconds. '''
    max_dock_size = NumericProperty(0.2)
    '''Maximum dock size as a fraction of the ImmersiveLayout's size. '''
    fade = BooleanProperty(True)
    '''Boolean specifying whether the dock fades into view when opening. '''
    transition = StringProperty('in_out_sine')
    '''The name of the animation transition type to use when animating. Defaults to 'out_cubic'.'''
    _anim_progress = NumericProperty(1 * (not immersed))
    ''' Internal parameter monitoring the progress of the dock's opening animation. 1 is opened, 0 is closed.'''
    _anim = ObjectProperty(None)
    '''Animation. '''
    _scheduled_close = ObjectProperty(None, allownone=True)
    '''Scheduled close event. '''
    main_panel = ObjectProperty(None, allownone=True)
    '''Automatically bound to whatever widget is added as the main panel.'''
    dock = ObjectProperty(None, allownone=True)
    '''Automatically bound to whatever widget is added as the dock.'''


    def __init__(self, **kwargs):
        super(ImmersiveLayout, self).__init__(**kwargs)
        self._anim = Animation(_anim_progress=1 * (not self.immersed),
                              duration=self.animation_duration,
                              t=self.transition)
        Window.bind(on_keyboard=self._keyboard_handler)
        self.register_event_type('on_enter_immersive')
        self.register_event_type('on_exit_immersive')
        self.register_event_type('on_finished_entering')
        self.register_event_type('on_finished_exiting')

    def _keyboard_handler(self, window, key, *args):
        """
        If auto_show is True. The first keyboard event will open the dock and block. If the dock is opened, then the
        key events will be passed
        """
        if self.auto_show:
            immersed = self.immersed
            #self.immersed = False
            self.exit_immersive_mode()
            self._schedule_close()
            # If the dock was opened, pass on the event, otherwise block it from the system
            return immersed

    def add_widget(self, widget, index=0):
        """
        The first two widget we add are the containers for the main panel and dock, _main_panel and _dock, this is done
        automatically by instantiating the class. After, when the user adds widgets to the ImmersiveLayout, we add the
        first widget supplied to the the _main_panel and the second widget to the _dock.
        """
        if len(self.children) == 0:
            super(ImmersiveLayout, self).add_widget(widget)
            self._main_panel = widget
        elif len(self.children) == 1:
            super(ImmersiveLayout, self).add_widget(widget)
            self._dock = widget
        elif self.main_panel is None:
            self._main_panel.add_widget(widget)
            self.main_panel = widget
        elif self.dock is None:
            self._dock.add_widget(widget)
            self.dock = widget

    def cancel_scheduled_close(self):
        """
        Cancel a scheduled close and schedule a new one.
        """
        if self._scheduled_close:
            self._scheduled_close.cancel()

    def _schedule_close(self, *args):
        """
        Schedules a close event for the dock.
        """
        if self.timeout > 0:
            self.cancel_scheduled_close()
            self._scheduled_close = Clock.schedule_once(self.enter_immersive_mode, self.timeout)

    def toggle_state(self, *args):
        """
        Toggle the state of immersion
        """
        if self.immersed:
            self.exit_immersive_mode()
        else:
            self.enter_immersive_mode()

    def enter_immersive_mode(self, *args):
        """
        Enter immersive mode.
        """
        self._anim.cancel(self)
        self._anim = Animation(_anim_progress=0, duration=self.animation_duration, t=self.transition)
        self._anim.start(self)
        self._anim.bind(on_complete=lambda *x: self.dispatch('on_finished_entering'))
        self.immersed = True
        self.dispatch('on_enter_immersive')

    def exit_immersive_mode(self, *args):
        """
        Exit immersive mode.
        """
        self._anim.cancel(self)
        self._anim = Animation(_anim_progress=1, duration=self.animation_duration, t=self.transition)
        self._anim.start(self)
        self.immersed = False
        self._anim.bind(on_complete=lambda *x: self.dispatch('on_finished_exiting'))
        self.dispatch('on_exit_immersive')
        # Schedule a close event if auto_hide is enabled.
        if self.auto_hide:
            self._schedule_close()


    def on_enter_immersive(self, *args):
        """
        Signals the beginning of the event to enter immersive mode.
        """
        pass

    def on_finished_entering(self, *args):
        """
        Signals the end of the event to enter immersive mode.
        """
        pass

    def on_exit_immersive(self, *args):
        """
        Signals the beginning of the event to leave immersive mode.
        """
        pass

    def on_finished_exiting(self, *args):
        """
        Signals the end of the event to exit immersive mode.
        """
        pass

    def on_auto_hide(self, *args):
        if self.timeout > 0:
            # Store the value of the timeout in case we turn on auto_hide again.
            self._timeout = self.timeout
        if self._scheduled_close:
            self._scheduled_close.cancel()
        self.timeout = self._timeout * self.auto_hide
        if self.auto_hide:
            self._schedule_close()


    def on_touch_down(self, touch):
        if self.auto_show:
            immersed = self.immersed
            if not self.immersed:
                self.cancel_scheduled_close()
            self.exit_immersive_mode()
            # While the dock is hidden, do not pass the touch event through.
            if immersed:
                return
            else:
                super(ImmersiveLayout, self).on_touch_down(touch)
        else:
            super(ImmersiveLayout, self).on_touch_down(touch)
Esempio n. 38
0
class PickerScreen(Screen):
    def on_pre_enter(self):

        self.layout = search(self, 'layout')
        self.background = search(self, 'background')
        self.scrollview = search(self, 'scrollview')

        self.focus = None

        # set the background to the correct position
        self.on_picker_scroll(None, None)

        self.scrollview.bind(scroll_x=self.on_picker_scroll)
        self.scrollview.bind(pos=self.on_picker_move)

        images = get_images()
        width = math.ceil((len(images) / 2.0 * 312) / 1280.0)
        self.max_width = width * 1280

        # set the width to be much great than the screen
        # somewhat proportionally to the number of images
        rellayout = search(self, 'rellayout')
        rellayout.size_hint = (width, 1)

        grid = search(self, 'grid')

        Loader.loading_image = CoreImage('images/loading.gif')
        Loader.num_workers = 4
        Loader.max_upload_per_frame = 4

        for image in get_images():
            widget = Factory.AsyncImage(source=image, allow_stretch=True)
            widget.bind(on_touch_down=self.on_image_touch)
            grid.add_widget(widget)

        self.scrollview_hidden = False
        self._scrollview_pos_hint = self.scrollview.pos_hint
        self._scrollview_pos = self.scrollview.pos

        self._sv_hide_ani = None
        self._sv_show_ani = None

        self._focus_hide_ani = None
        self._focus_show_ani = None

        self._focus_widget = Image(source='images/loading.gif')
        self._focus_widget.allow_stretch = True
        self._focus_widget.pos_hint = {'center_x': .5}
        self._focus_widget.y = 1024
        self._focus_widget.size_hint = None, None
        self._focus_widget.size = (600, 600)
        self._focus_widget.bind(on_touch_down=self.on_image_touch)
        self.layout.add_widget(self._focus_widget)

    def on_image_touch(self, widget, mouse_point):
        if widget.collide_point(mouse_point.x, mouse_point.y):

            # show the focus widget
            if self.scrollview_hidden:
                self.scrollview_hidden = False

                # cancel scrollview hiding animation
                try:
                    self._sv_hide_ani.cancel(self.scrollview)
                except AttributeError:
                    pass

                # show the scrollview
                x, y = self._scrollview_pos
                self._sv_show_ani = Animation(x=x,
                                              y=y,
                                              t='in_out_quad',
                                              duration=.5)
                self._sv_show_ani.start(self.scrollview)

                # cancel the focus widget show animation
                try:
                    self._focus_show_ani.cancel(self._focus_widget)
                except AttributeError:
                    pass

                # hide the focus widget
                self._focus_hide_ani = Animation(y=1024,
                                                 size=(600, 600),
                                                 t='in_out_quad',
                                                 duration=.5)

                self._focus_hide_ani.start(self._focus_widget)

            # hide the focus widget
            elif self._focus_widget is not widget:
                self.scrollview_hidden = True

                # cancel the scrollview show animation
                try:
                    self._sv_show_ani.cancel(self.scrollview)
                except AttributeError:
                    pass

                # hide the scrollview
                self.sv_hide_ani = Animation(x=0,
                                             y=-450,
                                             t='in_out_quad',
                                             duration=.5)
                self.sv_hide_ani.start(self.scrollview)

                # make sure the focus animation is finished
                try:
                    self._focus_hide_ani.cancel(self._focus_widget)
                except AttributeError:
                    pass

                # set the focus widget to have the same image as the one picked
                # do a bit of mangling to get a more detailed image
                filename = os.path.join(detail,
                                        os.path.basename(widget.source))
                self._focus_widget.source = filename

                # show the focus widget
                self._focus_show_ani = Animation(y=200,
                                                 size=(800, 800),
                                                 t='in_out_quad',
                                                 duration=.5)

                self._focus_show_ani.start(self._focus_widget)

    def on_picker_move(self, widget, arg):
        if widget is self.scrollview:
            x, y = self.background.pos
            self.background.pos = (x, -arg[1] / 50)

    def on_picker_scroll(self, value1, value2):
        self.background.pos = (self.scrollview.scroll_x * -600 - 100,
                               self.background.pos[1])
        return False
Esempio n. 39
0
class Help(OverlayView):

    target_widget = ObjectProperty(None, allownone=True, baseclass=Widget)

    def __init__(self, **kwargs):
        super(Help, self).__init__(**kwargs)
        self._anim_open = Animation(d=0.4)
        self._anim_open.fbind('on_complete', self._on_anim_open_complete)
        self._anim_dismiss = Animation(d=0.4)
        self._anim_dismiss.fbind('on_complete', self._on_anim_dismiss_complete)
        self._current_anim = None

    def open(self, *largs):
        if self._current_anim:
            return
        if self._window is not None:
            Logger.warning('ModalView: you can only open once.')
            return
        # search window
        self._window = self._search_window()
        if not self._window:
            Logger.warning('ModalView: cannot open view, no window found.')
            return
        self._window.add_widget(self)
        self._window.bind(on_keyboard=self._handle_keyboard)
        self._align_center()
        self.pos = (0, -self.height)
        target_widget = self.target_widget
        if target_widget:
            target_widget.bind(center=self._align_center)
        else:
            self._window.bind(on_resize=self._align_center)
        anim = self._anim_open
        anim.animated_properties.update(self._create_open_properties())
        anim.start(self)
        self._current_anim = anim

    def dismiss(self, *largs, **kwargs):
        if self._current_anim is self._anim_open:
            self._anim_open.cancel(self)
        anim = self._anim_dismiss
        if self._current_anim is anim:
            return
        anim.animated_properties.update(self._create_dismiss_properties())
        anim.start(self)
        self._current_anim = anim

    def _on_anim_open_complete(self, *args):
        self._current_anim = None
        self.dispatch('on_open')

    def _on_anim_dismiss_complete(self, *args):
        self._current_anim = None
        self.dispatch('on_dismiss')
        self._real_remove_widget()

    def _create_open_properties(self):
        target_widget = self.target_widget
        if target_widget:
            center = target_widget.to_window(*target_widget.center)
        else:
            center = self._window.center
        return {'center': center}

    def _create_dismiss_properties(self):
        return {'top': 0}

    def _align_center(self, *l):
        if self.target_widget:
            self.size = self.target_widget.size
        else:
            self.size = self._window.size
        self._update_animation()

    def _update_animation(self, *args):
        anim = self._current_anim
        if anim:
            anim.cancel(self)
            if anim is self._anim_open:
                properties = self._create_open_properties()
            else:
                properties = self._create_dismiss_properties()
            anim.animated_properties.update(properties)
            anim.start(self)

    def _real_remove_widget(self):
        super(Help, self)._real_remove_widget()
        target_widget = self.target_widget
        if target_widget:
            target_widget.unbind(center=self._align_center)
Esempio n. 40
0
class TransitionBase(EventDispatcher):
    '''Transition class is used to animate 2 screens within the
    :class:`ScreenManager`. This class act as a base for others implementation,
    like :class:`SlideTransition`, :class:`SwapTransition`.

    :Events:
        `on_progress`: Transition object, progression float
            Fired during the animation of the transition
        `on_complete`: Transition object
            Fired when the transition is fininshed.
    '''

    screen_out = ObjectProperty()
    '''Property that contain the screen to hide.
    Automatically set by the :class:`ScreenManager`.

    :class:`screen_out` is a :class:`~kivy.properties.ObjectProperty`, default
    to None.
    '''

    screen_in = ObjectProperty()
    '''Property that contain the screen to show.
    Automatically set by the :class:`ScreenManager`.

    :class:`screen_in` is a :class:`~kivy.properties.ObjectProperty`, default
    to None.
    '''

    duration = NumericProperty(.7)
    '''Duration in seconds of the transition.

    :class:`duration` is a :class:`~kivy.properties.NumericProperty`, default
    to .7 (= 700ms)
    '''

    manager = ObjectProperty()
    '''Screen manager object, set when the screen is added within a manager.

    :data:`manager` is a :class:`~kivy.properties.ObjectProperty`, default to
    None, read-only.
    '''

    is_active = BooleanProperty(False)
    '''Indicate if the transition is currently active

    :data:`is_active` is a :class:`~kivy.properties.BooleanProperty`, default
    to False, read-only.
    '''

    # privates

    _anim = ObjectProperty(allownone=True)

    def __init__(self, **kw):
        self.register_event_type('on_progress')
        self.register_event_type('on_complete')
        super(TransitionBase, self).__init__(**kw)

    def start(self, manager):
        '''(internal) Start the transition. This is automatically called by the
        :class:`ScreenManager`.
        '''
        if self.is_active:
            raise ScreenManagerException('start() is called twice!')
        self.manager = manager
        self._anim = Animation(d=self.duration, s=0)
        self._anim.bind(on_progress=self._on_progress,
                        on_complete=self._on_complete)

        self.add_screen(self.screen_in)
        self.screen_in.transition_progress = 0.
        self.screen_in.transition_state = 'in'
        self.screen_out.transition_progress = 0.
        self.screen_out.transition_state = 'out'
        self.screen_in.dispatch('on_pre_enter')
        self.screen_out.dispatch('on_pre_leave')

        self.is_active = True
        self._anim.start(self)
        self.dispatch('on_progress', 0)

    def stop(self):
        '''(internal) Stop the transition. This is automatically called by the
        :class:`ScreenManager`.
        '''
        if self._anim:
            self._anim.cancel(self)
            self.dispatch('on_complete')
            self._anim = None
        self.is_active = False

    def add_screen(self, screen):
        '''(internal) Used to add a screen into the :class:`ScreenManager`
        '''
        self.manager.real_add_widget(screen)

    def remove_screen(self, screen):
        '''(internal) Used to remove a screen into the :class:`ScreenManager`
        '''
        self.manager.real_remove_widget(screen)

    def on_complete(self):
        self.remove_screen(self.screen_out)

    def on_progress(self, progression):
        pass

    def _on_progress(self, *l):
        progress = l[-1]
        self.screen_in.transition_progress = progress
        self.screen_out.transition_progress = 1. - progress
        self.dispatch('on_progress', progress)

    def _on_complete(self, *l):
        self.is_active = False
        self.dispatch('on_complete')
        self.screen_in.dispatch('on_enter')
        self.screen_out.dispatch('on_leave')
        self._anim = None
Esempio n. 41
0
class PickerScreen(Screen):
    def on_pre_enter(self):

        self.layout = search(self, 'layout')
        self.background = search(self, 'background')
        self.scrollview = search(self, 'scrollview')

        self.focus = None

        # set the background to the correct position
        self.on_picker_scroll(None, None)

        self.scrollview.bind(scroll_x=self.on_picker_scroll)
        self.scrollview.bind(pos=self.on_picker_move)

        images = get_images()
        width = math.ceil((len(images) / 2.0 * 312) / 1280.0) 
        self.max_width = width * 1280

        # set the width to be much great than the screen
        # somewhat proportionally to the number of images
        rellayout = search(self, 'rellayout')
        rellayout.size_hint = (width,1)

        grid = search(self, 'grid')

        Loader.loading_image = CoreImage('images/loading.gif')
        Loader.num_workers = 4
        Loader.max_upload_per_frame = 4

        for image in get_images():
            widget = Factory.AsyncImage(source=image, allow_stretch=True)
            widget.bind(on_touch_down=self.on_image_touch)
            grid.add_widget(widget)

        self.scrollview_hidden = False
        self._scrollview_pos_hint = self.scrollview.pos_hint
        self._scrollview_pos = self.scrollview.pos

        self._sv_hide_ani = None
        self._sv_show_ani = None

        self._focus_hide_ani = None
        self._focus_show_ani = None

        self._focus_widget = Image(source='images/loading.gif')
        self._focus_widget.allow_stretch = True
        self._focus_widget.pos_hint = {'center_x': .5}
        self._focus_widget.y = 1024
        self._focus_widget.size_hint = None, None
        self._focus_widget.size = (600, 600)
        self._focus_widget.bind(on_touch_down=self.on_image_touch)
        self.layout.add_widget(self._focus_widget)


    def on_image_touch(self, widget, mouse_point):
        if widget.collide_point(mouse_point.x, mouse_point.y):
        
            # show the focus widget
            if self.scrollview_hidden:
                self.scrollview_hidden = False
               
                # cancel scrollview hiding animation
                try:
                    self._sv_hide_ani.cancel(self.scrollview)
                except AttributeError:
                    pass

                # show the scrollview
                x, y = self._scrollview_pos
                self._sv_show_ani = Animation(x=x, y=y, t='in_out_quad', duration=.5)
                self._sv_show_ani.start(self.scrollview)

                # cancel the focus widget show animation
                try:
                    self._focus_show_ani.cancel(self._focus_widget)
                except AttributeError:
                    pass

                # hide the focus widget
                self._focus_hide_ani = Animation(y=1024,
                                                 size=(600,600),
                                                 t='in_out_quad',
                                                 duration=.5)

                self._focus_hide_ani.start(self._focus_widget)

            # hide the focus widget
            elif self._focus_widget is not widget:
                self.scrollview_hidden = True
              
                # cancel the scrollview show animation
                try:
                    self._sv_show_ani.cancel(self.scrollview)
                except AttributeError:
                    pass

                # hide the scrollview
                self.sv_hide_ani = Animation(x=0, y=-450, t='in_out_quad', duration=.5)
                self.sv_hide_ani.start(self.scrollview)

                # make sure the focus animation is finished
                try:
                    self._focus_hide_ani.cancel(self._focus_widget)
                except AttributeError:
                    pass

                # set the focus widget to have the same image as the one picked
                # do a bit of mangling to get a more detailed image
                filename = os.path.join(detail, os.path.basename(widget.source))
                self._focus_widget.source = filename

                # show the focus widget
                self._focus_show_ani = Animation(y=200,
                                                 size=(800, 800),
                                                 t='in_out_quad',
                                                 duration=.5)

                self._focus_show_ani.start(self._focus_widget)

    def on_picker_move(self, widget, arg):
        if widget is self.scrollview:
            x, y = self.background.pos
            self.background.pos = (x, -arg[1] / 50)

    def on_picker_scroll(self, value1, value2):
        self.background.pos = (self.scrollview.scroll_x*-600 - 100,
                               self.background.pos[1])
        return False
Esempio n. 42
0
class Leaf(Image):

    expression = StringProperty()
    source = StringProperty('')

    def __init__(self, pos, size, difficulty):
        super(Leaf, self).__init__()

        self.pos = pos
        self.size = size
        self.difficulty = difficulty
        self.truth = True
        self.taken = False

        if pos[0] < Window.width / 2:
            source = random.choice(('Leaf_1.png', 'Leaf_4.png'))
            self.left = True
        else:
            source = random.choice(('Leaf_2.png', 'Leaf_3.png'))
            self.left = False

        self.source = 'img/koalas/' + source

        self.add_expression()
        self.start_animation()

    def add_expression(self):
        if random.random() <= 0.5:
            self.truth = True
        else:
            self.truth = False

        if random.random() <= 0.7:
            expression = generator.get_expression(self.truth, self.difficulty)
        else:
            expression = generator.get_bool_expression(self.truth,
                                                       self.difficulty)

        self.expression = expression

    def start_animation(self):
        self.anim = Animation(x=self.x, y=-self.height, d=6)
        self.anim.bind(on_complete=self.reach_bottom)
        self.anim.start(self)

    def reach_bottom(self, *args):
        if self.truth:
            self.parent.remove_life()
        else:
            self.parent.add_points()

        self.destroy()

    def eat_leaf(self):
        if self.truth:
            self.parent.add_points()
        else:
            self.parent.remove_life()

        koala = KoalaPaw(self)
        self.add_widget(koala)
        koala.animation()

    def on_touch_down(self, touch):
        if self.collide_point(touch.x, touch.y) and not self.taken:
            self.eat_leaf()
            self.taken = True

    def grab(self, *args):
        self.anim.cancel(self)
        if self.left:
            x = -self.width
        else:
            x = Window.width + self.width

        y = self.y - self.height
        anim = Animation(x=x, y=y, d=0.5)
        anim.start(self)

    def destroy(self, *args):
        self.anim.cancel(self)
        try:
            self.parent.remove_widget(self)
        except AttributeError:
            pass

    def game_over(self):
        for child in self.children:
            if isinstance(child, KoalaPaw):
                child.game_over()

        anim = Animation(x=self.x, y=-self.height, d=0.5)
        anim.bind(on_complete=self.destroy)
        anim.start(self)
Esempio n. 43
0
class TransitionBase(EventDispatcher):
    '''Transition class is used to animate 2 screens within the
    :class:`ScreenManager`. This class act as a base for others implementation,
    like :class:`SlideTransition`, :class:`SwapTransition`.

    :Events:
        `on_progress`: Transition object, progression float
            Fired during the animation of the transition
        `on_complete`: Transition object
            Fired when the transition is fininshed.
    '''

    screen_out = ObjectProperty()
    '''Property that contain the screen to hide.
    Automatically set by the :class:`ScreenManager`.

    :class:`screen_out` is a :class:`~kivy.properties.ObjectProperty`, default
    to None.
    '''

    screen_in = ObjectProperty()
    '''Property that contain the screen to show.
    Automatically set by the :class:`ScreenManager`.

    :class:`screen_in` is a :class:`~kivy.properties.ObjectProperty`, default
    to None.
    '''

    duration = NumericProperty(.7)
    '''Duration in seconds of the transition.

    :class:`duration` is a :class:`~kivy.properties.NumericProperty`, default
    to .7 (= 700ms)
    '''

    manager = ObjectProperty()
    '''Screen manager object, set when the screen is added within a manager.

    :data:`manager` is a :class:`~kivy.properties.ObjectProperty`, default to
    None, read-only.
    '''

    is_active = BooleanProperty(False)
    '''Indicate if the transition is currently active

    :data:`is_active` is a :class:`~kivy.properties.BooleanProperty`, default
    to False, read-only.
    '''

    # privates

    _anim = ObjectProperty(allownone=True)

    __events__ = ('on_progress', 'on_complete')

    def start(self, manager):
        '''(internal) Start the transition. This is automatically called by the
        :class:`ScreenManager`.
        '''
        if self.is_active:
            raise ScreenManagerException('start() is called twice!')
        self.manager = manager
        self._anim = Animation(d=self.duration, s=0)
        self._anim.bind(on_progress=self._on_progress,
                        on_complete=self._on_complete)

        self.add_screen(self.screen_in)
        self.screen_in.transition_progress = 0.
        self.screen_in.transition_state = 'in'
        self.screen_out.transition_progress = 0.
        self.screen_out.transition_state = 'out'
        self.screen_in.dispatch('on_pre_enter')
        self.screen_out.dispatch('on_pre_leave')

        self.is_active = True
        self._anim.start(self)
        self.dispatch('on_progress', 0)

    def stop(self):
        '''(internal) Stop the transition. This is automatically called by the
        :class:`ScreenManager`.
        '''
        if self._anim:
            self._anim.cancel(self)
            self.dispatch('on_complete')
            self._anim = None
        self.is_active = False

    def add_screen(self, screen):
        '''(internal) Used to add a screen into the :class:`ScreenManager`
        '''
        self.manager.real_add_widget(screen)

    def remove_screen(self, screen):
        '''(internal) Used to remove a screen into the :class:`ScreenManager`
        '''
        self.manager.real_remove_widget(screen)

    def on_complete(self):
        self.remove_screen(self.screen_out)

    def on_progress(self, progression):
        pass

    def _on_progress(self, *l):
        progress = l[-1]
        self.screen_in.transition_progress = progress
        self.screen_out.transition_progress = 1. - progress
        self.dispatch('on_progress', progress)

    def _on_complete(self, *l):
        self.is_active = False
        self.dispatch('on_complete')
        self.screen_in.dispatch('on_enter')
        self.screen_out.dispatch('on_leave')
        self._anim = None
Esempio n. 44
0
class MDCheckbox(CircularRippleBehavior, ToggleButtonBehavior, MDIcon):
    active = BooleanProperty(False)

    checkbox_icon_normal = StringProperty("checkbox-blank-outline")
    checkbox_icon_down = StringProperty("checkbox-marked-outline")
    radio_icon_normal = StringProperty("checkbox-blank-circle-outline")
    radio_icon_down = StringProperty("checkbox-marked-circle-outline")

    selected_color = ListProperty()
    unselected_color = ListProperty()
    disabled_color = ListProperty()
    _current_color = ListProperty([0.0, 0.0, 0.0, 0.0])

    def __init__(self, **kwargs):
        self.check_anim_out = Animation(font_size=0,
                                        duration=0.1,
                                        t="out_quad")
        self.check_anim_in = Animation(font_size=sp(24),
                                       duration=0.1,
                                       t="out_quad")
        super().__init__(**kwargs)
        self.selected_color = self.theme_cls.primary_color
        self.unselected_color = self.theme_cls.secondary_text_color
        self.disabled_color = self.theme_cls.divider_color
        self._current_color = self.unselected_color
        self.check_anim_out.bind(
            on_complete=lambda *x: self.check_anim_in.start(self))
        self.bind(
            checkbox_icon_normal=self.update_icon,
            checkbox_icon_down=self.update_icon,
            radio_icon_normal=self.update_icon,
            radio_icon_down=self.update_icon,
            group=self.update_icon,
            selected_color=self.update_color,
            unselected_color=self.update_color,
            disabled_color=self.update_color,
            disabled=self.update_color,
            state=self.update_color,
        )
        self.update_icon()
        self.update_color()

    def update_icon(self, *args):
        if self.state == "down":
            self.icon = (self.radio_icon_down
                         if self.group else self.checkbox_icon_down)
        else:
            self.icon = (self.radio_icon_normal
                         if self.group else self.checkbox_icon_normal)

    def update_color(self, *args):
        if self.disabled:
            self._current_color = self.disabled_color
        elif self.state == "down":
            self._current_color = self.selected_color
        else:
            self._current_color = self.unselected_color

    def on_state(self, *args):
        if self.state == "down":
            self.check_anim_in.cancel(self)
            self.check_anim_out.start(self)
            self.update_icon()
            self.active = True
        else:
            self.check_anim_in.cancel(self)
            self.check_anim_out.start(self)
            self.update_icon()
            self.active = False

    def on_active(self, *args):
        self.state = "down" if self.active else "normal"
Esempio n. 45
0
class InventoryItem(BoxLayout):
    btn_save = ObjectProperty()
    btn_delete = ObjectProperty()

    def __init__(self, **kwargs):

        super(InventoryItem, self).__init__(**kwargs)

        self.btn_delete = ImageButton(source="delete.png",
                                      on_release=self.deleteInventory)
        self.btn_save = ImageButton(source="save.png",
                                    on_release=self.saveInventory)

    def editInventory(self):
        print "Edit inventory"
        self.txt_clave.disabled = False
        self.txt_producto.disabled = False
        self.txt_existencias.disabled = False
        self.txt_minimo.disabled = False
        self.txt_maximo.disabled = False
        self.txt_precio.disabled = False

        self.txt_producto.focus = True

        self.lay_buttons.remove_widget(self.btn_edit)

        self.lay_buttons.add_widget(self.btn_delete)
        self.lay_buttons.add_widget(self.btn_save)

    def saveInventory(self, w):

        if not hasattr(self, "dataitem"):
            self.dataitem = Inventarios()

        self.dataitem.Clave = self.txt_clave.text
        self.dataitem.Producto = self.txt_producto.text
        self.dataitem.Existencias = self.txt_existencias.text
        self.dataitem.Minimo = self.txt_minimo.text
        self.dataitem.Maximo = self.txt_maximo.text
        self.dataitem.Precio = self.txt_precio.text
        self.dataitem.PUser = app.root.user

        #inventoryitem.save()
        AsyncSave(callback=self.item_saved, objsave=self.dataitem)

        self.lay_buttons.remove_widget(self.btn_delete)
        self.lay_buttons.remove_widget(self.btn_save)

        self.loading = RotatedImage(source="newloading.png")
        self.anim = Animation(angle=360, duration=5)
        self.anim.bind(on_complete=self.item_timeout)
        self.anim.start(self.loading)

        self.lay_buttons.add_widget(self.loading)

    def item_saved(self, dt):
        self.anim.cancel(self.loading)
        self.lay_buttons.remove_widget(self.loading)
        self.lay_buttons.add_widget(self.btn_edit)

        #disable all
        self.txt_clave.disabled = True
        self.txt_producto.disabled = True
        self.txt_existencias.disabled = True
        self.txt_minimo.disabled = True
        self.txt_maximo.disabled = True
        self.txt_precio.disabled = True

    def item_timeout(self, anim, w):
        print "SAVE TIMEOUT"

    def deleteInventory(self, w):
        print "Deleting"
        self.dataitem.delete()

        app.root.inventario.lst_inventory.remove_widget(self)
class MDCheckbox(CircularRippleBehavior, ToggleButtonBehavior, MDIcon):
    active = BooleanProperty(False)
    """
    Indicates if the checkbox is active or inactive.

    :attr:`active` is a :class:`~kivy.properties.BooleanProperty`
    and defaults to `False`.
    """

    checkbox_icon_normal = StringProperty("checkbox-blank-outline")
    """
    Background icon of the checkbox used for the default graphical
    representation when the checkbox is not pressed.

    :attr:`checkbox_icon_normal` is a :class:`~kivy.properties.StringProperty`
    and defaults to `'checkbox-blank-outline'`.
    """

    checkbox_icon_down = StringProperty("checkbox-marked-outline")
    """
    Background icon of the checkbox used for the default graphical
    representation when the checkbox is pressed.

    :attr:`checkbox_icon_down` is a :class:`~kivy.properties.StringProperty`
    and defaults to `'checkbox-marked-outline'`.
    """

    radio_icon_normal = StringProperty("checkbox-blank-circle-outline")
    """
    Background icon (when using the ``group`` option) of the checkbox used for
    the default graphical representation when the checkbox is not pressed.

    :attr:`radio_icon_normal` is a :class:`~kivy.properties.StringProperty`
    and defaults to `'checkbox-blank-circle-outline'`.
    """

    radio_icon_down = StringProperty("checkbox-marked-circle-outline")
    """
    Background icon (when using the ``group`` option) of the checkbox used for
    the default graphical representation when the checkbox is pressed.

    :attr:`radio_icon_down` is a :class:`~kivy.properties.StringProperty`
    and defaults to `'checkbox-marked-circle-outline'`.
    """

    selected_color = ListProperty()
    """
    Selected color in ``rgba`` format.

    :attr:`selected_color` is a :class:`~kivy.properties.ListProperty`
    and defaults to `[]`.
    """

    unselected_color = ListProperty()
    """
    Unelected color in ``rgba`` format.

    :attr:`unselected_color` is a :class:`~kivy.properties.ListProperty`
    and defaults to `[]`.
    """

    disabled_color = ListProperty()
    """
    Disabled color in ``rgba`` format.

    :attr:`disabled_color` is a :class:`~kivy.properties.ListProperty`
    and defaults to `[]`.
    """

    _current_color = ListProperty([0.0, 0.0, 0.0, 0.0])

    def __init__(self, **kwargs):
        self.check_anim_out = Animation(font_size=0,
                                        duration=0.1,
                                        t="out_quad")
        self.check_anim_in = Animation(font_size=sp(24),
                                       duration=0.1,
                                       t="out_quad")
        super().__init__(**kwargs)
        self.selected_color = self.theme_cls.primary_color
        self.unselected_color = self.theme_cls.secondary_text_color
        self.disabled_color = self.theme_cls.divider_color
        self._current_color = self.unselected_color
        self.check_anim_out.bind(
            on_complete=lambda *x: self.check_anim_in.start(self))
        self.bind(
            checkbox_icon_normal=self.update_icon,
            checkbox_icon_down=self.update_icon,
            radio_icon_normal=self.update_icon,
            radio_icon_down=self.update_icon,
            group=self.update_icon,
            selected_color=self.update_color,
            unselected_color=self.update_color,
            disabled_color=self.update_color,
            disabled=self.update_color,
            state=self.update_color,
        )
        self.theme_cls.bind(primary_color=self.update_primary_color)
        self.update_icon()
        self.update_color()

    def update_primary_color(self, instance, value):
        self.selected_color = value

    def update_icon(self, *args):
        if self.state == "down":
            self.icon = (self.radio_icon_down
                         if self.group else self.checkbox_icon_down)
        else:
            self.icon = (self.radio_icon_normal
                         if self.group else self.checkbox_icon_normal)

    def update_color(self, *args):
        if self.disabled:
            self._current_color = self.disabled_color
        elif self.state == "down":
            self._current_color = self.selected_color
        else:
            self._current_color = self.unselected_color

    def on_state(self, *args):
        if self.state == "down":
            self.check_anim_in.cancel(self)
            self.check_anim_out.start(self)
            self.update_icon()
            if self.group:
                self._release_group(self)
            self.active = True
        else:
            self.check_anim_in.cancel(self)
            self.check_anim_out.start(self)
            self.update_icon()
            self.active = False

    def on_active(self, *args):
        self.state = "down" if self.active else "normal"
Esempio n. 47
0
class GameLayout(GridLayout):

    GAME_CONFIG_SECTION = "game"
    POSITION_MATCH_KEYBIND = ord('a')
    SHAPE_MATCH_KEYBIND = ord('f')
    CLEAR_INTERVAL = 0.2
    EVALUATE_INTERVAL = 0.3
    DEFAULT_BUTTON_COLOR = (0.8, 0.8, 0.8, 1)
    BTN_SIZE_HINT = (0.3, 0.3)
    RAND_RANGE = range(9)
    STATS_POPUP_SIZE_HINT = (.35, .35)
    INFO_LABEL_SIZE_HINT = (.1, .1)
    GRID_SIZE = 9
    MIN_TIME = 0.3

    iter = NumericProperty(None)
    p_errors = NumericProperty(None)
    s_errors = NumericProperty(None)

    def _get_config(self, opt_name):
        return self.parent.config.get(self.GAME_CONFIG_SECTION, opt_name)

    def _get_config_vals(self):
        self.history = int(self._get_config("level"))
        self.max_iter = int(self._get_config("max_iter")) + self.history
        self.step_duration = float(self._get_config("step_duration"))
        self.shape_display_duration = float(self._get_config("item_display"))
        self.start_noise_level = float(self._get_config("start_noise_level"))
        self.final_noise_level = float(self._get_config("final_noise_level"))
        self.shape_type = str(self._get_config("shape_type"))

    def _action_keys(self, window, key, *args):
        # bind to 'position match' and 'shape match'
        if key == self.POSITION_MATCH_KEYBIND and not self.p_clicked:
            self.p_btn.trigger_action()
        elif key == self.SHAPE_MATCH_KEYBIND and not self.n_clicked:
            self.n_btn.trigger_action()

    def build(self):
        self._get_config_vals()
        self.cols = 3
        self.rows = 5
        self.spacing = 5
        # animate noise application
        visibility = 1 - self.final_noise_level
        self.noise_animation = Animation(shape_visibility=visibility,
                                         duration=self.shape_display_duration)

        def create_info_label():
            return Label(size_hint=self.INFO_LABEL_SIZE_HINT)

        position_info = create_info_label()
        shape_info = create_info_label()
        overall_info = create_info_label()

        def update_position_info(instance, value):
            position_info.text = "Incorrect positions: %s" % value

        self.bind(p_errors=update_position_info)

        def update_shape_info(instance, value):
            shape_info.text = "Incorrect shapes: %s" % value

        self.bind(s_errors=update_shape_info)

        def update_overall_info(instance, value):
            overall_info.text = "%s / %s" % (value, self.max_iter)

        self.bind(iter=update_overall_info)

        self.add_widget(position_info)
        self.add_widget(shape_info)
        self.add_widget(overall_info)

        self.cells = []
        cell_shape_cls = Shapes.get(self.shape_type)
        for _ in xrange(self.GRID_SIZE):
            label = cell_shape_cls(self.start_noise_level)
            self.cells.append(label)
            self.add_widget(label)

        self.p_btn = Button(text="A: Position match",
                            size_hint=self.BTN_SIZE_HINT,
                            on_release=self.position_callback)
        self.add_widget(self.p_btn)
        self.n_btn = Button(text="F: Shape match",
                            size_hint=self.BTN_SIZE_HINT,
                            on_release=self.shape_callback)

        self.add_widget(self.n_btn)

        level_info = Label(text="[color=000000]%s-back[/color]" % self.history,
                           font_size="25sp",
                           markup=True,
                           size_hint=self.INFO_LABEL_SIZE_HINT)
        self.add_widget(level_info)
        # disable buttons at the start
        self.p_btn.disabled = True
        self.n_btn.disabled = True

    def position_callback(self, instance):
        self.p_clicked = True

    def shape_callback(self, instance):
        self.n_clicked = True

    def _rand(self, default_choice, choice_history):
        """Make items from the past more likely to be selected."""
        return random.choice(default_choice + choice_history + choice_history)

    def rand_shape(self):
        return self._rand(self.RAND_RANGE, self.shapes)

    def rand_position(self):
        return self._rand(self.RAND_RANGE, self.positions)

    def new_cell(self, dt=None):
        self.a_shape, self.a_position = self.rand_shape(), self.rand_position()
        self.actual_cell = self.cells[self.a_position]
        self.actual_cell.set_shape(self.a_shape)
        self.noise_animation.start(self.actual_cell)
        self.p_clicked = False
        self.n_clicked = False

    def start(self):
        self.iter = 1
        self.s_errors = 0
        self.p_errors = 0
        self.tested_positions = 0.0
        self.tested_shapes = 0.0

        self.p_clicked = False
        self.n_clicked = False

        self.positions = []
        self.shapes = []

        Clock.schedule_once(self.new_cell, self.MIN_TIME)
        Clock.schedule_interval(self._step, self.step_duration)
        self._schedule_cell_clearing()

    def _evaluate(self, dt):
        # using xor
        self.p_err = (self.positions[0] == self.a_position) != self.p_clicked
        self.n_err = (self.shapes[0] == self.a_shape) != self.n_clicked

        self.p_errors += self.p_err
        self.s_errors += self.n_err

        self.tested_positions += self.positions[0] == self.a_position
        self.tested_shapes += self.shapes[0] == self.a_shape

        # change buttons background color depending on success/fail
        if self.positions[0] == self.a_position or self.p_clicked:
            self.p_btn.background_color = RED if self.p_err else GREEN
        if self.shapes[0] == self.a_shape or self.n_clicked:
            self.n_btn.background_color = RED if self.n_err else GREEN

    def _display_statistics(self, position, shape, success):
        layout = BoxLayout(orientation="vertical")
        msg = self._format_statistics(position, shape, success)
        layout.add_widget(Label(text=msg, font_size='20sp'))

        def to_menu(instance):
            popup.dismiss()
            self.parent.manager.move_to_previous_screen()

        anchor_layout = AnchorLayout(anchor_x='right', anchor_y='center')
        btn = Button(text="ok", on_press=to_menu, size_hint=self.BTN_SIZE_HINT)
        anchor_layout.add_widget(btn)
        layout.add_widget(anchor_layout)
        popup = Popup(title='Game finished',
                      content=layout,
                      auto_dismiss=True,
                      size_hint=self.STATS_POPUP_SIZE_HINT)
        popup.open()

    def _clear_cell(self, dt):
        self.noise_animation.cancel(self.actual_cell)
        self.actual_cell.clear()

    def _schedule_cell_clearing(self):
        Clock.schedule_once(self._clear_cell, self.shape_display_duration)

    def _on_finish(self):
        Clock.unschedule(self._step)
        Window.unbind(on_keyboard=self._action_keys)
        self.p_btn.disabled = True
        self.n_btn.disabled = True
        position, shape, success = self._compute_statistics()
        App.get_running_app().add_result(self.history, position, shape,
                                         success, self.iter)
        self._display_statistics(position, shape, success)

    def _compute_statistics(self):
        if not self.tested_positions:
            c_position = 100.0
        else:
            c_position = (1 - self.p_errors / self.tested_positions) * 100

        if not self.tested_shapes:
            c_shape = 100.0
        else:
            c_shape = (1 - self.s_errors / self.tested_shapes) * 100

        tested_items = self.tested_positions + self.tested_shapes
        if not tested_items:
            s_rate = 100.0
        else:
            all_errors = self.p_errors + self.s_errors
            s_rate = 1 - (all_errors / tested_items)
            s_rate *= 100

        if c_position < 0:
            c_position = 0

        if c_shape < 0:
            c_shape = 0

        if s_rate < 0:
            s_rate = 0

        return c_position, c_shape, s_rate

    def _step(self, dt):

        if self.iter >= self.history and self.iter < self.max_iter:
            Clock.schedule_once(self._evaluate, dt - self.EVALUATE_INTERVAL)

        if self.iter >= self.max_iter:
            self._on_finish()
            return
        else:
            self._schedule_cell_clearing()

        if len(self.positions) >= self.history:
            del (self.positions[0])
            del (self.shapes[0])

        self.positions.append(self.a_position)
        self.shapes.append(self.a_shape)
        self.new_cell()

        # enable buttons if it make sense to click
        if self.iter >= self.history:
            self.p_btn.background_color = self.DEFAULT_BUTTON_COLOR
            self.n_btn.background_color = self.DEFAULT_BUTTON_COLOR
            self.p_btn.disabled = False
            self.n_btn.disabled = False
            Window.bind(on_keyboard=self._action_keys)

        self.iter += 1

    def _format_statistics(self, c_position, c_shape, s_rate):
        return "Samples count: %s\n"\
               "Correct positions: %.2f%%\n"\
               "Correct shapes: %.2f%%\n"\
               "Overall success: %.2f%%" % (self.iter - self.history,
                                          c_position,
                                          c_shape,
                                          s_rate)
Esempio n. 48
0
class TransitionBase(EventDispatcher):
    '''TransitionBase is used to animate 2 screens within the
    :class:`ScreenManager`. This class acts as a base for other
    implementations like the :class:`SlideTransition` and
    :class:`SwapTransition`.

    :Events:
        `on_progress`: Transition object, progression float
            Fired during the animation of the transition.
        `on_complete`: Transition object
            Fired when the transition is fininshed.
    '''

    screen_out = ObjectProperty()
    '''Property that contains the screen to hide.
    Automatically set by the :class:`ScreenManager`.

    :class:`screen_out` is an :class:`~kivy.properties.ObjectProperty` and
    defaults to None.
    '''

    screen_in = ObjectProperty()
    '''Property that contains the screen to show.
    Automatically set by the :class:`ScreenManager`.

    :class:`screen_in` is an :class:`~kivy.properties.ObjectProperty` and
    defaults to None.
    '''

    duration = NumericProperty(.4)
    '''Duration in seconds of the transition.

    :class:`duration` is a :class:`~kivy.properties.NumericProperty` and
    defaults to .4 (= 400ms).

    .. versionchanged:: 1.8.0

        Default duration has been changed from 700ms to 400ms.
    '''

    manager = ObjectProperty()
    ''':class:`ScreenManager` object, set when the screen is added to a
    manager.

    :attr:`manager` is an :class:`~kivy.properties.ObjectProperty` and
    defaults to None, read-only.

    '''

    is_active = BooleanProperty(False)
    '''Indicate whether the transition is currently active or not.

    :attr:`is_active` is a :class:`~kivy.properties.BooleanProperty` and
    defaults to False, read-only.
    '''

    # privates

    _anim = ObjectProperty(allownone=True)

    __events__ = ('on_progress', 'on_complete')

    def start(self, manager):
        '''(internal) Starts the transition. This is automatically
        called by the :class:`ScreenManager`.
        '''
        if self.is_active:
            raise ScreenManagerException('start() is called twice!')
        self.manager = manager
        self._anim = Animation(d=self.duration, s=0)
        self._anim.bind(on_progress=self._on_progress,
                        on_complete=self._on_complete)

        self.add_screen(self.screen_in)
        self.screen_in.transition_progress = 0.
        self.screen_in.transition_state = 'in'
        self.screen_out.transition_progress = 0.
        self.screen_out.transition_state = 'out'
        self.screen_in.dispatch('on_pre_enter')
        self.screen_out.dispatch('on_pre_leave')

        self.is_active = True
        self._anim.start(self)
        self.dispatch('on_progress', 0)

    def stop(self):
        '''(internal) Stops the transition. This is automatically called by the
        :class:`ScreenManager`.
        '''
        if self._anim:
            self._anim.cancel(self)
            self.dispatch('on_complete')
            self._anim = None
        self.is_active = False

    def add_screen(self, screen):
        '''(internal) Used to add a screen to the :class:`ScreenManager`.
        '''
        self.manager.real_add_widget(screen)

    def remove_screen(self, screen):
        '''(internal) Used to remove a screen from the :class:`ScreenManager`.
        '''
        self.manager.real_remove_widget(screen)

    def on_complete(self):
        self.remove_screen(self.screen_out)

    def on_progress(self, progression):
        pass

    def _on_progress(self, *l):
        progress = l[-1]
        self.screen_in.transition_progress = progress
        self.screen_out.transition_progress = 1. - progress
        self.dispatch('on_progress', progress)

    def _on_complete(self, *l):
        self.is_active = False
        self.dispatch('on_complete')
        self.screen_in.dispatch('on_enter')
        self.screen_out.dispatch('on_leave')
        self._anim = None
Esempio n. 49
0
class MapCursor(Rectangle):
    def __init__(self, map, map_size, tile_size, hue, **kwargs):
        super(MapCursor, self).__init__(**kwargs)
        self.map = map
        self.tile_size = tile_size
        self.hue = hue  # pass it's own hue to itself
        self.size = (tile_size, tile_size)
        self.cursor_anim_1 = ''
        self.cursor_anim_2 = ''
        self.pos = (0, 0)
        self.map_size = map_size
        self.x_coord = 0
        self.y_coord = 0

        self.hide_cursor()

    def change_map_size(self, x_max, y_max, tile_size):
        self.map_size = (x_max, y_max)
        self.tile_size = tile_size
        # self.pos = (0, 0)
        self.move_cursor(0, 0)

    def increment_x(self, x):
        border_len = self.map.border_len
        x_coord = self.x_coord + x

        if 0 > x_coord:
            return

        if x_coord > self.map_size[0] - 1:
            return

        self.x_coord = x_coord
        self.pos = int(x_coord * (self.tile_size +
                                  (1 * border_len))), self.pos[1]
        # anim = Animation(
        #     pos=(int(x_coord * (self.tile_size + (1*border_len))), self.pos[1]),
        #     duration=.01)
        # anim.start(self)

    def increment_y(self, y):
        border_len = self.map.border_len
        y_coord = self.y_coord + y

        if 0 > y_coord:
            return

        if y_coord > self.map_size[1] - 1:
            return
        self.y_coord = y_coord
        self.pos = self.pos[0], int(y_coord * (self.tile_size +
                                               (1 * border_len)))
        # anim = Animation(
        #     pos=(self.pos[0], int(y_coord * (self.tile_size + (1*border_len)))),
        #     duration=.01)
        # anim.start(self)

    def move_cursor(self, touch_x, touch_y):
        touch_x = int(touch_x)
        touch_y = int(touch_y)
        self.x_coord, self.y_coord = touch_x, touch_y
        # self.current_coordinates = (touch_x, touch_y)
        # print('\nCurrent Cursor Position: (%d, %d)' % (self.pos[0]/32, self.pos[1]/32))
        # print('Moving cursor to pos = (%d, %d).' % (touch_x, touch_y))
        anim = Animation(pos=(touch_x * self.tile_size,
                              touch_y * self.tile_size),
                         duration=.1)
        anim.start(self)

    def move_cursor_by_pos(self, new_pos):
        Animation(pos=new_pos, duration=.1).start(self)

    def begin_cursor_animation(self):
        # Highlighting Widget Animation
        self.reveal_cursor()
        self.cursor_anim_1 = Animation(a=.75, duration=.5)
        self.cursor_anim_2 = Animation(a=0, duration=.5)
        self.cursor_anim_1.bind(
            on_complete=lambda x, y: self.cursor_anim_2.start(self.hue))
        self.cursor_anim_2.bind(
            on_complete=lambda x, y: self.cursor_anim_1.start(self.hue))
        self.cursor_anim_1.repeat = False

        if self.cursor_anim_1:
            self.cursor_anim_1.start(self.hue)

    def cancel_cursor_animation(self, dt=0, *args):
        # Cancel Animation
        if isinstance(self.cursor_anim_1, Animation):
            self.cursor_anim_1.cancel(self)
            self.cursor_anim_2.cancel(self)

            self.cursor_anim_1.unbind(
                on_complete=lambda: self.cursor_anim_2.start(self))
            self.cursor_anim_2.unbind(
                on_complete=lambda: self.cursor_anim_1.start(self))

            self.cursor_anim_1 = ''
            self.cursor_anim_2 = ''

    def hide_cursor(self, *args):
        self.hue.a = 0

    def reveal_cursor(self, *args):
        self.hue.a = 0.75