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

mwx/graphman.py

@@ -1,74 +1,59 @@
 #! python3
 """Graph manager.
 """
+from contextlib import contextmanager
+from datetime import datetime
 from functools import wraps
 from importlib import reload, import_module
-from contextlib import contextmanager
-from pprint import pformat
 from bdb import BdbQuit
-import subprocess
 import threading
 import traceback
 import inspect
+import types
 import sys
 import os
 import platform
-import re
+import json
 import wx
 from wx import aui
+from wx import stc
+
+import numpy as np
+from numpy import nan, inf  # noqa # necessary to eval
 
 from matplotlib import cm
 from matplotlib import colors
-## from matplotlib import pyplot as plt
-import numpy as np
 from PIL import Image
 from PIL.TiffImagePlugin import TiffImageFile
 
 from . import framework as mwx
-from .utilus import ignore, warn
 from .utilus import funcall as _F
+from .utilus import ignore, warn, fix_fnchars
 from .controls import KnobCtrlPanel, Icon
 from .framework import CtrlInterface, AuiNotebook, Menu, FSM
-
-from .matplot2 import MatplotPanel # noqa
 from .matplot2g import GraphPlot
-from .matplot2lg import LinePlot # noqa
-from .matplot2lg import LineProfile # noqa
 from .matplot2lg import Histogram
 
 
-def split_paths(obj):
-    """Split obj path into dirname and basename.
-    The object can be module name:str, module, or class.
-    """
-    if hasattr(obj, '__file__'): #<class 'module'>
-        obj = obj.__file__
-    elif isinstance(obj, type):  #<class 'type'>
-        obj = inspect.getsourcefile(obj)
-    if obj.endswith(".py"):
-        obj, _ = os.path.splitext(obj)
-    return os.path.split(obj)
-
-
 class Thread:
     """Thread manager for graphman.Layer
     
     The worker:thread runs the given target.
     
     Attributes:
-        target  : A target method of the Layer.
-        result  : A variable that retains the last retval of f.
-        worker  : Reference of the worker thread.
-        owner   : Reference of the handler owner (was typ. f.__self__).
-                  If None, the thread_event is handled by its own handler.
-        event   : A common event flag to interrupt the process.
+        target: A target method of the Layer.
+        result: A variable that retains the last retval of f.
+        worker: Reference of the worker thread.
+        owner: Reference of the handler owner (was typ. f.__self__).
+               If None, the thread_event is handled by its own handler.
+        event: A common event flag to interrupt the process.
     
     There are two flags to check the thread status:
     
-     - active   : A flag of being kept going.
-                  Check this to see the worker is running and intended being kept going.
-     - running  : A flag of being running now.
-                  Watch this to verify the worker is alive after it has been inactivated.
+     - active: A flag of being kept going.
+               Check this to see the worker is running and intended being kept going.
+     - running: A flag of being running now.
+                Watch this to verify the worker is alive after it has been inactivated.
     
     The event object can be used to suspend/resume the thread:
     
@@ -84,7 +69,7 @@ class Thread:
         if self.worker:
             return self.worker.is_alive()
         return False
-    
+
     def __init__(self, owner=None):
         self.owner = owner
         self.worker = None
@@ -98,26 +83,22 @@ class Thread:
         except AttributeError:
             self.handler = FSM({ # DNA<Thread>
                 None : {
-                 'thread_begin' : [ None ], # begin processing
-                   'thread_end' : [ None ], # end processing
-                  'thread_quit' : [ None ], # terminated by user
-                 'thread_error' : [ None ], # failed in error
+                 'thread_begin' : [ None ],
+                   'thread_end' : [ None ],
                 },
             })
-    
+
     def __del__(self):
         if self.active:
             self.Stop()
-    
+
     @contextmanager
     def entry(self):
         """Exclusive reentrant lock manager.
         Allows only this worker (but no other thread) to enter.
         """
         frame = inspect.currentframe().f_back.f_back
-        filename = frame.f_code.co_filename
         name = frame.f_code.co_name
-        fname, _ = os.path.splitext(os.path.basename(filename))
         
         ## Other threads are not allowed to enter.
         ct = threading.current_thread()
@@ -125,75 +106,89 @@ class Thread:
         
         ## The thread must be activated to enter.
         ## assert self.active, f"{self!r} must be activated to enter {name!r}."
-        try:
-            self.handler(f"{fname}/{name}:enter", self)
-            yield self
-        except Exception:
-            self.handler(f"{fname}/{name}:error", self)
-            raise
-        finally:
-            self.handler(f"{fname}/{name}:exit", self)
-    
+        yield self
+
+    def enters(self, f):
+        """Decorator to add a one-time handler for the enter event.
+        The specified function will be called from the main thread.
+        """
+        return self.handler.binds('thread_begin', _F(f))
+
+    def exits(self, f):
+        """Decorator to add a one-time handler for the exit event.
+        The specified function will be called from the main thread.
+        """
+        return self.handler.binds('thread_end', _F(f))
+
     def wraps(self, f, *args, **kwargs):
-        """Decorator of thread starter function."""
+        """Decorator for a function that starts a new thread."""
         @wraps(f)
         def _f(*v, **kw):
             return self.Start(f, *v, *args, **kw, **kwargs)
         return _f
-    
+
     def check(self, timeout=None):
         """Check the thread event flags."""
         if not self.running:
             return None
-        if not self.event.wait(timeout): # wait until set in time
+        if not self.event.wait(timeout):  # wait until set in time
             raise KeyboardInterrupt("timeout")
         if not self.active:
             raise KeyboardInterrupt("terminated by user")
         return True
-    
-    def pause(self, msg="Pausing..."):
+
+    def pause(self, msg=None, caption=wx.MessageBoxCaptionStr):
         """Pause the thread.
+        Confirm whether to terminate the thread.
         
-        Use ``check`` method where you want to pause.
+        Returns:
+            True:  [OK] if terminating.
+            False: [CANCEL] otherwise.
         
         Note:
+            Use ``check`` method where you want to pause.
             Even after the message dialog is displayed, the thread
             does not suspend until check (or event.wait) is called.
         """
         if not self.running:
             return None
+        if not msg:
+            msg = ("The thread is running.\n\n"
+                   "Do you want to terminate the thread?")
         try:
-            self.event.clear() # suspend
-            if wx.MessageBox(msg + "\n\n"
-                    "Press [OK] to continue.\n"
-                    "Press [CANCEL] to terminate the process.",
-                    style=wx.OK|wx.CANCEL|wx.ICON_WARNING) != wx.OK:
+            self.event.clear()  # suspend
+            if wx.MessageBox(   # Confirm closing the thread.
+                    msg, caption,
+                    style=wx.OK|wx.CANCEL|wx.ICON_WARNING) == wx.OK:
                 self.Stop()
-                return False
-            return True
+                return True
+            return False
         finally:
-            self.event.set() # resume
-    
+            self.event.set()  # resume
+
     def Start(self, f, *args, **kwargs):
-        """Start the thread to run the specified function."""
+        """Start the thread to run the specified function.
+        """
         @wraps(f)
         def _f(*v, **kw):
             try:
-                self.handler('thread_begin', self)
+                wx.CallAfter(self.handler, 'thread_begin', self)
                 self.result = f(*v, **kw)
             except BdbQuit:
                 pass
             except KeyboardInterrupt as e:
-                print("- Thread:execution stopped:", e)
-            except AssertionError as e:
-                print("- Thread:execution failed:", e)
+                print("- Thread terminated by user:", e)
             except Exception as e:
+                print("- Thread failed in error:", e)
                 traceback.print_exc()
-                print("- Thread:exception:", e)
-                self.handler('thread_error', self)
+                tbstr = traceback.format_tb(e.__traceback__)
+                wx.CallAfter(wx.MessageBox,
+                             f"{e}\n\n" + tbstr[-1] + f"{type(e).__name__}: {e}",
+                             f"Error in the thread running {f.__name__!r}\n\n",
+                             style=wx.ICON_ERROR)
             finally:
                 self.active = 0
-                self.handler('thread_end', self)
+                wx.CallAfter(self.handler, 'thread_end', self)
         
         if self.running:
             wx.MessageBox("The thread is running (Press [C-g] to quit).",
@@ -207,81 +202,86 @@ class Thread:
                                 args=args, kwargs=kwargs, daemon=True)
         self.worker.start()
         self.event.set()
-    
+
     def Stop(self):
         """Stop the thread.
         
-        Use ``check`` method where you want to quit.
+        Note:
+            Use ``check`` method where you want to stop.
+            Even after the message dialog is displayed, the thread
+            does not suspend until check (or event.wait) is called.
         """
         def _stop():
             with wx.BusyInfo("One moment please, "
                              "waiting for threads to die..."):
-                self.handler('thread_quit', self)
                 self.worker.join(1)
         if self.running:
             self.active = 0
-            wx.CallAfter(_stop) # main-thread で終了させる
+            wx.CallAfter(_stop)  # main thread で終了させる
 
 
 class LayerInterface(CtrlInterface):
-    """Graphman.Layer interface mixin
+    """Graphman.Layer interface mixin.
     
     The layer properties can be switched by the following classvars::
     
-        menukey     : menu item key:str in parent menubar
-        category    : title of notebook holder, otherwise None for single pane
-        caption     : flag to set the pane caption to be visible
-                      a string can also be specified (default is __module__)
-        dockable    : flag to set the pane to be dockable
-                      type: bool or dock:int (1:t, 2:r, 3:b, 4:l, 5:c)
-        reloadable  : flag to set the Layer to be reloadable
-        unloadable  : flag to set the Layer to be unloadable
+        menukey:  menu item key:str in parent menubar
+        category: title of notebook holder, otherwise None for single pane
+        caption:  flag to set the pane caption to be visible
+                  a string can also be specified (default is __module__)
+        dockable: flag to set the pane to be dockable
+                  type: bool or dock:int (1:t, 2:r, 3:b, 4:l, 5:c)
+        reloadable: flag to set the Layer to be reloadable
+        unloadable: flag to set the Layer to be unloadable
     
     Note:
         parent <Frame> is not always equal to Parent when floating.
         Parent type can be <Frame>, <AuiFloatingFrame>, or <AuiNotebook>.
     """
-    MENU = "Plugins" # default menu for Plugins
+    MENU = "Plugins"  # default menu for Plugins
     menukey = "Plugins/"
     caption = True
     category = None
     dockable = True
-    editable = True # deprecated
     reloadable = True
     unloadable = True
