guiqwt.tools

The tools module provides a collection of plot tools :

• guiqwt.tools.RectZoomTool

• guiqwt.tools.SelectTool

• guiqwt.tools.SelectPointTool

• guiqwt.tools.MultiLineTool

• guiqwt.tools.FreeFormTool

• guiqwt.tools.LabelTool

• guiqwt.tools.RectangleTool

• guiqwt.tools.PointTool

• guiqwt.tools.SegmentTool

• guiqwt.tools.CircleTool

• guiqwt.tools.EllipseTool

• guiqwt.tools.PlaceAxesTool

• guiqwt.tools.AnnotatedRectangleTool

• guiqwt.tools.AnnotatedCircleTool

• guiqwt.tools.AnnotatedEllipseTool

• guiqwt.tools.AnnotatedPointTool

• guiqwt.tools.AnnotatedSegmentTool

• guiqwt.tools.HRangeTool

• guiqwt.tools.DummySeparatorTool

• guiqwt.tools.AntiAliasingTool

• guiqwt.tools.DisplayCoordsTool

• guiqwt.tools.ReverseYAxisTool

• guiqwt.tools.AspectRatioTool

• guiqwt.tools.PanelTool

• guiqwt.tools.ItemListPanelTool

• guiqwt.tools.ContrastPanelTool

• guiqwt.tools.ColormapTool

• guiqwt.tools.XCSPanelTool

• guiqwt.tools.YCSPanelTool

• guiqwt.tools.CrossSectionTool

• guiqwt.tools.AverageCrossSectionTool

• guiqwt.tools.SaveAsTool

• guiqwt.tools.CopyToClipboardTool

• guiqwt.tools.OpenFileTool

• guiqwt.tools.OpenImageTool

• guiqwt.tools.SnapshotTool

• guiqwt.tools.PrintTool

• guiqwt.tools.SaveItemsTool

• guiqwt.tools.LoadItemsTool

• guiqwt.tools.AxisScaleTool

• guiqwt.tools.HelpTool

• guiqwt.tools.ExportItemDataTool

• guiqwt.tools.EditItemDataTool

• guiqwt.tools.ItemCenterTool

• guiqwt.tools.DeleteItemTool

A plot tool is an object providing various features to a plotting widget (guiqwt.curve.CurvePlot or guiqwt.image.ImagePlot): buttons, menus, selection tools, image I/O tools, etc. To make it work, a tool has to be registered to the plotting widget’s manager, i.e. an instance of the guiqwt.plot.PlotManager class (see the guiqwt.plot module for more details on the procedure).

The CurvePlot and ImagePlot widgets do not provide any PlotManager: the manager has to be created separately. On the contrary, the ready-to-use widgets guiqwt.plot.CurveWidget and guiqwt.plot.ImageWidget are higher-level plotting widgets with integrated manager, tools and panels.

See also

Module guiqwt.plot

Module providing ready-to-use curve and image plotting widgets and dialog boxes

Module guiqwt.curve

Module providing curve-related plot items and plotting widgets

Module guiqwt.image

Module providing image-related plot items and plotting widgets

Example

The following example add all the existing tools to an ImageWidget object for testing purpose:

Reference

class guiqwt.tools.RectZoomTool(manager, toolbar_id=<class 'guiqwt.tools.DefaultToolbarID'>, title=None, icon=None, tip=None, switch_to_default_tool=None)

activate()

Activate tool

blockSignals(self, bool) → bool

childEvent(self, QChildEvent)

children(self) → List[QObject]

connectNotify(self, QMetaMethod)

create_action(manager)

Create and return tool’s action

create_action_menu(manager)

Create and return menu for the tool’s action

cursor()

Return tool mouse cursor

customEvent(self, QEvent)

deactivate()

Deactivate tool

deleteLater(self)

disconnect(QMetaObject.Connection) → bool

disconnect(self) → None

disconnectNotify(self, QMetaMethod)

dumpObjectInfo(self)

dumpObjectTree(self)

dynamicPropertyNames(self) → List[QByteArray]

event(self, QEvent) → bool

eventFilter(self, QObject, QEvent) → bool

