pyqttoolkit 0.9.1__py3-none-any.whl

pyqttoolkit/views/plot/matplotlib/colorbar.py

@@ -0,0 +1,75 @@
+# pyqttoolkit
+# Copyright (C) 2018-2019, Simmovation Ltd.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+from pyqttoolkit.views.plot.matplotlib import MatPlotLibBase
+from mpl_toolkits.axes_grid1 import Size
+from mpl_toolkits.axes_grid1.mpl_axes import Axes
+
+def _is_horizontal(position):
+    return position == 'top' or position == 'bottom'
+
+
+def _define_axes(position, cbar_size, _gap):
+    if position == 'bottom':
+        return [Size.Fixed(cbar_size), Size.Fixed(_gap), Size.Scaled(1.0)]
+    elif position == 'top':
+        return [Size.Scaled(1.0), Size.Fixed(_gap), Size.Fixed(cbar_size)]
+    elif position == 'left':
+        return [Size.Fixed(_gap/4), Size.Fixed(cbar_size), Size.Fixed(_gap*3), Size.Scaled(1.0)]
+    elif position == 'right':
+        return [Size.Scaled(1.0), Size.Fixed(_gap), Size.Fixed(cbar_size), Size.Fixed(_gap)]
+    else:
+        return None
+
+
+class MatPlotColorbar(MatPlotLibBase):
+    def __init__(self, parent, file_dialog_service, cbar_height=0.2, v_gap=0.6, cbar_width=0.2, h_gap=0.6,
+                 position='bottom', **kwargs):
+
+        # First element of the tuple correspond to the nx_default or ny_default.
+        # The second element is the nx and ny position for _colorbar_axes.
+        self._nx = {'bottom': (1, 1), 'top': (1, 1), 'right': (1, 3), 'left': (4, 1)}
+        self._ny = {'bottom': (3, 1), 'top': (1, 3), 'right': (1, 1), 'left': (1, 1)}
+
+        super().__init__(parent,
+                         file_dialog_service,
+                         v_axes=[Size.Scaled(1.0)] if not _is_horizontal(position)
+                         else _define_axes(position, cbar_height, v_gap),
+                         h_axes=[Size.Scaled(1.0)] if _is_horizontal(position)
+                         else _define_axes(position, cbar_width, h_gap),
+                         nx_default=self._nx[position][0],
+                         ny_default=self._ny[position][0], **kwargs)
+        self._colorbar_axes = Axes(self._figure, self._divider.get_position())
+        self._colorbar_axes.set_axes_locator(self._divider.new_locator(nx=self._nx[position][1], ny=self._ny[position][1]))
+        self._figure.add_axes(self._colorbar_axes)
+        self._cbar = None
+        self._points = None
+        self._position = position
+
+    def _plot_colorbar(self, label):
+        if self._cbar is not None:
+            self._colorbar_axes.clear()
+        self._cbar = self._figure.colorbar(self._points, self._colorbar_axes, orientation='horizontal' if
+                                           _is_horizontal(self._position) else 'vertical')
+        self._cbar.set_label(label)
+
+    @property
+    def colorbar(self):
+        return self._cbar
+
+    @colorbar.setter
+    def colorbar(self, cbar):
+        self._cbar = cbar

pyqttoolkit/views/plot/matplotlib/colormap.py

@@ -0,0 +1,48 @@
+# pyqttoolkit
+# Copyright (C) 2018-2019, Simmovation Ltd.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+from matplotlib.colors import LinearSegmentedColormap
+
+class MatPlotLibColormap:
+    def __init__(self, colormap, limits=None, invert=False):
+        self._colormap = colormap.reversed() if colormap and invert else colormap
+        self._limits = limits
+
+    @property
+    def colormap(self):
+        return self._colormap
+    
+    @property
+    def has_limits(self):
+        return self._limits is not None
+    
+    @property
+    def limits(self):
+        return self._limits
+    
+    @staticmethod
+    def from_list(values, invert=False):
+        if all(len(v) == 3 for v in values):
+            return MatPlotLibColormap(LinearSegmentedColormap.from_list('cmap', values), invert=invert)
+        if not all(len(v) == 2 for v in values):
+            return MatPlotLibColormap(None)
+        values = sorted(values, key=lambda v: v[0])
+        range_lower, range_upper = values[0][0], values[-1][0]
+        if range_lower == 0.0 and range_upper == 1.0:
+            return MatPlotLibColormap(LinearSegmentedColormap.from_list('cmap', values), invert=invert)
+        total_range = range_upper - range_lower
+        values = [((p - range_lower) / total_range, c) for p, c in values]
+        return MatPlotLibColormap(LinearSegmentedColormap.from_list('cmap', values), limits=(range_lower, range_upper), invert=invert)

