def setup(self, toolbar_widget: QtWidgets.QToolBar):
toolbar_widget.setOrientation(QtCore.Qt.Vertical)
pan_icon = QtGui.QIcon(":/image/pan.png")
pan = toolbar_widget.addAction(pan_icon, "Pan")
pan.setCheckable(True)
zoom_icon = QtGui.QIcon(":/image/zoom.png")
zoom = toolbar_widget.addAction(zoom_icon, "Zoom")
zoom.setCheckable(True)
reset_icon = QtGui.QIcon(":/image/home.png")
reset = toolbar_widget.addAction(reset_icon, "Reset")
def f(checked, a):
if checked:
a.setChecked(False)
pan.triggered.connect(self._onPan)
zoom.triggered.connect(self._onZoom)
reset.triggered.connect(self._onReset)
self.pan_action = pan
self.zoom_action = zoom
class CrossSectionWidget(PanelWidget):
PANEL_ID = None
PANEL_TITLE = _("Cross section tool")
PANEL_ICON = "csection.png"
CrossSectionPlotKlass = None
__implements__ = (IPanel,)
def __init__(self, parent=None):
super(CrossSectionWidget, self).__init__(parent)
self.export_ac = None
self.autoscale_ac = None
self.refresh_ac = None
self.autorefresh_ac = None
self.lockscales_ac = None
self.manager = None # manager for the associated image plot
self.local_manager = PlotManager(self)
self.cs_plot = self.CrossSectionPlotKlass(parent)
self.cs_plot.SIG_CS_CURVE_CHANGED.connect(self.cs_curve_has_changed)
self.export_tool = None
self.setup_plot()
self.toolbar = QToolBar(self)
self.toolbar.setOrientation(Qt.Vertical)
self.setup_widget()
def set_options(self, autoscale=None, autorefresh=None, lockscales=None):
assert self.manager is not None, (
"Panel '%s' must be registered to plot manager before changing options"
% self.PANEL_ID
)
if autoscale is not None:
self.autoscale_ac.setChecked(autoscale)
if autorefresh is not None:
self.autorefresh_ac.setChecked(autorefresh)
if lockscales is not None:
self.lockscales_ac.setChecked(lockscales)
def setup_plot(self):
# Configure the local manager
lman = self.local_manager
lman.add_plot(self.cs_plot)
lman.register_all_curve_tools()
self.export_tool = lman.get_tool(ExportItemDataTool)
def setup_widget(self):
layout = QHBoxLayout()
layout.addWidget(self.cs_plot)
layout.addWidget(self.toolbar)
layout.setContentsMargins(0, 0, 0, 0)
self.setLayout(layout)
def cs_curve_has_changed(self, curve):
"""Cross section curve has just changed"""
# Do something with curve's data for example
pass
def register_panel(self, manager):
"""Register panel to plot manager"""
self.manager = manager
for plot in manager.get_plots():
self.cs_plot.connect_plot(plot)
self.setup_actions()
self.add_actions_to_toolbar()
def configure_panel(self):
"""Configure panel"""
pass
def get_plot(self):
return self.manager.get_active_plot()
def setup_actions(self):
self.export_ac = self.export_tool.action
self.lockscales_ac = create_action(
self,
_("Lock scales"),
icon=get_icon("axes.png"),
toggled=self.cs_plot.toggle_lockscales,
tip=_("Lock scales to main plot axes"),
)
self.lockscales_ac.setChecked(self.cs_plot.lockscales)
self.autoscale_ac = create_action(
self,
_("Auto-scale"),
icon=get_icon("csautoscale.png"),
toggled=self.cs_plot.toggle_autoscale,
)
self.autoscale_ac.toggled.connect(self.lockscales_ac.setDisabled)
self.autoscale_ac.setChecked(self.cs_plot.autoscale_mode)
self.refresh_ac = create_action(
self,
_("Refresh"),
icon=get_icon("refresh.png"),
triggered=lambda: self.cs_plot.update_plot(),
)
self.autorefresh_ac = create_action(
self,
_("Auto-refresh"),
icon=get_icon("autorefresh.png"),
toggled=self.cs_plot.toggle_autorefresh,
)
self.autorefresh_ac.setChecked(self.cs_plot.autorefresh_mode)
def add_actions_to_toolbar(self):
add_actions(
self.toolbar,
(
self.export_ac,
None,
self.autoscale_ac,
self.lockscales_ac,
None,
self.refresh_ac,
self.autorefresh_ac,
),
)
def register_shape(self, shape, final, refresh=True):
plot = self.get_plot()
self.cs_plot.register_shape(plot, shape, final, refresh)
def unregister_shape(self, shape):
self.cs_plot.unregister_shape(shape)
def update_plot(self, obj=None):
"""
Update cross section curve(s) associated to object *obj*
*obj* may be a marker or a rectangular shape
(see :py:class:`guiqwt.tools.CrossSectionTool`
and :py:class:`guiqwt.tools.AverageCrossSectionTool`)
If obj is None, update the cross sections of the last active object
"""
self.cs_plot.update_plot(obj)
class ExtendedTabBar(QFrame):
'''
A tab bar that has QToolBars to the left, right, and floating at the end of the tabs.
Note that although this class inherits from QFrame, __getattr__() trickery is used to "inherit"
the attributes of an internal object that inherits from QTabBar. This is done because it allows
the actual tab bar object to be placed in a layout with other widgets, while allowing this class
to be treated as the tab bar itself.
'''
RoundedNorth = QTabBar.RoundedNorth
RoundedSouth = QTabBar.RoundedSouth
RoundedWest = QTabBar.RoundedWest
RoundedEast = QTabBar.RoundedEast
TriangularNorth = QTabBar.TriangularNorth
TriangularSouth = QTabBar.TriangularSouth
TriangularWest = QTabBar.TriangularWest
TriangularEast = QTabBar.TriangularEast
def __init__(self):
super(ExtendedTabBar, self).__init__()
self._tab_bar = _NoMinimumWidthTabBar()
self._left_toolbar = QToolBar()
self._floating_toolbar = QToolBar()
self._right_toolbar = QToolBar()
# Setup the layout.
self._main_layout = QBoxLayout(QBoxLayout.LeftToRight)
self._main_layout.setContentsMargins(0, 0, 0, 0)
self._main_layout.setSpacing(0)
self._main_layout.addWidget(self._left_toolbar)
self._main_layout.addWidget(self._tab_bar)
self._main_layout.addWidget(self._floating_toolbar)
self._main_layout.addStretch()
self._main_layout.addWidget(self._right_toolbar)
self.setLayout(self._main_layout)
def __getattr__(self, name):
'''
Return the internal tab bar object's attributes if this class does not have the given
attribute.
'''
return self.__dict__.get(name, getattr(self._tab_bar, name))
def minimumSizeHint(self):
'''
Add on any margins to the minimum size hint. Keeps the widget from getting sized so that the
tab tops are cut off.
'''
margins = self._main_layout.contentsMargins()
minimum_size_hint = self._tab_bar.minimumSizeHint()
if self.shape() in {
QTabBar.RoundedNorth, QTabBar.RoundedSouth,
QTabBar.TriangularNorth, QTabBar.TriangularSouth
}:
return minimum_size_hint + QSize(0,
margins.top() + margins.bottom())
else:
return minimum_size_hint + QSize(margins.left() + margins.right(),
0)
def setShape(self, shape):
'''
Sets the tab shapes.
shape
One of:
ExtendedTabBar.RoundedNorth
ExtendedTabBar.RoundedSouth
ExtendedTabBar.RoundedWest
ExtendedTabBar.RoundedEast
ExtendedTabBar.TriangularNorth
ExtendedTabBar.TriangularSouth
ExtendedTabBar.TriangularWest
ExtendedTabBar.TriangularEast
'''
self._tab_bar.setShape(shape)
if shape in {
QTabBar.RoundedNorth, QTabBar.RoundedSouth,
QTabBar.TriangularNorth, QTabBar.TriangularSouth
}:
direction = QBoxLayout.LeftToRight
orientation = Qt.Horizontal
else:
direction = QBoxLayout.TopToBottom
orientation = Qt.Vertical
self._main_layout.setDirection(direction)
self._left_toolbar.setOrientation(orientation)
self._floating_toolbar.setOrientation(orientation)
self._right_toolbar.setOrientation(orientation)
@property
def left_toolbar(self):
'''
Returns the QToolBar to the left (top) of the tabs.
'''
return self._left_toolbar
@property
def floating_toolbar(self):
'''
Returns the QToolBar floating to the right (bottom) of the tabs.
'''
return self._floating_toolbar
@property
def right_toolbar(self):
'''
Returns the QToolBar to the right (bottom) of the tabs.
'''
return self._right_toolbar