-    
+
     graph = property(lambda self: self.parent.graph)
     output = property(lambda self: self.parent.output)
     histogram = property(lambda self: self.parent.histogram)
     selected_view = property(lambda self: self.parent.selected_view)
-    
+
     message = property(lambda self: self.parent.message)
-    
+
     ## thread_type = Thread
     thread = None
-    
+
+    ## layout helper function (internal use only)
+    pack = mwx.pack
+
+    ## funcall = interactive_call (internal use only)
+    funcall = staticmethod(_F)
+
     ## for debug (internal use only)
     pane = property(lambda self: self.parent.get_pane(self))
-    
+
     @property
     def Arts(self):
-        """List of arts <matplotlib.artist.Artist>."""
+        """List of artists <matplotlib.artist.Artist>."""
         return self.__artists
-    
+
     @Arts.setter
     def Arts(self, arts):
-        for art in self.__artists[:]:
-            if art not in arts:
-                art.remove()
-                self.__artists.remove(art)
-        self.__artists = arts
-    
+        for art in (set(self.__artists) - set(arts)):
+            art.remove()
+        self.__artists = list(arts)
+
     @Arts.deleter
     def Arts(self):
         for art in self.__artists:
             art.remove()
         self.__artists = []
-    
+
     def attach_artists(self, axes, *artists):
         """Attach artists (e.g., patches) to the given axes."""
         for art in artists:
@@ -289,17 +289,8 @@ class LayerInterface(CtrlInterface):
                 art.remove()
                 art._transformSet = False
             axes.add_artist(art)
-            if art not in self.__artists:
-                self.__artists.append(art)
-    
-    def detach_artists(self, *artists):
-        """Detach artists (e.g., patches) from their axes."""
-        for art in artists:
-            if art.axes:
-                art.remove()
-                art._transformSet = False
-            self.__artists.remove(art)
-    
+        self.Arts += [art for art in artists if art not in self.Arts]
+
     def __init__(self, parent, session=None):
         if hasattr(self, 'handler'):
             warn(f"Duplicate iniheritance of CtrlInterface by {self}.")
@@ -315,27 +306,28 @@ class LayerInterface(CtrlInterface):
         except AttributeError:
             self.parameters = None
         
-        def copy_params(**kwargs):
-            if self.parameters:
-                return self.copy_to_clipboard(**kwargs)
+        def copy_params(evt, checked_only=False):
+            if isinstance(evt.EventObject, (wx.TextEntry, stc.StyledTextCtrl)):
+                evt.Skip()
+            elif self.parameters:
+                self.copy_to_clipboard(checked_only)
         
-        def paste_params(**kwargs):
-            if self.parameters:
-                return self.paste_from_clipboard(**kwargs)
+        def paste_params(evt, checked_only=False):
+            if isinstance(evt.EventObject, (wx.TextEntry, stc.StyledTextCtrl)):
+                evt.Skip()
+            elif self.parameters:
+                self.paste_from_clipboard(checked_only)
         
-        def reset_params(**kwargs):
+        def reset_params(evt, checked_only=False):
             self.Draw(None)
             if self.parameters:
-                return self.set_params(**kwargs)
+                self.reset_params(checked_only)
         
         self.handler.append({ # DNA<Layer>
             None : {
-                 'thread_begin' : [ None ], # begin processing
-                   'thread_end' : [ None ], # end processing
-                  'thread_quit' : [ None ], # terminated by user
-                 'thread_error' : [ None ], # failed in error
-                   'page_shown' : [ None, _F(self.Draw, True)  ],
-                  'page_closed' : [ None, _F(self.Draw, False) ],
+                   'page_shown' : [ None, _F(self.Draw, show=True)  ],
+                  'page_closed' : [ None, _F(self.Draw, show=False) ],
+                  'page_hidden' : [ None, _F(self.Draw, show=False) ],
             },
             0 : {
                   'C-c pressed' : (0, _F(copy_params)),
@@ -348,43 +340,40 @@ class LayerInterface(CtrlInterface):
         })
         self.menu = [
             (wx.ID_COPY, "&Copy params\t(C-c)", "Copy params",
-                lambda v: copy_params(checked_only=wx.GetKeyState(wx.WXK_SHIFT)),
+                lambda v: copy_params(v, checked_only=wx.GetKeyState(wx.WXK_SHIFT)),
                 lambda v: v.Enable(bool(self.parameters))),
                 
             (wx.ID_PASTE, "&Paste params\t(C-v)", "Read params",
-                lambda v: paste_params(checked_only=wx.GetKeyState(wx.WXK_SHIFT)),
+                lambda v: paste_params(v, checked_only=wx.GetKeyState(wx.WXK_SHIFT)),
                 lambda v: v.Enable(bool(self.parameters))),
             (),
             (wx.ID_RESET, "&Reset params\t(C-n)", "Reset params", Icon('-'),
-                lambda v: reset_params(checked_only=wx.GetKeyState(wx.WXK_SHIFT)),
+                lambda v: reset_params(v, checked_only=wx.GetKeyState(wx.WXK_SHIFT)),
                 lambda v: v.Enable(bool(self.parameters))),
             (),
-            (wx.ID_EDIT, "&Edit module", "Edit module", Icon('pen'),
-                lambda v: self.parent.edit_plug(self.__module__),
-                lambda v: v.Enable(self.editable)),
-                
-            (mwx.ID_(201), "&Reload module", "Reload module", Icon('load'),
-                lambda v: self.parent.reload_plug(self.__module__),
+            (mwx.ID_(201), "&Reload module", "Reload", Icon('load'),
+                lambda v: self.parent.reload_plug(self),
                 lambda v: v.Enable(self.reloadable
                             and not (self.thread and self.thread.active))),
                 
-            (mwx.ID_(202), "&Unload module", "Unload module", Icon('delete'),
-                lambda v: self.parent.unload_plug(self.__module__),
+            (mwx.ID_(202), "&Unload module", "Unload", Icon('delete'),
+                lambda v: self.parent.unload_plug(self),
                 lambda v: v.Enable(self.unloadable
                             and not (self.thread and self.thread.active))),
             (),
             (mwx.ID_(203), "&Dive into {!r}".format(self.__module__), "dive", Icon('core'),
-                lambda v: self.parent.inspect_plug(self.__module__)),
+                lambda v: self.parent.inspect_plug(self)),
         ]
         self.Bind(wx.EVT_CONTEXT_MENU,
                   lambda v: Menu.Popup(self, self.menu))
         
         self.Bind(wx.EVT_WINDOW_DESTROY, self.OnDestroy)
+        self.Bind(wx.EVT_SHOW, self.OnShow)
         
         try:
             self.Init()
         except Exception as e:
-            traceback.print_exc()
+            traceback.print_exc()  # Failed to initialize the plug.
             if parent:
                 bmp = wx.StaticBitmap(self, bitmap=Icon('!!!'))
                 txt = wx.StaticText(self, label="Exception")
@@ -394,59 +383,68 @@ class LayerInterface(CtrlInterface):
             if session:
                 self.load_session(session)
         except Exception:
-            traceback.print_exc()
-            print("- Failed to load session of", self)
-    
+            traceback.print_exc()  # Failed to load the plug session.
+
     def Init(self):
         """Initialize layout before load_session (to be overridden)."""
         pass
-    
+
     def load_session(self, session):
         """Restore settings from a session file (to be overridden)."""
         if 'params' in session:
             self.parameters = session['params']
-    
+
     def save_session(self, session):
         """Save settings in a session file (to be overridden)."""
         if self.parameters:
             session['params'] = self.parameters
-    
+
     def OnDestroy(self, evt):
         if evt.EventObject is self:
             if self.thread and self.thread.active:
-                self.thread.active = 0
+                # self.thread.active = 0
                 self.thread.Stop()
             del self.Arts
         evt.Skip()
-    
+
+    def OnShow(self, evt):
+        if not self:
+            return
+        if isinstance(self.Parent, aui.AuiNotebook):
+            if evt.IsShown():
+                self.handler('page_shown', self)
+            else:
+                self.handler('page_hidden', self)
+        evt.Skip()
+
     Shown = property(
         lambda self: self.IsShown(),
-        lambda self,v: self.Show(v))
-    
+        lambda self, v: self.Show(v))
+
     def IsShown(self):
-        """Returns True if the window is physically visible on the screen.
+        """Return True if the window is physically visible on the screen.
         
         (override) Equivalent to ``IsShownOnScreen``.
                    Note: The instance could be a page within a notebook.
         """
-        ## return self.pane.IsShown()
+        # return self.pane.IsShown()
         return self.IsShownOnScreen()
-    
-    def Show(self, show=True):
+
+    def Show(self, show=True, interactive=False):
         """Shows or hides the window.
         
         (override) Show associated pane window.
                    Note: This might be called from a thread.
         """
-        wx.CallAfter(self.parent.show_pane, self, show)
-    
+        wx.CallAfter(self.parent.show_pane, self, show, interactive)  # Use main thread.
+
     Drawn = property(
         lambda self: self.IsDrawn(),
-        lambda self,v: self.Draw(v))
-    
+        lambda self, v: self.Draw(v))
+
     def IsDrawn(self):
         return any(art.get_visible() for art in self.Arts)
-    
+
     def Draw(self, show=None):
         """Draw artists.
         If show is None:default, draw only when the pane is visible.
@@ -476,12 +474,33 @@ class Layer(LayerInterface, KnobCtrlPanel):
         LayerInterface.__init__(self, parent, session)
 
 
+def _register__dummy_plug__(cls, module):
+    if issubclass(cls, LayerInterface):
+        # warn(f"Duplicate iniheritance of LayerInterface by {cls}.")
+        module.Plugin = cls
+        return cls
+
+    class _Plugin(cls, LayerInterface):
+        def __init__(self, parent, session=None, **kwargs):
+            cls.__init__(self, parent, **kwargs)
+            LayerInterface.__init__(self, parent, session)
+        Show = LayerInterface.Show
+        IsShown = LayerInterface.IsShown
+
+    _Plugin.__module__ = module.__name__
+    _Plugin.__qualname__ = cls.__qualname__ + "~"
+    _Plugin.__name__ = cls.__name__ + "~"
+    _Plugin.__doc__ = cls.__doc__
+    module.Plugin = _Plugin
+    return _Plugin
+
+
 class Graph(GraphPlot):
     """GraphPlot (override) to better make use for graph manager
     
     Attributes:
-        parent : Parent window (usually mainframe)
-        loader : mainframe
+        parent: Parent window (usually mainframe)
+        loader: mainframe
     """
     def __init__(self, parent, loader=None, **kwargs):
         GraphPlot.__init__(self, parent, **kwargs)
@@ -499,76 +518,64 @@ class Graph(GraphPlot):
                    'f5 pressed' : [ None, _F(self.refresh) ],
             },
         })