pyqttoolkit/views/plot/matplotlib/font.py

@@ -0,0 +1,55 @@
+# pyqttoolkit
+# Copyright (C) 2018-2019, Simmovation Ltd.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+from matplotlib import rcParams
+from matplotlib.font_manager import findfont, FontProperties
+from fontTools.ttLib import TTFont
+from fontTools.ttLib.tables._c_m_a_p import CmapSubtable
+
+class MatPlotLibFont:
+    def __init__(self, font):
+        font_file = findfont(FontProperties(family=font))
+        self._is_ttf = font_file.endswith('.ttf')
+        if not self._is_ttf:
+            raise ValueError('Unknown font type')
+        self._font = TTFont(font_file)
+
+    def get_size(self, text, pointsize, dpi):
+        return self._get_ttf_size(text, pointsize, dpi)
+    
+    def _get_ttf_size(self, text, pointsize, dpi):
+        cmap = self._font['cmap']
+        t = cmap.getcmap(3,1).cmap
+        s = self._font.getGlyphSet()
+        width = 0
+        for c in text:
+            if ord(c) in t and t[ord(c)] in s:
+                char = s[t[ord(c)]]
+            else:
+                char = s['.notdef']
+            width += char.width
+        units_per_em = self._font['head'].unitsPerEm
+        return self._convert_to_pixels(width, pointsize, dpi, units_per_em), self._convert_to_pixels(units_per_em, pointsize, dpi, units_per_em)
+    
+    def _convert_to_pixels(self, value, pointsize, dpi, units_per_em):
+        value_pts = value * float(pointsize) / units_per_em
+        value_in = value_pts / 72
+        value_pixels = value_in * dpi
+        return value_pixels
+
+    @staticmethod
+    def default():
+        return MatPlotLibFont(rcParams['font.family'])

pyqttoolkit/views/plot/plot_options.py

