seolpyo-mplchart 0.1.3.1__py3-none-any.whl → 2.0.0.3__py3-none-any.whl

seolpyo_mplchart/slider.py

@@ -1,504 +1,573 @@
+import matplotlib.pyplot as plt
+from matplotlib.axes import Axes
 from matplotlib.collections import LineCollection
+from matplotlib.text import Text
 from matplotlib.backend_bases import MouseEvent, MouseButton, cursors
 import pandas as pd
 
+from .base import convert_unit
+from .cursor import BaseMixin as BM, Mixin as M
 
-from .cursor import CursorMixin, Chart as CM
 
-
-class Mixin:
+class Mixin(M):
     def on_click(self, e):
         "This function works if mouse button click event active."
         return
     def on_release(self, e):
         "This function works if mouse button release event active."
         return
-    def draw_artist(self):
-        "This function works before canvas.blit()."
+
+
+class PlotMixin(BM):
+    slider_top = True
+    ratio_ax_slider = 3
+    ratio_ax_none = 2
+
+    def _get_plot(self):
+        if self.slider_top:
+            self.figure, axes = plt.subplots(
+                4, # row 수
+                figsize=self.figsize, # 기본 크기
+                height_ratios=(self.ratio_ax_slider, self.ratio_ax_legend, self.ratio_ax_price, self.ratio_ax_volume) # row 크기 비율
+            )
+            axes: list[Axes]
+            self.ax_slider, self.ax_legend, self.ax_price, self.ax_volume = axes
+        else:
+            self.figure, axes = plt.subplots(
+                5, # row 수
+                figsize=self.figsize, # 기본 크기
+                height_ratios=(self.ratio_ax_legend, self.ratio_ax_price, self.ratio_ax_volume, self.ratio_ax_none, self.ratio_ax_slider) # row 크기 비율
+            )
+            axes: list[Axes]
+            self.ax_legend, self.ax_price, self.ax_volume, ax_none, self.ax_slider = axes
+
+            ax_none.set_axis_off()
+            ax_none.xaxis.set_animated(True)
+            ax_none.yaxis.set_animated(True)
+
+        self.ax_slider.set_label('slider ax')
+        self.ax_legend.set_label('legend ax')
+        self.ax_price.set_label('price ax')
+        self.ax_volume.set_label('volume ax')
+
+        self.figure.canvas.manager.set_window_title(f'{self.title}')
+        self.figure.set_facecolor(self.color_background)
+
+        # 플롯간 간격 제거(Configure subplots)
+        self.figure.subplots_adjust(**self.adjust)
+
+        self.ax_legend.set_axis_off()
+
+        # y ticklabel foramt 설정
+        self.ax_slider.yaxis.set_major_formatter(lambda x, _: convert_unit(x, word=self.unit_price, digit=2))
+        self.ax_price.yaxis.set_major_formatter(lambda x, _: convert_unit(x, word=self.unit_price, digit=2))
+        self.ax_volume.yaxis.set_major_formatter(lambda x, _: convert_unit(x, word=self.unit_volume, digit=2))
+
+        gridKwargs = {'visible': True, 'linewidth': 0.5, 'color': '#d0d0d0', 'linestyle': '-', 'dashes': (1, 0)}
+        gridKwargs.update(self.gridKwargs)
+        # 공통 설정
+        for ax in (self.ax_slider, self.ax_price, self.ax_volume):
+            ax.xaxis.set_animated(True)
+            ax.yaxis.set_animated(True)
+
+            # x tick 외부 눈금 표시하지 않기
+            ax.xaxis.set_ticks_position('none')
+            # x tick label 제거
+            ax.set_xticklabels([])
+            # y tick 우측으로 이동
+            ax.tick_params(left=False, right=True, labelleft=False, labelright=True, colors=self.color_tick_label)
+            # Axes 외곽선 색 변경
+            for i in ['top', 'bottom', 'left', 'right']: ax.spines[i].set_color(self.color_tick)
+
+            # 차트 영역 배경 색상
+            ax.set_facecolor(self.color_background)
+
+            # grid(구분선, 격자) 그리기
+            # 어째서인지 grid의 zorder 값을 선언해도 1.6을 값으로 한다.
+            ax.grid(**gridKwargs)
         return
 
 
-class NavgatorMixin(CursorMixin):
+class CollectionMixin(PlotMixin):
     min_distance = 30
-    color_navigatorline = '#1e78ff'
-    color_navigator = 'k'
-
-    _x_click, _x_release = (0, 0)
-    is_click, is_move = (False, False)
-    _navcoordinate = (0, 0)
+    color_navigator_line = '#1e78ff'
+    color_navigator_cover = 'k'
 
     def _add_collection(self):
         super()._add_collection()
 
+        self.collection_slider = LineCollection([], animated=True)
+        self.ax_slider.add_artist(self.collection_slider)
+
         # 슬라이더 네비게이터
-        self.navigator = LineCollection([], animated=True, edgecolors=[self.color_navigator, self.color_navigatorline], alpha=(0.2, 1.0))
+        self.navigator = LineCollection([], animated=True, edgecolors=[self.color_navigator_cover, self.color_navigator_line], alpha=(0.3, 1.0))
         self.ax_slider.add_artist(self.navigator)
