mwxlib 1.0.0__py3-none-any.whl → 1.8.0__py3-none-any.whl

mwx/framework.py

@@ -1,15 +1,15 @@
 #! python3
 """mwxlib framework.
 """
-__version__ = "1.0.0"
+__version__ = "1.8.0"
 __author__ = "Kazuya O'moto <komoto@jeol.co.jp>"
 
 from contextlib import contextmanager
+from datetime import datetime
 from functools import wraps, partial
 from importlib import reload
 import traceback
 import builtins
-import datetime
 import textwrap
 import time
 import os
@@ -24,34 +24,33 @@ from .utilus import get_rootpath, ignore, warn
 from .utilus import FSM, TreeList, apropos, typename, where, mro, pp
 
 
-def deb(target=None, loop=True, locals=None, debrc=None, **kwargs):
+def deb(target=None, loop=True, locals=None, **kwargs):
     """Dive into the process.
     
     Args:
-        target  : Object or module (default None).
-                  If None, the target is set to `__main__`.
-        loop    : If True, the app and the mainloop will be created.
-        locals  : Additional context of the shell
-        debrc   : file name of the session; defaults to None.
-                  If None, no session will be created or saved.
-        
-        **kwargs: Nautilus ShellFrame arguments
-        
-            - introText         : introductory of the shell
-            - startupScript     : startup script file (default None)
-            - execStartupScript : True => Execute the startup script.
-            - ensureClose       : True => EVT_CLOSE will close the window.
-                                  False => EVT_CLOSE will hide the window.
+        target: Object or module (default None).
+                If None, the target is set to `__main__`.
+        loop:   If True, the app and the mainloop will be created.
+        locals: Additional context of the shell
+        
+        **kwargs: ShellFrame and Nautilus arguments
+        
+            - session: file name of the session. Defaults to None.
+            - standalone: True => EVT_CLOSE will close the window.
+                          False => EVT_CLOSE will hide the window.
+            - introText: introductory of the shell
+            - startupScript: startup script file (default None)
+            - execStartupScript: True => Execute the startup script.
     
     Note:
         This will execute the startup script $(PYTHONSTARTUP).
     """
     kwargs.setdefault("introText", f"mwx {__version__}\n")
     kwargs.setdefault("execStartupScript", True)
-    kwargs.setdefault("ensureClose", True)
-
+    kwargs.setdefault("standalone", True)
+    
     app = wx.GetApp() or wx.App()
-    frame = ShellFrame(None, target, session=debrc, **kwargs)
+    frame = ShellFrame(None, target, **kwargs)
     frame.Show()
     frame.rootshell.SetFocus()
     if locals:
@@ -74,12 +73,12 @@ def postcall(f):
 @contextmanager
 def save_focus_excursion():
     """Save window focus excursion."""
-    wnd = wx.Window.FindFocus() # original focus
+    wnd = wx.Window.FindFocus()  # original focus
     try:
         yield wnd
     finally:
         if wnd and wnd.IsShownOnScreen():
