diff options
Diffstat (limited to 'Lib/stdwin')
| -rwxr-xr-x | Lib/stdwin/Buttons.py | 143 | ||||
| -rwxr-xr-x | Lib/stdwin/Histogram.py | 37 | ||||
| -rwxr-xr-x | Lib/stdwin/Sliders.py | 215 | ||||
| -rwxr-xr-x | Lib/stdwin/StripChart.py | 25 | ||||
| -rwxr-xr-x | Lib/stdwin/VUMeter.py | 7 |
5 files changed, 215 insertions, 212 deletions
diff --git a/Lib/stdwin/Buttons.py b/Lib/stdwin/Buttons.py index 5395f88..3ad5605 100755 --- a/Lib/stdwin/Buttons.py +++ b/Lib/stdwin/Buttons.py @@ -1,10 +1,8 @@ # Module 'Buttons' -from Resize import * - - -# Import module 'rect' renamed as '_rect' +# Import module 'rect' renamed as '_rect' to avoid exporting it on +# 'from Buttons import *' # import rect _rect = rect @@ -28,61 +26,69 @@ class LabelAppearance(): # # Initialization # - def init_appearance(self, (win, bounds)): - self.win = win - self.bounds = bounds + def init_appearance(self): + self.bounds = _rect.empty self.enabled = 1 self.hilited = 0 self.selected = 0 self.text = '' - self.limbo = 1 - self.recalc() - self.win.change(self.bounds) - # While the limbo flag is set, redraw calls are ignored. - # It is cleared by the first draw event. - # This is intended to avoid duplicate drawing during - # initialization. + # + # Size enquiry + # + def minsize(self, m): + try: + self.text = self.text + except NameError: + self.text = '' + return m.textwidth(self.text) + 6, m.lineheight() + 6 + # + def getbounds(self): + return self.bounds # # Changing the parameters # def settext(self, text): self.text = text - self.recalctextpos() - self.redraw() + if self.bounds <> _rect.empty: + self.recalctextpos() + self.redraw() # def setbounds(self, bounds): - # This delays drawing until after all buttons are moved - self.win.change(self.bounds) + if self.bounds <> _rect.empty: + self.parent.change(self.bounds) self.bounds = bounds - self.recalc() - self.win.change(bounds) + if self.bounds <> _rect.empty: + self.recalc() + self.parent.change(bounds) # # Changing the state bits # def enable(self, flag): if flag <> self.enabled: self.enabled = flag - if not self.limbo: - self.flipenable(self.win.begindrawing()) + if self.bounds <> _rect.empty: + self.flipenable(self.parent.begindrawing()) # def hilite(self, flag): if flag <> self.hilited: self.hilited = flag - if not self.limbo: - self.fliphilite(self.win.begindrawing()) + if self.bounds <> _rect.empty: + self.fliphilite(self.parent.begindrawing()) # def select(self, flag): if flag <> self.selected: self.selected = flag - self.redraw() + if self.bounds <> _rect.empty: + self.redraw() # # Recalculate the box bounds and text position. # This can be overridden by buttons that draw different boxes # or want their text in a different position. # def recalc(self): - self.recalcbounds() - self.recalctextpos() + if self.bounds <> _rect.empty: + self.recalcbounds() + self.recalctextpos() # def recalcbounds(self): self.hilitebounds = _rect.inset(self.bounds, (3, 3)) @@ -90,20 +96,19 @@ class LabelAppearance(): # def recalctextpos(self): (left, top), (right, bottom) = self.bounds - d = self.win.begindrawing() - h = (left + right - d.textwidth(self.text)) / 2 - v = (top + bottom - d.lineheight()) / 2 + m = self.parent.beginmeasuring() + h = (left + right - m.textwidth(self.text)) / 2 + v = (top + bottom - m.lineheight()) / 2 self.textpos = h, v # - # Generic drawing mechanism. + # Generic drawing interface. # Do not override redraw() or draw() methods; override drawit() c.s. # def redraw(self): - if not self.limbo: - self.draw(self.win.begindrawing(), self.bounds) + if self.bounds <> _rect.empty: + self.draw(self.parent.begindrawing(), self.bounds) # def draw(self, (d, area)): - self.limbo = 0 area = _rect.intersect(area, self.bounds) if area = _rect.empty: return @@ -161,6 +166,10 @@ class ButtonAppearance() = LabelAppearance(): # class CheckAppearance() = LabelAppearance(): # + def minsize(self, m): + width, height = m.textwidth(self.text) + 6, m.lineheight() + 6 + return width + height + m.textwidth(' '), height + # def drawpict(self, d): d.box(self.boxbounds) if self.selected: _xorcross(d, self.boxbounds) @@ -173,10 +182,10 @@ class CheckAppearance() = LabelAppearance(): self.hilitebounds = self.boxbounds # def recalctextpos(self): - d = self.win.begindrawing() + m = self.parent.beginmeasuring() (left, top), (right, bottom) = self.boxbounds - h = right + d.textwidth(' ') - v = top + (self.size - d.lineheight()) / 2 + h = right + m.textwidth(' ') + v = top + (self.size - m.lineheight()) / 2 self.textpos = h, v # @@ -199,24 +208,31 @@ class RadioAppearance() = CheckAppearance(): # -# NoReactivity ignores mouse and timer events. +# NoReactivity ignores mouse events. +# +class NoReactivity(): + def init_reactivity(self): pass + + +# BaseReactivity defines hooks and asks for mouse events, +# but provides only dummy mouse event handlers. # The trigger methods call the corresponding hooks set by the user. # Hooks (and triggers) mean the following: # down_hook called on some mouse-down events # move_hook called on some mouse-move events # up_hook called on mouse-up events # on_hook called for buttons with on/off state, when it goes on -# timer_hook called on timer events # hook called when a button 'fires' or a radiobutton goes on # There are usually extra conditions, e.g., hooks are only called # when the button is enabled, or active, or selected (on). # -class NoReactivity(): +class BaseReactivity(): # def init_reactivity(self): self.down_hook = self.move_hook = self.up_hook = \ - self.on_hook = self.off_hook = self.timer_hook = \ - self.hook = self.active = 0 + self.on_hook = self.off_hook = \ + self.hook = self.active = 0 + self.parent.need_mouse(self) # def mousetest(self, hv): return _rect.pointinrect(hv, self.bounds) @@ -230,9 +246,6 @@ class NoReactivity(): def mouse_up(self, detail): pass # - def timer(self): - pass - # def down_trigger(self): if self.down_hook: self.down_hook(self) # @@ -248,18 +261,14 @@ class NoReactivity(): def off_trigger(self): if self.off_hook: self.off_hook(self) # - def timer_trigger(self): - if self.timer_hook: self.timer_hook(self) - # def trigger(self): if self.hook: self.hook(self) # ToggleReactivity acts like a simple pushbutton. # It toggles its hilite state on mouse down events. -# Its timer_trigger method is called for all timer events while hilited. # -class ToggleReactivity() = NoReactivity(): +class ToggleReactivity() = BaseReactivity(): # def mouse_down(self, detail): if self.enabled and self.mousetest(detail[_HV]): @@ -276,10 +285,6 @@ class ToggleReactivity() = NoReactivity(): self.up_trigger() self.active = 0 # - def timer(self): - if self.hilited: - self.timer_trigger() - # def down_trigger(self): if self.hilited: self.on_trigger() @@ -292,7 +297,7 @@ class ToggleReactivity() = NoReactivity(): # TriggerReactivity acts like a fancy pushbutton. # It hilites itself while the mouse is down within its bounds. # -class TriggerReactivity() = NoReactivity(): +class TriggerReactivity() = BaseReactivity(): # def mouse_down(self, detail): if self.enabled and self.mousetest(detail[_HV]): @@ -315,10 +320,6 @@ class TriggerReactivity() = NoReactivity(): self.active = 0 self.hilite(0) # - def timer(self): - if self.active and self.hilited: - self.timer_trigger() - # # CheckReactivity handles mouse events like TriggerReactivity, @@ -356,13 +357,22 @@ class RadioReactivity() = TriggerReactivity(): # Auxiliary class for 'define' method. +# Call the initializers in the right order. # -class Define() = NoResize(): +class Define(): # - def define(self, (win, bounds, text)): - self.init_appearance(win, bounds) + def define(self, parent): + self.parent = parent + parent.addchild(self) + self.init_appearance() self.init_reactivity() - self.init_resize() + return self + # + def destroy(self): + self.parent = 0 + # + def definetext(self, (parent, text)): + self = self.define(parent) self.settext(text) return self @@ -380,11 +390,10 @@ def _xorcross(d, bounds): d.xorline((left, bottom), (right, top)) -# Ready-made button classes +# Ready-made button classes. # -class BaseButton() = NoReactivity(), LabelAppearance(), Define(): pass class Label() = NoReactivity(), LabelAppearance(), Define(): pass -class ClassicButton() = TriggerReactivity(), ButtonAppearance(), Define(): pass +class PushButton() = TriggerReactivity(), ButtonAppearance(), Define(): pass class CheckButton() = CheckReactivity(), CheckAppearance(), Define(): pass class RadioButton() = RadioReactivity(), RadioAppearance(), Define(): pass -class Toggle() = ToggleReactivity(), ButtonAppearance(), Define(): pass +class ToggleButton() = ToggleReactivity(), ButtonAppearance(), Define(): pass diff --git a/Lib/stdwin/Histogram.py b/Lib/stdwin/Histogram.py index f469272..505bbaf 100755 --- a/Lib/stdwin/Histogram.py +++ b/Lib/stdwin/Histogram.py @@ -1,41 +1,36 @@ # Module 'Histogram' from Buttons import * -from Resize import Resize - # A Histogram displays a histogram of numeric data. -# It reacts to resize events by resizing itself, -# leaving the same amount of space around the borders. -# (This is geometry management, and should really be implemented -# by a different group of classes, but for now this hack is OK.) # -class HistogramAppearance() = Resize(), LabelAppearance(): +class HistogramAppearance() = LabelAppearance(), Define(): # - def define(self, (win, bounds, ydata, scale)): - self.init_appearance(win, bounds) - self.init_resize() - self.ydata = ydata - self.scale = scale # (min, max) + def define(self, parent): + Define.define(self, (parent, '')) + self.ydata = [] + self.scale = (0, 100) return self # def setdata(self, (ydata, scale)): self.ydata = ydata self.scale = scale # (min, max) - self.win.change(self.bounds) + self.parent.change(self.bounds) # - def drawit(self, d): - ydata = self.ydata + def drawpict(self, d): (left, top), (right, bottom) = self.bounds min, max = self.scale size = max-min width, height = right-left, bottom-top - for i in range(len(ydata)): - h0 = left + i * width/len(ydata) - h1 = left + (i+1) * width/len(ydata) - v0 = top + height - (self.ydata[i]-min)*height/size - v1 = top + height + ydata = self.ydata + npoints = len(ydata) + v1 = top + height # constant + h1 = left # changed in loop + for i in range(npoints): + h0 = h1 + v0 = top + height - (ydata[i]-min)*height/size + h1 = left + (i+1) * width/npoints d.paint((h0, v0), (h1, v1)) # -class Histogram() = HistogramAppearance(), NoReactivity(): pass +class Histogram() = NoReactivity(), HistogramAppearance(): pass diff --git a/Lib/stdwin/Sliders.py b/Lib/stdwin/Sliders.py index b142ef4..f655e77 100755 --- a/Lib/stdwin/Sliders.py +++ b/Lib/stdwin/Sliders.py @@ -1,13 +1,11 @@ # Module 'Sliders' -# -# XXX Should split caller interface, appearance and reactivity better import stdwin from stdwinevents import * import rect from Buttons import * -from Resize import * +from HVSplit import HSplit # Field indices in event detail @@ -18,11 +16,13 @@ _BUTTON = 2 _MASK = 3 -# A dragslider is the simplest possible slider. +# DragSlider is the simplest possible slider. # It looks like a button but dragging the mouse left or right # changes the controlled value. +# It does not support any of the triggers or hooks defined by Buttons, +# but defines its own setval_trigger and setval_hook. # -class DragSliderReactivity() = NoReactivity(): +class DragSliderReactivity() = BaseReactivity(): # def mouse_down(self, detail): h, v = hv = detail[_HV] @@ -43,136 +43,133 @@ class DragSliderReactivity() = NoReactivity(): self.active = 0 # -class DragSliderAppearance() = NoResize(), ButtonAppearance(): - # - def define(self, (win, bounds)): - self.min = 0 - self.val = -1 # Changed by next setval call - self.max = 100 - self.setval_hook = 0 - self.pretext = self.postext = '' - self = ClassicButton.define(self, (win, bounds, '')) - self.setval(50) - return self +class DragSliderAppearance() = ButtonAppearance(): # # INVARIANTS maintained by the setval method: # # self.min <= self.val <= self.max # self.text = self.pretext + `self.val` + self.postext # - # (Notice that unlike in Python ranges, the end point belongs + # (Notice that unlike Python ranges, the end point belongs # to the range.) # + def init_appearance(self): + ButtonAppearance.init_appearance(self) + self.min = 0 + self.val = 0 + self.max = 100 + self.hook = 0 + self.pretext = self.postext = '' + self.recalctext() + # + # The 'get*' and 'set*' methods belong to the generic slider interface + # + def getval(self): return self.val + # + def sethook(self, hook): + self.hook = hook + # + def setminvalmax(self, (min, val, max)): + self.min = min + self.max = max + self.setval(val) + # + def settexts(self, (pretext, postext)): + self.pretext = pretext + self.postext = postext + self.recalctext() + # def setval(self, val): val = min(self.max, max(self.min, val)) if val <> self.val: self.val = val - self.setval_trigger() - # (The trigger may change val, pretext and postext) - self.settext(self.pretext + `self.val` + self.postext) + self.recalctext() + self.trigger() + # + def trigger(self): + if self.hook: + self.hook(self) # - def setval_trigger(self): - if self.setval_hook: - self.setval_hook(self) + def recalctext(self): + self.settext(self.pretext + `self.val` + self.postext) # -class DragSlider() = DragSliderReactivity(), DragSliderAppearance(): pass +class DragSlider() = DragSliderReactivity(), DragSliderAppearance(), Define(): + def definetext(self, (parent, text)): + raise RuntimeError, 'DragSlider.definetext() not supported' -# Auxiliary class for DragSlider incorporated in ComplexSlider +# Auxiliary class for PushButton incorporated in ComplexSlider # -class _SubDragSlider() = DragSlider(): - def define(self, (win, bounds, parent)): - self.parent = parent - return DragSlider.define(self, (win, bounds)) - def setval_trigger(self): - self.parent.val = self.val - self.parent.setval_trigger() - -# Auxiliary class for ClassicButton incorporated in ComplexSlider -# -class _SubClassicButton() = ClassicButton(): - def define(self, (win, bounds, text, step, parent)): - self.parent = parent +class _StepButton() = PushButton(): + def define(self, parent): + self = PushButton.define(self, parent) + self.step = 0 + return self + def setstep(self, step): self.step = step - return ClassicButton.define(self, (win, bounds, text)) + def definetextstep(self, (parent, text, step)): + self = self.definetext(parent, text) + self.setstep(step) + return self + def init_reactivity(self): + PushButton.init_reactivity(self) + self.parent.need_timer(self) + def step_trigger(self): + self.parent.setval(self.parent.getval() + self.step) def down_trigger(self): - self.parent.setval(self.parent.val + self.step) - self.delay = 5 - self.win.settimer(self.delay) - def move_trigger(self): - self.win.settimer(self.delay) - def timer_trigger(self): - self.delay = 1 - self.parent.setval(self.parent.val + self.step) - self.win.settimer(self.delay) + self.step_trigger() + self.parent.settimer(5) + def timer(self): + if self.hilited: + self.step_trigger() + if self.active: + self.parent.settimer(1) -# A complex slider is a wrapper around three buttons: -# One to step down, a dragslider, and one to step up. + +# A complex slider is an HSplit initialized to three buttons: +# one to step down, a dragslider, and one to step up. # -class ComplexSlider() = NoResize(), LabelAppearance(), NoReactivity(): +class ComplexSlider() = HSplit(): # - def define(self, (win, bounds)): - # - self.win = win - self.bounds = bounds - self.setval_hook = 0 - # - (left, top), (right, bottom) = bounds - size = bottom - top - # - downbox = (left, top), (left+size, bottom) - sliderbox = (left+size, top), (right-size, bottom) - upbox = (right-size, top), (right, bottom) - # - self.downbutton = \ - _SubClassicButton().define(win, downbox, '-', -1, self) - # - self.sliderbutton = \ - _SubDragSlider().define(win, sliderbox, self) - # - self.upbutton = \ - _SubClassicButton().define(win, upbox, '+', 1, self) - # - self.min = self.sliderbutton.min - self.val = self.sliderbutton.val - self.max = self.sliderbutton.max - self.pretext = self.sliderbutton.pretext - self.postext = self.sliderbutton.postext + # Override Slider define() method + # + def define(self, parent): + self = self.create(parent) # HSplit # - self.children = \ - [self.downbutton, self.sliderbutton, self.upbutton] + self.downbutton = _StepButton().definetextstep(self, '-', -1) + self.dragbutton = DragSlider().define(self) + self.upbutton = _StepButton().definetextstep(self, '+', 1) # return self # - def mouse_down(self, detail): - for b in self.children: - b.mouse_down(detail) + # Override HSplit methods # - def mouse_move(self, detail): - for b in self.children: - b.mouse_move(detail) - # - def mouse_up(self, detail): - for b in self.children: - b.mouse_up(detail) - # - def timer(self): - for b in self.children: - b.timer() - # - def draw(self, area): - for b in self.children: - b.draw(area) - # - def setval(self, val): - self.sliderbutton.min = self.min - self.sliderbutton.max = self.max - self.sliderbutton.pretext = self.pretext - self.sliderbutton.postext = self.postext - self.sliderbutton.setval(val) - # - def setval_trigger(self): - if self.setval_hook: - self.setval_hook(self) + def minsize(self, m): + w1, h1 = self.downbutton.minsize(m) + w2, h2 = self.dragbutton.minsize(m) + w3, h3 = self.upbutton.minsize(m) + height = max(h1, h2, h3) + w1 = max(w1, height) + w3 = max(w3, height) + return w1+w2+w3, height # + def setbounds(self, bounds): + (left, top), (right, bottom) = self.bounds = bounds + size = bottom - top + self.downbutton.setbounds((left, top), (left+size, bottom)) + self.dragbutton.setbounds((left+size, top), \ + (right-size, bottom)) + self.upbutton.setbounds((right-size, top), (right, bottom)) + # + # Pass other Slider methods on to dragbutton + # + def getval(self): return self.dragbutton.getval() + def sethook(self, hook): self.dragbutton.sethook(hook) + def setminvalmax(self, args): self.dragbutton.setminvalmax(args) + def settexts(self, args): self.dragbutton.settexts(args) + def setval(self, val): self.dragbutton.setval(val) + def enable(self, flag): + self.downbutton.enable(flag) + self.dragbutton.enable(flag) + self.upbutton.enable(flag) diff --git a/Lib/stdwin/StripChart.py b/Lib/stdwin/StripChart.py index 2021cc4..ac767c3 100755 --- a/Lib/stdwin/StripChart.py +++ b/Lib/stdwin/StripChart.py @@ -1,17 +1,18 @@ # Module 'StripChart' - import rect -from Buttons import * -from Resize import * +from Buttons import LabelAppearance, NoReactivity +# A StripChart doesn't really look like a label but it needs a base class. +# LabelAppearance allows it to be disabled and hilited. -class StripChart() = LabelAppearance(), NoReactivity(), NoResize(): +class StripChart() = LabelAppearance(), NoReactivity(): # - def define(self, (win, bounds, scale)): - self.init_appearance(win, bounds) + def define(self, (parent, scale)): + self.parent = parent + parent.addchild(self) + self.init_appearance() self.init_reactivity() - self.init_resize() self.ydata = [] self.scale = scale self.resetbounds() @@ -37,18 +38,18 @@ class StripChart() = LabelAppearance(), NoReactivity(), NoResize(): excess = len(self.ydata) - self.width if excess > 0: del self.ydata[:excess] - if not self.limbo: - self.win.scroll(self.bounds, (-excess, 0)) - if not self.limbo: + if self.bounds <> rect.empty: + self.parent.scroll(self.bounds, (-excess, 0)) + if self.bounds <> rect.empty: (left, top), (right, bottom) = self.bounds i = len(self.ydata) area = (left+i-1, top), (left+i, bottom) - self.draw(self.win.begindrawing(), area) + self.draw(self.parent.begindrawing(), area) # def draw(self, (d, area)): - self.limbo = 0 area = rect.intersect(area, self.bounds) if area = rect.empty: + print 'mt' return d.cliprect(area) d.erase(self.bounds) diff --git a/Lib/stdwin/VUMeter.py b/Lib/stdwin/VUMeter.py index 65c018b..59fc36f 100755 --- a/Lib/stdwin/VUMeter.py +++ b/Lib/stdwin/VUMeter.py @@ -10,8 +10,9 @@ class VUMeter() = StripChart(): # # Override define() and timer() methods # - def define(self, (win, bounds)): - self = StripChart.define(self, (win, bounds, 128)) + def define(self, parent): + self = StripChart.define(self, (parent, 128)) + self.parent.need_timer(self) self.sampling = 0 self.rate = 3 self.enable(0) @@ -31,7 +32,7 @@ class VUMeter() = StripChart(): audio.start_recording(size) self.sampling = 1 if self.sampling: - self.win.settimer(1) + self.parent.settimer(1) # # New methods: start() and stop() # |