-        return
 
-    def _set_data(self, df: pd.DataFrame, sort_df=True, calc_ma=True, change_lim=True, calc_info=True):
-        super()._set_data(df, sort_df, calc_ma, change_lim, calc_info)
+        lineKwargs = {'edgecolor': 'k', 'linewidth': 1, 'linestyle': '-'}
+        lineKwargs.update(self.lineKwargs)
+        lineKwargs.update({'segments': [], 'animated': True})
 
-        # 네비게이터 라인 선택 영역
-        xsub = self.xmax - self.xmin
-        self._navLineWidth = xsub * 0.008
-        if self._navLineWidth < 1: self._navLineWidth = 1
-        self._navLineWidth_half = self._navLineWidth / 2
-        return
+        self.slider_vline = LineCollection(**lineKwargs)
+        self.ax_slider.add_artist(self.slider_vline)
 
-    def _connect_event(self):
-        super()._connect_event()
-        self.canvas.mpl_connect('axes_leave_event', lambda x: self._leave_axes(x))
-        self.canvas.mpl_connect('button_press_event', lambda x: self._on_click(x))
-        self.canvas.mpl_connect('button_release_event', lambda x: self._on_release(x))
-        return
+        textboxKwargs = {'boxstyle': 'round', 'facecolor': 'w'}
+        textboxKwargs.update(self.textboxKwargs)
+        textKwargs = self.textKwargs
+        textKwargs.update({'animated': True, 'bbox': textboxKwargs, 'horizontalalignment': '', 'verticalalignment': ''})
+        (textKwargs.pop('horizontalalignment'), textKwargs.pop('verticalalignment'))
 
-    def _leave_axes(self, e: MouseEvent):
-        if not self.is_click and e.inaxes is self.ax_slider:
-            self.canvas.set_cursor(cursors.POINTER)
+        self.text_slider = Text(**textKwargs, horizontalalignment='center', verticalalignment='top')
+        self.ax_slider.add_artist(self.text_slider)
         return
 
-    def _on_click(self, e: MouseEvent):
-        if self.is_click or e.button != MouseButton.LEFT or e.inaxes is not self.ax_slider: return
+    def _get_segments(self):
+        super()._get_segments()
 
-        self.is_click = True
+        keys = []
+        for i in reversed(self.list_ma):
+            keys.append('_x')
+            keys.append(f'ma{i}')
 
-        x = e.xdata.__int__()
-        left, right = self._navcoordinate
-        lmin, lmax = (left-self._navLineWidth, left+self._navLineWidth_half)
-        rmin, rmax = (right-self._navLineWidth_half, right+self._navLineWidth)
+        segment_slider = self.df[keys + ['_x', self.close] ].values
+        segment_slider = segment_slider.reshape(segment_slider.shape[0], len(self.list_ma)+1, 2).swapaxes(0, 1)
+        self.collection_slider.set_segments(segment_slider)
+        return
 
-        gtl, ltr = (lmax < x, x < rmin)
-        if gtl and ltr:
-            self._x_click = x
-            self.is_move = True
-            self.canvas.set_cursor(cursors.MOVE)
-        else:
-            self.canvas.set_cursor(cursors.RESIZE_HORIZONTAL)
-            if not gtl and lmin <= x:
-                self._x_click = right
-            elif not ltr and x <= rmax:
-                self._x_click = left
-            else:
-                self._x_click = x
+    def _get_color_segment(self):
+        super()._get_color_segment()
 
-        # 그리기 후 최초 클릭이면 좌표 수정
-        if left == right:
-            self._navcoordinate = (x, x)
+        self.collection_slider.set_edgecolor(self.edgecolor_ma + [self.color_priceline])
         return
 
-    def _on_release(self, e: MouseEvent):
-        if e.inaxes is not self.ax_slider: return
-        self.is_click, self.is_move = (False, False)
+    def change_background_color(self, color):
+        super().change_background_color(color)
 
-        if self._navcoordinate[0] == self._navcoordinate[1]:
-            self._navcoordinate = (self._navcoordinate[0], self._navcoordinate[1]+self.min_distance)
+        self.ax_slider.set_facecolor(color)
+        self.text_slider.set_backgroundcolor(color)
         return
 
+    def change_tick_color(self, color):
+        super().change_tick_color(color)
 
-class BackgroundMixin(NavgatorMixin):
-    def _on_draw(self, e):
-        self.background = None
-        self._restore_region()
+        for i in ['top', 'bottom', 'left', 'right']: self.ax_slider.spines[i].set_color(self.color_tick)
+        self.ax_slider.tick_params(colors=color)
         return
 
-    def _restore_region(self, with_nav=True, empty=False, empty_with_nav=False):
-        if not self.background: self._create_background()
+    def change_text_color(self, color):
+        super().change_text_color(color)
 
-        if empty: self.canvas.restore_region(self.background_empty)
-        elif empty_with_nav: self.canvas.restore_region(self.background_empty_with_nav)
-        elif with_nav: self.canvas.restore_region(self.background_with_nav)
-        else: self.canvas.renderer.restore_region(self.background)
+        self.text_slider.set_color(color)
         return
 
