Skip to content
Snippets Groups Projects
Select Git revision
  • master default protected
1 result
Blame Permalink
animation_handler.py 3.96 KiB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128 






from blinkenbase.animation import Animation
from blinkenbase.blinkenroom import Blinkenroom
import blinkenbase.blinkenroom
import blinkenbase.animation
import time
from blinkenbase.blinkenroom import BLINKENROOM_LOUNGE
import _thread
#from darken import darken

class AnimationHandler(object):

    ERROR_ANIMATION_RUNNING = 100
    ERROR_ANIMATION_NOT_FOUND = 101
    ERROR_OVERLAPPING = 102

    def __init__(self):
        self.running_animations = {}
        self.known_animations = {}
        self.last_frame = None

    #######################
    ###Animation control###
    ######################

    def stop_animation(self, p_name):
        if p_name in self.running_animations:
            animation = self.running_animations[p_name]
            print("Stopping %s" % p_name)
            animation.stop()
            del self.running_animations[p_name]

    def stop_all_animations(self, p_args=None):
        for running in self.running_animations.values():
            running.stop()
        self.running_animations = {}
        self.last_frame = BLINKENROOM_LOUNGE.get_last_frame()

    def pause_animation(self, p_animation_name):
        if p_animation_name in self.running_animations:
            animation = self.running_animations[p_animation_name]
            animation.pause()

    def pause_all_animations(self):
        for animation in self.running_animations.values():
            animation.pause()

    def resume_animation(self, p_animation_name):
        if p_animation_name in self.running_animations:
            animation = self.running_animations[p_animation_name]
            animation.resume()

    def resume_all_animations(self):
        for animation in self.running_animations.values():
            animation.resume()

    def start_animation(self, p_name, p_animation_args):
        p_name = p_name.lower()

        animation_class = None
        try:
            exec("from animations.%s import %s" % (p_name, p_name))
            animation_class = eval(p_name)
        except ImportError:
            print("Animation not found '%s'" % p_name)
            return self.ERROR_ANIMATION_NOT_FOUND

        animation = animation_class()
        required_args = animation.required_args
        for arg in required_args:
            required = required_args[arg]
            if arg not in p_animation_args:
                p_animation_args[arg] = required[1]
            else:
                casting_method = required[0]
                current_arg = p_animation_args[arg]
                p_animation_args[arg] = casting_method(current_arg)

        animation.set_args(p_animation_args)
        animation.init_animation()
        to_stop = []
        for running in self.running_animations.values():
            if animation.blinkenroom.is_overlapping(running.blinkenroom):
                to_stop.append(running.name)

        for running in to_stop:
            self.stop_animation(running)

        self.running_animations[p_name] = animation
        animation.start()

    #################
    ###Light-Level###
    #################

    def _thread_handler_darken(self, a, b):
        f = 100
        while f > 0:
            BLINKENROOM_LOUNGE.set_brightness(f)
            time.sleep(0.05)
            f -= 1
        self.pause_all_animations()

    def _thread_handler_lighten(self, a, b):
        f = 1
        self.resume_all_animations()
        while f <= 100:
            BLINKENROOM_LOUNGE.set_brightness(f)
            time.sleep(0.05)
            f += 1

    def darken(self, p_args):
        _thread.start_new_thread(self._thread_handler_darken, (None, None))

    def lighten(self, p_args):
        _thread.start_new_thread(self._thread_handler_lighten, (None, None))

#    def darken(self, p_args):
#        self.stop_all_animations()
#        darken_dicts = {
#            "frame": self.last_frame,
#            "rate": 30,
#            "steps": 100
#        }
#        animation = darken()
#        animation.set_args(darken_dicts)
#        animation.init_animation()
#        animation.start()