findChild(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChild(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChildren(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

inherits(self, str) → bool

installEventFilter(self, QObject)

isSignalConnected(self, QMetaMethod) → bool

isWidgetType(self) → bool

isWindowType(self) → bool

killTimer(self, int)

metaObject(self) → QMetaObject

moveToThread(self, QThread)

objectName(self) → str

parent(self) → QObject

property(self, str) → Any

pyqtConfigure(...)

Each keyword argument is either the name of a Qt property or a Qt signal. For properties the property is set to the given value which should be of an appropriate type. For signals the signal is connected to the given value which should be a callable.

receivers(self, PYQT_SIGNAL) → int

register_plot(baseplot)

Every BasePlot using this tool should call register_plot to notify the tool about this widget using it

removeEventFilter(self, QObject)

sender(self) → QObject

senderSignalIndex(self) → int

setObjectName(self, str)

setParent(self, QObject)

setProperty(self, str, Any) → bool

set_parent_tool(tool)

Used to organize tools automatically in menu items

setup_context_menu(menu, plot)

If the tool supports it, this method should install an action in the context menu

setup_toolbar(toolbar)

Setup tool’s toolbar

signalsBlocked(self) → bool

startTimer(self, int, timerType: Qt.TimerType = Qt.CoarseTimer) → int

thread(self) → QThread

timerEvent(self, QTimerEvent)

tr(self, str, disambiguation: str = None, n: int = - 1) → str

update_status(plot)

called by to allow derived classes to update the states of actions based on the currently active BasePlot

can also be called after an action modifying the BasePlot (e.g. in order to update action states when an item is deselected)

class guiqwt.tools.SelectTool(manager, toolbar_id=<class 'guiqwt.tools.DefaultToolbarID'>, title=None, icon=None, tip=None, switch_to_default_tool=None)

Graphical Object Selection Tool

activate()

Activate tool

blockSignals(self, bool) → bool

childEvent(self, QChildEvent)

children(self) → List[QObject]

connectNotify(self, QMetaMethod)

create_action(manager)

Create and return tool’s action

create_action_menu(manager)

Create and return menu for the tool’s action

cursor()

Return tool mouse cursor

customEvent(self, QEvent)

deactivate()

Deactivate tool

deleteLater(self)

disconnect(QMetaObject.Connection) → bool

disconnect(self) → None

disconnectNotify(self, QMetaMethod)

dumpObjectInfo(self)

dumpObjectTree(self)

dynamicPropertyNames(self) → List[QByteArray]

event(self, QEvent) → bool

eventFilter(self, QObject, QEvent) → bool

findChild(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChild(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChildren(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

inherits(self, str) → bool

installEventFilter(self, QObject)

isSignalConnected(self, QMetaMethod) → bool

isWidgetType(self) → bool

isWindowType(self) → bool

killTimer(self, int)

metaObject(self) → QMetaObject

moveToThread(self, QThread)

objectName(self) → str

parent(self) → QObject

property(self, str) → Any

pyqtConfigure(...)

Each keyword argument is either the name of a Qt property or a Qt signal. For properties the property is set to the given value which should be of an appropriate type. For signals the signal is connected to the given value which should be a callable.

receivers(self, PYQT_SIGNAL) → int

register_plot(baseplot)

Every BasePlot using this tool should call register_plot to notify the tool about this widget using it

removeEventFilter(self, QObject)

sender(self) → QObject

senderSignalIndex(self) → int

setObjectName(self, str)

setParent(self, QObject)

setProperty(self, str, Any) → bool

set_parent_tool(tool)

Used to organize tools automatically in menu items

setup_context_menu(menu, plot)

If the tool supports it, this method should install an action in the context menu

setup_toolbar(toolbar)

Setup tool’s toolbar

signalsBlocked(self) → bool

startTimer(self, int, timerType: Qt.TimerType = Qt.CoarseTimer) → int

thread(self) → QThread

timerEvent(self, QTimerEvent)

tr(self, str, disambiguation: str = None, n: int = - 1) → str

update_status(plot)

called by to allow derived classes to update the states of actions based on the currently active BasePlot

can also be called after an action modifying the BasePlot (e.g. in order to update action states when an item is deselected)

class guiqwt.tools.SelectPointTool(manager, mode='reuse', on_active_item=False, title=None, icon=None, tip=None, end_callback=None, toolbar_id=<class 'guiqwt.tools.DefaultToolbarID'>, marker_style=None, switch_to_default_tool=None)

activate()

Activate tool

blockSignals(self, bool) → bool

childEvent(self, QChildEvent)

children(self) → List[QObject]

connectNotify(self, QMetaMethod)

create_action(manager)

Create and return tool’s action

create_action_menu(manager)

Create and return menu for the tool’s action

cursor()

Return tool mouse cursor

customEvent(self, QEvent)

deactivate()

Deactivate tool

deleteLater(self)

disconnect(QMetaObject.Connection) → bool

disconnect(self) → None

disconnectNotify(self, QMetaMethod)

dumpObjectInfo(self)

dumpObjectTree(self)

dynamicPropertyNames(self) → List[QByteArray]

event(self, QEvent) → bool

eventFilter(self, QObject, QEvent) → bool

findChild(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChild(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChildren(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

inherits(self, str) → bool

installEventFilter(self, QObject)

isSignalConnected(self, QMetaMethod) → bool

isWidgetType(self) → bool

isWindowType(self) → bool

killTimer(self, int)

metaObject(self) → QMetaObject

moveToThread(self, QThread)

objectName(self) → str

parent(self) → QObject

property(self, str) → Any

pyqtConfigure(...)

Each keyword argument is either the name of a Qt property or a Qt signal. For properties the property is set to the given value which should be of an appropriate type. For signals the signal is connected to the given value which should be a callable.

receivers(self, PYQT_SIGNAL) → int

register_plot(baseplot)

Every BasePlot using this tool should call register_plot to notify the tool about this widget using it

removeEventFilter(self, QObject)

sender(self) → QObject

senderSignalIndex(self) → int

setObjectName(self, str)

setParent(self, QObject)

setProperty(self, str, Any) → bool

set_parent_tool(tool)

Used to organize tools automatically in menu items

setup_context_menu(menu, plot)

If the tool supports it, this method should install an action in the context menu

setup_toolbar(toolbar)

Setup tool’s toolbar

signalsBlocked(self) → bool

startTimer(self, int, timerType: Qt.TimerType = Qt.CoarseTimer) → int

thread(self) → QThread

timerEvent(self, QTimerEvent)

tr(self, str, disambiguation: str = None, n: int = - 1) → str

update_status(plot)

called by to allow derived classes to update the states of actions based on the currently active BasePlot

can also be called after an action modifying the BasePlot (e.g. in order to update action states when an item is deselected)

class guiqwt.tools.MultiLineTool(manager, handle_final_shape_cb=None, shape_style=None, toolbar_id=<class 'guiqwt.tools.DefaultToolbarID'>, title=None, icon=None, tip=None, switch_to_default_tool=None)

mouse_press(filter, event)

We create a new shape if it’s the first point otherwise we add a new point

move(filter, event)

moving while holding the button down lets the user position the last created point

mouse_release(filter, event)

Releasing the mouse button validate the last point position

activate()

Activate tool

blockSignals(self, bool) → bool

childEvent(self, QChildEvent)

children(self) → List[QObject]

connectNotify(self, QMetaMethod)

create_action(manager)

Create and return tool’s action

create_action_menu(manager)

Create and return menu for the tool’s action

cursor()

Return tool mouse cursor

customEvent(self, QEvent)

deactivate()

Deactivate tool

deleteLater(self)

disconnect(QMetaObject.Connection) → bool

disconnect(self) → None

disconnectNotify(self, QMetaMethod)

dumpObjectInfo(self)

dumpObjectTree(self)

dynamicPropertyNames(self) → List[QByteArray]

event(self, QEvent) → bool

eventFilter(self, QObject, QEvent) → bool

findChild(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChild(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChildren(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

inherits(self, str) → bool

installEventFilter(self, QObject)

isSignalConnected(self, QMetaMethod) → bool

isWidgetType(self) → bool

isWindowType(self) → bool

killTimer(self, int)

metaObject(self) → QMetaObject

moveToThread(self, QThread)

objectName(self) → str

parent(self) → QObject

property(self, str) → Any

pyqtConfigure(...)

Each keyword argument is either the name of a Qt property or a Qt signal. For properties the property is set to the given value which should be of an appropriate type. For signals the signal is connected to the given value which should be a callable.

receivers(self, PYQT_SIGNAL) → int

register_plot(baseplot)

Every BasePlot using this tool should call register_plot to notify the tool about this widget using it

removeEventFilter(self, QObject)

sender(self) → QObject

senderSignalIndex(self) → int

setObjectName(self, str)

setParent(self, QObject)

setProperty(self, str, Any) → bool

set_parent_tool(tool)

Used to organize tools automatically in menu items

setup_context_menu(menu, plot)

If the tool supports it, this method should install an action in the context menu

setup_toolbar(toolbar)

Setup tool’s toolbar

signalsBlocked(self) → bool

startTimer(self, int, timerType: Qt.TimerType = Qt.CoarseTimer) → int

thread(self) → QThread

timerEvent(self, QTimerEvent)

tr(self, str, disambiguation: str = None, n: int = - 1) → str

update_status(plot)

called by to allow derived classes to update the states of actions based on the currently active BasePlot

can also be called after an action modifying the BasePlot (e.g. in order to update action states when an item is deselected)

class guiqwt.tools.FreeFormTool(manager, handle_final_shape_cb=None, shape_style=None, toolbar_id=<class 'guiqwt.tools.DefaultToolbarID'>, title=None, icon=None, tip=None, switch_to_default_tool=None)

cancel_point(filter, event)

Reimplement base class method

mouse_press(filter, event)

Reimplement base class method

activate()

Activate tool

blockSignals(self, bool) → bool

childEvent(self, QChildEvent)

children(self) → List[QObject]

connectNotify(self, QMetaMethod)

create_action(manager)

Create and return tool’s action

create_action_menu(manager)

Create and return menu for the tool’s action

cursor()

Return tool mouse cursor

customEvent(self, QEvent)

deactivate()

Deactivate tool

deleteLater(self)

disconnect(QMetaObject.Connection) → bool

disconnect(self) → None

disconnectNotify(self, QMetaMethod)

dumpObjectInfo(self)

dumpObjectTree(self)

dynamicPropertyNames(self) → List[QByteArray]

event(self, QEvent) → bool

eventFilter(self, QObject, QEvent) → bool

findChild(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChild(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChildren(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

inherits(self, str) → bool

installEventFilter(self, QObject)

isSignalConnected(self, QMetaMethod) → bool

isWidgetType(self) → bool

isWindowType(self) → bool

killTimer(self, int)

metaObject(self) → QMetaObject

mouse_release(filter, event)

Releasing the mouse button validate the last point position

move(filter, event)

moving while holding the button down lets the user position the last created point

moveToThread(self, QThread)

objectName(self) → str

parent(self) → QObject

property(self, str) → Any

pyqtConfigure(...)

Each keyword argument is either the name of a Qt property or a Qt signal. For properties the property is set to the given value which should be of an appropriate type. For signals the signal is connected to the given value which should be a callable.

receivers(self, PYQT_SIGNAL) → int

register_plot(baseplot)

Every BasePlot using this tool should call register_plot to notify the tool about this widget using it

removeEventFilter(self, QObject)

sender(self) → QObject

senderSignalIndex(self) → int

setObjectName(self, str)

setParent(self, QObject)

setProperty(self, str, Any) → bool

set_parent_tool(tool)

Used to organize tools automatically in menu items

setup_context_menu(menu, plot)

If the tool supports it, this method should install an action in the context menu

setup_toolbar(toolbar)

Setup tool’s toolbar

signalsBlocked(self) → bool

startTimer(self, int, timerType: Qt.TimerType = Qt.CoarseTimer) → int

thread(self) → QThread

timerEvent(self, QTimerEvent)

tr(self, str, disambiguation: str = None, n: int = - 1) → str

update_status(plot)

called by to allow derived classes to update the states of actions based on the currently active BasePlot

can also be called after an action modifying the BasePlot (e.g. in order to update action states when an item is deselected)

class guiqwt.tools.LabelTool(manager, handle_label_cb=None, label_style=None, toolbar_id=<class 'guiqwt.tools.DefaultToolbarID'>, title=None, icon=None, tip=None, switch_to_default_tool=None)

activate()

Activate tool

blockSignals(self, bool) → bool

childEvent(self, QChildEvent)

children(self) → List[QObject]

connectNotify(self, QMetaMethod)

create_action(manager)

Create and return tool’s action

create_action_menu(manager)

Create and return menu for the tool’s action

cursor()

Return tool mouse cursor

customEvent(self, QEvent)

deactivate()

Deactivate tool

deleteLater(self)

disconnect(QMetaObject.Connection) → bool

disconnect(self) → None

disconnectNotify(self, QMetaMethod)

dumpObjectInfo(self)

dumpObjectTree(self)

dynamicPropertyNames(self) → List[QByteArray]

event(self, QEvent) → bool

eventFilter(self, QObject, QEvent) → bool

findChild(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChild(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChildren(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

inherits(self, str) → bool

installEventFilter(self, QObject)

isSignalConnected(self, QMetaMethod) → bool

isWidgetType(self) → bool

isWindowType(self) → bool

killTimer(self, int)

metaObject(self) → QMetaObject

moveToThread(self, QThread)

objectName(self) → str

parent(self) → QObject

property(self, str) → Any

pyqtConfigure(...)

Each keyword argument is either the name of a Qt property or a Qt signal. For properties the property is set to the given value which should be of an appropriate type. For signals the signal is connected to the given value which should be a callable.

receivers(self, PYQT_SIGNAL) → int

register_plot(baseplot)

Every BasePlot using this tool should call register_plot to notify the tool about this widget using it

removeEventFilter(self, QObject)

sender(self) → QObject

senderSignalIndex(self) → int

setObjectName(self, str)

setParent(self, QObject)

setProperty(self, str, Any) → bool

set_parent_tool(tool)

Used to organize tools automatically in menu items

setup_context_menu(menu, plot)

If the tool supports it, this method should install an action in the context menu

setup_toolbar(toolbar)

Setup tool’s toolbar

signalsBlocked(self) → bool

startTimer(self, int, timerType: Qt.TimerType = Qt.CoarseTimer) → int

thread(self) → QThread

timerEvent(self, QTimerEvent)

tr(self, str, disambiguation: str = None, n: int = - 1) → str

update_status(plot)

called by to allow derived classes to update the states of actions based on the currently active BasePlot

can also be called after an action modifying the BasePlot (e.g. in order to update action states when an item is deselected)

class guiqwt.tools.RectangleTool(manager, setup_shape_cb=None, handle_final_shape_cb=None, shape_style=None, toolbar_id=<class 'guiqwt.tools.DefaultToolbarID'>, title=None, icon=None, tip=None, switch_to_default_tool=None)

activate()

Activate tool

add_shape_to_plot(plot, p0, p1)

Method called when shape’s rectangular area has just been drawn on screen. Adding the final shape to plot and returning it.

blockSignals(self, bool) → bool

childEvent(self, QChildEvent)

children(self) → List[QObject]

connectNotify(self, QMetaMethod)

create_action(manager)

Create and return tool’s action

create_action_menu(manager)

Create and return menu for the tool’s action

cursor()

Return tool mouse cursor

customEvent(self, QEvent)

deactivate()

Deactivate tool

deleteLater(self)

disconnect(QMetaObject.Connection) → bool

disconnect(self) → None

disconnectNotify(self, QMetaMethod)

dumpObjectInfo(self)

dumpObjectTree(self)

dynamicPropertyNames(self) → List[QByteArray]

event(self, QEvent) → bool

eventFilter(self, QObject, QEvent) → bool

findChild(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChild(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChildren(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

get_shape()

Reimplemented RectangularActionTool method

handle_final_shape(shape)

To be reimplemented

inherits(self, str) → bool

installEventFilter(self, QObject)

isSignalConnected(self, QMetaMethod) → bool

isWidgetType(self) → bool

isWindowType(self) → bool

killTimer(self, int)

metaObject(self) → QMetaObject

moveToThread(self, QThread)

objectName(self) → str

parent(self) → QObject

property(self, str) → Any

pyqtConfigure(...)

Each keyword argument is either the name of a Qt property or a Qt signal. For properties the property is set to the given value which should be of an appropriate type. For signals the signal is connected to the given value which should be a callable.

receivers(self, PYQT_SIGNAL) → int

register_plot(baseplot)

Every BasePlot using this tool should call register_plot to notify the tool about this widget using it

removeEventFilter(self, QObject)

sender(self) → QObject

senderSignalIndex(self) → int

setObjectName(self, str)

setParent(self, QObject)

setProperty(self, str, Any) → bool

set_parent_tool(tool)

Used to organize tools automatically in menu items

setup_context_menu(menu, plot)

If the tool supports it, this method should install an action in the context menu

setup_shape(shape)

To be reimplemented

setup_toolbar(toolbar)

Setup tool’s toolbar

signalsBlocked(self) → bool

startTimer(self, int, timerType: Qt.TimerType = Qt.CoarseTimer) → int

thread(self) → QThread

timerEvent(self, QTimerEvent)

tr(self, str, disambiguation: str = None, n: int = - 1) → str

update_status(plot)

called by to allow derived classes to update the states of actions based on the currently active BasePlot

can also be called after an action modifying the BasePlot (e.g. in order to update action states when an item is deselected)

class guiqwt.tools.PointTool(manager, setup_shape_cb=None, handle_final_shape_cb=None, shape_style=None, toolbar_id=<class 'guiqwt.tools.DefaultToolbarID'>, title=None, icon=None, tip=None, switch_to_default_tool=None)

activate()

Activate tool

add_shape_to_plot(plot, p0, p1)

Method called when shape’s rectangular area has just been drawn on screen. Adding the final shape to plot and returning it.

blockSignals(self, bool) → bool

childEvent(self, QChildEvent)

children(self) → List[QObject]

connectNotify(self, QMetaMethod)

create_action(manager)

Create and return tool’s action

create_action_menu(manager)

Create and return menu for the tool’s action

cursor()

Return tool mouse cursor

customEvent(self, QEvent)

deactivate()

Deactivate tool

deleteLater(self)

disconnect(QMetaObject.Connection) → bool

disconnect(self) → None

disconnectNotify(self, QMetaMethod)

dumpObjectInfo(self)

dumpObjectTree(self)

dynamicPropertyNames(self) → List[QByteArray]

event(self, QEvent) → bool

eventFilter(self, QObject, QEvent) → bool

findChild(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChild(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChildren(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

get_shape()

Reimplemented RectangularActionTool method

handle_final_shape(shape)

To be reimplemented

inherits(self, str) → bool

installEventFilter(self, QObject)

isSignalConnected(self, QMetaMethod) → bool

isWidgetType(self) → bool

isWindowType(self) → bool

killTimer(self, int)

metaObject(self) → QMetaObject

moveToThread(self, QThread)

objectName(self) → str

parent(self) → QObject

property(self, str) → Any

pyqtConfigure(...)

Each keyword argument is either the name of a Qt property or a Qt signal. For properties the property is set to the given value which should be of an appropriate type. For signals the signal is connected to the given value which should be a callable.

receivers(self, PYQT_SIGNAL) → int

register_plot(baseplot)

Every BasePlot using this tool should call register_plot to notify the tool about this widget using it

removeEventFilter(self, QObject)

sender(self) → QObject

senderSignalIndex(self) → int

setObjectName(self, str)

setParent(self, QObject)

setProperty(self, str, Any) → bool

set_parent_tool(tool)

Used to organize tools automatically in menu items

setup_context_menu(menu, plot)

If the tool supports it, this method should install an action in the context menu

setup_shape(shape)

To be reimplemented

setup_toolbar(toolbar)

Setup tool’s toolbar

signalsBlocked(self) → bool

startTimer(self, int, timerType: Qt.TimerType = Qt.CoarseTimer) → int

thread(self) → QThread

timerEvent(self, QTimerEvent)

tr(self, str, disambiguation: str = None, n: int = - 1) → str

update_status(plot)

called by to allow derived classes to update the states of actions based on the currently active BasePlot

can also be called after an action modifying the BasePlot (e.g. in order to update action states when an item is deselected)

class guiqwt.tools.SegmentTool(manager, setup_shape_cb=None, handle_final_shape_cb=None, shape_style=None, toolbar_id=<class 'guiqwt.tools.DefaultToolbarID'>, title=None, icon=None, tip=None, switch_to_default_tool=None)

activate()

Activate tool

add_shape_to_plot(plot, p0, p1)

Method called when shape’s rectangular area has just been drawn on screen. Adding the final shape to plot and returning it.

blockSignals(self, bool) → bool

childEvent(self, QChildEvent)

children(self) → List[QObject]

connectNotify(self, QMetaMethod)

create_action(manager)

Create and return tool’s action

create_action_menu(manager)

Create and return menu for the tool’s action

cursor()

Return tool mouse cursor

customEvent(self, QEvent)

deactivate()

Deactivate tool

deleteLater(self)

disconnect(QMetaObject.Connection) → bool

disconnect(self) → None

disconnectNotify(self, QMetaMethod)

dumpObjectInfo(self)

dumpObjectTree(self)

dynamicPropertyNames(self) → List[QByteArray]

event(self, QEvent) → bool

eventFilter(self, QObject, QEvent) → bool

findChild(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChild(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChildren(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

get_shape()

Reimplemented RectangularActionTool method

handle_final_shape(shape)

To be reimplemented

inherits(self, str) → bool

installEventFilter(self, QObject)

isSignalConnected(self, QMetaMethod) → bool

isWidgetType(self) → bool

isWindowType(self) → bool

killTimer(self, int)

metaObject(self) → QMetaObject

moveToThread(self, QThread)

objectName(self) → str

parent(self) → QObject

property(self, str) → Any

pyqtConfigure(...)

Each keyword argument is either the name of a Qt property or a Qt signal. For properties the property is set to the given value which should be of an appropriate type. For signals the signal is connected to the given value which should be a callable.

receivers(self, PYQT_SIGNAL) → int

register_plot(baseplot)

Every BasePlot using this tool should call register_plot to notify the tool about this widget using it

removeEventFilter(self, QObject)

sender(self) → QObject

senderSignalIndex(self) → int

setObjectName(self, str)

setParent(self, QObject)

setProperty(self, str, Any) → bool

set_parent_tool(tool)

Used to organize tools automatically in menu items

setup_context_menu(menu, plot)

If the tool supports it, this method should install an action in the context menu

setup_shape(shape)

To be reimplemented

setup_toolbar(toolbar)

Setup tool’s toolbar

signalsBlocked(self) → bool

startTimer(self, int, timerType: Qt.TimerType = Qt.CoarseTimer) → int

thread(self) → QThread

timerEvent(self, QTimerEvent)

tr(self, str, disambiguation: str = None, n: int = - 1) → str

update_status(plot)

called by to allow derived classes to update the states of actions based on the currently active BasePlot

can also be called after an action modifying the BasePlot (e.g. in order to update action states when an item is deselected)

class guiqwt.tools.CircleTool(manager, setup_shape_cb=None, handle_final_shape_cb=None, shape_style=None, toolbar_id=<class 'guiqwt.tools.DefaultToolbarID'>, title=None, icon=None, tip=None, switch_to_default_tool=None)

activate()

Activate tool

add_shape_to_plot(plot, p0, p1)

Method called when shape’s rectangular area has just been drawn on screen. Adding the final shape to plot and returning it.

blockSignals(self, bool) → bool

childEvent(self, QChildEvent)

children(self) → List[QObject]

connectNotify(self, QMetaMethod)

create_action(manager)

Create and return tool’s action

create_action_menu(manager)

Create and return menu for the tool’s action

cursor()

Return tool mouse cursor

customEvent(self, QEvent)

deactivate()

Deactivate tool

deleteLater(self)

disconnect(QMetaObject.Connection) → bool

disconnect(self) → None

disconnectNotify(self, QMetaMethod)

dumpObjectInfo(self)

dumpObjectTree(self)

dynamicPropertyNames(self) → List[QByteArray]

event(self, QEvent) → bool

eventFilter(self, QObject, QEvent) → bool

findChild(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChild(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChildren(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

get_shape()

Reimplemented RectangularActionTool method

handle_final_shape(shape)

To be reimplemented

inherits(self, str) → bool

installEventFilter(self, QObject)

isSignalConnected(self, QMetaMethod) → bool

isWidgetType(self) → bool

isWindowType(self) → bool

killTimer(self, int)

metaObject(self) → QMetaObject

moveToThread(self, QThread)

objectName(self) → str

parent(self) → QObject

property(self, str) → Any

pyqtConfigure(...)

Each keyword argument is either the name of a Qt property or a Qt signal. For properties the property is set to the given value which should be of an appropriate type. For signals the signal is connected to the given value which should be a callable.

receivers(self, PYQT_SIGNAL) → int

register_plot(baseplot)

Every BasePlot using this tool should call register_plot to notify the tool about this widget using it

removeEventFilter(self, QObject)

sender(self) → QObject

senderSignalIndex(self) → int

setObjectName(self, str)

setParent(self, QObject)

setProperty(self, str, Any) → bool

set_parent_tool(tool)

Used to organize tools automatically in menu items

setup_context_menu(menu, plot)

If the tool supports it, this method should install an action in the context menu

setup_shape(shape)

To be reimplemented

setup_toolbar(toolbar)

Setup tool’s toolbar

signalsBlocked(self) → bool

startTimer(self, int, timerType: Qt.TimerType = Qt.CoarseTimer) → int

thread(self) → QThread

timerEvent(self, QTimerEvent)

tr(self, str, disambiguation: str = None, n: int = - 1) → str

update_status(plot)

called by to allow derived classes to update the states of actions based on the currently active BasePlot

can also be called after an action modifying the BasePlot (e.g. in order to update action states when an item is deselected)

class guiqwt.tools.EllipseTool(manager, setup_shape_cb=None, handle_final_shape_cb=None, shape_style=None, toolbar_id=<class 'guiqwt.tools.DefaultToolbarID'>, title=None, icon=None, tip=None, switch_to_default_tool=None)

handle_final_shape(shape)

To be reimplemented

activate()

Activate tool

add_shape_to_plot(plot, p0, p1)

Method called when shape’s rectangular area has just been drawn on screen. Adding the final shape to plot and returning it.

blockSignals(self, bool) → bool

childEvent(self, QChildEvent)

children(self) → List[QObject]

connectNotify(self, QMetaMethod)

create_action(manager)

Create and return tool’s action

create_action_menu(manager)

Create and return menu for the tool’s action

cursor()

Return tool mouse cursor

customEvent(self, QEvent)

deactivate()

Deactivate tool

deleteLater(self)

disconnect(QMetaObject.Connection) → bool

disconnect(self) → None

disconnectNotify(self, QMetaMethod)

dumpObjectInfo(self)

dumpObjectTree(self)

dynamicPropertyNames(self) → List[QByteArray]

event(self, QEvent) → bool

eventFilter(self, QObject, QEvent) → bool

findChild(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChild(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChildren(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

get_shape()

Reimplemented RectangularActionTool method

inherits(self, str) → bool

installEventFilter(self, QObject)

isSignalConnected(self, QMetaMethod) → bool

isWidgetType(self) → bool

isWindowType(self) → bool

killTimer(self, int)

metaObject(self) → QMetaObject

moveToThread(self, QThread)

objectName(self) → str

parent(self) → QObject

property(self, str) → Any

pyqtConfigure(...)

Each keyword argument is either the name of a Qt property or a Qt signal. For properties the property is set to the given value which should be of an appropriate type. For signals the signal is connected to the given value which should be a callable.

receivers(self, PYQT_SIGNAL) → int

register_plot(baseplot)

Every BasePlot using this tool should call register_plot to notify the tool about this widget using it

removeEventFilter(self, QObject)

sender(self) → QObject

senderSignalIndex(self) → int

setObjectName(self, str)

setParent(self, QObject)

setProperty(self, str, Any) → bool

set_parent_tool(tool)

Used to organize tools automatically in menu items

setup_context_menu(menu, plot)

If the tool supports it, this method should install an action in the context menu

setup_shape(shape)

To be reimplemented

setup_toolbar(toolbar)

Setup tool’s toolbar

signalsBlocked(self) → bool

startTimer(self, int, timerType: Qt.TimerType = Qt.CoarseTimer) → int

thread(self) → QThread

timerEvent(self, QTimerEvent)

tr(self, str, disambiguation: str = None, n: int = - 1) → str

update_status(plot)

called by to allow derived classes to update the states of actions based on the currently active BasePlot

can also be called after an action modifying the BasePlot (e.g. in order to update action states when an item is deselected)

class guiqwt.tools.PlaceAxesTool(manager, setup_shape_cb=None, handle_final_shape_cb=None, shape_style=None, toolbar_id=<class 'guiqwt.tools.DefaultToolbarID'>, title=None, icon=None, tip=None, switch_to_default_tool=None)

activate()

Activate tool

add_shape_to_plot(plot, p0, p1)

Method called when shape’s rectangular area has just been drawn on screen. Adding the final shape to plot and returning it.

blockSignals(self, bool) → bool

childEvent(self, QChildEvent)

children(self) → List[QObject]

connectNotify(self, QMetaMethod)

create_action(manager)

Create and return tool’s action

create_action_menu(manager)

Create and return menu for the tool’s action

cursor()

Return tool mouse cursor

customEvent(self, QEvent)

deactivate()

Deactivate tool

deleteLater(self)

disconnect(QMetaObject.Connection) → bool

disconnect(self) → None

disconnectNotify(self, QMetaMethod)

dumpObjectInfo(self)

dumpObjectTree(self)

dynamicPropertyNames(self) → List[QByteArray]

event(self, QEvent) → bool

eventFilter(self, QObject, QEvent) → bool

findChild(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChild(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChildren(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

get_shape()

Reimplemented RectangularActionTool method

handle_final_shape(shape)

To be reimplemented

inherits(self, str) → bool

installEventFilter(self, QObject)

isSignalConnected(self, QMetaMethod) → bool

isWidgetType(self) → bool

isWindowType(self) → bool

killTimer(self, int)

metaObject(self) → QMetaObject

moveToThread(self, QThread)

objectName(self) → str

parent(self) → QObject

property(self, str) → Any

pyqtConfigure(...)

Each keyword argument is either the name of a Qt property or a Qt signal. For properties the property is set to the given value which should be of an appropriate type. For signals the signal is connected to the given value which should be a callable.

receivers(self, PYQT_SIGNAL) → int

register_plot(baseplot)

Every BasePlot using this tool should call register_plot to notify the tool about this widget using it

removeEventFilter(self, QObject)

sender(self) → QObject

senderSignalIndex(self) → int

setObjectName(self, str)

setParent(self, QObject)

setProperty(self, str, Any) → bool

set_parent_tool(tool)

Used to organize tools automatically in menu items

setup_context_menu(menu, plot)

If the tool supports it, this method should install an action in the context menu

setup_shape(shape)

To be reimplemented

setup_toolbar(toolbar)

Setup tool’s toolbar

signalsBlocked(self) → bool

startTimer(self, int, timerType: Qt.TimerType = Qt.CoarseTimer) → int

thread(self) → QThread

timerEvent(self, QTimerEvent)

tr(self, str, disambiguation: str = None, n: int = - 1) → str

update_status(plot)

called by to allow derived classes to update the states of actions based on the currently active BasePlot

can also be called after an action modifying the BasePlot (e.g. in order to update action states when an item is deselected)

class guiqwt.tools.AnnotatedRectangleTool(manager, setup_shape_cb=None, handle_final_shape_cb=None, shape_style=None, toolbar_id=<class 'guiqwt.tools.DefaultToolbarID'>, title=None, icon=None, tip=None, switch_to_default_tool=None)

activate()

Activate tool

add_shape_to_plot(plot, p0, p1)

Method called when shape’s rectangular area has just been drawn on screen. Adding the final shape to plot and returning it.

blockSignals(self, bool) → bool

childEvent(self, QChildEvent)

children(self) → List[QObject]

connectNotify(self, QMetaMethod)

create_action(manager)

Create and return tool’s action

create_action_menu(manager)

Create and return menu for the tool’s action

cursor()

Return tool mouse cursor

customEvent(self, QEvent)

deactivate()

Deactivate tool

deleteLater(self)

disconnect(QMetaObject.Connection) → bool

disconnect(self) → None

disconnectNotify(self, QMetaMethod)

dumpObjectInfo(self)

dumpObjectTree(self)

dynamicPropertyNames(self) → List[QByteArray]

event(self, QEvent) → bool

eventFilter(self, QObject, QEvent) → bool

findChild(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChild(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChildren(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

get_shape()

Reimplemented RectangularActionTool method

handle_final_shape(shape)

To be reimplemented

inherits(self, str) → bool

installEventFilter(self, QObject)

isSignalConnected(self, QMetaMethod) → bool

isWidgetType(self) → bool

isWindowType(self) → bool

killTimer(self, int)

metaObject(self) → QMetaObject

moveToThread(self, QThread)

objectName(self) → str

parent(self) → QObject

property(self, str) → Any

pyqtConfigure(...)

Each keyword argument is either the name of a Qt property or a Qt signal. For properties the property is set to the given value which should be of an appropriate type. For signals the signal is connected to the given value which should be a callable.

receivers(self, PYQT_SIGNAL) → int

register_plot(baseplot)

Every BasePlot using this tool should call register_plot to notify the tool about this widget using it

removeEventFilter(self, QObject)

sender(self) → QObject

senderSignalIndex(self) → int

setObjectName(self, str)

setParent(self, QObject)

setProperty(self, str, Any) → bool

set_parent_tool(tool)

Used to organize tools automatically in menu items

setup_context_menu(menu, plot)

If the tool supports it, this method should install an action in the context menu

setup_shape(shape)

To be reimplemented

setup_toolbar(toolbar)

Setup tool’s toolbar

signalsBlocked(self) → bool

startTimer(self, int, timerType: Qt.TimerType = Qt.CoarseTimer) → int

thread(self) → QThread

timerEvent(self, QTimerEvent)

tr(self, str, disambiguation: str = None, n: int = - 1) → str

update_status(plot)

called by to allow derived classes to update the states of actions based on the currently active BasePlot

can also be called after an action modifying the BasePlot (e.g. in order to update action states when an item is deselected)

class guiqwt.tools.AnnotatedCircleTool(manager, setup_shape_cb=None, handle_final_shape_cb=None, shape_style=None, toolbar_id=<class 'guiqwt.tools.DefaultToolbarID'>, title=None, icon=None, tip=None, switch_to_default_tool=None)

activate()

Activate tool

add_shape_to_plot(plot, p0, p1)

Method called when shape’s rectangular area has just been drawn on screen. Adding the final shape to plot and returning it.

blockSignals(self, bool) → bool

childEvent(self, QChildEvent)

children(self) → List[QObject]

connectNotify(self, QMetaMethod)

create_action(manager)

Create and return tool’s action

create_action_menu(manager)

Create and return menu for the tool’s action

cursor()

Return tool mouse cursor

customEvent(self, QEvent)

deactivate()

Deactivate tool

deleteLater(self)

disconnect(QMetaObject.Connection) → bool

disconnect(self) → None

disconnectNotify(self, QMetaMethod)

dumpObjectInfo(self)

dumpObjectTree(self)

dynamicPropertyNames(self) → List[QByteArray]

event(self, QEvent) → bool

eventFilter(self, QObject, QEvent) → bool

findChild(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChild(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChildren(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

get_shape()

Reimplemented RectangularActionTool method

handle_final_shape(shape)

To be reimplemented

inherits(self, str) → bool

installEventFilter(self, QObject)

isSignalConnected(self, QMetaMethod) → bool

isWidgetType(self) → bool

isWindowType(self) → bool

killTimer(self, int)

metaObject(self) → QMetaObject

moveToThread(self, QThread)

objectName(self) → str

parent(self) → QObject

property(self, str) → Any

pyqtConfigure(...)

Each keyword argument is either the name of a Qt property or a Qt signal. For properties the property is set to the given value which should be of an appropriate type. For signals the signal is connected to the given value which should be a callable.

receivers(self, PYQT_SIGNAL) → int

register_plot(baseplot)

Every BasePlot using this tool should call register_plot to notify the tool about this widget using it

removeEventFilter(self, QObject)

sender(self) → QObject

senderSignalIndex(self) → int

setObjectName(self, str)

setParent(self, QObject)

setProperty(self, str, Any) → bool

set_parent_tool(tool)

Used to organize tools automatically in menu items

setup_context_menu(menu, plot)

If the tool supports it, this method should install an action in the context menu

setup_shape(shape)

To be reimplemented

setup_toolbar(toolbar)

Setup tool’s toolbar

signalsBlocked(self) → bool

startTimer(self, int, timerType: Qt.TimerType = Qt.CoarseTimer) → int

thread(self) → QThread

timerEvent(self, QTimerEvent)

tr(self, str, disambiguation: str = None, n: int = - 1) → str

update_status(plot)

called by to allow derived classes to update the states of actions based on the currently active BasePlot

can also be called after an action modifying the BasePlot (e.g. in order to update action states when an item is deselected)

class guiqwt.tools.AnnotatedEllipseTool(manager, setup_shape_cb=None, handle_final_shape_cb=None, shape_style=None, toolbar_id=<class 'guiqwt.tools.DefaultToolbarID'>, title=None, icon=None, tip=None, switch_to_default_tool=None)

handle_final_shape(shape)

To be reimplemented

activate()

Activate tool

add_shape_to_plot(plot, p0, p1)

Method called when shape’s rectangular area has just been drawn on screen. Adding the final shape to plot and returning it.

blockSignals(self, bool) → bool

childEvent(self, QChildEvent)

children(self) → List[QObject]

connectNotify(self, QMetaMethod)

create_action(manager)

Create and return tool’s action

create_action_menu(manager)

Create and return menu for the tool’s action

cursor()

Return tool mouse cursor

customEvent(self, QEvent)

deactivate()

Deactivate tool

deleteLater(self)

disconnect(QMetaObject.Connection) → bool

disconnect(self) → None

disconnectNotify(self, QMetaMethod)

dumpObjectInfo(self)

dumpObjectTree(self)

dynamicPropertyNames(self) → List[QByteArray]

event(self, QEvent) → bool

eventFilter(self, QObject, QEvent) → bool

findChild(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChild(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChildren(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

get_shape()

Reimplemented RectangularActionTool method

inherits(self, str) → bool

installEventFilter(self, QObject)

isSignalConnected(self, QMetaMethod) → bool

isWidgetType(self) → bool

isWindowType(self) → bool

killTimer(self, int)

metaObject(self) → QMetaObject

moveToThread(self, QThread)

objectName(self) → str

parent(self) → QObject

property(self, str) → Any

pyqtConfigure(...)

Each keyword argument is either the name of a Qt property or a Qt signal. For properties the property is set to the given value which should be of an appropriate type. For signals the signal is connected to the given value which should be a callable.

receivers(self, PYQT_SIGNAL) → int

register_plot(baseplot)

Every BasePlot using this tool should call register_plot to notify the tool about this widget using it

removeEventFilter(self, QObject)

sender(self) → QObject

senderSignalIndex(self) → int

setObjectName(self, str)

setParent(self, QObject)

setProperty(self, str, Any) → bool

set_parent_tool(tool)

Used to organize tools automatically in menu items

setup_context_menu(menu, plot)

If the tool supports it, this method should install an action in the context menu

setup_shape(shape)

To be reimplemented

setup_toolbar(toolbar)

Setup tool’s toolbar

signalsBlocked(self) → bool

startTimer(self, int, timerType: Qt.TimerType = Qt.CoarseTimer) → int

thread(self) → QThread

timerEvent(self, QTimerEvent)

tr(self, str, disambiguation: str = None, n: int = - 1) → str

update_status(plot)

called by to allow derived classes to update the states of actions based on the currently active BasePlot

can also be called after an action modifying the BasePlot (e.g. in order to update action states when an item is deselected)

class guiqwt.tools.AnnotatedPointTool(manager, setup_shape_cb=None, handle_final_shape_cb=None, shape_style=None, toolbar_id=<class 'guiqwt.tools.DefaultToolbarID'>, title=None, icon=None, tip=None, switch_to_default_tool=None)

activate()

Activate tool

add_shape_to_plot(plot, p0, p1)

Method called when shape’s rectangular area has just been drawn on screen. Adding the final shape to plot and returning it.

blockSignals(self, bool) → bool

childEvent(self, QChildEvent)

children(self) → List[QObject]

connectNotify(self, QMetaMethod)

create_action(manager)

Create and return tool’s action

create_action_menu(manager)

Create and return menu for the tool’s action

cursor()

Return tool mouse cursor

customEvent(self, QEvent)

deactivate()

Deactivate tool

deleteLater(self)

disconnect(QMetaObject.Connection) → bool

disconnect(self) → None

disconnectNotify(self, QMetaMethod)

dumpObjectInfo(self)

dumpObjectTree(self)

dynamicPropertyNames(self) → List[QByteArray]

event(self, QEvent) → bool

eventFilter(self, QObject, QEvent) → bool

findChild(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChild(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChildren(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

get_shape()

Reimplemented RectangularActionTool method

handle_final_shape(shape)

To be reimplemented

inherits(self, str) → bool

installEventFilter(self, QObject)

isSignalConnected(self, QMetaMethod) → bool

isWidgetType(self) → bool

isWindowType(self) → bool

killTimer(self, int)

metaObject(self) → QMetaObject

moveToThread(self, QThread)

objectName(self) → str

parent(self) → QObject

property(self, str) → Any

pyqtConfigure(...)

Each keyword argument is either the name of a Qt property or a Qt signal. For properties the property is set to the given value which should be of an appropriate type. For signals the signal is connected to the given value which should be a callable.

receivers(self, PYQT_SIGNAL) → int

register_plot(baseplot)

Every BasePlot using this tool should call register_plot to notify the tool about this widget using it

removeEventFilter(self, QObject)

sender(self) → QObject

senderSignalIndex(self) → int

setObjectName(self, str)

setParent(self, QObject)

setProperty(self, str, Any) → bool

set_parent_tool(tool)

Used to organize tools automatically in menu items

setup_context_menu(menu, plot)

If the tool supports it, this method should install an action in the context menu

setup_shape(shape)

To be reimplemented

setup_toolbar(toolbar)

Setup tool’s toolbar

signalsBlocked(self) → bool

startTimer(self, int, timerType: Qt.TimerType = Qt.CoarseTimer) → int

thread(self) → QThread

timerEvent(self, QTimerEvent)

tr(self, str, disambiguation: str = None, n: int = - 1) → str

update_status(plot)

called by to allow derived classes to update the states of actions based on the currently active BasePlot

can also be called after an action modifying the BasePlot (e.g. in order to update action states when an item is deselected)

class guiqwt.tools.AnnotatedSegmentTool(manager, setup_shape_cb=None, handle_final_shape_cb=None, shape_style=None, toolbar_id=<class 'guiqwt.tools.DefaultToolbarID'>, title=None, icon=None, tip=None, switch_to_default_tool=None)

activate()

Activate tool

add_shape_to_plot(plot, p0, p1)

Method called when shape’s rectangular area has just been drawn on screen. Adding the final shape to plot and returning it.

blockSignals(self, bool) → bool

childEvent(self, QChildEvent)

children(self) → List[QObject]

connectNotify(self, QMetaMethod)

create_action(manager)

Create and return tool’s action

create_action_menu(manager)

Create and return menu for the tool’s action

cursor()

Return tool mouse cursor

customEvent(self, QEvent)

deactivate()

Deactivate tool

deleteLater(self)

disconnect(QMetaObject.Connection) → bool

disconnect(self) → None

disconnectNotify(self, QMetaMethod)

dumpObjectInfo(self)

dumpObjectTree(self)

dynamicPropertyNames(self) → List[QByteArray]

event(self, QEvent) → bool

eventFilter(self, QObject, QEvent) → bool

findChild(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChild(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChildren(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

get_shape()

Reimplemented RectangularActionTool method

handle_final_shape(shape)

To be reimplemented

inherits(self, str) → bool

installEventFilter(self, QObject)

isSignalConnected(self, QMetaMethod) → bool

isWidgetType(self) → bool

isWindowType(self) → bool

killTimer(self, int)

metaObject(self) → QMetaObject

moveToThread(self, QThread)

objectName(self) → str

parent(self) → QObject

property(self, str) → Any

pyqtConfigure(...)

Each keyword argument is either the name of a Qt property or a Qt signal. For properties the property is set to the given value which should be of an appropriate type. For signals the signal is connected to the given value which should be a callable.

receivers(self, PYQT_SIGNAL) → int

register_plot(baseplot)

Every BasePlot using this tool should call register_plot to notify the tool about this widget using it

removeEventFilter(self, QObject)

sender(self) → QObject

senderSignalIndex(self) → int

setObjectName(self, str)

setParent(self, QObject)

setProperty(self, str, Any) → bool

set_parent_tool(tool)

Used to organize tools automatically in menu items

setup_context_menu(menu, plot)

If the tool supports it, this method should install an action in the context menu

setup_shape(shape)

To be reimplemented

setup_toolbar(toolbar)

Setup tool’s toolbar

signalsBlocked(self) → bool

startTimer(self, int, timerType: Qt.TimerType = Qt.CoarseTimer) → int

thread(self) → QThread

timerEvent(self, QTimerEvent)

tr(self, str, disambiguation: str = None, n: int = - 1) → str

update_status(plot)

called by to allow derived classes to update the states of actions based on the currently active BasePlot

can also be called after an action modifying the BasePlot (e.g. in order to update action states when an item is deselected)

class guiqwt.tools.HRangeTool(manager, toolbar_id=<class 'guiqwt.tools.DefaultToolbarID'>, title=None, icon=None, tip=None, switch_to_default_tool=None)

create_shape()

Create and return the cursor/range shape

activate()

Activate tool

blockSignals(self, bool) → bool

childEvent(self, QChildEvent)

children(self) → List[QObject]

connectNotify(self, QMetaMethod)

create_action(manager)

Create and return tool’s action

create_action_menu(manager)

Create and return menu for the tool’s action

cursor()

Return tool mouse cursor

customEvent(self, QEvent)

deactivate()

Deactivate tool

deleteLater(self)

disconnect(QMetaObject.Connection) → bool

disconnect(self) → None

disconnectNotify(self, QMetaMethod)

dumpObjectInfo(self)

dumpObjectTree(self)

dynamicPropertyNames(self) → List[QByteArray]

event(self, QEvent) → bool

eventFilter(self, QObject, QEvent) → bool

findChild(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChild(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChildren(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

inherits(self, str) → bool

installEventFilter(self, QObject)

isSignalConnected(self, QMetaMethod) → bool

isWidgetType(self) → bool

isWindowType(self) → bool

killTimer(self, int)

metaObject(self) → QMetaObject

moveToThread(self, QThread)

objectName(self) → str

parent(self) → QObject

property(self, str) → Any

pyqtConfigure(...)

Each keyword argument is either the name of a Qt property or a Qt signal. For properties the property is set to the given value which should be of an appropriate type. For signals the signal is connected to the given value which should be a callable.

receivers(self, PYQT_SIGNAL) → int

register_plot(baseplot)

Every BasePlot using this tool should call register_plot to notify the tool about this widget using it

removeEventFilter(self, QObject)

sender(self) → QObject

senderSignalIndex(self) → int

setObjectName(self, str)

setParent(self, QObject)

setProperty(self, str, Any) → bool

set_parent_tool(tool)

Used to organize tools automatically in menu items

setup_context_menu(menu, plot)

If the tool supports it, this method should install an action in the context menu

setup_toolbar(toolbar)

Setup tool’s toolbar

signalsBlocked(self) → bool

startTimer(self, int, timerType: Qt.TimerType = Qt.CoarseTimer) → int

thread(self) → QThread

timerEvent(self, QTimerEvent)

tr(self, str, disambiguation: str = None, n: int = - 1) → str

update_status(plot)

called by to allow derived classes to update the states of actions based on the currently active BasePlot

can also be called after an action modifying the BasePlot (e.g. in order to update action states when an item is deselected)

class guiqwt.tools.DummySeparatorTool(manager, toolbar_id=<class 'guiqwt.tools.DefaultToolbarID'>)

setup_toolbar(toolbar)

Setup tool’s toolbar

setup_context_menu(menu, plot)

If the tool supports it, this method should install an action in the context menu

blockSignals(self, bool) → bool

childEvent(self, QChildEvent)

children(self) → List[QObject]

connectNotify(self, QMetaMethod)

create_action(manager)

Create and return tool’s action

create_action_menu(manager)

Create and return menu for the tool’s action

customEvent(self, QEvent)

deleteLater(self)

disconnect(QMetaObject.Connection) → bool

disconnect(self) → None

disconnectNotify(self, QMetaMethod)

dumpObjectInfo(self)

dumpObjectTree(self)

dynamicPropertyNames(self) → List[QByteArray]

event(self, QEvent) → bool

eventFilter(self, QObject, QEvent) → bool

findChild(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChild(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChildren(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

inherits(self, str) → bool

installEventFilter(self, QObject)

isSignalConnected(self, QMetaMethod) → bool

isWidgetType(self) → bool

isWindowType(self) → bool

killTimer(self, int)

metaObject(self) → QMetaObject

moveToThread(self, QThread)

objectName(self) → str

parent(self) → QObject

property(self, str) → Any

pyqtConfigure(...)

Each keyword argument is either the name of a Qt property or a Qt signal. For properties the property is set to the given value which should be of an appropriate type. For signals the signal is connected to the given value which should be a callable.

receivers(self, PYQT_SIGNAL) → int

register_plot(baseplot)

Every BasePlot using this tool should call register_plot to notify the tool about this widget using it

removeEventFilter(self, QObject)

sender(self) → QObject

senderSignalIndex(self) → int

setObjectName(self, str)

setParent(self, QObject)

setProperty(self, str, Any) → bool

set_parent_tool(tool)

Used to organize tools automatically in menu items

signalsBlocked(self) → bool

startTimer(self, int, timerType: Qt.TimerType = Qt.CoarseTimer) → int

thread(self) → QThread

timerEvent(self, QTimerEvent)

tr(self, str, disambiguation: str = None, n: int = - 1) → str

update_status(plot)

called by to allow derived classes to update the states of actions based on the currently active BasePlot

can also be called after an action modifying the BasePlot (e.g. in order to update action states when an item is deselected)

class guiqwt.tools.AntiAliasingTool(manager)

activate_command(plot, checked)

Activate tool

update_status(plot)

called by to allow derived classes to update the states of actions based on the currently active BasePlot

can also be called after an action modifying the BasePlot (e.g. in order to update action states when an item is deselected)

blockSignals(self, bool) → bool

childEvent(self, QChildEvent)

children(self) → List[QObject]

connectNotify(self, QMetaMethod)

create_action(manager)

Create and return tool’s action

create_action_menu(manager)

Create and return menu for the tool’s action

customEvent(self, QEvent)

deleteLater(self)

disconnect(QMetaObject.Connection) → bool

disconnect(self) → None

disconnectNotify(self, QMetaMethod)

dumpObjectInfo(self)

dumpObjectTree(self)

dynamicPropertyNames(self) → List[QByteArray]

event(self, QEvent) → bool

eventFilter(self, QObject, QEvent) → bool

findChild(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChild(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChildren(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

inherits(self, str) → bool

installEventFilter(self, QObject)

isSignalConnected(self, QMetaMethod) → bool

isWidgetType(self) → bool

isWindowType(self) → bool

killTimer(self, int)

metaObject(self) → QMetaObject

moveToThread(self, QThread)

objectName(self) → str

parent(self) → QObject

property(self, str) → Any

pyqtConfigure(...)

Each keyword argument is either the name of a Qt property or a Qt signal. For properties the property is set to the given value which should be of an appropriate type. For signals the signal is connected to the given value which should be a callable.

receivers(self, PYQT_SIGNAL) → int

register_plot(baseplot)

Every BasePlot using this tool should call register_plot to notify the tool about this widget using it

removeEventFilter(self, QObject)

sender(self) → QObject

senderSignalIndex(self) → int

setObjectName(self, str)

setParent(self, QObject)

setProperty(self, str, Any) → bool

set_parent_tool(tool)

Used to organize tools automatically in menu items

setup_context_menu(menu, plot)

If the tool supports it, this method should install an action in the context menu

setup_toolbar(toolbar)

Setup tool’s toolbar

signalsBlocked(self) → bool

startTimer(self, int, timerType: Qt.TimerType = Qt.CoarseTimer) → int

thread(self) → QThread

timerEvent(self, QTimerEvent)

tr(self, str, disambiguation: str = None, n: int = - 1) → str

class guiqwt.tools.DisplayCoordsTool(manager)

create_action_menu(manager)

Create and return menu for the tool’s action

update_status(plot)

called by to allow derived classes to update the states of actions based on the currently active BasePlot

can also be called after an action modifying the BasePlot (e.g. in order to update action states when an item is deselected)

blockSignals(self, bool) → bool

childEvent(self, QChildEvent)

children(self) → List[QObject]

connectNotify(self, QMetaMethod)

create_action(manager)

Create and return tool’s action

customEvent(self, QEvent)

deleteLater(self)

disconnect(QMetaObject.Connection) → bool

disconnect(self) → None

disconnectNotify(self, QMetaMethod)

dumpObjectInfo(self)

dumpObjectTree(self)

dynamicPropertyNames(self) → List[QByteArray]

event(self, QEvent) → bool

eventFilter(self, QObject, QEvent) → bool

findChild(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChild(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChildren(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

inherits(self, str) → bool

installEventFilter(self, QObject)

isSignalConnected(self, QMetaMethod) → bool

isWidgetType(self) → bool

isWindowType(self) → bool

killTimer(self, int)

metaObject(self) → QMetaObject

moveToThread(self, QThread)

objectName(self) → str

parent(self) → QObject

property(self, str) → Any

pyqtConfigure(...)

Each keyword argument is either the name of a Qt property or a Qt signal. For properties the property is set to the given value which should be of an appropriate type. For signals the signal is connected to the given value which should be a callable.

receivers(self, PYQT_SIGNAL) → int

register_plot(baseplot)

Every BasePlot using this tool should call register_plot to notify the tool about this widget using it

removeEventFilter(self, QObject)

sender(self) → QObject

senderSignalIndex(self) → int

setObjectName(self, str)

setParent(self, QObject)

setProperty(self, str, Any) → bool

set_parent_tool(tool)

Used to organize tools automatically in menu items

setup_context_menu(menu, plot)

If the tool supports it, this method should install an action in the context menu

setup_toolbar(toolbar)

Setup tool’s toolbar

signalsBlocked(self) → bool

startTimer(self, int, timerType: Qt.TimerType = Qt.CoarseTimer) → int

thread(self) → QThread

timerEvent(self, QTimerEvent)

tr(self, str, disambiguation: str = None, n: int = - 1) → str

class guiqwt.tools.ReverseYAxisTool(manager)

activate_command(plot, checked)

Activate tool

update_status(plot)

called by to allow derived classes to update the states of actions based on the currently active BasePlot

can also be called after an action modifying the BasePlot (e.g. in order to update action states when an item is deselected)

blockSignals(self, bool) → bool

childEvent(self, QChildEvent)

children(self) → List[QObject]

connectNotify(self, QMetaMethod)

create_action(manager)

Create and return tool’s action

create_action_menu(manager)

Create and return menu for the tool’s action

customEvent(self, QEvent)

deleteLater(self)

disconnect(QMetaObject.Connection) → bool

disconnect(self) → None

disconnectNotify(self, QMetaMethod)

dumpObjectInfo(self)

dumpObjectTree(self)

dynamicPropertyNames(self) → List[QByteArray]

event(self, QEvent) → bool

eventFilter(self, QObject, QEvent) → bool

findChild(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChild(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChildren(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

inherits(self, str) → bool

installEventFilter(self, QObject)

isSignalConnected(self, QMetaMethod) → bool

isWidgetType(self) → bool

isWindowType(self) → bool

killTimer(self, int)

metaObject(self) → QMetaObject

moveToThread(self, QThread)

objectName(self) → str

parent(self) → QObject

property(self, str) → Any

pyqtConfigure(...)

Each keyword argument is either the name of a Qt property or a Qt signal. For properties the property is set to the given value which should be of an appropriate type. For signals the signal is connected to the given value which should be a callable.

receivers(self, PYQT_SIGNAL) → int

register_plot(baseplot)

Every BasePlot using this tool should call register_plot to notify the tool about this widget using it

removeEventFilter(self, QObject)

sender(self) → QObject

senderSignalIndex(self) → int

setObjectName(self, str)

setParent(self, QObject)

setProperty(self, str, Any) → bool

set_parent_tool(tool)

Used to organize tools automatically in menu items

setup_context_menu(menu, plot)

If the tool supports it, this method should install an action in the context menu

setup_toolbar(toolbar)

Setup tool’s toolbar

signalsBlocked(self) → bool

startTimer(self, int, timerType: Qt.TimerType = Qt.CoarseTimer) → int

thread(self) → QThread

timerEvent(self, QTimerEvent)

tr(self, str, disambiguation: str = None, n: int = - 1) → str

class guiqwt.tools.AspectRatioTool(manager)

create_action_menu(manager)

Create and return menu for the tool’s action

activate_command(plot, checked)

Activate tool

lock_aspect_ratio(checked)

Lock aspect ratio

update_status(plot)

called by to allow derived classes to update the states of actions based on the currently active BasePlot

can also be called after an action modifying the BasePlot (e.g. in order to update action states when an item is deselected)

blockSignals(self, bool) → bool

childEvent(self, QChildEvent)

children(self) → List[QObject]

connectNotify(self, QMetaMethod)

create_action(manager)

Create and return tool’s action

customEvent(self, QEvent)

deleteLater(self)

disconnect(QMetaObject.Connection) → bool

disconnect(self) → None

disconnectNotify(self, QMetaMethod)

dumpObjectInfo(self)

dumpObjectTree(self)

dynamicPropertyNames(self) → List[QByteArray]

event(self, QEvent) → bool

eventFilter(self, QObject, QEvent) → bool

findChild(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChild(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChildren(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

inherits(self, str) → bool

installEventFilter(self, QObject)

isSignalConnected(self, QMetaMethod) → bool

isWidgetType(self) → bool

isWindowType(self) → bool

killTimer(self, int)

metaObject(self) → QMetaObject

moveToThread(self, QThread)

objectName(self) → str

parent(self) → QObject

property(self, str) → Any

pyqtConfigure(...)

Each keyword argument is either the name of a Qt property or a Qt signal. For properties the property is set to the given value which should be of an appropriate type. For signals the signal is connected to the given value which should be a callable.

receivers(self, PYQT_SIGNAL) → int

register_plot(baseplot)

Every BasePlot using this tool should call register_plot to notify the tool about this widget using it

removeEventFilter(self, QObject)

sender(self) → QObject

senderSignalIndex(self) → int

setObjectName(self, str)

setParent(self, QObject)

setProperty(self, str, Any) → bool

set_parent_tool(tool)

Used to organize tools automatically in menu items

setup_context_menu(menu, plot)

If the tool supports it, this method should install an action in the context menu

setup_toolbar(toolbar)

Setup tool’s toolbar

signalsBlocked(self) → bool

startTimer(self, int, timerType: Qt.TimerType = Qt.CoarseTimer) → int

thread(self) → QThread

timerEvent(self, QTimerEvent)

tr(self, str, disambiguation: str = None, n: int = - 1) → str

class guiqwt.tools.PanelTool(manager)

activate_command(plot, checked)

Activate tool

update_status(plot)

called by to allow derived classes to update the states of actions based on the currently active BasePlot

can also be called after an action modifying the BasePlot (e.g. in order to update action states when an item is deselected)

blockSignals(self, bool) → bool

childEvent(self, QChildEvent)

children(self) → List[QObject]

connectNotify(self, QMetaMethod)

create_action(manager)

Create and return tool’s action

create_action_menu(manager)

Create and return menu for the tool’s action

customEvent(self, QEvent)

deleteLater(self)

disconnect(QMetaObject.Connection) → bool

disconnect(self) → None

disconnectNotify(self, QMetaMethod)

dumpObjectInfo(self)

dumpObjectTree(self)

dynamicPropertyNames(self) → List[QByteArray]

event(self, QEvent) → bool

eventFilter(self, QObject, QEvent) → bool

findChild(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChild(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChildren(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

inherits(self, str) → bool

installEventFilter(self, QObject)

isSignalConnected(self, QMetaMethod) → bool

isWidgetType(self) → bool

isWindowType(self) → bool

killTimer(self, int)

metaObject(self) → QMetaObject

moveToThread(self, QThread)

objectName(self) → str

parent(self) → QObject

property(self, str) → Any

pyqtConfigure(...)

Each keyword argument is either the name of a Qt property or a Qt signal. For properties the property is set to the given value which should be of an appropriate type. For signals the signal is connected to the given value which should be a callable.

receivers(self, PYQT_SIGNAL) → int

register_plot(baseplot)

Every BasePlot using this tool should call register_plot to notify the tool about this widget using it

removeEventFilter(self, QObject)

sender(self) → QObject

senderSignalIndex(self) → int

setObjectName(self, str)

setParent(self, QObject)

setProperty(self, str, Any) → bool

set_parent_tool(tool)

Used to organize tools automatically in menu items

setup_context_menu(menu, plot)

If the tool supports it, this method should install an action in the context menu

setup_toolbar(toolbar)

Setup tool’s toolbar

signalsBlocked(self) → bool

startTimer(self, int, timerType: Qt.TimerType = Qt.CoarseTimer) → int

thread(self) → QThread

timerEvent(self, QTimerEvent)

tr(self, str, disambiguation: str = None, n: int = - 1) → str

class guiqwt.tools.ItemListPanelTool(manager)

activate_command(plot, checked)

Activate tool

blockSignals(self, bool) → bool

childEvent(self, QChildEvent)

children(self) → List[QObject]

connectNotify(self, QMetaMethod)

create_action(manager)

Create and return tool’s action

create_action_menu(manager)

Create and return menu for the tool’s action

customEvent(self, QEvent)

deleteLater(self)

disconnect(QMetaObject.Connection) → bool

disconnect(self) → None

disconnectNotify(self, QMetaMethod)

dumpObjectInfo(self)

dumpObjectTree(self)

dynamicPropertyNames(self) → List[QByteArray]

event(self, QEvent) → bool

eventFilter(self, QObject, QEvent) → bool

findChild(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChild(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChildren(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

inherits(self, str) → bool

installEventFilter(self, QObject)

isSignalConnected(self, QMetaMethod) → bool

isWidgetType(self) → bool

isWindowType(self) → bool

killTimer(self, int)

metaObject(self) → QMetaObject

moveToThread(self, QThread)

objectName(self) → str

parent(self) → QObject

property(self, str) → Any

pyqtConfigure(...)

Each keyword argument is either the name of a Qt property or a Qt signal. For properties the property is set to the given value which should be of an appropriate type. For signals the signal is connected to the given value which should be a callable.

receivers(self, PYQT_SIGNAL) → int

register_plot(baseplot)

Every BasePlot using this tool should call register_plot to notify the tool about this widget using it

removeEventFilter(self, QObject)

sender(self) → QObject

senderSignalIndex(self) → int

setObjectName(self, str)

setParent(self, QObject)

setProperty(self, str, Any) → bool

set_parent_tool(tool)

Used to organize tools automatically in menu items

setup_context_menu(menu, plot)

If the tool supports it, this method should install an action in the context menu

setup_toolbar(toolbar)

Setup tool’s toolbar

signalsBlocked(self) → bool

startTimer(self, int, timerType: Qt.TimerType = Qt.CoarseTimer) → int

thread(self) → QThread

timerEvent(self, QTimerEvent)

tr(self, str, disambiguation: str = None, n: int = - 1) → str

update_status(plot)

called by to allow derived classes to update the states of actions based on the currently active BasePlot

can also be called after an action modifying the BasePlot (e.g. in order to update action states when an item is deselected)

class guiqwt.tools.ContrastPanelTool(manager)

update_status(plot)

called by to allow derived classes to update the states of actions based on the currently active BasePlot

can also be called after an action modifying the BasePlot (e.g. in order to update action states when an item is deselected)

activate_command(plot, checked)

Activate tool

blockSignals(self, bool) → bool

childEvent(self, QChildEvent)

children(self) → List[QObject]

connectNotify(self, QMetaMethod)

create_action(manager)

Create and return tool’s action

create_action_menu(manager)

Create and return menu for the tool’s action

customEvent(self, QEvent)

deleteLater(self)

disconnect(QMetaObject.Connection) → bool

disconnect(self) → None

disconnectNotify(self, QMetaMethod)

dumpObjectInfo(self)

dumpObjectTree(self)

dynamicPropertyNames(self) → List[QByteArray]

event(self, QEvent) → bool

eventFilter(self, QObject, QEvent) → bool

findChild(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChild(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChildren(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

inherits(self, str) → bool

installEventFilter(self, QObject)

isSignalConnected(self, QMetaMethod) → bool

isWidgetType(self) → bool

isWindowType(self) → bool

killTimer(self, int)

metaObject(self) → QMetaObject

moveToThread(self, QThread)

objectName(self) → str

parent(self) → QObject

property(self, str) → Any

pyqtConfigure(...)

Each keyword argument is either the name of a Qt property or a Qt signal. For properties the property is set to the given value which should be of an appropriate type. For signals the signal is connected to the given value which should be a callable.

receivers(self, PYQT_SIGNAL) → int

register_plot(baseplot)

Every BasePlot using this tool should call register_plot to notify the tool about this widget using it

removeEventFilter(self, QObject)

sender(self) → QObject

senderSignalIndex(self) → int

setObjectName(self, str)

setParent(self, QObject)

setProperty(self, str, Any) → bool

set_parent_tool(tool)

Used to organize tools automatically in menu items

setup_context_menu(menu, plot)

If the tool supports it, this method should install an action in the context menu

setup_toolbar(toolbar)

Setup tool’s toolbar

signalsBlocked(self) → bool

startTimer(self, int, timerType: Qt.TimerType = Qt.CoarseTimer) → int

thread(self) → QThread

timerEvent(self, QTimerEvent)

tr(self, str, disambiguation: str = None, n: int = - 1) → str

class guiqwt.tools.ColormapTool(manager, toolbar_id=<class 'guiqwt.tools.DefaultToolbarID'>)

create_action_menu(manager)

Create and return menu for the tool’s action

activate_command(plot, checked)

Activate tool

update_status(plot)

called by to allow derived classes to update the states of actions based on the currently active BasePlot

can also be called after an action modifying the BasePlot (e.g. in order to update action states when an item is deselected)

blockSignals(self, bool) → bool

childEvent(self, QChildEvent)

children(self) → List[QObject]

connectNotify(self, QMetaMethod)

create_action(manager)

Create and return tool’s action

customEvent(self, QEvent)

deleteLater(self)

disconnect(QMetaObject.Connection) → bool

disconnect(self) → None

disconnectNotify(self, QMetaMethod)

dumpObjectInfo(self)

dumpObjectTree(self)

dynamicPropertyNames(self) → List[QByteArray]

event(self, QEvent) → bool

eventFilter(self, QObject, QEvent) → bool

findChild(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChild(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChildren(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

inherits(self, str) → bool

installEventFilter(self, QObject)

isSignalConnected(self, QMetaMethod) → bool

isWidgetType(self) → bool

isWindowType(self) → bool

killTimer(self, int)

metaObject(self) → QMetaObject

moveToThread(self, QThread)

objectName(self) → str

parent(self) → QObject

property(self, str) → Any

pyqtConfigure(...)

Each keyword argument is either the name of a Qt property or a Qt signal. For properties the property is set to the given value which should be of an appropriate type. For signals the signal is connected to the given value which should be a callable.

receivers(self, PYQT_SIGNAL) → int

register_plot(baseplot)

Every BasePlot using this tool should call register_plot to notify the tool about this widget using it

removeEventFilter(self, QObject)

sender(self) → QObject

senderSignalIndex(self) → int

setObjectName(self, str)

setParent(self, QObject)

setProperty(self, str, Any) → bool

set_parent_tool(tool)

Used to organize tools automatically in menu items

setup_context_menu(menu, plot)

If the tool supports it, this method should install an action in the context menu

setup_toolbar(toolbar)

Setup tool’s toolbar

signalsBlocked(self) → bool

startTimer(self, int, timerType: Qt.TimerType = Qt.CoarseTimer) → int

thread(self) → QThread

timerEvent(self, QTimerEvent)

tr(self, str, disambiguation: str = None, n: int = - 1) → str

class guiqwt.tools.XCSPanelTool(manager)

activate_command(plot, checked)

Activate tool

blockSignals(self, bool) → bool

childEvent(self, QChildEvent)

children(self) → List[QObject]

connectNotify(self, QMetaMethod)

create_action(manager)

Create and return tool’s action

create_action_menu(manager)

Create and return menu for the tool’s action

customEvent(self, QEvent)

deleteLater(self)

disconnect(QMetaObject.Connection) → bool

disconnect(self) → None

disconnectNotify(self, QMetaMethod)

dumpObjectInfo(self)

dumpObjectTree(self)

dynamicPropertyNames(self) → List[QByteArray]

event(self, QEvent) → bool

eventFilter(self, QObject, QEvent) → bool

findChild(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChild(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChildren(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

inherits(self, str) → bool

installEventFilter(self, QObject)

isSignalConnected(self, QMetaMethod) → bool

isWidgetType(self) → bool

isWindowType(self) → bool

killTimer(self, int)

metaObject(self) → QMetaObject

moveToThread(self, QThread)

objectName(self) → str

parent(self) → QObject

property(self, str) → Any

pyqtConfigure(...)

Each keyword argument is either the name of a Qt property or a Qt signal. For properties the property is set to the given value which should be of an appropriate type. For signals the signal is connected to the given value which should be a callable.

receivers(self, PYQT_SIGNAL) → int

register_plot(baseplot)

Every BasePlot using this tool should call register_plot to notify the tool about this widget using it

removeEventFilter(self, QObject)

sender(self) → QObject

senderSignalIndex(self) → int

setObjectName(self, str)

setParent(self, QObject)

setProperty(self, str, Any) → bool

set_parent_tool(tool)

Used to organize tools automatically in menu items

setup_context_menu(menu, plot)

If the tool supports it, this method should install an action in the context menu

setup_toolbar(toolbar)

Setup tool’s toolbar

signalsBlocked(self) → bool

startTimer(self, int, timerType: Qt.TimerType = Qt.CoarseTimer) → int

thread(self) → QThread

timerEvent(self, QTimerEvent)

tr(self, str, disambiguation: str = None, n: int = - 1) → str

update_status(plot)

called by to allow derived classes to update the states of actions based on the currently active BasePlot

can also be called after an action modifying the BasePlot (e.g. in order to update action states when an item is deselected)

class guiqwt.tools.YCSPanelTool(manager)

activate_command(plot, checked)

Activate tool

blockSignals(self, bool) → bool

childEvent(self, QChildEvent)

children(self) → List[QObject]

connectNotify(self, QMetaMethod)

create_action(manager)

Create and return tool’s action

create_action_menu(manager)

Create and return menu for the tool’s action

customEvent(self, QEvent)

deleteLater(self)

disconnect(QMetaObject.Connection) → bool

disconnect(self) → None

disconnectNotify(self, QMetaMethod)

dumpObjectInfo(self)

dumpObjectTree(self)

dynamicPropertyNames(self) → List[QByteArray]

event(self, QEvent) → bool

eventFilter(self, QObject, QEvent) → bool

findChild(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChild(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChildren(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

inherits(self, str) → bool

installEventFilter(self, QObject)

isSignalConnected(self, QMetaMethod) → bool

isWidgetType(self) → bool

isWindowType(self) → bool

killTimer(self, int)

metaObject(self) → QMetaObject

moveToThread(self, QThread)

objectName(self) → str

parent(self) → QObject

property(self, str) → Any

pyqtConfigure(...)

Each keyword argument is either the name of a Qt property or a Qt signal. For properties the property is set to the given value which should be of an appropriate type. For signals the signal is connected to the given value which should be a callable.

receivers(self, PYQT_SIGNAL) → int

register_plot(baseplot)

Every BasePlot using this tool should call register_plot to notify the tool about this widget using it

removeEventFilter(self, QObject)

sender(self) → QObject

senderSignalIndex(self) → int

setObjectName(self, str)

setParent(self, QObject)

setProperty(self, str, Any) → bool

set_parent_tool(tool)

Used to organize tools automatically in menu items

setup_context_menu(menu, plot)

If the tool supports it, this method should install an action in the context menu

setup_toolbar(toolbar)

Setup tool’s toolbar

signalsBlocked(self) → bool

startTimer(self, int, timerType: Qt.TimerType = Qt.CoarseTimer) → int

thread(self) → QThread

timerEvent(self, QTimerEvent)

tr(self, str, disambiguation: str = None, n: int = - 1) → str

update_status(plot)

called by to allow derived classes to update the states of actions based on the currently active BasePlot

can also be called after an action modifying the BasePlot (e.g. in order to update action states when an item is deselected)

class guiqwt.tools.CrossSectionTool(manager, setup_shape_cb=None, handle_final_shape_cb=None, shape_style=None, toolbar_id=<class 'guiqwt.tools.DefaultToolbarID'>, title=None, icon=None, tip=None, switch_to_default_tool=None)

setup_shape(shape)

To be reimplemented

activate()

Activate tool

handle_final_shape(shape)

To be reimplemented

update_status(plot)

called by to allow derived classes to update the states of actions based on the currently active BasePlot

can also be called after an action modifying the BasePlot (e.g. in order to update action states when an item is deselected)

add_shape_to_plot(plot, p0, p1)

Method called when shape’s rectangular area has just been drawn on screen. Adding the final shape to plot and returning it.

blockSignals(self, bool) → bool

childEvent(self, QChildEvent)

children(self) → List[QObject]

connectNotify(self, QMetaMethod)

create_action(manager)

Create and return tool’s action

create_action_menu(manager)

Create and return menu for the tool’s action

cursor()

Return tool mouse cursor

customEvent(self, QEvent)

deactivate()

Deactivate tool

deleteLater(self)

disconnect(QMetaObject.Connection) → bool

disconnect(self) → None

disconnectNotify(self, QMetaMethod)

dumpObjectInfo(self)

dumpObjectTree(self)

dynamicPropertyNames(self) → List[QByteArray]

event(self, QEvent) → bool

eventFilter(self, QObject, QEvent) → bool

findChild(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChild(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChildren(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

get_shape()

Reimplemented RectangularActionTool method

inherits(self, str) → bool

installEventFilter(self, QObject)

isSignalConnected(self, QMetaMethod) → bool

isWidgetType(self) → bool

isWindowType(self) → bool

killTimer(self, int)

metaObject(self) → QMetaObject

moveToThread(self, QThread)

objectName(self) → str

parent(self) → QObject

property(self, str) → Any

pyqtConfigure(...)

Each keyword argument is either the name of a Qt property or a Qt signal. For properties the property is set to the given value which should be of an appropriate type. For signals the signal is connected to the given value which should be a callable.

receivers(self, PYQT_SIGNAL) → int

register_plot(baseplot)

Every BasePlot using this tool should call register_plot to notify the tool about this widget using it

removeEventFilter(self, QObject)

sender(self) → QObject

senderSignalIndex(self) → int

setObjectName(self, str)

setParent(self, QObject)

setProperty(self, str, Any) → bool

set_parent_tool(tool)

Used to organize tools automatically in menu items

setup_context_menu(menu, plot)

If the tool supports it, this method should install an action in the context menu

setup_toolbar(toolbar)

Setup tool’s toolbar

signalsBlocked(self) → bool

startTimer(self, int, timerType: Qt.TimerType = Qt.CoarseTimer) → int

thread(self) → QThread

timerEvent(self, QTimerEvent)

tr(self, str, disambiguation: str = None, n: int = - 1) → str

class guiqwt.tools.AverageCrossSectionTool(manager, setup_shape_cb=None, handle_final_shape_cb=None, shape_style=None, toolbar_id=<class 'guiqwt.tools.DefaultToolbarID'>, title=None, icon=None, tip=None, switch_to_default_tool=None)

activate()

Activate tool

add_shape_to_plot(plot, p0, p1)

Method called when shape’s rectangular area has just been drawn on screen. Adding the final shape to plot and returning it.

blockSignals(self, bool) → bool

childEvent(self, QChildEvent)

children(self) → List[QObject]

connectNotify(self, QMetaMethod)

create_action(manager)

Create and return tool’s action

create_action_menu(manager)

Create and return menu for the tool’s action

cursor()

Return tool mouse cursor

customEvent(self, QEvent)

deactivate()

Deactivate tool

deleteLater(self)

disconnect(QMetaObject.Connection) → bool

disconnect(self) → None

disconnectNotify(self, QMetaMethod)

dumpObjectInfo(self)

dumpObjectTree(self)

dynamicPropertyNames(self) → List[QByteArray]

event(self, QEvent) → bool

eventFilter(self, QObject, QEvent) → bool

findChild(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChild(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChildren(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

get_shape()

Reimplemented RectangularActionTool method

handle_final_shape(shape)

To be reimplemented

inherits(self, str) → bool

installEventFilter(self, QObject)

isSignalConnected(self, QMetaMethod) → bool

isWidgetType(self) → bool

isWindowType(self) → bool

killTimer(self, int)

metaObject(self) → QMetaObject

moveToThread(self, QThread)

objectName(self) → str

parent(self) → QObject

property(self, str) → Any

pyqtConfigure(...)

Each keyword argument is either the name of a Qt property or a Qt signal. For properties the property is set to the given value which should be of an appropriate type. For signals the signal is connected to the given value which should be a callable.

receivers(self, PYQT_SIGNAL) → int

register_plot(baseplot)

Every BasePlot using this tool should call register_plot to notify the tool about this widget using it

removeEventFilter(self, QObject)

sender(self) → QObject

senderSignalIndex(self) → int

setObjectName(self, str)

setParent(self, QObject)

setProperty(self, str, Any) → bool

set_parent_tool(tool)

Used to organize tools automatically in menu items

setup_context_menu(menu, plot)

If the tool supports it, this method should install an action in the context menu

setup_shape(shape)

To be reimplemented

setup_toolbar(toolbar)

Setup tool’s toolbar

signalsBlocked(self) → bool

startTimer(self, int, timerType: Qt.TimerType = Qt.CoarseTimer) → int

thread(self) → QThread

timerEvent(self, QTimerEvent)

tr(self, str, disambiguation: str = None, n: int = - 1) → str

update_status(plot)

called by to allow derived classes to update the states of actions based on the currently active BasePlot

can also be called after an action modifying the BasePlot (e.g. in order to update action states when an item is deselected)

class guiqwt.tools.SaveAsTool(manager, toolbar_id=<class 'guiqwt.tools.DefaultToolbarID'>)

activate_command(plot, checked)

Activate tool

blockSignals(self, bool) → bool

childEvent(self, QChildEvent)

children(self) → List[QObject]

connectNotify(self, QMetaMethod)

create_action(manager)

Create and return tool’s action

create_action_menu(manager)

Create and return menu for the tool’s action

customEvent(self, QEvent)

deleteLater(self)

disconnect(QMetaObject.Connection) → bool

disconnect(self) → None

disconnectNotify(self, QMetaMethod)

dumpObjectInfo(self)

dumpObjectTree(self)

dynamicPropertyNames(self) → List[QByteArray]

event(self, QEvent) → bool

eventFilter(self, QObject, QEvent) → bool

findChild(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChild(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChildren(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

inherits(self, str) → bool

installEventFilter(self, QObject)

isSignalConnected(self, QMetaMethod) → bool

isWidgetType(self) → bool

isWindowType(self) → bool

killTimer(self, int)

metaObject(self) → QMetaObject

moveToThread(self, QThread)

objectName(self) → str

parent(self) → QObject

property(self, str) → Any

pyqtConfigure(...)

Each keyword argument is either the name of a Qt property or a Qt signal. For properties the property is set to the given value which should be of an appropriate type. For signals the signal is connected to the given value which should be a callable.

receivers(self, PYQT_SIGNAL) → int

register_plot(baseplot)

Every BasePlot using this tool should call register_plot to notify the tool about this widget using it

removeEventFilter(self, QObject)

sender(self) → QObject

senderSignalIndex(self) → int

setObjectName(self, str)

setParent(self, QObject)

setProperty(self, str, Any) → bool

set_parent_tool(tool)

Used to organize tools automatically in menu items

setup_context_menu(menu, plot)

If the tool supports it, this method should install an action in the context menu

setup_toolbar(toolbar)

Setup tool’s toolbar

signalsBlocked(self) → bool

startTimer(self, int, timerType: Qt.TimerType = Qt.CoarseTimer) → int

thread(self) → QThread

timerEvent(self, QTimerEvent)

tr(self, str, disambiguation: str = None, n: int = - 1) → str

update_status(plot)

called by to allow derived classes to update the states of actions based on the currently active BasePlot

can also be called after an action modifying the BasePlot (e.g. in order to update action states when an item is deselected)

class guiqwt.tools.CopyToClipboardTool(manager, toolbar_id=<class 'guiqwt.tools.DefaultToolbarID'>)

activate_command(plot, checked)

Activate tool

blockSignals(self, bool) → bool

childEvent(self, QChildEvent)

children(self) → List[QObject]

connectNotify(self, QMetaMethod)

create_action(manager)

Create and return tool’s action

create_action_menu(manager)

Create and return menu for the tool’s action

customEvent(self, QEvent)

deleteLater(self)

disconnect(QMetaObject.Connection) → bool

disconnect(self) → None

disconnectNotify(self, QMetaMethod)

dumpObjectInfo(self)

dumpObjectTree(self)

dynamicPropertyNames(self) → List[QByteArray]

event(self, QEvent) → bool

eventFilter(self, QObject, QEvent) → bool

findChild(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChild(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChildren(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

inherits(self, str) → bool

installEventFilter(self, QObject)

isSignalConnected(self, QMetaMethod) → bool

isWidgetType(self) → bool

isWindowType(self) → bool

killTimer(self, int)

metaObject(self) → QMetaObject

moveToThread(self, QThread)

objectName(self) → str

parent(self) → QObject

property(self, str) → Any

pyqtConfigure(...)

Each keyword argument is either the name of a Qt property or a Qt signal. For properties the property is set to the given value which should be of an appropriate type. For signals the signal is connected to the given value which should be a callable.

receivers(self, PYQT_SIGNAL) → int

register_plot(baseplot)

Every BasePlot using this tool should call register_plot to notify the tool about this widget using it

removeEventFilter(self, QObject)

sender(self) → QObject

senderSignalIndex(self) → int

setObjectName(self, str)

setParent(self, QObject)

setProperty(self, str, Any) → bool

set_parent_tool(tool)

Used to organize tools automatically in menu items

setup_context_menu(menu, plot)

If the tool supports it, this method should install an action in the context menu

setup_toolbar(toolbar)

Setup tool’s toolbar

signalsBlocked(self) → bool

startTimer(self, int, timerType: Qt.TimerType = Qt.CoarseTimer) → int

thread(self) → QThread

timerEvent(self, QTimerEvent)

tr(self, str, disambiguation: str = None, n: int = - 1) → str

update_status(plot)

called by to allow derived classes to update the states of actions based on the currently active BasePlot

can also be called after an action modifying the BasePlot (e.g. in order to update action states when an item is deselected)

class guiqwt.tools.OpenFileTool(manager, title='Open...', formats='*.*', toolbar_id=<class 'guiqwt.tools.DefaultToolbarID'>)

SIG_OPEN_FILE

Signal emitted by OpenFileTool when a file was opened (arg: filename)

activate_command(plot, checked)

Activate tool

blockSignals(self, bool) → bool

childEvent(self, QChildEvent)

children(self) → List[QObject]

connectNotify(self, QMetaMethod)

create_action(manager)

Create and return tool’s action

create_action_menu(manager)

Create and return menu for the tool’s action

customEvent(self, QEvent)

deleteLater(self)

disconnect(QMetaObject.Connection) → bool

disconnect(self) → None

disconnectNotify(self, QMetaMethod)

dumpObjectInfo(self)

dumpObjectTree(self)

dynamicPropertyNames(self) → List[QByteArray]

event(self, QEvent) → bool

eventFilter(self, QObject, QEvent) → bool

findChild(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChild(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChildren(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

inherits(self, str) → bool

installEventFilter(self, QObject)

isSignalConnected(self, QMetaMethod) → bool

isWidgetType(self) → bool

isWindowType(self) → bool

killTimer(self, int)

metaObject(self) → QMetaObject

moveToThread(self, QThread)

objectName(self) → str

parent(self) → QObject

property(self, str) → Any

pyqtConfigure(...)

Each keyword argument is either the name of a Qt property or a Qt signal. For properties the property is set to the given value which should be of an appropriate type. For signals the signal is connected to the given value which should be a callable.

receivers(self, PYQT_SIGNAL) → int

register_plot(baseplot)

Every BasePlot using this tool should call register_plot to notify the tool about this widget using it

removeEventFilter(self, QObject)

sender(self) → QObject

senderSignalIndex(self) → int

setObjectName(self, str)

setParent(self, QObject)

setProperty(self, str, Any) → bool

set_parent_tool(tool)

Used to organize tools automatically in menu items

setup_context_menu(menu, plot)

If the tool supports it, this method should install an action in the context menu

setup_toolbar(toolbar)

Setup tool’s toolbar

signalsBlocked(self) → bool

startTimer(self, int, timerType: Qt.TimerType = Qt.CoarseTimer) → int

thread(self) → QThread

timerEvent(self, QTimerEvent)

tr(self, str, disambiguation: str = None, n: int = - 1) → str

update_status(plot)

called by to allow derived classes to update the states of actions based on the currently active BasePlot

can also be called after an action modifying the BasePlot (e.g. in order to update action states when an item is deselected)

class guiqwt.tools.OpenImageTool(manager, toolbar_id=<class 'guiqwt.tools.DefaultToolbarID'>)

activate_command(plot, checked)

Activate tool

blockSignals(self, bool) → bool

childEvent(self, QChildEvent)

children(self) → List[QObject]

connectNotify(self, QMetaMethod)

create_action(manager)

Create and return tool’s action

create_action_menu(manager)

Create and return menu for the tool’s action

customEvent(self, QEvent)

deleteLater(self)

disconnect(QMetaObject.Connection) → bool

disconnect(self) → None

disconnectNotify(self, QMetaMethod)

dumpObjectInfo(self)

dumpObjectTree(self)

dynamicPropertyNames(self) → List[QByteArray]

event(self, QEvent) → bool

eventFilter(self, QObject, QEvent) → bool

findChild(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChild(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChildren(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

inherits(self, str) → bool

installEventFilter(self, QObject)

isSignalConnected(self, QMetaMethod) → bool

isWidgetType(self) → bool

isWindowType(self) → bool

killTimer(self, int)

metaObject(self) → QMetaObject

moveToThread(self, QThread)

objectName(self) → str

parent(self) → QObject

property(self, str) → Any

pyqtConfigure(...)

Each keyword argument is either the name of a Qt property or a Qt signal. For properties the property is set to the given value which should be of an appropriate type. For signals the signal is connected to the given value which should be a callable.

receivers(self, PYQT_SIGNAL) → int

register_plot(baseplot)

Every BasePlot using this tool should call register_plot to notify the tool about this widget using it

removeEventFilter(self, QObject)

sender(self) → QObject

senderSignalIndex(self) → int

setObjectName(self, str)

setParent(self, QObject)

setProperty(self, str, Any) → bool

set_parent_tool(tool)

Used to organize tools automatically in menu items

setup_context_menu(menu, plot)

If the tool supports it, this method should install an action in the context menu

setup_toolbar(toolbar)

Setup tool’s toolbar

signalsBlocked(self) → bool

startTimer(self, int, timerType: Qt.TimerType = Qt.CoarseTimer) → int

thread(self) → QThread

timerEvent(self, QTimerEvent)

tr(self, str, disambiguation: str = None, n: int = - 1) → str

update_status(plot)

called by to allow derived classes to update the states of actions based on the currently active BasePlot

can also be called after an action modifying the BasePlot (e.g. in order to update action states when an item is deselected)

class guiqwt.tools.SnapshotTool(manager, toolbar_id=<class 'guiqwt.tools.DefaultToolbarID'>)

activate()

Activate tool

blockSignals(self, bool) → bool

childEvent(self, QChildEvent)

children(self) → List[QObject]

connectNotify(self, QMetaMethod)

create_action(manager)

Create and return tool’s action

create_action_menu(manager)

Create and return menu for the tool’s action

cursor()

Return tool mouse cursor

customEvent(self, QEvent)

deactivate()

Deactivate tool

deleteLater(self)

disconnect(QMetaObject.Connection) → bool

disconnect(self) → None

disconnectNotify(self, QMetaMethod)

dumpObjectInfo(self)

dumpObjectTree(self)

dynamicPropertyNames(self) → List[QByteArray]

event(self, QEvent) → bool

eventFilter(self, QObject, QEvent) → bool

findChild(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChild(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChildren(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

get_shape()

Reimplemented RectangularActionTool method

inherits(self, str) → bool

installEventFilter(self, QObject)

isSignalConnected(self, QMetaMethod) → bool

isWidgetType(self) → bool

isWindowType(self) → bool

killTimer(self, int)

metaObject(self) → QMetaObject

moveToThread(self, QThread)

objectName(self) → str

parent(self) → QObject

property(self, str) → Any

pyqtConfigure(...)

Each keyword argument is either the name of a Qt property or a Qt signal. For properties the property is set to the given value which should be of an appropriate type. For signals the signal is connected to the given value which should be a callable.

receivers(self, PYQT_SIGNAL) → int

register_plot(baseplot)

Every BasePlot using this tool should call register_plot to notify the tool about this widget using it

removeEventFilter(self, QObject)

sender(self) → QObject

senderSignalIndex(self) → int

setObjectName(self, str)

setParent(self, QObject)

setProperty(self, str, Any) → bool

set_parent_tool(tool)

Used to organize tools automatically in menu items

setup_context_menu(menu, plot)

If the tool supports it, this method should install an action in the context menu

setup_toolbar(toolbar)

Setup tool’s toolbar

signalsBlocked(self) → bool

startTimer(self, int, timerType: Qt.TimerType = Qt.CoarseTimer) → int

thread(self) → QThread

timerEvent(self, QTimerEvent)

tr(self, str, disambiguation: str = None, n: int = - 1) → str

update_status(plot)

called by to allow derived classes to update the states of actions based on the currently active BasePlot

can also be called after an action modifying the BasePlot (e.g. in order to update action states when an item is deselected)

class guiqwt.tools.PrintTool(manager, toolbar_id=<class 'guiqwt.tools.DefaultToolbarID'>)

activate_command(plot, checked)

Activate tool

blockSignals(self, bool) → bool

childEvent(self, QChildEvent)

children(self) → List[QObject]

connectNotify(self, QMetaMethod)

create_action(manager)

Create and return tool’s action

create_action_menu(manager)

Create and return menu for the tool’s action

customEvent(self, QEvent)

deleteLater(self)

disconnect(QMetaObject.Connection) → bool

disconnect(self) → None

disconnectNotify(self, QMetaMethod)

dumpObjectInfo(self)

dumpObjectTree(self)

dynamicPropertyNames(self) → List[QByteArray]

event(self, QEvent) → bool

eventFilter(self, QObject, QEvent) → bool

findChild(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChild(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChildren(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

inherits(self, str) → bool

installEventFilter(self, QObject)

isSignalConnected(self, QMetaMethod) → bool

isWidgetType(self) → bool

isWindowType(self) → bool

killTimer(self, int)

metaObject(self) → QMetaObject

moveToThread(self, QThread)

objectName(self) → str

parent(self) → QObject

property(self, str) → Any

pyqtConfigure(...)

Each keyword argument is either the name of a Qt property or a Qt signal. For properties the property is set to the given value which should be of an appropriate type. For signals the signal is connected to the given value which should be a callable.

receivers(self, PYQT_SIGNAL) → int

register_plot(baseplot)

Every BasePlot using this tool should call register_plot to notify the tool about this widget using it

removeEventFilter(self, QObject)

sender(self) → QObject

senderSignalIndex(self) → int

setObjectName(self, str)

setParent(self, QObject)

setProperty(self, str, Any) → bool

set_parent_tool(tool)

Used to organize tools automatically in menu items

setup_context_menu(menu, plot)

If the tool supports it, this method should install an action in the context menu

setup_toolbar(toolbar)

Setup tool’s toolbar

signalsBlocked(self) → bool

startTimer(self, int, timerType: Qt.TimerType = Qt.CoarseTimer) → int

thread(self) → QThread

timerEvent(self, QTimerEvent)

tr(self, str, disambiguation: str = None, n: int = - 1) → str

update_status(plot)

called by to allow derived classes to update the states of actions based on the currently active BasePlot

can also be called after an action modifying the BasePlot (e.g. in order to update action states when an item is deselected)

class guiqwt.tools.SaveItemsTool(manager, toolbar_id=<class 'guiqwt.tools.DefaultToolbarID'>)

activate_command(plot, checked)

Activate tool

blockSignals(self, bool) → bool

childEvent(self, QChildEvent)

children(self) → List[QObject]

connectNotify(self, QMetaMethod)

create_action(manager)

Create and return tool’s action

create_action_menu(manager)

Create and return menu for the tool’s action

customEvent(self, QEvent)

deleteLater(self)

disconnect(QMetaObject.Connection) → bool

disconnect(self) → None

disconnectNotify(self, QMetaMethod)

dumpObjectInfo(self)

dumpObjectTree(self)

dynamicPropertyNames(self) → List[QByteArray]

event(self, QEvent) → bool

eventFilter(self, QObject, QEvent) → bool

findChild(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChild(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChildren(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

inherits(self, str) → bool

installEventFilter(self, QObject)

isSignalConnected(self, QMetaMethod) → bool

isWidgetType(self) → bool

isWindowType(self) → bool

killTimer(self, int)

metaObject(self) → QMetaObject

moveToThread(self, QThread)

objectName(self) → str

parent(self) → QObject

property(self, str) → Any

pyqtConfigure(...)

Each keyword argument is either the name of a Qt property or a Qt signal. For properties the property is set to the given value which should be of an appropriate type. For signals the signal is connected to the given value which should be a callable.

receivers(self, PYQT_SIGNAL) → int

register_plot(baseplot)

Every BasePlot using this tool should call register_plot to notify the tool about this widget using it

removeEventFilter(self, QObject)

sender(self) → QObject

senderSignalIndex(self) → int

setObjectName(self, str)

setParent(self, QObject)

setProperty(self, str, Any) → bool

set_parent_tool(tool)

Used to organize tools automatically in menu items

setup_context_menu(menu, plot)

If the tool supports it, this method should install an action in the context menu

setup_toolbar(toolbar)

Setup tool’s toolbar

signalsBlocked(self) → bool

startTimer(self, int, timerType: Qt.TimerType = Qt.CoarseTimer) → int

thread(self) → QThread

timerEvent(self, QTimerEvent)

tr(self, str, disambiguation: str = None, n: int = - 1) → str

update_status(plot)

called by to allow derived classes to update the states of actions based on the currently active BasePlot

can also be called after an action modifying the BasePlot (e.g. in order to update action states when an item is deselected)

class guiqwt.tools.LoadItemsTool(manager, toolbar_id=<class 'guiqwt.tools.DefaultToolbarID'>)

activate_command(plot, checked)

Activate tool

blockSignals(self, bool) → bool

childEvent(self, QChildEvent)

children(self) → List[QObject]

connectNotify(self, QMetaMethod)

create_action(manager)

Create and return tool’s action

create_action_menu(manager)

Create and return menu for the tool’s action

customEvent(self, QEvent)

deleteLater(self)

disconnect(QMetaObject.Connection) → bool

disconnect(self) → None

disconnectNotify(self, QMetaMethod)

dumpObjectInfo(self)

dumpObjectTree(self)

dynamicPropertyNames(self) → List[QByteArray]

event(self, QEvent) → bool

eventFilter(self, QObject, QEvent) → bool

findChild(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChild(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChildren(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

inherits(self, str) → bool

installEventFilter(self, QObject)

isSignalConnected(self, QMetaMethod) → bool

isWidgetType(self) → bool

isWindowType(self) → bool

killTimer(self, int)

metaObject(self) → QMetaObject

moveToThread(self, QThread)

objectName(self) → str

parent(self) → QObject

property(self, str) → Any

pyqtConfigure(...)

Each keyword argument is either the name of a Qt property or a Qt signal. For properties the property is set to the given value which should be of an appropriate type. For signals the signal is connected to the given value which should be a callable.

receivers(self, PYQT_SIGNAL) → int

register_plot(baseplot)

Every BasePlot using this tool should call register_plot to notify the tool about this widget using it

removeEventFilter(self, QObject)

sender(self) → QObject

senderSignalIndex(self) → int

setObjectName(self, str)

setParent(self, QObject)

setProperty(self, str, Any) → bool

set_parent_tool(tool)

Used to organize tools automatically in menu items

setup_context_menu(menu, plot)

If the tool supports it, this method should install an action in the context menu

setup_toolbar(toolbar)

Setup tool’s toolbar

signalsBlocked(self) → bool

startTimer(self, int, timerType: Qt.TimerType = Qt.CoarseTimer) → int

thread(self) → QThread

timerEvent(self, QTimerEvent)

tr(self, str, disambiguation: str = None, n: int = - 1) → str

update_status(plot)

called by to allow derived classes to update the states of actions based on the currently active BasePlot

can also be called after an action modifying the BasePlot (e.g. in order to update action states when an item is deselected)

class guiqwt.tools.AxisScaleTool(manager)

create_action_menu(manager)

Create and return menu for the tool’s action

update_status(plot)

called by to allow derived classes to update the states of actions based on the currently active BasePlot

can also be called after an action modifying the BasePlot (e.g. in order to update action states when an item is deselected)

blockSignals(self, bool) → bool

childEvent(self, QChildEvent)

children(self) → List[QObject]

connectNotify(self, QMetaMethod)

create_action(manager)

Create and return tool’s action

customEvent(self, QEvent)

deleteLater(self)

disconnect(QMetaObject.Connection) → bool

disconnect(self) → None

disconnectNotify(self, QMetaMethod)

dumpObjectInfo(self)

dumpObjectTree(self)

dynamicPropertyNames(self) → List[QByteArray]

event(self, QEvent) → bool

eventFilter(self, QObject, QEvent) → bool

findChild(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChild(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChildren(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

inherits(self, str) → bool

installEventFilter(self, QObject)

isSignalConnected(self, QMetaMethod) → bool

isWidgetType(self) → bool

isWindowType(self) → bool

killTimer(self, int)

metaObject(self) → QMetaObject

moveToThread(self, QThread)

objectName(self) → str

parent(self) → QObject

property(self, str) → Any

pyqtConfigure(...)

Each keyword argument is either the name of a Qt property or a Qt signal. For properties the property is set to the given value which should be of an appropriate type. For signals the signal is connected to the given value which should be a callable.

receivers(self, PYQT_SIGNAL) → int

register_plot(baseplot)

Every BasePlot using this tool should call register_plot to notify the tool about this widget using it

removeEventFilter(self, QObject)

sender(self) → QObject

senderSignalIndex(self) → int

setObjectName(self, str)

setParent(self, QObject)

setProperty(self, str, Any) → bool

set_parent_tool(tool)

Used to organize tools automatically in menu items

setup_context_menu(menu, plot)

If the tool supports it, this method should install an action in the context menu

setup_toolbar(toolbar)

Setup tool’s toolbar

signalsBlocked(self) → bool

startTimer(self, int, timerType: Qt.TimerType = Qt.CoarseTimer) → int

thread(self) → QThread

timerEvent(self, QTimerEvent)

tr(self, str, disambiguation: str = None, n: int = - 1) → str

class guiqwt.tools.HelpTool(manager, toolbar_id=<class 'guiqwt.tools.DefaultToolbarID'>)

activate_command(plot, checked)

Activate tool

blockSignals(self, bool) → bool

childEvent(self, QChildEvent)

children(self) → List[QObject]

connectNotify(self, QMetaMethod)

create_action(manager)

Create and return tool’s action

create_action_menu(manager)

Create and return menu for the tool’s action

customEvent(self, QEvent)

deleteLater(self)

disconnect(QMetaObject.Connection) → bool

disconnect(self) → None

disconnectNotify(self, QMetaMethod)

dumpObjectInfo(self)

dumpObjectTree(self)

dynamicPropertyNames(self) → List[QByteArray]

event(self, QEvent) → bool

eventFilter(self, QObject, QEvent) → bool

findChild(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChild(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChildren(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

inherits(self, str) → bool

installEventFilter(self, QObject)

isSignalConnected(self, QMetaMethod) → bool

isWidgetType(self) → bool

isWindowType(self) → bool

killTimer(self, int)

metaObject(self) → QMetaObject

moveToThread(self, QThread)

objectName(self) → str

parent(self) → QObject

property(self, str) → Any

pyqtConfigure(...)

Each keyword argument is either the name of a Qt property or a Qt signal. For properties the property is set to the given value which should be of an appropriate type. For signals the signal is connected to the given value which should be a callable.

receivers(self, PYQT_SIGNAL) → int

register_plot(baseplot)

Every BasePlot using this tool should call register_plot to notify the tool about this widget using it

removeEventFilter(self, QObject)

sender(self) → QObject

senderSignalIndex(self) → int

setObjectName(self, str)

setParent(self, QObject)

setProperty(self, str, Any) → bool

set_parent_tool(tool)

Used to organize tools automatically in menu items

setup_context_menu(menu, plot)

If the tool supports it, this method should install an action in the context menu

setup_toolbar(toolbar)

Setup tool’s toolbar

signalsBlocked(self) → bool

startTimer(self, int, timerType: Qt.TimerType = Qt.CoarseTimer) → int

thread(self) → QThread

timerEvent(self, QTimerEvent)

tr(self, str, disambiguation: str = None, n: int = - 1) → str

update_status(plot)

called by to allow derived classes to update the states of actions based on the currently active BasePlot

can also be called after an action modifying the BasePlot (e.g. in order to update action states when an item is deselected)

class guiqwt.tools.ExportItemDataTool(manager, toolbar_id=None)

activate_command(plot, checked)

Activate tool

blockSignals(self, bool) → bool

childEvent(self, QChildEvent)

children(self) → List[QObject]

connectNotify(self, QMetaMethod)

create_action(manager)

Create and return tool’s action

create_action_menu(manager)

Create and return menu for the tool’s action

customEvent(self, QEvent)

deleteLater(self)

disconnect(QMetaObject.Connection) → bool

disconnect(self) → None

disconnectNotify(self, QMetaMethod)

dumpObjectInfo(self)

dumpObjectTree(self)

dynamicPropertyNames(self) → List[QByteArray]

event(self, QEvent) → bool

eventFilter(self, QObject, QEvent) → bool

findChild(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChild(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChildren(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

inherits(self, str) → bool

installEventFilter(self, QObject)

isSignalConnected(self, QMetaMethod) → bool

isWidgetType(self) → bool

isWindowType(self) → bool

killTimer(self, int)

metaObject(self) → QMetaObject

moveToThread(self, QThread)

objectName(self) → str

parent(self) → QObject

property(self, str) → Any

pyqtConfigure(...)

Each keyword argument is either the name of a Qt property or a Qt signal. For properties the property is set to the given value which should be of an appropriate type. For signals the signal is connected to the given value which should be a callable.

receivers(self, PYQT_SIGNAL) → int

register_plot(baseplot)

Every BasePlot using this tool should call register_plot to notify the tool about this widget using it

removeEventFilter(self, QObject)

sender(self) → QObject

senderSignalIndex(self) → int

setObjectName(self, str)

setParent(self, QObject)

setProperty(self, str, Any) → bool

set_parent_tool(tool)

Used to organize tools automatically in menu items

setup_context_menu(menu, plot)

If the tool supports it, this method should install an action in the context menu

setup_toolbar(toolbar)

Setup tool’s toolbar

signalsBlocked(self) → bool

startTimer(self, int, timerType: Qt.TimerType = Qt.CoarseTimer) → int

thread(self) → QThread

timerEvent(self, QTimerEvent)

tr(self, str, disambiguation: str = None, n: int = - 1) → str

update_status(plot)

called by to allow derived classes to update the states of actions based on the currently active BasePlot

can also be called after an action modifying the BasePlot (e.g. in order to update action states when an item is deselected)

class guiqwt.tools.EditItemDataTool(manager, toolbar_id=None)

Edit item data

activate_command(plot, checked)

Activate tool

blockSignals(self, bool) → bool

childEvent(self, QChildEvent)

children(self) → List[QObject]

connectNotify(self, QMetaMethod)

create_action(manager)

Create and return tool’s action

create_action_menu(manager)

Create and return menu for the tool’s action

customEvent(self, QEvent)

deleteLater(self)

disconnect(QMetaObject.Connection) → bool

disconnect(self) → None

disconnectNotify(self, QMetaMethod)

dumpObjectInfo(self)

dumpObjectTree(self)

dynamicPropertyNames(self) → List[QByteArray]

event(self, QEvent) → bool

eventFilter(self, QObject, QEvent) → bool

findChild(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChild(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChildren(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

inherits(self, str) → bool

installEventFilter(self, QObject)

isSignalConnected(self, QMetaMethod) → bool

isWidgetType(self) → bool

isWindowType(self) → bool

killTimer(self, int)

metaObject(self) → QMetaObject

moveToThread(self, QThread)

objectName(self) → str

parent(self) → QObject

property(self, str) → Any

pyqtConfigure(...)

Each keyword argument is either the name of a Qt property or a Qt signal. For properties the property is set to the given value which should be of an appropriate type. For signals the signal is connected to the given value which should be a callable.

receivers(self, PYQT_SIGNAL) → int

register_plot(baseplot)

Every BasePlot using this tool should call register_plot to notify the tool about this widget using it

removeEventFilter(self, QObject)

sender(self) → QObject

senderSignalIndex(self) → int

setObjectName(self, str)

setParent(self, QObject)

setProperty(self, str, Any) → bool

set_parent_tool(tool)

Used to organize tools automatically in menu items

setup_context_menu(menu, plot)

If the tool supports it, this method should install an action in the context menu

setup_toolbar(toolbar)

Setup tool’s toolbar

signalsBlocked(self) → bool

startTimer(self, int, timerType: Qt.TimerType = Qt.CoarseTimer) → int

thread(self) → QThread

timerEvent(self, QTimerEvent)

tr(self, str, disambiguation: str = None, n: int = - 1) → str

update_status(plot)

called by to allow derived classes to update the states of actions based on the currently active BasePlot

can also be called after an action modifying the BasePlot (e.g. in order to update action states when an item is deselected)

class guiqwt.tools.ItemCenterTool(manager, toolbar_id=None)

update_status(plot)

called by to allow derived classes to update the states of actions based on the currently active BasePlot

can also be called after an action modifying the BasePlot (e.g. in order to update action states when an item is deselected)

activate_command(plot, checked)

Activate tool

blockSignals(self, bool) → bool

childEvent(self, QChildEvent)

children(self) → List[QObject]

connectNotify(self, QMetaMethod)

create_action(manager)

Create and return tool’s action

create_action_menu(manager)

Create and return menu for the tool’s action

customEvent(self, QEvent)

deleteLater(self)

disconnect(QMetaObject.Connection) → bool

disconnect(self) → None

disconnectNotify(self, QMetaMethod)

dumpObjectInfo(self)

dumpObjectTree(self)

dynamicPropertyNames(self) → List[QByteArray]

event(self, QEvent) → bool

eventFilter(self, QObject, QEvent) → bool

findChild(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChild(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChildren(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

inherits(self, str) → bool

installEventFilter(self, QObject)

isSignalConnected(self, QMetaMethod) → bool

isWidgetType(self) → bool

isWindowType(self) → bool

killTimer(self, int)

metaObject(self) → QMetaObject

moveToThread(self, QThread)

objectName(self) → str

parent(self) → QObject

property(self, str) → Any

pyqtConfigure(...)

Each keyword argument is either the name of a Qt property or a Qt signal. For properties the property is set to the given value which should be of an appropriate type. For signals the signal is connected to the given value which should be a callable.

receivers(self, PYQT_SIGNAL) → int

register_plot(baseplot)

Every BasePlot using this tool should call register_plot to notify the tool about this widget using it

removeEventFilter(self, QObject)

sender(self) → QObject

senderSignalIndex(self) → int

setObjectName(self, str)

setParent(self, QObject)

setProperty(self, str, Any) → bool

set_parent_tool(tool)

Used to organize tools automatically in menu items

setup_context_menu(menu, plot)

If the tool supports it, this method should install an action in the context menu

setup_toolbar(toolbar)

Setup tool’s toolbar

signalsBlocked(self) → bool

startTimer(self, int, timerType: Qt.TimerType = Qt.CoarseTimer) → int

thread(self) → QThread

timerEvent(self, QTimerEvent)

tr(self, str, disambiguation: str = None, n: int = - 1) → str

class guiqwt.tools.DeleteItemTool(manager, toolbar_id=None)

update_status(plot)

called by to allow derived classes to update the states of actions based on the currently active BasePlot

can also be called after an action modifying the BasePlot (e.g. in order to update action states when an item is deselected)

activate_command(plot, checked)

Activate tool

blockSignals(self, bool) → bool

childEvent(self, QChildEvent)

children(self) → List[QObject]

connectNotify(self, QMetaMethod)

create_action(manager)

Create and return tool’s action

create_action_menu(manager)

Create and return menu for the tool’s action

customEvent(self, QEvent)

deleteLater(self)

disconnect(QMetaObject.Connection) → bool

disconnect(self) → None

disconnectNotify(self, QMetaMethod)

dumpObjectInfo(self)

dumpObjectTree(self)

dynamicPropertyNames(self) → List[QByteArray]

event(self, QEvent) → bool

eventFilter(self, QObject, QEvent) → bool

findChild(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChild(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → QObject

findChildren(self, type, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, name: str = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, type, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

findChildren(self, Tuple, QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) → List[QObject]

inherits(self, str) → bool

installEventFilter(self, QObject)

isSignalConnected(self, QMetaMethod) → bool

isWidgetType(self) → bool

isWindowType(self) → bool

killTimer(self, int)

metaObject(self) → QMetaObject

moveToThread(self, QThread)

objectName(self) → str

parent(self) → QObject

property(self, str) → Any

pyqtConfigure(...)

Each keyword argument is either the name of a Qt property or a Qt signal. For properties the property is set to the given value which should be of an appropriate type. For signals the signal is connected to the given value which should be a callable.

receivers(self, PYQT_SIGNAL) → int

register_plot(baseplot)

Every BasePlot using this tool should call register_plot to notify the tool about this widget using it

removeEventFilter(self, QObject)

sender(self) → QObject

senderSignalIndex(self) → int

setObjectName(self, str)

setParent(self, QObject)

setProperty(self, str, Any) → bool

set_parent_tool(tool)

Used to organize tools automatically in menu items

setup_context_menu(menu, plot)

If the tool supports it, this method should install an action in the context menu

setup_toolbar(toolbar)

Setup tool’s toolbar

signalsBlocked(self) → bool

startTimer(self, int, timerType: Qt.TimerType = Qt.CoarseTimer) → int

thread(self) → QThread

timerEvent(self, QTimerEvent)

tr(self, str, disambiguation: str = None, n: int = - 1) → str