-    def _copy_bbox(self):
-        renderer = self.canvas.renderer
+    def change_line_color(self, color):
+        super().change_line_color(color)
 
-        self.background_empty = renderer.copy_from_bbox(self.fig.bbox)
+        self.text_slider.get_bbox_patch().set_edgecolor(color)
+        return
 
-        self.ax_slider.xaxis.draw(renderer)
-        self.ax_slider.yaxis.draw(renderer)
-        self.slidercollection.draw(renderer)
-        self.background_empty_with_nav = self.canvas.renderer.copy_from_bbox(self.fig.bbox)
 
-        self._draw_artist()
-        self.background = self.canvas.renderer.copy_from_bbox(self.fig.bbox)
+class NavigatorMixin(CollectionMixin):
+    def _set_slider_lim(self):
+        xmax = self.list_index[-1]
+        # 슬라이더 xlim
+        xdistance = xmax / 30
+        self.slider_xmin, self.slider_xmax = (-xdistance, xmax + xdistance)
+        self.ax_slider.set_xlim(self.slider_xmin, self.slider_xmax)
 
-        self.navigator.draw(self.canvas.renderer)
-        self.background_with_nav = self.canvas.renderer.copy_from_bbox(self.fig.bbox)
+        # 슬라이더 ylim
+        ymin, ymax = (self.df[self.low].min(), self.df[self.high].max())
+        ysub = ymax - ymin
+        self.sldier_ymiddle = ymin + (ysub / 2)
+        ydistance = ysub / 5
+        self.slider_ymin, self.slider_ymax = (ymin-ydistance, ymax+ydistance)
+        self.ax_slider.set_ylim(self.slider_ymin, self.slider_ymax)
+
+        # 슬라이더 텍스트 y
+        self.text_slider.set_y(ymax)
+
+        self.navigator.set_linewidth([ysub, 5])
+
+        # 네비게이터 라인 선택 범위
+        xsub = self.slider_xmax - self.slider_xmin
+        self._navLineWidth = xsub * 8 / 1_000
+        if self._navLineWidth < 1: self._navLineWidth = 1
+        self._navLineWidth_half = self._navLineWidth / 2
         return
 
-    def _draw_artist(self):
-        renderer = self.canvas.renderer
+    def _set_navigator(self, navmin, navmax):
+        navseg = [
+            (
+                (self.slider_xmin, self.sldier_ymiddle),
+                (navmin, self.sldier_ymiddle)
+            ),
+            (
+                (navmin, self.slider_ymin),
+                (navmin, self.slider_ymax)
+            ),
+            (
+                (navmax, self.sldier_ymiddle),
+                (self.slider_xmax, self.sldier_ymiddle)
+            ),
+            (
+                (navmax, self.slider_ymin),
+                (navmax, self.slider_ymax)
+            ),
+        ]
+
+        self.navigator.set_segments(navseg)
+        return
 
-        self.ax_price.xaxis.draw(renderer)
-        self.ax_price.yaxis.draw(renderer)
 
-        if self.candle_on_ma:
-            self.macollection.draw(renderer)
-            self.candlecollection.draw(renderer)
-        else:
-            self.candlecollection.draw(renderer)
-            self.macollection.draw(renderer)
+class DataMixin(NavigatorMixin):
+    navcoordinate = (0, 0)
+
+    def set_data(self, df, sort_df=True, calc_ma=True, set_candlecolor=True, set_volumecolor=True, calc_info=True, change_lim=True, *args, **kwargs):
+        self._generate_data(df, sort_df, calc_ma, set_candlecolor, set_volumecolor, calc_info, *args, **kwargs)
+        self._get_segments()
 
-        self.ax_volume.xaxis.draw(renderer)
-        self.ax_volume.yaxis.draw(renderer)
+        vmin, vmax = self.navcoordinate
+        if change_lim or (vmax-vmin) < self.min_distance:
+            vmin, vmax = self.get_default_lim()
+            self.navcoordinate = (vmin, vmax)
 
-        self.volumecollection.draw(renderer)
+        self._set_lim(vmin, vmax)
+        self._set_slider_lim()
+        self._set_navigator(vmin, vmax)
+
+        self._length_text = self.df[(self.volume if self.volume else self.high)].apply(lambda x: len(str(x))).max()
         return
 
+    def get_default_lim(self):
+        xmax = self.list_index[-1]
+        return (xmax-120, xmax)
+
 
-class DrawMixin(BackgroundMixin):
-    def _set_data(self, df: pd.DataFrame, sort_df=True, calc_ma=True, change_lim=True, calc_info=True):
-        super()._set_data(df, sort_df, calc_ma, change_lim, calc_info)
+class BackgroundMixin(DataMixin):
+    def _copy_bbox(self):
+        renderer = self.figure.canvas.renderer
 
-        # 네비게이터 높이 설정
-        ysub = self._slider_ymax - self._slider_ymin
-        self._ymiddle = self._slider_ymax - ysub / 2
-        self.navigator.set_linewidth((ysub, 5))
+        self.ax_slider.xaxis.draw(renderer)
+        self.ax_slider.yaxis.draw(renderer)
+        self.collection_slider.draw(renderer)
+        self.background_emtpy = renderer.copy_from_bbox(self.figure.bbox)
+
+        self._draw_artist()
+        self.background = renderer.copy_from_bbox(self.figure.bbox)
+
+        self.navigator.draw(self.figure.canvas.renderer)
+        self.background_with_nav = renderer.copy_from_bbox(self.figure.bbox)
         return
 