-            wnd.SetFocus() # restore focus
+            wnd.SetFocus()  # restore focus
 
 
 _speckeys = {
@@ -175,11 +174,11 @@ def hotkey(evt):
     mod = ""
     for k, v in ((wx.WXK_WINDOWS_LEFT, 'Lwin-'),
                  (wx.WXK_WINDOWS_RIGHT, 'Rwin-'),
-                 ## (wx.WXK_CONTROL, 'C-'),
-                 ## (wx.WXK_ALT,     'M-'),
-                 ## (wx.WXK_SHIFT,   'S-')
+                 # (wx.WXK_CONTROL, 'C-'),
+                 # (wx.WXK_ALT,     'M-'),
+                 # (wx.WXK_SHIFT,   'S-')
                  ):
-        if key != k and wx.GetKeyState(k): # Note: lazy-eval state
+        if key != k and wx.GetKeyState(k):  # Note: lazy-eval state
             mod += v
     
     if key != wx.WXK_CONTROL and evt.controlDown: mod += "C-"
@@ -192,10 +191,10 @@ def hotkey(evt):
 
 
 def regulate_key(key):
-    return (key.replace("ctrl-",  "C-") # modifier keys abbreviation
+    return (key.replace("ctrl-",  "C-")  # modifier keys abbreviation
                .replace("alt-",   "M-")
                .replace("shift-", "S-")
-               .replace("M-C-", "C-M-") # modifier key regulation C-M-S-
+               .replace("M-C-", "C-M-")  # modifier key regulation C-M-S-
                .replace("S-M-", "M-S-")
                .replace("S-C-", "C-S-"))
 
@@ -210,20 +209,20 @@ class KeyCtrlInterfaceMixin:
         spec-map    : 'C-c'
         esc-map     : 'escape'
     """
-    message = print # override this in subclass
-    
+    message = print  # override this in subclass
+
     @postcall
     def post_message(self, *args, **kwargs):
         return self.message(*args, **kwargs)
-    
+
     @staticmethod
     def getKeyState(key):
-        """Returns state of speckey (cf. wx.GetKeyState)."""
+        """Return state of speckey (cf. wx.GetKeyState)."""
         try:
             return wx.GetKeyState(_speckeys_wxkmap[key])
         except KeyError:
             pass
-    
+
     @staticmethod
     def setKeyState(key, state):
         """Makes you feel like having pressed/released speckey."""
@@ -232,7 +231,7 @@ class KeyCtrlInterfaceMixin:
             vk.KeyDown(_speckeys_wxkmap[key])
         else:
             vk.KeyUp(_speckeys_wxkmap[key])
-    
+
     def make_keymap(self, keymap):
         """Make a basis of extension map in the handler.
         """
@@ -240,56 +239,60 @@ class KeyCtrlInterfaceMixin:
         
         def _Pass(evt):
             self.message("{} {}".format(keymap, evt.key))
-        _Pass.__name__ = str('pass')
+        _Pass.__name__ = "pass"
         
         state = self.handler.default_state
         event = keymap + ' pressed'
         
         assert state is not None, "Don't make keymap for None:state"
         
-        self.handler.update({ # DNA<KeyCtrlInterfaceMixin>
+        self.handler.update({  # DNA<KeyCtrlInterfaceMixin>
             state : {
-                          event : [ keymap, self.pre_command_hook ],
+                          event : [keymap, self.pre_command_hook],
             },
             keymap : {
-                         'quit' : [ state, ],
-                    '* pressed' : [ state, self.post_command_hook ],
-                 '*alt pressed' : [ keymap, _Pass ],
-                '*ctrl pressed' : [ keymap, _Pass ],
-               '*shift pressed' : [ keymap, _Pass ],
-             '*[LR]win pressed' : [ keymap, _Pass ],
+                         'quit' : [state, ],
+                    '* pressed' : [state, self.post_command_hook],
+                 '*alt pressed' : [keymap, _Pass],
+                '*ctrl pressed' : [keymap, _Pass],
+               '*shift pressed' : [keymap, _Pass],
+             '*[LR]win pressed' : [keymap, _Pass],
             },
         })
-    
+
     def pre_command_hook(self, evt):
-        """Called when entering extension mode (internal use only)."""
+        ## """Called when entering extension mode (internal use only)."""
         ## Check text selection for [C-c/C-x].
         wnd = wx.Window.FindFocus()
         if isinstance(wnd, wx.TextEntry) and wnd.StringSelection\
-        or isinstance(wnd, stc.StyledTextCtrl) and wnd.SelectedText:
-            ## or any other of pre-selection-p?
+          or isinstance(wnd, stc.StyledTextCtrl) and wnd.SelectedText:
             self.handler('quit', evt)
         else:
             self.message(evt.key + '-')
         evt.Skip()
-    
+    pre_command_hook.__name__ = "enter"
+
     def post_command_hook(self, evt):
-        """Called when exiting extension mode (internal use only)."""
+        ## """Called when exiting extension mode (internal use only)."""
         keymap = self.handler.previous_state
         if keymap:
             self.message("{} {}".format(keymap, evt.key))
         else:
             self.message(evt.key)
+        ## Check if the event has reached a top-level window; Don't skip text event.
+        if isinstance(self, wx.TopLevelWindow):
+            return
         evt.Skip()
-    
-    def define_key(self, keymap, action=None, *args, **kwargs):
+    post_command_hook.__name__ = "exit"
+
+    def define_key(self, keymap, action=None, /, *args, **kwargs):
         """Define [map key (pressed)] action.
         
         If no action, it invalidates the key and returns @decor(binder).
         The key must be in C-M-S order (ctrl + alt(meta) + shift).
         
         Note:
-            kwargs `doc` and `alias` are reserved as kw-only-args.
+            The funcall kwargs `doc` and `alias` are reserved as kw-only-args.
         """
         assert isinstance(keymap, str)
         assert callable(action) or action is None
@@ -304,28 +307,22 @@ class KeyCtrlInterfaceMixin:
         
         if map not in self.handler:
             warn(f"New map to define_key {keymap!r} in {self}.")
-            self.make_keymap(map) # make new keymap
-        
-        transaction = self.handler[map].get(key, [state])
-        if len(transaction) > 1:
-            warn(f"Duplicate define_key {keymap!r} in {self}.")
+            self.make_keymap(map)  # make new keymap
         
         if action is None:
-            self.handler[map].pop(key, None) # cf. undefine_key
+            self.handler[map].pop(key, None)  # cf. undefine_key
             return lambda f: self.define_key(keymap, f, *args, **kwargs)
         
         F = _F(action, *args, **kwargs)
+        
         @wraps(F)
         def f(*v, **kw):
-            self.message(f.__name__)
+            self.message(f.__name__)  # echo message
             return F(*v, **kw)
         
-        if map != state:
-            self.handler.update({map: {key: [state, self.post_command_hook, f]}})
-        else:
-            self.handler.update({map: {key: [state, f]}})
+        self.handler.update({map: {key: [state, f]}})
         return action
-    
+
     @ignore(UserWarning)
     def undefine_key(self, keymap):
         """Delete [map key (pressed)] context."""
@@ -336,12 +333,12 @@ class CtrlInterface(KeyCtrlInterfaceMixin):
     """Mouse/Key event interface mixin.
     """
     handler = property(lambda self: self.__handler)
-    
+
     def __init__(self):
         self.__key = ''
         self.__button = ''
         self.__isDragging = False
-        self.__handler = FSM({ # DNA<CtrlInterface>
+        self.__handler = FSM({  # DNA<CtrlInterface>
                 None : {
                 },
                 0 : {
@@ -353,15 +350,17 @@ class CtrlInterface(KeyCtrlInterfaceMixin):
         _N = self._normal_handler
         
         def activate(evt):
-            self.handler('focus_set', evt)
+            if self:
+                self.handler('focus_set', evt)
             evt.Skip()
         self.Bind(wx.EVT_SET_FOCUS, activate)
         
         def inactivate(evt):
-            self.__key = ''
-            self.__button = ''
-            self.__isDragging = False
-            self.handler('focus_kill', evt)
+            if self:
+                self.__key = ''
+                self.__button = ''
+                self.__isDragging = False
+                self.handler('focus_kill', evt)
             evt.Skip()
         self.Bind(wx.EVT_KILL_FOCUS, inactivate)
         
@@ -392,18 +391,18 @@ class CtrlInterface(KeyCtrlInterfaceMixin):
         
         self.Bind(wx.EVT_MOUSE_CAPTURE_LOST, lambda v: _N('capture_lost', v))
         self.Bind(wx.EVT_MOUSE_CAPTURE_CHANGED, lambda v: _N('capture_changed', v))
-    
-    def on_hotkey_press(self, evt): #<wx._core.KeyEvent>
+
+    def on_hotkey_press(self, evt):  # <wx._core.KeyEvent>
         """Called when a key is pressed."""
-        if evt.EventObject is not self:
-            evt.Skip()
-            return
+        # if evt.EventObject is not self:
+        #     evt.Skip()
+        #     return
         key = hotkey(evt)
         self.__key = regulate_key(key + '-')
         if self.handler('{} pressed'.format(key), evt) is None:
             evt.Skip()
-    
-    def on_hotkey_down(self, evt): #<wx._core.KeyEvent>
+
+    def on_hotkey_down(self, evt):  # <wx._core.KeyEvent>
         """Called when a key is pressed while dragging.
         Specifically called when the mouse is being captured.
         """
@@ -411,15 +410,15 @@ class CtrlInterface(KeyCtrlInterfaceMixin):
             self.on_hotkey_press(evt)
         else:
             evt.Skip()
-    
-    def on_hotkey_up(self, evt): #<wx._core.KeyEvent>
+
+    def on_hotkey_up(self, evt):  # <wx._core.KeyEvent>
         """Called when a key is released."""
         key = hotkey(evt)
         self.__key = ''
         if self.handler('{} released'.format(key), evt) is None:
             evt.Skip()
-    
-    def on_mousewheel(self, evt): #<wx._core.MouseEvent>
+
+    def on_mousewheel(self, evt):  # <wx._core.MouseEvent>
         """Called on mouse wheel events.
         Trigger event: 'key+wheel[up|down|right|left] pressed'
         """
@@ -430,8 +429,8 @@ class CtrlInterface(KeyCtrlInterfaceMixin):
         evt.key = self.__key + "wheel{}".format(p)
         if self.handler('{} pressed'.format(evt.key), evt) is None:
             evt.Skip()
-    
-    def on_motion(self, evt): #<wx._core.MouseEvent>
+
+    def on_motion(self, evt):  # <wx._core.MouseEvent>
         """Called on mouse motion events.
         Trigger event: 'key+[LMR]drag begin/motion/end'
         """
@@ -445,8 +444,8 @@ class CtrlInterface(KeyCtrlInterfaceMixin):
         else:
             self.handler('motion', evt)
         evt.Skip()
-    
-    def _mouse_handler(self, event, evt): #<wx._core.MouseEvent>
+
+    def _mouse_handler(self, event, evt):  # <wx._core.MouseEvent>
         """Called on mouse button events.
         Trigger event: 'key+[LMRX]button pressed/released/dblclick'
         """
@@ -458,7 +457,7 @@ class CtrlInterface(KeyCtrlInterfaceMixin):
                 kbtn = self.__key + self.__button
                 self.handler('{}drag end'.format(kbtn), evt)
         
-        k = evt.GetButton() #{1:L, 2:M, 3:R, 4:X1, 5:X2}
+        k = evt.GetButton()  # {1:L, 2:M, 3:R, 4:X1, 5:X2}
         if action == 'pressed' and k in (1,2,3):
             self.__button = 'LMR'[k-1]
         else:
@@ -466,22 +465,22 @@ class CtrlInterface(KeyCtrlInterfaceMixin):
         if self.handler(event, evt) is None:
             evt.Skip()
         try:
-            self.SetFocusIgnoringChildren() # let the panel accept keys
+            self.SetFocusIgnoringChildren()  # let the panel accept keys
         except AttributeError:
             pass
-    
-    def _normal_handler(self, event, evt): #<wx._core.Event>
+
+    def _normal_handler(self, event, evt):  # <wx._core.Event>
         if self.handler(event, evt) is None:
             evt.Skip()
 
 
 ## --------------------------------
-## wx Framework and Designer
+## wx Framework and Designer.
 ## --------------------------------
 
 def ID_(id):
-    ## Free ID - どこで使っているか検索できるように
-    ## do not use [ID_LOWEST(4999):ID_HIGHEST(5999)]
+    ## Free ID - どこで使っているか検索できるように．
+    ## Do not use [ID_LOWEST(4999):ID_HIGHEST(5999)].
     id += wx.ID_HIGHEST
     assert not wx.ID_LOWEST <= id <= wx.ID_HIGHEST
     return id
@@ -500,7 +499,7 @@ def pack(self, items, orient=wx.HORIZONTAL, style=None, label=None):
         )
     
     Args:
-        items   : wx objects (with some packing parameters)
+        items: wx objects (with some packing parameters)
         
             - (obj, 1) -> sized with ratio 1 (parallel to `orient`)
             - (obj, 1, wx.EXPAND) -> expanded with ratio 1 (perpendicular to `orient`)
@@ -509,9 +508,9 @@ def pack(self, items, orient=wx.HORIZONTAL, style=None, label=None):
             - (-1,-1) -> padding space
             - None -> phantom
         
-        orient  : HORIZONTAL or VERTICAL
-        label   : StaticBox label
-        style   : Sizer option (proportion, flag, border)
+        orient: HORIZONTAL or VERTICAL
+        label:  StaticBox label
+        style:  Sizer option (proportion, flag, border)
         
             - flag-expansion -> EXPAND, SHAPED
             - flag-border -> TOP, BOTTOM, LEFT, RIGHT, ALL
@@ -519,7 +518,7 @@ def pack(self, items, orient=wx.HORIZONTAL, style=None, label=None):
                             ALIGN_CENTER_VERTICAL, ALIGN_CENTER_HORIZONTAL
     """
     if style is None:
-        style = (0, wx.EXPAND | wx.ALL, 0) # DEFALT_STYLE (prop, flag, border)
+        style = (0, wx.EXPAND | wx.ALL, 0)  # DEFALT_STYLE (prop, flag, border)
     if label is None:
         sizer = wx.BoxSizer(orient)
     else:
@@ -529,14 +528,14 @@ def pack(self, items, orient=wx.HORIZONTAL, style=None, label=None):
         if not isinstance(item, (wx.Object, list, tuple, type(None))):
             warn(f"pack items must be a wx.Object, tuple or None, not {type(item)}")
         if item is None:
-            item = (0, 0), 0, 0, 0 # null space
+            item = (0, 0), 0, 0, 0  # null space
         elif not item:
-            item = (0, 0) # padding space
+            item = (0, 0)  # padding space
         try:
             try:
                 sizer.Add(item, *style)
             except TypeError:
-                sizer.Add(*item) # using item-specific style
+                sizer.Add(*item)  # using item-specific style
         except TypeError as e:
             traceback.print_exc()
             bmp = wx.StaticBitmap(self, bitmap=wx.ArtProvider.GetBitmap(wx.ART_ERROR))
@@ -550,8 +549,8 @@ class Menu(wx.Menu):
     """Construct the menu.
     
     Args:
-        menulist : list of MenuItem args
-        owner    : window object to bind handlers
+        owner: window object to bind handlers
+        menulist: list of MenuItem args
     
     (id, text, hint, style, icon,  ... Menu.Append arguments
        action, updater, highlight) ... Menu Event handlers
@@ -572,10 +571,10 @@ class Menu(wx.Menu):
                 continue
             id = item[0]
             handlers = [x for x in item if callable(x)]
-            icons =  [x for x in item if isinstance(x, wx.Bitmap)]
+            icons = [x for x in item if isinstance(x, wx.Bitmap)]
             argv = [x for x in item if x not in handlers and x not in icons]
             if isinstance(id, int):
-                menu_item = wx.MenuItem(self, *argv) # <- menu_item.Id
+                menu_item = wx.MenuItem(self, *argv)  # <- menu_item.Id
                 if icons:
                     menu_item.SetBitmaps(*icons)
                 self.Append(menu_item)
@@ -586,16 +585,16 @@ class Menu(wx.Menu):
                 except IndexError:
                     pass
             else:
-                subitems = list(argv.pop()) # extract the last element as submenu
+                subitems = list(argv.pop())  # extract the last element as submenu
                 submenu = Menu(owner, subitems)
                 submenu_item = wx.MenuItem(self, wx.ID_ANY, *argv)
                 submenu_item.SetSubMenu(submenu)
                 if icons:
                     submenu_item.SetBitmaps(*icons)
                 self.Append(submenu_item)
-                self.Enable(submenu_item.Id, len(subitems)) # Disable an empty menu.
-                submenu.Id = submenu_item.Id # <- ID_ANY (dummy to check empty sbumenu)
-    
+                self.Enable(submenu_item.Id, len(subitems))  # Disable an empty menu.
+                submenu.Id = submenu_item.Id  # <- ID_ANY (dummy to check empty sbumenu)
+
     def _unbind(self):
         for item in self.MenuItems:
             if item.Id != wx.ID_SEPARATOR:
@@ -604,17 +603,16 @@ class Menu(wx.Menu):
                 self.owner.Unbind(wx.EVT_MENU_HIGHLIGHT, item)
             if item.SubMenu:
                 item.SubMenu._unbind()
-    
+
     def Destroy(self):
-        try:
+        if self.owner and not self.owner.IsBeingDeleted():
             self._unbind()
-        finally:
-            return wx.Menu.Destroy(self)
-    
+        return wx.Menu.Destroy(self)
+
     @staticmethod
-    def Popup(parent, menulist, *args, **kwargs):
-        menu = Menu(parent, menulist)
-        parent.PopupMenu(menu, *args, **kwargs)
+    def Popup(owner, menulist, *args, **kwargs):
+        menu = Menu(owner, menulist)
+        owner.PopupMenu(menu, *args, **kwargs)
         menu.Destroy()
 
 
@@ -633,7 +631,7 @@ class MenuBar(wx.MenuBar, TreeList):
     def __init__(self, *args, **kwargs):
         wx.MenuBar.__init__(self, *args, **kwargs)
         TreeList.__init__(self)
-    
+
     def getmenu(self, key, root=None):
         if '/' in key:
             a, b = key.split('/', 1)
@@ -642,7 +640,7 @@ class MenuBar(wx.MenuBar, TreeList):
         if root is None:
             return next((menu for menu, label in self.Menus if menu.Title == key), None)
         return next((item.SubMenu for item in root.MenuItems if item.ItemLabel == key), None)
-    
+
     def update(self, key):
         """Update items of the menu that has specified key:root/branch.
         Call when the menulist is changed.
@@ -657,19 +655,19 @@ class MenuBar(wx.MenuBar, TreeList):
             return
         
         menu._unbind()
-        for item in menu.MenuItems: # delete all items
+        for item in menu.MenuItems:  # delete all items
             menu.Delete(item)
         
-        menu2 = Menu(self.Parent, self[key]) # new menu2 to swap menu
+        menu2 = Menu(self.Parent, self[key])  # new menu2 to swap menu
         for item in menu2.MenuItems:
-            menu.Append(menu2.Remove(item)) # 重複しないようにいったん切り離して追加する
+            menu.Append(menu2.Remove(item))  # 重複しないようにいったん切り離して追加する
         
         if hasattr(menu, 'Id'):
-            self.Enable(menu.Id, menu.MenuItemCount > 0) # Disable empty submenu.
+            self.Enable(menu.Id, menu.MenuItemCount > 0)  # Disable empty submenu.
         
         for j, (key, values) in enumerate(self):
-            self.EnableTop(j, bool(values)) # Disable empty main menu.
-    
+            self.EnableTop(j, bool(values))  # Disable empty main menu.
+
     def reset(self):
         """Recreates the menubar if the Parent was attached.
         Call when the menulist is changed.
@@ -678,41 +676,41 @@ class MenuBar(wx.MenuBar, TreeList):
             warn(f"No parents bound to {self}.")
             return
         
-        for j in range(self.GetMenuCount()): # remove and del all top-level menu
+        for j in range(self.GetMenuCount()):  # remove and del all top-level menu
             menu = self.Remove(0)
             menu.Destroy()
         
         for j, (key, values) in enumerate(self):
             menu = Menu(self.Parent, values)
             self.Append(menu, key)
-            self.EnableTop(j, bool(values)) # Disable empty main menu.
+            self.EnableTop(j, bool(values))  # Disable empty main menu.
 
 
 class StatusBar(wx.StatusBar):
     """Construct the statusbar with read/write interfaces.
     
     Attributes:
-        field   : list of field widths
-        pane    : index of status text field
+        field: list of field widths
+        pane: index of status text field
     """
     def __init__(self, *args, **kwargs):
         wx.StatusBar.__init__(self, *args, **kwargs)
-    
+
     def __call__(self, *args, **kwargs):
         text = ' '.join(str(v) for v in args)
         if self:
             return self.write(text, **kwargs)
-    
+
     def resize(self, field):
         self.SetFieldsCount(len(field))
-        self.SetStatusWidths(list(field)) # oldver requires list type
-    
+        self.SetStatusWidths(list(field))  # oldver requires list type
+
     def write(self, text, pane=0):
         if text and text[0] == '\b':
             text = self.read(pane) + text[1:]
         self.SetStatusText(text, pane % self.GetFieldsCount())
         return text
-    
+
     def read(self, pane=0):
         return self.GetStatusText(pane % self.GetFieldsCount())
 
@@ -721,19 +719,14 @@ class Frame(wx.Frame, KeyCtrlInterfaceMixin):
     """Frame extension class.
     
     Attributes:
-        menubar     : MenuBar
-        statusbar   : StatusBar
-        shellframe  : mini-frame of the shell
+        menubar: MenuBar
+        statusbar: StatusBar
+        shellframe: mini-frame of the shell
     """
     handler = property(lambda self: self.__handler)
-    
+
     message = property(lambda self: self.statusbar)
-    
-    def post_command_hook(self, evt):
-        ## (override) Don't skip events as a TopLevelWindow.
-        pass
-    post_command_hook.__name__ = str('noskip')
-    
+
     def __init__(self, *args, **kwargs):
         wx.Frame.__init__(self, *args, **kwargs)
         
@@ -769,14 +762,14 @@ class Frame(wx.Frame, KeyCtrlInterfaceMixin):
         ## AcceleratorTable mimic
         def hook_char(evt):
             """Called when key down."""
-            if isinstance(evt.EventObject, wx.TextEntry): # prior to handler
+            if isinstance(evt.EventObject, wx.TextEntry):  # prior to handler
                 evt.Skip()
             else:
                 if self.handler('{} pressed'.format(hotkey(evt)), evt) is None:
                     evt.Skip()
         self.Bind(wx.EVT_CHAR_HOOK, hook_char)
         
-        self.__handler = FSM({ # DNA<Frame>
+        self.__handler = FSM({  # DNA<Frame>
                 None : {
                 },
                 0 : {
@@ -784,39 +777,32 @@ class Frame(wx.Frame, KeyCtrlInterfaceMixin):
             },
         )
         self.make_keymap('C-x')
-    
+
     def About(self):
         wx.MessageBox(__import__("__main__").__doc__ or "no information",
                       "About this software")
-    
+
     def Destroy(self):
-        try:
-            self.timer.Stop()
-            self.shellframe.Destroy() # shellframe is not my child
-        finally:
-            return wx.Frame.Destroy(self)
+        self.timer.Stop()
+        self.shellframe.Destroy()  # shellframe is not my child
+        return wx.Frame.Destroy(self)
 
 
 class MiniFrame(wx.MiniFrame, KeyCtrlInterfaceMixin):
     """MiniFrame extension class.
     
     Attributes:
-        menubar     : MenuBar
-        statusbar   : StatusBar (not shown by default)
+        menubar: MenuBar
+        statusbar: StatusBar (not shown by default)
     """
     handler = property(lambda self: self.__handler)
-    
+
     message = property(lambda self: self.statusbar)
-    
-    def post_command_hook(self, evt):
-        ## (override) Don't skip events as a TopLevelWindow.
-        pass
-    post_command_hook.__name__ = str('noskip')
-    
+
     def __init__(self, *args, **kwargs):
         wx.MiniFrame.__init__(self, *args, **kwargs)
         
-        ## To disable, self.SetMenuBar(None)
+        ## To disable, call self.SetMenuBar(None).
         self.menubar = MenuBar()
         self.SetMenuBar(self.menubar)
         
@@ -824,20 +810,20 @@ class MiniFrame(wx.MiniFrame, KeyCtrlInterfaceMixin):
         self.statusbar.Show(0)
         self.SetStatusBar(self.statusbar)
         
-        ## AcceleratorTable mimic
+        ## AcceleratorTable mimic.
         def hook_char(evt):
             """Called when key down."""
-            if isinstance(evt.EventObject, wx.TextEntry): # prior to handler
+            if isinstance(evt.EventObject, wx.TextEntry):  # prior to handler
                 evt.Skip()
             else:
                 if self.handler('{} pressed'.format(hotkey(evt)), evt) is None:
                     evt.Skip()
         self.Bind(wx.EVT_CHAR_HOOK, hook_char)
         
-        ## To default close >>> self.Unbind(wx.EVT_CLOSE)
+        ## To default close >>> self.Unbind(wx.EVT_CLOSE).
         self.Bind(wx.EVT_CLOSE, lambda v: self.Show(0))
         
-        self.__handler = FSM({ # DNA<MiniFrame>
+        self.__handler = FSM({  # DNA<MiniFrame>
                 None : {
                 },
                 0 : {
@@ -845,9 +831,6 @@ class MiniFrame(wx.MiniFrame, KeyCtrlInterfaceMixin):
             },
         )
         self.make_keymap('C-x')
-    
-    def Destroy(self):
-        return wx.MiniFrame.Destroy(self)
 
 
 class AuiNotebook(aui.AuiNotebook):
@@ -866,52 +849,48 @@ class AuiNotebook(aui.AuiNotebook):
             self.Name = name
         
         def tab_menu(evt):
-            tabs = evt.EventObject #<AuiTabCtrl>
-            page = tabs.Pages[evt.Selection] # GetPage for split notebook.
+            tabs = evt.EventObject  # <AuiTabCtrl>
+            page = tabs.Pages[evt.Selection]  # GetPage for split notebook.
             try:
                 Menu.Popup(self, page.window.menu)
             except AttributeError:
                 pass
         self.Bind(aui.EVT_AUINOTEBOOK_TAB_RIGHT_DOWN, tab_menu)
-    
-    @property
-    def all_pages(self):
-        """Returns all window pages."""
-        return [self.GetPage(i) for i in range(self.PageCount)]
-    
+
     @property
-    def all_tabs(self):
-        """Returns all AuiTabCtrl objects."""
+    def _all_tabs(self):
+        """Return all AuiTabCtrl objects (internal use only)."""
         return [x for x in self.Children if isinstance(x, aui.AuiTabCtrl)]
-    
+
     @property
-    def all_panes(self):
-        """Returns all AuiPaneInfo excluding `dummy` one."""
+    def _all_panes(self):
+        """Return all AuiPaneInfo excluding `dummy` one (internal use only)."""
         return list(self._mgr.AllPanes)[1:]
-    
+
     def get_pages(self, type=None):
         """Yields pages of the specified window type."""
-        for win in self.all_pages:
+        for i in range(self.PageCount):
+            win = self.GetPage(i)
             if type is None or isinstance(win, type):
                 yield win
-    
+
     def swap_page(self, win):
         """Replace the page with the specified page w/o focusing."""
         j = self.GetPageIndex(win)
         if j != -1:
-            wnd = wx.Window.FindFocus() # original focus
+            wnd = wx.Window.FindFocus()  # original focus
             org = self.CurrentPage
             if j != self.Selection:
-                self.Selection = j      # the focus moves if shown
-            self.CurrentPage.SetFocus() # reset focus
-            if wnd and wnd is not org:  # restore focus other window
+                self.Selection = j       # the focus moves if shown
+            self.CurrentPage.SetFocus()  # reset focus
+            if wnd and wnd is not org:   # restore focus other window
                 wnd.SetFocus()
-    
+
     def get_caption(self, win):
         """Get caption of tab/page for specifiend window."""
         tab, page = self.find_tab(win)
         return page.caption
-    
+
     def set_caption(self, win, caption):
         """Set caption of tab/page for specifiend window.
         Returns True if the caption has changed.
@@ -921,41 +900,43 @@ class AuiNotebook(aui.AuiNotebook):
             page.caption = caption
             tab.Refresh()
             return True
-    
+
     def find_tab(self, win):
-        """Returns AuiTabCtrl and AuiNotebookPage for the window.
+        """Return AuiTabCtrl and AuiNotebookPage for the window.
         
         cf. aui.AuiNotebook.FindTab -> bool, tab, idx
         Note:
             Argument `win` can also be page.window.Name (not page.caption).
         """
-        for tabs in self.all_tabs: #<aui.AuiTabCtrl>
-            for page in tabs.Pages: #<aui.AuiNotebookPage>
+        for tab in self._all_tabs:  # <aui.AuiTabCtrl>
+            for page in tab.Pages:  # <aui.AuiNotebookPage>
                 ## if page.window is win or page.caption == win:
                 if page.window is win or page.window.Name == win:
-                    return tabs, page
-    
-    def move_tab(self, win, tabs):
-        """Move the window page to the specified tabs."""
+                    return tab, page
+
+    def move_tab(self, win, tab):
+        """Move the window page to the specified tab."""
+        if isinstance(tab, int):
+            tab = self._all_tabs[tab]
         try:
             tc1, nb1 = self.find_tab(win)
             win = nb1.window
-        except Exception: # object not found
+        except Exception:  # object not found
             return
-        page = wx.aui.AuiNotebookPage(nb1) # copy-ctor
+        page = wx.aui.AuiNotebookPage(nb1)  # copy-ctor
         tc1.RemovePage(win)     # Accessing nb1 will crash at this point.
-        tabs.AddPage(win, page) # Add a page with the copied info.
+        tab.AddPage(win, page)  # Add a page with the copied info.
         if tc1.PageCount == 0:
             ## Delete an empty tab and the corresponding pane.
-            j = self.all_tabs.index(tc1)
-            pane = self.all_panes[j]
+            j = self._all_tabs.index(tc1)
+            pane = self._all_panes[j]
             tc1.Destroy()
             self._mgr.DetachPane(pane.window)
         self._mgr.Update()
-    
+
     ## Methods to save / load the perspectives.
     ## *** Inspired by wx.lib.agw.aui.AuiNotebook ***
-    
+
     def savePerspective(self):
         """Saves the entire user interface layout into an encoded string,
         which can then be stored by the application.
@@ -964,17 +945,16 @@ class AuiNotebook(aui.AuiNotebook):
             Perspectives are saved according to page.window.Name.
             User should give it (not page.caption) a unique name.
         """
-        for j, pane in enumerate(self.all_panes):
+        for j, pane in enumerate(self._all_panes):
             pane.name = f"pane{j+1}"
         spec = ""
-        for j, tabs in enumerate(self.all_tabs):
-            k = next(k for k, page in enumerate(tabs.Pages)
-                                   if page.window.Shown) # get active window
+        for j, tabs in enumerate(self._all_tabs):
+            k = next(k for k, page in enumerate(tabs.Pages) if page.window.Shown)
             ## names = [page.caption for page in tabs.Pages]
             names = [page.window.Name for page in tabs.Pages]
             spec += f"pane{j+1}={names};{k}|"
         return spec + '@' + self._mgr.SavePerspective()
-    
+
     def loadPerspective(self, spec):
         """Loads a saved perspective.
         
@@ -986,34 +966,31 @@ class AuiNotebook(aui.AuiNotebook):
         tabinfo = re.findall(r"pane\w+?=(.*?);(.*?)\|", tabs)
         try:
             self.Parent.Freeze()
-            ## Collapse all tabs to main tabctrl
-            maintab = self.all_tabs[0]
-            for win in self.all_pages:
-                self.move_tab(win, maintab)
+            ## Collapse all tabctrls to main tabctrl.
+            for win in self.get_pages():
+                self.move_tab(win, 0)
             
-            ## Create a new tab using Split method.
+            ## Create a new tabctrl using Split method.
             ## Note: The normal way of creating panes with `_mgr` crashes.
-            
-            all_names = [win.Name for win in self.all_pages]
+            all_names = [win.Name for win in self.get_pages()]
             for names, k in tabinfo[1:]:
                 names, k = eval(names), int(k)
-                i = all_names.index(names[0]) # Assuming 0:tab is included.
+                i = all_names.index(names[0])  # Assuming 0:tab is included.
                 self.Split(i, wx.LEFT)
-                newtab = self.all_tabs[-1]
                 for name in names[1:]:
-                    self.move_tab(name, newtab)
-                self.Selection = all_names.index(names[k]) # new tabs active window
+                    self.move_tab(name, -1)
+                self.Selection = all_names.index(names[k])  # new tabctrl active window
             else:
                 names, k = tabinfo[0]
                 names, k = eval(names), int(k)
-                self.Selection = all_names.index(names[k]) # main tabs active window
+                self.Selection = all_names.index(names[k])  # main tabctrl active window
             
-            for j, pane in enumerate(self.all_panes):
+            for j, pane in enumerate(self._all_panes):
                 pane.name = f"pane{j+1}"
             self._mgr.LoadPerspective(frames)
             self._mgr.Update()
         except Exception as e:
-            print("- Failed to load perspective.", e)
+            print("- Failed to load perspective;", e)
         finally:
             self.Parent.Thaw()
 
@@ -1027,31 +1004,33 @@ class FileDropLoader(wx.DropTarget):
         self.target = target
         self.textdo = wx.TextDataObject()
         self.filedo = wx.FileDataObject()
-        self.DataObject = wx.DataObjectComposite()
-        self.DataObject.Add(self.textdo)
-        self.DataObject.Add(self.filedo, True)
-    
+        self.do = wx.DataObjectComposite()
+        self.do.Add(self.textdo)
+        self.do.Add(self.filedo)
+        self.SetDataObject(self.do)
+
+    def OnDragOver(self, x, y, result):
+        index, flags = self.target.HitTest((x, y))
+        if index != -1:
+            self.target.Selection = index
+            result = wx.DragCopy
+        else:
+            result = wx.DragNone
+        return result
+
     def OnData(self, x, y, result):
-        editor = self.target.current_editor
+        editor = self.target.Parent.current_editor
         self.GetData()
-        if self.textdo.TextLength > 1:
-            f = self.textdo.Text.strip()
-            res = editor.load_file(f)
-            if res:
-                editor.buffer.SetFocus()
-                result = wx.DragCopy
-            elif res is None:
-                editor.post_message("Load canceled.")
-                result = wx.DragCancel
-            else:
-                editor.post_message(f"Loading {f!r} failed.")
-                result = wx.DragNone
-            self.textdo.Text = ''
+        if self.textdo.Text:
+            fn = self.textdo.Text.strip()
+            res = editor.parent.handler("text_dropped", fn)
+            if res is None or not any(res):
+                editor.load_file(fn)
+            result = wx.DragCopy
+            self.textdo.SetText("")
         else:
-            for f in self.filedo.Filenames:
-                if editor.load_file(f):
-                    editor.buffer.SetFocus()
-                    editor.post_message(f"Loaded {f!r} successfully.")
+            for fn in self.filedo.Filenames:
+                editor.load_file(fn)
             self.filedo.SetData(wx.DF_FILENAME, None)
         return result
 
@@ -1060,26 +1039,28 @@ class ShellFrame(MiniFrame):
     """MiniFrame of the Shell.
     
     Args:
-        target  : target object of the rootshell.
-                  If None, it will be __main__.
-        session : file name of the session; defaults to None.
-                  If None, no session will be created or saved.
-        ensureClose : flag for the shell standalone.
-                      If True, EVT_CLOSE will close the window.
-                      Otherwise the window will be only hidden.
-        **kwargs    : Nautilus arguments
+        target: target object of the rootshell.
+                If None, it will be __main__.
+        session: file name of the session. Defaults to None.
+                 If None, no session will be created or saved.
+                 If `''`, the default session (.debrc) will be loaded.
+        standalone: flag for the shell standalone.
+                    If True, EVT_CLOSE will close the window.
+                    Otherwise the window will be only hidden.
+        **kwargs: Nautilus arguments
     
     Attributes:
-        console     : Notebook of shells
-        ghost       : Notebook of editors/buffers
-        watcher     : Notebook of global/locals watcher
-        Scratch     : Book of scratch (tooltip)
-        Help        : Book of help
-        Log         : Book of logging
-        monitor     : wxmon.EventMonitor object
-        inspector   : wxwit.Inspector object
-        debugger    : wxpdb.Debugger object
-        ginfo/linfo : globals/locals list
+        console:    Notebook of shells
+        ghost:      Notebook of editors/buffers
+        watcher:    Notebook of global/locals watcher
+        Scratch:    Book of scratch (tooltip)
+        Help:       Book of help
+        Log:        Book of logging
+        monitor:    wxmon.EventMonitor object
+        inspector:  wxwit.Inspector object
+        debugger:   wxpdb.Debugger object
+        ginfo:      globals list
+        linfo:      locals list
     
     Built-in utility::
     
@@ -1098,19 +1079,19 @@ class ShellFrame(MiniFrame):
         @highlight  : Highlight the widget.
         @filling    : Inspection using ``wx.lib.filling.Filling``.
     """
-    rootshell = property(lambda self: self.__shell) #: the root shell
-    
-    def __init__(self, parent, target=None, session=None, ensureClose=False, **kwargs):
+    rootshell = property(lambda self: self.__shell)  # the root shell
+
+    def __init__(self, parent, target=None, session=None, standalone=False, **kwargs):
         MiniFrame.__init__(self, parent, size=(1280,720), style=wx.DEFAULT_FRAME_STYLE)
         
         self.statusbar.resize((-1,120))
         self.statusbar.Show(1)
         
-        self.__standalone = bool(ensureClose)
+        self.__standalone = bool(standalone)
         
         self.Init()
         
-        from .nutshell import Nautilus, EditorBook
+        from .nutshell import Nautilus, EditorBook, Stylus
         from .bookshelf import EditorTreeCtrl
         
         self.__shell = Nautilus(self,
@@ -1125,6 +1106,28 @@ class ShellFrame(MiniFrame):
         self.Bookshelf = EditorTreeCtrl(self, name="Bookshelf",
                                         style=wx.TR_DEFAULT_STYLE|wx.TR_HIDE_ROOT)
         
+        ## Set shell and editor styles.
+        self.Scratch.set_attributes(Style=Stylus.py_shell_mode)
+        
+        self.Log.set_attributes(ReadOnly=True,
+                                Style=Stylus.py_log_mode)
+        
+        self.Help.set_attributes(ReadOnly=False,
+                                 Style=Stylus.py_log_mode)
+        
+        self.set_hookable(self.Scratch)
+        self.set_hookable(self.Log)
+        
+        @self.Scratch.define_key('C-j')
+        def eval_line(evt):
+            self.Scratch.buffer.eval_line()
+            evt.Skip(False)  # Don't skip explicitly.
+        
+        @self.Scratch.define_key('M-j')
+        def eval_buffer(evt):
+            self.Scratch.buffer.exec_region()
+            evt.Skip(False)  # Don't skip explicitly.
+        
         from .wxpdb import Debugger
         from .wxwit import Inspector
         from .wxmon import EventMonitor
@@ -1134,8 +1137,8 @@ class ShellFrame(MiniFrame):
         self.debugger = Debugger(self,
                                  stdin=self.__shell.interp.stdin,
                                  stdout=self.__shell.interp.stdout,
-                                 skip=[Debugger.__module__, # Don't enter debugger
-                                       EventMonitor.__module__, # Don't enter event-hook
+                                 skip=[Debugger.__module__,  # Don't enter debugger
+                                       EventMonitor.__module__,  # Don't enter event-hook
                                        FSM.__module__,
                                        'wx.core', 'wx.lib.eventwatcher',
                                        'fnmatch', 'warnings', 'bdb', 'pdb', 'contextlib',
@@ -1149,9 +1152,7 @@ class ShellFrame(MiniFrame):
         self.console = AuiNotebook(self, size=(600,400), name='console')
         self.console.AddPage(self.__shell, "root", bitmap=Icon('core'))
         self.console.TabCtrlHeight = 0
-        ## self.console.Name = "console"
         
-        ## self.console.Bind(aui.EVT_AUINOTEBOOK_BUTTON, self.OnConsoleCloseBtn)
         self.console.Bind(aui.EVT_AUINOTEBOOK_PAGE_CLOSE, self.OnConsolePageClose)
         self.console.Bind(aui.EVT_AUINOTEBOOK_PAGE_CHANGED, self.OnConsolePageChanged)
         
@@ -1162,7 +1163,7 @@ class ShellFrame(MiniFrame):
         
         self.ghost.AddPage(self.Bookshelf, "Bookshelf", bitmap=Icon('book'))
         
-        self.ghost.SetDropTarget(FileDropLoader(self))
+        self.ghost.SetDropTarget(FileDropLoader(self.ghost))
         
         self.watcher = AuiNotebook(self, size=(600,400), name="watcher")
         self.watcher.AddPage(self.ginfo, "globals")
@@ -1183,7 +1184,7 @@ class ShellFrame(MiniFrame):
         self._mgr.AddPane(self.ghost,
                           aui.AuiPaneInfo().Name("ghost")
                              .Caption("Ghost in the Shell").Right()
-                             .MaximizeButton().Show(0))
+                             .MaximizeButton().Show(1))
         
         self._mgr.AddPane(self.watcher,
                           aui.AuiPaneInfo().Name("watcher")
@@ -1205,6 +1206,8 @@ class ShellFrame(MiniFrame):
         
         self.Bind(wx.EVT_FIND, self.OnFindNext)
         self.Bind(wx.EVT_FIND_NEXT, self.OnFindNext)
+        self.Bind(wx.EVT_FIND_REPLACE, self.OnFindNext)
+        self.Bind(wx.EVT_FIND_REPLACE_ALL, self.OnFindNext)
         self.Bind(wx.EVT_FIND_CLOSE, self.OnFindClose)
         
         self.indicator = Indicator(self.statusbar, value=1)
@@ -1236,39 +1239,39 @@ class ShellFrame(MiniFrame):
                     self.indicator.Value = 7
             evt.Skip()
         
-        self.handler.update({ # DNA<ShellFrame>
+        self.handler.update({  # DNA<ShellFrame>
             None : {
-                  'debug_begin' : [ None, self.on_debug_begin ],
-                   'debug_next' : [ None, self.on_debug_next ],
-                    'debug_end' : [ None, self.on_debug_end ],
-                  'trace_begin' : [ None, self.on_trace_begin ],
-                   'trace_hook' : [ None, self.on_trace_hook ],
-                    'trace_end' : [ None, self.on_trace_end ],
-                'monitor_begin' : [ None, self.on_monitor_begin ],
-                  'monitor_end' : [ None, self.on_monitor_end ],
-                   'buffer_new' : [ None, ],
-                    'shell_new' : [ None, ],
-                      'add_log' : [ None, self.add_log ],
-                     'add_help' : [ None, self.add_help ],
-                 'title_window' : [ None, self.on_title_window ],
-       'buffer_caption_updated' : [ None, self.on_buffer_caption ], # => self.OnActivate
+                  'debug_begin' : [None, self.on_debug_begin],
+                   'debug_next' : [None, self.on_debug_next],
+                    'debug_end' : [None, self.on_debug_end],
+                  'trace_begin' : [None, self.on_trace_begin],
+                   'trace_hook' : [None, self.on_trace_hook],
+                    'trace_end' : [None, self.on_trace_end],
+                'monitor_begin' : [None, self.on_monitor_begin],
+                  'monitor_end' : [None, self.on_monitor_end],
+                    'shell_new' : [None, ],
+                     'book_new' : [None, ],
+                      'add_log' : [None, self.add_log],
+                     'add_help' : [None, self.add_help],
+                 'title_window' : [None, self.on_title_window],
             },
             0 : {
                     '* pressed' : (0, fork_debugger),
                    '* released' : (0, fork_debugger),
                   'C-g pressed' : (0, self.Quit, fork_debugger),
                    'f1 pressed' : (0, self.About),
-                  'C-f pressed' : (0, self.OnFindText),
-                   'f3 pressed' : (0, self.OnFindNext),
-                 'S-f3 pressed' : (0, self.OnFindPrev),
-                  'f11 pressed' : (0, _F(self.toggle_window, self.ghost, alias='toggle_ghost')),
-                'S-f11 pressed' : (0, _F(self.toggle_window, self.watcher, alias='toggle_watcher')),
+                  'C-f pressed' : (0, self.on_search_dialog),
+                'C-S-f pressed' : (0, self.on_replace_dialog),
+                   'f3 pressed' : (0, self.repeat_forward_search),
+                 'S-f3 pressed' : (0, self.repeat_backward_search),
+                  'f11 pressed' : (0, _F(self.toggle_window, win=self.ghost, alias='toggle_ghost')),
+                'S-f11 pressed' : (0, _F(self.toggle_window, win=self.watcher, alias='toggle_watcher')),
                   'f12 pressed' : (0, _F(self.Close, alias="close")),
              '*f[0-9]* pressed' : (0, ),
             },
         })
         
-        ## Session files
+        ## Session files.
         self.SESSION_FILE = get_rootpath(".debrc")
         self.SCRATCH_FILE = get_rootpath("scratch.py")
         self.LOGGING_FILE = get_rootpath("deb-logging.log")
@@ -1277,9 +1280,7 @@ class ShellFrame(MiniFrame):
             self.load_session(session or self.SESSION_FILE)
         else:
             self.SESSION_FILE = None
-        
-        self.postInit()
-    
+
     def load_session(self, filename):
         """Load session from file.
         Buffers, pointers, and the entire layout are loaded.
@@ -1292,10 +1293,10 @@ class ShellFrame(MiniFrame):
             except Exception:
                 pass
         
-        _fload(self.Scratch, self.SCRATCH_FILE) # restore scratch
+        _fload(self.Scratch, self.SCRATCH_FILE)  # restore scratch
         
         ## Re-open the *log* file.
-        self.add_log("#! Opened: <{}>\r\n".format(datetime.datetime.now()))
+        self.add_log("#! Opened: <{}>\r\n".format(datetime.now()))
         
         session = os.path.abspath(filename)
         try:
@@ -1303,12 +1304,14 @@ class ShellFrame(MiniFrame):
                 exec(i.read())
         except FileNotFoundError:
             pass
+        except Exception as e:
+            print("- Failed to load session;", e)
         self.SESSION_FILE = session
         
         ## Reposition the window if it is not on the desktop.
         if wx.Display.GetFromWindow(self) == -1:
             self.Position = (0, 0)
-    
+
     def save_session(self):
         """Save session to file.
         Buffers, pointers, and the entire layout are saved.
@@ -1321,8 +1324,8 @@ class ShellFrame(MiniFrame):
             except Exception:
                 pass
         
-        _fsave(self.Scratch, self.SCRATCH_FILE) # save scratch
-        _fsave(self.Log,     self.LOGGING_FILE) # save log
+        _fsave(self.Scratch, self.SCRATCH_FILE)  # save scratch
+        _fsave(self.Log,     self.LOGGING_FILE)  # save log
         
         if not self.SESSION_FILE:
             return
@@ -1332,8 +1335,10 @@ class ShellFrame(MiniFrame):
             o.write("self.SetSize({})\n".format(self.Size))
             o.write("self.SetPosition({})\n".format(self.Position))
             
-            for book in self.all_editors:
-                for buf in book.all_buffers:
+            for book in self.get_all_editors():
+                if book.Name not in ("Scratch", "Log", "Help"):  # Save default editors only.
+                    continue
+                for buf in book.get_all_buffers():
                     if buf.mtdelta is not None:
                         o.write("self.{}.load_file({!r}, {})\n"
                                 .format(book.Name, buf.filename, buf.markline+1))
@@ -1345,35 +1350,7 @@ class ShellFrame(MiniFrame):
                 "self._mgr.LoadPerspective({!r})".format(self._mgr.SavePerspective()),
                 "self._mgr.Update()\n",
             )))
-    
-    def postInit(self):
-        """Set shell and editor styles.
-        Note:
-            This is called after loading session.
-        """
-        from .nutshell import Stylus
-        
-        self.Scratch.set_attributes(Style=Stylus.py_shell_mode)
-        
-        self.Log.set_attributes(ReadOnly=True,
-                                Style=Stylus.py_log_mode)
-        
-        self.Help.set_attributes(ReadOnly=False,
-                                 Style=Stylus.py_log_mode)
-        
-        self.set_hookable(self.Scratch)
-        self.set_hookable(self.Log)
-        
-        @self.Scratch.define_key('C-j')
-        def eval_line(evt):
-            self.Scratch.buffer.eval_line()
-            evt.Skip(False) # Don't skip explicitly.
-        
-        @self.Scratch.define_key('M-j')
-        def eval_buffer(evt):
-            self.Scratch.buffer.exec_region()
-            evt.Skip(False) # Don't skip explicitly.
-    
+
     def Init(self):
         """Initialize self-specific builtins.
         Note:
@@ -1382,7 +1359,7 @@ class ShellFrame(MiniFrame):
         try:
             builtins.dive
         except AttributeError:
-            ## Add useful built-in functions and methods
+            ## Add useful built-in functions and methods.
             builtins.apropos = apropos
             builtins.typename = typename
             builtins.reload = reload
@@ -1401,10 +1378,10 @@ class ShellFrame(MiniFrame):
             builtins.profile = self.profile
             builtins.highlight = self.highlight
             builtins.filling = filling
-    
+
     def Destroy(self):
         try:
-            ## Remove built-in self methods
+            ## Remove built-in self methods.
             del builtins.info
             del builtins.help
             del builtins.load
@@ -1416,16 +1393,21 @@ class ShellFrame(MiniFrame):
             del builtins.highlight
         except AttributeError:
             pass
-        try:
-            self.timer.Stop()
-            self.save_session()
-        finally:
-            self._mgr.UnInit()
-            return MiniFrame.Destroy(self)
-    
+        
+        self.timer.Stop()
+        self.save_session()
+        self._mgr.UnInit()
+        return MiniFrame.Destroy(self)
+
+    def Close(self):
+        if self.__standalone:
+            MiniFrame.Close(self)
+        else:
+            self.Show(not self.Shown)
+
     def OnClose(self, evt):
         if self.debugger.busy:
-            if wx.MessageBox( # Confirm debugger close.
+            if wx.MessageBox(  # Confirm closing the debugger.
                     "The debugger is running.\n\n"
                     "Enter [q]uit to exit before closing.\n"
                     "Continue closing?",
@@ -1433,20 +1415,20 @@ class ShellFrame(MiniFrame):
                 self.message("The close has been canceled.")
                 evt.Veto()
                 return
-            #? RuntimeError('wrapped C/C++ object ... has been deleted')
+            ## RuntimeError('wrapped C/C++ object ... has been deleted')
             self.Quit()
         
         if self.debugger.tracing:
             wx.MessageBox("The debugger ends tracing.\n\n"
                           "The trace pointer will be cleared.")
-            self.debugger.unwatch() # cf. [pointer_unset] stop_trace
+            self.debugger.unwatch()  # cf. [pointer_unset] stop_trace
         
-        for book in self.all_editors:
-            for buf in book.all_buffers:
+        for book in self.get_all_editors():
+            for buf in book.get_all_buffers():
                 if buf.need_buffer_save:
                     self.popup_window(book)
                     buf.SetFocus()
-                    if wx.MessageBox( # Confirm close.
+                    if wx.MessageBox(  # Confirm closing the buffer.
                             "You are closing unsaved content.\n\n"
                             "Changes to the content will be discarded.\n"
                             "Continue closing?",
@@ -1455,58 +1437,60 @@ class ShellFrame(MiniFrame):
                         self.message("The close has been canceled.")
                         evt.Veto()
                         return
-                    break # Don't ask any more.
+                    break  # Don't ask any more.
         if self.__standalone:
-            evt.Skip() # Close the window
+            evt.Skip()  # Close the window
         else:
-            self.Show(0) # Don't destroy the window
-    
+            self.Show(0)  # Don't destroy the window
+
     def OnActivate(self, evt):
         if not evt.Active:
             ## Reset autoload when active focus going outside.
             self.__autoload = True
-        elif evt.GetActivationReason() == evt.Reason_Mouse\
-          and self.__autoload:
+        ## elif evt.GetActivationReason() == evt.Reason_Mouse and self.__autoload:
+        elif self.__autoload:
             ## Check all buffers that need to be loaded.
-            for book in self.all_editors:
-                for buf in book.all_buffers:
+            verbose = 1
+            for book in self.get_all_editors():
+                for buf in book.get_all_buffers():
                     if buf.need_buffer_load:
-                        if wx.MessageBox( # Confirm load.
-                                "The file has been modified externally.\n\n"
-                                "The contents of the buffer will be overwritten.\n"
-                                "Continue loading {}/{}?".format(book.Name, buf.name),
-                                "Load {!r}".format(buf.name),
-                                style=wx.YES_NO|wx.ICON_INFORMATION) != wx.YES:
-                            self.__autoload = False # Don't ask any more.
-                            return
-                        book.load_file(buf.filename)
+                        buf.update_caption()
+                        if verbose:
+                            with wx.MessageDialog(self,  # Confirm load.
+                                    "The file has been modified externally.\n\n"
+                                    "The contents of the buffer will be overwritten.\n"
+                                    "Continue loading {}/{}?".format(book.Name, buf.name),
+                                    "Load {!r}".format(buf.name),
+                                    style=wx.YES_NO|wx.CANCEL|wx.HELP|wx.ICON_INFORMATION) as dlg:
+                                dlg.SetHelpLabel("Yes to All")
+                                ret = dlg.ShowModal()
+                                if ret == wx.ID_NO:
+                                    continue
+                                if ret == wx.ID_CANCEL:
+                                    break  # all
+                                if ret == wx.ID_HELP:  # ID_YESTOALL
+                                    verbose = 0
+                        book.load_file(buf.filename, buf.markline+1)
+            self.__autoload = False
         ## Reinitialize self-specific builtins if other instances are destroyed.
         if evt.Active:
             self.Init()
         evt.Skip()
-    
+
     def OnShow(self, evt):
-        pane = self._mgr.GetPane(self.watcher)
-        if evt.IsShown():
-            if pane.IsShown():
-                self.inspector.watch()
-                self.monitor.watch()
-        else:
-            if pane.IsDocked():
-                self.inspector.unwatch()
-                self.monitor.unwatch()
+        for pane in self._mgr.GetAllPanes():
+            ## When the window is hidden, disable docking and keep child panes floating.
+            pane.Dockable(evt.IsShown() or pane.IsDocked())
         evt.Skip()
-    
+
     def OnGhostShow(self, evt):
         if evt.IsShown():
             self.inspector.watch()
-            self.monitor.watch()
         else:
             self.inspector.unwatch()
-            self.monitor.unwatch()
         evt.Skip()
-    
-    def OnConsolePageChanged(self, evt): #<wx._aui.AuiNotebookEvent>
+
+    def OnConsolePageChanged(self, evt):  # <wx._aui.AuiNotebookEvent>
         nb = evt.EventObject
         win = nb.CurrentPage
         if win is self.rootshell:
@@ -1515,24 +1499,12 @@ class ShellFrame(MiniFrame):
             nb.WindowStyle |= aui.AUI_NB_CLOSE_ON_ACTIVE_TAB
         nb.TabCtrlHeight = 0 if nb.PageCount == 1 else -1
         evt.Skip()
-    
-    ## def OnConsoleCloseBtn(self, evt): #<wx._aui.AuiNotebookEvent>
-    ##     tabs = evt.EventObject
-    ##     win = tabs.Pages[evt.Selection].window # GetPage for split notebook.
-    ##     if win is self.rootshell:
-    ##         ## self.message("- Don't close the root shell.")
-    ##         return
-    ##     elif self.debugger.busy and win is self.debugger.interactive_shell:
-    ##         wx.MessageBox("The debugger is running.\n\n"
-    ##                       "Enter [q]uit to exit before closing.")
-    ##         return
-    ##     evt.Skip()
-    
-    def OnConsolePageClose(self, evt): #<wx._aui.AuiNotebookEvent>
+
+    def OnConsolePageClose(self, evt):  # <wx._aui.AuiNotebookEvent>
         nb = evt.EventObject
-        win = nb.all_pages[evt.Selection]
+        win = list(nb.get_pages())[evt.Selection]
         if win is self.rootshell:
-            ## self.message("Don't close the root shell.")
+            # self.message("Don't close the root shell.")
             nb.WindowStyle &= ~aui.AUI_NB_CLOSE_ON_ACTIVE_TAB
             evt.Veto()
         elif self.debugger.busy and win is self.debugger.interactive_shell:
@@ -1541,39 +1513,37 @@ class ShellFrame(MiniFrame):
             evt.Veto()
         else:
             evt.Skip()
-    
+
     def About(self, evt=None):
         self.add_help(
             '\n\n'.join((
-                "#<module 'mwx' from {!r}>".format(__file__),
-                "Author: {!r}".format(__author__),
-                "Version: {!s}".format(__version__),
+                f"# <module 'mwx' from {__file__!r}>",
+                f"Author: {__author__!r}",
+                f"Version: {__version__!s}",
                 self.__class__.__doc__,
                 self.rootshell.__class__.__doc__,
-                
-                ## Thanks to wx.py.shell.
-                "#{!r}".format(wx.py),
-                "Author: {!r}".format(wx.py.version.__author__),
-                "Version: {!s}".format(wx.py.version.VERSION),
+                ## <--- Thanks to <wx.py.shell> --->
+                f"# {wx.py!r}",
+                f"Author: {wx.py.version.__author__!r}",
+                f"Version: {wx.py.version.VERSION!s}",
                 wx.py.shell.Shell.__doc__,
                 textwrap.indent("*original" + wx.py.shell.HELP_TEXT, ' '*4),
-                
-                ## Thanks are also due to wx.
-                "#{!r}".format(wx),
-                "To show the credit, press C-M-Mbutton.\n",
+                ## <--- Thanks are also due to <wx> --->
+                # f"#{wx!r}",
+                # f"To show the credit, press [C-M-Mbutton].",  # cf. wx.InfoMessageBox(None)
                 ))
             )
-    
+
     def toggle_window(self, win):
         pane = self._mgr.GetPane(win)
         if pane.IsDocked():
             if not self.console.IsShown():
-                self._mgr.RestoreMaximizedPane() # いったん表示切替
-                self._mgr.Update()               # 更新後に best_size 取得
+                self._mgr.RestoreMaximizedPane()  # いったん表示切替
+                self._mgr.Update()                # 更新後に best_size 取得
         if pane.IsShown():
             pane.best_size = win.Size
         self.popup_window(win, not pane.IsShown())
-    
+
     @save_focus_excursion()
     def popup_window(self, win, show=True):
         """Show the notebook page and keep the focus."""
@@ -1581,47 +1551,48 @@ class ShellFrame(MiniFrame):
             nb = pane.window
             if nb is win:
                 break
-            j = nb.GetPageIndex(win) # find and select page
+            j = nb.GetPageIndex(win)  # find and select page
             if j != -1:
                 if j != nb.Selection:
-                    nb.Selection = j # the focus moves
+                    nb.Selection = j  # the focus moves
                 break
         else:
-            return # no such pane.window
+            return  # no such pane.window
         
         ## Modify the floating position of the pane when displayed.
         ## Note: This is a known bug in wxWidgets 3.17 -- 3.20,
-        ##       and will be fixed in wxPython 4.2.1.
+        ##       and will be fixed in wx ver 4.2.1.
         if wx.Display.GetFromWindow(pane.window) == -1:
             pane.floating_pos = wx.GetMousePosition()
         
         nb.Show(show)
         pane.Show(show)
         self._mgr.Update()
-    
+
     ## --------------------------------
-    ## Actions for handler
+    ## Actions for handler.
     ## --------------------------------
-    
+
     def Quit(self, evt=None):
         """Stop debugger and monitor."""
+        self.monitor.unwatch()
         self.debugger.unwatch()
-        self.debugger.send_input('\n') # terminates the reader of threading pdb
-        shell = self.debugger.interactive_shell # reset interp locals
+        self.debugger.send_input('\n')  # terminates the reader of threading pdb
+        shell = self.debugger.interactive_shell  # reset interp locals
         del shell.locals
         del shell.globals
         self.indicator.Value = 1
         self.message("Quit")
-    
+
     @save_focus_excursion()
     def load(self, filename, lineno=0, show=True):
         """Load file @where the object is defined.
         
         Args:
-            filename : target filename:str or object.
-                       It also supports <'filename:lineno'> format.
-            lineno   : Set mark to lineno on load.
-            show     : Show the page.
+            filename: target filename:str or object.
+                      It also supports <'filename:lineno'> format.
+            lineno: Set mark to lineno on load.
+            show: Show the page.
         """
         if not isinstance(filename, str):
             filename = where(filename)
@@ -1632,18 +1603,18 @@ class ShellFrame(MiniFrame):
             if m:
                 filename, ln = m.groups()
                 lineno = int(ln)
-        editor = self.find_editor(filename) or self.Log
+        editor = next(self.get_all_editors(filename), self.Log)
         ret = editor.load_file(filename, lineno)
-        if ret:
+        if ret and show:
             self.popup_window(editor, show)
         return ret
-    
+
     def info(self, obj):
         self.rootshell.info(obj)
-    
+
     def help(self, obj):
         self.rootshell.help(obj)
-    
+
     def watch(self, obj):
         if isinstance(obj, wx.Object):
             self.monitor.watch(obj)
@@ -1652,10 +1623,12 @@ class ShellFrame(MiniFrame):
             self.linfo.watch(obj.__dict__)
             self.ginfo.watch(None)
             self.popup_window(self.linfo)
-    
+        else:
+            raise TypeError("primitive objects cannot be set as watch targets")
+
     def highlight(self, obj, *args, **kwargs):
         self.inspector.highlight(obj, *args, **kwargs)
-    
+
     def timeit(self, obj, *args, **kwargs):
         """Measure the duration cpu time (per one execution)."""
         from timeit import timeit
@@ -1673,8 +1646,8 @@ class ShellFrame(MiniFrame):
             except Exception as e:
                 print(e)
         else:
-            print("- obj is neither a string nor callable")
-    
+            print("- obj must be either a string or a callable.")
+
     def profile(self, obj, *args, **kwargs):
         """Profile a single function call."""
         from profile import Profile
@@ -1694,9 +1667,9 @@ class ShellFrame(MiniFrame):
             except TypeError as e:
                 print(e)
         else:
-            print("- obj must be callable or be a string, bytes or code object")
-    
-    ## Note: history に余計な文字列が入らないようにする
+            print("- obj must be callable, or a string, bytes, or code object.")
+
+    ## Note: history に余計な文字列が入らないようにする．
     @postcall
     def debug(self, obj, *args, **kwargs):
         shell = self.debugger.interactive_shell
@@ -1723,13 +1696,13 @@ class ShellFrame(MiniFrame):
                               style=wx.ICON_ERROR)
         finally:
             self.debugger.interactive_shell = shell
-    
+
     def on_debug_begin(self, frame):
         """Called before set_trace."""
         if not self:
             return
         shell = self.debugger.interactive_shell
-        shell.write("#<-- Enter [n]ext to continue.\n", -1)
+        shell.write("# <-- Enter [n]ext to continue.\n", -1)
         shell.prompt()
         shell.SetFocus()
         self.Show()
@@ -1739,7 +1712,7 @@ class ShellFrame(MiniFrame):
         self.indicator.Value = 2
         if wx.IsBusy():
             wx.EndBusyCursor()
-    
+
     def on_debug_next(self, frame):
         """Called from cmdloop."""
         if not self:
@@ -1760,13 +1733,13 @@ class ShellFrame(MiniFrame):
             command = re.sub(r"^(.*)", r"    \1", command, flags=re.M)
             self.add_log(command)
         self.message("Debugger is busy now (Press [C-g] to quit).")
-    
+
     def on_debug_end(self, frame):
         """Called after set_quit."""
         if not self:
             return
         shell = self.debugger.interactive_shell
-        shell.write("#--> Debugger closed successfully.\n", -1)
+        shell.write("# --> Debugger closed successfully.\n", -1)
         shell.prompt()
         self.add_log("--> End of debugger\r\n")
         self.linfo.unwatch()
@@ -1777,7 +1750,7 @@ class ShellFrame(MiniFrame):
         self.indicator.Value = 1
         if wx.IsBusy():
             wx.EndBusyCursor()
-    
+
     def set_hookable(self, editor, traceable=True):
         """Bind pointer to set/unset trace."""
         if traceable:
@@ -1786,100 +1759,103 @@ class ShellFrame(MiniFrame):
         else:
             editor.handler.unbind('pointer_set')
             editor.handler.unbind('pointer_unset')
-    
+
     def start_trace(self, line, editor):
         if not self.debugger.busy:
             self.debugger.unwatch()
             self.debugger.editor = editor
             self.debugger.watch((editor.buffer.filename, line+1))
-            self.debugger.send_input('') # clear input
-    
+            self.debugger.send_input('')  # clear input
+
     def stop_trace(self, line, editor):
         if self.debugger.busy:
             return
         if self.debugger.tracing:
             self.debugger.editor = None
             self.debugger.unwatch()
-    
+
     def on_trace_begin(self, frame):
         """Called when set-trace."""
         self.message("Debugger has started tracing {!r}.".format(frame))
         self.indicator.Value = 3
-    
+
     def on_trace_hook(self, frame):
         """Called when a breakpoint is reached."""
         self.message("Debugger hooked {!r}.".format(frame))
-    
+
     def on_trace_end(self, frame):
         """Called when unset-trace."""
         self.message("Debugger has stopped tracing {!r}.".format(frame))
         self.indicator.Value = 1
-    
+
     def on_monitor_begin(self, widget):
         """Called when monitor watch."""
         self.inspector.set_colour(widget, 'blue')
         self.message("Started monitoring {!r}.".format(widget))
-    
+
     def on_monitor_end(self, widget):
         """Called when monitor unwatch."""
         self.inspector.set_colour(widget, 'black')
         self.message("Stopped monitoring {!r}.".format(widget))
-    
+
     def on_title_window(self, obj):
         """Set title to the frame."""
         title = obj if isinstance(obj, str) else repr(obj)
         self.SetTitle("Nautilus - {}".format(title))
-    
-    def on_buffer_caption(self, buf):
-        """Called when the buffer caption is updated."""
-        if buf.caption_prefix.startswith('!'):
-            v = wx.ActivateEvent(wx.wxEVT_ACTIVATE, True,
-                                 buf.Id, ActivationReason=0)
-            self.EventHandler.ProcessEvent(v) # => self.OnActivate
-    
+
     def add_log(self, text, noerr=None):
         """Add text to the logging buffer.
-        If noerr <bool> is specified, add a line-marker.
+        If noerr:bool is specified, add a line-marker.
         """
         buf = self.Log.default_buffer or self.Log.new_buffer()
         with buf.off_readonly():
-            buf.goto_char(buf.TextLength) # line to set an arrow marker
+            buf.goto_char(buf.TextLength)  # line to set an arrow marker
             buf.write(text)
         if noerr is not None:
             ## Set a marker on the current line.
-            buf.add_marker(buf.cline, 1 if noerr else 2) # 1:white 2:red-arrow
+            buf.add_marker(buf.cline, 1 if noerr else 2)  # 1:white 2:red-arrow
             return
         
         ## Logging text every step in case of crash.
-        ## with open(self.LOGGING_FILE, 'a', encoding='utf-8', newline='') as o:
-        ##     o.write(text)
-    
-    def add_help(self, text):
-        """Add text to the help buffer."""
+        # with open(self.LOGGING_FILE, 'a', encoding='utf-8', newline='') as o:
+        #     o.write(text)
+
+    def add_help(self, text, title=None):
+        """Add text to the help buffer.
+        If title:str is specified, create a new buffer with that title.
+        """
         buf = self.Help.default_buffer or self.Help.new_buffer()
+        if title is not None:
+            self.Help.find_file(f"*{title}*")
+            buf = self.Help.buffer
         with buf.off_readonly():
-            buf.SetText(text)
+            buf.Text = text
+            buf.EmptyUndoBuffer()
+            buf.SetSavePoint()
         ## Overwrite text and popup the window.
         self.popup_window(self.Help)
         self.Help.swap_page(buf)
-    
+
     def clone_shell(self, target):
         if not hasattr(target, '__dict__'):
             raise TypeError("primitive objects cannot be targeted")
         
-        shell = self.rootshell.__class__(self, target, name="clone",
-                    style=wx.CLIP_CHILDREN|wx.BORDER_NONE)
-        self.handler('shell_new', shell)
-        self.Show()
-        self.console.AddPage(shell, typename(shell.target))
+        try:
+            shell = next(self.get_all_shells(target))
+        except StopIteration:
+            shell = self.rootshell.__class__(self, target, name="clone",
+                                             style=wx.CLIP_CHILDREN|wx.BORDER_NONE)
+            self.console.AddPage(shell, typename(shell.target))
+            self.handler('shell_new', shell)
         self.popup_window(shell)
+        self.Show()
         shell.SetFocus()
         return shell
-    
+
     def delete_shell(self, shell):
         """Close the current shell."""
         if shell is self.rootshell:
-            ## self.message("- Don't close the root shell.")
+            # self.message("- Don't close the root shell.")
             return
         if self.debugger.busy and shell is self.debugger.interactive_shell:
             wx.MessageBox("The debugger is running.\n\n"
@@ -1887,63 +1863,86 @@ class ShellFrame(MiniFrame):
             return
         j = self.console.GetPageIndex(shell)
         if j != -1:
-            self.console.DeletePage(j) # Destroy the window
-    
+            self.console.DeletePage(j)  # Destroy the window
+
     ## --------------------------------
-    ## Attributes for notebook pages
+    ## Attributes for notebook pages.
     ## --------------------------------
-    
+
     def get_all_pages(self, type=None):
         """Yields all pages of the specified type in the notebooks."""
         yield from self.console.get_pages(type)
         yield from self.ghost.get_pages(type)
-    
-    @property
-    def all_shells(self):
-        """Yields all books in the notebooks."""
-        return self.console.get_pages(type(self.rootshell))
-    
+
+    def get_all_shells(self, target=None):
+        """Yields all shells with specified target.
+        
+        If the shell is found, it switches to the corresponding page.
+        If `target` is not provided, it yields all shells in the notebooks.
+        """
+        if target is None:
+            yield from self.console.get_pages(type(self.rootshell))
+        else:
+            for shell in self.console.get_pages(type(self.rootshell)):
+                if shell.target is target:
+                    self.console.swap_page(shell)
+                    yield shell
+
+    def get_all_editors(self, fn=None):
+        """Yields all editors with specified fn:filename or code.
+        
+        If the editor is found, it switches to the corresponding page.
+        If `fn` is not provided, it yields all editors in the notebooks.
+        """
+        if fn is None:
+            yield from self.ghost.get_pages(type(self.Log))
+        else:
+            for book in self.ghost.get_pages(type(self.Log)):
+                buf = book.find_buffer(fn)
+                if buf:
+                    book.swap_page(buf)
+                    yield book
+
     @property
     def current_shell(self):
         """Currently selected shell or rootshell."""
         return self.console.CurrentPage
-    
-    @property
-    def all_editors(self):
-        """Yields all editors in the notebooks."""
-        return self.ghost.get_pages(type(self.Log))
-    
+
     @property
     def current_editor(self):
         """Currently selected editor or scratch."""
         editor = self.ghost.CurrentPage
         if isinstance(editor, type(self.Log)):
             return editor
-        return next((x for x in self.all_editors if x.IsShown()), self.Scratch)
-    
-    def find_editor(self, fn):
-        """Find an editor with the specified fn:filename or code.
-        If found, switch to the buffer page.
+        return next((book for book in self.get_all_editors() if book.IsShown()), self.Scratch)
+
+    def create_editor(self, bookname):
+        """Create a new editor (internal use only)..
+        If such an editor already exists, no new editor is created.
         """
-        return next(self.find_editors(fn), None)
-    
-    def find_editors(self, fn):
-        """Yields all editors with the specified fn:filename or code."""
-        def _f(book):
-            buf = book.find_buffer(fn)
-            if buf:
-                book.swap_page(buf)
-            return buf
-        return filter(_f, self.all_editors)
-    
+        try:
+            return next(book for book  in self.get_all_editors() if book.Name == bookname)
+        except StopIteration:
+            with wx.FrozenWindow(self.ghost):
+                editor = self.Log.__class__(self, bookname)
+                self.ghost.AddPage(editor, bookname)
+                self.ghost.move_tab(editor, 0)
+            self.handler('book_new', editor)
+            
+            def _attach():
+                editor.handler.append(self.Bookshelf.context)
+                self.Bookshelf.build_tree(clear=0)
+            wx.CallAfter(_attach)
+            return editor
+
     ## --------------------------------
-    ## Find text dialog
+    ## Find / Replace text dialog.
     ## --------------------------------
     ## *** The following code is a modification of <wx.py.frame.Frame> ***
-    
+
     __find_target = None
-    
-    def OnFindText(self, evt):
+
+    def on_search_dialog(self, evt, flags=0):
         if self.findDlg is not None:
             self.findDlg.SetFocus()
             return
@@ -1952,32 +1951,54 @@ class ShellFrame(MiniFrame):
         if not isinstance(wnd, stc.StyledTextCtrl):
             return
         self.__find_target = wnd
-        self.findData.FindString = wnd.topic_at_caret
-        self.findDlg = wx.FindReplaceDialog(wnd, self.findData, "Find",
-                            style=wx.FR_NOWHOLEWORD|wx.FR_NOUPDOWN)
+        topic = wnd.topic_at_caret
+        if topic:
+            self.findData.FindString = topic
+        self.findData.Flags |= wx.FR_DOWN
+        self.findDlg = wx.FindReplaceDialog(wnd, self.findData, "Find", flags)
         self.findDlg.Show()
-    
-    def OnFindNext(self, evt, backward=False): #<wx._core.FindDialogEvent>
-        data = self.findData
-        down_p = data.Flags & wx.FR_DOWN
-        if (backward and down_p) or (not backward and not down_p):
-            data.Flags ^= wx.FR_DOWN # toggle up/down flag
-        
-        wnd = wx.Window.FindFocus()
-        if not isinstance(wnd, stc.StyledTextCtrl):
-            wnd = self.__find_target
-            if not wnd:
-                return
-        wnd.DoFindNext(data, self.findDlg or wnd)
-        if self.findDlg:
-            self.OnFindClose(None)
-        wnd.EnsureVisible(wnd.cline)
-        wnd.EnsureLineMoreOnScreen(wnd.cline)
-    
-    def OnFindPrev(self, evt):
+
+    def on_replace_dialog(self, evt):
+        self.on_search_dialog(evt, flags=wx.FR_REPLACEDIALOG)
+
+    def repeat_forward_search(self, evt):
+        self.OnFindNext(evt, backward=False)
+
+    def repeat_backward_search(self, evt):
         self.OnFindNext(evt, backward=True)
-    
-    def OnFindClose(self, evt): #<wx._core.FindDialogEvent>
+
+    def OnFindNext(self, evt, backward=None):  # <wx._core.FindDialogEvent>
+        if not self.findData.FindString:
+            self.message("No last search.")
+            return
+        if isinstance(evt, wx.FindDialogEvent):
+            wnd = self.findDlg.Parent
+        else:
+            wnd = evt.EventObject
+            if not isinstance(wnd, stc.StyledTextCtrl):
+                wnd = self.__find_target
+            if backward:
+                self.findData.Flags &= ~wx.FR_DOWN
+            else:
+                self.findData.Flags |= wx.FR_DOWN
+        
+        if evt.EventType == wx.EVT_FIND_REPLACE_ALL.typeId:  # replace-all
+            n = wnd.DoReplaceAll(self.findData)
+            self.message(f"Replaced {n} strings.")
+            if self.findDlg:
+                self.OnFindClose(None)
+            return
+        elif evt.EventType == wx.EVT_FIND_REPLACE.typeId:  # replace
+            loc = wnd.DoReplaceNext(self.findData)
+        else:
+            loc = wnd.DoFindNext(self.findData)
+            if self.findDlg:
+                if not (self.findDlg.WindowStyle & wx.FR_REPLACEDIALOG):  # for search-dialog
+                    self.OnFindClose(None)
+        if loc < 0:
+            self.message("Unable to find the search text.")
+
+    def OnFindClose(self, evt):  # <wx._core.FindDialogEvent>
         self.findDlg.Destroy()
         self.findDlg = None
 
@@ -1989,7 +2010,7 @@ def filling(obj=None, **kwargs):
                          rootLabel=typename(obj),
                          pos=wx.GetMousePosition(),
                          **kwargs)
-    frame.filling.text.WrapMode = 0 # no wrap
-    frame.filling.text.Zoom = -1 # zoom level of size of fonts
+    frame.filling.text.WrapMode = 0  # no wrap
+    frame.filling.text.Zoom = -1  # zoom level of size of fonts
     frame.Show()
     return frame