-        ## ドロップターゲットを許可する
+        ## ドロップターゲットを許可する．
         self.SetDropTarget(MyFileDropLoader(self, self.loader))
-    
+
     def refresh(self):
         if self.frame:
             self.frame.update_buffer()
             self.draw()
-    
+
     def toggle_infobar(self):
         """Toggle infobar (frame.annotation)."""
         if self.infobar.IsShown():
             self.infobar.Dismiss()
         elif self.frame:
             self.infobar.ShowMessage(self.frame.annotation)
-    
+
     def update_infobar(self, frame):
         """Show infobar (frame.annotation)."""
         if self.infobar.IsShown():
             self.infobar.ShowMessage(frame.annotation)
-    
-    def get_markups_visible(self):
-        return self.marked.get_visible()
-    
-    def set_markups_visible(self, v):
-        self.selected.set_visible(v)
-        self.marked.set_visible(v)
-        self.rected.set_visible(v)
-        self.update_art_of_mark()
-    
-    def remove_markups(self):
-        del self.Selector
-        del self.Markers
-        del self.Region
-    
+
     def hide_layers(self):
-        for name in self.parent.plugins:
-            plug = self.parent.get_plug(name)
+        for plug in self.parent.get_all_plugs():
             for art in plug.Arts:
                 art.set_visible(0)
-        self.remove_markups()
+        del self.selector
+        del self.markers
+        del self.region
         self.draw()
 
 
 class MyFileDropLoader(wx.FileDropTarget):
-    """File Drop interface
+    """File Drop interface.
     
     Args:
-        target : target view to drop in, e.g. frame, graph, pane, etc.
-        loader : mainframe
+        target: target view to drop in, e.g. frame, graph, pane, etc.
+        loader: mainframe
     """
     def __init__(self, target, loader):
         wx.FileDropTarget.__init__(self)
         
         self.view = target
         self.loader = loader
-    
+
     def OnDropFiles(self, x, y, filenames):
-        pos = self.view.ScreenPosition + (x,y)
+        pos = self.view.ScreenPosition + (x, y)
         paths = []
         for fn in filenames:
-            name, ext = os.path.splitext(fn)
+            _name, ext = os.path.splitext(fn)
             if ext == '.py' or os.path.isdir(fn):
-                self.loader.load_plug(fn, show=1, floating_pos=pos,
-                                      force=wx.GetKeyState(wx.WXK_ALT))
+                self.loader.load_plug(fn, show=1,
+                                          floating_pos=pos,
+                                          force=wx.GetKeyState(wx.WXK_ALT))
             elif ext == '.jssn':
                 self.loader.load_session(fn)
             elif ext == '.index':
                 self.loader.load_index(fn, self.view)
             else:
-                paths.append(fn) # image file just stacks to be loaded
+                paths.append(fn)  # image file just stacks to be loaded
         if paths:
             self.loader.load_frame(paths, self.view)
         return True
@@ -586,24 +593,24 @@ class Frame(mwx.Frame):
     graph = property(lambda self: self.__graph)
     output = property(lambda self: self.__output)
     histogram = property(lambda self: self.__histgrm)
-    
+
     selected_view = property(lambda self: self.__view)
-    
+
     def select_view(self, view):
         self.__view = view
         self.set_title(view.frame)
-    
+
     @property
     def graphic_windows(self):
         """Graphic windows list.
         [0] graph [1] output [2:] others(user-defined)
         """
         return self.__graphic_windows
-    
+
     @property
     def graphic_windows_on_screen(self):
         return [w for w in self.__graphic_windows if w.IsShownOnScreen()]
-    
+
     def __init__(self, *args, **kwargs):
         mwx.Frame.__init__(self, *args, **kwargs)
         
@@ -611,10 +618,10 @@ class Frame(mwx.Frame):
         self._mgr.SetManagedWindow(self)
         self._mgr.SetDockSizeConstraint(0.5, 0.5)
         
-        self.__plugins = {} # modules in the order of load/save
+        self.__plugins = {}  # modules in the order of load/save
         
-        self.__graph = Graph(self, log=self.message, margin=None, size=(600,600))
-        self.__output = Graph(self, log=self.message, margin=None, size=(600,600))
+        self.__graph = Graph(self, log=self.message, margin=None)
+        self.__output = Graph(self, log=self.message, margin=None)
         
         self.__histgrm = Histogram(self, log=self.message, margin=None, size=(130,65))
         self.__histgrm.attach(self.graph)
@@ -632,7 +639,7 @@ class Frame(mwx.Frame):
         self.histogram.Name = "histogram"
         
         self._mgr.AddPane(self.graph,
-                          aui.AuiPaneInfo().CenterPane().CloseButton(1)
+                          aui.AuiPaneInfo().CenterPane()
                              .Name("graph").Caption("graph").CaptionVisible(1))
         
         size = (200, 200)
@@ -664,7 +671,7 @@ class Frame(mwx.Frame):
                 lambda v: v.Enable(self.__view.frame is not None)),
                 
             (wx.ID_SAVEAS, "&Save as TIFFs", "Save buffers as a multi-page tiff", Icon('saveall'),
-                lambda v: self.save_buffers_as_tiffs(),
+                lambda v: self.save_frames_as_tiff(),
                 lambda v: v.Enable(self.__view.frame is not None)),
             (),
             ("Index", (
@@ -687,7 +694,7 @@ class Frame(mwx.Frame):
                     lambda v: self.save_session_as()),
                 )),
             (),
-            ("Options", []), # reserved for optional app settings
+            ("Options", []),  # reserved for optional app settings
             (),
             (mwx.ID_(13), "&Graph window\tF9", "Show graph window", wx.ITEM_CHECK,
                 lambda v: self.show_pane(self.graph, v.IsChecked()),
@@ -705,44 +712,37 @@ class Frame(mwx.Frame):
             (wx.ID_PASTE, "&Paste\t(C-v)", "Paste buffer from clipboard", Icon('paste'),
                 lambda v: self.__view.read_buffer_from_clipboard()),
             (),
-            (mwx.ID_(21), "Toggle &Markers", "Show/Hide markups", wx.ITEM_CHECK, Icon('+'),
-                lambda v: self.__view.set_markups_visible(v.IsChecked()),
-                lambda v: v.Check(self.__view.get_markups_visible())),
-                
-            (mwx.ID_(22), "&Remove Markers", "Remove markups", Icon('-'),
-                lambda v: self.__view.remove_markups()),
-            (),
-            (mwx.ID_(23), "Hide all &Layers", "Hide all layers", Icon('xr'),
+            (mwx.ID_(23), "Hide all &layers", "Hide all layers", Icon('xr'),
                 lambda v: self.__view.hide_layers()),
             (),
-            (mwx.ID_(24), "&Histogram\tCtrl-h", "Show Histogram window", wx.ITEM_CHECK,
+            (mwx.ID_(24), "&Histogram\tCtrl-h", "Show histogram window", wx.ITEM_CHECK,
                 lambda v: self.show_pane(self.histogram, v.IsChecked()),
                 lambda v: v.Check(self.histogram.IsShownOnScreen())),
                 
-            (mwx.ID_(25), "&Invert Color\t(C-i)", "Invert colormap", wx.ITEM_CHECK,
+            (mwx.ID_(25), "&Invert color\t(C-i)", "Invert colormap", wx.ITEM_CHECK,
                 lambda v: self.__view.invert_cmap(),
-                lambda v: v.Check(self.__view.get_cmap()[-2:] == "_r")),
+                lambda v: v.Check(self.__view.get_cmapstr()[-2:] == "_r")),
         ]
         
         def _cmenu(i, name):
             return (mwx.ID_(30 + i), "&" + name, name, wx.ITEM_CHECK,
-                lambda v: self.__view.set_cmap(name),
-                lambda v: v.Check(self.__view.get_cmap() == name
-                               or self.__view.get_cmap() == name+"_r"),
+                lambda v: self.__view.set_cmapstr(name),
+                lambda v: v.Check(self.__view.get_cmapstr() == name
+                               or self.__view.get_cmapstr() == name+"_r"),
             )
         colours = [c for c in dir(cm) if c[-2:] != "_r"
                     and isinstance(getattr(cm, c), colors.LinearSegmentedColormap)]
         
         self.menubar["Edit"] += [
             (),
-            ## (mwx.ID_(26), "Default Color", "gray", wx.ITEM_CHECK,
-            ##     lambda v: self.__view.set_cmap('gray'),
-            ##     lambda v: v.Check(self.__view.get_cmap()[:4] == "gray")),
-            ##     
-            ("Standard Colors",
+            # (mwx.ID_(26), "Default Color", "gray", wx.ITEM_CHECK,
+            #     lambda v: self.__view.set_cmapstr('gray'),
+            #     lambda v: v.Check(self.__view.get_cmapstr()[:4] == "gray")),
+            #     
+            ("Standard colors",
                 [_cmenu(i, c) for i, c in enumerate(colours) if c.islower()]),
                 
-            ("Other Colors",
+            ("Other colors",
                 [_cmenu(i, c) for i, c in enumerate(colours) if not c.islower()]),
         ]
         
@@ -757,7 +757,8 @@ class Frame(mwx.Frame):
         self.menubar.reset()
         
         def show_frameview(frame):
-            wx.CallAfter(self.show_pane, frame.parent) # Show graph / output
+            if not frame.parent.IsShown():
+                wx.CallAfter(self.show_pane, frame.parent)
         
         self.graph.handler.append({ # DNA<Graph:Frame>
             None : {
@@ -778,9 +779,9 @@ class Frame(mwx.Frame):
             },
         })
         
-        ## Add main-menu to context-menu
-        self.graph.menu += self.menubar["Edit"][2:7]
-        self.output.menu += self.menubar["Edit"][2:7]
+        ## Add main-menu to context-menu.
+        self.graph.menu += self.menubar["Edit"][2:4]
+        self.output.menu += self.menubar["Edit"][2:4]
         
         self._mgr.Bind(aui.EVT_AUI_PANE_CLOSE, self.OnPaneClose)
         
@@ -796,10 +797,10 @@ class Frame(mwx.Frame):
             _display(self.graph, show)
             _display(self.output, show)
             evt.Skip()
-        self.Bind(wx.EVT_MOVE_START, lambda v :on_move(v, show=0))
-        self.Bind(wx.EVT_MOVE_END, lambda v :on_move(v, show=1))
+        self.Bind(wx.EVT_MOVE_START, lambda v: on_move(v, show=0))
+        self.Bind(wx.EVT_MOVE_END, lambda v: on_move(v, show=1))
         
-        ## Custom Key Bindings
+        ## Custom Key Bindings.
         self.define_key('* C-g', self.Quit)
         
         @self.shellframe.define_key('* C-g')
@@ -807,36 +808,33 @@ class Frame(mwx.Frame):
             """Dispatch quit to the main Frame."""
             self.handler('C-g pressed', evt)
         
-        ## Accepts DnD
+        ## Accepts DnD.
         self.SetDropTarget(MyFileDropLoader(self.graph, self))
-        
-        ## Script editor for plugins (external call)
-        self.Editor = "notepad"
-    
-    sync_switch = True
-    
+
+    SYNC_SWITCH = True
+
     def sync(self, a, b):
         """Synchronize b to a."""
-        if (self.sync_switch
-            and a.frame and b.frame
-            and a.frame.unit == b.frame.unit
-            and a.buffer.shape == b.buffer.shape):
-                b.xlim = a.xlim
-                b.ylim = a.ylim
-                b.OnDraw(None)
-                b.canvas.draw_idle()
-    
+        if (self.SYNC_SWITCH
+                and a.frame and b.frame
+                and a.frame.unit == b.frame.unit
+                and a.buffer.shape == b.buffer.shape):
+            b.xlim = a.xlim
+            b.ylim = a.ylim
+            b.OnDraw(None)
+            b.canvas.draw_idle()
+
     def set_title(self, frame):
         ssn = os.path.basename(self.session_file or '--')
         ssn, _ = os.path.splitext(ssn)
         name = (frame.pathname or frame.name) if frame else ''
         self.SetTitle("{}@{} - [{}] {}".format(self.Name, platform.node(), ssn, name))
-    
-    def OnActivate(self, evt): #<wx._core.ActivateEvent>
+
+    def OnActivate(self, evt):  #<wx._core.ActivateEvent>
         if self and evt.Active:
             self.set_title(self.selected_view.frame)
-    
-    def OnClose(self, evt): #<wx._core.CloseEvent>
+
+    def OnClose(self, evt):  #<wx._core.CloseEvent>
         ssn = os.path.basename(self.session_file or '--')
         with wx.MessageDialog(None,
                 "Do you want to save session before closing program?",
@@ -848,66 +846,69 @@ class Frame(mwx.Frame):
             elif ret == wx.ID_CANCEL:
                 evt.Veto()
                 return
-        for name in self.plugins:
-            plug = self.get_plug(name)
-            if plug.thread and plug.thread.active:
-                if wx.MessageBox( # Confirm thread close.
-                        "The thread is running.\n\n"
-                        "Enter [q]uit to exit before closing.\n"
-                        "Continue closing?",
-                        "Close {!r}".format(plug.Name),
-                        style=wx.YES_NO|wx.ICON_INFORMATION) != wx.YES:
-                    self.message("The close has been canceled.")
-                    evt.Veto()
-                    return
-                self.Quit()
-                break
-        for frame in self.graph.all_frames:
-            if frame.pathname is None:
-                if wx.MessageBox( # Confirm close.
-                        "You are closing unsaved frame.\n\n"
-                        "Continue closing?",
-                        "Close {!r}".format(frame.name),
-                        style=wx.YES_NO|wx.ICON_INFORMATION) != wx.YES:
-                    self.message("The close has been canceled.")
-                    evt.Veto()
-                    return
-                break
+        n = sum(bool(plug.thread and plug.thread.active) for plug in self.get_all_plugs())
+        if n:
+            s = 's' if n > 1 else ''
+            if wx.MessageBox( # Confirm closing the thread.
+                    f"Currently  running {n} thread{s}.\n\n"
+                    "Continue closing?",
+                    style=wx.YES_NO|wx.ICON_INFORMATION) != wx.YES:
+                self.message("The close has been canceled.")
+                evt.Veto()
+                return
+            self.Quit()
+        n = sum(frame.pathname is None for frame in self.graph.all_frames)
+        if n:
+            s = 's' if n > 1 else ''
+            if wx.MessageBox( # Confirm closing the frame.
+                    f"You are closing {n} unsaved frame{s}.\n\n"
+                     "Continue closing?",
+                    style=wx.YES_NO|wx.ICON_INFORMATION) != wx.YES:
+                self.message("The close has been canceled.")
+                evt.Veto()
+                return
         evt.Skip()
-    
+
     def Destroy(self):
-        ## for name in list(self.plugins):
-        ##     self.unload_plug(name) # => plug.Destroy
         self._mgr.UnInit()
         return mwx.Frame.Destroy(self)
-    
+
     ## --------------------------------
-    ## pane window interface
+    ## pane window interface.
     ## --------------------------------
-    
+
     def get_pane(self, name):
         """Get named pane or notebook pane.
         
         Args:
-            name : str or plug object.
+            name: plug name or object.
         """
         plug = self.get_plug(name)
         if plug:
             name = plug.category or plug
         if name:
             return self._mgr.GetPane(name)
-    
+
     def show_pane(self, name, show=True, interactive=False):
-        """Show named pane or notebook pane."""
+        """Show named pane or notebook pane.
+        
+        Args:
+            name: plug name or object.
+            show: Show or hide the pane window.
+            interactive: If True, modifier keys can be used to reset or reload
+                         the plugin when showing the pane:
+                         - [S-menu] Reset floating position.
+                         - [M-S-menu] Reload plugin.
+        """
         pane = self.get_pane(name)
         if not pane.IsOk():
             return
         
         ## Set the graph and output window sizes to half & half.
-        ## ドッキング時に再計算される
+        ## ドッキング時に再計算される．
         if name == "output" or name is self.output:
             w, h = self.graph.GetClientSize()
-            pane.best_size = (w//2 - 3, h) # 分割線幅補正 -12pix (Windows only ?)
+            pane.best_size = (w//2 - 3, h)  # 分割線幅補正 -12pix (Windows only ?)
         
         ## Force Layer windows to show.
         if interactive:
@@ -923,91 +924,90 @@ class Frame(mwx.Frame):
                 pane.Float()
                 show = True
         
-        ## Note: We need to distinguish cases whether:
-        ##       - pane.window is AuiNotebook or normal Panel,
-        ##       - pane.window is floating (win.Parent is AuiFloatingFrame) or docked.
-        
-        plug = self.get_plug(name) # -> None if pane.window is a Graph
-        win = pane.window # -> Window (plug / notebook / Graph)
+        plug = self.get_plug(name)  # -> None if pane.window is a Graph
+        win = pane.window
         try:
             shown = plug.IsShown()
         except AttributeError:
             shown = pane.IsShown()
+        
         if show and not shown:
             if isinstance(win, aui.AuiNotebook):
                 j = win.GetPageIndex(plug)
                 if j != win.Selection:
-                    win.Selection = j # the focus moves => EVT_SHOW
+                    win.Selection = j  # the focus moves => EVT_SHOW
                 else:
                     plug.handler('page_shown', plug)
             else:
                 win.handler('page_shown', win)
+            if plug:
+                plug.SetFocus()  # plugins only
         elif not show and shown:
             if isinstance(win, aui.AuiNotebook):
-                for plug in win.all_pages:
+                for plug in win.get_pages():
                     plug.handler('page_closed', plug)
             else:
                 win.handler('page_closed', win)
         
         ## 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()
         
         pane.Show(show)
         self._mgr.Update()
         return (show != shown)
-    
-    def update_pane(self, name, show=False, **kwargs):
-        """Update the layout of the pane.
+
+    def update_pane(self, name, **props):
+        """Update the layout of the pane (internal use only).
         
         Note:
             This is called automatically from load_plug,
             and should not be called directly from user.
         """
         pane = self.get_pane(name)
-        
-        pane.dock_layer = kwargs.get('layer', 0)
-        pane.dock_pos = kwargs.get('pos', 0)
-        pane.dock_row = kwargs.get('row', 0)
-        pane.dock_proportion = kwargs.get('prop') or pane.dock_proportion
-        pane.floating_pos = kwargs.get('floating_pos') or pane.floating_pos
-        pane.floating_size = kwargs.get('floating_size') or pane.floating_size
+        for k, v in props.items():
+            if v is not None:
+                setattr(pane, k, v)
         
         plug = self.get_plug(name)
         if plug:
             dock = plug.dockable
-            if not isinstance(dock, bool): # prior to kwargs
-                kwargs.update(dock=dock)
+            if not isinstance(dock, bool):
+                pane.dock_direction = dock
             if not plug.caption:
                 pane.CaptionVisible(False)       # no caption bar
-                pane.Gripper(dock not in (0, 5)) # show a grip when docked
+                pane.Gripper(dock not in (0,5))  # show a grip when docked
             pane.Dockable(dock)
         
-        dock = kwargs.get('dock')
-        pane.dock_direction = dock or 0
-        if dock:
+        if pane.dock_direction:
             pane.Dock()
         else:
             pane.Float()
-        return self.show_pane(name, show)
-    
-    def OnPaneClose(self, evt): #<wx.aui.AuiManagerEvent>
+
+    def OnPaneClose(self, evt):  #<wx.aui.AuiManagerEvent>
         pane = evt.GetPane()
         win = pane.window
         if isinstance(win, aui.AuiNotebook):
-            for plug in win.all_pages:
+            for plug in win.get_pages():
                 plug.handler('page_closed', plug)
         else:
             win.handler('page_closed', win)
-        evt.Skip()
-    
+        evt.Skip(False)  # Don't skip to avoid being called twice.
+
     ## --------------------------------
-    ## Plugin <Layer> interface
+    ## Plugin <Layer> interface.
     ## --------------------------------
     plugins = property(lambda self: self.__plugins)