-    def _on_release(self, e: MouseEvent):
-        super()._on_release(e)
-        self._set_navigator(*self._navcoordinate)
+    def _restore_region(self, is_empty=False, with_nav=True):
+        if not self.background: self._create_background()
 
-        self._restore_region(empty=True)
-        self._creating_background = False
-        self._create_background()
-        self._restore_region()
-        self._blit()
+        if is_empty: self.figure.canvas.renderer.restore_region(self.background_emtpy)
+        elif with_nav: self.figure.canvas.renderer.restore_region(self.background_with_nav)
+        else: self.figure.canvas.renderer.restore_region(self.background)
         return
 
-    def _on_move(self, e: MouseEvent):
-        self._restore_region((not self.is_click))
 
+class MouseMoveMixin(BackgroundMixin):
+    in_slider = False
+    is_click_slider = False
+
+    def _on_move(self, e):
         self._on_move_action(e)
 
+        self._restore_region((self.is_click_slider and self.in_slider))
+
         if self.in_slider:
-            self._change_coordinate()
-            if self.is_click:
-                if self.is_move: self._set_navigator(*self._navcoordinate)
-                elif self.intx is not None: self._set_navigator(self._x_click, self.intx)
-                self.navigator.draw(self.canvas.renderer)
-            self._slider_move_action(e)
-        elif self.is_click:
-            self.navigator.draw(self.canvas.renderer)
-        else:
-            if self.in_slider or self.in_price or self.in_volume:
-                self._slider_move_action(e)
-            if self.in_price or self.in_volume:
-                self._chart_move_action(e)
+            self._on_move_slider(e)
+        elif self.in_price_chart:
+            self._on_move_price_chart(e)
+        elif self.in_volume_chart:
+            self._on_move_volume_chart(e)
 
         self._blit()
         return
 
-    def _change_coordinate(self):
-        if self.intx is None: return
-        x = self.intx
-        left, right = self._navcoordinate
-
-        if not self.is_click:
-            lmin, lmax = (left-self._navLineWidth, left+self._navLineWidth_half)
-            rmin, rmax = (right-self._navLineWidth_half, right+self._navLineWidth)
-            ltel, gter = (x <= lmax, rmin <= x)
-            if ltel and lmin <= x:
-                self.canvas.set_cursor(cursors.RESIZE_HORIZONTAL)
-            elif gter and x <= rmax:
-                self.canvas.set_cursor(cursors.RESIZE_HORIZONTAL)
-            elif not ltel and not gter: self.canvas.set_cursor(cursors.MOVE)
-            else: self.canvas.set_cursor(cursors.POINTER)
-        else:
-            # 네비게이터 좌표 수정
-            intx = x.__int__()
-            if self.is_move:
-                xsub = self._x_click - intx
-                left, right = (left-xsub, right-xsub)
-                self._x_click = intx
-            else:
-                if intx == left: left = intx
-                elif intx == right: right = intx
-                else:
-                    if self._x_click < intx: left, right = (self._x_click, intx)
-                    else: left, right = (intx, self._x_click)
+    def _on_move_action(self, e: MouseEvent):
+        self._check_ax(e)
 
-            nsub = right - left
-            if right < 0 or self.df.index[-1] < left or nsub < self.min_distance: left, right = self._navcoordinate
-            self._navcoordinate = (left, right)
-        return
+        self.intx = None
+        if self.in_slider or self.in_price_chart or self.in_volume_chart: self._get_x(e)
 
-    def _set_navigator(self, x1, x2):
-        xmin, xmax = (x1, x2) if x1 < x2 else (x2, x1)
+        self._change_cursor(e)
+        return
 
-        left = ((self.xmin, self._ymiddle), (xmin, self._ymiddle))
-        right = ((xmax, self._ymiddle), (self.xmax, self._ymiddle))
-        leftline = ((xmin, self._slider_ymin), (xmin, self._slider_ymax))
-        rightline = ((xmax, self._slider_ymin), (xmax, self._slider_ymax))
-        self.navigator.set_segments((left, leftline, right, rightline))
+    def _change_cursor(self, e: MouseEvent):
+        # 마우스 커서 변경
+        if self.is_click_slider: return
+        elif not self.in_slider:
+            self.figure.canvas.set_cursor(cursors.POINTER)
+            return
+
+        navleft, navright = self.navcoordinate
+        if navleft == navright: return
+
+        x = e.xdata
+        leftmin, leftmax = (navleft-self._navLineWidth, navleft+self._navLineWidth_half)
+        rightmin, rightmax = (navright-self._navLineWidth_half, navright+self._navLineWidth)
+        if x < leftmin: self.figure.canvas.set_cursor(cursors.POINTER)
+        elif x < leftmax: self.figure.canvas.set_cursor(cursors.RESIZE_HORIZONTAL)
+        elif x < rightmin: self.figure.canvas.set_cursor(cursors.MOVE)
+        elif x < rightmax: self.figure.canvas.set_cursor(cursors.RESIZE_HORIZONTAL)
+        else: self.figure.canvas.set_cursor(cursors.POINTER)
         return
 
