mwxlib 0.99.0__py3-none-any.whl → 1.7.13__py3-none-any.whl

mwx/controls.py

@@ -1,18 +1,21 @@
 #! python3
 """mwxlib param controller and wx custom controls.
 """
+from contextlib import contextmanager
 from itertools import chain
+import io
+import re
 import wx
 import wx.lib.platebtn as pb
 import wx.lib.scrolledpanel as scrolled
 
 from . import images
-from .utilus import SSM, warn
+from .utilus import SSM
 from .utilus import funcall as _F
 from .framework import pack, Menu, CtrlInterface
 
 import numpy as np
-from numpy import nan, inf  # noqa: necessary to eval
+from numpy import nan, inf  # noqa # necessary to eval
 
 
 def _Tip(*tips):
@@ -21,29 +24,31 @@ def _Tip(*tips):
 
 
 class Param:
-    """Standard Parameter
+    """Standard Parameter.
     
     Args:
-        name    : label
-        range   : range
-        value   : std_value (default is nan)
-        fmt     : text formatter or format:str (default is '%g')
-                  `hex` specifies hexadecimal format
-        handler : called when control changed
-        updater : called when check changed
+        name:  label
+        range: list of values
+        value: std_value (default is None)
+        fmt:   text formatter or format:str (default is '%g')
+               `hex` specifies hexadecimal format
+        handler: called when knob is handled.
+        updater: called when button is pressed.
+        checker: called when tick turns on/off.
     
     Attributes:
-        knobs       : knob list
-        callback    : single state machine that handles following events
+        knobs: knob list
+        callback: single state machine that handles following events
         
-            - control -> when index changed by knobs or reset (handler)
-            - update  -> when button pressed (updater)
-            - check   -> when check marked (updater)
+            - control -> when index is changed by knobs or reset (handler)
+            - updated -> when button is pressed (updater)
+            - checked -> when tick turns on/off (checker)
+            - notified -> when value changed
             - overflow -> when value overflows
             - underflow -> when value underflows
     """
     def __init__(self, name, range=None, value=None, fmt=None,
-                 handler=None, updater=None):
+                 handler=None, updater=None, checker=None):
         self.knobs = []
         self.name = name
         self.range = range
@@ -56,114 +61,110 @@ class Param:
         else:
             self.__eval = lambda v: eval(v)
             self.__format = fmt or "{:,g}".format
-            if isinstance(fmt, str): # support %-format:str (deprecated)
+            if isinstance(fmt, str):  # support %-format:str (deprecated)
                 self.__format = lambda v: fmt % v
         self.callback = SSM({
             'control' : [ _F(handler) ] if handler else [],
-             'update' : [ _F(updater) ] if updater else [],
-              'check' : [ _F(updater) ] if updater else [],
+            'updated' : [ _F(updater) ] if updater else [],
+            'checked' : [ _F(checker) ] if checker else [],
+           'notified' : [],
            'overflow' : [],
           'underflow' : [],
         })
-        self._tooltip = _Tip(handler.__doc__, updater.__doc__)
-    
+        self._tooltip = _Tip(handler.__doc__,
+                             updater.__doc__)
+
     def __str__(self, v=None):
         if v is None:
             v = self.value
         try:
             return self.__format(v)
-        except ValueError:
+        except (TypeError, ValueError):
             return str(v)
-    
+
     def __int__(self):
         return int(self.value)
-    
+
     def __float__(self):
         return float(self.value)
-    
+
     def __len__(self):
         return len(self.range)
-    
-    def bind(self, action=None, target='control'):
-        warn("Use `Param.callback.bind('control')` instead.", DeprecationWarning)
-        return self.callback.bind(target, action)
-    
-    def unbind(self, action=None, target='control'):
-        warn("Use `Param.callback.unbind('control')` instead.", DeprecationWarning)
-        return self.callback.unbind(target, action)
-    
+
     def reset(self, v=None, internal_callback=True):
         """Reset value when indexed (by knobs) with callback."""
         if v is None:
-            v = self.std_value  # reset to std_value
-            if np.isnan(v):     # do nothing if std_value is nan
+            v = self.std_value
+            if np.isnan(v):
                 return
         elif isinstance(v, str):
             try:
-                v = self.__eval(v.replace(',', '')) # eliminates commas; includes nan, inf
+                v = self.__eval(v.replace(',', ''))  # Eliminates commas.
             except Exception:
                 v = self.value
                 internal_callback = False
-        
-        if v is None:
-            v = nan
-        if np.isnan(v) or np.isinf(v):
-            self.__value = v
-            for knob in self.knobs:
-                knob.update_ctrl(None, notify=False)
-            return
-        if v != self.__value:
-            ## If the value is out of range, it will be modified.
-            valid = (self.min <= v <= self.max)
-            if valid:
-                self.__value = v
-            elif v < self.min:
-                self.__value = self.min
-                self.callback('underflow', self)
-            else:
-                self.__value = self.max
-                self.callback('overflow', self)
-            for knob in self.knobs:
-                knob.update_ctrl(valid, notify=True)
+        self.value = v
         if internal_callback:
             self.callback('control', self)
-    
+
     @property
     def check(self):
-        """A knob check property (user defined)."""
+        """A knob check-flag (user defined)."""
         return self.__check
-    
+
     @check.setter
     def check(self, v):
         self.__check = bool(v)
-        self.callback('check', self)
-        for knob in self.knobs:
-            knob.update_label()
-    
+        self.callback('checked', self)
+
     @property
     def name(self):
         return self.__name
-    
+
     @name.setter
     def name(self, v):
         self.__name = v
         for knob in self.knobs:
             knob.update_label()
-    
+
     @property
     def value(self):
         """Current value := std_value + offset."""
         return self.__value
-    
+
     @value.setter
     def value(self, v):
-        self.reset(v)
-    
+        if v is None:
+            v = nan
+        if np.isnan(v) or np.isinf(v):  # Skip events for nan and inf.
+            self.__value = v
+            for knob in self.knobs:
+                knob.update_control(None)
+            return
+        elif v == self.__value:
+            for knob in self.knobs:
+                knob.update_control()
+            return
+        
+        ## If the value is out of range, it will be modified.
+        valid = (self.min <= v <= self.max)
+        if valid:
+            self.__value = v
+        elif v < self.min:
+            self.__value = self.min
+            self.callback('underflow', self)
+        else:
+            self.__value = self.max
+            self.callback('overflow', self)
+        for knob in self.knobs:
+            knob.update_control(valid, notify=True)
+        self.callback('notified', self)
+
     @property
     def std_value(self):
         """A standard value (default None)."""
         return self.__std_value
-    
+
     @std_value.setter
     def std_value(self, v):
         if v is None:
@@ -171,7 +172,7 @@ class Param:
         self.__std_value = v
         for knob in self.knobs:
             knob.update_label()
-    
+
     @property
     def offset(self):
         """Offset value
@@ -180,38 +181,40 @@ class Param:
         if not np.isnan(self.std_value):
             return self.value - self.std_value
         return self.value
-    
+
     @offset.setter
     def offset(self, v):
         if not np.isnan(self.std_value):
             v += self.std_value
         self.value = v
-    
+
     min = property(lambda self: self.__range[0] if self else nan)
     max = property(lambda self: self.__range[-1] if self else nan)
-    
+
     @property
     def range(self):
         """Index range."""
         return self.__range
-    
+
     @range.setter
     def range(self, v):
         if v is None:
-            self.__range = [] # dummy data
+            self.__range = []  # dummy data
         else:
             self.__range = sorted(v)
         for knob in self.knobs:
-            knob.update_range() # list range of related knobs
-    
+            knob.update_range()  # list range of related knobs
+
     @property
     def index(self):
         """A knob index -> value.
-        Returns -1 if the value is not defined."""
-        if self:
-            return int(np.searchsorted(self.range, self.value))
-        return -1
-    
+        Returns -1 if the value is not defined.
+        """
+        v = self.value
+        if np.isnan(v) or np.isinf(v):
+            return -1
+        return int(np.searchsorted(self.range, v))
+
     @index.setter
     def index(self, j):
         if self:
@@ -220,38 +223,41 @@ class Param:
 
 
 class LParam(Param):
-    """Linear Parameter
+    """Linear Parameter.
     
     Args:
-        name    : label
-        range   : range [min:max:step]
-        value   : std_value (default is None)
-        fmt     : text formatter or format:str (default is '%g')
-                  `hex` specifies hexadecimal format
-        handler : called when control changed
-        updater : called when check changed
+        name:  label
+        range: range params [min:max:step]
+        value: std_value (default is None)
+        fmt:   text formatter or format:str (default is '%g')
+               `hex` specifies hexadecimal format
+        handler: called when knob is handled.
+        updater: called when button is pressed.
+        checker: called when tick turns on/off.
     
     Attributes:
-        knobs       : knob list
-        callback    : single state machine that handles following events
+        knobs: knob list
+        callback: single state machine that handles following events
         
-            - control -> when index changed by knobs or reset (handler)
-            - check   -> when check ticks on/off (updater)
+            - control -> when index is changed by knobs or reset (handler)
+            - updated -> when button is pressed (updater)
+            - checked -> when tick turns on/off (checker)
+            - notified -> when value changed
             - overflow -> when value overflows
             - underflow -> when value underflows
     """
     min = property(lambda self: self.__min)
     max = property(lambda self: self.__max)
     step = property(lambda self: self.__step)
-    
+
     def __len__(self):
-        return 1 + int(round((self.max - self.min) / self.step)) # includes [min,max]
-    
+        return 1 + int(round((self.max - self.min) / self.step))  # includes [min,max]
+
     @property
     def range(self):
         """Index range."""
         return np.arange(self.min, self.max + self.step, self.step)
-    
+
     @range.setter
     def range(self, v):
         assert v is None or len(v) <= 3, "The range must be of length <= 3 or None"
@@ -261,8 +267,8 @@ class LParam(Param):
         self.__max = v[1]
         self.__step = v[2] if len(v) > 2 else 1
         for knob in self.knobs:
-            knob.update_range() # linear range of related knobs
-    
+            knob.update_range()  # linear range of related knobs
+
     @property
     def index(self):
         """A knob index -> value
@@ -271,19 +277,19 @@ class LParam(Param):
         v = self.value
         if np.isnan(v) or np.isinf(v):
             return -1
-        return int(round((self.value - self.min) / self.step))
-    
+        return int(round((v - self.min) / self.step))
+
     @index.setter
     def index(self, j):
         self.value = self.min + j * self.step
 
 
 ## --------------------------------
-## Knob unit for Parameter Control 
+## Knob unit for Parameter Control.
 ## --------------------------------
 
 class Knob(wx.Panel):
-    """Parameter controller unit
+    """Parameter controller unit.
     
     In addition to direct key input to the textctrl,
     [up][down][wheelup][wheeldown] keys can be used,
@@ -291,42 +297,49 @@ class Knob(wx.Panel):
     [Mbutton] resets to the std. value if it exists.
     
     Args:
-        param   : <Param> or <LParam> object
-        type    : ctrl type (slider[*], [hv]spin, choice, None)
-        style   : style of label
-                  None -> static text (default)
-                  chkbox -> label with check box
-                  button -> label with flat button
-        cw      : width of ctrl
-        lw      : width of label
-        tw      : width of textbox
-        h       : height of widget (defaults to 22)
+        param: <Param> or <LParam> object
+        type:  control type (slider[*], [hv]spin, choice, None)
+        style: style of label
+               None -> static text (default)
+               button -> label with flat button
+               checkbox -> label with checkbox
+        cw: width of control
+        lw: width of label
+        tw: width of textbox
+        h:  height of widget (defaults to 22)
     """
     @property
     def param(self):
         """Param object referred from knobs."""
         return self.__par
-    
+
     @param.setter
     def param(self, v):
         self.__par.knobs.remove(self)
         self.__par = v
         self.__par.knobs.append(self)
         self.update_range()
-        self.update_ctrl()
-    
+        self.update_control()
+
+    @property
+    def button(self):
+        if isinstance(self._label, pb.PlateButton):
+            return self._label
+
+    @property
+    def control(self):
+        return self._ctrl
+
     def __init__(self, parent, param, type=None,
                  style=None, cw=-1, lw=-1, tw=-1, h=22, **kwargs):
         wx.Panel.__init__(self, parent, **kwargs)
         
-        assert isinstance(param, Param),\
-          "Argument `param` must be an instance of Param"
+        assert isinstance(param, Param), "Argument `param` must be an instance of Param"
         
-        self.__bit = 1
         self.__par = param
-        self.__par.knobs.append(self) # パラメータの関連付けを行う
+        self.__par.knobs.append(self)  # パラメータの関連付けを行う
         
-        if type is None:
+        if not type:
             type = 'slider'
             if cw < 0:
                 cw = 0
@@ -338,211 +351,214 @@ class Knob(wx.Panel):
         
         label = self.__par.name + '  '
         
-        if style == 'chkbox':
-            if lw >= 0:
-                lw += 16
-            self.label = wx.CheckBox(self, label=label, size=(lw,-1))
-            self.label.Bind(wx.EVT_CHECKBOX, self.OnCheck)
-            
+        if style == 'chkbox' or style == 'checkbox':
+            ## Keep margin for the checkbox: lw += 16
+            self._label = wx.CheckBox(self, label=label, size=(lw,-1))
+            self._label.Bind(wx.EVT_CHECKBOX, self.OnCheck)
         elif style == 'button':
-            if lw >= 0:
-                lw += 16
-            self.label = pb.PlateButton(self, label=label, size=(lw,-1),
-                            style=pb.PB_STYLE_DEFAULT|pb.PB_STYLE_SQUARE)
-            self.label.Bind(wx.EVT_BUTTON, self.OnPress)
-            
+            ## Keep margin for the button: lw += 16
+            self._label = pb.PlateButton(self, label=label, size=(lw,-1),
+                                         style=pb.PB_STYLE_DEFAULT|pb.PB_STYLE_SQUARE)
+            self._label.Bind(wx.EVT_BUTTON, self.OnPress)
         elif not style:
-            self.label = wx.StaticText(self, label=label, size=(lw,-1))
+            self._label = wx.StaticText(self, label=label, size=(lw,-1))
         else:
-            raise Exception("unknown style: {!r}".format(style))
+            raise Exception(f"unknown style: {style!r}")
         
-        self.label.Bind(wx.EVT_MIDDLE_DOWN, lambda v: self.__par.reset())
-        self.label.SetToolTip(self.__par._tooltip)
-        self.label.Enable(lw) # skip focus
+        self._label.Bind(wx.EVT_MIDDLE_DOWN, lambda v: self.__par.reset())
+        self._label.SetToolTip(self.__par._tooltip)
+        self._label.Enable(lw)  # skip focus
         
-        self.text = wx.TextCtrl(self, size=(tw,h), style=wx.TE_PROCESS_ENTER)
-        self.text.Bind(wx.EVT_TEXT_ENTER, self.OnTextEnter)
-        self.text.Bind(wx.EVT_KILL_FOCUS, self.OnTextExit)
-        self.text.Bind(wx.EVT_KEY_DOWN, self.OnTextKeyDown)
-        self.text.Bind(wx.EVT_KEY_UP, self.OnTextKeyUp)
-        self.text.Bind(wx.EVT_MOUSEWHEEL, self.OnMouseWheel)
-        self.text.Bind(wx.EVT_MIDDLE_DOWN, lambda v: self.__par.reset())
+        self._text = wx.TextCtrl(self, size=(tw,h), style=wx.TE_PROCESS_ENTER)
+        self._text.Bind(wx.EVT_TEXT_ENTER, self.OnTextEnter)
+        self._text.Bind(wx.EVT_KILL_FOCUS, self.OnTextExit)
+        self._text.Bind(wx.EVT_KEY_DOWN, self.OnTextKeyDown)
+        self._text.Bind(wx.EVT_KEY_UP, self.OnTextKeyUp)
+        self._text.Bind(wx.EVT_MOUSEWHEEL, self.OnMouseWheel)
+        self._text.Bind(wx.EVT_MIDDLE_DOWN, lambda v: self.__par.reset())
         