-    
+
+    def register(self, cls=None, **kwargs):
+        """Decorator of plugin class register."""
+        if cls is None:
+            return lambda f: self.register(f, **kwargs)
+        self.load_plug(cls, force=1, show=1, **kwargs)
+        return cls
+
     def require(self, name):
         """Get named plug window.
         If not found, try to load it once.
@@ -1021,53 +1021,77 @@ class Frame(mwx.Frame):
             if self.load_plug(name) is not False:
                 return self.get_plug(name)
         return plug
-    
+
     def get_plug(self, name):
-        """Get named plug window.
-        
-        Args:
-            name : str or plug object.
-        """
+        """Get named plug window."""
         if isinstance(name, str):
             if name.endswith(".py"):
                 name, _ = os.path.splitext(os.path.basename(name))
             if name in self.plugins:
                 return self.plugins[name].__plug__
         elif isinstance(name, LayerInterface):
-            return name
-    
-    @staticmethod
-    def register(cls, module=None):
-        """Register dummy plug; Add module.Plugin <Layer>.
-        """
-        if not module:
-            module = inspect.getmodule(cls) # rebase module or __main__
-        
-        if issubclass(cls, LayerInterface):
-            cls.__module__ = module.__name__ # __main__ to module
-            warn(f"Duplicate iniheritance of LayerInterface by {cls}.")
-            module.Plugin = cls
-            return cls
-        
-        class _Plugin(LayerInterface, cls):
-            def __init__(self, parent, session=None, **kwargs):
-                cls.__init__(self, parent, **kwargs)
-                LayerInterface.__init__(self, parent, session)
-        
-        _Plugin.__module__ = cls.__module__ = module.__name__
-        _Plugin.__name__ = cls.__name__ + str("~")
-        _Plugin.__doc__ = cls.__doc__
-        module.Plugin = _Plugin
-        return _Plugin
-    
-    def load_module(self, root):
-        """Load module of plugin (internal use only).
+            # return name
+            return next((x for x in self.get_all_plugs() if x is name), None)
+
+    def get_all_plugs(self):
+        for name, module in self.plugins.items():
+            yield module.__plug__
+
+    def load_plug(self, root, session=None, force=False, show=False,
+                        dock=0, floating_pos=None, floating_size=None,
+                        **kwargs):
+        """Load plugin.
+        
+        Args:
+            root: Plugin <Layer> module, or name of the module.
+                  Any wx.Window object can be specified (as dummy-plug).
+                  However, do not use this mode in release versions.
+            session: Conditions for initializing the plug and starting session
+            force: force loading even if it is already loaded
+            show: the pane is shown after loaded
+            dock: dock_direction (1:top, 2:right, 3:bottom, 4:left, 5:center)
+            floating_pos: posision of floating window
+            floating_size: size of floating window
+            **kwargs: keywords for Plugin <Layer>
+        
+        Returns:
+            None if succeeded else False
         
         Note:
-            This is called automatically from load_plug,
-            and should not be called directly from user.
+            The root module must contain a class Plugin <Layer>.
         """
-        dirname_, name = split_paths(root)
+        props = dict(dock_direction=dock,
+                     floating_pos=floating_pos,
+                     floating_size=floating_size)
+        
+        if inspect.ismodule(root):
+            name = root.__name__
+        elif inspect.isclass(root):
+            name = root.__module__
+        else:
+            name = root
+        
+        dirname_, name = os.path.split(name)  # if the name is full-path:str
+        if name.endswith(".py"):
+            name = name[:-3]
+        
+        if not force:
+            ## 文字列参照 (full-path) による重複ロードを避ける．
+            module = next((v for v in self.plugins.values() if root == v.__file__), None)
+            if module:
+                plug = module.__plug__
+            else:
+                plug = self.get_plug(name)
+            ## Check if the named plug is already loaded.
+            if plug:
+                self.update_pane(name, **props)
+                self.show_pane(name, show)
+                try:
+                    if session:
+                        plug.load_session(session)
+                except Exception:
+                    traceback.print_exc()  # Failed to load the plug session.
+                return None
         
         ## Update the include-path to load the module correctly.
         if os.path.isdir(dirname_):
@@ -1075,135 +1099,81 @@ class Frame(mwx.Frame):
                 sys.path.remove(dirname_)
             sys.path.insert(0, dirname_)
         elif dirname_:
-            print("- No such directory {!r}".format(dirname_))
+            print(f"- No such directory {dirname_!r}.")
             return False
         
+        ## Load or reload the module, and check whether it contains a class named `Plugin`.
         try:
-            if name in sys.modules:
+            ## Check if the module is reloadable.
+            loadable = not name.startswith(("__main__", "builtins"))  # no __file__
+            if not loadable:
+                module = types.ModuleType(name)  # dummy module (cannot reload)
+                module.__file__ = "<scratch>"
+            elif name in sys.modules:
                 module = reload(sys.modules[name])
             else:
                 module = import_module(name)
-        except Exception as e:
-            print(f"- Unable to load {root!r}.", e)
+        except Exception:
+            traceback.print_exc()  # Unable to load the module.
             return False
-        
-        ## the module must have a class `Plugin`.
-        if not hasattr(module, 'Plugin'):
-            if isinstance(root, type):
-                warn(f"Use dummy plug for debugging {name!r}.")
-                module.__dummy_plug__ = root
-                self.register(root, module)
         else:
-            if hasattr(module, '__dummy_plug__'):
-                root = module.__dummy_plug__         # old class (imported)
-                cls = getattr(module, root.__name__) # new class (reloaded)
-                self.register(cls, module)
-        return module
-    
-    def load_plug(self, root, force=False, session=None,
-                  show=False, dock=False, layer=0, pos=0, row=0, prop=10000,
-                  floating_pos=None, floating_size=None, **kwargs):
-        """Load plugin.
-        
-        Args:
-            root    : Plugin <Layer> module, or name of the module.
-                      Any wx.Window object can be specified (as dummy-plug).
-                      However, do not use this mode in release versions.
-            force   : force loading even if it is already loaded
-            session : Conditions for initializing the plug and starting session
-            show    : the pane is shown after loaded
-            dock    : dock_direction (1:top, 2:right, 3:bottom, 4:left, 5:center)
-            layer   : dock_layer
-            pos     : dock_pos
-            row     : dock_row position
-            prop    : dock_proportion < 1e6 ?
-            floating_pos: posision of floating window
-            floating_size: size of floating window
-            
-            **kwargs: keywords for Plugin <Layer>
-        
-        Returns:
-            None if succeeded else False
-        
-        Note:
-            The root module must have a class Plugin <Layer>
-        """
-        props = dict(show=show, dock=dock, layer=layer, pos=pos, row=row, prop=prop,
-                     floating_pos=floating_pos, floating_size=floating_size)
-        
-        _dirname, name = split_paths(root)
-        
-        plug = self.get_plug(name)
-        if plug and not force:
-            self.update_pane(name, **props)
-            try:
-                if session:
-                    plug.load_session(session)
-            except Exception:
-                traceback.print_exc()
-                print("- Failed to load session of", plug)
-            return None
-        
-        module = self.load_module(root)
-        if not module:
-            return False # failed to import
+            ## Register dummy plug; Add module.Plugin <Layer>.
+            if not hasattr(module, 'Plugin'):
+                if inspect.isclass(root):
+                    module.__dummy_plug__ = root.__name__
+                    root.reloadable = loadable
+                    _register__dummy_plug__(root, module)
+            else:
+                if hasattr(module, '__dummy_plug__'):
+                    root = getattr(module, module.__dummy_plug__)
+                    root.reloadable = loadable
+                    _register__dummy_plug__(root, module)
         
+        ## Note: name (module.__name__) != Plugin.__module__ if module is a package.
         try:
-            name = module.Plugin.__module__
-            title = module.Plugin.category
+            Plugin = module.Plugin   # Check if the module has a class `Plugin`.
+            title = Plugin.category  # Plugin <LayerInterface>
             
-            pane = self._mgr.GetPane(title)
-            
-            if pane.IsOk(): # <pane:title> is already registered
-                nb = pane.window
-                if not isinstance(nb, aui.AuiNotebook):
-                    raise NameError("Notebook name must not be the same as any other plugins")
-            
-            pane = self.get_pane(name)
+            pane = self._mgr.GetPane(title)  # Check if <pane:title> is already registered.
+            if pane.IsOk():
+                if not isinstance(pane.window, aui.AuiNotebook):
+                    raise NameError("Notebook name must not be the same as any other plugin")
             
-            if pane.IsOk(): # <pane:name> is already registered
+            pane = self.get_pane(name)  # Check if <pane:name> is already registered.
+            if pane.IsOk():
                 if name not in self.plugins:
-                    raise NameError("Plugin name must not be the same as any other panes")
-                
-                props.update(
-                    show = show or pane.IsShown(),
-                    dock = pane.IsDocked() and pane.dock_direction,
-                    layer = pane.dock_layer,
-                    pos = pane.dock_pos,
-                    row = pane.dock_row,
-                    prop = pane.dock_proportion,
-                    floating_pos = floating_pos or pane.floating_pos[:], # copy (pane unloaded)
-                    floating_size = floating_size or pane.floating_size[:], # copy
-                )
+                    raise NameError("Plugin name must not be the same as any other pane")
+            
         except (AttributeError, NameError) as e:
             traceback.print_exc()