+    def _check_ax(self, e: MouseEvent):
+        ax = e.inaxes
+        if not ax or e.xdata is None or e.ydata is None:
+            self.in_slider, self.in_price_chart, self.in_volume_chart = (False, False, False)
+        else:
+            self.in_slider = ax is self.ax_slider
+            self.in_price_chart = False if self.in_slider else ax is self.ax_price
+            self.in_volume_chart = False if (self.in_slider or self.in_price_chart) else ax is self.ax_volume
+        return
 
-class LimMixin(DrawMixin):
-    def _on_release(self, e: MouseEvent):
-        if e.inaxes is not self.ax_slider: return
-        self.is_click, self.is_move = (False, False)
+    def _on_move_slider(self, e: MouseEvent):
+        x = e.xdata
 
-        if self._navcoordinate[0] == self._navcoordinate[1]:
-            self._navcoordinate = (self._navcoordinate[0], self._navcoordinate[1]+self.min_distance)
-        self._set_navigator(*self._navcoordinate)
-        self._lim()
+        if self.intx is not None:
+            renderer = self.figure.canvas.renderer
+            self.slider_vline.set_segments([((x, self.slider_ymin), (x, self.slider_ymax))])
+            self.slider_vline.draw(renderer)
 
-        self._restore_region(empty=True)
-        self._copy_bbox()
-        self._restore_region()
-        self._blit()
+            if self.in_slider:
+                self.text_slider.set_text(f'{self.df[self.date][self.intx]}')
+                self.text_slider.set_x(x)
+                self.text_slider.draw(renderer)
         return
 
-    def _on_move(self, e):
-        self._restore_region(with_nav=(not self.is_click), empty_with_nav=self.is_click)
 
-        self._on_move_action(e)
+class ClickMixin(MouseMoveMixin):
+    x_click = None
+    is_move = False
+    click_navleft, click_navright = (False, False)
 
-        if self.in_slider:
-            self._change_coordinate()
-            if self.is_click:
-                nsub = self._navcoordinate[1] - self._navcoordinate[0]
-                if self.min_distance <= nsub: self._lim()
-                if self.is_move: self._set_navigator(*self._navcoordinate)
-                elif self.intx is not None: self._set_navigator(self._x_click, self.intx)
-                self.navigator.draw(self.canvas.renderer)
-                self._draw_blit_artist()
-            self._slider_move_action(e)
-        elif self.is_click:
-            self.navigator.draw(self.canvas.renderer)
-            self._draw_blit_artist()
-        else:
-            if self.in_slider or self.in_price or self.in_volume:
-                self._slider_move_action(e)
-            if self.in_price or self.in_volume:
-                self._chart_move_action(e)
+    def _connect_event(self):
+        super()._connect_event()
 
-        self._blit()
+        self.figure.canvas.mpl_connect('button_press_event', lambda x: self._on_click(x))
         return
 
-    def _draw_blit_artist(self):
-        return self._draw_artist()
+    def _on_click(self, e: MouseEvent):
+        if self.in_slider: self._on_click_slider(e)
+        return
 
-    def _lim(self):
-        xmin, xmax = self._navcoordinate
+    def _on_click_slider(self, e: MouseEvent):
+        if self.is_click_slider or e.button != MouseButton.LEFT: return
 
-        xmax += 1
-        self.ax_price.set_xlim(xmin, xmax)
-        self.ax_volume.set_xlim(xmin, xmax)
+        self.background_with_nav_pre = self.background_with_nav
 
-        indmin, indmax = (xmin, xmax)
-        if xmin < 0: indmin = 0
-        if indmax < 1: indmax = 1
-        if indmin == indmax: indmax += 1
-        ymin, ymax = (self.df[self.low][indmin:indmax].min(), self.df[self.high][indmin:indmax].max())
-        ysub = (ymax - ymin) / 15
-        pmin, pmax = (ymin-ysub, ymax+ysub)
-        self.ax_price.set_ylim(pmin, pmax)
-    
-        ymax = self.df[self.volume][indmin:indmax].max()
-        # self._vol_ymax = ymax*1.2
-        volmax = ymax * 1.2
-        self.ax_volume.set_ylim(0, volmax)
+        self.is_click_slider = True
+        self.figure.canvas.set_cursor(cursors.RESIZE_HORIZONTAL)
 
-        self.set_text_coordante(xmin, xmax, pmin, pmax, volmax)
+        x = e.xdata.__int__()
+        navmin, navmax = self.navcoordinate
+        
+        leftmin, leftmax = (navmin-self._navLineWidth, navmin+self._navLineWidth_half)
+        rightmin, rightmax = (navmax-self._navLineWidth_half, navmax+self._navLineWidth)
+
+        grater_than_left, less_then_right = (leftmax < x, x < rightmin)
+        if grater_than_left and less_then_right:
+            self.is_move = True
+            self.x_click = x
+        else:
+            if not grater_than_left and leftmin <= x:
+                self.click_navleft = True
+                self.x_click = navmax
+            elif not less_then_right and x <= rightmax:
+                self.click_navright = True
+                self.x_click = navmin
+            else:
+                self.x_click = x
         return
 
 
