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

mwx/nutshell.py

@@ -1,9 +1,10 @@
 #! python3
 """mwxlib Nautilus in the shell.
 """
+from contextlib import contextmanager
 from functools import wraps
 from importlib import import_module
-from contextlib import contextmanager
+from pathlib import Path
 from pprint import pformat
 from bdb import BdbQuit
 import traceback
@@ -17,7 +18,8 @@ import sys
 import os
 import re
 import wx
-from wx import stc, aui
+from wx import aui
+from wx import stc
 from wx.py import dispatcher
 from wx.py import introspect
 from wx.py import interpreter
@@ -25,34 +27,116 @@ from wx.py.shell import Shell
 from wx.py.editwindow import EditWindow
 
 from .utilus import funcall as _F
-from .utilus import ignore
-from .utilus import split_words, split_paren, split_tokens, find_modules
+from .utilus import typename, fix_fnchars
+from .utilus import split_words, split_parts, split_tokens, find_modules
 from .framework import CtrlInterface, AuiNotebook, Menu
 
 
-## URL pattern (flag = re.M | re.A)
-url_re = r"https?://[\w/:%#$&?()~.=+-]+"
+## URL pattern (flag = re.M | re.A).
+# url_re = r"https?://[\w/:%#$&?()~.=+-]+"
+url_re = r"https?://[\w/:%#$&?!@~.,;=+-]+"  # excluding ()
 
-## no-file pattern
-nofile_re = r'[\/:*?"<>|]'
-
-## Python syntax pattern
+## Python syntax patterns.
 py_indent_re  = r"if|else|elif|for|while|with|def|class|try|except|finally"
 py_outdent_re = r"else:|elif\s+.*:|except(\s+.*)?:|finally:"
 py_closing_re = r"break|pass|return|raise|continue"
 
-## Python interp traceback pattern
-py_error_re = r' +File "(.*?)", line ([0-9]+)'
-py_frame_re = r" +file '(.*?)', line ([0-9]+)"
-py_where_re = r'> +([^*?"<>|\r\n]+?):([0-9]+)'
-py_break_re = r'at ([^*?"<>|\r\n]+?):([0-9]+)'
+## Python traceback pattern.
+py_trace_re = r' +File "(.*?)", line (\d+)'
+
+## Custom constants in wx.stc.
+stc.STC_STYLE_CARETLINE = 40
+stc.STC_STYLE_ANNOTATION = 41
+
+
+class Stylus:
+    py_log_mode = {
+        stc.STC_STYLE_DEFAULT     : "fore:#7f7f7f,back:#ffffb8,size:9,face:MS Gothic",
+        stc.STC_STYLE_LINENUMBER  : "fore:#000000,back:#ffffb8,size:9",
+        stc.STC_STYLE_BRACELIGHT  : "fore:#000000,back:#ffffb8,bold",
+        stc.STC_STYLE_BRACEBAD    : "fore:#000000,back:#ff0000,bold",
+        stc.STC_STYLE_CONTROLCHAR : "size:6",
+        stc.STC_STYLE_INDENTGUIDE : "",
+        stc.STC_STYLE_CARETLINE   : "fore:#000000,back:#ffff7f,size:2",  # optional
+        stc.STC_STYLE_ANNOTATION  : "fore:#7f0000,back:#ff7f7f",  # optional
+        stc.STC_P_DEFAULT         : "fore:#000000",
+        stc.STC_P_OPERATOR        : "fore:#000000",
+        stc.STC_P_IDENTIFIER      : "fore:#000000",
+        stc.STC_P_COMMENTLINE     : "fore:#007f7f,back:#ffcfcf",
+        stc.STC_P_COMMENTBLOCK    : "fore:#007f7f,back:#ffcfcf,eol",
+        stc.STC_P_NUMBER          : "fore:#7f0000",
+        stc.STC_P_CHARACTER       : "fore:#7f7f7f",
+        stc.STC_P_STRING          : "fore:#7f7f7f",
+        stc.STC_P_TRIPLE          : "fore:#7f7f7f",
+        stc.STC_P_TRIPLEDOUBLE    : "fore:#7f7f7f",
+        stc.STC_P_STRINGEOL       : "fore:#000000,back:#ffcfcf,eol",
+        stc.STC_P_CLASSNAME       : "fore:#7f00ff,bold",
+        stc.STC_P_DEFNAME         : "fore:#0000ff,bold",
+        stc.STC_P_WORD            : "fore:#0000ff",
+        stc.STC_P_WORD2           : "fore:#b8007f",
+        stc.STC_P_DECORATOR       : "fore:#e08040",
+    }
+
+    py_text_mode = {
+        stc.STC_STYLE_DEFAULT     : "fore:#7f7f7f,back:#fffff8,size:9,face:MS Gothic",
+        stc.STC_STYLE_LINENUMBER  : "fore:#000000,back:#fffff8,size:9",
+        stc.STC_STYLE_BRACELIGHT  : "fore:#000000,back:#cccccc,bold",
+        stc.STC_STYLE_BRACEBAD    : "fore:#000000,back:#ff0000,bold",
+        stc.STC_STYLE_CONTROLCHAR : "size:6",
+        stc.STC_STYLE_INDENTGUIDE : "",
+        stc.STC_STYLE_CARETLINE   : "fore:#000000,back:#f0f0ff,size:2",  # optional
+        stc.STC_STYLE_ANNOTATION  : "fore:#7f0000,back:#ff7f7f",  # optional
+        stc.STC_P_DEFAULT         : "fore:#000000",
+        stc.STC_P_OPERATOR        : "fore:#000000",
+        stc.STC_P_IDENTIFIER      : "fore:#000000",
+        stc.STC_P_COMMENTLINE     : "fore:#007f00,back:#f0fff0",
+        stc.STC_P_COMMENTBLOCK    : "fore:#007f00,back:#f0fff0,eol",
+        stc.STC_P_NUMBER          : "fore:#e02000",
+        stc.STC_P_CHARACTER       : "fore:#7f7f7f",
+        stc.STC_P_STRING          : "fore:#7f7f7f",
+        stc.STC_P_TRIPLE          : "fore:#7f7f7f",
+        stc.STC_P_TRIPLEDOUBLE    : "fore:#7f7f7f",
+        stc.STC_P_STRINGEOL       : "fore:#7f7f7f,back:#ffc0c0,eol",
+        stc.STC_P_CLASSNAME       : "fore:#7f00ff,bold",
+        stc.STC_P_DEFNAME         : "fore:#0000ff,bold",
+        stc.STC_P_WORD            : "fore:#0000ff",
+        stc.STC_P_WORD2           : "fore:#7f007f",
+        stc.STC_P_DECORATOR       : "fore:#c04040,bold",
+    }
+
+    py_shell_mode = {
+        stc.STC_STYLE_DEFAULT     : "fore:#7f7f7f,back:#202020,size:9,face:MS Gothic",
+        stc.STC_STYLE_LINENUMBER  : "fore:#000000,back:#f0f0f0,size:9",
+        stc.STC_STYLE_BRACELIGHT  : "fore:#ffffff,back:#202020,bold",
+        stc.STC_STYLE_BRACEBAD    : "fore:#ffffff,back:#ff0000,bold",
+        stc.STC_STYLE_CONTROLCHAR : "size:6",
+        stc.STC_STYLE_INDENTGUIDE : "",
+        stc.STC_STYLE_CARETLINE   : "fore:#ffffff,back:#123460,size:2",  # optional
+        stc.STC_STYLE_ANNOTATION  : "fore:#7f0000,back:#ff7f7f",  # optional
+        stc.STC_P_DEFAULT         : "fore:#cccccc",
+        stc.STC_P_OPERATOR        : "fore:#cccccc",
+        stc.STC_P_IDENTIFIER      : "fore:#cccccc",
+        stc.STC_P_COMMENTLINE     : "fore:#42c18c,back:#004040",
+        stc.STC_P_COMMENTBLOCK    : "fore:#42c18c,back:#004040,eol",
+        stc.STC_P_NUMBER          : "fore:#ffc080",
+        stc.STC_P_CHARACTER       : "fore:#a0a0a0",
+        stc.STC_P_STRING          : "fore:#a0c0ff",
+        stc.STC_P_TRIPLE          : "fore:#a0a0a0",
+        stc.STC_P_TRIPLEDOUBLE    : "fore:#a0c0ff",
+        stc.STC_P_STRINGEOL       : "fore:#cccccc,back:#400000,eol",
+        stc.STC_P_CLASSNAME       : "fore:#61d6d6,bold",
+        stc.STC_P_DEFNAME         : "fore:#3a96ff,bold",
+        stc.STC_P_WORD            : "fore:#80c0ff",
+        stc.STC_P_WORD2           : "fore:#ff80ff",
+        stc.STC_P_DECORATOR       : "fore:#ff8040",
+    }
 
 
 def skip(evt):
     evt.Skip()
 
 
-def can_edit(f):
+def editable(f):
     @wraps(f)
     def _f(self, *v, **kw):
         if self.CanEdit():
@@ -63,10 +147,14 @@ def can_edit(f):
 def ask(f, prompt="Enter value", type=str):
     """Get response from the user using a dialog box."""
     @wraps(f)
-    def _f(*v):
-        with wx.TextEntryDialog(None, prompt, f.__name__) as dlg:
+    def _f(evt, value=''):
+        with wx.TextEntryDialog(None, prompt, f.__name__, value) as dlg:
             if dlg.ShowModal() == wx.ID_OK:
-                return f(type(dlg.Value))
+                value = dlg.Value
+                try:
+                    return f(type(value))
+                except ValueError:
+                    return _f(evt, value)  # show the prompt again
     return _f
 
 
@@ -86,15 +174,15 @@ class AutoCompInterfaceMixin:
     """
     history = []     # used in history-comp mode
     modules = set()  # used in module-comp mode
-    fragmwords = set(keyword.kwlist + dir(builtins)) # used in text-comp mode
-    
+    fragmwords = set(keyword.kwlist + dir(builtins))  # used in text-comp mode
+
     def __init__(self):
         ## cf. sys.modules
         if not self.modules:
             force = wx.GetKeyState(wx.WXK_CONTROL)\
                   & wx.GetKeyState(wx.WXK_SHIFT)
             AutoCompInterfaceMixin.modules = set(find_modules(force))
-    
+
     def CallTipShow(self, pos, tip, N=11):
         """Show a call tip containing a definition near position pos.
         
@@ -107,11 +195,14 @@ class AutoCompInterfaceMixin:
             lines[N+1:] = ["\n...(snip) This tips are too long... "
                            "Click to show more details."]
             tip = '\n'.join(lines)
-            self._calltips[-1] = True # snipped (needs to be shown)
+            self._calltips[-1] = True  # snipped (needs to be shown)
         super().CallTipShow(pos, tip)
-    
+
     def autoCallTipShow(self, command, insertcalltip=True):
-        """Display argument spec and docstring in a popup window."""
+        """Display argument spec and docstring in a popup window.
+        
+        (override) Fix cursor position on calltip insertion.
+        """
         if self.CallTipActive():
             self.CallTipCancel()
         
@@ -120,50 +211,50 @@ class AutoCompInterfaceMixin:
             dispatcher.send(signal='Shell.calltip', sender=self, calltip=tip)
         p = self.cpos
         if argspec and insertcalltip:
-            self.AddText(argspec + ')')     # 挿入後のカーソル位置は変化しない
-            self.SetSelection(self.cpos, p) # selection back
+            self.AddText(argspec + ')')
+            self.cpos = p  # selection backward to the point
         if tip:
             ## In case there isn't enough room, only go back to bol fallback.
             tippos = max(self.bol, p - len(name) - 1)
             self.CallTipShow(tippos, tip)
-    
+
     def call_helpDoc(self, evt):
         """Show help:str for the selected topic."""
         if self.CallTipActive():
             self.CallTipCancel()
         
-        text = next(self.gen_text_at_caret(), None)
+        text = self.SelectedText or self.expr_at_caret or self.line_at_caret
         if text:
             text = introspect.getRoot(text, terminator='(')
             try:
                 obj = self.eval(text)
                 self.help(obj)
             except Exception as e:
-                self.message("- {} : {!r}".format(e, text))
-    
+                self.message(e)
+
     def call_helpTip(self, evt):
         """Show a calltip for the selected function."""
         if self.CallTipActive():
             self.CallTipCancel()
         
-        text = next(self.gen_text_at_caret(), None)
+        text = self.SelectedText or self.expr_at_caret or self.line_at_caret
         if text:
             p = self.cpos
             self.autoCallTipShow(text,
-                p == self.eol and self.get_char(p-1) == '(') # => CallTipShow
-    
+                p == self.eol and self.get_char(p-1) == '(')  # => CallTipShow
+
     def on_completion_forward(self, evt):
         if not self.AutoCompActive():
             self.handler('quit', evt)
             return
         self._on_completion(1)
-    
+
     def on_completion_backward(self, evt):
         if not self.AutoCompActive():
             self.handler('quit', evt)
             return
         self._on_completion(-1)
-    
+
     def _on_completion(self, step=0):
         """Show completion with selection."""
         try:
@@ -174,18 +265,18 @@ class AutoCompInterfaceMixin:
             n = len(self.__comp_hint)
             p = self.cpos
             if not self.SelectedText:
-                p, q, sty = self.get_following_atom(p) # word-right-selection
+                p, q, sty = self.get_following_atom(p)  # word-right-selection
                 if sty == 'word':
                     self.anchor = q
             with self.off_undocollection():
                 self.ReplaceSelection(word[n:])
-            self.cpos = p # backward selection to the point
+            self.cpos = p  # selection backward to the point
             self.__comp_ind = j
         except IndexError:
             self.message("No completion words")
-    
+
     def _gen_autocomp(self, j, hint, words, sep=' ', mode=True):
-        ## Prepare on_completion_forward/backward
+        ## Prepare on_completion_forward/backward.
         self.__comp_ind = j
         self.__comp_hint = hint
         self.__comp_words = words
@@ -195,12 +286,20 @@ class AutoCompInterfaceMixin:
         elif words:
             self.AutoCompSetSeparator(ord(sep))
             self.AutoCompShow(len(hint), sep.join(words))
-    
+
     def _get_words_hint(self):
         cmdl = self.GetTextRange(self.bol, self.cpos)
-        text = next(split_words(cmdl, reverse=1), '')
-        return text.rpartition('.') # -> text, sep, hint
-    
+        if cmdl.endswith(' '):  # 前の文字が空白の場合はスキップする
+            text = ''
+        else:
+            text = next(split_words(cmdl, reverse=1), '')
+        return text.rpartition('.')  # -> text, sep, hint
+
+    def clear_autocomp(self, evt):
+        if self.AutoCompActive():
+            self.AutoCompCancel()
+        self.message("")
+
     def call_history_comp(self, evt):
         """Called when history-comp mode."""
         if not self.CanEdit():
@@ -209,19 +308,19 @@ class AutoCompInterfaceMixin:
         
         cmdl = self.GetTextRange(self.bol, self.cpos)
         if cmdl.isspace() or self.bol != self.bolc:
-            self.handler('skip', evt) # [tab pressed] => on_indent_line
+            self.handler('skip', evt)  # [tab pressed] => on_indent_line
             return
         
         hint = cmdl.strip()
         ls = [x.replace('\n', os.linesep + sys.ps2)
-                for x in self.history if x.startswith(hint)] # case-sensitive match
-        words = sorted(set(ls), key=ls.index, reverse=0)     # keep order, no duplication
+                for x in self.history if x.startswith(hint)]  # case-sensitive match
+        words = sorted(set(ls), key=ls.index, reverse=0)      # keep order, no duplication
         
-        ## the latest history stacks in the head of the list (time-descending)
+        ## The latest history stacks in the head of the list (time-descending).
         self._gen_autocomp(0, hint, words, mode=False)
         self.message("[history] {} candidates matched"
                      " with {!r}".format(len(words), hint))
-    
+
     def call_text_autocomp(self, evt):
         """Called when text-comp mode."""
         if not self.CanEdit():
@@ -229,15 +328,17 @@ class AutoCompInterfaceMixin:
             return
         
         cmdl = self.GetTextRange(self.bol, self.cpos)
-        hint = re.search(r"[\w.]*$", cmdl).group(0) # extract the last word
+        hint = re.search(r"[\w.]*$", cmdl).group(0)  # extract the last word
         
-        ls = [x for x in self.fragmwords if x.startswith(hint)] # case-sensitive match
-        words = sorted(ls, key=lambda s:s.upper())
+        ## ls = [x for x in self.fragmwords if x.startswith(hint)]  # case-sensitive match
+        q = hint.lower()
+        ls = [x for x in self.fragmwords if x.lower().startswith(q)]  # case-insensitive match
+        words = sorted(ls, key=lambda s: s.upper())
         
         self._gen_autocomp(0, hint, words)
         self.message("[text] {} candidates matched"
                      " with {!r}".format(len(words), hint))
-    
+
     def call_module_autocomp(self, evt, force=False):
         """Called when module-comp mode."""
         if not self.CanEdit():
@@ -248,13 +349,14 @@ class AutoCompInterfaceMixin:
             if not hints.endswith(' '):
                 h = hints.strip()
                 if not h.endswith(','):
-                    lh = h.split(',')[-1].strip() # 'x, y, z|' last hint after ','
-                    if ' ' not in lh:             # 'x, y as|' contains no spaces.
+                    lh = h.split(',')[-1].strip()  # 'x, y, z|' last hint after ','
+                    if ' ' not in lh:              # 'x, y as|' contains no spaces.
                         return lh
         
         cmdl = self.GetTextRange(self.bol, self.cpos)
-        hint = re.search(r"[\w.]*$", cmdl).group(0) # extract the last word
+        hint = re.search(r"[\w.]*$", cmdl).group(0)  # extract the last word including dots
         try:
+            ## from * import ...
             if (m := re.match(r"from\s+([\w.]+)\s+import\s+(.*)", cmdl)):
                 text, hints = m.groups()
                 if not _continue(hints) and not force:
@@ -270,17 +372,18 @@ class AutoCompInterfaceMixin:
                     self.message("\b failed.", e)
                     return
                 else:
-                    ## Add unimported module names.
-                    p = "{}.{}".format(text, hint)
-                    keys = [x[len(text)+1:] for x in self.modules if x.startswith(p)]
+                    ## Add unimported module names (case-insensitive match).
+                    q = f"{text}.{hint}".lower()
+                    keys = [x[len(text)+1:] for x in self.modules if x.lower().startswith(q)]
                     modules.update(k for k in keys if '.' not in k)
-            
+            ## import ...
             elif (m := re.match(r"(import|from)\s+(.*)", cmdl)):
                 text, hints = m.groups()
                 if not _continue(hints) and not force:
                     self.message("[module]>>> waiting for key input...")
                     return
                 modules = self.modules
+            ## Module X.Y.Z
             else:
                 text, sep, hint = self._get_words_hint()
                 obj = self.eval(text)
@@ -288,7 +391,7 @@ class AutoCompInterfaceMixin:
             
             P = re.compile(hint)
             p = re.compile(hint, re.I)
-            words = sorted([x for x in modules if p.match(x)], key=lambda s:s.upper())
+            words = sorted([x for x in modules if p.match(x)], key=lambda s: s.upper())
             
             j = next((k for k, w in enumerate(words) if P.match(w)),
                 next((k for k, w in enumerate(words) if p.match(w)), -1))
@@ -303,19 +406,24 @@ class AutoCompInterfaceMixin:
             self.message("- {} : {!r}".format(e, text))
         except Exception as e:
             self.message("- {} : {!r}".format(e, text))
-    
+
     def call_word_autocomp(self, evt):
         """Called when word-comp mode."""
         if not self.CanEdit():
             self.handler('quit', evt)
             return
+        
+        text, sep, hint = self._get_words_hint()
+        if not text:
+            self.handler('quit', evt)
+            self.message("- No autocompletion candidates or hints found.")
+            return
         try:
-            text, sep, hint = self._get_words_hint()
+            ## dir = introspect.getAttributeNames  # @TODO in wx ver 4.2.3
             obj = self.eval(text)
-            
             P = re.compile(hint)
             p = re.compile(hint, re.I)
-            words = sorted([x for x in dir(obj) if p.match(x)], key=lambda s:s.upper())
+            words = sorted([x for x in dir(obj) if p.match(x)], key=lambda s: s.upper())
             
             j = next((k for k, w in enumerate(words) if P.match(w)),
                 next((k for k, w in enumerate(words) if p.match(w)), -1))
@@ -330,19 +438,24 @@ class AutoCompInterfaceMixin:
             self.message("- {} : {!r}".format(e, text))
         except Exception as e:
             self.message("- {} : {!r}".format(e, text))
-    
+
     def call_apropos_autocomp(self, evt):
         """Called when apropos mode."""
         if not self.CanEdit():
             self.handler('quit', evt)
             return
+        
+        text, sep, hint = self._get_words_hint()
+        if not text:
+            self.handler('quit', evt)
+            self.message("- No autocompletion candidates or hints found.")
+            return
         try:
-            text, sep, hint = self._get_words_hint()
+            ## dir = introspect.getAttributeNames  # @TODO in wx ver 4.2.3.
             obj = self.eval(text)
-            
             P = re.compile(hint)
             p = re.compile(hint, re.I)