-        self.text.Enable(tw) # skip focus
+        self._text.Enable(tw)  # skip focus
         
         if type == 'slider':
-            self.ctrl = wx.Slider(self, size=(cw,h), style=wx.SL_HORIZONTAL)
-            self.ctrl.Bind(wx.EVT_SCROLL_CHANGED, self.OnScroll)
-            self.ctrl.Bind(wx.EVT_KEY_DOWN, self.OnCtrlKeyDown)
-            self.ctrl.Bind(wx.EVT_MOUSEWHEEL, self.OnMouseWheel)
+            self._ctrl = wx.Slider(self, size=(cw,h), style=wx.SL_HORIZONTAL)
+            self._ctrl.Bind(wx.EVT_SCROLL_CHANGED, self.OnScroll)
+            self._ctrl.Bind(wx.EVT_KEY_DOWN, self.OnCtrlKeyDown)
+            self._ctrl.Bind(wx.EVT_MOUSEWHEEL, self.OnMouseWheel)
             
         elif type == 'slider*':
-            self.ctrl = wx.Slider(self, size=(cw,h), style=wx.SL_HORIZONTAL)
-            self.ctrl.Bind(wx.EVT_SCROLL, self.OnScroll) # called while dragging
-            self.ctrl.Bind(wx.EVT_SCROLL_CHANGED, lambda v: None) # pass no action
-            self.ctrl.Bind(wx.EVT_KEY_DOWN, self.OnCtrlKeyDown)
-            self.ctrl.Bind(wx.EVT_MOUSEWHEEL, self.OnMouseWheel)
+            self._ctrl = wx.Slider(self, size=(cw,h), style=wx.SL_HORIZONTAL)
+            self._ctrl.Bind(wx.EVT_SCROLL, self.OnScroll)  # called while dragging
+            self._ctrl.Bind(wx.EVT_SCROLL_CHANGED, lambda v: None)  # pass no action
+            self._ctrl.Bind(wx.EVT_KEY_DOWN, self.OnCtrlKeyDown)
+            self._ctrl.Bind(wx.EVT_MOUSEWHEEL, self.OnMouseWheel)
             
-        elif type == 'spin' or type =='hspin':
-            self.ctrl = wx.SpinButton(self, size=(cw,h), style=wx.SP_HORIZONTAL)
-            self.ctrl.Bind(wx.EVT_SPIN, self.OnScroll)
-            self.ctrl.Bind(wx.EVT_MOUSEWHEEL, self.OnMouseWheel)
+        elif type == 'spin' or type == 'hspin':
+            self._ctrl = wx.SpinButton(self, size=(cw,h), style=wx.SP_HORIZONTAL)
+            self._ctrl.Bind(wx.EVT_SPIN, self.OnScroll)
+            self._ctrl.Bind(wx.EVT_MOUSEWHEEL, self.OnMouseWheel)
             
         elif type == 'vspin':
-            self.ctrl = wx.SpinButton(self, size=(cw,h), style=wx.SP_VERTICAL)
-            self.ctrl.Bind(wx.EVT_SPIN, self.OnScroll)
-            self.ctrl.Bind(wx.EVT_MOUSEWHEEL, self.OnMouseWheel)
+            self._ctrl = wx.SpinButton(self, size=(cw,h), style=wx.SP_VERTICAL)
+            self._ctrl.Bind(wx.EVT_SPIN, self.OnScroll)
+            self._ctrl.Bind(wx.EVT_MOUSEWHEEL, self.OnMouseWheel)
             
         elif type == 'choice':
-            self.ctrl = wx.Choice(self, size=(cw,h))
-            self.ctrl.Bind(wx.EVT_CHOICE, self.OnScroll)
-            self.ctrl.SetValue = self.ctrl.SetSelection # setter of choice
-            self.ctrl.GetValue = self.ctrl.GetSelection # getter (ditto)
+            self._ctrl = wx.Choice(self, size=(cw,h))
+            self._ctrl.Bind(wx.EVT_CHOICE, self.OnScroll)
+            self._ctrl.SetValue = self._ctrl.SetSelection  # setter of choice
+            self._ctrl.GetValue = self._ctrl.GetSelection  # getter (ditto)
             
         else:
-            raise Exception("unknown type: {!r}".format(type))
+            raise Exception(f"unknown type: {type!r}")
         
-        self.ctrl.Bind(wx.EVT_MIDDLE_DOWN, lambda v: self.__par.reset())
-        self.ctrl.Enable(cw) # skip focus
+        self._ctrl.Bind(wx.EVT_MIDDLE_DOWN, lambda v: self.__par.reset())
+        self._ctrl.Enable(cw)  # skip focus
         
         c = (cw and type != 'vspin')
         self.SetSizer(
             pack(self, (
-                (self.label, 0, wx.ALIGN_CENTER | wx.LEFT | wx.RIGHT, lw and 1),
-                (self.text,  0, wx.ALIGN_CENTER | wx.LEFT | wx.RIGHT, tw and 1),
-                (self.ctrl,  c, wx.ALIGN_CENTER | wx.LEFT | wx.RIGHT, cw and 1),
+                (self._label, 0, wx.ALIGN_CENTER | wx.LEFT | wx.RIGHT, lw and 1),
+                (self._text,  0, wx.ALIGN_CENTER | wx.LEFT | wx.RIGHT, tw and 1),
+                (self._ctrl,  c, wx.ALIGN_CENTER | wx.LEFT | wx.RIGHT, cw and 1),
             ))
         )
         self.update_range()
-        self.update_ctrl()
+        self.update_control()
         
         self.Bind(wx.EVT_WINDOW_DESTROY, self.OnDestroy)
-    
+
     def OnDestroy(self, evt):
-        self.__par.knobs.remove(self) # パラメータの関連付けを解除する
+        self.__par.knobs.remove(self)  # パラメータの関連付けを解除する
         evt.Skip()
-    
+
     def update_range(self):
         """Called when range is being changed (internal use only)."""
         v = self.__par
-        if isinstance(self.ctrl, wx.Choice): #<wx.Choice>
+        if isinstance(self._ctrl, wx.Choice):  #<wx.Choice>
             items = [v.__str__(x) for x in v.range]
-            if items != self.ctrl.Items:
-                self.ctrl.SetItems(items)
-                self.ctrl.SetStringSelection(str(v))
+            if items != self._ctrl.Items:
+                self._ctrl.SetItems(items)
+                self._ctrl.SetStringSelection(str(v))
         else:
-            self.ctrl.SetRange(0, len(v)-1) #<wx.Slider> <wx.SpinButton>
-    
+            self._ctrl.SetRange(0, len(v)-1)  #<wx.Slider> #<wx.SpinButton>
+
     def update_label(self):
         """Called when label is being changed (internal use only)."""
         v = self.__par
-        if isinstance(self.label, wx.CheckBox):
-            self.label.SetValue(v.check)
+        if isinstance(self._label, wx.CheckBox):
+            self._label.SetValue(v.check)
         
         t = '  ' if np.isnan(v.std_value) or v.value == v.std_value else '*'
-        self.label.SetLabel(v.name + t)
-        self.label.Refresh()
-    
-    def update_ctrl(self, valid=True, notify=False):
+        self._label.SetLabel(v.name + t)
+        self._label.Refresh()
+        self.Refresh()
+
+    def update_control(self, valid=True, notify=False):
         """Called when value is being changed (internal use only)."""
         v = self.__par
-        self.ctrl.SetValue(v.index)
-        wx.CallAfter(self.text.SetValue, str(v)) # for wxAssertionError
+        self._ctrl.SetValue(v.index)
+        wx.CallAfter(self._text.SetValue, str(v))  # for wxAssertionError
         if valid:
             if notify:
-                if self.text.BackgroundColour != '#ffff80':
+                if self._text.BackgroundColour != '#ffff80':
                     wx.CallAfter(wx.CallLater, 1000,
                                  self.set_textcolour, '#ffffff')
-                    self.set_textcolour('#ffff80') # light-yellow
+                    self.set_textcolour('#ffff80')  # light-yellow
                 else:
-                    self.set_textcolour('#ffffff') # True: white
+                    self.set_textcolour('#ffffff')  # True: white
             else:
-                self.set_textcolour('#ffffff') # True: white
+                self.set_textcolour('#ffffff')  # True: white
         elif valid is None:
-            self.set_textcolour('#ffff80') # None: light-yellow
+            self.set_textcolour('#ffff80')  # None: light-yellow
         else:
-            self.set_textcolour('#ff8080') # False: light-red
+            self.set_textcolour('#ff8080')  # False: light-red
         self.update_label()
-    
+
     def set_textcolour(self, c):
         if self:
-            self.text.BackgroundColour = c
-            self.text.Refresh()
-    
-    def shift(self, evt, bit):
+            self._text.BackgroundColour = c
+            self._text.Refresh()
+
+    def _shift_control(self, evt, bit):
+        ## Called when a key/mouse wheel is pressed/scrolled (internal use only).
+        ## In addition to direct key input to the textctrl,
+        ## [up][down][wheelup][wheeldown] keys can be used,
+        ## with modifiers S- 2x, C- 16x, and M- 256x steps.
         if bit:
             if evt.ShiftDown():   bit *= 2
             if evt.ControlDown(): bit *= 16
             if evt.AltDown():     bit *= 256
         v = self.__par
-        j = self.ctrl.GetValue() + bit
+        j = self._ctrl.GetValue() + bit
         if j != v.index:
             v.index = j
-    
-    def OnScroll(self, evt): #<wx._core.ScrollEvent><wx._controls.SpinEvent><wx._core.CommandEvent>
+            v.reset(v.value)
+
+    def OnScroll(self, evt):  #<wx._core.ScrollEvent> #<wx._controls.SpinEvent> #<wx._core.CommandEvent>
         v = self.__par
-        j = self.ctrl.GetValue()
+        j = self._ctrl.GetValue()
         if j != v.index:
             v.index = j
+            v.reset(v.value)
         evt.Skip()
-    
-    def OnMouseWheel(self, evt): #<wx._core.MouseEvent>
-        self.shift(evt, 1 if evt.WheelRotation>0 else -1)
+
+    def OnMouseWheel(self, evt):  #<wx._core.MouseEvent>
+        self._shift_control(evt, (1 if evt.WheelRotation > 0 else -1))
         evt.Skip(False)
-    
-    def OnCtrlKeyDown(self, evt): #<wx._core.KeyEvent>
+
+    def OnCtrlKeyDown(self, evt):  #<wx._core.KeyEvent>
         key = evt.GetKeyCode()
-        if key == wx.WXK_LEFT: return self.shift(evt, -1)
-        if key == wx.WXK_RIGHT: return self.shift(evt, 1)
+        if key == wx.WXK_LEFT: return self._shift_control(evt, -1)
+        if key == wx.WXK_RIGHT: return self._shift_control(evt, 1)
         
         def _focus(c):
-            if isinstance(c, Knob) and c.ctrl.IsEnabled():
-                c.ctrl.SetFocus()
+            if isinstance(c, Knob) and c._ctrl.IsEnabled():
+                c._ctrl.SetFocus()
                 return True
         
         ls = next(x for x in self.Parent.layout_groups if self in x)
         i = ls.index(self)
         if key == wx.WXK_DOWN: return any(_focus(c) for c in ls[i+1:])
         if key == wx.WXK_UP: return any(_focus(c) for c in ls[i-1::-1])
-    
-    def OnTextKeyUp(self, evt): #<wx._core.KeyEvent>
+
+    def OnTextKeyUp(self, evt):  #<wx._core.KeyEvent>
         evt.Skip()
-    
-    def OnTextKeyDown(self, evt): #<wx._core.KeyEvent>
+
+    def OnTextKeyDown(self, evt):  #<wx._core.KeyEvent>
         key = evt.GetKeyCode()
-        if key == wx.WXK_DOWN: return self.shift(evt, -1)
-        if key == wx.WXK_UP: return self.shift(evt, 1)
+        if key == wx.WXK_DOWN: return self._shift_control(evt, -1)
+        if key == wx.WXK_UP: return self._shift_control(evt, 1)
         if key == wx.WXK_ESCAPE:
-            self.__par.reset(self.__par.value, internal_callback=None) # restore value
+            self.__par.reset(self.__par.value, internal_callback=None)  # restore value
         evt.Skip()
-    
-    def OnTextEnter(self, evt): #<wx._core.CommandEvent>
+
+    def OnTextEnter(self, evt):  #<wx._core.CommandEvent>
         evt.Skip()
-        x = self.text.Value.strip()
+        x = self._text.Value.strip()
         self.__par.reset(x)
-    
-    def OnTextExit(self, evt): #<wx._core.FocusEvent>
-        x = self.text.Value.strip()
+
+    def OnTextExit(self, evt):  #<wx._core.FocusEvent>
+        x = self._text.Value.strip()
         if x != str(self.__par):
             self.__par.reset(x)
         evt.Skip()
-    
-    def OnCheck(self, evt): #<wx._core.CommandEvent>
+
+    def OnCheck(self, evt):  #<wx._core.CommandEvent>
         self.__par.check = evt.IsChecked()
         evt.Skip()
-    
-    def OnPress(self, evt): #<wx._core.CommandEvent>
-        self.__par.callback('update', self.__par)
+
+    def OnPress(self, evt):  #<wx._core.CommandEvent>
+        self.__par.callback('updated', self.__par)
         evt.Skip()
-    
+
     def Enable(self, p=True):
-        self.label.Enable(p)
-        self.ctrl.Enable(p)
-        self.text.Enable(p)
+        self._label.Enable(p)
+        self._ctrl.Enable(p)
+        self._text.Enable(p)
 
 
 class KnobCtrlPanel(scrolled.ScrolledPanel):
-    """Scrollable Control Panel
+    """Scrollable Control Panel.
     """
     def __init__(self, *args, **kwargs):
         scrolled.ScrolledPanel.__init__(self, *args, **kwargs)
@@ -574,86 +590,83 @@ class KnobCtrlPanel(scrolled.ScrolledPanel):
         self.Bind(wx.EVT_SCROLLWIN_THUMBRELEASE, self.OnRecalcLayout)
         self.Bind(wx.EVT_MOUSEWHEEL, self.OnRecalcLayout)
         self.Bind(wx.EVT_LEFT_DOWN, self.OnRecalcLayout)
-    
-    def OnRecalcLayout(self, evt): #<wx._core.ScrollWinEvent>
+
+    def OnRecalcLayout(self, evt):  #<wx._core.ScrollWinEvent>
         self.Layout()
         evt.Skip()
-    
-    def OnToggleFold(self, evt): #<wx._core.MouseEvent>
+
+    def OnToggleFold(self, evt):  #<wx._core.MouseEvent>
         x, y = evt.Position
-        for child in self.Sizer.Children: # child <wx._core.SizerItem>
+        for child in self.Sizer.Children:  # child <wx._core.SizerItem>
             if child.IsShown():
-                obj = child.Sizer or child.Window
-                if isinstance(obj, (wx.StaticBoxSizer, wx.StaticBox)):
+                obj = child.Sizer
+                if isinstance(obj, wx.StaticBoxSizer):
                     cx, cy = obj.Position
                     if cx < x < cx + obj.Size[0] and cy < y < cy+22:
-                        for cc in obj.Children: # child of child <wx._core.SizerItem>
+                        for cc in obj.Children:  # child of child <wx._core.SizerItem>
                             cc.Show(not cc.IsShown())
                         self.Layout()
                         self.SendSizeEvent()
                         break
         evt.Skip()
-    
+
     ## --------------------------------
-    ## Layout commands and attributes
+    ## Layout commands and attributes.
     ## --------------------------------
     @property
     def layout_groups(self):
         return self.__groups
-    
+
     def is_enabled(self, groupid, pred=all):
         return pred(win.Enabled for win in self.__groups[groupid])
-    
+
     def enable(self, groupid, p=True):
-        for win in self.__groups[groupid]: # child could be deep nesting
+        for win in self.__groups[groupid]:  # child could be deep nesting
             win.Enable(p)
-    
+
     def is_shown(self, groupid):
-        ## child = self.Sizer.Children[groupid]
-        ## return child.IsShown()
+        # child = self.Sizer.Children[groupid]
+        # return child.IsShown()
         return self.Sizer.IsShown(groupid % len(self.__groups))
-    
+
     def show(self, groupid, p=True):
         """Show/hide all including the box."""
-        ## child = self.Sizer.Children[groupid]
-        ## child.Show(p)
+        # child = self.Sizer.Children[groupid]
+        # child.Show(p)
         self.Sizer.Show(groupid % len(self.__groups), p)
-        ## self.Sizer.Fit(self) # do Fit(self.Parent) if needed
         self.Layout()
-        self.Parent.SendSizeEvent() # let parent redraw the child panel
-    
+
     def is_folded(self, groupid):
         child = self.Sizer.Children[groupid]
         return not any(cc.IsShown() for cc in child.Sizer.Children)
-    
+
     def fold(self, groupid, p=True):
         """Fold/unfold the boxed group."""
         child = self.Sizer.Children[groupid]
         if isinstance(child.Sizer, wx.StaticBoxSizer) and child.IsShown():
-            for cc in child.Sizer.Children: # child of child <wx._core.SizerItem>
+            for cc in child.Sizer.Children:  # child of child <wx._core.SizerItem>
                 cc.Show(not p)
-            ## self.Sizer.Fit(self) # do Fit(self.Parent) if needed
             self.Layout()
-            self.Parent.SendSizeEvent() # let parent redraw the child panel
-    
+
     def layout(self, items, title=None,
                row=0, expand=0, border=2, hspacing=1, vspacing=1,
                show=True, visible=True, align=wx.ALIGN_LEFT, **kwargs):
         """Do layout (cf. Layout).
         
         Args:
-            items   : list of Params, wx.Objects, tuple of sizing, or None
-            title   : box header string (default is None - no box)
-            row     : number of row to arange widgets
-            expand  : (0) fixed size
-                      (1) to expand horizontally
-                      (2) to expand horizontally and vertically
-            border  : size of outline border
+            items:    list of Params, wx.Objects, tuple of sizing, or None
+            title:    box header string (default is None - no box)
+            row:      number of row to arange widgets
+            expand:   expansion flag
+                      - (0) fixed size
+                      - (1) to expand horizontally
+                      - (2) to expand horizontally and vertically
+            border:   size of outline border
             hspacing: horizontal spacing among packed objs inside the group
             vspacing: vertical spacing among packed objs inside the group
-            show    : fold or unfold the boxed group
-            visible : Hide the boxed group if False
-            align   : alignment flag (wx.ALIGN_*) default is ALIGN_LEFT
+            show:     Fold or unfold the boxed group.
+            visible:  Hide the boxed group if False.
+            align:    alignment flag (wx.ALIGN_*) default is ALIGN_LEFT
             **kwargs: extra keyword arguments given for Knob
         """
         objs = [Knob(self, c, **kwargs) if isinstance(c, Param)
@@ -673,70 +686,74 @@ class KnobCtrlPanel(scrolled.ScrolledPanel):
         
         self.Sizer.Add(sizer, expand>1, p | wx.ALL, border)
         
-        ## Register object and parameter groups
-        def _flatiter(a):
-            for c in a:
+        ## Register objects and parameter groups.
+        def _flatiter(objects):
+            for c in objects:
                 if isinstance(c, tuple):
                     yield from _flatiter(c)
                 elif isinstance(c, wx.Object):
                     yield c
         self.__groups.append(list(_flatiter(objs)))
         
-        def _variter(a):
-            for c in a:
+        ## Parameters : Knob.param or widgets that have a `value`.
+        def _variter(objects):
+            for c in objects:
                 if isinstance(c, Knob):
                     yield c.param
                 elif hasattr(c, 'value'):
                     yield c
         self.__params.append(list(_variter(objs)))
         
-        ## Set appearance of the layout group
+        ## Set appearance of the layout group.
         self.show(-1, visible)
         self.fold(-1, not show)
         self.Sizer.Fit(self)
-    
+        
+        return self.__groups[-1]
+
     ## --------------------------------
-    ## 外部入出力／クリップボード通信
+    ## 外部入出力／クリップボード通信．
     ## --------------------------------
     @property
     def parameters(self):
         return [p.value for p in self.get_params()]
-    
+
     @parameters.setter
     def parameters(self, v):
         self.set_params(v)
-    
+
     def get_params(self, checked_only=False):
         params = chain(*self.__params)
         if not checked_only:
             return params
         return filter(lambda c: getattr(c, 'check', None), params)
-    
-    def set_params(self, argv=None, checked_only=False):
+
+    def set_params(self, argv, checked_only=False):
         params = self.get_params(checked_only)
-        if argv is None:
-            for p in params:
-                try:
-                    p.reset()
-                except (AttributeError, TypeError):
-                    pass
-        else:
-            for p, v in zip(params, argv):
-                try:
-                    p.reset(v) # eval v:str -> value
-                except AttributeError:
-                    p.value = v
-                except Exception as e: # failed to eval
-                    print(f"- Failed to reset {p!r}.", e)
-    
-    reset_params = set_params
-    
+        for p, v in zip(params, argv):
+            try:
+                p.reset(v)  # eval v:str -> value
+            except AttributeError:
+                p.value = v
+            except Exception as e:
+                print(f"- Failed to eval {v}:", e)
+
+    def reset_params(self, checked_only=False):
+        params = self.get_params(checked_only)
+        for p in params:
+            try:
+                p.reset()
+            except (AttributeError, TypeError):
+                ## TypeError might occur if p.reset(v) is called with
+                ## missing 1 required positional argument.
+                pass
+
     def copy_to_clipboard(self, checked_only=False):
         params = self.get_params(checked_only)
         text = '\t'.join(str(p) if isinstance(p, Param) else
                          str(p.value) for p in params)
         Clipboard.write(text)
-    
+
     def paste_from_clipboard(self, checked_only=False):
         text = Clipboard.read()
         if text:
@@ -744,7 +761,7 @@ class KnobCtrlPanel(scrolled.ScrolledPanel):
 
 
 class ControlPanel(CtrlInterface, KnobCtrlPanel):
-    """Gnuplot control panel.
+    """Control panel with mouse/key event interface.
     """
     def __init__(self, *args, **kwargs):
         KnobCtrlPanel.__init__(self, *args, **kwargs)
@@ -752,11 +769,24 @@ class ControlPanel(CtrlInterface, KnobCtrlPanel):
 
 
 class Clipboard:
-    """Clipboard interface of text and image
+    """Clipboard interface of text and image.
     
     This does not work unless wx.App instance exists.
     The clipboard data cannot be transferred unless wx.Frame exists.
     """
+    @contextmanager
+    @staticmethod
+    def istrstream():
+        with io.StringIO(Clipboard.read()) as f:
+            yield f
+
+    @contextmanager
+    @staticmethod
+    def ostrstream():
+        with io.StringIO() as f:
+            yield f
+            Clipboard.write(f.getvalue())
+
     @staticmethod
     def read(verbose=False):
         do = wx.TextDataObject()
@@ -769,7 +799,8 @@ class Clipboard:
             return text
         else:
             print("- Unable to open clipboard.")
-    
+            return None
+
     @staticmethod
     def write(text, verbose=False):
         do = wx.TextDataObject(str(text))
@@ -781,7 +812,7 @@ class Clipboard:
                 print(f"To clipboard:\n{text}")
         else:
             print("- Unable to open clipboard.")
-    
+
     @staticmethod
     def imread(verbose=False):
         do = wx.BitmapDataObject()
@@ -791,30 +822,31 @@ class Clipboard:
             bmp = do.GetBitmap()
         else:
             print("- Unable to open clipboard.")
-            return
+            return None
         try:
-            ## Convert bmp --> buf
+            ## Convert bmp --> buf.
             img = bmp.ConvertToImage()
-            buf = np.array(img.GetDataBuffer()) # do copy, don't ref
+            buf = np.array(img.GetDataBuffer())  # Do copy, don't ref.
             if verbose:
                 print("From clipboard: {:.1f} Mb data read.".format(buf.nbytes/1e6))
             w, h = img.GetSize()
             return buf.reshape(h, w, 3)
         except Exception:
-            print("- The contents of the clipboard are not images.")
-    
+            print("- Contents of the clipboard are not images.")
+            return None
+
     @staticmethod
     def imwrite(buf, verbose=False):
         try:
-            ## Convert buf --> bmp
+            ## Convert buf --> bmp.
             h, w = buf.shape[:2]
             if buf.ndim < 3:
-                ## buf = np.array([buf] * 3).transpose((1,2,0)) # convert to gray bitmap
-                buf = buf.repeat(3, axis=1) # convert to gray bitmap
+                # buf = np.array([buf] * 3).transpose((1,2,0))  # convert to gray bitmap
+                buf = buf.repeat(3, axis=1)  # Convert to gray bitmap.
             img = wx.Image(w, h, buf.tobytes())
             bmp = img.ConvertToBitmap()
         except Exception:
-            print("- The contents of the clipboard are not images.")
+            print("- Argument 'buf' is not a 2d array.")
             return
         do = wx.BitmapDataObject(bmp)
         if wx.TheClipboard.Open():
@@ -828,10 +860,19 @@ class Clipboard:
 
 
 ## --------------------------------
-## Wx custom controls and bitmaps 
+## Wx custom controls and bitmaps.
 ## --------------------------------
-if 1:
-    _provided_arts = {
+
+class Icon(wx.Bitmap):
+    """Return an iconic bitmap with the specified size (w, h).
+    
+    The key is either Icon.provided_arts or Icon.custom_images key.
+    If the key is empty it returns a transparent bitmap, otherwise NullBitmap.
+    
+    Note:
+        A null (0-shaped) bitmap fails with AssertionError from wx ver 4.1.1.
+    """
+    provided_arts = {
             'cut' : wx.ART_CUT,
            'copy' : wx.ART_COPY,
           'paste' : wx.ART_PASTE,
@@ -853,8 +894,8 @@ if 1:
             '!!!' : wx.ART_ERROR,
               '+' : wx.ART_PLUS,
               '-' : wx.ART_MINUS,
-              'x' : wx.ART_DELETE,
-              't' : wx.ART_TICK_MARK,
+              # 'x' : wx.ART_DELETE,
+              # 't' : wx.ART_TICK_MARK,
               '~' : wx.ART_GO_HOME,
            'undo' : wx.ART_UNDO,
            'redo' : wx.ART_REDO,
@@ -865,32 +906,80 @@ if 1:
             '|<-' : wx.ART_GOTO_FIRST,
             '->|' : wx.ART_GOTO_LAST,
     }
-    _custom_images = {
-        k:v for k, v in vars(images).items()
-            if isinstance(v, wx.lib.embeddedimage.PyEmbeddedImage)
+    custom_images = {
+        k: v for k, v in vars(images).items()
+             if isinstance(v, wx.lib.embeddedimage.PyEmbeddedImage)
     }
 
-class Icon(wx.Bitmap):
-    """Returns an iconic bitmap with the specified size (w, h).
-    
-    The key is either Icon.provided_arts or Icon.custom_images key.
-    If the key is empty it returns a transparent bitmap, otherwise NullBitmap.
-    
-    Note:
-        A null (0-shaped) bitmap fails with AssertionError from 4.1.1
-    """
-    provided_arts = _provided_arts
-    custom_images = _custom_images
-    
     def __init__(self, *args, **kwargs):
         try:
-            bmp = _getBitmap1(*args, **kwargs)
+            bmp = Icon._getBitmap1(*args, **kwargs)
         except TypeError:
-            bmp = _getBitmap2(*args, **kwargs)
+            bmp = Icon._getBitmap2(*args, **kwargs)
         wx.Bitmap.__init__(self, bmp)
 
     @staticmethod
-    def bullet(colour, ec=None, size=(16,16), radius=4):
+    def _getBitmap1(key, size=None):
+        if not isinstance(size, (type(None), tuple, wx.Size)):
+            raise TypeError("invalid size type")
+        
+        if isinstance(key, wx.Bitmap):
+            if size and key.Size != size:
+                key = (key.ConvertToImage()
+                          .Scale(*size, wx.IMAGE_QUALITY_NEAREST)
+                          .ConvertToBitmap())
+            return key  #<wx.Bitmap>
+        if size is None:
+            size = (16, 16)
+        if key:
+            ## Returns a bitmap of provided artwork.
+            ## Note: The result could be a zero-shaped bitmap.
+            try:
+                if re.match("bullet(.*)", key):
+                    return eval(f"Icon.{key}")  # -> Icon.bullet(*v, **kw)
+            except TypeError:
+                pass
+            try:
+                art = Icon.custom_images.get(key)
+                bmp = art.GetBitmap()
+            except Exception:
+                art = Icon.provided_arts.get(key)
+                bmp = wx.ArtProvider.GetBitmap(art or key, wx.ART_OTHER, size)
+            return bmp
+        if key == '':
+            ## Returns dummy-sized blank bitmap.
+            ## Note: A zero-shaped bitmap fails with AssertionError since wx ver 4.1.1.
+            bmp = wx.Bitmap(size)
+            with wx.MemoryDC(bmp) as dc:
+                dc.SetBackground(wx.Brush('black'))
+                dc.Clear()
+            bmp.SetMaskColour('black')
+            return bmp
+        return wx.NullBitmap  # The standard wx controls accept this.
+
+    @staticmethod
+    def _getBitmap2(back, fore, size=None, subsize=3/4):
+        if not size:
+            size = (16, 16)
+        if isinstance(subsize, float):
+            subsize = wx.Size(size) * subsize
+        back = Icon._getBitmap1(back, size)
+        fore = Icon._getBitmap1(fore, subsize)
+        if back.Size == (0, 0) or fore.Size == (0, 0):
+            return back
+        x = size[0] - subsize[0]
+        y = size[1] - subsize[1]
+        with wx.MemoryDC(back) as dc:
+            # dc = wx.GCDC(dc)
+            # dc.DrawBitmap(fore, x, y, useMask=True)
+            gc = wx.GraphicsContext.Create(dc)
+            gc.DrawBitmap(fore, x, y, *subsize)
+        return back
+
+    @staticmethod
+    def bullet(colour, radius=4, size=None, ec=None):
+        if not size:
+            size = (16, 16)
         bmp = wx.Bitmap(size)
         with wx.MemoryDC(bmp) as dc:
             dc.SetBackground(wx.Brush('black'))
@@ -903,7 +992,7 @@ class Icon(wx.Bitmap):
 
     @staticmethod
     def iconify(icon, w, h):
-        ## if wx.VERSION >= (4,1,0):
+        ## if wx.VERSION >= (4,1,0): ...
         try:
             import wx.svg
             import requests
@@ -917,175 +1006,114 @@ class Icon(wx.Bitmap):
         return bmp
 
 
-def _getBitmap1(key, size=(16,16)):
-    if isinstance(key, wx.Bitmap):
-        if key.Size != size:
-            key = (key.ConvertToImage()
-                      .Scale(*size, wx.IMAGE_QUALITY_NEAREST)
-                      .ConvertToBitmap())
-        return key
-    if key:
-        try:
-            art = _custom_images.get(key)
-            bmp = art.GetBitmap()
-        except Exception:
-            art = _provided_arts.get(key)
-            bmp = wx.ArtProvider.GetBitmap(art or key, wx.ART_OTHER, size)
-        return bmp
+class ClassicButton(wx.Button):
+    """Classic button.
     