-class SimpleMixin(LimMixin):
-    simpler = False
-    limit_volume = 1_500
-    default_left, default_right = (180, 10)
-    _draw_blit = False
+class SliderSelectMixin(ClickMixin):
+    limit_ma = 8_000
 
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        
-        # 영역 이동시 주가 collection
-        self.blitcandle = LineCollection([], animated=True)
-        self.ax_price.add_collection(self.blitcandle)
-        self.priceline = LineCollection([], animated=True, edgecolors='k')
-        self.ax_price.add_artist(self.priceline)
+    def _on_move_slider(self, e):
+        if self.is_click_slider: self._set_navcoordinate(e)
+        return super()._on_move_slider(e)
 
-        # 영역 이동시 거래량 collection
-        self.blitvolume = LineCollection([], animated=True, edgecolors=self.colors_volume)
-        self.ax_volume.add_collection(self.blitvolume)
-        return
+    def _set_navcoordinate(self, e: MouseEvent):
+        x = e.xdata.__int__()
+        navmin, navmax = self.navcoordinate
 
-    def _set_data(self, df: pd.DataFrame, sort_df=True, calc_ma=True, change_lim=True, calc_info=True):
-        super()._set_data(df, sort_df, calc_ma, False, calc_info)
+        if self.is_move:
+            xsub = self.x_click - x
+            navmin, navmax = (navmin-xsub, navmax-xsub)
 
-        seg = self.df[['x', self.high, 'x', self.low]].values
-        seg = seg.reshape(seg.shape[0], 2, 2)
-        self.blitcandle.set_segments(seg)
-        self.blitcandle.set_edgecolor(self.df['edgecolor'])
+            # 값 보정
+            if navmax < 0: navmin, navmax = (navmin-navmax, 0)
+            if self.list_index[-1] < navmin: navmin, navmax = (self.list_index[-1], self.list_index[-1] + (navmax-navmin))
 
-        pseg = self.df[['x', self.close]].values
-        self.priceline.set_verts(pseg.reshape(1, *pseg.shape))
+            self.navcoordinate = (navmin, navmax)
+            self.x_click = x
 
-        l = self.df.__len__()
-        if l < self.limit_volume:
-            volseg = self.df.loc[:, ['x', 'zero', 'x', self.volume]].values
-        else:
-            v = self.df[['x', 'zero', 'x', self.volume]].sort_values([self.volume], axis=0, ascending=False)
-            volseg = v[:self.limit_volume].values
+            self._set_lim(navmin, navmax, simpler=True, set_ma=(navmax-navmin < self.limit_ma))
 
-        self.blitvolume.set_segments(volseg.reshape(volseg.shape[0], 2, 2))
+            self._set_navigator(navmin, navmax)
+            self.navigator.draw(self.figure.canvas.renderer)
 
-        if change_lim:
-            index = self.df.index[-1]
-            if index < self.default_left + self.default_right: self._navcoordinate = (int(self.xmin)-1, int(self.xmax)+1)
-            else: self._navcoordinate = (index-self.default_left, index+self.default_right)
+            self._draw_artist()
+            self.background_with_nav = self.figure.canvas.renderer.copy_from_bbox(self.figure.bbox)
+            self._restore_region(False, True)
+        else:
+            navmin, navmax = (x, self.x_click) if x < self.x_click else (self.x_click, x)
+
+            # 슬라이더가 차트를 벗어나지 않도록 선택 영역 제한
+            if navmax < 0 or self.list_index[-1] < navmin:
+                seg = self.navigator.get_segments()
+                navmin, navmax = (int(seg[1][0][0]), int(seg[3][0][0]))
+
+            nsub = navmax - navmin
+            if nsub < self.min_distance:
+                self._restore_region(False, False)
+                self._set_navigator(navmin, navmax)
+                self.navigator.draw(self.figure.canvas.renderer)
+            else:
+                self._set_lim(navmin, navmax, simpler=True, set_ma=(nsub < self.limit_ma))
+                self._set_navigator(navmin, navmax)
 
-        self._set_navigator(*self._navcoordinate)
-        self._lim()
-        return 
+                self.navigator.draw(self.figure.canvas.renderer)
 
-    def _draw_blit_artist(self):
-        renderer = self.canvas.renderer
+                self._draw_artist()
+                self.background_with_nav = self.figure.canvas.renderer.copy_from_bbox(self.figure.bbox)
+                self._restore_region(False, True)
+        return
 
-        self.ax_price.xaxis.draw(renderer)
-        self.ax_price.yaxis.draw(renderer)
 
-        if self.simpler:
-            if self._draw_blit: self.priceline.draw(renderer)
-            else: self.blitcandle.draw(renderer)
-        elif self.candle_on_ma:
-            self.macollection.draw(renderer)
-            if self._draw_blit: self.blitcandle.draw(renderer)
-            else: self.candlecollection.draw(renderer)
-        else:
-            if self._draw_blit: self.blitcandle.draw(renderer)
-            else: self.candlecollection.draw(renderer)
-            self.macollection.draw(renderer)
+class ReleaseMixin(SliderSelectMixin):
+    def _connect_event(self):
+        super()._connect_event()
 