-            words = sorted([x for x in dir(obj) if p.search(x)], key=lambda s:s.upper())
+            words = sorted([x for x in dir(obj) if p.search(x)], key=lambda s: s.upper())
             
             j = next((k for k, w in enumerate(words) if P.match(w)),
                 next((k for k, w in enumerate(words) if p.match(w)), -1))
@@ -366,8 +479,8 @@ class EditorInterface(AutoCompInterfaceMixin, CtrlInterface):
         This class is mixed-in ``wx.stc.StyledTextCtrl``.
     """
     def __init__(self):
-        CtrlInterface.__init__(self)
         AutoCompInterfaceMixin.__init__(self)
+        CtrlInterface.__init__(self)
         
         def dispatch(evt):
             """Fork events to the parent."""
@@ -384,7 +497,7 @@ class EditorInterface(AutoCompInterfaceMixin, CtrlInterface):
                 'pointer_unset' : [ None, dispatch ],
             },
             0 : {
-               'insert pressed' : (0, _F(self.over, None, doc="toggle-over")),
+               'insert pressed' : (0, _F(self.over, mode=None, doc="toggle-over")),
                'C-left pressed' : (0, _F(self.WordLeft)),
               'C-right pressed' : (0, _F(self.WordRightEnd)),
              'C-S-left pressed' : (0, _F(self.selection_backward_word_or_paren)),
@@ -395,29 +508,29 @@ class EditorInterface(AutoCompInterfaceMixin, CtrlInterface):
                   'C-e pressed' : (0, _F(self.end_of_line)),
                   'M-a pressed' : (0, _F(self.back_to_indentation)),
                   'M-e pressed' : (0, _F(self.end_of_line)),
-                  'M-g pressed' : (0, ask(self.goto_line, "Line to goto:", lambda x:int(x)-1),
+                  'M-g pressed' : (0, ask(self.goto_line, "Line to goto:", lambda x: int(x)-1),
                                        _F(self.recenter)),
                   'M-f pressed' : (10, _F(self.filter_text), self.on_itext_enter),
                   'C-k pressed' : (0, _F(self.kill_line)),
                 'C-S-c pressed' : (0, _F(self.Copy)),
                 'C-S-v pressed' : (0, _F(self.Paste)),
                   'C-l pressed' : (0, _F(self.recenter)),
-                'C-S-l pressed' : (0, _F(self.recenter)), # overrides delete-line
-                'C-S-f pressed' : (0, _F(self.set_mark)), # overrides mark
+                # 'C-S-l pressed' : (0, _F(self.recenter)),  # overrides delete-line
+                # 'C-S-f pressed' : (0, _F(self.set_mark)),  # overrides mark
               'C-space pressed' : (0, _F(self.set_mark)),
-            'C-S-space pressed' : (0, _F(self.set_pointer)),
-          'C-backspace pressed' : (0, skip),
+            'C-S-space pressed' : (0, _F(self.toggle_pointer)),
+          'C-backspace pressed' : (0, _F(self.backward_kill_word)),
           'S-backspace pressed' : (0, _F(self.backward_kill_line)),
+             'C-delete pressed' : (0, _F(self.kill_word)),
+             'S-delete pressed' : (0, _F(self.kill_line)),
                 'C-tab pressed' : (0, _F(self.insert_space_like_tab)),
               'C-S-tab pressed' : (0, _F(self.delete_backward_space_like_tab)),
                   'tab pressed' : (0, self.on_indent_line),
                 'S-tab pressed' : (0, self.on_outdent_line),
-                  ## 'C-/ pressed' : (0, ), # cf. C-a home
-                  ## 'C-\ pressed' : (0, ), # cf. C-e end
+                  # 'C-/ pressed' : (0, ),  # cf. C-a home
+                  # 'C-\ pressed' : (0, ),  # cf. C-e end
                   'C-; pressed' : (0, _F(self.comment_out_line)),
-                'C-S-; pressed' : (0, _F(self.comment_out_line)),
                   'C-: pressed' : (0, _F(self.uncomment_line)),
-                'C-S-: pressed' : (0, _F(self.uncomment_line)),
                   'select_line' : (11, self.on_linesel_begin),
                  'select_lines' : (11, self.on_linesel_next),
             },
@@ -435,9 +548,9 @@ class EditorInterface(AutoCompInterfaceMixin, CtrlInterface):
             },
         })
         
-        ## cf. wx.py.editwindow.EditWindow.OnUpdateUI => Check for brace matching
+        ## cf. wx.py.editwindow.EditWindow.OnUpdateUI => Check for brace matching.
         self.Bind(stc.EVT_STC_UPDATEUI,
-                  lambda v: self.match_paren()) # no skip
+                  lambda v: self.match_paren())  # no skip
         
         def eof(evt):
             p = evt.Position
@@ -459,104 +572,100 @@ class EditorInterface(AutoCompInterfaceMixin, CtrlInterface):
                 ss |= set(x for x in dir(obj) if x.startswith('__'))
             return ss
         
-        ## Keyword(2) setting
+        ## Keyword(2) setting.
         self.SetLexer(stc.STC_LEX_PYTHON)
         self.SetKeyWords(0, ' '.join(keyword.kwlist))
         self.SetKeyWords(1, ' '.join(builtins.__dict__)
                           + ' '.join(_dunders(type, int, float, str, bytes,
                                               tuple, list, range, operator,))
-                          + ' self this')
+                          + ' self this shell')
         
-        ## AutoComp setting
+        ## AutoComp setting.
         self.AutoCompSetAutoHide(False)
         self.AutoCompSetIgnoreCase(True)
         self.AutoCompSetMaxWidth(80)
         self.AutoCompSetMaxHeight(10)
         
-        ## To prevent @filling crash (Never access to DropTarget)
-        ## [BUG 4.1.1] Don't allow DnD of text, file, whatever.
+        ## To prevent @filling crash (Never access to DropTarget).
+        ## [BUG ver 4.1.1] Don't allow DnD of text, file, whatever.
         ## self.SetDropTarget(None)
         
         self.Bind(stc.EVT_STC_START_DRAG, self.OnDrag)
         self.Bind(stc.EVT_STC_DRAG_OVER, self.OnDragging)
         self.Bind(stc.EVT_STC_DO_DROP, self.OnDragged)
         
-        ## Global style for all languages
+        ## Global style for all languages.
         ## font = wx.Font(9, wx.MODERN, wx.NORMAL, wx.NORMAL, False, "MS Gothic")
         ## self.StyleSetFont(stc.STC_STYLE_DEFAULT, font)
-        
         ## self.StyleClearAll()
-        ## self.SetSelForeground(True, wx.SystemSettings.GetColour(wx.SYS_COLOUR_HIGHLIGHTTEXT))
-        ## self.SetSelBackground(True, wx.SystemSettings.GetColour(wx.SYS_COLOUR_HIGHLIGHT))
+        ## => STC_STYLE_DEFAULT に設定したスタイルを他のスタイルに全適用する．
         
-        ## The magin style for line numbers and symbols
+        ## The magin style for line numbers and symbols.
         ## [0] for markers, 10 pixels wide, mask 0b11111
         ## [1] for numbers, 32 pixels wide, mask 0x01ffffff (~stc.STC_MASK_FOLDERS)
         ## [2] for borders,  1 pixels wide, mask 0xfe000000 ( stc.STC_MASK_FOLDERS)
-        
+        ## 
+        ## cf. `EditWindow.setDisplayLineNumbers`
+        ## 
         ## 32 bit margin mask
         ## [0] 1111,1111,1111,1111,1111,1111,1111,1111 = -1 for all markers
         ## [1] 0000,0001,1111,1111,1111,1111,1111,1111 = 0x01ffffff for markers
         ## [2] 1111,1110,0000,0000,0000,0000,0000,0000 = 0xfe000000 for folders
         
         self.SetMarginType(0, stc.STC_MARGIN_SYMBOL)
-        self.SetMarginMask(0, 0b00111) # mask for markers (0,1,2)
+        self.SetMarginMask(0, 0b00111)  # mask for markers (0,1,2)
         self.SetMarginWidth(0, 10)
         self.SetMarginSensitive(0, False)
         
         self.SetMarginType(1, stc.STC_MARGIN_NUMBER)
-        self.SetMarginMask(1, 0b11000) # mask for pointer (3,4)
+        self.SetMarginMask(1, 0b11000)  # mask for pointer (3,4)
         self.SetMarginWidth(1, 32)
         self.SetMarginSensitive(1, False)
         
         self.SetMarginType(2, stc.STC_MARGIN_SYMBOL)
-        self.SetMarginMask(2, stc.STC_MASK_FOLDERS) # mask for folders
+        self.SetMarginMask(2, stc.STC_MASK_FOLDERS)  # mask for folders
         self.SetMarginWidth(2, 1)
         self.SetMarginSensitive(2, False)
         
-        self.SetMarginLeft(2) # +1 margin at the left
+        self.SetMarginLeft(2)  # +1 margin at the left
         
-        self.SetFoldFlags(0x10) # draw below if not expanded
+        self.SetFoldFlags(stc.STC_FOLDFLAG_LINEAFTER_CONTRACTED)
         
-        self.SetProperty('fold', '1') # Enable folder property
+        self.SetProperty('fold', '1')  # Enable folder property
         
-        ## if wx.VERSION >= (4,1,0):
-        try:
-            self.Bind(stc.EVT_STC_MARGINCLICK, self.OnMarginClick)
-            self.Bind(stc.EVT_STC_MARGIN_RIGHT_CLICK, self.OnMarginRClick)
-        except AttributeError:
-            pass
+        self.Bind(stc.EVT_STC_MARGINCLICK, self.OnMarginClick)
+        self.Bind(stc.EVT_STC_MARGIN_RIGHT_CLICK, self.OnMarginRClick)
         
-        ## Custom markers
-        self.MarkerDefine(0, stc.STC_MARK_CIRCLE, '#007ff0', '#007ff0') # o mark
-        self.MarkerDefine(1, stc.STC_MARK_ARROW,  '#000000', '#ffffff') # > arrow
-        self.MarkerDefine(2, stc.STC_MARK_ARROW,  '#7f0000', '#ff0000') # > red-arrow
-        self.MarkerDefine(3, stc.STC_MARK_SHORTARROW, 'blue', 'gray')   # -> pointer
-        self.MarkerDefine(4, stc.STC_MARK_SHORTARROW, 'red', 'yellow')  # -> red-pointer
+        ## Custom markers.
+        self.MarkerDefine(0, stc.STC_MARK_CIRCLE, '#007ff0', '#007ff0')  # o mark
+        self.MarkerDefine(1, stc.STC_MARK_ARROW,  '#000000', '#ffffff')  # > arrow
+        self.MarkerDefine(2, stc.STC_MARK_ARROW,  '#7f0000', '#ff0000')  # > red-arrow
+        self.MarkerDefine(3, stc.STC_MARK_SHORTARROW, 'blue', 'gray')    # -> pointer
+        self.MarkerDefine(4, stc.STC_MARK_SHORTARROW, 'red', 'yellow')   # -> red-pointer
         
         v = ('white', 'black')
         self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPEN,    stc.STC_MARK_BOXMINUS, *v)
         self.MarkerDefine(stc.STC_MARKNUM_FOLDER,        stc.STC_MARK_BOXPLUS,  *v)
         self.MarkerDefine(stc.STC_MARKNUM_FOLDERSUB,     stc.STC_MARK_VLINE,    *v)
         self.MarkerDefine(stc.STC_MARKNUM_FOLDERTAIL,    stc.STC_MARK_LCORNER,  *v)
-        ## self.MarkerDefine(stc.STC_MARKNUM_FOLDEREND,     stc.STC_MARK_TCORNER, *v)
-        ## self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPENMID, stc.STC_MARK_TCORNER, *v)
+        # self.MarkerDefine(stc.STC_MARKNUM_FOLDEREND,     stc.STC_MARK_TCORNER, *v)
+        # self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPENMID, stc.STC_MARK_TCORNER, *v)
         self.MarkerDefine(stc.STC_MARKNUM_FOLDEREND,     stc.STC_MARK_VLINE, *v)
         self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPENMID, stc.STC_MARK_VLINE, *v)
         self.MarkerDefine(stc.STC_MARKNUM_FOLDERMIDTAIL, stc.STC_MARK_VLINE, *v)
         
-        ## Custom indicators ([BUG] indicator=1 is reset when the buffer is udpated.)
+        ## Custom indicators ([BUG] indicator=1 is reset when the buffer is updated).
         ## [10-11] filter_text
-        ## [2] URL for load_file
+        ## [2] URL
         ## [3] match_paren
         self.IndicatorSetStyle(10, stc.STC_INDIC_TEXTFORE)
         self.IndicatorSetForeground(10, "red")
         
         self.IndicatorSetStyle(11, stc.STC_INDIC_STRAIGHTBOX)
-        self.IndicatorSetUnder(11, True)
-        self.IndicatorSetAlpha(11, 255)
-        self.IndicatorSetOutlineAlpha(11, 255)
         self.IndicatorSetForeground(11, "yellow")
+        self.IndicatorSetUnder(11, True)
+        # self.IndicatorSetAlpha(11, 0xe8)
+        # self.IndicatorSetOutlineAlpha(11, 0)
         
         self.IndicatorSetStyle(2, stc.STC_INDIC_DOTS)
         self.IndicatorSetForeground(2, "light gray")
@@ -569,57 +678,50 @@ class EditorInterface(AutoCompInterfaceMixin, CtrlInterface):
         self.IndicatorSetStyle(3, stc.STC_INDIC_DOTS)
         self.IndicatorSetForeground(3, "light gray")
         
-        ## Custom annotation
+        ## Custom annotation.
         self.AnnotationSetVisible(stc.STC_ANNOTATION_BOXED)
         
-        ## Custom style of control-char, wrap-mode
-        ## self.UseTabs = False
-        ## self.ViewEOL = False
-        ## self.ViewWhiteSpace = False
-        ## self.TabWidth = 4
-        ## self.EOLMode = stc.STC_EOL_CRLF
+        ## Custom style of control-char, wrap-mode.
+        # self.UseTabs = False
+        # self.ViewEOL = False
+        # self.ViewWhiteSpace = False
+        # self.TabWidth = 4
+        # self.EOLMode = stc.STC_EOL_CRLF
         self.WrapMode = stc.STC_WRAP_NONE
         self.WrapIndentMode = stc.STC_WRAPINDENT_SAME
         self.IndentationGuides = stc.STC_IV_LOOKFORWARD
         
         self.__mark = -1
         self.__stylus = {}
-    
-    ## Custom constants embedded in wx.stc
-    stc.STC_P_WORD3 = 20 # deprecated
-    stc.STC_STYLE_CARETLINE = 40
-    stc.STC_STYLE_ANNOTATION = 41
-    
-    def OnDrag(self, evt): #<wx._core.StyledTextEvent>
-        EditorInterface.__dnd_from = evt.EventObject
-        try:
-            EditorInterface.__dnd_flag = (evt.Position < self.bolc) # force copy
-        except AttributeError:
+
+    __dnd_flag = 0
+
+    def OnDrag(self, evt):  #<wx._core.StyledTextEvent>
+        if isinstance(self, Shell):
+            EditorInterface.__dnd_flag = (evt.Position < self.bolc)  # readonly
+        else:
             EditorInterface.__dnd_flag = 0
         evt.Skip()
-    
-    def OnDragging(self, evt): #<wx._core.StyledTextEvent>
-        _from = EditorInterface.__dnd_from
-        _to = evt.EventObject
-        if isinstance(_from, Shell) and _from is not _to:  # from shell to buffer
-            wx.UIActionSimulator().KeyDown(wx.WXK_CONTROL) # force copy
-        try:
-            if evt.Position < self.bolc:
-                evt.DragResult = wx.DragNone # Don't drop (as readonly)
+
+    def OnDragging(self, evt):  #<wx._core.StyledTextEvent>
+        if isinstance(self, Shell):
+            if evt.Position < self.bolc:  # target is readonly
+                evt.DragResult = wx.DragNone
             elif EditorInterface.__dnd_flag:
-                evt.DragResult = wx.DragCopy # Don't move
-        except AttributeError:
-            pass
+                ## from shell to shell
+                evt.DragResult = wx.DragCopy if wx.GetKeyState(wx.WXK_CONTROL) else wx.DragNone
+        else:
+            if EditorInterface.__dnd_flag:
+                ## from shell to buffer
+                evt.DragResult = wx.DragCopy if wx.GetKeyState(wx.WXK_CONTROL) else wx.DragNone
         evt.Skip()
-    
-    def OnDragged(self, evt): #<wx._core.StyledTextEvent>
-        EditorInterface.__dnd_from = None
+
+    def OnDragged(self, evt):  #<wx._core.StyledTextEvent>
         EditorInterface.__dnd_flag = 0
-        wx.UIActionSimulator().KeyUp(wx.WXK_CONTROL)
         evt.Skip()
-    
+
     ## --------------------------------
-    ## Marker attributes of the editor
+    ## Marker attributes of the editor.
     ## --------------------------------
     marker_names = {
         0: "mark",
@@ -628,112 +730,116 @@ class EditorInterface(AutoCompInterfaceMixin, CtrlInterface):
         3: "pointer",
         4: "red-pointer",
     }
-    
+
     def get_marker(self, n):
         return self.MarkerNext(0, 1<<n)
-    
+
     def set_marker(self, line, n):
         if line != -1:
             self.MarkerDeleteAll(n)
             self.add_marker(line, n)
         else:
             self.del_marker(n)
-    
+
     def add_marker(self, line, n):
         if self.MarkerAdd(line, n):
-            self.EnsureVisible(line) # expand if folded
+            self.EnsureVisible(line)  # expand if folded
             self.handler('{}_set'.format(self.marker_names[n]), line)
-    
+
     def del_marker(self, n):
         line = self.MarkerNext(0, 1<<n)
         if line != -1:
             self.MarkerDeleteAll(n)
             self.handler('{}_unset'.format(self.marker_names[n]), line)
-    
+
     def goto_marker(self, markerMask, selection=False):
         line = self.MarkerNext(0, markerMask)
         if line != -1:
-            self.EnsureVisible(line) # expand if folded
+            self.EnsureVisible(line)  # expand if folded
             self.goto_line(line, selection)
             self.recenter()
-    
+
     def goto_next_marker(self, markerMask, selection=False):
         line = self.MarkerNext(self.cline+1, markerMask)
         if line == -1:
             line = self.LineCount
         self.goto_line(line, selection)
-    
+
     def goto_previous_marker(self, markerMask, selection=False):
         line = self.MarkerPrevious(self.cline-1, markerMask)
         if line == -1:
             line = 0
         self.goto_line(line, selection)
-    
+
     white_arrow = property(
         lambda self: self.get_marker(1),
-        lambda self,v: self.set_marker(v, 1), # [arrow_set]
-        lambda self: self.del_marker(1))      # [arrow_unset]
-    
+        lambda self, v: self.set_marker(v, 1),  # [arrow_set]
+        lambda self: self.del_marker(1),        # [arrow_unset]
+        doc="Arrow marker used to indicate success.")
+
     red_arrow = property(
         lambda self: self.get_marker(2),
-        lambda self,v: self.set_marker(v, 2), # [red-arrow_set]
-        lambda self: self.del_marker(2))      # [red-arrow_unset]
-    
+        lambda self, v: self.set_marker(v, 2),  # [red-arrow_set]
+        lambda self: self.del_marker(2),        # [red-arrow_unset]
+        doc="Arrow marker used to indicate failure.")
+
     pointer = property(
         lambda self: self.get_marker(3),
-        lambda self,v: self.set_marker(v, 3), # [pointer_set]
-        lambda self: self.del_marker(3))      # [pointer_unset]
-    
+        lambda self, v: self.set_marker(v, 3),  # [pointer_set]
+        lambda self: self.del_marker(3),        # [pointer_unset]
+        doc="Arrow marker used to indicate breakpoint.")
+
     red_pointer = property(
         lambda self: self.get_marker(4),
-        lambda self,v: self.set_marker(v, 4), # [red-pointer_set]
-        lambda self: self.del_marker(4))      # [red-pointer_unset]
-    
+        lambda self, v: self.set_marker(v, 4),  # [red-pointer_set]
+        lambda self: self.del_marker(4),        # [red-pointer_unset]
+        doc="Arrow marker used to indicate exception.")
+
     @property
     def markline(self):
         return self.MarkerNext(0, 1<<0)
-    
+
     @markline.setter
     def markline(self, v):
         if v != -1:
-            self.mark = self.PositionFromLine(v) # [mark_set]
+            self.mark = self.PositionFromLine(v)  # [mark_set]
         else:
-            del self.mark # [mark_unset]
-    
+            del self.mark  # [mark_unset]
+
     @markline.deleter
     def markline(self):
         del self.mark
-    
+
     @property
     def mark(self):
         return self.__mark
-    
+
     @mark.setter
     def mark(self, v):
         if v != -1:
             self.__mark = v
             ln = self.LineFromPosition(v)
-            self.set_marker(ln, 0) # [mark_set]
+            self.set_marker(ln, 0)  # [mark_set]
         else:
             del self.mark
-    
+
     @mark.deleter
     def mark(self):
         v = self.__mark
         if v != -1:
             self.__mark = -1
-            self.del_marker(0) # [mark_unset]
-    
+            self.del_marker(0)  # [mark_unset]
+
     def set_mark(self):
         self.mark = self.cpos
-    
-    def set_pointer(self):
-        if self.pointer == self.cline:
+
+    def toggle_pointer(self):
+        if self.pointer == self.cline:  # toggle
             self.pointer = -1
         else:
-            self.pointer = self.cline
-            self.red_pointer = -1
-    
+            self.pointer = self.cline   # reset
+        self.red_pointer = -1
+
     def exchange_point_and_mark(self):
         p = self.cpos
         q = self.mark
@@ -743,13 +849,13 @@ class EditorInterface(AutoCompInterfaceMixin, CtrlInterface):
             self.mark = p
         else:
             self.message("No marks")
-    
+
     ## --------------------------------
-    ## Attributes of the editor
+    ## Attributes of the editor.
     ## --------------------------------
     py_styles = {
-        stc.STC_P_DEFAULT       : 'nil', # etc. space \r\n\\$\0 (non-identifier)
-        stc.STC_P_OPERATOR      : 'op',  # ops. `@=+-/*%<>&|^~!?.,:;([{<>}])
+        stc.STC_P_DEFAULT       : 'nil',  # etc. space \r\n\\$\0 (non-identifier)
+        stc.STC_P_OPERATOR      : 'op',   # ops. `@=+-/*%<>&|^~!?.,:;([{<>}])
         stc.STC_P_COMMENTLINE   : 'comment',
         stc.STC_P_COMMENTBLOCK  : 'comment',
         stc.STC_P_NUMBER        : 'suji',
@@ -765,7 +871,7 @@ class EditorInterface(AutoCompInterfaceMixin, CtrlInterface):
         stc.STC_P_CLASSNAME     : 'class',
         stc.STC_P_DEFNAME       : 'def',
     }
-    
+
     def get_style(self, pos):
         c = self.get_char(pos)
         st = self.GetStyleAt(pos)
@@ -782,11 +888,11 @@ class EditorInterface(AutoCompInterfaceMixin, CtrlInterface):
             if c in "({[": return 'lparen'
             if c in ")}]": return 'rparen'
         return sty
-    
+
     def get_char(self, pos):
-        """Returns the character at the position."""
+        """Return the character at the given position."""
         return chr(self.GetCharAt(pos))
-    
+
     def get_text(self, start, end):
         """Retrieve a range of text.
         
