|
0
|
1 # taken from SnackMix -- now that's reusable code
|
|
|
2 from Tix import *
|
|
|
3 import time
|
|
|
4
|
|
|
5 class Fadable:
|
|
|
6 """Fading mixin: must mix in with a Tk widget (or something that has
|
|
|
7 'after' at least) This is currently used by VolumeBox and MixerTk.
|
|
|
8 It's probably too specialized to be used elsewhere, but could possibly
|
|
206
|
9 work with an Entry or a Meter, I guess. (Actually, this is used by
|
|
|
10 KeyboardComposer and KeyboardRecorder now too.)
|
|
0
|
11
|
|
|
12 var is a Tk variable that should be used to set and get the levels.
|
|
|
13 If use_fades is true, it will use fades to move between levels.
|
|
|
14 If key_bindings is true, it will install these keybindings:
|
|
|
15
|
|
|
16 Press a number to fade to that amount (e.g. '5' = 50%). Also,
|
|
|
17 '`' (grave) will fade to 0 and '0' will fade to 100%.
|
|
|
18
|
|
|
19 If mouse_bindings is true, the following mouse bindings will be
|
|
|
20 installed: Right clicking toggles muting. The mouse wheel will
|
|
|
21 raise or lower the volume. Shift-mouse wheeling will cause a more
|
|
|
22 precise volume adjustment. Control-mouse wheeling will cause a
|
|
|
23 longer fade."""
|
|
|
24 def __init__(self, var, wheel_step=5, use_fades=1, key_bindings=1,
|
|
|
25 mouse_bindings=1):
|
|
|
26 self.use_fades = use_fades # whether increase and decrease should fade
|
|
|
27 self.wheel_step = wheel_step # amount that increase and descrease should
|
|
|
28 # change volume (by default)
|
|
|
29
|
|
|
30 self.fade_start_level = 0
|
|
|
31 self.fade_end_level = 0
|
|
|
32 self.fade_start_time = 0
|
|
|
33 self.fade_length = 1
|
|
|
34 self.fade_step_time = 10
|
|
|
35 self.fade_var = var
|
|
|
36 self.fading = 0 # whether a fade is in progress
|
|
|
37
|
|
|
38 if key_bindings:
|
|
|
39 for k in range(1, 10):
|
|
|
40 self.bind("<Key-%d>" % k,
|
|
133
|
41 lambda evt, k=k: self.fade(k / 10.0))
|
|
206
|
42 self.bind("<Key-0>", lambda evt: self.fade(1.0))
|
|
0
|
43 self.bind("<grave>", lambda evt: self.fade(0))
|
|
|
44
|
|
|
45 # up / down arrows
|
|
|
46 self.bind("<Key-Up>", lambda evt: self.increase())
|
|
|
47 self.bind("<Key-Down>", lambda evt: self.decrease())
|
|
|
48
|
|
|
49 if mouse_bindings:
|
|
|
50 # right mouse button toggles muting
|
|
|
51 # self.bind('<3>', lambda evt: self.toggle_mute())
|
|
|
52 # "NOT ANY MORE!" - homer
|
|
|
53
|
|
|
54 # mouse wheel
|
|
|
55 self.bind('<4>', lambda evt: self.increase())
|
|
|
56 self.bind('<5>', lambda evt: self.decrease())
|
|
|
57
|
|
|
58 # modified mouse wheel
|
|
|
59 self.bind('<Shift-4>', lambda evt: self.increase(multiplier=0.2))
|
|
|
60 self.bind('<Shift-5>', lambda evt: self.decrease(multiplier=0.2))
|
|
|
61 self.bind('<Control-4>', lambda evt: self.increase(length=1))
|
|
|
62 self.bind('<Control-5>', lambda evt: self.decrease(length=1))
|
|
|
63
|
|
|
64 self.last_level = 0 # used for muting
|
|
|
65 def fade(self, value, length=0.5, step_time=10):
|
|
|
66 """Fade to value in length seconds with steps every step_time
|
|
206
|
67 milliseconds"""
|
|
|
68 if length == 0: # 0 seconds fades happen right away and prevents
|
|
|
69 # and prevents us from entering the fade loop,
|
|
|
70 # which would cause a divide by zero
|
|
|
71 self.fade_var.set(value)
|
|
|
72 self.fading = 0 # we stop all fades
|
|
|
73 else: # the general case
|
|
|
74 self.fade_start_time = time.time()
|
|
|
75 self.fade_length = length
|
|
0
|
76
|
|
206
|
77 self.fade_start_level = self.fade_var.get()
|
|
|
78 self.fade_end_level = value
|
|
|
79
|
|
|
80 self.fade_step_time = step_time
|
|
|
81 if not self.fading:
|
|
|
82 self.fading = 1
|
|
|
83 self.do_fade()
|
|
0
|
84 def do_fade(self):
|
|
|
85 """Actually performs the fade for Fadable.fade. Shouldn't be called
|
|
|
86 directly."""
|
|
|
87 now = time.time()
|
|
|
88 elapsed = now - self.fade_start_time
|
|
|
89 complete = elapsed / self.fade_length
|
|
|
90 complete = min(1.0, complete)
|
|
|
91 diff = self.fade_end_level - self.fade_start_level
|
|
|
92 newlevel = (complete * diff) + self.fade_start_level
|
|
|
93 self.fade_var.set(newlevel)
|
|
|
94 if complete < 1:
|
|
|
95 self.after(self.fade_step_time, self.do_fade)
|
|
|
96 else:
|
|
|
97 self.fading = 0
|
|
|
98 def increase(self, multiplier=1, length=0.3):
|
|
|
99 """Increases the volume by multiplier * wheel_step. If use_fades is
|
|
|
100 true, it do this as a fade over length time."""
|
|
|
101 amount = self.wheel_step * multiplier
|
|
|
102 if self.fading:
|
|
|
103 newlevel = self.fade_end_level + amount
|
|
|
104 else:
|
|
|
105 newlevel = self.fade_var.get() + amount
|
|
|
106 newlevel = min(100, newlevel)
|
|
|
107 self.set_volume(newlevel, length)
|
|
|
108 def decrease(self, multiplier=1, length=0.3):
|
|
|
109 """Descreases the volume by multiplier * wheel_step. If use_fades
|
|
|
110 is true, it do this as a fade over length time."""
|
|
|
111 amount = self.wheel_step * multiplier
|
|
|
112 if self.fading:
|
|
|
113 newlevel = self.fade_end_level - amount
|
|
|
114 else:
|
|
|
115 newlevel = self.fade_var.get() - amount
|
|
|
116 newlevel = max(0, newlevel)
|
|
|
117 self.set_volume(newlevel, length)
|
|
|
118 def set_volume(self, newlevel, length=0.3):
|
|
|
119 """Sets the volume to newlevel, performing a fade of length if
|
|
|
120 use_fades is true."""
|
|
|
121 if self.use_fades:
|
|
|
122 self.fade(newlevel, length=length)
|
|
|
123 else:
|
|
|
124 self.fade_var.set(newlevel)
|
|
|
125 def toggle_mute(self):
|
|
|
126 """Toggles whether the volume is being muted."""
|
|
|
127 curlevel = self.fade_var.get()
|
|
|
128 if curlevel:
|
|
|
129 newlevel = 0
|
|
|
130 self.last_level = curlevel
|
|
|
131 self['bg'] = 'red' # TODO: let them choose these colors
|
|
|
132 else:
|
|
|
133 newlevel = self.last_level
|
|
|
134 self['bg'] = 'lightGray'
|
|
|
135
|
|
|
136 self.fade_var.set(newlevel)
|
|
|
137
|
|
|
138 if __name__ == "__main__":
|
|
|
139 class SubScale(Scale, Fadable):
|
|
|
140 def __init__(self, master, *args, **kw):
|
|
|
141 self.scale_var = DoubleVar()
|
|
|
142 kw['variable'] = self.scale_var
|
|
|
143 Scale.__init__(self, master, *args, **kw)
|
|
|
144 Fadable.__init__(self, var=self.scale_var)
|
|
|
145
|
|
|
146 root = Tk()
|
|
|
147 root.tk_focusFollowsMouse()
|
|
206
|
148 ss = SubScale(root, from_=1, to_=0, res=0.01)
|
|
0
|
149 ss.pack()
|
|
|
150 mainloop()
|