-        self.ax_volume.xaxis.draw(renderer)
-        self.ax_volume.yaxis.draw(renderer)
+        self.figure.canvas.mpl_connect('button_release_event', lambda x: self._on_release(x))
+        return
 
-        self.blitvolume.draw(renderer)
+    def _on_release(self, e: MouseEvent):
+        if self.in_slider and self.is_click_slider: self._on_release_slider(e)
+        return
+
+    def _on_release_slider(self, e: MouseEvent):
+        if not self.is_move:
+            seg = self.navigator.get_segments()
+            navmin, navmax = (int(seg[1][0][0]), int(seg[3][0][0]))
+            nsub = navmax - navmin
+            if self.min_distance <= nsub: self.navcoordinate = (navmin, navmax)
+            else:
+                self.background_with_nav = self.background_with_nav_pre
+                navmin, navmax = self.navcoordinate
+                self._set_lim(navmin, navmax, simpler=True, set_ma=(nsub < self.limit_ma))
+                self._restore_region(False, True)
+                self._blit()
+            self._set_navigator(*self.navcoordinate)
+
+        self.is_click_slider = False
+        self.is_move = False
+        self.click_navleft, self.click_navright = (False, False)
         return
 
 
-class ClickMixin(SimpleMixin):
+class ChartClickMixin(ReleaseMixin):
     is_click_chart = False
 
     def _on_click(self, e: MouseEvent):
-        if not self.is_click and e.button == MouseButton.LEFT:
-            if e.inaxes is self.ax_slider: pass
-            elif e.inaxes is self.ax_price or e.inaxes is self.ax_volume: return self._on_chart_click(e)
-            else: return
-        else: return
+        if self.in_price_chart or self.in_volume_chart: self._on_click_chart(e)
+        elif self.in_slider: self._on_click_slider(e)
+        return
 
-        self.is_click = True
+    def _on_click_chart(self, e: MouseEvent):
+        if self.is_click_chart: return
 
-        x = e.xdata.__int__()
-        left, right = self._navcoordinate
-        lmin, lmax = (left-self._navLineWidth, left+self._navLineWidth_half)
-        rmin, rmax = (right-self._navLineWidth_half, right+self._navLineWidth)
-
-        gtl, ltr = (lmax < x, x < rmin)
-        if gtl and ltr:
-            self._x_click = x
-            self.is_move = True
-            self.canvas.set_cursor(cursors.MOVE)
-        else:
-            self.canvas.set_cursor(cursors.RESIZE_HORIZONTAL)
-            if not gtl and lmin <= x:
-                self._x_click = right
-            elif not ltr and x <= rmax:
-                self._x_click = left
-            else:
-                self._x_click = x
+        self.is_click_chart = True
+        self._x_click = e.x.__round__(2)
+        self.figure.canvas.set_cursor(cursors.RESIZE_HORIZONTAL)
+        return
 
-        # 그리기 후 최초 클릭이면 좌표 수정
-        if left == right:
-            self._navcoordinate = (x, x)
+    def _on_release(self, e):
+        if self.is_click_chart and (self.in_price_chart or self.in_volume_chart): self._on_release_chart(e)
+        elif self.is_click_slider and self.in_slider: self._on_release_slider(e)
         return
 
-    def _on_release(self, e: MouseEvent):
-        if not self.is_click: return
-        elif e.inaxes is self.ax_slider: return super()._on_release(e)
-        elif not self.in_price and not self.in_volume and not self.is_click_chart: return
-        # 차트 click release action
-        self.canvas.set_cursor(cursors.POINTER)
-        self.is_click, self.is_move = (False, False)
+    def _on_release_chart(self, e):
         self.is_click_chart = False
+        self.figure.canvas.set_cursor(cursors.POINTER)
+        return
+
+    def _change_cursor(self, e):
+        if self.is_click_chart: return
+        return super()._change_cursor(e)
+
+    def _on_move(self, e):
+        self._on_move_action(e)
+
+        need_slider_action = self.is_click_slider and self.in_slider
+        need_chart_action = False if need_slider_action else self.is_click_chart and (self.in_price_chart or self.in_volume_chart)
+        self._restore_region((need_slider_action or need_chart_action))
+
+        if self.in_slider:
+            self._on_move_slider(e)
+        elif self.in_price_chart:
+            self._on_move_price_chart(e)
+        elif self.in_volume_chart:
+            self._on_move_volume_chart(e)
 
-        self._restore_region(empty=True)
-        self._copy_bbox()
-        self._restore_region()
         self._blit()
         return
 
-    def _on_chart_click(self, e: MouseEvent):
-        self.is_click = True
-        self.is_click_chart = True
-        self._x_click = e.x.__int__()
-        self.canvas.set_cursor(cursors.RESIZE_HORIZONTAL)
-        return
+    def _on_move_price_chart(self, e):
+        if self.is_click_chart: self._move_chart(e)
+        return super()._on_move_price_chart(e)
 
-    def _change_coordinate(self):
-        if self.is_click_chart: self._change_coordinate_chart()
-        else: super()._change_coordinate()
-        return
+    def _on_move_volume_chart(self, e):
+        if self.is_click_chart: self._move_chart(e)
+        return super()._on_move_volume_chart(e)
 