@@ -0,0 +1,211 @@
+# pyqttoolkit
+# Copyright (C) 2018-2019, Simmovation Ltd.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+import math
+
+import numpy as np
+
+from PyQt5.QtWidgets import QWidget, QGridLayout, QLabel
+from PyQt5.QtCore import pyqtSignal
+
+from pyqttoolkit.properties import AutoProperty, bind
+from pyqttoolkit.views import BindableCheckBox, AutoFloatLineEdit
+
+class PlotOptionsView(QWidget):
+    def __init__(self, parent, grid_lines=True, x_limits=True, y_limits=True, secondary_x_limits=False, secondary_y_limits=False):
+        QWidget.__init__(self, parent)
+
+        edit_width = 60
+        self._grid_lines = grid_lines
+        self._x_limits = x_limits
+        self._y_limits = y_limits
+        self._secondary_y_limits = secondary_y_limits
+        self._secondary_x_limits = secondary_x_limits
+
+        self.showGridLines = False
+        self.xAxisLowerLimit = self.xAxisUpperLimit = self.yAxisLowerLimit = self.yAxisUpperLimit = float('nan')
+        self.secondaryXAxisLowerLimit = self.secondaryXAxisUpperLimit = self.secondaryYAxisLowerLimit = self.secondaryYAxisUpperLimit = float('nan')
+
+        self._layout = QGridLayout(self)
+        if grid_lines:
+            self._show_gridlines = BindableCheckBox(None, self)
+            self._layout.addWidget(QLabel(self.tr('Show Grid Lines'), self), 0, 0)
+            self._layout.addWidget(self._show_gridlines, 0, 1)
+            bind(self, self._show_gridlines, 'showGridLines', 'checked')
+        else:
+            self._show_gridlines = None
+
+        if x_limits:
+            self._x_axis_lower_limit = AutoFloatLineEdit(self, allow_inf=False, formatter=self._value_formatter)
+            self._x_axis_upper_limit = AutoFloatLineEdit(self, allow_inf=False, formatter=self._value_formatter)
+            self._x_axis_lower_limit.setFixedWidth(edit_width)
+            self._x_axis_upper_limit.setFixedWidth(edit_width)
+            self._layout.addWidget(QLabel(self.tr('X Axis Limits'), self), 1, 0)
+            self._layout.addWidget(self._x_axis_lower_limit, 1, 1)
+            self._layout.addWidget(self._x_axis_upper_limit, 1, 2)
+            bind(self, self._x_axis_lower_limit, 'xAxisLowerLimit', 'value')
+            bind(self, self._x_axis_upper_limit, 'xAxisUpperLimit', 'value')
+        else:
+            self._x_axis_lower_limit = self._x_axis_upper_limit = None
+
+        if y_limits:
+            self._y_axis_lower_limit = AutoFloatLineEdit(self, allow_inf=False, formatter=self._value_formatter)
+            self._y_axis_upper_limit = AutoFloatLineEdit(self, allow_inf=False, formatter=self._value_formatter)
+            self._y_axis_lower_limit.setFixedWidth(edit_width)
+            self._y_axis_upper_limit.setFixedWidth(edit_width)
+            self._layout.addWidget(QLabel(self.tr('Y Axis Limits'), self), 2, 0)
+            self._layout.addWidget(self._y_axis_lower_limit, 2, 1)
+            self._layout.addWidget(self._y_axis_upper_limit, 2, 2)
+            bind(self, self._y_axis_lower_limit, 'yAxisLowerLimit', 'value')
+            bind(self, self._y_axis_upper_limit, 'yAxisUpperLimit', 'value')
+        else:
+            self._y_axis_lower_limit = self._y_axis_upper_limit = None
+        
+        if secondary_y_limits:
+            self._secondary_y_axis_lower_limit = AutoFloatLineEdit(self, allow_inf=False, formatter=self._value_formatter)
+            self._secondary_y_axis_upper_limit = AutoFloatLineEdit(self, allow_inf=False, formatter=self._value_formatter)
+            self._secondary_y_axis_lower_limit.setFixedWidth(edit_width)
+            self._secondary_y_axis_upper_limit.setFixedWidth(edit_width)
+            self._secondary_y_limits_label = QLabel(self.tr('2nd Y Axis Limits'), self)
+            self._layout.addWidget(self._secondary_y_limits_label, 3, 0)
+            self._layout.addWidget(self._secondary_y_axis_lower_limit, 3, 1)
+            self._layout.addWidget(self._secondary_y_axis_upper_limit, 3, 2)
+            bind(self, self._secondary_y_axis_lower_limit, 'secondaryYAxisLowerLimit', 'value')
+            bind(self, self._secondary_y_axis_upper_limit, 'secondaryYAxisUpperLimit', 'value')
+        else:
+            self._secondary_y_axis_lower_limit = self._secondary_y_axis_upper_limit = self._secondary_y_limits_label = None
+
+        if secondary_x_limits:
+            self._secondary_x_axis_lower_limit = AutoFloatLineEdit(self, allow_inf=False, formatter=self._value_formatter)
+            self._secondary_x_axis_upper_limit = AutoFloatLineEdit(self, allow_inf=False, formatter=self._value_formatter)
+            self._secondary_x_axis_lower_limit.setFixedWidth(edit_width)
+            self._secondary_x_axis_upper_limit.setFixedWidth(edit_width)
+            self._secondary_x_limits_label = QLabel(self.tr('2nd X Axis Limits'), self)
+            self._layout.addWidget(self._secondary_x_limits_label, 4, 0)
+            self._layout.addWidget(self._secondary_x_axis_lower_limit, 4, 1)
+            self._layout.addWidget(self._secondary_x_axis_upper_limit, 4, 2)
+            bind(self, self._secondary_x_axis_lower_limit, 'secondaryXAxisLowerLimit', 'value')
+            bind(self, self._secondary_x_axis_upper_limit, 'secondaryXAxisUpperLimit', 'value')
+        else:
+            self._secondary_x_axis_lower_limit = self._secondary_x_axis_upper_limit = self._secondary_x_limits_label = None
+
+
+    showGridLinesChanged = pyqtSignal(bool)
+    xAxisLowerLimitChanged = pyqtSignal(float)
+    xAxisUpperLimitChanged = pyqtSignal(float)
+    xAxisLimitsChanged = pyqtSignal(float, float)
+    yAxisLowerLimitChanged = pyqtSignal(float)
+    yAxisUpperLimitChanged = pyqtSignal(float)
+    yAxisLimitsChanged = pyqtSignal(float, float)
+    secondaryXAxisLowerLimitChanged = pyqtSignal(float)
+    secondaryXAxisUpperLimitChanged = pyqtSignal(float)
+    secondaryXAxisLimitsChanged = pyqtSignal(float, float)
+    secondaryYAxisLowerLimitChanged = pyqtSignal(float)
+    secondaryYAxisUpperLimitChanged = pyqtSignal(float)
+    secondaryYAxisLimitsChanged = pyqtSignal(float, float)
+
+    showGridLines = AutoProperty(bool)
+    xAxisLowerLimit = AutoProperty(float)
+    xAxisUpperLimit = AutoProperty(float)
+    yAxisLowerLimit = AutoProperty(float)
+    yAxisUpperLimit = AutoProperty(float)
+    secondaryYAxisLowerLimit = AutoProperty(float)
+    secondaryYAxisUpperLimit = AutoProperty(float)
+    secondaryXAxisLowerLimit = AutoProperty(float)
+    secondaryXAxisUpperLimit = AutoProperty(float)
+
+    def _value_formatter(self, value):
+        if isinstance(value, str):
+            return value
+        if value == np.inf:
+            return 'inf'
+        if value == -np.inf:
+            return '-inf'
+        if np.isnan(value):
+            return 'Auto'
+        value = int(value * 100) / 100
+        if value == 0:
+            return '0.0'
+        precision = min(int(math.log10(abs(value))), 2) + 2
+        return f'{value:.{precision}g}'
+    
+    @property
+    def grid_lines(self):
+        return self._grid_lines
+    
+    def setXLimits(self, x_lower, x_upper):
+        blocked = self.blockSignals(True)
+        self.xAxisLowerLimit = x_lower
+        self._x_axis_lower_limit.value = x_lower
+        self.xAxisUpperLimit = x_upper
+        self._x_axis_upper_limit.value = x_upper
+        self.blockSignals(blocked)
+        self.xAxisLimitsChanged.emit(x_lower, x_upper)
+    
+    def setYLimits(self, y_lower, y_upper):
+        blocked = self.blockSignals(True)
+        self.yAxisLowerLimit = y_lower
+        self._y_axis_lower_limit.value = y_lower
+        self.yAxisUpperLimit = y_upper
+        self._y_axis_upper_limit.value = y_upper
+        self.blockSignals(blocked)
+        self.yAxisLimitsChanged.emit(y_lower, y_upper)
+    
+    def setSecondaryXLimits(self, x_lower, x_upper):
+        blocked = self.blockSignals(True)
+        self.secondaryXAxisLowerLimit = x_lower
+        self._secondary_x_axis_lower_limit.value = x_lower
+        self.secondaryXAxisUpperLimit = x_upper
+        self._secondary_x_axis_upper_limit.value = x_upper
+        self.blockSignals(blocked)
+        self.secondaryXAxisLimitsChanged.emit(x_lower, x_upper)
+    
+    def setSecondaryYLimits(self, y_lower, y_upper):
+        blocked = self.blockSignals(True)
+        self.secondaryYAxisLowerLimit = y_lower
+        self._secondary_y_axis_lower_limit.value = y_lower
+        self.secondaryYAxisUpperLimit = y_upper
+        self._secondary_y_axis_upper_limit.value = y_upper
+        self.blockSignals(blocked)
+        self.secondaryYAxisLimitsChanged.emit(y_lower, y_upper)
+    
+    @property
+    def x_limits(self):
+        return self._x_limits
+    
+    @property
+    def y_limits(self):
+        return self._y_limits
+
+    @property
+    def secondary_y_limits(self):
+        return self._secondary_y_limits
+
+    @property
+    def secondary_x_limits(self):
+        return self._secondary_x_limits
+
+    def setSecondaryYLimitsEnabled(self, enabled):
+        if self._secondary_y_limits:
+            self._secondary_y_axis_lower_limit.setEnabled(enabled)
+            self._secondary_y_axis_upper_limit.setEnabled(enabled)
+            self._secondary_y_limits_label.setEnabled(enabled)
+
+    def setSecondaryXLimitsEnabled(self, enabled):
+        if self._secondary_x_limits:
+            self._secondary_x_axis_lower_limit.setEnabled(enabled)
+            self._secondary_x_axis_upper_limit.setEnabled(enabled)
+            self._secondary_x_limits_label.setEnabled(enabled)