-    ## Note: null (0-shaped) bitmap fails with AssertionError from 4.1.1
-    elif key == '':
-        bmp = wx.Bitmap(size)
-        with wx.MemoryDC(bmp) as dc:
-            dc.SetBackground(wx.Brush('black'))
-            dc.Clear()
-        bmp.SetMaskColour('black') # return dummy-sized blank bitmap
-        return bmp
-    
-    return wx.NullBitmap # The standard wx controls accept this,
-
-
-def _getBitmap2(back, fore, size=(16,16), subsize=3/4):
-    if isinstance(subsize, float):
-        subsize = wx.Size(size) * subsize
-    back = _getBitmap1(back, size)
-    fore = _getBitmap1(fore, subsize)
-    x = size[0] - subsize[0]
-    y = size[1] - subsize[1]
-    with wx.MemoryDC(back) as dc:
-        ## dc = wx.GCDC(dc)
-        ## dc.DrawBitmap(fore, x, y, useMask=True)
-        gc = wx.GraphicsContext.Create(dc)
-        gc.DrawBitmap(fore, x, y, *subsize)
-    return back
-
-
-def _Icon(v):
-    if isinstance(v, (str, bytes)):
-        return Icon(v)
-    if isinstance(v, wx.lib.embeddedimage.PyEmbeddedImage):
-        return v.GetBitmap()
-    return v
+    Args:
+        label:    button label
+        handler:  event handler when the button is pressed
+        icon:     key:str or bitmap for button icon
+        **kwargs: keywords for wx.lib.platebtn.PlateButton
+    """
+    def __init__(self, parent, label='', handler=None, icon=None, **kwargs):
+        wx.Button.__init__(self, parent, -1, label, **kwargs)
+        
+        if handler:
+            self.Bind(wx.EVT_BUTTON, _F(handler))
+            self.SetToolTip(_Tip(handler.__doc__))
+        if icon:
+            self.SetBitmap(Icon(icon))
 
 
 class Button(pb.PlateButton):
-    """Flat button
+    """Flat button.
     
     Args:
-        label   : button label
-        handler : event handler when the button is pressed
-        icon    : key:str or bitmap for button icon
+        label:    button label
+        handler:  event handler when the button is pressed
+        icon:     key:str or bitmap for button icon
         **kwargs: keywords for wx.lib.platebtn.PlateButton
     """
-    @property
-    def icon(self):
-        """Icon key:str or bitmap."""
-        return self.__icon
-    
-    @icon.setter
-    def icon(self, v):
-        self.__icon = v
-        self.SetBitmap(_Icon(v))
-        self.Refresh()
-    
     def __init__(self, parent, label='', handler=None, icon=None, **kwargs):
         kwargs.setdefault('style', pb.PB_STYLE_DEFAULT | pb.PB_STYLE_SQUARE)
         pb.PlateButton.__init__(self, parent, -1, label, **kwargs)
         
         if handler:
             self.Bind(wx.EVT_BUTTON, _F(handler))
-        
-        self.ToolTip = _Tip(handler.__doc__)
-        self.icon = icon
-    
+            self.SetToolTip(_Tip(handler.__doc__))
+        if icon:
+            self.SetBitmap(Icon(icon))
+
     def SetBitmap(self, bmp):
         """Set the bitmap displayed in the button.
+        
         (override) If it fails, it clears the bitmap.
         """
         try:
             pb.PlateButton.SetBitmap(self, bmp)
         except Exception:
-            self._bmp = dict(enable=None, disable=None)
+            self._bmp['enable'] = None
+            self._bmp['disable'] = None
 
 
 class ToggleButton(wx.ToggleButton):
-    """Togglable button
+    """Togglable button.
     
     Args:
-        label   : button label
-        handler : event handler when the button is pressed
-        icon    : key:str or bitmap for button icon
+        label:    button label
+        handler:  event handler when the button is pressed
+        icon:     key:str or bitmap for button icon
         **kwargs: keywords for wx.ToggleButton
     
     Note:
         To get the status, check Value or event.GetInt or event.IsChecked.
     """
-    @property
-    def icon(self):
-        """Icon key:str or bitmap."""
-        return self.__icon
-    
-    @icon.setter
-    def icon(self, v):
-        self.__icon = v
-        if isinstance(v, tuple):
-            self.SetBitmap(_Icon(v[0]))
-            self.SetBitmapPressed(_Icon(v[1]))
-        elif v:
-            self.SetBitmap(_Icon(v))
-        self.Refresh()
-    
     def __init__(self, parent, label='', handler=None, icon=None, **kwargs):
         wx.ToggleButton.__init__(self, parent, -1, label, **kwargs)
         
         if handler:
             self.Bind(wx.EVT_TOGGLEBUTTON, _F(handler))
-        
-        self.ToolTip = _Tip(handler.__doc__)
-        self.icon = icon
+            self.SetToolTip(_Tip(handler.__doc__))
+        if icon:
+            try:
+                self.SetBitmap(Icon(icon[0]))
+                self.SetBitmapPressed(Icon(icon[1]))
+            except Exception:
+                self.SetBitmap(Icon(icon))
 
 
-class TextCtrl(wx.Control):
-    """Text panel
+class TextBox(wx.Control):
+    """Text control.
     
     Args:
-        label   : button label
-        handler : event handler when text is entered
-        updater : event handler when the button is pressed
-        icon    : key:str or bitmap for button icon
+        label:    button label
+        handler:  event handler when text is entered
+        updater:  event handler when the button is pressed
+        icon:     key:str or bitmap for button icon
         readonly: flag:bool (equiv. style=wx.TE_READONLY)
         **kwargs: keywords for wx.TextCtrl
                   e.g., value:str
     """
-    Value = property(
+    Value = property( # textctrl value:str
         lambda self: self._ctrl.GetValue(),
-        lambda self,v: self._ctrl.SetValue(v),
-        doc="textctrl value:str")
-    
-    value = Value #: internal use only
-    
-    @property
-    def icon(self):
-        """Icon key:str or bitmap."""
-        return self._btn.icon
-    
-    @icon.setter
-    def icon(self, v):
-        self._btn.icon = v
-    
+        lambda self, v: self._ctrl.SetValue(v))
+
+    value = Value  # internal use only
+
+    button = property(lambda self: self._btn)
+    control = property(lambda self: self._ctrl)
+
     def __init__(self, parent, label='', handler=None, updater=None,
                  icon=None, readonly=False, size=(-1,-1), **kwargs):
         wx.Control.__init__(self, parent, size=size, style=wx.BORDER_NONE)
         
         kwargs['style'] = (kwargs.get('style', 0)
-                            | wx.TE_PROCESS_ENTER
-                            | (wx.TE_READONLY if readonly else 0))
+                                    | wx.TE_PROCESS_ENTER
+                                    | (wx.TE_READONLY if readonly else 0))
         
         self._ctrl = wx.TextCtrl(self, **kwargs)
         self._btn = Button(self, label, None, icon,
                            size=(-1,-1) if label or icon else (0,0))