@@ -798,50 +904,53 @@ class EditorInterface(AutoCompInterfaceMixin, CtrlInterface):
         p = max(start, 0)
         q = min(end, self.TextLength)
         return self.GetTextRange(p, q)
-    
+
     anchor = property(
         lambda self: self.GetAnchor(),
-        lambda self,v: self.SetAnchor(v))
-    
+        lambda self, v: self.SetAnchor(v),
+        doc="Position of the opposite end of the selection to the caret.")
+
     cpos = property(
         lambda self: self.GetCurrentPos(),
-        lambda self,v: self.SetCurrentPos(v))
-    
+        lambda self, v: self.SetCurrentPos(v),
+        doc="Position of the caret.")
+
     cline = property(
         lambda self: self.GetCurrentLine(),
-        lambda self,v: self.SetCurrentPos(self.PositionFromLine(v)))
-    
+        lambda self, v: self.SetCurrentPos(self.PositionFromLine(v)),
+        doc="Line number of the line with the caret.")
+
     @property
     def bol(self):
         """Beginning of line."""
         text, lp = self.CurLine
         return self.cpos - lp
-    
+
     @property
     def eol(self):
         """End of line."""
         text, lp = self.CurLine
-        text = text.strip('\r\n') # remove linesep: '\r' and '\n'
+        text = text.strip('\r\n')  # remove linesep: '\r' and '\n'
         return (self.cpos - lp + len(text.encode()))
-    
+
     @property
     def line_at_caret(self):
         """Text of the range (bol, eol) at the caret-line."""
         return self.GetTextRange(self.bol, self.eol)
-    
+
     @property
     def expr_at_caret(self):
         """A syntax unit (expression) at the caret-line."""
         p = q = self.cpos
-        lsty = self.get_style(p-1)
-        rsty = self.get_style(p)
-        if lsty == rsty == 'moji': # inside string
-            ## styles = {'moji'}
+        lst = self.get_style(p-1)
+        rst = self.get_style(p)
+        if lst == rst == 'moji':  # inside string
+            # styles = {'moji'}
             return ''
-        elif lsty == 'suji' or rsty == 'suji':
+        elif lst == 'suji' or rst == 'suji':
             styles = {'suji'}
-        elif lsty in ('word', 'dot', 'moji', 'rparen')\
-          or rsty in ('word', 'dot', 'moji', 'lparen'):
+        elif lst in ('word', 'dot', 'moji', 'rparen')\
+          or rst in ('word', 'dot', 'moji', 'lparen'):
             styles = {'word', 'dot', 'moji', 'paren'}
         else:
             return ''
@@ -854,7 +963,7 @@ class EditorInterface(AutoCompInterfaceMixin, CtrlInterface):
             if sty not in styles:
                 break
         return self.GetTextRange(start, end).strip()
-    
+
     @property
     def topic_at_caret(self):
         """Topic word at the caret or selected substring.
@@ -865,75 +974,77 @@ class EditorInterface(AutoCompInterfaceMixin, CtrlInterface):
             return topic
         with self.save_excursion():
             p = q = self.cpos
-            if self.get_char(p-1).isalnum():
+            cp = self.GetTextRange(self.PositionBefore(p), p)  # cf. self.get_char(p-1)
+            if cp.isidentifier() or cp.isalnum():
                 self.WordLeft()
                 p = self.cpos
-            if self.get_char(q).isalnum():
+            cq = self.GetTextRange(q, self.PositionAfter(q))  # cf. self.get_char(q)
+            if cq.isidentifier() or cq.isalnum():
                 self.WordRightEnd()
                 q = self.cpos
             return self.GetTextRange(p, q)
-    
+
     ## --------------------------------
-    ## Python syntax and indentation
+    ## Python syntax and indentation.
     ## --------------------------------
-    
+
     def on_indent_line(self, evt):
         if self.SelectedText:
             evt.Skip()
         else:
             self.py_indent_line()
-    
+
     def on_outdent_line(self, evt):
         if self.SelectedText:
             evt.Skip()
         else:
             self.py_outdent_line()
-    
-    @can_edit
+
+    @editable
     def py_indent_line(self):
         """Indent the current line."""
-        text = self.line_at_caret # w/ no-prompt
-        lstr = text.lstrip()      # w/ no-indent
+        text = self.line_at_caret  # w/ no-prompt
+        lstr = text.lstrip()       # w/ no-indent
         p = self.bol + len(text) - len(lstr)
         offset = max(0, self.cpos - p)
-        indent = self.py_current_indent() # check current/previous line
+        indent = self.py_current_indent()  # check current/previous line
         if indent >= 0:
             self.Replace(self.bol, p, ' '*indent)
             self.goto_char(self.bol + indent + offset)
-    
-    @can_edit
+
+    @editable
     def py_outdent_line(self):
         """Outdent the current line."""
-        text = self.line_at_caret # w/ no-prompt
-        lstr = text.lstrip()      # w/ no-indent
+        text = self.line_at_caret  # w/ no-prompt
+        lstr = text.lstrip()       # w/ no-indent
         p = self.bol + len(text) - len(lstr)
         offset = max(0, self.cpos - p)
         indent = len(text) - len(lstr) - 4
         if indent >= 0:
             self.Replace(self.bol, p, ' '*indent)
             self.goto_char(self.bol + indent + offset)
-    
+
     def py_current_indent(self):
         """Calculate indent spaces from previous line."""
         text = self.GetLine(self.cline - 1)
-        indent = self.py_calc_indentation(text) # check previous line
+        indent = self.py_calc_indentation(text)  # check previous line
         text = self.GetLine(self.cline)
-        lstr, _indent = self.py_strip_indents(text) # check current line
+        lstr, _indent = self.py_strip_indents(text)  # check current line
         if re.match(py_outdent_re, lstr):
             indent -= 4
         return indent
-    
+
     def py_electric_indent(self):
         """Calculate indent spaces for the following line."""
-        ## [BUG 4.2.0] The last char is replaced with b'\x00'.
+        ## [BUG ver 4.2.0] The last char is replaced with b'\x00'.
         ## text, lp = self.CurLineRaw
         ## return self.py_calc_indentation(text[:lp].decode())
         text, lp = self.CurLine
         return self.py_calc_indentation(text[:lp])
-    
+
     @classmethod
     def py_calc_indentation(self, text):
-        """Returns indent spaces for the command text."""
+        """Return indent spaces for the command text."""
         text = self.py_strip_comments(text)
         lstr, indent = self.py_strip_indents(text)
         text = text.rstrip()
@@ -944,33 +1055,33 @@ class EditorInterface(AutoCompInterfaceMixin, CtrlInterface):
         if re.match(py_closing_re, lstr):
             return indent - 4
         return indent
-    
+
     @classmethod
     def py_strip_indents(self, text):
-        """Returns left-stripped text and the number of indent spaces."""
-        text = self.py_strip_prompts(text) # cf. shell.lstripPrompt(text)
+        """Return left-stripped text and the number of indent spaces."""
+        text = self.py_strip_prompts(text)  # cf. shell.lstripPrompt(text)
         lstr = text.lstrip(' \t')
         indent = len(text) - len(lstr)
         return lstr, indent
-    
+
     @classmethod
     def py_strip_prompts(self, text):
-        """Returns text without a leading prompt."""
+        """Return text without a leading prompt."""
         for ps in (sys.ps1, sys.ps2, sys.ps3):
             if text.startswith(ps):
                 text = text[len(ps):]
                 break
         return text
-    
+
     @classmethod
     def py_strip_comments(self, text):
-        """Returns text without comments."""
+        """Return text without comments."""
         return ''.join(split_tokens(text, comment=False))
-    
+
     ## --------------------------------
-    ## Fold / Unfold functions
+    ## Fold / Unfold functions.
     ## --------------------------------
-    
+
     def show_folder(self, show=True):
         """Show folder margin.
         
@@ -992,8 +1103,8 @@ class EditorInterface(AutoCompInterfaceMixin, CtrlInterface):
             self.SetMarginSensitive(2, False)
             self.SetFoldMarginColour(True, 'black')
             self.SetFoldMarginHiColour(True, 'black')
-    
-    def OnMarginClick(self, evt): #<wx._stc.StyledTextEvent>
+
+    def OnMarginClick(self, evt):  #<wx._stc.StyledTextEvent>
         lc = self.LineFromPosition(evt.Position)
         level = self.GetFoldLevel(lc) ^ stc.STC_FOLDLEVELBASE
         ## `level` indicates indent-level number
@@ -1004,8 +1115,8 @@ class EditorInterface(AutoCompInterfaceMixin, CtrlInterface):
             self.handler('select_lines', evt)
         else:
             self.handler('select_line', evt)
-    
-    def OnMarginRClick(self, evt): #<wx._stc.StyledTextEvent>
+
+    def OnMarginRClick(self, evt):  #<wx._stc.StyledTextEvent>
         """Popup context menu."""
         def _Icon(key):
             return wx.ArtProvider.GetBitmap(key, size=(16,16))
@@ -1017,26 +1128,26 @@ class EditorInterface(AutoCompInterfaceMixin, CtrlInterface):
             (wx.ID_UP, "&Expand ALL", _Icon(wx.ART_PLUS),
                 lambda v: self.FoldAll(1)),
         ])
-    
+
     def toggle_fold(self, lc):
         """Similar to ToggleFold, but the top header containing
         the specified line switches between expanded and contracted.
         """
         while 1:
-            la = self.GetFoldParent(lc) # get folding root
+            la = self.GetFoldParent(lc)  # get folding root
             if la == -1:
                 break
             lc = la
         self.ToggleFold(lc)
-        self.EnsureLineOnScreen(lc)
+        self.ensureLineOnScreen(lc)
         return lc
-    
-    def get_region(self, line):
+
+    def get_indent_region(self, line):
         """Line numbers of folding head and tail containing the line."""
         lc = line
         le = lc + 1
         while 1:
-            la = self.GetFoldParent(lc) # get folding root
+            la = self.GetFoldParent(lc)  # get folding root
             if la == -1:
                 break
             lc = la
@@ -1046,39 +1157,40 @@ class EditorInterface(AutoCompInterfaceMixin, CtrlInterface):
                 break
             le += 1
         return lc, le
-    
+
     def on_linesel_begin(self, evt):
         """Called when a line of text selection begins."""
-        self.cpos = self.anchor = evt.Position #<select_line>
+        self.cpos = self.anchor = evt.Position  #<select_line>
         self.CaptureMouse()
         evt.Skip()
-    
+
     def on_linesel_next(self, evt):
         """Called when next line of text selection begins."""
-        self.cpos = evt.Position #<select_lines>
+        self.cpos = evt.Position  #<select_lines>
         self.CaptureMouse()
         evt.Skip()
-    
+
     def on_linesel_motion(self, evt):
         """Called when a line of text selection is changing."""
         self.cpos = self.PositionFromPoint(evt.Position)
         self.EnsureCaretVisible()
         evt.Skip()
-    
+
     def on_linesel_end(self, evt):
         """Called when a line of text selection ends."""
         if self.HasCapture():
             self.ReleaseMouse()
         evt.Skip()
-    
+
     ## --------------------------------
-    ## Preferences / Appearance
+    ## Preferences / Appearance.
     ## --------------------------------
-    
+
     def get_stylus(self):
         return self.__stylus
-    
+
     def set_stylus(self, spec=None, **kwargs):
+        """Set style spec for wx.stc.StyleSetSpec."""
         spec = spec and spec.copy() or {}
         spec.update(kwargs)
         if not spec:
@@ -1089,33 +1201,38 @@ class EditorInterface(AutoCompInterfaceMixin, CtrlInterface):
         def _map(sc):
             return dict(kv.partition(':')[::2] for kv in sc.split(',') if kv)
         
-        ## Apply the default style first
+        ## Apply the default style first.
         default = spec.pop(stc.STC_STYLE_DEFAULT, '')
         if default:
             self.StyleSetSpec(stc.STC_STYLE_DEFAULT, default)
             self.StyleClearAll()
         
-        ## Add style to the folding margin
+        self.SetSelForeground(True, wx.SystemSettings.GetColour(wx.SYS_COLOUR_HIGHLIGHTTEXT))
+        self.SetSelBackground(True, wx.SystemSettings.GetColour(wx.SYS_COLOUR_HIGHLIGHT))
+        
+        ## Add style to the folding margin.
         item = _map(spec.get(stc.STC_STYLE_LINENUMBER, ''))
         if item:
-            ## Set colors used as a chequeboard pattern,
-            ## lo (back) one of the colors
-            ## hi (fore) the other color
+            ## Set colors used as a chequeboard pattern.
+            ## - lo (back) one of the colors
+            ## - hi (fore) the other color
             self.BackgroundColour = item.get('back')
             self.ForegroundColour = item.get('fore')
             if self.GetMarginWidth(2) > 1:
-                ## 12 pixel chequeboard, fore being default colour
+                ## 12 pixel chequeboard, fore being default colour.
                 self.SetFoldMarginColour(True, item.get('back'))
                 self.SetFoldMarginHiColour(True, 'light gray')
             else:
-                ## one pixel solid line, the same colour as the line number
+                ## One pixel solid line, the same colour as the line number.
                 self.SetFoldMarginColour(True, item.get('fore'))
                 self.SetFoldMarginHiColour(True, item.get('fore'))
         
-        ## Custom style for caret and line colour
+        self.SetCaretLineVisible(0)
+        self.SetCaretForeground(_map(default).get('fore'))
+        
+        ## Custom style for caret and line colour.
         item = _map(spec.pop(stc.STC_STYLE_CARETLINE, ''))
         if item:
-            self.SetCaretLineVisible(0)
             if 'fore' in item:
                 self.SetCaretForeground(item['fore'])
             if 'back' in item:
@@ -1127,10 +1244,10 @@ class EditorInterface(AutoCompInterfaceMixin, CtrlInterface):
             if 'bold' in item:
                 self.SetCaretStyle(stc.STC_CARETSTYLE_BLOCK)
         
-        ## Apply the rest of the style
+        ## Apply the rest of the style.
         for key, value in spec.items():
             self.StyleSetSpec(key, value)
-    
+
     def match_paren(self):
         self.SetIndicatorCurrent(3)
         self.IndicatorClearRange(0, self.TextLength)
@@ -1138,7 +1255,7 @@ class EditorInterface(AutoCompInterfaceMixin, CtrlInterface):
         if self.get_char(p-1) in ")}]>":
             q = self.BraceMatch(p-1)
             if q != -1:
-                self.BraceHighlight(q, p-1) # matched the preceding char
+                self.BraceHighlight(q, p-1)  # matched the preceding char
                 self.IndicatorFillRange(q, p-q)
                 return q
             else:
@@ -1146,20 +1263,20 @@ class EditorInterface(AutoCompInterfaceMixin, CtrlInterface):
         elif self.get_char(p) in "({[<":
             q = self.BraceMatch(p)
             if q != -1:
-                self.BraceHighlight(p, q) # matched the following char
+                self.BraceHighlight(p, q)  # matched the following char
                 self.IndicatorFillRange(p, q-p+1)
                 return q
             else:
                 self.BraceBadLight(p)
         else:
-            self.BraceHighlight(-1,-1) # no highlight
-    
+            self.BraceHighlight(-1,-1)  # no highlight
+
     def over(self, mode=1):
         """Set insert or overtype.
         mode in {0:insert, 1:over, None:toggle}
         """
         self.Overtype = mode if mode is not None else not self.Overtype
-    
+
     def wrap(self, mode=1):
         """Set whether text is word wrapped.
         
@@ -1167,78 +1284,141 @@ class EditorInterface(AutoCompInterfaceMixin, CtrlInterface):
                             3:whitespace-wrap, None:toggle}
         """
         self.WrapMode = mode if mode is not None else not self.WrapMode
-    
+
     def recenter(self, ln=None):
         """Scroll the cursor line to the center of screen.
         If ln=0, the cursor moves to the top of the screen.
         If ln=-1 (ln=n-1), moves to the bottom
         """
-        n = self.LinesOnScreen() # lines completely visible
-        m = n//2 if ln is None else ln % n if ln < n else n # ln[0:n]
+        n = self.LinesOnScreen()  # lines completely visible
+        m = n//2 if ln is None else ln % n if ln < n else n  # ln[0:n]
         vl = self._calc_vline(self.cline)
         self.ScrollToLine(vl - m)
-    
+
     def _calc_vline(self, line):
         """Virtual line number in the buffer window."""
         pos = self.PositionFromLine(line)
         w, h = self.PointFromPosition(pos)
-        return self.FirstVisibleLine + h//self.TextHeight(0)
-    
-    def EnsureLineOnScreen(self, line):
+        return self.FirstVisibleLine + h // self.TextHeight(line)
+
+    def ensureLineOnScreen(self, line):
         """Ensure a particular line is visible by scrolling the buffer
         without expanding any header line hiding it.
         """
-        n = self.LinesOnScreen() # lines completely visible
+        n = self.LinesOnScreen()  # lines completely visible
         hl = self.FirstVisibleLine
         vl = self._calc_vline(line)
         if vl < hl:
             self.ScrollToLine(vl)
         elif vl > hl + n - 1:
             self.ScrollToLine(vl - n + 1)
-    
-    def EnsureLineMoreOnScreen(self, line, offset=0):
+
+    def ensureLineMoreOnScreen(self, line, offset=0):
         """Ensure a particular line is visible by scrolling the buffer
         without expanding any header line hiding it.
         If the line is at the screen edge, recenter it.
         """