pyqttoolkit/views/plot/plot_toolbar_options.py

@@ -0,0 +1,133 @@
+# pyqttoolkit
+# Copyright (C) 2018-2019, Simmovation Ltd.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+from PyQt5.QtWidgets import QWidget, QGridLayout, QSizePolicy, QVBoxLayout
+from PyQt5.QtCore import Qt
+
+from pyqttoolkit.views import PopoutWidget, make_styleable
+from pyqttoolkit.colors import interpolate_rgb, format_color, ColorFormat
+from pyqttoolkit.views.layout import HLine
+
+from .tool_type import ToolType
+from .toolbar import PlotToolbarWidget
+from .plot_options import PlotOptionsView
+from .legend_control import LegendControlView
+
+def _to_qt_color(color):
+    return tuple(c * 255 for c in color)
+
+class ToolbarContainer(QWidget):
+    pass
+
+ToolbarContainer = make_styleable(ToolbarContainer)
+
+class PlotToolbarOptions(QWidget):
+    def __init__(self, parent, series_style, theme_manager, plot, options=None, legend_control=None, right_padding=0, has_extra_tools=False):
+        QWidget.__init__(self, parent)
+        self._theme_manager = theme_manager
+        self._plot = plot
+        self._toolbar_container = ToolbarContainer(plot)
+        
+        self._background_color_qt = _to_qt_color(series_style.get_color_from_key('axes_background'))
+        self._foreground_color_qt = _to_qt_color(series_style.get_color_from_key('axes_foreground'))
+        interpolation = interpolate_rgb(self._background_color_qt, self._foreground_color_qt, 3)
+        self._icon_hover_color = interpolation[1]
+
+        self._toolbar = PlotToolbarWidget(self._toolbar_container, plot, self._foreground_color_qt, self._icon_hover_color)
+        self._toolbar.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
+        self._layout = QGridLayout(self)
+        self._layout.setContentsMargins(0, 0, 0, 0)
+        self._layout.setSpacing(0)
+        self._layout.addWidget(plot, 0, 0, 1, 3)
+        self._background_opacity = 0.8
+        plot.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
+        if options is not None:
+            if isinstance(options, PlotOptionsView):
+                plot.setOptionsView(options)
+            self._options = self._add_popout(ToolType.options, options)
+        else:
+            self._options = None
+
+        if legend_control is not None:
+            if isinstance(legend_control, LegendControlView):
+                plot.setLegendControl(legend_control)
+            self._legend_control = self._add_popout(ToolType.legend, legend_control)
+            legend_control.hasHiddenSeriesChanged.connect(self._handle_has_hidden_series_changed)
+        else:
+            self._legend_control = None
+        
+        self._toolbar_layout = QVBoxLayout(self._toolbar_container)
+        self._toolbar_layout.addWidget(self._toolbar, Qt.AlignTop)
+
+        self._layout.addWidget(self._toolbar_container, 0, 1, Qt.AlignRight | Qt.AlignTop)
+        self._layout.setColumnStretch(0, 1)
+        self._layout.setColumnStretch(1, 0)
+        if right_padding > 0:
+            self._padding_widget = QWidget(self)
+            self._padding_widget.setVisible(False)
+            self._layout.addWidget(self._padding_widget, 0, 2)
+            self._layout.setColumnMinimumWidth(2, int(right_padding))
+        else:
+            self._padding_widget = None
+        
+        if not has_extra_tools:
+            self._toolbar_layout.addStretch()
+    
+    def _handle_has_hidden_series_changed(self, has_hidden):
+        color = None if not has_hidden else self._theme_manager.get_color('highlight')
+        self._toolbar.setColor(ToolType.legend, color)
+
+    def _handle_tool_activated(self, tool_type, view):
+        def _(tool, active):
+            if tool == tool_type:
+                view.setVisible(active)
+                if self._padding_widget:
+                    self._padding_widget.setVisible(active)
+                if active:
+                    self._toolbar_container.setStyleSheet("ToolbarContainer {{ background-color: {} }}".format(format_color(self._background_color_qt, ColorFormat.rgba_string_256, self._background_opacity)))
+                    self._layout.setAlignment(self._toolbar_container, Qt.AlignRight)
+                    if self._padding_widget:
+                        self._padding_widget.setStyleSheet("QWidget {{ background-color: {} }}".format(format_color(self._background_color_qt, ColorFormat.rgba_string_256, self._background_opacity)))
+                else:
+                    self._layout.setAlignment(self._toolbar_container, Qt.AlignRight | Qt.AlignTop)
+                    self._toolbar_container.setStyleSheet("")
+                    if self._padding_widget:
+                        self._padding_widget.setStyleSheet("")
+        return _
+
+    def addTool(self, tool_widget):
+        self._toolbar_layout.addWidget(HLine(self._plot), Qt.AlignTop)
+        self._toolbar_layout.addWidget(tool_widget, Qt.AlignTop | Qt.AlignCenter)
+        self._toolbar_layout.addStretch()
+    
+    @property
+    def icon_color(self):
+        return self._foreground_color_qt
+
+    @property
+    def icon_hover_color(self):
+        return self._icon_hover_color
+
+    @property
+    def toolbar(self):
+        return self._toolbar
+
+    def _add_popout(self, tool_type, view):
+        popout = PopoutWidget(self, view, self._background_color_qt, self._foreground_color_qt, self._background_opacity)
+        popout.setVisible(False)
+        self._layout.addWidget(popout, 0, 0, Qt.AlignRight)
+        self._toolbar.toolActivated.connect(self._handle_tool_activated(tool_type, popout))
+        return popout

pyqttoolkit/views/plot/size.py

@@ -0,0 +1,41 @@
+# pyqttoolkit
+# Copyright (C) 2018-2019, Simmovation Ltd.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+from mpl_toolkits.axes_grid1 import Size
+
+class ToggleableFixed(Size._Base):
+    def __init__(self, size):
+        self._size = size
+        self._active = False
+
+    def activate(self):
+        self._active = True
+    
+    def deactivate(self):
+        self._active = False
+
+    def get_size(self, _renderer):
+        return 0.0, self._size if self._active else 0.0
+
+class MaxWidth(Size.MaxWidth):
+    def remove_artist(self, artist):
+        if artist in self._artist_list:
+            self._artist_list.remove(artist)
+    
+    def get_size(self, renderer):
+        if self._artist_list:
+            return Size.MaxWidth.get_size(self, renderer)
+        return 0, 0

pyqttoolkit/views/plot/tool_type.py

@@ -0,0 +1,26 @@
+# pyqttoolkit
+# Copyright (C) 2018-2019, Simmovation Ltd.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+from enum import Enum
+
+class ToolType(Enum):
+    zoom = 0
+    polygon = 1
+    span = 2
+    pan = 3
+    reset = 4
+    options = 5
+    legend = 6