-            wx.CallAfter(wx.MessageBox,
+            wx.CallAfter(wx.MessageBox,  # Show the message after load_session has finished.
                          f"{e}\n\n" + traceback.format_exc(),
                          f"Error in loading {module.__name__!r}",
                          style=wx.ICON_ERROR)
             return False
         
-        ## Create and register the plugin
+        ## Unload the plugin if loaded.
         if pane.IsOk():
-            self.unload_plug(name) # unload once right here
+            show = show or pane.IsShown()
+            props.update(
+                dock_direction = pane.IsDocked() and pane.dock_direction,
+                floating_pos = floating_pos or pane.floating_pos[:],  # copy unloading pane
+                floating_size = floating_size or pane.floating_size[:],  # copy unloading pane
+            )
+            self.unload_plug(name)
         
+        ## Create the plugin object.
         try:
-            plug = module.Plugin(self, session, **kwargs)
+            plug = Plugin(self, session, **kwargs)
         except Exception as e:
             traceback.print_exc()
-            wx.CallAfter(wx.MessageBox,
+            wx.CallAfter(wx.MessageBox,  # Show the message after load_session has finished.
                          f"{e}\n\n" + traceback.format_exc(),
                          f"Error in loading {name!r}",
                          style=wx.ICON_ERROR)
             return False
         
-        ## Add to the list after the plug is created successfully.
-        self.plugins[name] = module
-        
-        ## set reference of a plug (one module, one plugin)
-        module.__plug__ = plug
-        
-        ## Create pane or notebook pane
+        ## Create pane or notebook pane.
         caption = plug.caption
         if not isinstance(caption, str):
             caption = name
@@ -1215,7 +1185,7 @@ class Frame(mwx.Frame):
                 nb = pane.window
                 nb.AddPage(plug, caption)
             else:
-                size = plug.GetSize() + (2,30) # padding for notebook
+                size = plug.GetSize() + (2,30)  # padding for notebook
                 nb = AuiNotebook(self, name=title)
                 nb.AddPage(plug, caption)
                 self._mgr.AddPane(nb, aui.AuiPaneInfo()
@@ -1231,16 +1201,23 @@ class Frame(mwx.Frame):
                                        .Name(name).Caption(caption)
                                        .FloatingSize(size).MinSize(size).Show(0))
         
+        ## Add to the list after the plug is created successfully.
+        self.plugins[name] = module
+        
+        ## Set reference of a plug (one module, one plugin).
+        module.__plug__ = plug
+        
         ## Set winow.Name for inspection.
         plug.Name = name
         
         self.update_pane(name, **props)
+        self.show_pane(name, show)
         
-        ## Create a menu
+        ## Create a menu.
         plug.__Menu_item = None
         
-        if not hasattr(module, 'ID_'): # give a unique index to the module
-            global __plug_ID__ # cache ID *not* in [ID_LOWEST(4999):ID_HIGHEST(5999)]
+        if not hasattr(module, 'ID_'):  # give a unique index to the module
+            global __plug_ID__          # cache ID *not* in [ID_LOWEST(4999):ID_HIGHEST(5999)]
             try:
                 __plug_ID__
             except NameError:
@@ -1255,26 +1232,26 @@ class Frame(mwx.Frame):
             hint = (plug.__doc__ or name).strip().splitlines()[0]
             plug.__Menu_item = (
                 module.ID_, text, hint, wx.ITEM_CHECK,
-                lambda v: self.show_pane(name, v.IsChecked(), interactive=1),
+                lambda v: (self.update_pane(name),
+                           self.show_pane(name, v.IsChecked(), interactive=1)),
                 lambda v: v.Check(plug.IsShown()),
             )
             if menu not in self.menubar:
                 self.menubar[menu] = []
             self.menubar[menu] += [plug.__Menu_item]
             self.menubar.update(menu)
+        
+        self.handler('plug_loaded', plug)
         return None
-    
+
     def unload_plug(self, name):
         """Unload plugin and detach the pane from UI manager."""
         plug = self.get_plug(name)
         if not plug:
+            print(f"- {name!r} is not listed in plugins.")
             return
         
-        name = plug.__module__
-        if name not in self.plugins:
-            return
-        
-        del self.plugins[name]
+        del self.plugins[plug.Name]
         
         if plug.__Menu_item:
             menu, sep, tail = plug.menukey.rpartition('/')
@@ -1285,94 +1262,87 @@ class Frame(mwx.Frame):
         if isinstance(plug.Parent, aui.AuiNotebook):
             nb = plug.Parent
             j = nb.GetPageIndex(plug)
-            nb.RemovePage(j) # just remove page
-            ## nb.DeletePage(j) # Destroys plug object too.
+            nb.RemovePage(j)  # just remove page
+            # nb.DeletePage(j)  # Destroys plug object too.
         else:
             nb = None
             self._mgr.DetachPane(plug)
             self._mgr.Update()
         
-        plug.handler('page_closed', plug) # (even if not shown)
+        self.handler('plug_unloaded', plug)
+        plug.handler('page_closed', plug)  # (even if not shown)
         plug.Destroy()
         
         if nb and not nb.PageCount:
-            self._mgr.DetachPane(nb) # detach notebook pane
+            self._mgr.DetachPane(nb)  # detach notebook pane
             self._mgr.Update()
             nb.Destroy()
-    
+
     def reload_plug(self, name):
+        """Reload plugin."""
         plug = self.get_plug(name)
-        if not plug or not plug.reloadable:
+        if not plug:
+            print(f"- {name!r} is not listed in plugins.")
             return
+        
         session = {}
         try:
-            print("Reloading {}...".format(plug))
+            print(f"Reloading {plug}...")
             plug.save_session(session)
         except Exception:
-            traceback.print_exc()
-            print("- Failed to save session of", plug)
+            traceback.print_exc()  # Failed to save the plug session.
+        
         self.load_plug(plug.__module__, force=1, session=session)
         
-        ## Update shell.target --> new plug
-        for shell in self.shellframe.all_shells:
+        ## Update shell.target --> new plug.
+        for shell in self.shellframe.get_all_shells():
             if shell.target is plug:
                 shell.handler('shell_activated', shell)
-    
-    @ignore(ResourceWarning)
-    def edit_plug(self, name):
-        plug = self.get_plug(name)
-        if not plug:
-            return
-        ## this = inspect.getmodule(plug)
-        this = self.plugins[plug.__module__]
-        cmd = '{} "{}"'.format(self.Editor, this.__file__)
-        subprocess.Popen(cmd)
-        self.message(cmd)
-    
+
     def inspect_plug(self, name):
-        """Dive into the process to inspect plugs in the shell.
-        """
+        """Dive into the process to inspect plugs in the shell."""
         plug = self.get_plug(name)
         if not plug:
+            print(f"- {name!r} is not listed in plugins.")
             return
         
         shell = self.shellframe.clone_shell(plug)
+        name = plug.Name  # init(shell) で名前を参照するため再定義する
         
         @shell.handler.bind("shell_activated")
         def init(shell):
+            """Called when the plug shell is activated."""
             nonlocal plug
             _plug = self.get_plug(name)
             if _plug is not plug:
-                shell.target = _plug or self # reset for loaded/unloaded plug
+                shell.target = _plug or self  # Reset the target to the reloaded plug.
             plug = _plug
         init(shell)
         self.shellframe.Show()
-        if wx.GetKeyState(wx.WXK_SHIFT):
+        if wx.GetKeyState(wx.WXK_SHIFT):  # open the source code.
             self.shellframe.load(plug)
-    
+
     def OnLoadPlugins(self, evt):
         with wx.FileDialog(self, "Load a plugin file",
                 wildcard="Python file (*.py)|*.py",
-                style=wx.FD_OPEN|wx.FD_FILE_MUST_EXIST
-                                |wx.FD_MULTIPLE) as dlg:
+                style=wx.FD_OPEN|wx.FD_FILE_MUST_EXIST|wx.FD_MULTIPLE) as dlg:
             if dlg.ShowModal() == wx.ID_OK:
                 for path in dlg.Paths:
                     self.load_plug(path)
-    
+
     def Quit(self, evt=None):
         """Stop all Layer threads."""
-        for name in self.plugins:
-            plug = self.get_plug(name)
+        for plug in self.get_all_plugs():
             thread = plug.thread  # Note: thread can be None or shared.
             if thread and thread.active:
-                thread.active = 0
+                # thread.active = 0
                 thread.Stop()
-    
+
     ## --------------------------------
-    ## load/save index file
+    ## load/save index file.
     ## --------------------------------
-    ATTRIBUTESFILE = "results.index"
-    
+    INDEXFILE = "results.index"
+
     def load_index(self, filename=None, view=None):
         """Load frames :ref to the Index file.
         
@@ -1382,10 +1352,10 @@ class Frame(mwx.Frame):
             view = self.selected_view
         
         if not filename:
-            fn = view.frame.pathname if view.frame else ''
-            with wx.FileDialog(self, "Select index file to import",
-                    defaultDir=os.path.dirname(fn or ''),
-                    defaultFile=self.ATTRIBUTESFILE,
+            default_path = view.frame.pathname if view.frame else None
+            with wx.FileDialog(self, "Select index file to load",
+                    defaultDir=os.path.dirname(default_path or ''),
+                    defaultFile=self.INDEXFILE,
                     wildcard="Index (*.index)|*.index|"
                              "ALL files (*.*)|*.*",
                     style=wx.FD_OPEN|wx.FD_FILE_MUST_EXIST) as dlg:
@@ -1399,16 +1369,16 @@ class Frame(mwx.Frame):
         frames = self.load_buffer(paths, view)
         if frames:
             for frame in frames:
-                frame.update_attributes(res.get(frame.name))
+                frame.update_attr(res.get(frame.name))
         
         n = len(frames)
-        self.message(
+        print(self.message(
             "{} frames were imported, "
             "{} files were skipped, "
-            "{} files are missing.".format(n, len(res)-n, len(mis)))
-        print(self.message.read())
+            "{} files are missing.".format(n, len(res)-n, len(mis))
+        ))
         return frames
-    
+
     def save_index(self, filename=None, frames=None):
         """Save frames :ref to the Index file.
         """
@@ -1419,10 +1389,10 @@ class Frame(mwx.Frame):
                 return None
         
         if not filename:
-            fn = view.frame.pathname if view.frame else ''
+            default_path = view.frame.pathname if view.frame else None
             with wx.FileDialog(self, "Select index file to export",
-                    defaultDir=os.path.dirname(fn or ''),
-                    defaultFile=self.ATTRIBUTESFILE,
+                    defaultDir=os.path.dirname(default_path or ''),
+                    defaultFile=self.INDEXFILE,
                     wildcard="Index (*.index)|*.index",
                     style=wx.FD_SAVE|wx.FD_OVERWRITE_PROMPT) as dlg:
                 if dlg.ShowModal() != wx.ID_OK:
@@ -1435,234 +1405,300 @@ class Frame(mwx.Frame):
             try:
                 self.message("Export index of {!r}...".format(frame.name))
                 fn = frame.pathname
-                if not fn:
-                    fn = os.path.join(savedir, frame.name) # new file
+                if not fn or fn.endswith('>'):  # <dummy-path>
+                    fn = os.path.join(savedir, fix_fnchars(frame.name))
                 if not os.path.exists(fn):
                     if not fn.endswith('.tif'):
                         fn += '.tif'
                     self.write_buffer(fn, frame.buffer)
                     frame.pathname = fn
-                    frame.name = os.path.basename(fn) # new name and pathname
+                    frame.name = os.path.basename(fn)  # new name and pathname
+                    print(' ', self.message("\b done."))
+                else:
+                    print(' ', self.message("\b skipped."))
                 output_frames.append(frame)
-                print(' ', self.message("\b done."))
-            except (PermissionError, OSError) as e:
+            except OSError as e:
                 print('-', self.message("\b failed.", e))
         
         frames = output_frames
         res, mis = self.write_attributes(filename, frames)
         n = len(frames)
-        self.message(
+        print(self.message(
             "{} frames were exported, "
             "{} files were skipped, "
-            "{} files are missing.".format(n, len(res)-n, len(mis)))
-        print(self.message.read())
+            "{} files are missing.".format(n, len(res)-n, len(mis))
+        ))
         return frames
-    
+
     ## --------------------------------
-    ## load/save frames and attributes 
+    ## load/save frames and attributes.
     ## --------------------------------
-    
+
     @classmethod
-    def read_attributes(self, filename):
-        """Read attributes file."""
-        from numpy import nan, inf  # noqa: necessary to eval
-        import datetime             # noqa: necessary to eval
+    def read_attributes(self, filename, check_path=True):
+        """Read attributes file.
+        
+        Returns:
+            res: <dict> Successfully loaded attribute information.
+            mis: <dict> Attributes whose file paths were missing.
+        """
+        def dt_parser(dct):
+            for k, v in dct.items():
+                if isinstance(v, str):
+                    try:
+                        dct[k] = datetime.fromisoformat(v)
+                    except Exception:
+                        pass
+            return dct
         try:
             res = {}
             mis = {}
             savedir = os.path.dirname(filename)
             with open(filename) as i:
-                res.update(eval(i.read())) # read res <dict>
+                s = i.read()
+                try:
+                    res.update(json.loads(s, object_hook=dt_parser))  # Read res safely.
+                except json.decoder.JSONDecodeError:
+                    res.update(eval(s))  # Read res <dict> for backward compatibility.
             
-            for name, attr in tuple(res.items()):
-                fn = os.path.join(savedir, name)
-                if not os.path.exists(fn): # search by relpath (dir+name)
-                    fn = attr.get('pathname')
-                if not os.path.exists(fn): # check & pop missing files
-                    res.pop(name)
-                    mis.update({name:attr})
-                else:
-                    attr.update(pathname=fn)
+            if check_path:
+                for name, attr in tuple(res.items()):
+                    fn = os.path.join(savedir, name)  # search by relpath (saved dir/name)
+                    if os.path.exists(fn):
+                        attr['pathname'] = fn  # If found, update pathname.
+                    else:
+                        fn = attr.get('pathname')  # If not found, check for the recorded path.
+                        if not fn or not os.path.exists(fn):
+                            mis[name] = res.pop(name)  # pop missing items
         except FileNotFoundError:
             pass
         except Exception as e:
             print("- Failed to read attributes.", e)
             wx.MessageBox(str(e), style=wx.ICON_ERROR)
-        finally:
-            return res, mis # finally raises no exception
-    
+        return res, mis
+
     @classmethod
-    def write_attributes(self, filename, frames):
-        """Write attributes file."""
+    def write_attributes(self, filename, frames, merge_data=True):
+        """Write attributes file.
+        
+        Returns:
+            res: <dict> Successfully loaded attribute information.
+            mis: <dict> Attributes whose file paths were missing.
+        """
+        def dt_converter(o):
+            if isinstance(o, datetime):
+                return o.isoformat()
         try:
-            res, mis = self.read_attributes(filename)
-            new = dict((x.name, x.attributes) for x in frames)
-            
-            ## `res` order may differ from that of given frames,
-            ## so we take a few steps to merge `new` to be exported.
-            
-            res.update(new) # res updates to new info,
-            new.update(res) # copy res back keeping new order.
+            new = dict((frame.name, frame.attributes) for frame in frames)
+            mis = {}
+            if merge_data:
+                res, mis = self.read_attributes(filename)
+                ## Merge existing attributes from `res` to `new`, 
+                ## while keeping the order and values from `frames` (new) priority.
+                for name, attr in res.items():
+                    if name not in new:
+                        new[name] = attr
             
             with open(filename, 'w') as o:
-                print(pformat(tuple(new.items())), file=o)
-            
+                # print(pformat(tuple(new.items())), file=o)  # tuple with pformat is deprecated.
+                json.dump(new, o, indent=2, default=dt_converter)
         except Exception as e:
             print("- Failed to write attributes.", e)
             wx.MessageBox(str(e), style=wx.ICON_ERROR)
-        finally:
-            return new, mis # finally raises no exception
-    
+        return new, mis
+
     def load_frame(self, paths=None, view=None):
-        """Load frames from files to the view window.
+        """Load frames and the attributes from files to the view window."""
+        if not view:
+            view = self.selected_view
+        
+        if isinstance(paths, str):  # for single frame
+            paths = [paths]
+        
+        if paths is None:
+            default_path = view.frame.pathname if view.frame else None
+            with wx.FileDialog(self, "Open image files",
+                    defaultDir=os.path.dirname(default_path or ''),
+                    defaultFile='',
+                    wildcard='|'.join(self.wildcards),
+                    style=wx.FD_OPEN|wx.FD_FILE_MUST_EXIST|wx.FD_MULTIPLE) as dlg:
+                if dlg.ShowModal() != wx.ID_OK:
+                    return None
+                paths = dlg.Paths
         
-        Load buffer and the attributes of the frame.
-        If the file names duplicate, the latter takes priority.
-        """
         frames = self.load_buffer(paths, view)
         if frames:
-            savedirs = {}
+            saved_results = {}
             for frame in frames:
+                if frame.pathname.endswith('>'):  # <dummy-path>
+                    ## Attributes are compiled in load_buffer.
+                    continue
+                ## Compile attributes from index files located in each frame path.
                 savedir = os.path.dirname(frame.pathname)
-                if savedir not in savedirs:
-                    fn = os.path.join(savedir, self.ATTRIBUTESFILE)
+                if savedir not in saved_results:
+                    fn = os.path.join(savedir, self.INDEXFILE)
                     res, mis = self.read_attributes(fn)
-                    savedirs[savedir] = res
-                results = savedirs[savedir]
-                frame.update_attributes(results.get(frame.name))
+                    saved_results[savedir] = res
+                res = saved_results[savedir]
+                frame.update_attr(res.get(frame.name))
         return frames
-    
+
     def save_frame(self, path=None, frame=None):
-        """Save frame to a file.
+        """Save frame and the attributes to a file."""
+        view = self.selected_view
+        
+        if not frame:
+            frame = view.frame
+            if not frame:
+                return None
+        
+        if not path:
+            default_path = view.frame.pathname if view.frame else None
+            with wx.FileDialog(self, "Save buffer as",
+                    defaultDir=os.path.dirname(default_path or ''),
+                    defaultFile=fix_fnchars(frame.name),
+                    wildcard='|'.join(self.wildcards),
+                    style=wx.FD_SAVE|wx.FD_OVERWRITE_PROMPT) as dlg:
+                if dlg.ShowModal() != wx.ID_OK:
+                    return None
+                path = dlg.Path
         
-        Save buffer and the attributes of the frame.
-        """
         frame = self.save_buffer(path, frame)
         if frame:
             savedir = os.path.dirname(frame.pathname)
-            fn = os.path.join(savedir, self.ATTRIBUTESFILE)
+            fn = os.path.join(savedir, self.INDEXFILE)
             res, mis = self.write_attributes(fn, [frame])
         return frame
-    
+
+    def save_frames_as_tiff(self, path=None, frames=None):
+        """Save frames to a multi-page tiff."""
+        if not frames:
+            frames = self.selected_view.all_frames
+            if not frames:
+                return None
+        
+        if not path:
+            with wx.FileDialog(self, "Save buffers as a multi-page tiff",
+                    defaultFile="Stack-image",
+                    wildcard="TIF file (*.tif)|*.tif",
+                    style=wx.FD_SAVE|wx.FD_OVERWRITE_PROMPT) as dlg:
+                if dlg.ShowModal() != wx.ID_OK:
+                    return None
+                path = dlg.Path
+        _name, ext = os.path.splitext(path)
+        if ext != ".tif":
+            path += ".tif"
+        try:
+            name = os.path.basename(path)
+            self.message("Saving {!r}...".format(name))
+            with wx.BusyInfo(f"One moment please, saving {name!r}..."):
+                stack = [Image.fromarray(frame.buffer) for frame in frames]
+                stack[0].save(path,
+                              save_all=True,
+                              compression="tiff_deflate",  # cf. tiff_lzw
+                              append_images=stack[1:])
+            n = len(frames)
+            d = len(str(n))
+            for j, frame in enumerate(frames):
+                frame.pathname = path + f"<{j:0{d}}>"  # <dummy-path>
+            ## multi-page tiff: 同名のインデクスファイルに属性を書き出す．
+            self.write_attributes(path[:-4] + ".index", frames, merge_data=False)
+            self.message("\b done.")
+            return True
+        except Exception as e:
+            self.message("\b failed.")
+            wx.MessageBox(str(e), style=wx.ICON_ERROR)
+            return False
+
     ## --------------------------------
-    ## load/save images
+    ## load/save images.
     ## --------------------------------
     wildcards = [
         "TIF file (*.tif)|*.tif",
          "ALL files (*.*)|*.*",
     ]
-    
+
     @staticmethod
     def read_buffer(path):
         """Read buffer from a file (to be overridden)."""
         buf = Image.open(path)
         info = {}
-        if buf.mode[:3] == 'RGB':  # 今のところカラー画像には対応する気はない▼
-            buf = buf.convert('L') # ここでグレースケールに変換する
-        ## return np.asarray(buf), info # ref
-        ## return np.array(buf), info # copy
+        if buf.mode[:3] == 'RGB':   # 今のところカラー画像には対応する気はない▼
+            buf = buf.convert('L')  # ここでグレースケールに変換する
+        # return np.asarray(buf), info  # ref
+        # return np.array(buf), info  # copy
         return buf, info
-    
+
     @staticmethod
     def write_buffer(path, buf):
         """Write buffer to a file (to be overridden)."""
         try:
             img = Image.fromarray(buf)
-            img.save(path) # PIL saves as L, I, F, and RGB.
+            img.save(path)  # PIL saves as L, I, F, and RGB.
         except PermissionError:
             raise
-        except OSError: # cannot write mode L, I, F as BMP, etc.
+        except OSError:  # cannot write mode L, I, F as BMP, etc.
             if os.path.exists(path):
                 os.remove(path)
             raise
-    
+
     @ignore(ResourceWarning)
-    def load_buffer(self, paths=None, view=None):
-        """Load buffers from paths to the view window.
-        
-        If no view given, the currently selected view is chosen.
+    def load_buffer(self, paths, view):
+        """Load buffers from paths to the view window (internal use only).
         """
-        if not view:
-            view = self.selected_view
-        
-        if isinstance(paths, str): # for single frame
-            paths = [paths]
-        
-        if paths is None:
-            fn = view.frame.pathname if view.frame else ''
-            with wx.FileDialog(self, "Open image files",
-                    defaultDir=os.path.dirname(fn or ''),
-                    defaultFile='',
-                    wildcard='|'.join(self.wildcards),
-                    style=wx.FD_OPEN|wx.FD_FILE_MUST_EXIST
-                                    |wx.FD_MULTIPLE) as dlg:
-                if dlg.ShowModal() != wx.ID_OK:
-                    return None
-                paths = dlg.Paths
         frames = []
         frame = None
+        paths = list(dict.fromkeys(paths))  # 順序を保って重複を除く．
         try:
             for i, path in enumerate(paths):
-                fn = os.path.basename(path)
-                self.message("Loading {!r} ({} of {})...".format(fn, i+1, len(paths)))
+                name = os.path.basename(path)
+                self.message("Loading {!r} ({} of {})...".format(name, i+1, len(paths)))
                 try:
                     buf, info = self.read_buffer(path)
                 except Image.UnidentifiedImageError:
                     retvals = self.handler('unknown_format', path)
                     if retvals and any(retvals):
                         continue
-                    raise # no context or no handlers or cannot identify image file
+                    raise  # no context or no handlers or cannot identify image file
                 except FileNotFoundError as e:
                     print(e)
                     continue
                 
-                if isinstance(buf, TiffImageFile) and buf.n_frames > 1: # multi-page tiff
+                if isinstance(buf, TiffImageFile) and buf.n_frames > 1:
+                    ## multi-page tiff: 同名のインデクスファイルから属性を読み出す．
+                    res, mis = self.read_attributes(path[:-4] + ".index", check_path=False)
+                    items = list({**res, **mis}.items())
                     n = buf.n_frames
                     d = len(str(n))
                     for j in range(n):
-                        self.message("Loading {!r} [{} of {} pages]...".format(fn, j+1, n))
+                        self.message("Loading {!r} [{} of {} pages]...".format(name, j+1, n))
                         buf.seek(j)
-                        name = "{:0{d}}-{}".format(j, fn, d=d)
-                        frame = view.load(buf, name, show=0)
+                        if items:
+                            page_name, info = items[j]  # original buffer name and attributes
+                        else:
+                            page_name = name + f"<{j:0{d}}>"  # default buffer name
+                        info['pathname'] = path + f"<{j:0{d}}>"  # <dummy-path>
+                        frame = view.load(buf, page_name, show=0, **info)
+                        frames.append(frame)
                 else:
-                    frame = view.load(buf, fn, show=0, pathname=path, **info)
+                    frame = view.load(buf, name, show=0, pathname=path, **info)
                     frames.append(frame)
             self.message("\b done.")
         except Exception as e:
             self.message("\b failed.")
             wx.MessageBox(str(e), style=wx.ICON_ERROR)
         
-        if frame:
-            view.select(frame)
+        view.select(frame)
         return frames
-    
-    def save_buffer(self, path=None, frame=None):
-        """Save buffer of the frame to a file.
-        """
-        view = self.selected_view
-        if not frame:
-            frame = view.frame
-            if not frame:
-                return None
-        
-        if not path:
-            fn = view.frame.pathname if view.frame else ''
-            with wx.FileDialog(self, "Save buffer as",
-                    defaultDir=os.path.dirname(fn or ''),
-                    defaultFile=re.sub(r'[\/:*?"<>|]', '_', frame.name),
-                    wildcard='|'.join(self.wildcards),
-                    style=wx.FD_SAVE|wx.FD_OVERWRITE_PROMPT) as dlg:
-                if dlg.ShowModal() != wx.ID_OK:
-                    return None
-                path = dlg.Path
+
+    def save_buffer(self, path, frame):
+        """Save buffer of the frame to a file (internal use only)."""
         try:
             name = os.path.basename(path)
             self.message("Saving {!r}...".format(name))
-            
             self.write_buffer(path, frame.buffer)
             frame.name = name
             frame.pathname = path
-            
             self.message("\b done.")
             return frame
         except ValueError:
@@ -1674,58 +1710,24 @@ class Frame(mwx.Frame):
             self.message("\b failed.")
             wx.MessageBox(str(e), style=wx.ICON_ERROR)
             return None
-    
-    def save_buffers_as_tiffs(self, path=None, frames=None):
-        """Save buffers to a file as a multi-page tiff."""
-        if not frames:
-            frames = self.selected_view.all_frames
-            if not frames:
-                return None
-        
-        if not path:
-            with wx.FileDialog(self, "Save buffers as a multi-page tiff",
-                    defaultFile="Stack-image",
-                    wildcard="TIF file (*.tif)|*.tif",
-                    style=wx.FD_SAVE|wx.FD_OVERWRITE_PROMPT) as dlg:
-                if dlg.ShowModal() != wx.ID_OK:
-                    return None
-                path = dlg.Path
-        try:
-            name = os.path.basename(path)
-            self.message("Saving {!r}...".format(name))
-            with wx.BusyInfo("One moment please, "
-                             "now saving {!r}...".format(name)):
-                stack = [Image.fromarray(x.buffer.astype(int)) for x in frames]
-                stack[0].save(path,
-                              save_all=True,
-                              compression="tiff_deflate", # cf. tiff_lzw
-                              append_images=stack[1:])
-            self.message("\b done.")
-            wx.MessageBox("{} files successfully saved into\n{!r}.".format(len(stack), path))
-            return True
-        except Exception as e:
-            self.message("\b failed.")
-            wx.MessageBox(str(e), style=wx.ICON_ERROR)
-            return False
-    
+
     ## --------------------------------
-    ## load/save session
+    ## load/save session.
     ## --------------------------------
     session_file = None
-    
+
     def load_session(self, filename=None, flush=True):
         """Load session from file."""
         if not filename:
-            with wx.FileDialog(self, 'Load session',
+            with wx.FileDialog(self, "Load session",
                     wildcard="Session file (*.jssn)|*.jssn",
-                    style=wx.FD_OPEN|wx.FD_FILE_MUST_EXIST
-                                    |wx.FD_CHANGE_DIR) as dlg:
+                    style=wx.FD_OPEN|wx.FD_FILE_MUST_EXIST|wx.FD_CHANGE_DIR) as dlg:
                 if dlg.ShowModal() != wx.ID_OK:
                     return
                 filename = dlg.Path
         
         if flush:
-            for name in list(self.plugins): # plugins:dict mutates during iteration
+            for name in list(self.plugins):  # plugins:dict mutates during iteration
                 self.unload_plug(name)
             del self.graph[:]
             del self.output[:]
@@ -1745,28 +1747,31 @@ class Frame(mwx.Frame):
         self._mgr.Update()
         self.menubar.reset()
         
-        dirname_ = os.path.dirname(i.name)
-        if dirname_:
-            os.chdir(dirname_)
-        
         ## Reposition the window if it is not on the desktop.
         if wx.Display.GetFromWindow(self) == -1:
             self.Position = (0, 0)
         
+        ## LoadPerspective => 表示状態の不整合．手動でイベントを発生させる．
+        for pane in self._mgr.GetAllPanes():
+            if pane.IsShown():
+                win = pane.window
+                if isinstance(win, aui.AuiNotebook):
+                    win = win.CurrentPage
+                win.handler('page_shown', win)
+        
         self.message("\b done.")
-    
+
     def save_session_as(self):
         """Save session as a new file."""
         with wx.FileDialog(self, "Save session as",
                 defaultDir=os.path.dirname(self.session_file or ''),
                 defaultFile=os.path.basename(self.session_file or ''),
                 wildcard="Session file (*.jssn)|*.jssn",
-                style=wx.FD_SAVE|wx.FD_OVERWRITE_PROMPT
-                                |wx.FD_CHANGE_DIR) as dlg:
+                style=wx.FD_SAVE|wx.FD_OVERWRITE_PROMPT|wx.FD_CHANGE_DIR) as dlg:
             if dlg.ShowModal() == wx.ID_OK:
                 self.session_file = dlg.Path
                 self.save_session()