-    def _change_coordinate_chart(self, e: MouseEvent):
-        x = e.x.__int__()
-        left, right = self._navcoordinate
+    def _move_chart(self, e: MouseEvent):
+        x = e.x.__round__(2)
+        left, right = self.navcoordinate
         nsub = right - left
         xsub = x - self._x_click
         xdiv = (xsub / (1200 / nsub)).__int__()
-        if xdiv:
+        if not xdiv:
+            self.navigator.draw(self.figure.canvas.renderer)
+            self._draw_artist()
+        else:
             left, right = (left-xdiv, right-xdiv)
-            if -1 < right and left < self.df.index[-1]:
-                self._navcoordinate = (left, right)
+            if right < 0 or self.df.index[-1] < left: self._restore_region(False, True)
+            else:
+                self.navcoordinate = (left, right)
+                self._set_lim(left, right, simpler=True, set_ma=((right-left) < self.limit_ma))
+                self._set_navigator(left, right)
+                self.navigator.draw(self.figure.canvas.renderer)
+
+                self._draw_artist()
+                self.background_with_nav = self.figure.canvas.renderer.copy_from_bbox(self.figure.bbox)
+                self._restore_region(False, True)
             self._x_click = x
         return
 
-    def _on_move(self, e):
-        self._restore_region(with_nav=(not self.is_click), empty_with_nav=self.is_click)
 
-        self._on_move_action(e)
-
-        if self.in_slider and not self.is_click_chart:
-            self._change_coordinate()
-            if self.is_click:
-                nsub = self._navcoordinate[1] - self._navcoordinate[0]
-                if self.is_move: self._set_navigator(*self._navcoordinate)
-                else:
-                    self._draw_blit = 900 < nsub
-                    if self.intx is not None: self._set_navigator(self._x_click, self.intx)
-
-                if self.min_distance <= nsub: self._lim()
-
-                self.navigator.draw(self.canvas.renderer)
-                self._draw_blit_artist()
-            self._slider_move_action(e)
-        elif self.is_click:
-            if self.is_click_chart and (self.in_price or self.in_volume):
-                if (self.vmin, self.vmax) != self._navcoordinate:
-                    self._change_coordinate_chart(e)
-                    self._lim()
-                    self._set_navigator(*self._navcoordinate)
-            self.navigator.draw(self.canvas.renderer)
-            self._draw_blit_artist()
-        else:
-            if self.in_slider or self.in_price or self.in_volume:
-                self._slider_move_action(e)
-            if self.in_price or self.in_volume:
-                self._chart_move_action(e)
+class BaseMixin(ChartClickMixin):
+    pass
 
-        self._blit()
-        return
 
+class Chart(BaseMixin, Mixin):
+    def _add_collection(self):
+        super()._add_collection()
+        return self.add_artist()
 
-class SliderMixin(ClickMixin):
-    pass
+    def _draw_artist(self):
+        super()._draw_artist()
+        return self.draw_artist()
 
+    def _get_segments(self):
+        self.generate_data()
+        return super()._get_segments()
 
-class Chart(SliderMixin, CM, Mixin):
     def _on_draw(self, e):
         super()._on_draw(e)
         return self.on_draw(e)
@@ -507,44 +576,30 @@ class Chart(SliderMixin, CM, Mixin):
         self.on_pick(e)
         return super()._on_pick(e)
 
+    def _set_candle_segments(self, index_start, index_end):
+        super()._set_candle_segments(index_start, index_end)
+        self.set_segment(index_start, index_end)
+        return
+
+    def _set_wick_segments(self, index_start, index_end, simpler=False):
+        super()._set_wick_segments(index_start, index_end, simpler)
+        self.set_segment(index_start, index_end, simpler)
+        return
+
+    def _set_line_segments(self, index_start, index_end, simpler=False, set_ma=True):
+        super()._set_line_segments(index_start, index_end, simpler, set_ma)
+        self.set_segment(index_start, index_end, simpler, set_ma)
+        return
+
     def _on_move(self, e):
         super()._on_move(e)
         return self.on_move(e)
 
-    def _draw_artist(self):
-        super()._draw_artist()
-        return self.draw_artist()
-    def _draw_blit_artist(self):
-        super()._draw_blit_artist()
-        return self.draw_artist()
-
     def _on_click(self, e):
         super()._on_click(e)
         return self.on_click(e)
-    def _on_release(self, e):
-        super()._on_release(e)
-        return self.on_release(e)
-
-
-if __name__ == '__main__':
-    import json
-    from time import time
 
-    import matplotlib.pyplot as plt
-    from pathlib import Path
-
-    file = Path(__file__).parent / 'data/samsung.txt'
-    # file = Path(__file__).parent / 'data/apple.txt'
-    with open(file, 'r', encoding='utf-8') as txt:
-        data = json.load(txt)
-    data = data
-    df = pd.DataFrame(data)
-
-    t = time()
-    # c = SimpleMixin()
-    c = SliderMixin()
-    c.set_data(df)
-    t2 = time() - t
-    print(f'{t2=}')
-    plt.show()
+    def on_release(self, e):
+        super().on_release(e)
+        return self.on_release(e)