-        n = self.LinesOnScreen() # lines completely visible
+        n = self.LinesOnScreen()  # lines completely visible
         hl = self.FirstVisibleLine
         vl = self._calc_vline(line)
         if not hl + offset < vl < hl + n - 1 - offset:
             self.ScrollToLine(vl - n//2)
-    
+
     ## --------------------------------
-    ## Search functions
+    ## Search functions.
     ## --------------------------------
-    
+
+    def DoFindNext(self, findData):
+        """Find the search text defined in `findData`.
+        
+        If found, selects the matched text and scrolls to its line.
+        Typically called from `wx.EVT_FIND` event handlers.
+        
+        (override) Enables whole word search.
+                   Returns the match position if found, -1 otherwise.
+        """
+        flags = 0
+        if findData.Flags & wx.FR_MATCHCASE: flags |= stc.STC_FIND_MATCHCASE
+        if findData.Flags & wx.FR_WHOLEWORD: flags |= stc.STC_FIND_WHOLEWORD
+        self.SetSearchFlags(flags)
+        
+        backward = not (findData.Flags & wx.FR_DOWN)
+        findstring = findData.FindString.encode()
+        if backward:
+            self.TargetStart = self.anchor  # backward anchor
+            self.TargetEnd = 0
+        else:
+            self.TargetStart = self.cpos  # forward anchor
+            self.TargetEnd = self.TextLength
+        loc = self.SearchInTarget(findstring)
+        
+        ## If it wasn't found then restart at beginning.
+        if loc == -1:
+            self.TargetStart = self.TextLength if backward else 0
+            loc = self.SearchInTarget(findstring)
+        
+        ## Was it still not found?
+        if loc == -1:
+            # wx.MessageBox("Unable to find the search text any more.",
+            #               "Not found!", wx.OK|wx.ICON_INFORMATION)
+            wx.Bell()
+            pass
+        else:
+            self.SetSelection(loc, loc + len(findstring))
+            self.EnsureVisible(self.cline)  # expand if folded
+            self.EnsureCaretVisible()
+        return loc
+
+    def DoReplaceNext(self, findData):
+        if self.SelectedText == findData.FindString:
+            if self.CanEdit():
+                self.ReplaceSelection(findData.ReplaceString)
+        return self.DoFindNext(findData)
+
+    def DoReplaceAll(self, findData):
+        with self.save_excursion():
+            locs = [-1]
+            count = 0
+            while 1:
+                loc = self.DoFindNext(findData)
+                if loc in locs:
+                    break
+                locs.append(loc)
+                self.TargetStart = self.anchor
+                self.TargetEnd = self.cpos
+                if self.CanEdit():
+                    self.ReplaceTarget(findData.ReplaceString)
+                    count += 1
+            return count
+
     def get_right_paren(self, p):
-        if self.get_char(p) in "({[<": # left-parentheses, <
+        if self.get_char(p) in "({[<":  # left-parentheses, <
             q = self.BraceMatch(p)
             return q if q < 0 else q+1
-    
+
     def get_left_paren(self, p):
-        if self.get_char(p-1) in ")}]>": # right-parentheses, >
+        if self.get_char(p-1) in ")}]>":  # right-parentheses, >
             q = self.BraceMatch(p-1)
             return q
-    
+
     def get_right_quotation(self, p):
         st = self.get_style(p)
         if st == 'moji':
-            if self.get_style(p-1) == 'moji': # inside string
+            if self.get_style(p-1) == 'moji':  # inside string
                 return
             while self.get_style(p) == st and p < self.TextLength:
                 p += 1
             return p
-    
+
     def get_left_quotation(self, p):
         st = self.get_style(p-1)
         if st == 'moji':
-            if self.get_style(p) == 'moji': # inside string
+            if self.get_style(p) == 'moji':  # inside string
                 return
             while self.get_style(p-1) == st and p > 0:
                 p -= 1
             return p
-    
+
     def get_following_atom(self, p):
         q = p
         st = self.get_style(p)
@@ -1246,15 +1426,15 @@ class EditorInterface(AutoCompInterfaceMixin, CtrlInterface):
             q = self.BraceMatch(p)
             if q == -1:
                 q = self.TextLength
-                st = None # no closing paren
+                st = None  # no closing paren
             else:
                 q += 1
-                st = 'paren' # closed
+                st = 'paren'  # closed
         else:
             while self.get_style(q) == st and q < self.TextLength:
                 q += 1
         return p, q, st
-    
+
     def get_preceding_atom(self, p):
         q = p
         st = self.get_style(p-1)
@@ -1262,14 +1442,14 @@ class EditorInterface(AutoCompInterfaceMixin, CtrlInterface):
             p = self.BraceMatch(p-1)
             if p == -1:
                 p = 0
-                st = None # no closing paren
+                st = None  # no closing paren
             else:
-                st = 'paren' # closed
+                st = 'paren'  # closed
         else:
             while self.get_style(p-1) == st and p > 0:
                 p -= 1
         return p, q, st
-    
+
     def grep_forward(self, pattern, flags=re.M):
         orig = self.eol if (self.markline == self.cline) else self.cpos
         text = self.GetTextRange(orig, self.TextLength)
@@ -1281,7 +1461,7 @@ class EditorInterface(AutoCompInterfaceMixin, CtrlInterface):
             self.mark = self.cpos
             self.EnsureVisible(self.cline)
             yield err
-    
+
     def grep_backward(self, pattern, flags=re.M):
         text = self.GetTextRange(0, self.cpos)
         errs = re.finditer(pattern, text, flags)
@@ -1292,47 +1472,43 @@ class EditorInterface(AutoCompInterfaceMixin, CtrlInterface):
             self.mark = self.cpos
             self.EnsureVisible(self.cline)
             yield err
-    
+
     def grep(self, pattern, flags=re.M):
         yield from re.finditer(pattern.encode(), self.TextRaw, flags)
-    
-    def search_text(self, text):
-        """Yields raw-positions where `text` is found."""
-        word = text.encode()
-        raw = self.TextRaw
-        pos = -1
-        while 1:
-            pos = raw.find(word, pos+1)
-            if pos < 0:
-                break
-            yield pos
-    
-    def filter_text(self, text=None):
+
+    def filter_text(self):
         """Show indicators for the selected text."""
         self.__itextlines = []
         for i in (10, 11,):
             self.SetIndicatorCurrent(i)
             self.IndicatorClearRange(0, self.TextLength)
-        if text is None:
-            text = self.topic_at_caret
+        text = self.topic_at_caret
         if not text:
             self.message("No words")
             return
-        
-        lw = len(text.encode()) # for multi-byte string
+        wholeword = (not self.SelectedText  # Enable or disable whole word search.
+                     and text.isascii())    # whole word search is for ascii only. (単語境界が不明確のため)
+        pattern = re.escape(text)
+        if wholeword:
+            pattern = rf"\b{pattern}\b"
         lines = []
-        for p in self.search_text(text):
+        for m in self.grep(pattern):
+            p, q = m.span()
             lines.append(self.LineFromPosition(p))
             for i in (10, 11,):
                 self.SetIndicatorCurrent(i)
-                self.IndicatorFillRange(p, lw)
-        self.__itextlines = sorted(set(lines)) # keep order, no duplication
+                self.IndicatorFillRange(p, q-p)
+        self.__itextlines = sorted(set(lines))  # keep order, no duplication
         self.message("{}: {} found".format(text, len(lines)))
         try:
             self.TopLevelParent.findData.FindString = text
+            if wholeword:
+                self.TopLevelParent.findData.Flags |= wx.FR_WHOLEWORD
+            else:
+                self.TopLevelParent.findData.Flags &= ~wx.FR_WHOLEWORD
         except AttributeError:
             pass
-    
+
     def on_itext_enter(self, evt):
         """Called when entering filter_text mode."""
         if not self.__itextlines:
@@ -1342,22 +1518,22 @@ class EditorInterface(AutoCompInterfaceMixin, CtrlInterface):
         def _format(ln):
             return "{:4d} {}".format(ln+1, self.GetLine(ln).strip())
         
-        pts = self.StyleGetSize(stc.STC_STYLE_DEFAULT)
-        self.StyleSetSize(stc.STC_STYLE_DEFAULT, pts-1)
+        # pts = self.StyleGetSize(stc.STC_STYLE_DEFAULT)
+        # self.StyleSetSize(stc.STC_STYLE_DEFAULT, pts-1)
         
         self.AutoCompSetSeparator(ord('\n'))
         self.AutoCompShow(0, '\n'.join(map(_format, self.__itextlines)))
         self.AutoCompSelect("{:4d}".format(self.cline+1))
         self.Bind(stc.EVT_STC_AUTOCOMP_SELECTION, self.on_itext_selection)
         
-        self.StyleSetSize(stc.STC_STYLE_DEFAULT, pts)
-    
+        # self.StyleSetSize(stc.STC_STYLE_DEFAULT, pts)
+
     def on_itext_exit(self, evt):
         """Called when exiting filter_text mode."""
         if self.AutoCompActive():
             self.AutoCompCancel()
         self.Unbind(stc.EVT_STC_AUTOCOMP_SELECTION, handler=self.on_itext_selection)
-    
+
     def on_itext_selection(self, evt):
         """Called when filter_text is selected."""
         i = self.AutoCompGetCurrent()
@@ -1365,15 +1541,15 @@ class EditorInterface(AutoCompInterfaceMixin, CtrlInterface):
             evt.Skip()
             return
         line = self.__itextlines[i]
-        self.EnsureVisible(line) # expand if folded
+        self.EnsureVisible(line)  # expand if folded
         self.goto_line(line)
         self.recenter()
         self.on_itext_exit(evt)
-    
+
     ## --------------------------------
     ## goto / skip / selection / etc.
     ## --------------------------------
-    
+
     def goto_char(self, pos, selection=False, interactive=False):
         """Goto char position with selection."""
         if pos is None or pos < 0:
@@ -1388,7 +1564,7 @@ class EditorInterface(AutoCompInterfaceMixin, CtrlInterface):
             
             if interactive:
                 ## Update the caret position/status manually.
-                ## To update caret status, shake L/R w/o modifier
+                ## To update caret status, shake L/R w/o modifier.
                 ## Don't do this if selection is active.
                 vk = wx.UIActionSimulator()
                 modkeys = [k for k in (wx.WXK_CONTROL, wx.WXK_ALT, wx.WXK_SHIFT)
@@ -1402,74 +1578,74 @@ class EditorInterface(AutoCompInterfaceMixin, CtrlInterface):
                     vk.KeyDown(wx.WXK_LEFT)
                     vk.KeyDown(wx.WXK_RIGHT)
                 for k in modkeys:
-                    vk.KeyDown(k) # restore modifier key state
+                    vk.KeyDown(k)  # restore modifier key state
         return True
-    
+
     def goto_line(self, ln, selection=False):
         """Goto line with selection."""
         if ln is None or ln < 0:
             return
-        ## if ln < 0:
-        ##     ln += self.LineCount
+        # if ln < 0:
+        #     ln += self.LineCount
         if selection:
             self.cline = ln
         else:
             self.GotoLine(ln)
         return True
-    
+
     def skip_chars_forward(self, chars):
         p = self.cpos
         while self.get_char(p) in chars and p < self.TextLength:
             p += 1
         self.goto_char(p)
-    
+
     def skip_chars_backward(self, chars):
         p = self.cpos
         while self.get_char(p-1) in chars and p > 0:
             p -= 1
         self.goto_char(p)
-    
+
     def back_to_indentation(self):
-        text = self.line_at_caret # w/ no-prompt
-        lstr = text.lstrip()      # w/ no-indent
+        text = self.line_at_caret  # w/ no-prompt
+        lstr = text.lstrip()       # w/ no-indent
         p = self.bol + len(text) - len(lstr)
         self.goto_char(p, interactive=True)
         self.ScrollToColumn(0)
-    
+
     def beginning_of_line(self):
         self.goto_char(self.bol, interactive=True)
         self.ScrollToColumn(0)
-    
+
     def end_of_line(self):
         self.goto_char(self.eol, interactive=True)
-    
+
     def beginning_of_buffer(self):
         self.mark = self.cpos
         self.goto_char(0, interactive=True)
-    
+
     def end_of_buffer(self):
         self.mark = self.cpos
         self.goto_char(self.TextLength, interactive=True)
-    
+
     def goto_matched_paren(self):
         p = self.cpos
         return (self.goto_char(self.get_left_paren(p))
              or self.goto_char(self.get_right_paren(p))
              or self.goto_char(self.get_left_quotation(p))
              or self.goto_char(self.get_right_quotation(p)))
-    
+
     def selection_forward_word_or_paren(self):
         p = self.cpos
         return (self.goto_char(self.get_right_paren(p), selection=True)
              or self.goto_char(self.get_right_quotation(p), selection=True)
              or self.WordRightEndExtend())
-    
+
     def selection_backward_word_or_paren(self):
         p = self.cpos
         return (self.goto_char(self.get_left_paren(p), selection=True)
              or self.goto_char(self.get_left_quotation(p), selection=True)
              or self.WordLeftExtend())
-    
+
     @contextmanager
     def save_excursion(self):
         """Save buffer excursion."""
@@ -1482,7 +1658,7 @@ class EditorInterface(AutoCompInterfaceMixin, CtrlInterface):
             self.GotoPos(p)
             self.ScrollToLine(vpos)
             self.SetXOffset(hpos)
-    
+
     @contextmanager
     def pre_selection(self):
         """Save buffer cpos and anchor."""
@@ -1495,7 +1671,7 @@ class EditorInterface(AutoCompInterfaceMixin, CtrlInterface):
                 self.cpos = p
             else:
                 self.anchor = q
-    
+
     @contextmanager
     def save_attributes(self, **kwargs):
         """Save buffer attributes (e.g. ReadOnly=False)."""
@@ -1507,50 +1683,48 @@ class EditorInterface(AutoCompInterfaceMixin, CtrlInterface):
         finally:
             for k, v in kwargs.items():
                 setattr(self, k, v)
-    
+
     def off_readonly(self):
         """Disables buffer read-only lock temporarily."""
         return self.save_attributes(ReadOnly=False)
-    
+
     def off_undocollection(self):
         """Disables buffer undo stack temporarily."""
         return self.save_attributes(UndoCollection=False)
-    
+
     ## --------------------------------
-    ## Edit: comment / insert / kill
+    ## Edit: comment / insert / kill.
     ## --------------------------------
-    comment_prefix = "## "
-    
-    @can_edit
+    comment_prefix = "#"
+
+    @editable
     def comment_out_selection(self, from_=None, to_=None):
         """Comment out the selected text."""
         if from_ is not None: self.anchor = from_
         if to_ is not None: self.cpos = to_
-        prefix = self.comment_prefix
         with self.pre_selection():
-            text = re.sub("^", prefix, self.SelectedText, flags=re.M)
-            ## Don't comment out the last (blank) line.
-            lines = text.splitlines()
-            if len(lines) > 1 and lines[-1].endswith(prefix):
-                text = text[:-len(prefix)]
+            text = re.sub("^", self.comment_prefix + ' ', self.SelectedText, flags=re.M)
+            ## Don't comment out the last (blank) line in a multiline selection.
+            if '\n' in text:
+                text = text.rstrip(self.comment_prefix + ' ')
             self.ReplaceSelection(text)
-    
-    @can_edit
+
+    @editable
     def uncomment_selection(self, from_=None, to_=None):
         """Uncomment the selected text."""
         if from_ is not None: self.anchor = from_
         if to_ is not None: self.cpos = to_
         with self.pre_selection():
-            text = re.sub("^#+ ", "", self.SelectedText, flags=re.M)
+            text = re.sub(f"^{self.comment_prefix}+ ", "", self.SelectedText, flags=re.M)
             if text != self.SelectedText:
                 self.ReplaceSelection(text)
-    
-    @can_edit
+
+    @editable
     def comment_out_line(self):
         if self.SelectedText:
             self.comment_out_selection()
         else:
-            ## align with current or previous indent position
+            ## Align with current or previous indent position.
             self.back_to_indentation()
             text = self.GetLine(self.cline - 1)
             lstr, j = self.py_strip_indents(text)
@@ -1560,8 +1734,8 @@ class EditorInterface(AutoCompInterfaceMixin, CtrlInterface):
                 self.goto_char(self.bol + min(j, k))
             self.comment_out_selection(self.cpos, self.eol)
             self.LineDown()
-    
-    @can_edit
+
+    @editable
     def uncomment_line(self):
         if self.SelectedText:
             self.uncomment_selection()
@@ -1569,36 +1743,58 @@ class EditorInterface(AutoCompInterfaceMixin, CtrlInterface):
             self.back_to_indentation()
             self.uncomment_selection(self.cpos, self.eol)
             self.LineDown()
-    
-    @can_edit
+
+    @editable
     def eat_white_forward(self):
         p = self.cpos
         self.skip_chars_forward(' \t')
         self.Replace(p, self.cpos, '')
-    
-    @can_edit
+
+    @editable
     def eat_white_backward(self):
         p = self.cpos
         self.skip_chars_backward(' \t')
         self.Replace(max(self.cpos, self.bol), p, '')
-    
-    @can_edit
+
+    @editable
+    def kill_word(self):
+        if not self.SelectedText:
+            self.WordRightEndExtend()
+        self.ReplaceSelection('')
+
+    @editable
+    def backward_kill_word(self):
+        if not self.SelectedText:
+            self.WordLeftExtend()
+        self.ReplaceSelection('')
+
+    @editable
     def kill_line(self):
-        p = self.eol
-        if p == self.cpos: # caret at end of line
-            if self.get_char(p) == '\r': p += 1
-            if self.get_char(p) == '\n': p += 1
-        self.Replace(self.cpos, p, '')
-    
-    @can_edit
+        if not self.SelectedText:
+            p = self.cpos
+            if p == self.eol:
+                ## self.WordRightEndExtend()  # Select cr/lf chunks.
+                if self.get_char(p) == '\r': p += 1
+                if self.get_char(p) == '\n': p += 1
+                self.cpos = p
+            else:
+                self.cpos = self.eol
+        self.ReplaceSelection('')
+
+    @editable
     def backward_kill_line(self):
-        p = self.bol
-        if p == self.cpos > 0: # caret at beginning of line
-            if self.get_char(p-1) == '\n': p -= 1
-            if self.get_char(p-1) == '\r': p -= 1
-        self.Replace(p, self.cpos, '')
-    
-    @can_edit
+        if not self.SelectedText:
+            p = self.cpos
+            if p == self.bol:
+                ## self.WordLeftExtend()  # Select cr/lf chunks.
+                if self.get_char(p-1) == '\n': p -= 1
+                if self.get_char(p-1) == '\r': p -= 1
+                self.cpos = p
+            else:
+                self.cpos = self.bol
+        self.ReplaceSelection('')
+
+    @editable
     def insert_space_like_tab(self):
         """Insert half-width spaces forward as if feeling like [tab].
         タブの気持ちになって半角スペースを入力する
@@ -1606,15 +1802,15 @@ class EditorInterface(AutoCompInterfaceMixin, CtrlInterface):
         self.eat_white_forward()
         _text, lp = self.CurLine
         self.WriteText(' ' * (4 - lp % 4))
-    
-    @can_edit
+
+    @editable
     def delete_backward_space_like_tab(self):
         """Delete half-width spaces backward as if feeling like [S-tab].
         シフト+タブの気持ちになって半角スペースを消す
         """
         self.eat_white_forward()
         _text, lp = self.CurLine
-        for i in range(lp % 4 or 4):
+        for _i in range(lp % 4 or 4):
             p = self.cpos
             if p == self.bol or self.get_char(p-1) != ' ':
                 break
@@ -1624,78 +1820,71 @@ class EditorInterface(AutoCompInterfaceMixin, CtrlInterface):
 
 class Buffer(EditorInterface, EditWindow):
     """Python code buffer.
-    
-    Attributes:
-        name     : buffer-name (basename)
-        filename : buffer-file-name
-        code     : code object
     """
-    STYLE = {
-        stc.STC_STYLE_DEFAULT     : "fore:#7f7f7f,back:#ffffb8,size:9,face:MS Gothic",
-        stc.STC_STYLE_LINENUMBER  : "fore:#000000,back:#ffffb8,size:9",
-        stc.STC_STYLE_BRACELIGHT  : "fore:#000000,back:#ffffb8,bold",
-        stc.STC_STYLE_BRACEBAD    : "fore:#000000,back:#ff0000,bold",
-        stc.STC_STYLE_CONTROLCHAR : "size:6",
-        stc.STC_STYLE_CARETLINE   : "fore:#000000,back:#ffff7f,size:2", # optional
-        stc.STC_STYLE_ANNOTATION  : "fore:#7f0000,back:#ff7f7f", # optional
-        stc.STC_P_DEFAULT         : "fore:#000000",
-        stc.STC_P_OPERATOR        : "fore:#000000",
-        stc.STC_P_IDENTIFIER      : "fore:#000000",
-        stc.STC_P_COMMENTLINE     : "fore:#007f7f,back:#ffcfcf",
-        stc.STC_P_COMMENTBLOCK    : "fore:#007f7f,back:#ffcfcf,eol",
-        stc.STC_P_NUMBER          : "fore:#7f0000",
-        stc.STC_P_STRINGEOL       : "fore:#000000,back:#ffcfcf",
-        stc.STC_P_CHARACTER       : "fore:#7f7f7f",
-        stc.STC_P_STRING          : "fore:#7f7f7f",
-        stc.STC_P_TRIPLE          : "fore:#7f7f7f",
-        stc.STC_P_TRIPLEDOUBLE    : "fore:#7f7f7f",
-        stc.STC_P_CLASSNAME       : "fore:#7f00ff,bold",
-        stc.STC_P_DEFNAME         : "fore:#0000ff,bold",
-        stc.STC_P_WORD            : "fore:#0000ff",
-        stc.STC_P_WORD2           : "fore:#b8007f",
-        stc.STC_P_DECORATOR       : "fore:#e08040",
-    }
-    
     @property
     def message(self):
         return self.parent.message
-    
+
     @property
     def name(self):
+        """buffer-name (basename)."""
         return os.path.basename(self.__filename or '')
-    
-    Name = name # page.window.Name for save/loadPerspective
-    
+
+    Name = name  # page.window.Name for save/loadPerspective
+
     @property
     def filename(self):
+        """buffer-file-name."""
         return self.__filename
-    
+
     def update_filestamp(self, fn):
-        if fn and os.path.isfile(fn):
-            self.__mtime = os.path.getmtime(fn) # update timestamp (modified time)
-        else:
-            self.__mtime = None
+        self.__path = Path(fn)
+        try:
+            self.__mtime = os.path.getmtime(self.__path)  # update timestamp (modified time)
+        except FileNotFoundError:
+            self.__mtime = False  # valid path (but not found)
+        except OSError:
+            if re.match(url_re, fn):
+                self.__mtime = -1
+            else:
+                self.__mtime = None  # *invalid path*
         if self.__filename != fn:
             self.__filename = fn
             self.update_caption()
-    
+
     @property
     def mtdelta(self):
         """Timestamp delta (for checking external mod).
         
         Returns:
-            None : no file
-            = 0  : a file
-            > 0  : a file edited externally
-            < 0  : a url file
+            None: no file
+            = 0:  a file (even if not found)
+            > 0:  a file edited externally
+            < 0:  a url file
         """
-        fn = self.filename
-        if os.path.isfile(fn):
-            return os.path.getmtime(fn) - self.__mtime
-        if re.match(url_re, fn):
-            return -1
-        return None
-    
+        try:
+            mtime = os.path.getmtime(self.__path)
+            return mtime - self.__mtime
+        except FileNotFoundError:
+            self.__mtime = False  # valid path (but not found)
+        except OSError:
+            pass
+        return self.__mtime
+
+    @property
+    def need_buffer_save(self):
+        """Return whether the buffer should be saved.
+        The file has been modified internally.
+        """
+        return self.mtdelta is not None and self.IsModified()
+
+    @property
+    def need_buffer_load(self):
+        """Return whether the buffer should be loaded.
+        The file has been modified externally.
+        """
+        return self.mtdelta is not None and self.mtdelta > 0
+
     @property
     def caption_prefix(self):
         prefix = ''
@@ -1710,7 +1899,7 @@ class Buffer(EditorInterface, EditWindow):
         if prefix:
             prefix += ' '
         return prefix
-    
+
     def update_caption(self):
         caption = self.caption_prefix + self.name
         try:
@@ -1718,31 +1907,7 @@ class Buffer(EditorInterface, EditWindow):
                 self.parent.handler('buffer_caption_updated', self)
         except AttributeError:
             pass
-    
-    @property
-    def need_buffer_save(self):
-        """Returns whether the buffer should be saved.
-        The file has been modified internally.
-        """
-        return self.mtdelta is not None and self.IsModified()
-    
-    @property
-    def need_buffer_load(self):
-        """Returns whether the buffer should be loaded.
-        The file has been modified externally.
-        """
-        return self.mtdelta is not None and self.mtdelta > 0
-    
-    def pre_command_hook(self, evt):
-        self.parent.handler(self.handler.current_event, evt)
-        return EditorInterface.pre_command_hook(self, evt)
-    pre_command_hook.__name__ = str('pre_command_dispatch') # alias
-    
-    def post_command_hook(self, evt):
-        self.parent.handler(self.handler.current_event, evt)
-        return EditorInterface.post_command_hook(self, evt)
-    post_command_hook.__name__ = str('post_command_dispatch') # alias
-    
+
     def __init__(self, parent, filename, **kwargs):
         EditWindow.__init__(self, parent, **kwargs)
         EditorInterface.__init__(self)
@@ -1752,7 +1917,7 @@ class Buffer(EditorInterface, EditWindow):
         self.update_filestamp(filename)
         self.code = None
         
-        self.Bind(stc.EVT_STC_UPDATEUI, self.OnUpdate) # skip to brace matching
+        self.Bind(stc.EVT_STC_UPDATEUI, self.OnUpdate)  # skip to brace matching
         self.Bind(stc.EVT_STC_CALLTIP_CLICK, self.OnCallTipClick)
         self.Bind(stc.EVT_STC_INDICATOR_CLICK, self.OnIndicatorClick)
         
@@ -1773,19 +1938,10 @@ class Buffer(EditorInterface, EditWindow):
         
         def clear(evt):
             ## """Clear selection and message, no skip."""
-            ## *do not* clear autocomp, so that the event can skip to AutoComp properly.
+            ## *DO NOT* clear autocomp, so that the event can skip to AutoComp properly.
             if self.CanEdit():
                 with self.off_undocollection():
-                    self.ReplaceSelection("")
-            self.message("")
-        
-        def clear_autocomp(evt):
-            ## """Clear autocomp, selection, and message."""
-            if self.AutoCompActive():
-                self.AutoCompCancel()
-            if self.CanEdit():
-                with self.off_undocollection():
-                    self.ReplaceSelection("")
+                    self.ReplaceSelection('')
             self.message("")
         
         def fork(evt):
@@ -1795,16 +1951,16 @@ class Buffer(EditorInterface, EditWindow):
             """Fork events to the parent."""
             self.parent.handler(self.handler.current_event, evt)
         
-        ## Note: Key events are not propagated from Buffer to EditorBook.
+        ## Note: Mouse events are not propagated from Buffer to EditorBook.
         ## They are explicitly dispatched from buffer.handler to editor.handler.
         
         self.handler.update({ # DNA<Buffer>
             None : {
                  'buffer_saved' : [ None, dispatch ],
                 'buffer_loaded' : [ None, dispatch ],
-              'buffer_modified' : [ None, dispatch, self.on_modified ],
-             'buffer_activated' : [ None, dispatch, self.on_activated ],
-           'buffer_inactivated' : [ None, dispatch, self.on_inactivated ],
+              'buffer_modified' : [ None, dispatch, self.on_buffer_modified ],
+             'buffer_activated' : [ None, dispatch, self.on_buffer_activated ],
+           'buffer_inactivated' : [ None, dispatch, self.on_buffer_inactivated ],
        'buffer_region_executed' : [ None, dispatch ],
             },
             -1 : { # original action of the EditWindow
@@ -1815,20 +1971,24 @@ class Buffer(EditorInterface, EditWindow):
              '*[LR]win pressed' : (-1, ),
             },
             0 : { # Normal mode
-                    '* pressed' : (0, skip, dispatch),
+                    '* pressed' : (0, skip),
                    '* released' : (0, skip, dispatch),
+             '*button* pressed' : (0, skip, dispatch),
+              'Lbutton pressed' : (0, self.on_left_down),
                'escape pressed' : (-1, self.on_enter_escmap),
                   'C-h pressed' : (0, self.call_helpTip),
                     '. pressed' : (2, self.OnEnterDot),
+                  'C-. pressed' : (2, self.call_word_autocomp),
+                  'C-/ pressed' : (3, self.call_apropos_autocomp),
                   'M-. pressed' : (2, self.call_word_autocomp),
                   'M-/ pressed' : (3, self.call_apropos_autocomp),
             },
             2 : { # word auto completion AS-mode
-                         'quit' : (0, clear_autocomp),
-                    '* pressed' : (0, clear_autocomp, fork),
+                         'quit' : (0, self.clear_autocomp),
+                    '* pressed' : (0, self.clear_autocomp, fork),
                   'tab pressed' : (0, clear, skip),
                 'enter pressed' : (0, clear, skip),
-               'escape pressed' : (0, clear_autocomp),
+               'escape pressed' : (0, clear, skip),
                    'up pressed' : (2, skip, self.on_completion_backward),
                  'down pressed' : (2, skip, self.on_completion_forward),
                 '*left pressed' : (2, skip),
@@ -1843,7 +2003,7 @@ class Buffer(EditorInterface, EditWindow):
               '*delete pressed' : (2, skip),
            '*backspace pressed' : (2, skip),
           '*backspace released' : (2, self.call_word_autocomp),
-        'C-S-backspace pressed' : (2, ),
+         '*S-backspace pressed' : (0, self.clear_autocomp, fork),
                  '*alt pressed' : (2, ),
                 '*ctrl pressed' : (2, ),
                '*shift pressed' : (2, ),
@@ -1851,11 +2011,11 @@ class Buffer(EditorInterface, EditWindow):
              '*f[0-9]* pressed' : (2, ),
             },
             3 : { # apropos auto completion AS-mode
-                         'quit' : (0, clear_autocomp),
-                    '* pressed' : (0, clear_autocomp, fork),
+                         'quit' : (0, self.clear_autocomp),
+                    '* pressed' : (0, self.clear_autocomp, fork),
                   'tab pressed' : (0, clear, skip),
                 'enter pressed' : (0, clear, skip),
-               'escape pressed' : (0, clear_autocomp),
+               'escape pressed' : (0, clear, skip),
                    'up pressed' : (3, skip, self.on_completion_backward),
                  'down pressed' : (3, skip, self.on_completion_forward),
                 '*left pressed' : (3, skip),
@@ -1870,7 +2030,7 @@ class Buffer(EditorInterface, EditWindow):
               '*delete pressed' : (3, skip),
            '*backspace pressed' : (3, skip),
           '*backspace released' : (3, self.call_apropos_autocomp),
-        'C-S-backspace pressed' : (3, ),
+         '*S-backspace pressed' : (0, self.clear_autocomp, fork),
                  '*alt pressed' : (3, ),
                 '*ctrl pressed' : (3, ),
                '*shift pressed' : (3, ),
@@ -1880,104 +2040,119 @@ class Buffer(EditorInterface, EditWindow):
         })
         
         self.show_folder()
-        self.set_stylus(self.STYLE)
-    
+        self.set_stylus(Stylus.py_text_mode)
+
     def __contains__(self, code):
         if inspect.iscode(code) and self.code:
             return code is self.code\
                 or code in self.code.co_consts
-    
+
     def trace_position(self):
         _text, lp = self.CurLine
         self.message("{:>6d}:{} ({})".format(self.cline, lp, self.cpos), pane=-1)
-    
-    def OnUpdate(self, evt): #<wx._stc.StyledTextEvent>
+
+    def OnUpdate(self, evt):  #<wx._stc.StyledTextEvent>
         if evt.Updated & (stc.STC_UPDATE_SELECTION | stc.STC_UPDATE_CONTENT):
             self.trace_position()
             if evt.Updated & stc.STC_UPDATE_CONTENT:
                 self.handler('buffer_modified', self)
         evt.Skip()
-    
-    def OnCallTipClick(self, evt): #<wx._stc.StyledTextEvent>
+
+    def OnCallTipClick(self, evt):  #<wx._stc.StyledTextEvent>
         if self.CallTipActive():
             self.CallTipCancel()
         pos, tip, more = self._calltips
         if more:
             self.CallTipShow(pos, tip, N=None)
         evt.Skip()
-    
-    def OnIndicatorClick(self, evt): #<wx._stc.StyledTextEvent>
+
+    def OnIndicatorClick(self, evt):  #<wx._stc.StyledTextEvent>
         if self.SelectedText or not wx.GetKeyState(wx.WXK_CONTROL):
-            ## Processing text selection, dragging, or dragging+
+            ## Processing text selection or dragging.
             evt.Skip()
             return
+        
         pos = evt.Position
+        self.goto_char(pos)
         i = 2
-        if self.IndicatorValueAt(i, pos): # [C-indic click]
+        if self.IndicatorValueAt(i, pos):  # [C-indic click]
             p = self.IndicatorStart(i, pos)
             q = self.IndicatorEnd(i, pos)
             url = self.GetTextRange(p, q).strip()
-            self.message("URL {!r}".format(url))
-            if wx.GetKeyState(wx.WXK_SHIFT): # [C-S-indic click]
+            if wx.GetKeyState(wx.WXK_SHIFT):  # [C-S-indic click]
                 import webbrowser
                 return webbrowser.open(url)
             else:
                 ## Note: post-call for the confirmation dialog.
                 wx.CallAfter(self.parent.load_file, url)
-        self.anchor = pos # Clear selection
-    
-    def on_modified(self, buf):
+
+    def on_buffer_modified(self, buf):
         """Called when the buffer is modified."""
         self.SetIndicatorCurrent(2)
         self.IndicatorClearRange(0, self.TextLength)
         for m in self.grep(url_re):
             p, q = m.span()
             self.IndicatorFillRange(p, q-p)
-    
+
     def OnSavePointLeft(self, evt):
         self.update_caption()
         evt.Skip()
-    
+
     def OnSavePointReached(self, evt):
         self.update_caption()
         evt.Skip()
-    
+
     def OnEnterDot(self, evt):
+        if not self.CanEdit():
+            self.handler('quit', evt)
+            return
         p = self.cpos
-        st = self.get_style(p-1)
+        lst = self.get_style(p-1)
         rst = self.get_style(p)
-        if st not in ('moji', 'word', 'rparen') or rst == 'word':
-            self.handler('quit', evt) # don't enter autocomp
+        if lst not in ('moji', 'word', 'rparen') or rst == 'word':
+            self.handler('quit', evt)  # Don't enter autocomp
         evt.Skip()
-    
-    def on_activated(self, buf):
+
+    def on_buffer_activated(self, buf):
         """Called when the buffer is activated."""
         self.update_caption()
         self.trace_position()
-    
-    def on_inactivated(self, buf):
+
+    def on_buffer_inactivated(self, buf):
         """Called when the buffer is inactivated."""
         pass
-    
+
+    def on_left_down(self, evt):
+        pos = self.PositionFromPoint(evt.Position)
+        ln = self.LineFromPosition(pos)
+        ann_text = self.AnnotationGetText(ln)
+        if ann_text:
+            if pos == self.GetLineEndPosition(ln):  # Check eol (not clicked yet).
+                if wx.TheClipboard.Open():
+                    wx.TheClipboard.SetData(wx.TextDataObject(ann_text))
+                    wx.TheClipboard.Close()
+                    self.message("Annotation copied.")
+                self.AnnotationClearLine(ln)
+        evt.Skip()
+
     def on_enter_escmap(self, evt):
         self.message("ESC-")
-    
+
     def on_exit_escmap(self, evt):
         self.message("ESC {}".format(evt.key))
         self.AnnotationClearAll()
-    
+
     ## --------------------------------
-    ## File I/O
+    ## File I/O.
     ## --------------------------------
-    
-    def _load_textfile(self, text, filename):
+
+    def _load_textfile(self, text):
         with self.off_readonly():
             self.Text = text
             self.EmptyUndoBuffer()
             self.SetSavePoint()
-        self.update_filestamp(filename)
         self.handler('buffer_loaded', self)
-    
+
     def _load_file(self, filename):
         """Wrapped method of LoadFile."""
         if self.LoadFile(filename):
@@ -1987,7 +2162,7 @@ class Buffer(EditorInterface, EditWindow):
             self.handler('buffer_loaded', self)
             return True
         return False
-    
+
     def _save_file(self, filename):
         """Wrapped method of SaveFile."""
         if self.SaveFile(filename):
@@ -1996,7 +2171,7 @@ class Buffer(EditorInterface, EditWindow):
             self.handler('buffer_saved', self)
             return True
         return False
-    
+
     def LoadFile(self, filename):
         """Load the contents of file into the editor.
         
@@ -2006,7 +2181,7 @@ class Buffer(EditorInterface, EditWindow):
             with self.off_readonly():
                 self.Text = i.read()
         return True
-    
+
     def SaveFile(self, filename):
         """Write the contents of the editor to file.
         
@@ -2015,37 +2190,38 @@ class Buffer(EditorInterface, EditWindow):
         with open(filename, "w", encoding='utf-8', newline='') as o:
             o.write(self.Text)
         return True
-    
+
     ## --------------------------------
-    ## Python eval / exec
+    ## Python eval / exec.
     ## --------------------------------
-    
+
     @property
-    def locals(self): # internal use only
+    def locals(self):  # internal use only
         try:
             return self.parent.parent.current_shell.locals
         except AttributeError:
             return None
-    
+
     @property
-    def globals(self): # internal use only
+    def globals(self):  # internal use only
         try:
             return self.parent.parent.current_shell.globals
         except AttributeError:
             return None
-    
+
     def eval(self, text):
-        return eval(text, self.globals, self.locals) # using current shell namespace
-    
+        return eval(text, self.globals, self.locals)  # using current shell namespace
+
     def exec(self, text):
-        exec(text, self.globals, self.locals) # using current shell namespace
+        exec(text, self.globals, self.locals)  # using current shell namespace
         dispatcher.send(signal='Interpreter.push',
                         sender=self, command=None, more=False)
-    
-    def gen_text_at_caret(self):
-        """Generates the selected text,
-        otherwise the line or expression at the caret.
-        """
+
+    def eval_line(self):
+        """Evaluate the selected word or line and show calltips."""
+        if self.CallTipActive():
+            self.CallTipCancel()
+        
         def _gen_text():
             text = self.SelectedText
             if text:
@@ -2053,61 +2229,47 @@ class Buffer(EditorInterface, EditWindow):
             else:
                 yield self.line_at_caret
                 yield self.expr_at_caret
-        return filter(None, _gen_text())
-    
-    def eval_line(self):
-        self.py_eval_line(self.globals, self.locals)
-    
-    def py_eval_line(self, globals=None, locals=None):
-        if self.CallTipActive():
-            self.CallTipCancel()
         
-        status = "No words"
-        for text in self.gen_text_at_caret():
+        for text in _gen_text():
             try:
-                obj = eval(text, globals, locals)
+                obj = eval(text, self.globals, self.locals)
             except Exception as e:
-                status = "- {} : {!r}".format(e, text)
+                self.message(e)
             else:
                 self.CallTipShow(self.cpos, pformat(obj))
                 self.message(text)
                 return
-        self.message(status)
-    
+        if not text:
+            self.message("No words")
+
     def exec_region(self):
-        self.py_exec_region(self.globals, self.locals)
-    
-    def py_exec_region(self, globals=None, locals=None, filename=None):
-        if not filename:
-            filename = self.filename
+        """Execute a region of code."""
         try:
-            code = compile(self.Text, filename, "exec")
-            exec(code, globals, locals)
+            code = compile(self.Text, self.filename, "exec")
+            exec(code, self.globals, self.locals)
             dispatcher.send(signal='Interpreter.push',
                             sender=self, command=None, more=False)
         except BdbQuit:
-            self.red_pointer = self.cline
             pass
         except Exception as e:
             msg = traceback.format_exc()
-            err = re.findall(py_error_re, msg, re.M)
-            lines = [int(ln) for fn, ln in err if fn == filename]
+            err = re.findall(py_trace_re, msg, re.M)
+            lines = [int(ln) for fn, ln in err if fn == self.filename]
             if lines:
                 lx = lines[-1] - 1
                 self.red_arrow = lx
                 self.goto_line(lx)
-                self.EnsureVisible(lx) # expand if folded
+                self.EnsureVisible(lx)  # expand if folded
                 self.EnsureCaretVisible()
                 self.AnnotationSetStyle(lx, stc.STC_STYLE_ANNOTATION)
                 self.AnnotationSetText(lx, msg)
             self.message(e)
-            ## print(msg, file=sys.__stderr__)
         else:
             self.code = code
-            del self.pointer # Reset pointer (debugger hook point).
+            del self.pointer  # Reset pointer (debugger hook point).
             del self.red_arrow
             self.handler('buffer_region_executed', self)
-            self.message("Evaluated {!r} successfully.".format(filename))
+            self.message("Evaluated {!r} successfully.".format(self.filename))
             self.AnnotationClearAll()
 
 
@@ -2115,16 +2277,16 @@ class EditorBook(AuiNotebook, CtrlInterface):
     """Python code editor.
     
     Args:
-        name : Window.Name (e.g. 'Scratch')
+        name: Window.Name (e.g. 'Scratch')
     
     Attributes:
-        default_name   : default buffer name (e.g. '*scratch*')
-        default_buffer : default buffer
+        default_name: default buffer name (e.g. '*scratch*')
+        default_buffer: default buffer
     """
     @property
     def message(self):
         return self.parent.message
-    
+
     def __init__(self, parent, name="book", **kwargs):
         kwargs.setdefault('style',
             (aui.AUI_NB_DEFAULT_STYLE | aui.AUI_NB_TOP)
@@ -2136,12 +2298,11 @@ class EditorBook(AuiNotebook, CtrlInterface):
         ## So we set the tabs' height to zero to hide them.
         self.TabCtrlHeight = 0
         
-        self.defaultBufferStyle = dict(
-            ReadOnly = False,
-        )
-        self.parent = parent #: parent<ShellFrame> is not Parent<AuiNotebook>
+        self.defaultBufferStyle = {}
+        
+        self.parent = parent  # parent<ShellFrame> is not Parent<AuiNotebook>
         self.Name = name
-        self.default_name = "*{}*".format(name.lower()) # e.g. '*scratch*'
+        self.default_name = "*{}*".format(name.lower())  # e.g. '*scratch*'
         self.default_buffer = self.create_buffer(self.default_name)
         
         self.Bind(aui.EVT_AUINOTEBOOK_PAGE_CLOSE, self.OnPageClose)
@@ -2163,29 +2324,29 @@ class EditorBook(AuiNotebook, CtrlInterface):
                 'buffer_loaded' : [ None, dispatch ],
                'buffer_deleted' : [ None, dispatch ],
               'buffer_modified' : [ None, dispatch ],
-             'buffer_activated' : [ None, dispatch, self.on_activated ],
-           'buffer_inactivated' : [ None, dispatch, self.on_inactivated ],
+             'buffer_activated' : [ None, dispatch, self.on_buffer_activated ],
+           'buffer_inactivated' : [ None, dispatch, self.on_buffer_inactivated ],
        'buffer_caption_updated' : [ None, dispatch ],
-             '*button* pressed' : [ None, dispatch, skip ],
-            '*button* released' : [ None, dispatch, skip ],
             },
             0 : { # Normal mode
+                    '* pressed' : (0, skip),
+                   '* released' : (0, skip, dispatch),
+             '*button* pressed' : (0, skip, dispatch),
                  'M-up pressed' : (0, _F(self.previous_buffer)),
                'M-down pressed' : (0, _F(self.next_buffer)),
             },
         })
-    
+
     def OnDestroy(self, evt):
         obj = evt.EventObject
         if isinstance(obj, Buffer):
             self.handler('buffer_deleted', obj)
         evt.Skip()
-    
-    def OnPageClose(self, evt): #<wx._aui.AuiNotebookEvent>
-        nb = evt.EventObject
-        buf = nb.all_buffers[evt.Selection]
+
+    def OnPageClose(self, evt):  #<wx._aui.AuiNotebookEvent>
+        buf = self.GetPage(evt.Selection)
         if buf.need_buffer_save:
-            if wx.MessageBox( # Confirm close.
+            if wx.MessageBox( # Confirm closing the buffer.
                     "You are closing unsaved content.\n\n"
                     "The changes will be discarded.\n"
                     "Continue closing?",
@@ -2195,20 +2356,19 @@ class EditorBook(AuiNotebook, CtrlInterface):
                 evt.Veto()
                 return
         evt.Skip()
-    
-    def OnPageClosed(self, evt): #<wx._aui.AuiNotebookEvent>
+
+    def OnPageClosed(self, evt):  #<wx._aui.AuiNotebookEvent>
         if self.PageCount == 0:
             self.new_buffer()
         evt.Skip()
-    
+
     def set_attributes(self, buf=None, **kwargs):
         """Set multiple properties at once to the buffer(s).
         
         Args:
-            buf : a buffer to apply (if None, applies to all buffers).
+            buf: a buffer to apply (if None, applies to all buffers).
             **kwargs: default style.
             
-                Style           = Buffer.STYLE
                 ReadOnly        = False
                 UseTabs         = False
                 ViewEOL         = False
@@ -2228,29 +2388,36 @@ class EditorBook(AuiNotebook, CtrlInterface):
             _setattribute(buf, kwargs)
         else:
             self.defaultBufferStyle.update(kwargs)
-            for buf in self.all_buffers:
+            for buf in self.get_all_buffers():
                 _setattribute(buf, self.defaultBufferStyle)
-    
-    def on_activated(self, buf):
+
+    def on_buffer_activated(self, buf):
         """Called when the buffer is activated."""
         title = "{} file: {}".format(self.Name, buf.filename)
         self.parent.handler('title_window', title)
-    
-    def on_inactivated(self, buf):
+
+    def on_buffer_inactivated(self, buf):
         """Called when the buffer is inactivated."""
         pass
-    
+
     ## --------------------------------
-    ## Buffer list controls
+    ## Buffer list controls.
     ## --------------------------------
-    
-    @property
-    def all_buffers(self):
-        """Returns all buffer pages.
-        cf. equiv. AuiNotebook.all_pages
-        """
-        return [self.GetPage(j) for j in range(self.PageCount)]
-    
+
+    def get_all_buffers(self, fn=None):
+        """Yields all buffers with specified fn:filename or code."""
+        if fn is None:
+            yield from self.get_pages(Buffer)
+        elif isinstance(fn, str):
+            g = os.path.realpath(fn)
+            for buf in self.get_pages(Buffer):
+                if fn == buf.filename or g == os.path.realpath(buf.filename):
+                    yield buf
+        else:
+            for buf in self.get_pages(Buffer):
+                if fn is buf or fn in buf:  # check code
+                    yield buf
+
     @property
     def menu(self):
         """Yields context menu."""
@@ -2260,86 +2427,91 @@ class EditorBook(AuiNotebook, CtrlInterface):
                 lambda v: buf.SetFocus(),
                 lambda v: v.Check(buf is self.buffer))
         
-        return (_menu(j+1, x) for j, x in enumerate(self.all_buffers))
-    
+        return (_menu(j+1, x) for j, x in enumerate(self.get_all_buffers()))
+
     @property
     def buffer(self):
-        """Returns the currently selected page or None."""
+        """Return the currently selected page or None."""
         return self.CurrentPage
-    
+
     def find_buffer(self, fn):
-        """Find buffer with specified fn:filename or code."""
-        if isinstance(fn, str):
-            g = os.path.realpath(fn)
-            for buf in self.all_buffers:
-                if fn == buf.filename or g == os.path.realpath(buf.filename):
-                    return buf
-        else:
-            for buf in self.all_buffers:
-                if fn is buf or fn in buf: # check code
-                    return buf
-    
+        """Find a buffer with specified fn:filename or code."""
+        return next(self.get_all_buffers(fn), None)
+
     def swap_buffer(self, buf, lineno=0):
         self.swap_page(buf)
         if lineno:
             buf.markline = lineno - 1
             buf.goto_marker(1)
-    
+
     def create_buffer(self, filename, index=None):
         """Create a new buffer (internal use only)."""
-        try:
-            self.Freeze()
+        with wx.FrozenWindow(self):
             buf = Buffer(self, filename, style=wx.BORDER_DEFAULT)
             self.set_attributes(buf, **self.defaultBufferStyle)
             if index is None:
                 index = self.PageCount
-            self.InsertPage(index, buf, buf.name)
+            self.InsertPage(index, buf, buf.name)  # => [buffer_activated]
             self.handler('buffer_new', buf)
             return buf
-        finally:
-            self.Thaw()
-    
+
     def new_buffer(self):
         """Create a new default buffer."""
         buf = self.default_buffer
-        if not buf or buf.mtdelta is not None: # is saved?
-            buf = self.create_buffer(self.default_name, index=0)
+        if not buf or buf.mtdelta is not None:  # is saved?
+            buf = self.create_buffer(self.default_name)
             self.default_buffer = buf
         else:
             buf.ClearAll()
-            ## buf.EmptyUndoBuffer()
+            # buf.EmptyUndoBuffer()
         buf.SetFocus()
         return buf
-    
+
     def delete_buffer(self, buf=None):
         """Pop the current buffer from the buffer list."""
         if not buf:
             buf = self.buffer
         j = self.GetPageIndex(buf)
         if j != -1:
-            self.DeletePage(j)  # the focus moves
-            if not self.buffer: # no buffers
-                self.new_buffer()
-    
+            self.DeletePage(j)   # the focus moves
+            if not self.buffer:  # no buffers
+                wx.CallAfter(self.new_buffer)  # Note: post-call to avoid a crash.
+
     def delete_all_buffers(self):
         """Initialize list of buffers."""
         self.DeleteAllPages()
-        self.new_buffer()
-    
+        wx.CallAfter(self.new_buffer)  # Note: post-call to avoid a crash.
+
     def next_buffer(self):
-        self.Selection += 1
-    
+        if self.Selection < self.PageCount - 1:
+            self.Selection += 1
+        else:
+            books = list(self.Parent.get_pages(type(self)))
+            k = books.index(self)
+            if k < len(books) - 1:
+                other_editor = books[k+1]
+                other_editor.Selection = 0
+                other_editor.CurrentPage.SetFocus()
+
     def previous_buffer(self):
-        self.Selection -= 1
-    
+        if self.Selection > 0:
+            self.Selection -= 1
+        else:
+            books = list(self.Parent.get_pages(type(self)))
+            k = books.index(self)
+            if k > 0:
+                other_editor = books[k-1]
+                other_editor.Selection = other_editor.PageCount - 1
+                other_editor.CurrentPage.SetFocus()
+
     ## --------------------------------
-    ## File I/O
+    ## File I/O.
     ## --------------------------------
     wildcards = [
         "PY files (*.py)|*.py",
         "ALL files (*.*)|*.*",
     ]
-    
+
     def load_cache(self, filename, lineno=0):
         """Load a file from cache using linecache.
         Note:
@@ -2355,12 +2527,13 @@ class EditorBook(AuiNotebook, CtrlInterface):
             elif not buf.need_buffer_load:
                 self.swap_buffer(buf, lineno)
                 return True
-            buf._load_textfile(''.join(lines), filename)
+            buf._load_textfile(''.join(lines))
+            buf.update_filestamp(filename)
             self.swap_buffer(buf, lineno)
             return True
         return False
-    
-    def load_file(self, filename, lineno=0, verbose=True):
+
+    def load_file(self, filename, lineno=0, verbose=True, **kwargs):
         """Load a file into an existing or new buffer.
         The requests module is required to use URL extension.
         """
@@ -2368,7 +2541,7 @@ class EditorBook(AuiNotebook, CtrlInterface):
         if not buf:
             buf = self.create_buffer("*temp file*")
         elif buf.need_buffer_save and verbose:
-            if wx.MessageBox( # Confirm load.
+            if wx.MessageBox( # Confirm loading the buffer.
                     "You are leaving unsaved content.\n\n"
                     "The changes will be discarded.\n"
                     "Continue loading?",
@@ -2382,22 +2555,23 @@ class EditorBook(AuiNotebook, CtrlInterface):
         try:
             if re.match(url_re, filename):
                 import requests
-                res = requests.get(filename, timeout=3.0)
-                if res.status_code == requests.codes.ok:
-                    buf._load_textfile(res.text, filename)
+                kwargs.setdefault('timeout', 3.0)
+                res = requests.get(filename, **kwargs)
+                if res.status_code == requests.codes.OK:
+                    buf._load_textfile(res.text)
+                    buf.update_filestamp(filename)
                     self.swap_buffer(buf, lineno)
                     return True
-                ## return False
-                raise Exception("The requested URL was not found")
+                res.raise_for_status()  # raise HTTP error; don't catch here.
             if buf._load_file(filename):
                 self.swap_buffer(buf, lineno)
                 return True
             return False
-        except Exception as e:
-            self.post_message(f"Failed to load {filename!r}.", e)
+        except (OSError, UnicodeDecodeError, ModuleNotFoundError) as e:
+            self.post_message("Failed to load:", e)
             self.delete_buffer(buf)
             return False
-    
+
     def find_file(self, filename=None):
         """Open the specified file."""
         if not filename:
@@ -2406,21 +2580,22 @@ class EditorBook(AuiNotebook, CtrlInterface):
                     wildcard='|'.join(self.wildcards),
                     style=wx.FD_OPEN|wx.FD_MULTIPLE) as dlg:
                 if dlg.ShowModal() == wx.ID_OK:
-                    for fn in dlg.Paths:
-                        self.find_file(fn)
-            return
-        if not self.load_file(filename):
+                    return all([self.find_file(fn) for fn in dlg.Paths])
+            return None
+        retval = self.load_file(filename)
+        if retval == False:  # noqa # to check if not None
             buf = self.create_buffer(filename)
-            buf._Buffer__mtime = 0 # => need_buffer_save
             self.swap_buffer(buf)
-    
+            self.post_message("New file.")
+        return retval
+
     def save_file(self, filename, buf=None, verbose=True):
         """Save the current buffer to a file.
         """
         buf = buf or self.buffer
         if buf.need_buffer_load and verbose:
             self.swap_buffer(buf)
-            if wx.MessageBox( # Confirm save.
+            if wx.MessageBox( # Confirm saving the buffer.
                     "The file has been modified externally.\n\n"
                     "The contents of the file will be overwritten.\n"
                     "Continue saving?",
@@ -2434,10 +2609,10 @@ class EditorBook(AuiNotebook, CtrlInterface):
                     self.default_buffer = None
                 return True
             return False
-        except Exception as e:
-            self.post_message(f"Failed to save {filename!r}.", e)
+        except (OSError, UnicodeDecodeError) as e:
+            self.post_message("Failed to save:", e)
             return False
-    
+
     def load_buffer(self, buf=None):
         """Confirm the load with the dialog."""
         buf = buf or self.buffer
@@ -2450,7 +2625,7 @@ class EditorBook(AuiNotebook, CtrlInterface):
             return None
         else:
             return self.load_file(buf.filename, buf.markline+1)
-    
+
     def save_buffer(self, buf=None):
         """Confirm the save with the dialog."""
         buf = buf or self.buffer
@@ -2463,28 +2638,28 @@ class EditorBook(AuiNotebook, CtrlInterface):
             return None
         else:
             return self.save_file(buf.filename, buf)
-    
+
     def save_buffer_as(self, buf=None):
         """Confirm the saveas with the dialog."""
         buf = buf or self.buffer
         with wx.FileDialog(self, "Save buffer as",
                 defaultDir=os.path.dirname(self.buffer.filename),
-                defaultFile=re.sub(r'[\/:*?"<>|]', '_', buf.name),
+                defaultFile=fix_fnchars(buf.name),
                 wildcard='|'.join(self.wildcards),
                 style=wx.FD_SAVE|wx.FD_OVERWRITE_PROMPT) as dlg:
             if dlg.ShowModal() == wx.ID_OK:
                 return self.save_file(dlg.Path, buf)
-    
+
     def save_all_buffers(self):
-        for buf in self.all_buffers:
+        for buf in self.get_all_buffers():
             if buf.need_buffer_save:
                 self.save_buffer(buf)
-    
+
     def kill_buffer(self, buf=None):
         """Confirm the close with the dialog."""
         buf = buf or self.buffer
         if buf.need_buffer_save:
-            if wx.MessageBox( # Confirm close.
+            if wx.MessageBox( # Confirm closing the buffer.
                     "You are closing unsaved content.\n\n"
                     "The changes will be discarded.\n"
                     "Continue closing?",
@@ -2492,12 +2667,12 @@ class EditorBook(AuiNotebook, CtrlInterface):
                     style=wx.YES_NO|wx.ICON_INFORMATION) != wx.YES:
                 self.post_message("The close has been canceled.")
                 return None
-        wx.CallAfter(self.delete_buffer, buf)
-    
+        self.delete_buffer(buf)
+
     def kill_all_buffers(self):
-        for buf in self.all_buffers:
+        for buf in self.get_all_buffers():
             if buf.need_buffer_save:
-                if wx.MessageBox( # Confirm close.
+                if wx.MessageBox( # Confirm closing the buffer.
                         "You are closing unsaved content.\n\n"
                         "The changes will be discarded.\n"
                         "Continue closing?",
@@ -2505,7 +2680,7 @@ class EditorBook(AuiNotebook, CtrlInterface):
                         style=wx.YES_NO|wx.ICON_INFORMATION) != wx.YES:
                     self.post_message("The close has been canceled.")
                     return None
-        wx.CallAfter(self.delete_all_buffers)
+        self.delete_all_buffers()
 
 
 class Interpreter(interpreter.Interpreter):
@@ -2516,7 +2691,7 @@ class Interpreter(interpreter.Interpreter):
         
         self.parent = interpShell
         self.globals = self.locals
-    
+
     def runcode(self, code):
         """Execute a code object.
         
@@ -2529,10 +2704,10 @@ class Interpreter(interpreter.Interpreter):
         except Exception:
             self.showtraceback()
         finally:
-            ## ex. KeyboardInterrupt:
+            ## ex. KeyboardInterrupt
             if wx.IsBusy():
                 wx.EndBusyCursor()
-    
+
     def showtraceback(self):
         """Display the exception that just occurred.
         
@@ -2541,41 +2716,27 @@ class Interpreter(interpreter.Interpreter):
         interpreter.Interpreter.showtraceback(self)
         
         t, v, tb = sys.exc_info()
-        v.lineno = tb.tb_next.tb_lineno
-        v.filename = tb.tb_next.tb_frame.f_code.co_filename
+        while tb.tb_next:
+            tb = tb.tb_next
+        v.lineno = tb.tb_lineno
+        v.filename = tb.tb_frame.f_code.co_filename
         try:
             self.parent.handler('interp_error', v)
         except AttributeError:
             pass
-    
-    def showsyntaxerror(self, filename=None):
+
+    def showsyntaxerror(self, filename=None, **kwargs):
         """Display the syntax error that just occurred.
         
         (override) Pass the syntax error info to the parent:shell.
         """
-        interpreter.Interpreter.showsyntaxerror(self, filename)
+        interpreter.Interpreter.showsyntaxerror(self, filename, **kwargs)
         
         t, v, tb = sys.exc_info()
         try:
             self.parent.handler('interp_error', v)
         except AttributeError:
             pass
-    
-    @ignore(DeprecationWarning)
-    def getCallTip(self, command='', *args, **kwargs):
-        """Return call tip text for a command.
-        
-        (override) Ignore DeprecationWarning: for function,
-                   `formatargspec` is deprecated since Python 3.5.
-        (override) Ignore ValueError: no signature found for builtin
-                   if the unwrapped function is a builtin function.
-        """
-        ## In 4.2.1, DeprecationWarning was fixed.
-        ## In 4.2.2, ValueError was fixed.
-        try:
-            return interpreter.Interpreter.getCallTip(self, command, *args, **kwargs)
-        except ValueError:
-            return interpreter.Interpreter.getCallTip(self) # dummy
 
 
 class Nautilus(EditorInterface, Shell):
@@ -2597,10 +2758,9 @@ class Nautilus(EditorInterface, Shell):
     
         - quoteback : x`y --> y=x  | x`y`z --> z=y=x
         - pullback  : x@y --> y(x) | x@y@z --> z(y(x))
-        - apropos   : x.y? [not] p --> shows apropos (not-)matched by predicates p
-                      equiv. apropos(x, y [,ignorecase ?:True,??:False] [,pred=p])
-                      ``y`` can contain regular expressions except for a dot.
-                      ``y`` can contain abbreviations: \\a:[a-z], \\A:[A-Z] .
+        - apropos   : x.y? [not] p --> shows items (not) matched by predicate p
+                      equiv. apropos(x, y [,ignorecase ?:True,??:False] [,pred=p]).
+                      ``y`` can contain regular expressions, but no dots or backslashes.
                       ``p`` can be atom, callable, type (e.g., int, str, ...),
                       and any predicates such as inspect.isclass.
         
@@ -2615,15 +2775,15 @@ class Nautilus(EditorInterface, Shell):
     
         C-up        : [0] retrieve previous history
         C-down      : [0] retrieve next history
-        C-j, M-j    : [0] tooltip of eval (for the selected or focused word)
-        C-h, M-h    : [0] calltip of help (for the selected or focused func)
+        C-j         : [0] tooltip of eval (for the selected or focused word)
+        C-h  M-h    : [0] calltip of help (for the selected or focused func)
         TAB         : [1] history-comp
         M-p         : [1] retrieve previous history in history-comp mode
         M-n         : [1] retrieve next history in history-comp mode
-        M-.         : [2] word-comp
-        M-/         : [3] apropos-comp
-        M-,         : [4] text-comp
-        M-m         : [5] module-comp
+        M-.  C-.    : [2] word-comp
+        M-/  C-/    : [3] apropos-comp
+        M-,  C-,    : [4] text-comp
+        M-m  C-m    : [5] module-comp
         
         Autocomps are incremental when pressed any alnums,
                   and decremental when backspace.
@@ -2645,46 +2805,20 @@ class Nautilus(EditorInterface, Shell):
         Half-baked by Patrik K. O'Brien,
         and this other half by K. O'moto.
     """
-    STYLE = {
-        stc.STC_STYLE_DEFAULT     : "fore:#7f7f7f,back:#202020,size:9,face:MS Gothic",
-        stc.STC_STYLE_LINENUMBER  : "fore:#000000,back:#f0f0f0,size:9",
-        stc.STC_STYLE_BRACELIGHT  : "fore:#ffffff,back:#202020,bold",
-        stc.STC_STYLE_BRACEBAD    : "fore:#ffffff,back:#ff0000,bold",
-        stc.STC_STYLE_CONTROLCHAR : "size:6",
-        stc.STC_STYLE_CARETLINE   : "fore:#ffffff,back:#123460,size:2", # optional
-        stc.STC_STYLE_ANNOTATION  : "fore:#7f0000,back:#ff7f7f", # optional
-        stc.STC_P_DEFAULT         : "fore:#cccccc",
-        stc.STC_P_OPERATOR        : "fore:#cccccc",
-        stc.STC_P_IDENTIFIER      : "fore:#cccccc",
-        stc.STC_P_COMMENTLINE     : "fore:#42c18c,back:#004040",
-        stc.STC_P_COMMENTBLOCK    : "fore:#42c18c,back:#004040,eol",
-        stc.STC_P_NUMBER          : "fore:#ffc080",
-        stc.STC_P_STRINGEOL       : "fore:#cccccc,back:#004040,eol",
-        stc.STC_P_CHARACTER       : "fore:#a0a0a0",
-        stc.STC_P_STRING          : "fore:#a0a0a0",
-        stc.STC_P_TRIPLE          : "fore:#a0a0a0,back:#004040",
-        stc.STC_P_TRIPLEDOUBLE    : "fore:#a0a0a0,back:#004040",
-        stc.STC_P_CLASSNAME       : "fore:#61d6d6,bold",
-        stc.STC_P_DEFNAME         : "fore:#3a96ff,bold",
-        stc.STC_P_WORD            : "fore:#80c0ff",
-        stc.STC_P_WORD2           : "fore:#ff80ff",
-        stc.STC_P_DECORATOR       : "fore:#ff8040",
-    }
-    
     @property
     def message(self):
         return self.parent.message
-    
+
     @property
     def target(self):
         return self.__target
-    
+
     @target.setter
     def target(self, obj):
         """Reset the shell target object; Rename the parent title.
         """
         if not hasattr(obj, '__dict__'):
-            raise TypeError("primitive objects cannot be targeted")
+            raise TypeError("invalid target")
         
         self.__target = obj
         self.locals = obj.__dict__
@@ -2693,39 +2827,39 @@ class Nautilus(EditorInterface, Shell):
         try:
             obj.self = obj
             obj.this = inspect.getmodule(obj)
-            obj.shell = self # overwrite the facade <wx.py.shell.ShellFacade>
+            obj.shell = self  # Overwrite the facade <wx.py.shell.ShellFacade>.
+            ## obj.__name__ = typename(obj)  # A namespace for ghost in the shell. cf. exec_region
         except AttributeError:
-            ## print("- cannot overwrite target vars:", e)
             pass
         self.parent.handler('title_window', obj)
-    
+
     @property
     def locals(self):
         return self.interp.locals
-    
+
     @locals.setter
-    def locals(self, v): # internal use only
+    def locals(self, v):  # internal use only
         self.interp.locals = v
-    
+
     @locals.deleter
-    def locals(self): # internal use only
+    def locals(self):  # internal use only
         self.interp.locals = self.__target.__dict__
-    
+
     @property
     def globals(self):
         return self.interp.globals
-    
+
     @globals.setter
-    def globals(self, v): # internal use only
+    def globals(self, v):  # internal use only
         self.interp.globals = v
-    
+
     @globals.deleter
-    def globals(self): # internal use only
+    def globals(self):  # internal use only
         self.interp.globals = self.__target.__dict__
         self.interp.globals.update(self.__globals)
-    
+
     __globals = {}
-    
+
     def __init__(self, parent, target, name="root",
                  introText=None,
                  startupScript=None,
@@ -2733,22 +2867,22 @@ class Nautilus(EditorInterface, Shell):
                  **kwargs):
         Shell.__init__(self, parent,
                  locals=target.__dict__,
-                 interpShell=self, # **kwds of InterpClass
+                 interpShell=self,  # **kwds of InterpClass
                  InterpClass=Interpreter,
                  introText=introText,
                  startupScript=startupScript,
-                 execStartupScript=execStartupScript, # executes ~/.py
+                 execStartupScript=execStartupScript,  # executes ~/.py
                  **kwargs)
         EditorInterface.__init__(self)
         
-        self.parent = parent #: parent<ShellFrame> is not Parent<AuiNotebook>
+        self.parent = parent  # parent<ShellFrame> is not Parent<AuiNotebook>
         self.target = target
         self.Name = name
         
         wx.py.shell.USE_MAGIC = True
-        wx.py.shell.magic = self.magic # called when USE_MAGIC
+        wx.py.shell.magic = self.magic  # called when USE_MAGIC
         
-        self.Bind(stc.EVT_STC_UPDATEUI, self.OnUpdate) # skip to brace matching
+        self.Bind(stc.EVT_STC_UPDATEUI, self.OnUpdate)  # skip to brace matching
         self.Bind(stc.EVT_STC_CALLTIP_CLICK, self.OnCallTipClick)
         
         self.Bind(wx.EVT_WINDOW_DESTROY, self.OnDestroy)
@@ -2767,19 +2901,10 @@ class Nautilus(EditorInterface, Shell):
         
         def clear(evt):
             ## """Clear selection and message, no skip."""
-            ## *do not* clear autocomp, so that the event can skip to AutoComp properly.
-            if self.CanEdit():
-                with self.off_undocollection():
-                    self.ReplaceSelection("")
-            self.message("")
-        
-        def clear_autocomp(evt):
-            ## """Clear autocomp, selection, and message."""
-            if self.AutoCompActive():
-                self.AutoCompCancel()
+            ## *DO NOT* clear autocomp, so that the event can skip to AutoComp properly.
             if self.CanEdit():
                 with self.off_undocollection():
-                    self.ReplaceSelection("")
+                    self.ReplaceSelection('')
             self.message("")
         
         def fork(evt):
@@ -2792,12 +2917,10 @@ class Nautilus(EditorInterface, Shell):
         self.handler.update({ # DNA<Nautilus>
             None : {
                  'interp_error' : [ None, self.on_interp_error ],
-                'shell_deleted' : [ None, dispatch, self.on_deleted ],
+                'shell_deleted' : [ None, dispatch, self.on_shell_deleted ],
                'shell_modified' : [ None, dispatch ],
-              'shell_activated' : [ None, dispatch, self.on_activated ],
-            'shell_inactivated' : [ None, dispatch, self.on_inactivated ],
-             '*button* pressed' : [ None, dispatch, skip ],
-            '*button* released' : [ None, dispatch, skip ],
+              'shell_activated' : [ None, dispatch, self.on_shell_activated ],
+            'shell_inactivated' : [ None, dispatch, self.on_shell_inactivated ],
             },
             -1 : { # original action of the wx.py.shell
                     '* pressed' : (0, skip, self.on_exit_escmap),
@@ -2814,36 +2937,39 @@ class Nautilus(EditorInterface, Shell):
             },
             0 : { # Normal mode
                     '* pressed' : (0, skip),
-                   '* released' : (0, skip),
+                   '* released' : (0, skip, dispatch),
+             '*button* pressed' : (0, skip, dispatch),
                'escape pressed' : (-1, self.on_enter_escmap),
                 'space pressed' : (0, self.OnSpace),
            '*backspace pressed' : (0, self.OnBackspace),
-          'C-backspace pressed' : (0, _F(self.backward_kill_word)),
-          'S-backspace pressed' : (0, _F(self.backward_kill_line)),
                 'enter pressed' : (0, self.OnEnter),
               'C-enter pressed' : (0, _F(self.insertLineBreak)),
             'C-S-enter pressed' : (0, _F(self.insertLineBreak)),
-               '*enter pressed' : (0, ), # -> OnShowCompHistory 無効
+               '*enter pressed' : (0, ),  # -> OnShowCompHistory 無効
                   'C-[ pressed' : (0, _F(self.goto_previous_mark_arrow)),
                 'C-S-[ pressed' : (0, _F(self.goto_previous_mark_arrow, selection=1)),
                   'C-] pressed' : (0, _F(self.goto_next_mark_arrow)),
                 'C-S-] pressed' : (0, _F(self.goto_next_mark_arrow, selection=1)),
                  'M-up pressed' : (0, _F(self.goto_previous_white_arrow)),
                'M-down pressed' : (0, _F(self.goto_next_white_arrow)),
-                # 'C-c pressed' : (0, skip), # -> spec-map
-                'C-S-c pressed' : (0, skip), # -> Copy selected text, retaining prompts.
+                # 'C-c pressed' : (0, skip),  # -> spec-map
+                'C-S-c pressed' : (0, skip),  # -> Copy selected text, retaining prompts.
                   'C-v pressed' : (0, _F(self.Paste)),
                 'C-S-v pressed' : (0, _F(self.Paste, rectangle=1)),
              'S-insert pressed' : (0, _F(self.Paste)),
            'C-S-insert pressed' : (0, _F(self.Paste, rectangle=1)),
-                  'C-j pressed' : (0, self.eval_line),
-                  'M-j pressed' : (0, self.exec_region),
+                  'C-j pressed' : (0, _F(self.eval_line)),
+                  'M-j pressed' : (0, _F(self.exec_region)),
                   'C-h pressed' : (0, self.call_helpTip),
                   'M-h pressed' : (0, self.call_helpDoc),
-                    '. pressed' : (2, self.OnEnterDot),
                   'tab pressed' : (1, self.call_history_comp),
                   'M-p pressed' : (1, self.call_history_comp),
                   'M-n pressed' : (1, self.call_history_comp),
+                    '. pressed' : (2, self.OnEnterDot),
+                  'C-. pressed' : (2, self.call_word_autocomp),
+                  'C-/ pressed' : (3, self.call_apropos_autocomp),
+                  'C-, pressed' : (4, self.call_text_autocomp),
+                  'C-m pressed' : (5, self.call_module_autocomp),
                   'M-. pressed' : (2, self.call_word_autocomp),
                   'M-/ pressed' : (3, self.call_apropos_autocomp),
                   'M-, pressed' : (4, self.call_text_autocomp),
@@ -2859,10 +2985,10 @@ class Nautilus(EditorInterface, Shell):
               'S-left released' : (1, self.call_history_comp),
               'S-right pressed' : (1, skip),
              'S-right released' : (1, self.call_history_comp),
-                  'tab pressed' : (1, _F(self._on_completion,  1)), # 古いヒストリへ進む
-                'S-tab pressed' : (1, _F(self._on_completion, -1)), # 新しいヒストリへ戻る
-                  'M-p pressed' : (1, _F(self._on_completion,  1)),
-                  'M-n pressed' : (1, _F(self._on_completion, -1)),
+                  'tab pressed' : (1, _F(self._on_completion, step=1)),  # 古いヒストリへ進む
+                'S-tab pressed' : (1, _F(self._on_completion, step=-1)),  # 新しいヒストリへ戻る
+                  'M-p pressed' : (1, _F(self._on_completion, step=1)),
+                  'M-n pressed' : (1, _F(self._on_completion, step=-1)),
             '[a-z0-9_] pressed' : (1, skip),
            '[a-z0-9_] released' : (1, self.call_history_comp),
             'S-[a-z\\] pressed' : (1, skip),
@@ -2875,11 +3001,11 @@ class Nautilus(EditorInterface, Shell):
              '*f[0-9]* pressed' : (1, ),
             },
             2 : { # word auto completion AS-mode
-                         'quit' : (0, clear_autocomp),
-                    '* pressed' : (0, clear_autocomp, fork),
+                         'quit' : (0, self.clear_autocomp),
+                    '* pressed' : (0, self.clear_autocomp, fork),
                   'tab pressed' : (0, clear, skip),
                 'enter pressed' : (0, clear, skip),
-               'escape pressed' : (0, clear_autocomp),
+               'escape pressed' : (0, clear, skip),
                    'up pressed' : (2, skip, self.on_completion_backward),
                  'down pressed' : (2, skip, self.on_completion_forward),
                 '*left pressed' : (2, skip),
@@ -2894,8 +3020,8 @@ class Nautilus(EditorInterface, Shell):
               '*delete pressed' : (2, skip),
            '*backspace pressed' : (2, self.OnBackspace),
           '*backspace released' : (2, self.call_word_autocomp),
-        'C-S-backspace pressed' : (2, ),
-                  'C-j pressed' : (2, self.eval_line),
+         '*S-backspace pressed' : (0, self.clear_autocomp, fork),
+                  'C-j pressed' : (2, _F(self.eval_line)),
                  '*alt pressed' : (2, ),
                 '*ctrl pressed' : (2, ),
                '*shift pressed' : (2, ),
@@ -2903,11 +3029,11 @@ class Nautilus(EditorInterface, Shell):
              '*f[0-9]* pressed' : (2, ),
             },
             3 : { # apropos auto completion AS-mode
-                         'quit' : (0, clear_autocomp),
-                    '* pressed' : (0, clear_autocomp, fork),
+                         'quit' : (0, self.clear_autocomp),
+                    '* pressed' : (0, self.clear_autocomp, fork),
                   'tab pressed' : (0, clear, skip),
                 'enter pressed' : (0, clear, skip),
-               'escape pressed' : (0, clear_autocomp),
+               'escape pressed' : (0, clear, skip),
                    'up pressed' : (3, skip, self.on_completion_backward),
                  'down pressed' : (3, skip, self.on_completion_forward),
                 '*left pressed' : (3, skip),
@@ -2922,8 +3048,8 @@ class Nautilus(EditorInterface, Shell):
               '*delete pressed' : (3, skip),
            '*backspace pressed' : (3, self.OnBackspace),
           '*backspace released' : (3, self.call_apropos_autocomp),
-        'C-S-backspace pressed' : (3, ),
-                  'C-j pressed' : (3, self.eval_line),
+         '*S-backspace pressed' : (0, self.clear_autocomp, fork),
+                  'C-j pressed' : (3, _F(self.eval_line)),
                  '*alt pressed' : (3, ),
                 '*ctrl pressed' : (3, ),
                '*shift pressed' : (3, ),
@@ -2931,11 +3057,11 @@ class Nautilus(EditorInterface, Shell):
              '*f[0-9]* pressed' : (3, ),
             },
             4 : { # text auto completion AS-mode
-                         'quit' : (0, clear_autocomp),
-                    '* pressed' : (0, clear_autocomp, fork),
+                         'quit' : (0, self.clear_autocomp),
+                    '* pressed' : (0, self.clear_autocomp, fork),
                   'tab pressed' : (0, clear, skip),
                 'enter pressed' : (0, clear, skip),
-               'escape pressed' : (0, clear_autocomp),
+               'escape pressed' : (0, clear, skip),
                    'up pressed' : (4, skip, self.on_completion_backward),
                  'down pressed' : (4, skip, self.on_completion_forward),
                 '*left pressed' : (4, skip),
@@ -2950,8 +3076,8 @@ class Nautilus(EditorInterface, Shell):
               '*delete pressed' : (4, skip),
            '*backspace pressed' : (4, self.OnBackspace),
           '*backspace released' : (4, self.call_text_autocomp),
-        'C-S-backspace pressed' : (4, ),
-                  'C-j pressed' : (4, self.eval_line),
+         '*S-backspace pressed' : (0, self.clear_autocomp, fork),
+                  'C-j pressed' : (4, _F(self.eval_line)),
                  '*alt pressed' : (4, ),
                 '*ctrl pressed' : (4, ),
                '*shift pressed' : (4, ),
@@ -2959,11 +3085,11 @@ class Nautilus(EditorInterface, Shell):
              '*f[0-9]* pressed' : (4, ),
             },
             5 : { # module auto completion AS-mode
-                         'quit' : (0, clear_autocomp),
-                    '* pressed' : (0, clear_autocomp, fork),
+                         'quit' : (0, self.clear_autocomp),
+                    '* pressed' : (0, self.clear_autocomp, fork),
                   'tab pressed' : (0, clear, skip),
                 'enter pressed' : (0, clear, skip),
-               'escape pressed' : (0, clear_autocomp),
+               'escape pressed' : (0, clear, skip),
                    'up pressed' : (5, skip, self.on_completion_backward),
                  'down pressed' : (5, skip, self.on_completion_forward),
                 '*left pressed' : (5, skip),
@@ -2975,11 +3101,12 @@ class Nautilus(EditorInterface, Shell):
             'S-[a-z\\] pressed' : (5, skip),
            'S-[a-z\\] released' : (5, self.call_module_autocomp),
                   '\\ released' : (5, self.call_module_autocomp),
+                  'C-m pressed' : (5, _F(self.call_module_autocomp, force=1)),
                   'M-m pressed' : (5, _F(self.call_module_autocomp, force=1)),
               '*delete pressed' : (5, skip),
            '*backspace pressed' : (5, self.OnBackspace),
           '*backspace released' : (5, self.call_module_autocomp),
-        'C-S-backspace pressed' : (5, ),
+         '*S-backspace pressed' : (0, self.clear_autocomp, fork),
                  '*alt pressed' : (5, ),
                 '*ctrl pressed' : (5, ),
                '*shift pressed' : (5, ),
@@ -2990,24 +3117,24 @@ class Nautilus(EditorInterface, Shell):
         
         self.wrap(0)
         self.show_folder()
-        self.set_stylus(self.STYLE)
+        self.set_stylus(Stylus.py_shell_mode)
         
-        ## delete unnecessary arrows at startup
+        ## Delete unnecessary arrows at startup.
         del self.white_arrow
         del self.red_arrow
         
         self.__text = ''
-    
+
     def trace_position(self):
         _text, lp = self.CurLine
         self.message("{:>6d}:{} ({})".format(self.cline, lp, self.cpos), pane=-1)
-    
+
     def OnDestroy(self, evt):
         if evt.EventObject is self:
             self.handler('shell_deleted', self)
         evt.Skip()
-    
-    def OnUpdate(self, evt): #<wx._stc.StyledTextEvent>
+
+    def OnUpdate(self, evt):  #<wx._stc.StyledTextEvent>
         if evt.Updated & (stc.STC_UPDATE_SELECTION | stc.STC_UPDATE_CONTENT):
             self.trace_position()
             if self.handler.current_state == 0:
@@ -3016,18 +3143,18 @@ class Nautilus(EditorInterface, Shell):
                     name, argspec, tip = self.interp.getCallTip(text)
                     if tip:
                         tip = tip.splitlines()[0]
-                    self.message(tip) # clear if no tip
+                    self.message(tip)  # clear if no tip
                     self.__text = text
             if evt.Updated & stc.STC_UPDATE_CONTENT:
                 self.handler('shell_modified', self)
         evt.Skip()
-    
+
     def OnCallTipClick(self, evt):
         if self.CallTipActive():
             self.CallTipCancel()
         self.parent.handler('add_help', self._calltips[1])
         evt.Skip()
-    
+
     def OnSpace(self, evt):
         """Called when space pressed."""
         if not self.CanEdit():
@@ -3037,133 +3164,142 @@ class Nautilus(EditorInterface, Shell):
           or re.match(r"from\s*$", cmdl)\
           or re.match(r"from\s+([\w.]+)\s+import\s*", cmdl):
             self.ReplaceSelection(' ')
-            self.handler('M-m pressed', None) # => call_module_autocomp
+            self.handler('M-m pressed', None)  # => call_module_autocomp
             return
         evt.Skip()
-    
+
     def OnBackspace(self, evt):
         """Called when backspace pressed.
         Backspace-guard from autocomp eating over a prompt whitespace.
         """
         if self.cpos == self.bolc:
-            self.handler('quit', evt) # don't eat backward prompt
+            self.handler('quit', evt)  # Don't eat backward prompt
             return
         evt.Skip()
-    
-    @can_edit
-    def backward_kill_line(self):
-        p = max(self.bol, self.bolc) # for debugger mode: bol <= bolc
-        text, lp = self.CurLine
-        if text[:lp] == sys.ps2:
-            self.Replace(p - lp, p, '') # eats ps2:prompt
-            return
-        if p == self.cpos > 0: # caret at beginning of line
-            if self.get_char(p-1) == '\n': p -= 1
-            if self.get_char(p-1) == '\r': p -= 1
-        self.Replace(p, self.cpos, '')
-    
-    @can_edit
-    def backward_kill_word(self):
-        p = self.cpos
-        text, lp = self.CurLine
-        if text[:lp] == sys.ps2:
-            self.goto_char(p - lp) # skips ps2:prompt
-        self.WordLeft()
-        q = max(self.bol, self.bolc) # for debugger mode: bol <= bolc
-        if self.cpos < q:
-            self.goto_char(q) # Don't skip back prompt
-        self.Replace(self.cpos, p, '')
-    
+
+    @editable
+    def backward_kill_word(self):  # (override)
+        if not self.SelectedText:
+            if self.cpos <= self.bolc:
+                return
+            text, lp = self.CurLine
+            if text[:lp] == sys.ps2:
+                self.cpos -= lp        # Select ps2:prompt
+                self.WordLeftExtend()  # Select cr/lf chunks
+            else:
+                self.WordLeftExtend()
+                q = max(self.bol, self.bolc)  # for debugger mode: bol <= bolc
+                if self.cpos < q:
+                    self.cpos = q  # Don't skip back ps2:prompt
+        self.ReplaceSelection('')
+
+    @editable
+    def backward_kill_line(self):  # (override)
+        if not self.SelectedText:
+            if self.cpos <= self.bolc:
+                return
+            text, lp = self.CurLine
+            if text[:lp] == sys.ps2:
+                self.cpos -= lp        # Select ps2:prompt
+                self.WordLeftExtend()  # Select cr/lf chunks
+            else:
+                q = max(self.bol, self.bolc)  # for debugger mode: bol <= bolc
+                if self.cpos > q:
+                    self.cpos = q
+                else:
+                    self.WordLeftExtend()  # Select cr/lf chunks
+        self.ReplaceSelection('')
+
     def OnEnter(self, evt):
         """Called when enter pressed."""
         if not self.CanEdit():
-            self.goto_char(self.eolc) # go to end of command line
+            self.goto_char(self.eolc)  # go to end of command line
             return
-        if self.AutoCompActive(): # skip to auto completion
+        if self.AutoCompActive():  # skip to auto completion
             evt.Skip()
             return
         if self.CallTipActive():
             self.CallTipCancel()
         
-        ## skip to wx.py.magic if text begins with !(sx), ?(info), and ??(help)
+        ## Skip to wx.py.magic if text begins with !(sx), ?(info), and ??(help).
         text = self.cmdline
         if not text or text[0] in '!?':
             evt.Skip()
             return
         
-        ## cast magic for `@? (Note: PY35 supports @(matmul)-operator)
+        ## Cast magic for `@? (Note: PY35 supports @(matmul)-operator).
         tokens = list(split_words(text))
         if any(x in tokens for x in '`@?$'):
             cmd = self.magic_interpret(tokens)
             if '\n' in cmd:
-                self.Execute(cmd) # => multi-line commands
+                self.Execute(cmd)  # => multi-line commands
             else:
-                self.run(cmd, verbose=0, prompt=0) # => push(cmd)
+                self.run(cmd, verbose=0, prompt=0)  # => push(cmd)
             return
         
         self.exec_cmdline()
-        ## evt.Skip() # => processLine
-    
+        # evt.Skip()  # => processLine
+
     def OnEnterDot(self, evt):
         """Called when dot [.] pressed."""
         if not self.CanEdit():
             self.handler('quit', evt)
             return
         p = self.cpos
-        st = self.get_style(p-1)
+        lst = self.get_style(p-1)
         rst = self.get_style(p)
         if p == self.bolc:
-            self.ReplaceSelection('self') # replace [.] --> [self.]
-        elif st in ('nil', 'space', 'op', 'sep', 'lparen'):
+            self.ReplaceSelection('self')  # replace [.] --> [self.]
+        elif lst in ('space', 'sep', 'lparen'):
             self.ReplaceSelection('self')
-        elif st not in ('moji', 'word', 'rparen') or rst == 'word':
-            self.handler('quit', evt) # don't enter autocomp
+        elif lst not in ('moji', 'word', 'rparen') or rst == 'word':
+            self.handler('quit', evt)  # Don't enter autocomp
         evt.Skip()
-    
+
     def on_enter_escmap(self, evt):
         self.__caret_mode = self.CaretPeriod
         self.CaretPeriod = 0
         self.message("ESC-")
-    
+
     def on_exit_escmap(self, evt):
         self.CaretPeriod = self.__caret_mode
         self.message("ESC {}".format(evt.key))
-        if self.eolc < self.bolc: # check if prompt is in valid state
+        if self.eolc < self.bolc:  # Check if prompt is in valid state.
             self.goto_char(self.eolc)
-            self.promptPosEnd = 0
+            self.promptPosEnd = 0  # Enabale write(prompt).
             self.prompt()
         self.AnnotationClearAll()
-    
+
     def on_enter_notemode(self, evt):
         self.noteMode = True
         self.__caret_mode = self.CaretForeground
         self.CaretForeground = 'red'
         self.message("Note mode")
-    
+
     def on_exit_notemode(self, evt):
         self.noteMode = False
         self.CaretForeground = self.__caret_mode
         self.goto_char(self.eolc)
-        self.promptPosEnd = 0
+        self.promptPosEnd = 0  # Enabale write(prompt).
         self.prompt()
         self.message("")
-    
+
     def goto_next_white_arrow(self):
-        self.goto_next_marker(0b010) # next white-arrow
-    
+        self.goto_next_marker(0b010)  # next white-arrow
+
     def goto_previous_white_arrow(self):
-        self.goto_previous_marker(0b010) # previous white-arrow
-    
+        self.goto_previous_marker(0b010)  # previous white-arrow
+
     def goto_next_mark_arrow(self, selection=False):
-        self.goto_next_marker(0b110, selection) # next white/red-arrow
-    
+        self.goto_next_marker(0b110, selection)  # next white/red-arrow
+
     def goto_previous_mark_arrow(self, selection=False):
-        self.goto_previous_marker(0b110, selection) # previous white/red-arrow
-    
+        self.goto_previous_marker(0b110, selection)  # previous white/red-arrow
+
     ## --------------------------------
-    ## Magic caster of the shell
+    ## Magic caster of the shell.
     ## --------------------------------
-    
+
     @classmethod
     def magic(self, cmd):
         """Called before command pushed.
@@ -3175,7 +3311,7 @@ class Nautilus(EditorInterface, Shell):
             elif cmd[0] == '?': cmd = 'info({})'.format(cmd[1:])
             elif cmd[0] == '!': cmd = 'sx({!r})'.format(cmd[1:])
         return cmd
-    
+
     @classmethod
     def magic_interpret(self, tokens):
         """Called when [Enter] command, or eval-time for tooltip.
@@ -3190,8 +3326,8 @@ class Nautilus(EditorInterface, Shell):
         Note:
             This is called before run, execute, and original magic.
         """
-        sep1 = "`@=;#"                # [`] no ops, no spaces, no comma
-        sep2 = "`@=+-/*%<>&|^~,; \t#" # [@] ops, delims, and whitespaces
+        sep1 = "`@=;\r\n#"                 # [`] no ops, no spaces, no comma
+        sep2 = "`@=+-/*%<>&|^~,; \t\r\n#"  # [@] ops, delims, and whitespaces
         
         def _popiter(ls, f):
             pred = f if callable(f) else re.compile(f).match
@@ -3207,7 +3343,7 @@ class Nautilus(EditorInterface, Shell):
         for i, c in enumerate(tokens):
             rest = tokens[i+1:]
             
-            if c == '@' and not lhs.strip() and '\n' in rest: # @decor
+            if c == '@' and not lhs.strip() and '\n' in rest:  # @decor
                 pass
             
             elif c == '@':
@@ -3217,16 +3353,21 @@ class Nautilus(EditorInterface, Shell):
                 ## func(a,b,c) @debug --> func,a,b,c @debug
                 if rhs in ("debug", "profile", "timeit"):
                     if lhs[-1] in ')':
-                        L, R = split_paren(lhs, reverse=1)
+                        R = next(split_parts(lhs, reverse=1))
+                        L = lhs[:-len(R)]
                         if not L:
                             lhs = "{!r}".format(R[1:-1])
-                        elif R:
+                        else:
                             lhs = "{}, {}".format(L, R[1:-1])
                 
                 ## @(y1,,,yn) --> @partial(y1,,,yn)
                 elif rhs.startswith('('):
                     rhs = re.sub(r"^\((.*)\)", r"partial(\1)", rhs, flags=re.S)
                 
+                ## obj @.method --> (obj).method
+                elif rhs.startswith('.'):
+                    return self.magic_interpret([f"({lhs}){rhs}"] + rest)
+                
                 return self.magic_interpret([f"{rhs}({lhs})"] + rest)
             
             if c == '`':
@@ -3245,40 +3386,44 @@ class Nautilus(EditorInterface, Shell):
                 return lhs + c + self.magic_interpret(rest)
             
             if c == sys.ps2.strip():
-                rhs = ''.join(_popiter(rest, "[ \t\r\n]")) # feed
+                rhs = ''.join(_popiter(rest, "[ \t\r\n]"))  # feed
                 return lhs + c + rhs + self.magic_interpret(rest)
             
             if c.startswith('#'):
-                rhs = ''.join(_popiter(rest, "[^\r\n]")) # skip comment
+                rhs = ''.join(_popiter(rest, "[^\r\n]"))  # skip comment
                 return lhs + c + rhs + self.magic_interpret(rest)
             
-            lhs += c # store in lhs; no more processing
+            lhs += c  # store in lhs; no more processing
         return lhs
-    
-    def on_deleted(self, shell):
+
+    def on_shell_deleted(self, shell):
         """Called before shell:self is killed.
         Delete target shell to prevent referencing the dead shell.
         """
         def _del():
+            obj = self.target
             try:
-                if not self.target.shell:
-                    del self.target.shell # delete the facade <wx.py.shell.ShellFacade>
+                if not obj.shell:
+                    del obj.shell  # delete the facade <wx.py.shell.ShellFacade>
             except AttributeError:
                 pass
         wx.CallAfter(_del)
-    
-    def on_activated(self, shell):
+
+    def on_shell_activated(self, shell):
         """Called when the shell:self is activated.
-        Reset localvars assigned for the shell target.
+        Reset localvars assigned for the shell target. cf. target.setter.
         """
         self.trace_position()
-        self.parent.handler('title_window', self.target)
+        obj = self.target
         try:
-            self.target.shell = self # overwrite the facade <wx.py.shell.ShellFacade>
+            obj.self = obj
+            obj.this = inspect.getmodule(obj)
+            obj.shell = self  # Overwrite the facade <wx.py.shell.ShellFacade>
         except AttributeError:
             pass
-    
-    def on_inactivated(self, shell):
+        self.parent.handler('title_window', obj)
+
+    def on_shell_inactivated(self, shell):
         """Called when shell:self is inactivated.
         Remove target localvars assigned for the shell target.
         """
@@ -3286,7 +3431,7 @@ class Nautilus(EditorInterface, Shell):
             self.AutoCompCancel()
         if self.CallTipActive():
             self.CallTipCancel()
-    
+
     def on_text_input(self, text):
         """Called when [Enter] text (before push).
         Mark points, reset history point, etc.
@@ -3297,7 +3442,7 @@ class Nautilus(EditorInterface, Shell):
         if text.rstrip():
             self.__eolc_mark = self.eolc
             self.historyIndex = -1
-    
+
     def on_text_output(self, text):
         """Called when [Enter] text (after push).
         Set markers at the last command line.
@@ -3306,28 +3451,28 @@ class Nautilus(EditorInterface, Shell):
             Argument `text` is raw output:str with no magic cast.
         """
         ln = self.LineFromPosition(self.bolc)
-        err = re.findall(py_error_re, text, re.M)
-        self.add_marker(ln, 1 if not err else 2) # 1:white-arrow 2:red-arrow
+        err = re.findall(py_trace_re, text, re.M)
+        self.add_marker(ln, 1 if not err else 2)  # 1:white-arrow 2:red-arrow
         return (not err)
-    
+
     def on_interp_error(self, e):
         ln = self.LineFromPosition(self.bolc)
-        self.pointer = ln + e.lineno - 1
-    
+        self.red_pointer = ln + e.lineno - 1
+
     ## --------------------------------
-    ## Attributes of the shell
+    ## Attributes of the shell.
     ## --------------------------------
-    
+
     @property
     def bolc(self):
-        "Beginning of command-line."
+        """Beginning of command-line."""
         return self.promptPosEnd
-    
+
     @property
     def eolc(self):
-        "End of command-line."
+        """End of command-line."""
         return self.TextLength
-    
+
     @property
     def bol(self):
         """Beginning of line (override) excluding prompt."""
@@ -3337,30 +3482,35 @@ class Nautilus(EditorInterface, Shell):
                 lp -= len(ps)
                 break
         return self.cpos - lp
-    
+
     @property
     def cmdline(self):
         """Full multi-line command in the current prompt."""
         return self.GetTextRange(self.bolc, self.eolc)
-    
+
     ## cf. getCommand() -> caret-line that starts with a prompt
     ## cf. getMultilineCommand() -> caret-multi-line that starts with a prompt
-    ##     [BUG 4.1.1] Don't use for current prompt --> Fixed in 4.2.0.
-    
-    def getMultilineCommand(self):
+    ##     [BUG ver 4.1.1] Don't use for current prompt --> Fixed in wx ver 4.2.0.
+
+    def getMultilineCommand(self, rstrip=True):
         """Extract a multi-line command which starts with a prompt.
         
         (override) Don't remove trailing ps2 + spaces.
                    Don't invoke ``GotoLine``.
         """
-        region = self.get_region(self.cline)
+        region = self.get_command_region(self.cline)
         if region:
             p, q = (self.PositionFromLine(x) for x in region)
             p += len(sys.ps1)
-            return self.GetTextRange(p, q)
+            command = self.GetTextRange(p, q).rstrip(os.linesep)  # remove the last cr/lf
+            if rstrip:
+                command = command.replace(os.linesep + sys.ps2, '\n')
+                command = command.rstrip()
+                command = command.replace('\n', os.linesep + sys.ps2)
+            return command
         return ''
-    
-    def get_region(self, line):
+
+    def get_command_region(self, line):
         """Line numbers of prompt head and tail containing the line."""
         lc = line
         le = lc + 1
@@ -3369,7 +3519,7 @@ class Nautilus(EditorInterface, Shell):
             if not text.startswith(sys.ps2):
                 break
             lc -= 1
-        if not text.startswith(sys.ps1): # bad region
+        if not text.startswith(sys.ps1):  # bad region
             return None
         while le < self.LineCount:
             text = self.GetLine(le)
@@ -3377,11 +3527,11 @@ class Nautilus(EditorInterface, Shell):
                 break
             le += 1
         return lc, le
-    
+
     ## --------------------------------
-    ## Execution methods of the shell
+    ## Execution methods of the shell.
     ## --------------------------------
-    
+
     def push(self, command, **kwargs):
         """Send command to the interpreter for execution.
         
@@ -3389,7 +3539,7 @@ class Nautilus(EditorInterface, Shell):
         """
         self.on_text_input(command)
         Shell.push(self, command, **kwargs)
-    
+
     def addHistory(self, command):
         """Add command to the command history.
         
@@ -3399,7 +3549,7 @@ class Nautilus(EditorInterface, Shell):
         if not command:
             return
         
-        ## この段階では push された直後で，次のようになっている
+        ## この段階では push された直後で，次のようになっている．
         ## bolc : beginning of command-line
         ## eolc : end of the output-buffer
         try:
@@ -3407,7 +3557,7 @@ class Nautilus(EditorInterface, Shell):
             output = self.GetTextRange(self.__eolc_mark, self.eolc)
             
             input = self.regulate_cmd(input)
-            Shell.addHistory(self, input) # => self.history
+            Shell.addHistory(self, input)  # => self.history
             
             noerr = self.on_text_output(output)
             if noerr:
@@ -3416,18 +3566,30 @@ class Nautilus(EditorInterface, Shell):
             command = self.fixLineEndings(command)
             self.parent.handler('add_log', command + os.linesep, noerr)
         except AttributeError:
-            ## execStartupScript 実行時は出力先 (owner) が存在しない
-            ## shell.__init__ よりも先に実行される
+            ## execStartupScript 実行時は出力先 (owner) が存在しない．
+            ## shell.__init__ よりも先に実行される．
             pass
-    
+
+    def setBuiltinKeywords(self):
+        """Create pseudo keywords as part of builtins.
+        
+        (override) Don't add `close`, `exit` and `quit` to builtins.
+        """
+        from wx.py.path import ls, cd, pwd, sx
+        builtins.cd = cd
+        builtins.ls = ls
+        builtins.pwd = pwd
+        builtins.sx = sx
+
     def execStartupScript(self, su):
         """Execute the user's PYTHONSTARTUP script if they have one.
         
         (override) Add globals when executing su:startupScript.
-                   Fix history point.
+                   Don't add '_f' to globals when executing su:startupScript.
+                   Don't add intro text in the history.
         """
-        keys = set(self.locals.keys()) # check for locals map changes
-        self.promptPosEnd = self.TextLength # fix history point
+        keys = set(self.locals.keys())  # to check for locals map changes.
+        self.promptPosEnd = self.TextLength  # Fix history point
         if su and os.path.isfile(su):
             self.push("print('Startup script executed:', {0!r})\n".format(su))
             self.push("with open({0!r}) as _f: exec(_f.read())\n".format(su))
@@ -3437,31 +3599,31 @@ class Nautilus(EditorInterface, Shell):
             self.push("")
             self.interp.startupScript = None
         self.__globals = {k: self.locals[k] for k in (self.locals.keys() - keys)}
-    
+
     def Paste(self, rectangle=False):
         """Replace selection with clipboard contents.
         
         (override) Remove ps1 and ps2 from the multi-line command to paste.
                    Add offset in paste-rectangle mode.
-                   Don't relplace the last crlf to ps.
+                   Don't relplace the last cr/lf to ps.
         """
         if self.CanPaste() and wx.TheClipboard.Open():
             data = wx.TextDataObject()
             if wx.TheClipboard.GetData(data):
                 command = data.GetText()
-                ## command = command.rstrip()
+                # command = command.rstrip()
                 command = self.fixLineEndings(command)
                 command = self.regulate_cmd(command)
                 ps = sys.ps2
                 _text, lp = self.CurLine
                 if rectangle:
-                    ps += ' ' * (lp - len(ps)) # add offset
+                    ps += ' ' * (lp - len(ps))  # add offset
                 if lp == 0:
-                    command = ps + command # paste-line
+                    command = ps + command  # paste-line
                 command = command.replace('\n', os.linesep + ps)
                 self.ReplaceSelection(command)
             wx.TheClipboard.Close()
-    
+
     def regulate_cmd(self, text):
         """Regulate text to executable command.
         
@@ -3470,53 +3632,53 @@ class Nautilus(EditorInterface, Shell):
             The eol-code (cr/lf) is not fixed.
             Call self.fixLineEndings in advance as necessary.
         """
-        text = self.lstripPrompt(text) # strip a leading prompt
+        text = self.lstripPrompt(text)  # strip a leading prompt
         lf = '\n'
         return (text.replace(os.linesep + sys.ps1, lf)
                     .replace(os.linesep + sys.ps2, lf)
                     .replace(os.linesep, lf))
-    
+
     def clear(self):
         """Delete all text (override) put new prompt."""
         self.ClearAll()
         self.promptPosStart = 0
         self.promptPosEnd = 0
         self.prompt()
-    
+
     def write(self, text, pos=None):
         """Display text in the shell.
         
-        (override) Append text if it is writable at the position.
+        (override) Append text if it is writable at the given position.
         """
         if pos is not None:
             if pos < 0:
-                pos += self.TextLength + 1 # Counts end-of-buffer (+1:\0)
+                pos += self.TextLength + 1  # Counts end-of-buffer (+1:\0)
             self.goto_char(pos)
         if self.CanEdit():
-            Shell.write(self, text) # => AddText
-    
+            Shell.write(self, text)  # => AddText
+
     ## input = classmethod(Shell.ask)
-    
+
     def info(self, obj):
         """Short information."""
         doc = inspect.getdoc(obj)\
                 or "No information about {}".format(obj)
-        self.parent.handler('add_help', doc) or print(doc)
-    
+        self.parent.handler('add_help', doc, typename(obj)) or print(doc)
+
     def help(self, obj):
         """Full description."""
         doc = pydoc.plain(pydoc.render_doc(obj))\
                 or "No description about {}".format(obj)
-        self.parent.handler('add_help', doc) or print(doc)
-    
+        self.parent.handler('add_help', doc, typename(obj)) or print(doc)
+
     def eval(self, text):
         return eval(text, self.globals, self.locals)
-    
+
     def exec(self, text):
         exec(text, self.globals, self.locals)
         dispatcher.send(signal='Interpreter.push',
                         sender=self, command=None, more=False)
-    
+
     def exec_cmdline(self):
         """Execute command-line directly.
         
@@ -3537,14 +3699,14 @@ class Nautilus(EditorInterface, Shell):
                 continue
             line = self.lstripPrompt(lines)
             lstr = line.lstrip()
-            if (lstr and lstr == line # no indent
-                and not lstr.startswith('#') # no comment
-                and not re.match(py_outdent_re, lstr)): # no outdent pattern
+            if (lstr and lstr == line  # no indent
+                and not lstr.startswith('#')  # no comment
+                and not re.match(py_outdent_re, lstr)):  # no outdent pattern
                 if cmd:
-                    commands.append(cmd) # Add stacked commands to the list
+                    commands.append(cmd)  # Add stacked commands to the list
                 cmd = line
             else:
-                cmd += lines # multi-line command
+                cmd += lines  # multi-line command
             lines = ''
         commands.append(cmd + lines)
         
@@ -3568,56 +3730,37 @@ class Nautilus(EditorInterface, Shell):
         for cmd in commands:
             self.write(cmd)
             self.processLine()
-    
-    ## --------------------------------
-    ## Autocomp actions of the shell
-    ## --------------------------------
-    
-    def autoCallTipShow(self, command, insertcalltip=True, forceCallTip=False):
-        """Display argument spec and docstring in a popup window.
+
+    def eval_line(self):
+        """Evaluate the selected word or line and show calltips."""
+        if self.CallTipActive():
+            self.CallTipCancel()
         
-        (override) Swap anchors to not scroll to the end of the line.
-        """
-        Shell.autoCallTipShow(self, command, insertcalltip, forceCallTip)
-        self.cpos, self.anchor = self.anchor, self.cpos
-        self.EnsureCaretVisible()
-    
-    def gen_text_at_caret(self):
-        """Generates the selected text,
-        otherwise the line or expression at the caret.
-        (override) Generates command line (that starts with a prompt).
-        """
         def _gen_text():
             text = self.SelectedText
             if text:
                 yield text
             else:
-                yield self.getCommand() # self.line_at_caret
+                yield self.line_at_caret
                 yield self.expr_at_caret
-        return filter(None, _gen_text())
-    
-    def eval_line(self, evt):
-        """Evaluate the selected word or line."""
-        if self.CallTipActive():
-            self.CallTipCancel()
         
-        status = "No words"
-        for text in self.gen_text_at_caret():
+        for text in _gen_text():
             tokens = split_words(text)
             try:
                 cmd = self.magic_interpret(tokens)
                 cmd = self.regulate_cmd(cmd)
                 obj = self.eval(cmd)
             except Exception as e:
-                status = "- {} : {!r}".format(e, text)
+                self.message(e)
             else:
                 self.CallTipShow(self.cpos, pformat(obj))
                 self.message(cmd)
                 return
-        self.message(status)
-    
-    def exec_region(self, evt):
-        """Execute the the selected region."""
+        if not text:
+            self.message("No words")
+
+    def exec_region(self):
+        """Execute a region of code."""
         if self.CallTipActive():
             self.CallTipCancel()
         
@@ -3632,15 +3775,15 @@ class Nautilus(EditorInterface, Shell):
                 self.exec(code)
             except Exception as e:
                 msg = traceback.format_exc()
-                err = re.findall(py_error_re, msg, re.M)
+                err = re.findall(py_trace_re, msg, re.M)
                 lines = [int(ln) for fn, ln in err if fn == filename]
                 if lines:
-                    region = self.get_region(self.cline)
-                    self.pointer = region[0] + lines[-1] - 1
+                    region = self.get_command_region(self.cline)
+                    lx = region[0] + lines[-1] - 1
+                    self.red_pointer = lx
                 self.message(e)
-                ## print(msg, file=sys.__stderr__)
             else:
-                del self.pointer
+                del self.red_pointer
                 self.message("Evaluated {!r} successfully.".format(filename))
         else:
             self.message("No region")