-        self._ctrl.ToolTip = _Tip(handler.__doc__)
-        self._btn.ToolTip = _Tip(updater.__doc__)
         
         self.SetSizer(
             pack(self, (
@@ -1096,10 +1124,14 @@ class TextCtrl(wx.Control):
         if handler:
             self._handler = _F(handler)
             self._ctrl.Bind(wx.EVT_TEXT_ENTER, lambda v: self._handler(self))
+            self._ctrl.SetToolTip(_Tip(handler.__doc__))
         if updater:
             self._updater = _F(updater)
             self._btn.Bind(wx.EVT_BUTTON, lambda v: self._updater(self))
-    
+            self._btn.SetToolTip(_Tip(updater.__doc__))
+        
+        self.Bind(wx.EVT_NAVIGATION_KEY, self.OnNavKey)
+
     def reset(self, v):
         try:
             self.Value = v
@@ -1107,15 +1139,21 @@ class TextCtrl(wx.Control):
         except AttributeError:
             pass
 
+    def OnNavKey(self, evt):
+        if evt.EventObject is self._ctrl:
+            self.Navigate(evt.Direction)
+        elif self.IsShown():
+            self._ctrl.SetFocus()
+
 
 class Choice(wx.Control):
-    """Editable Choice (ComboBox) panel
+    """Editable Choice (ComboBox) control.
     
     Args:
-        label   : button label
-        handler : event handler when text is entered or item is selected
-        updater : event handler when the button is pressed
-        icon    : key:str or bitmap for button icon
+        label:    button label
+        handler:  event handler when text is entered or item is selected
+        updater:  event handler when the button is pressed
+        icon:     key:str or bitmap for button icon
         readonly: flag:bool (equiv. style=wx.CB_READONLY)
         **kwargs: keywords for wx.ComboBox
                   e.g., choices:list
@@ -1124,45 +1162,34 @@ class Choice(wx.Control):
         If the input item is not found in the choices,
         it will be added to the list (unless readonly)
     """
-    Value = property(
+    Value = property( # combobox value:str
         lambda self: self._ctrl.GetValue(),
-        lambda self,v: self._ctrl.SetValue(v),
-        doc="combobox value:str")
-    
-    value = Value #: internal use only
-    
-    Selection = property(
+        lambda self, v: self._ctrl.SetValue(v))
+
+    value = Value  # internal use only
+
+    Selection = property( # combobox selection:int or NOT_FOUND(-1)
         lambda self: self._ctrl.GetSelection(),
-        lambda self,v: self._ctrl.SetSelection(v), # int or NOT_FOUND(-1)
-        doc="combobox selection:int")
-    
-    Items = property(
+        lambda self, v: self._ctrl.SetSelection(v))
+
+    Items = property( # combobox items:list
         lambda self: self._ctrl.GetItems(),
-        lambda self,v: self._ctrl.SetItems(v),
-        doc="combobox items:list")
-    
-    @property
-    def icon(self):
-        """Icon key:str or bitmap."""
-        return self._btn.icon
-    
-    @icon.setter
-    def icon(self, v):
-        self._btn.icon = v
-    
+        lambda self, v: self._ctrl.SetItems(v))
+
+    button = property(lambda self: self._btn)
+    control = property(lambda self: self._ctrl)
+
     def __init__(self, parent, label='', handler=None, updater=None,
                  icon=None, readonly=False, size=(-1,-1), **kwargs):
         wx.Control.__init__(self, parent, size=size, style=wx.BORDER_NONE)
         
         kwargs['style'] = (kwargs.get('style', 0)
-                            | wx.TE_PROCESS_ENTER
-                            | (wx.CB_READONLY if readonly else 0))
+                                    | wx.TE_PROCESS_ENTER
+                                    | (wx.CB_READONLY if readonly else 0))
         
         self._ctrl = wx.ComboBox(self, **kwargs)
         self._btn = Button(self, label, None, icon,
                            size=(-1,-1) if label or icon else (0,0))
-        self._ctrl.ToolTip = _Tip(handler.__doc__)
-        self._btn.ToolTip = _Tip(updater.__doc__)
         
         self.SetSizer(
             pack(self, (
@@ -1174,18 +1201,22 @@ class Choice(wx.Control):
             self._handler = _F(handler)
             self._ctrl.Bind(wx.EVT_TEXT_ENTER, lambda v: self._handler(self))
             self._ctrl.Bind(wx.EVT_COMBOBOX, lambda v: self._handler(self))
+            self._ctrl.SetToolTip(_Tip(handler.__doc__))
         self._ctrl.Bind(wx.EVT_TEXT_ENTER, self.OnTextEnter)
         if updater:
             self._updater = _F(updater)
             self._btn.Bind(wx.EVT_BUTTON, lambda v: self._updater(self))
-    
+            self._btn.SetToolTip(_Tip(updater.__doc__))
+        
+        self.Bind(wx.EVT_NAVIGATION_KEY, self.OnNavKey)
+
     def reset(self, v):
         try:
             self.Value = v
             self._handler(self)
         except AttributeError:
             pass
-    
+
     def OnTextEnter(self, evt):
         s = evt.String.strip()
         if not s:
@@ -1195,29 +1226,35 @@ class Choice(wx.Control):
             self._ctrl.SetStringSelection(s)
         evt.Skip()
 
+    def OnNavKey(self, evt):
+        if evt.EventObject is self._ctrl:
+            self.Navigate(evt.Direction)
+        elif self.IsShown():
+            self._ctrl.SetFocus()
+
 
 class Indicator(wx.Control):
-    """Traffic light indicator
+    """Traffic light indicator.
     
     Args:
-        colors  : list of colors (default is tricolour) cf. wx.ColourDatabase
-        value   : initial value
+        colors:   list of colors (default is tricolour) cf. wx.ColourDatabase
+        value:    initial value
         **kwargs: keywords for wx.Control
     """
     @property
     def Value(self):
         return self.__value
-    
+
     @Value.setter
     def Value(self, v):
         self.__value = int(v)
         self.Refresh()
-    
+
     def redesign(self, **kwargs):
         """Update multiple design properties at once.
         
         This method is useful for changing colors, spacing, radius, etc.
-        The best size will be automatically invalidated and re-calculated.
+        The best size will be automatically invalidated and recalculated.
         
         Args:
             **kwargs: class attributes, e.g. colors, spacing, radius.
@@ -1227,14 +1264,14 @@ class Indicator(wx.Control):
         """
         self.__dict__.update(kwargs)
         self.InvalidateBestSize()
-    
-    colors = ('green', 'yellow', 'red') # default tricolor style
+
+    colors = ('green', 'yellow', 'red')  # default tricolor style
     backgroundColour = 'dark gray'
     foregroundColour = 'light gray'
     spacing = 7
     radius = 4
     glow = 0
-    
+
     def __init__(self, parent, colors=None, value=0,
                  style=wx.BORDER_NONE, **kwargs):
         wx.Control.__init__(self, parent, style=style, **kwargs)
@@ -1248,19 +1285,19 @@ class Indicator(wx.Control):
         self.InvalidateBestSize()
         self.Fit()
         
-        self.SetBackgroundStyle(wx.BG_STYLE_PAINT) # to avoid flickering
+        self.SetBackgroundStyle(wx.BG_STYLE_PAINT)  # to avoid flickering
         
         self.Bind(wx.EVT_SIZE, self.OnSize)
         self.Bind(wx.EVT_PAINT, self.OnPaint)
-    
+
     def DoGetBestSize(self):
         N = len(self.colors)
         s = self.spacing
         return wx.Size((2*s-1)*N+3, 2*s+2)
-    
+
     def OnSize(self, evt):
         self.Refresh()
-    
+
     def OnPaint(self, evt):
         dc = wx.BufferedPaintDC(self)
         dc.Clear()
@@ -1296,7 +1333,7 @@ class Indicator(wx.Control):
                 gc.DrawPath(path)
             dc.SetBrush(wx.Brush(name if b else self.foregroundColour))
             dc.DrawCircle(x, y, r)
-    
+
     def blink(self, msec, mask=0):
         """Blinks once for given milliseconds.
         
@@ -1315,31 +1352,31 @@ class Indicator(wx.Control):
 
 
 class Gauge(wx.Control):
-    """Rainbow gauge
+    """Rainbow gauge.
     
     Args:
-        range   : maximum value
-        value   : initial value
+        range:    maximum value
+        value:    initial value
         **kwargs: keywords for wx.Control
     """
     @property
     def Value(self):
         return self.__value
-    
+
     @Value.setter
     def Value(self, v):
         self.__value = int(v)
         self.Refresh()
-    
+
     @property
     def Range(self):
         return self.__range
-    
+
     @Range.setter
     def Range(self, v):
         self.__range = int(v)
         self.Refresh()
-    
+
     def __init__(self, parent, range=24, value=0,
                  style=wx.BORDER_NONE, **kwargs):
         wx.Control.__init__(self, parent, style=style, **kwargs)
@@ -1347,14 +1384,14 @@ class Gauge(wx.Control):
         self.__range = range
         self.__value = value
         
-        self.SetBackgroundStyle(wx.BG_STYLE_PAINT) # to avoid flickering
+        self.SetBackgroundStyle(wx.BG_STYLE_PAINT)  # to avoid flickering
         
         self.Bind(wx.EVT_SIZE, self.OnSize)
         self.Bind(wx.EVT_PAINT, self.OnPaint)
-    
+
     def OnSize(self, evt):
         self.Refresh()
-    
+
     def OnPaint(self, evt):
         dc = wx.BufferedPaintDC(self)
         dc.Clear()