-    
+
     def save_session(self):
         """Save session to file."""
         if not self.session_file:
@@ -1775,34 +1780,35 @@ class Frame(mwx.Frame):
         self.message("Saving session to {!r}...".format(self.session_file))
         
         with open(self.session_file, 'w') as o,\
-          np.printoptions(threshold=np.inf): # printing all(inf) elements
+          np.printoptions(threshold=np.inf):  # printing all(inf) elements
             o.write("#! Session file (This file is generated automatically)\n")
             o.write("self.SetSize({})\n".format(self.Size))
             o.write("self.SetPosition({})\n".format(self.Position))
             
             for name, module in self.plugins.items():
                 plug = self.get_plug(name)
-                path = os.path.abspath(module.__file__)
-                basename = os.path.basename(path)
-                if basename == "__init__.py": # is module package?
-                    path = path[:-12]
+                name = module.__file__  # Replace the name with full-path.
+                if not plug or not os.path.exists(name):
+                    print(f"Skipping dummy plugin {name!r}...")
+                    continue
+                if hasattr(module, '__path__'):  # is the module a package?
+                    name = os.path.dirname(name)
                 session = {}
                 try:
                     plug.save_session(session)
                 except Exception:
-                    traceback.print_exc()
-                    print("- Failed to save session of", plug)
-                o.write("self.load_plug({!r}, session={})\n".format(path, session or None))
+                    traceback.print_exc()  # Failed to save the plug session.
+                o.write("self.load_plug({!r}, session={})\n".format(name, session))
             o.write("self._mgr.LoadPerspective({!r})\n".format(self._mgr.SavePerspective()))
             
             def _save(view):
-                name = view.Name
-                paths = [x.pathname for x in view.all_frames if x.pathname]
-                o.write(f"self.{name}.unit = {view.unit:g}\n")
-                o.write(f"self.load_frame({paths!r}, self.{name})\n")
+                paths = [frame.pathname for frame in view.all_frames if frame.pathname]
+                paths = [fn for fn in paths if not fn.endswith('>')]  # <dummy-path> 除外
+                o.write(f"self.{view.Name}.unit = {view.unit:g}\n")
+                o.write(f"self.load_frame({paths!r}, self.{view.Name})\n")
                 try:
-                    index = paths.index(view.frame.pathname)
-                    o.write(f"self.{name}.select({index})\n")
+                    if view.frame.pathname in paths:
+                        o.write(f"self.{view.Name}.select({view.frame.name!r})\n")
                 except Exception:
                     pass