guiqwt.tools

The tools module provides a collection of plot tools :

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:

import os.path as osp

from guiqwt.plot import ImageDialog
from guiqwt.tools import (RectangleTool, EllipseTool, HRangeTool, PlaceAxesTool,
                          MultiLineTool, FreeFormTool, SegmentTool, CircleTool,
                          AnnotatedRectangleTool, AnnotatedEllipseTool,
                          AnnotatedSegmentTool, AnnotatedCircleTool, LabelTool,
                          AnnotatedPointTool,
                          VCursorTool, HCursorTool, XCursorTool,
                          ObliqueRectangleTool, AnnotatedObliqueRectangleTool)
from guiqwt.builder import make

def create_window():
    win = ImageDialog(edit=False, toolbar=True,
                      wintitle="All image and plot tools test")
    for toolklass in (LabelTool, HRangeTool,
                      VCursorTool, HCursorTool, XCursorTool,
                      SegmentTool, RectangleTool, ObliqueRectangleTool,
                      CircleTool, EllipseTool,
                      MultiLineTool, FreeFormTool, PlaceAxesTool,
                      AnnotatedRectangleTool, AnnotatedObliqueRectangleTool,
                      AnnotatedCircleTool, AnnotatedEllipseTool,
                      AnnotatedSegmentTool, AnnotatedPointTool):
        win.add_tool(toolklass)
    return win

def test():
    """Test"""
    # -- Create QApplication
    import guidata
    _app = guidata.qapplication()
    # --
    filename = osp.join(osp.dirname(__file__), "brain.png")
    win = create_window()
    image = make.image(filename=filename, colormap="bone")
    plot = win.get_plot()
    plot.add_item(image)
    win.exec_()

if __name__ == "__main__":
    test()
../_images/image_plot_tools.png

Reference

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

Activate tool

blockSignals(bool) → bool
childEvent(QChildEvent)
children() → list-of-QObject
connect(QObject, SIGNAL(), QObject, SLOT(), Qt.ConnectionType=Qt.AutoConnection) → bool

QObject.connect(QObject, SIGNAL(), callable, Qt.ConnectionType=Qt.AutoConnection) -> bool QObject.connect(QObject, SIGNAL(), SLOT(), Qt.ConnectionType=Qt.AutoConnection) -> bool

connectNotify(SIGNAL())
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(QEvent)
deactivate()

Deactivate tool

deleteLater()
destroyed

QObject.destroyed[QObject] [signal] QObject.destroyed [signal]

disconnect(QObject, SIGNAL(), QObject, SLOT()) → bool

QObject.disconnect(QObject, SIGNAL(), callable) -> bool

disconnectNotify(SIGNAL())
dumpObjectInfo()
dumpObjectTree()
dynamicPropertyNames() → list-of-QByteArray
emit(SIGNAL(), ...)
event(QEvent) → bool
eventFilter(QObject, QEvent) → bool
findChild(type, str name='') → QObject

QObject.findChild(tuple, str name=’‘) -> QObject

findChildren(type, str name='') → list-of-QObject

QObject.findChildren(tuple, str name=’‘) -> list-of-QObject QObject.findChildren(type, QRegExp) -> list-of-QObject QObject.findChildren(tuple, QRegExp) -> list-of-QObject

inherits(str) → bool
installEventFilter(QObject)
isWidgetType() → bool
killTimer(int)
metaObject() → QMetaObject
moveToThread(QThread)
objectName() → str
parent() → QObject
property(str) → object
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(SIGNAL()) → int
removeEventFilter(QObject)
sender() → QObject
senderSignalIndex() → int
setObjectName(str)
setParent(QObject)
setProperty(str, object) → 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() → bool
startTimer(int) → int
thread() → QThread
timerEvent(QTimerEvent)
tr(str, str disambiguation=None, int n=-1) → str
trUtf8(str, str disambiguation=None, int n=-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)[source]

Graphical Object Selection Tool

activate()

Activate tool

blockSignals(bool) → bool
childEvent(QChildEvent)
children() → list-of-QObject
connect(QObject, SIGNAL(), QObject, SLOT(), Qt.ConnectionType=Qt.AutoConnection) → bool

QObject.connect(QObject, SIGNAL(), callable, Qt.ConnectionType=Qt.AutoConnection) -> bool QObject.connect(QObject, SIGNAL(), SLOT(), Qt.ConnectionType=Qt.AutoConnection) -> bool

connectNotify(SIGNAL())
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(QEvent)
deactivate()

Deactivate tool

deleteLater()
destroyed

QObject.destroyed[QObject] [signal] QObject.destroyed [signal]

disconnect(QObject, SIGNAL(), QObject, SLOT()) → bool

QObject.disconnect(QObject, SIGNAL(), callable) -> bool

disconnectNotify(SIGNAL())
dumpObjectInfo()
dumpObjectTree()
dynamicPropertyNames() → list-of-QByteArray
emit(SIGNAL(), ...)
event(QEvent) → bool
eventFilter(QObject, QEvent) → bool
findChild(type, str name='') → QObject

QObject.findChild(tuple, str name=’‘) -> QObject

findChildren(type, str name='') → list-of-QObject

QObject.findChildren(tuple, str name=’‘) -> list-of-QObject QObject.findChildren(type, QRegExp) -> list-of-QObject QObject.findChildren(tuple, QRegExp) -> list-of-QObject

inherits(str) → bool
installEventFilter(QObject)
isWidgetType() → bool
killTimer(int)
metaObject() → QMetaObject
moveToThread(QThread)
objectName() → str
parent() → QObject
property(str) → object
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(SIGNAL()) → int
removeEventFilter(QObject)
sender() → QObject
senderSignalIndex() → int
setObjectName(str)
setParent(QObject)
setProperty(str, object) → 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() → bool
startTimer(int) → int
thread() → QThread
timerEvent(QTimerEvent)
tr(str, str disambiguation=None, int n=-1) → str
trUtf8(str, str disambiguation=None, int n=-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)[source]
activate()

Activate tool

blockSignals(bool) → bool
childEvent(QChildEvent)
children() → list-of-QObject
connect(QObject, SIGNAL(), QObject, SLOT(), Qt.ConnectionType=Qt.AutoConnection) → bool

QObject.connect(QObject, SIGNAL(), callable, Qt.ConnectionType=Qt.AutoConnection) -> bool QObject.connect(QObject, SIGNAL(), SLOT(), Qt.ConnectionType=Qt.AutoConnection) -> bool

connectNotify(SIGNAL())
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(QEvent)
deactivate()

Deactivate tool

deleteLater()
destroyed

QObject.destroyed[QObject] [signal] QObject.destroyed [signal]

disconnect(QObject, SIGNAL(), QObject, SLOT()) → bool

QObject.disconnect(QObject, SIGNAL(), callable) -> bool

disconnectNotify(SIGNAL())
dumpObjectInfo()
dumpObjectTree()
dynamicPropertyNames() → list-of-QByteArray
emit(SIGNAL(), ...)
event(QEvent) → bool
eventFilter(QObject, QEvent) → bool
findChild(type, str name='') → QObject

QObject.findChild(tuple, str name=’‘) -> QObject

findChildren(type, str name='') → list-of-QObject

QObject.findChildren(tuple, str name=’‘) -> list-of-QObject QObject.findChildren(type, QRegExp) -> list-of-QObject QObject.findChildren(tuple, QRegExp) -> list-of-QObject

inherits(str) → bool
installEventFilter(QObject)
isWidgetType() → bool
killTimer(int)
metaObject() → QMetaObject
moveToThread(QThread)
objectName() → str
parent() → QObject
property(str) → object
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(SIGNAL()) → int
removeEventFilter(QObject)
sender() → QObject
senderSignalIndex() → int
setObjectName(str)
setParent(QObject)
setProperty(str, object) → 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() → bool
startTimer(int) → int
thread() → QThread
timerEvent(QTimerEvent)
tr(str, str disambiguation=None, int n=-1) → str
trUtf8(str, str disambiguation=None, int n=-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)[source]
mouse_press(filter, event)[source]

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

move(filter, event)[source]

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

mouse_release(filter, event)[source]

Releasing the mouse button validate the last point position

activate()

Activate tool

blockSignals(bool) → bool
childEvent(QChildEvent)
children() → list-of-QObject
connect(QObject, SIGNAL(), QObject, SLOT(), Qt.ConnectionType=Qt.AutoConnection) → bool

QObject.connect(QObject, SIGNAL(), callable, Qt.ConnectionType=Qt.AutoConnection) -> bool QObject.connect(QObject, SIGNAL(), SLOT(), Qt.ConnectionType=Qt.AutoConnection) -> bool

connectNotify(SIGNAL())
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(QEvent)
deactivate()

Deactivate tool

deleteLater()
destroyed

QObject.destroyed[QObject] [signal] QObject.destroyed [signal]

disconnect(QObject, SIGNAL(), QObject, SLOT()) → bool

QObject.disconnect(QObject, SIGNAL(), callable) -> bool

disconnectNotify(SIGNAL())
dumpObjectInfo()
dumpObjectTree()
dynamicPropertyNames() → list-of-QByteArray
emit(SIGNAL(), ...)
event(QEvent) → bool
eventFilter(QObject, QEvent) → bool
findChild(type, str name='') → QObject

QObject.findChild(tuple, str name=’‘) -> QObject

findChildren(type, str name='') → list-of-QObject

QObject.findChildren(tuple, str name=’‘) -> list-of-QObject QObject.findChildren(type, QRegExp) -> list-of-QObject QObject.findChildren(tuple, QRegExp) -> list-of-QObject

inherits(str) → bool
installEventFilter(QObject)
isWidgetType() → bool
killTimer(int)
metaObject() → QMetaObject
moveToThread(QThread)
objectName() → str
parent() → QObject
property(str) → object
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(SIGNAL()) → int
removeEventFilter(QObject)
sender() → QObject
senderSignalIndex() → int
setObjectName(str)
setParent(QObject)
setProperty(str, object) → 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() → bool
startTimer(int) → int
thread() → QThread
timerEvent(QTimerEvent)
tr(str, str disambiguation=None, int n=-1) → str
trUtf8(str, str disambiguation=None, int n=-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)[source]
cancel_point(filter, event)[source]

Reimplement base class method

mouse_press(filter, event)[source]

Reimplement base class method

activate()

Activate tool

blockSignals(bool) → bool
childEvent(QChildEvent)
children() → list-of-QObject
connect(QObject, SIGNAL(), QObject, SLOT(), Qt.ConnectionType=Qt.AutoConnection) → bool

QObject.connect(QObject, SIGNAL(), callable, Qt.ConnectionType=Qt.AutoConnection) -> bool QObject.connect(QObject, SIGNAL(), SLOT(), Qt.ConnectionType=Qt.AutoConnection) -> bool

connectNotify(SIGNAL())
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(QEvent)
deactivate()

Deactivate tool

deleteLater()
destroyed

QObject.destroyed[QObject] [signal] QObject.destroyed [signal]

disconnect(QObject, SIGNAL(), QObject, SLOT()) → bool

QObject.disconnect(QObject, SIGNAL(), callable) -> bool

disconnectNotify(SIGNAL())
dumpObjectInfo()
dumpObjectTree()
dynamicPropertyNames() → list-of-QByteArray
emit(SIGNAL(), ...)
event(QEvent) → bool
eventFilter(QObject, QEvent) → bool
findChild(type, str name='') → QObject

QObject.findChild(tuple, str name=’‘) -> QObject

findChildren(type, str name='') → list-of-QObject

QObject.findChildren(tuple, str name=’‘) -> list-of-QObject QObject.findChildren(type, QRegExp) -> list-of-QObject QObject.findChildren(tuple, QRegExp) -> list-of-QObject

inherits(str) → bool
installEventFilter(QObject)
isWidgetType() → bool
killTimer(int)
metaObject() → 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(QThread)
objectName() → str
parent() → QObject
property(str) → object
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(SIGNAL()) → int
removeEventFilter(QObject)
sender() → QObject
senderSignalIndex() → int
setObjectName(str)
setParent(QObject)
setProperty(str, object) → 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() → bool
startTimer(int) → int
thread() → QThread
timerEvent(QTimerEvent)
tr(str, str disambiguation=None, int n=-1) → str
trUtf8(str, str disambiguation=None, int n=-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)[source]
activate()

Activate tool

blockSignals(bool) → bool
childEvent(QChildEvent)
children() → list-of-QObject
connect(QObject, SIGNAL(), QObject, SLOT(), Qt.ConnectionType=Qt.AutoConnection) → bool

QObject.connect(QObject, SIGNAL(), callable, Qt.ConnectionType=Qt.AutoConnection) -> bool QObject.connect(QObject, SIGNAL(), SLOT(), Qt.ConnectionType=Qt.AutoConnection) -> bool

connectNotify(SIGNAL())
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(QEvent)
deactivate()

Deactivate tool

deleteLater()
destroyed

QObject.destroyed[QObject] [signal] QObject.destroyed [signal]

disconnect(QObject, SIGNAL(), QObject, SLOT()) → bool

QObject.disconnect(QObject, SIGNAL(), callable) -> bool

disconnectNotify(SIGNAL())
dumpObjectInfo()
dumpObjectTree()
dynamicPropertyNames() → list-of-QByteArray
emit(SIGNAL(), ...)
event(QEvent) → bool
eventFilter(QObject, QEvent) → bool
findChild(type, str name='') → QObject

QObject.findChild(tuple, str name=’‘) -> QObject

findChildren(type, str name='') → list-of-QObject

QObject.findChildren(tuple, str name=’‘) -> list-of-QObject QObject.findChildren(type, QRegExp) -> list-of-QObject QObject.findChildren(tuple, QRegExp) -> list-of-QObject

inherits(str) → bool
installEventFilter(QObject)
isWidgetType() → bool
killTimer(int)
metaObject() → QMetaObject
moveToThread(QThread)
objectName() → str
parent() → QObject
property(str) → object
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(SIGNAL()) → int
removeEventFilter(QObject)
sender() → QObject
senderSignalIndex() → int
setObjectName(str)
setParent(QObject)
setProperty(str, object) → 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() → bool
startTimer(int) → int
thread() → QThread
timerEvent(QTimerEvent)
tr(str, str disambiguation=None, int n=-1) → str
trUtf8(str, str disambiguation=None, int n=-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)[source]
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(bool) → bool
childEvent(QChildEvent)
children() → list-of-QObject
connect(QObject, SIGNAL(), QObject, SLOT(), Qt.ConnectionType=Qt.AutoConnection) → bool

QObject.connect(QObject, SIGNAL(), callable, Qt.ConnectionType=Qt.AutoConnection) -> bool QObject.connect(QObject, SIGNAL(), SLOT(), Qt.ConnectionType=Qt.AutoConnection) -> bool

connectNotify(SIGNAL())
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(QEvent)
deactivate()

Deactivate tool

deleteLater()
destroyed

QObject.destroyed[QObject] [signal] QObject.destroyed [signal]

disconnect(QObject, SIGNAL(), QObject, SLOT()) → bool

QObject.disconnect(QObject, SIGNAL(), callable) -> bool

disconnectNotify(SIGNAL())
dumpObjectInfo()
dumpObjectTree()
dynamicPropertyNames() → list-of-QByteArray
emit(SIGNAL(), ...)
event(QEvent) → bool
eventFilter(QObject, QEvent) → bool
findChild(type, str name='') → QObject

QObject.findChild(tuple, str name=’‘) -> QObject

findChildren(type, str name='') → list-of-QObject

QObject.findChildren(tuple, str name=’‘) -> list-of-QObject QObject.findChildren(type, QRegExp) -> list-of-QObject QObject.findChildren(tuple, QRegExp) -> list-of-QObject

get_shape()

Reimplemented RectangularActionTool method

handle_final_shape(shape)

To be reimplemented

inherits(str) → bool
installEventFilter(QObject)
isWidgetType() → bool
killTimer(int)
metaObject() → QMetaObject
moveToThread(QThread)
objectName() → str
parent() → QObject
property(str) → object
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(SIGNAL()) → int
removeEventFilter(QObject)
sender() → QObject
senderSignalIndex() → int
setObjectName(str)
setParent(QObject)
setProperty(str, object) → 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() → bool
startTimer(int) → int
thread() → QThread
timerEvent(QTimerEvent)
tr(str, str disambiguation=None, int n=-1) → str
trUtf8(str, str disambiguation=None, int n=-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)[source]
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(bool) → bool
childEvent(QChildEvent)
children() → list-of-QObject
connect(QObject, SIGNAL(), QObject, SLOT(), Qt.ConnectionType=Qt.AutoConnection) → bool

QObject.connect(QObject, SIGNAL(), callable, Qt.ConnectionType=Qt.AutoConnection) -> bool QObject.connect(QObject, SIGNAL(), SLOT(), Qt.ConnectionType=Qt.AutoConnection) -> bool

connectNotify(SIGNAL())
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(QEvent)
deactivate()

Deactivate tool

deleteLater()
destroyed

QObject.destroyed[QObject] [signal] QObject.destroyed [signal]

disconnect(QObject, SIGNAL(), QObject, SLOT()) → bool

QObject.disconnect(QObject, SIGNAL(), callable) -> bool

disconnectNotify(SIGNAL())
dumpObjectInfo()
dumpObjectTree()
dynamicPropertyNames() → list-of-QByteArray
emit(SIGNAL(), ...)
event(QEvent) → bool
eventFilter(QObject, QEvent) → bool
findChild(type, str name='') → QObject

QObject.findChild(tuple, str name=’‘) -> QObject

findChildren(type, str name='') → list-of-QObject

QObject.findChildren(tuple, str name=’‘) -> list-of-QObject QObject.findChildren(type, QRegExp) -> list-of-QObject QObject.findChildren(tuple, QRegExp) -> list-of-QObject

get_shape()

Reimplemented RectangularActionTool method

handle_final_shape(shape)

To be reimplemented

inherits(str) → bool
installEventFilter(QObject)
isWidgetType() → bool
killTimer(int)
metaObject() → QMetaObject
moveToThread(QThread)
objectName() → str
parent() → QObject
property(str) → object
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(SIGNAL()) → int
removeEventFilter(QObject)
sender() → QObject
senderSignalIndex() → int
setObjectName(str)
setParent(QObject)
setProperty(str, object) → 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() → bool
startTimer(int) → int
thread() → QThread
timerEvent(QTimerEvent)
tr(str, str disambiguation=None, int n=-1) → str
trUtf8(str, str disambiguation=None, int n=-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)[source]
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(bool) → bool
childEvent(QChildEvent)
children() → list-of-QObject
connect(QObject, SIGNAL(), QObject, SLOT(), Qt.ConnectionType=Qt.AutoConnection) → bool

QObject.connect(QObject, SIGNAL(), callable, Qt.ConnectionType=Qt.AutoConnection) -> bool QObject.connect(QObject, SIGNAL(), SLOT(), Qt.ConnectionType=Qt.AutoConnection) -> bool

connectNotify(SIGNAL())
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(QEvent)
deactivate()

Deactivate tool

deleteLater()
destroyed

QObject.destroyed[QObject] [signal] QObject.destroyed [signal]

disconnect(QObject, SIGNAL(), QObject, SLOT()) → bool

QObject.disconnect(QObject, SIGNAL(), callable) -> bool

disconnectNotify(SIGNAL())
dumpObjectInfo()
dumpObjectTree()
dynamicPropertyNames() → list-of-QByteArray
emit(SIGNAL(), ...)
event(QEvent) → bool
eventFilter(QObject, QEvent) → bool
findChild(type, str name='') → QObject

QObject.findChild(tuple, str name=’‘) -> QObject

findChildren(type, str name='') → list-of-QObject

QObject.findChildren(tuple, str name=’‘) -> list-of-QObject QObject.findChildren(type, QRegExp) -> list-of-QObject QObject.findChildren(tuple, QRegExp) -> list-of-QObject

get_shape()

Reimplemented RectangularActionTool method

handle_final_shape(shape)

To be reimplemented

inherits(str) → bool
installEventFilter(QObject)
isWidgetType() → bool
killTimer(int)
metaObject() → QMetaObject
moveToThread(QThread)
objectName() → str
parent() → QObject
property(str) → object
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(SIGNAL()) → int
removeEventFilter(QObject)
sender() → QObject
senderSignalIndex() → int
setObjectName(str)
setParent(QObject)
setProperty(str, object) → 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() → bool
startTimer(int) → int
thread() → QThread
timerEvent(QTimerEvent)
tr(str, str disambiguation=None, int n=-1) → str
trUtf8(str, str disambiguation=None, int n=-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)[source]
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(bool) → bool
childEvent(QChildEvent)
children() → list-of-QObject
connect(QObject, SIGNAL(), QObject, SLOT(), Qt.ConnectionType=Qt.AutoConnection) → bool

QObject.connect(QObject, SIGNAL(), callable, Qt.ConnectionType=Qt.AutoConnection) -> bool QObject.connect(QObject, SIGNAL(), SLOT(), Qt.ConnectionType=Qt.AutoConnection) -> bool

connectNotify(SIGNAL())
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(QEvent)
deactivate()

Deactivate tool

deleteLater()
destroyed

QObject.destroyed[QObject] [signal] QObject.destroyed [signal]

disconnect(QObject, SIGNAL(), QObject, SLOT()) → bool

QObject.disconnect(QObject, SIGNAL(), callable) -> bool

disconnectNotify(SIGNAL())
dumpObjectInfo()
dumpObjectTree()
dynamicPropertyNames() → list-of-QByteArray
emit(SIGNAL(), ...)
event(QEvent) → bool
eventFilter(QObject, QEvent) → bool
findChild(type, str name='') → QObject

QObject.findChild(tuple, str name=’‘) -> QObject

findChildren(type, str name='') → list-of-QObject

QObject.findChildren(tuple, str name=’‘) -> list-of-QObject QObject.findChildren(type, QRegExp) -> list-of-QObject QObject.findChildren(tuple, QRegExp) -> list-of-QObject

get_shape()

Reimplemented RectangularActionTool method

handle_final_shape(shape)

To be reimplemented

inherits(str) → bool
installEventFilter(QObject)
isWidgetType() → bool
killTimer(int)
metaObject() → QMetaObject
moveToThread(QThread)
objectName() → str
parent() → QObject
property(str) → object
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(SIGNAL()) → int
removeEventFilter(QObject)
sender() → QObject
senderSignalIndex() → int
setObjectName(str)
setParent(QObject)
setProperty(str, object) → 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() → bool
startTimer(int) → int
thread() → QThread
timerEvent(QTimerEvent)
tr(str, str disambiguation=None, int n=-1) → str
trUtf8(str, str disambiguation=None, int n=-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)[source]
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(bool) → bool
childEvent(QChildEvent)
children() → list-of-QObject
connect(QObject, SIGNAL(), QObject, SLOT(), Qt.ConnectionType=Qt.AutoConnection) → bool

QObject.connect(QObject, SIGNAL(), callable, Qt.ConnectionType=Qt.AutoConnection) -> bool QObject.connect(QObject, SIGNAL(), SLOT(), Qt.ConnectionType=Qt.AutoConnection) -> bool

connectNotify(SIGNAL())
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(QEvent)
deactivate()

Deactivate tool

deleteLater()
destroyed

QObject.destroyed[QObject] [signal] QObject.destroyed [signal]

disconnect(QObject, SIGNAL(), QObject, SLOT()) → bool

QObject.disconnect(QObject, SIGNAL(), callable) -> bool

disconnectNotify(SIGNAL())
dumpObjectInfo()
dumpObjectTree()
dynamicPropertyNames() → list-of-QByteArray
emit(SIGNAL(), ...)
event(QEvent) → bool
eventFilter(QObject, QEvent) → bool
findChild(type, str name='') → QObject

QObject.findChild(tuple, str name=’‘) -> QObject

findChildren(type, str name='') → list-of-QObject

QObject.findChildren(tuple, str name=’‘) -> list-of-QObject QObject.findChildren(type, QRegExp) -> list-of-QObject QObject.findChildren(tuple, QRegExp) -> list-of-QObject

get_shape()

Reimplemented RectangularActionTool method

inherits(str) → bool
installEventFilter(QObject)
isWidgetType() → bool
killTimer(int)
metaObject() → QMetaObject
moveToThread(QThread)
objectName() → str
parent() → QObject
property(str) → object
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(SIGNAL()) → int
removeEventFilter(QObject)
sender() → QObject
senderSignalIndex() → int
setObjectName(str)
setParent(QObject)
setProperty(str, object) → 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() → bool
startTimer(int) → int
thread() → QThread
timerEvent(QTimerEvent)
tr(str, str disambiguation=None, int n=-1) → str
trUtf8(str, str disambiguation=None, int n=-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)[source]
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(bool) → bool
childEvent(QChildEvent)
children() → list-of-QObject
connect(QObject, SIGNAL(), QObject, SLOT(), Qt.ConnectionType=Qt.AutoConnection) → bool

QObject.connect(QObject, SIGNAL(), callable, Qt.ConnectionType=Qt.AutoConnection) -> bool QObject.connect(QObject, SIGNAL(), SLOT(), Qt.ConnectionType=Qt.AutoConnection) -> bool

connectNotify(SIGNAL())
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(QEvent)
deactivate()

Deactivate tool

deleteLater()
destroyed

QObject.destroyed[QObject] [signal] QObject.destroyed [signal]

disconnect(QObject, SIGNAL(), QObject, SLOT()) → bool

QObject.disconnect(QObject, SIGNAL(), callable) -> bool

disconnectNotify(SIGNAL())
dumpObjectInfo()
dumpObjectTree()
dynamicPropertyNames() → list-of-QByteArray
emit(SIGNAL(), ...)
event(QEvent) → bool
eventFilter(QObject, QEvent) → bool
findChild(type, str name='') → QObject

QObject.findChild(tuple, str name=’‘) -> QObject

findChildren(type, str name='') → list-of-QObject

QObject.findChildren(tuple, str name=’‘) -> list-of-QObject QObject.findChildren(type, QRegExp) -> list-of-QObject QObject.findChildren(tuple, QRegExp) -> list-of-QObject

get_shape()

Reimplemented RectangularActionTool method

handle_final_shape(shape)

To be reimplemented

inherits(str) → bool
installEventFilter(QObject)
isWidgetType() → bool
killTimer(int)
metaObject() → QMetaObject
moveToThread(QThread)
objectName() → str
parent() → QObject
property(str) → object
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(SIGNAL()) → int
removeEventFilter(QObject)
sender() → QObject
senderSignalIndex() → int
setObjectName(str)
setParent(QObject)
setProperty(str, object) → 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() → bool
startTimer(int) → int
thread() → QThread
timerEvent(QTimerEvent)
tr(str, str disambiguation=None, int n=-1) → str
trUtf8(str, str disambiguation=None, int n=-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)[source]
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(bool) → bool
childEvent(QChildEvent)
children() → list-of-QObject
connect(QObject, SIGNAL(), QObject, SLOT(), Qt.ConnectionType=Qt.AutoConnection) → bool

QObject.connect(QObject, SIGNAL(), callable, Qt.ConnectionType=Qt.AutoConnection) -> bool QObject.connect(QObject, SIGNAL(), SLOT(), Qt.ConnectionType=Qt.AutoConnection) -> bool

connectNotify(SIGNAL())
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(QEvent)
deactivate()

Deactivate tool

deleteLater()
destroyed

QObject.destroyed[QObject] [signal] QObject.destroyed [signal]

disconnect(QObject, SIGNAL(), QObject, SLOT()) → bool

QObject.disconnect(QObject, SIGNAL(), callable) -> bool

disconnectNotify(SIGNAL())
dumpObjectInfo()
dumpObjectTree()
dynamicPropertyNames() → list-of-QByteArray
emit(SIGNAL(), ...)
event(QEvent) → bool
eventFilter(QObject, QEvent) → bool
findChild(type, str name='') → QObject

QObject.findChild(tuple, str name=’‘) -> QObject

findChildren(type, str name='') → list-of-QObject

QObject.findChildren(tuple, str name=’‘) -> list-of-QObject QObject.findChildren(type, QRegExp) -> list-of-QObject QObject.findChildren(tuple, QRegExp) -> list-of-QObject

get_shape()

Reimplemented RectangularActionTool method

handle_final_shape(shape)

To be reimplemented

inherits(str) → bool
installEventFilter(QObject)
isWidgetType() → bool
killTimer(int)
metaObject() → QMetaObject
moveToThread(QThread)
objectName() → str
parent() → QObject
property(str) → object
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(SIGNAL()) → int
removeEventFilter(QObject)
sender() → QObject
senderSignalIndex() → int
setObjectName(str)
setParent(QObject)
setProperty(str, object) → 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() → bool
startTimer(int) → int
thread() → QThread
timerEvent(QTimerEvent)
tr(str, str disambiguation=None, int n=-1) → str
trUtf8(str, str disambiguation=None, int n=-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)[source]
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(bool) → bool
childEvent(QChildEvent)
children() → list-of-QObject
connect(QObject, SIGNAL(), QObject, SLOT(), Qt.ConnectionType=Qt.AutoConnection) → bool

QObject.connect(QObject, SIGNAL(), callable, Qt.ConnectionType=Qt.AutoConnection) -> bool QObject.connect(QObject, SIGNAL(), SLOT(), Qt.ConnectionType=Qt.AutoConnection) -> bool

connectNotify(SIGNAL())
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(QEvent)
deactivate()

Deactivate tool

deleteLater()
destroyed

QObject.destroyed[QObject] [signal] QObject.destroyed [signal]

disconnect(QObject, SIGNAL(), QObject, SLOT()) → bool

QObject.disconnect(QObject, SIGNAL(), callable) -> bool

disconnectNotify(SIGNAL())
dumpObjectInfo()
dumpObjectTree()
dynamicPropertyNames() → list-of-QByteArray
emit(SIGNAL(), ...)
event(QEvent) → bool
eventFilter(QObject, QEvent) → bool
findChild(type, str name='') → QObject

QObject.findChild(tuple, str name=’‘) -> QObject

findChildren(type, str name='') → list-of-QObject

QObject.findChildren(tuple, str name=’‘) -> list-of-QObject QObject.findChildren(type, QRegExp) -> list-of-QObject QObject.findChildren(tuple, QRegExp) -> list-of-QObject

get_shape()

Reimplemented RectangularActionTool method

handle_final_shape(shape)

To be reimplemented

inherits(str) → bool
installEventFilter(QObject)
isWidgetType() → bool
killTimer(int)
metaObject() → QMetaObject
moveToThread(QThread)
objectName() → str
parent() → QObject
property(str) → object
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(SIGNAL()) → int
removeEventFilter(QObject)
sender() → QObject
senderSignalIndex() → int
setObjectName(str)
setParent(QObject)
setProperty(str, object) → 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() → bool
startTimer(int) → int
thread() → QThread
timerEvent(QTimerEvent)
tr(str, str disambiguation=None, int n=-1) → str
trUtf8(str, str disambiguation=None, int n=-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)[source]
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(bool) → bool
childEvent(QChildEvent)
children() → list-of-QObject
connect(QObject, SIGNAL(), QObject, SLOT(), Qt.ConnectionType=Qt.AutoConnection) → bool

QObject.connect(QObject, SIGNAL(), callable, Qt.ConnectionType=Qt.AutoConnection) -> bool QObject.connect(QObject, SIGNAL(), SLOT(), Qt.ConnectionType=Qt.AutoConnection) -> bool

connectNotify(SIGNAL())
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(QEvent)
deactivate()

Deactivate tool

deleteLater()
destroyed

QObject.destroyed[QObject] [signal] QObject.destroyed [signal]

disconnect(QObject, SIGNAL(), QObject, SLOT()) → bool

QObject.disconnect(QObject, SIGNAL(), callable) -> bool

disconnectNotify(SIGNAL())
dumpObjectInfo()
dumpObjectTree()
dynamicPropertyNames() → list-of-QByteArray
emit(SIGNAL(), ...)
event(QEvent) → bool
eventFilter(QObject, QEvent) → bool
findChild(type, str name='') → QObject

QObject.findChild(tuple, str name=’‘) -> QObject

findChildren(type, str name='') → list-of-QObject

QObject.findChildren(tuple, str name=’‘) -> list-of-QObject QObject.findChildren(type, QRegExp) -> list-of-QObject QObject.findChildren(tuple, QRegExp) -> list-of-QObject

get_shape()

Reimplemented RectangularActionTool method

inherits(str) → bool
installEventFilter(QObject)
isWidgetType() → bool
killTimer(int)
metaObject() → QMetaObject
moveToThread(QThread)
objectName() → str
parent() → QObject
property(str) → object
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(SIGNAL()) → int
removeEventFilter(QObject)
sender() → QObject
senderSignalIndex() → int
setObjectName(str)
setParent(QObject)
setProperty(str, object) → 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() → bool
startTimer(int) → int
thread() → QThread
timerEvent(QTimerEvent)
tr(str, str disambiguation=None, int n=-1) → str
trUtf8(str, str disambiguation=None, int n=-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)[source]
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(bool) → bool
childEvent(QChildEvent)
children() → list-of-QObject
connect(QObject, SIGNAL(), QObject, SLOT(), Qt.ConnectionType=Qt.AutoConnection) → bool

QObject.connect(QObject, SIGNAL(), callable, Qt.ConnectionType=Qt.AutoConnection) -> bool QObject.connect(QObject, SIGNAL(), SLOT(), Qt.ConnectionType=Qt.AutoConnection) -> bool

connectNotify(SIGNAL())
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(QEvent)
deactivate()

Deactivate tool

deleteLater()
destroyed

QObject.destroyed[QObject] [signal] QObject.destroyed [signal]

disconnect(QObject, SIGNAL(), QObject, SLOT()) → bool

QObject.disconnect(QObject, SIGNAL(), callable) -> bool

disconnectNotify(SIGNAL())
dumpObjectInfo()
dumpObjectTree()
dynamicPropertyNames() → list-of-QByteArray
emit(SIGNAL(), ...)
event(QEvent) → bool
eventFilter(QObject, QEvent) → bool
findChild(type, str name='') → QObject

QObject.findChild(tuple, str name=’‘) -> QObject

findChildren(type, str name='') → list-of-QObject

QObject.findChildren(tuple, str name=’‘) -> list-of-QObject QObject.findChildren(type, QRegExp) -> list-of-QObject QObject.findChildren(tuple, QRegExp) -> list-of-QObject

get_shape()

Reimplemented RectangularActionTool method

handle_final_shape(shape)

To be reimplemented

inherits(str) → bool
installEventFilter(QObject)
isWidgetType() → bool
killTimer(int)
metaObject() → QMetaObject
moveToThread(QThread)
objectName() → str
parent() → QObject
property(str) → object
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(SIGNAL()) → int
removeEventFilter(QObject)
sender() → QObject
senderSignalIndex() → int
setObjectName(str)
setParent(QObject)
setProperty(str, object) → 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() → bool
startTimer(int) → int
thread() → QThread
timerEvent(QTimerEvent)
tr(str, str disambiguation=None, int n=-1) → str
trUtf8(str, str disambiguation=None, int n=-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)[source]
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(bool) → bool
childEvent(QChildEvent)
children() → list-of-QObject
connect(QObject, SIGNAL(), QObject, SLOT(), Qt.ConnectionType=Qt.AutoConnection) → bool

QObject.connect(QObject, SIGNAL(), callable, Qt.ConnectionType=Qt.AutoConnection) -> bool QObject.connect(QObject, SIGNAL(), SLOT(), Qt.ConnectionType=Qt.AutoConnection) -> bool

connectNotify(SIGNAL())
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(QEvent)
deactivate()

Deactivate tool

deleteLater()
destroyed

QObject.destroyed[QObject] [signal] QObject.destroyed [signal]

disconnect(QObject, SIGNAL(), QObject, SLOT()) → bool

QObject.disconnect(QObject, SIGNAL(), callable) -> bool

disconnectNotify(SIGNAL())
dumpObjectInfo()
dumpObjectTree()
dynamicPropertyNames() → list-of-QByteArray
emit(SIGNAL(), ...)
event(QEvent) → bool
eventFilter(QObject, QEvent) → bool
findChild(type, str name='') → QObject

QObject.findChild(tuple, str name=’‘) -> QObject

findChildren(type, str name='') → list-of-QObject

QObject.findChildren(tuple, str name=’‘) -> list-of-QObject QObject.findChildren(type, QRegExp) -> list-of-QObject QObject.findChildren(tuple, QRegExp) -> list-of-QObject

get_shape()

Reimplemented RectangularActionTool method

handle_final_shape(shape)

To be reimplemented

inherits(str) → bool
installEventFilter(QObject)
isWidgetType() → bool
killTimer(int)
metaObject() → QMetaObject
moveToThread(QThread)
objectName() → str
parent() → QObject
property(str) → object
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(SIGNAL()) → int
removeEventFilter(QObject)
sender() → QObject
senderSignalIndex() → int
setObjectName(str)
setParent(QObject)
setProperty(str, object) → 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() → bool
startTimer(int) → int
thread() → QThread
timerEvent(QTimerEvent)
tr(str, str disambiguation=None, int n=-1) → str
trUtf8(str, str disambiguation=None, int n=-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)[source]
activate()

Activate tool

blockSignals(bool) → bool
childEvent(QChildEvent)
children() → list-of-QObject
connect(QObject, SIGNAL(), QObject, SLOT(), Qt.ConnectionType=Qt.AutoConnection) → bool

QObject.connect(QObject, SIGNAL(), callable, Qt.ConnectionType=Qt.AutoConnection) -> bool QObject.connect(QObject, SIGNAL(), SLOT(), Qt.ConnectionType=Qt.AutoConnection) -> bool

connectNotify(SIGNAL())
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(QEvent)
deactivate()

Deactivate tool

deleteLater()
destroyed

QObject.destroyed[QObject] [signal] QObject.destroyed [signal]

disconnect(QObject, SIGNAL(), QObject, SLOT()) → bool

QObject.disconnect(QObject, SIGNAL(), callable) -> bool

disconnectNotify(SIGNAL())
dumpObjectInfo()
dumpObjectTree()
dynamicPropertyNames() → list-of-QByteArray
emit(SIGNAL(), ...)
event(QEvent) → bool
eventFilter(QObject, QEvent) → bool
findChild(type, str name='') → QObject

QObject.findChild(tuple, str name=’‘) -> QObject

findChildren(type, str name='') → list-of-QObject

QObject.findChildren(tuple, str name=’‘) -> list-of-QObject QObject.findChildren(type, QRegExp) -> list-of-QObject QObject.findChildren(tuple, QRegExp) -> list-of-QObject

inherits(str) → bool
installEventFilter(QObject)
isWidgetType() → bool
killTimer(int)
metaObject() → QMetaObject
moveToThread(QThread)
objectName() → str
parent() → QObject
property(str) → object
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(SIGNAL()) → int
removeEventFilter(QObject)
sender() → QObject
senderSignalIndex() → int
setObjectName(str)
setParent(QObject)
setProperty(str, object) → 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() → bool
startTimer(int) → int
thread() → QThread
timerEvent(QTimerEvent)
tr(str, str disambiguation=None, int n=-1) → str
trUtf8(str, str disambiguation=None, int n=-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'>)[source]
setup_toolbar(toolbar)[source]

Setup tool’s toolbar

blockSignals(bool) → bool
childEvent(QChildEvent)
children() → list-of-QObject
connect(QObject, SIGNAL(), QObject, SLOT(), Qt.ConnectionType=Qt.AutoConnection) → bool

QObject.connect(QObject, SIGNAL(), callable, Qt.ConnectionType=Qt.AutoConnection) -> bool QObject.connect(QObject, SIGNAL(), SLOT(), Qt.ConnectionType=Qt.AutoConnection) -> bool

connectNotify(SIGNAL())
create_action(manager)

Create and return tool’s action

create_action_menu(manager)

Create and return menu for the tool’s action

customEvent(QEvent)
deleteLater()
destroyed

QObject.destroyed[QObject] [signal] QObject.destroyed [signal]

disconnect(QObject, SIGNAL(), QObject, SLOT()) → bool

QObject.disconnect(QObject, SIGNAL(), callable) -> bool

disconnectNotify(SIGNAL())
dumpObjectInfo()
dumpObjectTree()
dynamicPropertyNames() → list-of-QByteArray
emit(SIGNAL(), ...)
event(QEvent) → bool
eventFilter(QObject, QEvent) → bool
findChild(type, str name='') → QObject

QObject.findChild(tuple, str name=’‘) -> QObject

findChildren(type, str name='') → list-of-QObject

QObject.findChildren(tuple, str name=’‘) -> list-of-QObject QObject.findChildren(type, QRegExp) -> list-of-QObject QObject.findChildren(tuple, QRegExp) -> list-of-QObject

inherits(str) → bool
installEventFilter(QObject)
isWidgetType() → bool
killTimer(int)
metaObject() → QMetaObject
moveToThread(QThread)
objectName() → str
parent() → QObject
property(str) → object
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(SIGNAL()) → int
register_plot(baseplot)

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

removeEventFilter(QObject)
sender() → QObject
senderSignalIndex() → int
setObjectName(str)
setParent(QObject)
setProperty(str, object) → bool
set_parent_tool(tool)

Used to organize tools automatically in menu items

signalsBlocked() → bool
startTimer(int) → int
thread() → QThread
timerEvent(QTimerEvent)
tr(str, str disambiguation=None, int n=-1) → str
trUtf8(str, str disambiguation=None, int n=-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)[source]
activate_command(plot, checked)[source]

Activate tool

blockSignals(bool) → bool
childEvent(QChildEvent)
children() → list-of-QObject
connect(QObject, SIGNAL(), QObject, SLOT(), Qt.ConnectionType=Qt.AutoConnection) → bool

QObject.connect(QObject, SIGNAL(), callable, Qt.ConnectionType=Qt.AutoConnection) -> bool QObject.connect(QObject, SIGNAL(), SLOT(), Qt.ConnectionType=Qt.AutoConnection) -> bool

connectNotify(SIGNAL())
create_action(manager)

Create and return tool’s action

create_action_menu(manager)

Create and return menu for the tool’s action

customEvent(QEvent)
deleteLater()
destroyed

QObject.destroyed[QObject] [signal] QObject.destroyed [signal]

disconnect(QObject, SIGNAL(), QObject, SLOT()) → bool

QObject.disconnect(QObject, SIGNAL(), callable) -> bool

disconnectNotify(SIGNAL())
dumpObjectInfo()
dumpObjectTree()
dynamicPropertyNames() → list-of-QByteArray
emit(SIGNAL(), ...)
event(QEvent) → bool
eventFilter(QObject, QEvent) → bool
findChild(type, str name='') → QObject

QObject.findChild(tuple, str name=’‘) -> QObject

findChildren(type, str name='') → list-of-QObject

QObject.findChildren(tuple, str name=’‘) -> list-of-QObject QObject.findChildren(type, QRegExp) -> list-of-QObject QObject.findChildren(tuple, QRegExp) -> list-of-QObject

inherits(str) → bool
installEventFilter(QObject)
isWidgetType() → bool
killTimer(int)
metaObject() → QMetaObject
moveToThread(QThread)
objectName() → str
parent() → QObject
property(str) → object
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(SIGNAL()) → int
register_plot(baseplot)

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

removeEventFilter(QObject)
sender() → QObject
senderSignalIndex() → int
setObjectName(str)
setParent(QObject)
setProperty(str, object) → bool
set_parent_tool(tool)

Used to organize tools automatically in menu items

setup_toolbar(toolbar)

Setup tool’s toolbar

signalsBlocked() → bool
startTimer(int) → int
thread() → QThread
timerEvent(QTimerEvent)
tr(str, str disambiguation=None, int n=-1) → str
trUtf8(str, str disambiguation=None, int n=-1) → str
class guiqwt.tools.DisplayCoordsTool(manager)[source]
create_action_menu(manager)[source]

Create and return menu for the tool’s action

blockSignals(bool) → bool
childEvent(QChildEvent)
children() → list-of-QObject
connect(QObject, SIGNAL(), QObject, SLOT(), Qt.ConnectionType=Qt.AutoConnection) → bool

QObject.connect(QObject, SIGNAL(), callable, Qt.ConnectionType=Qt.AutoConnection) -> bool QObject.connect(QObject, SIGNAL(), SLOT(), Qt.ConnectionType=Qt.AutoConnection) -> bool

connectNotify(SIGNAL())
create_action(manager)

Create and return tool’s action

customEvent(QEvent)
deleteLater()
destroyed

QObject.destroyed[QObject] [signal] QObject.destroyed [signal]

disconnect(QObject, SIGNAL(), QObject, SLOT()) → bool

QObject.disconnect(QObject, SIGNAL(), callable) -> bool

disconnectNotify(SIGNAL())
dumpObjectInfo()
dumpObjectTree()
dynamicPropertyNames() → list-of-QByteArray
emit(SIGNAL(), ...)
event(QEvent) → bool
eventFilter(QObject, QEvent) → bool
findChild(type, str name='') → QObject

QObject.findChild(tuple, str name=’‘) -> QObject

findChildren(type, str name='') → list-of-QObject

QObject.findChildren(tuple, str name=’‘) -> list-of-QObject QObject.findChildren(type, QRegExp) -> list-of-QObject QObject.findChildren(tuple, QRegExp) -> list-of-QObject

inherits(str) → bool
installEventFilter(QObject)
isWidgetType() → bool
killTimer(int)
metaObject() → QMetaObject
moveToThread(QThread)
objectName() → str
parent() → QObject
property(str) → object
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(SIGNAL()) → int
register_plot(baseplot)

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

removeEventFilter(QObject)
sender() → QObject
senderSignalIndex() → int
setObjectName(str)
setParent(QObject)
setProperty(str, object) → bool
set_parent_tool(tool)

Used to organize tools automatically in menu items

setup_toolbar(toolbar)

Setup tool’s toolbar

signalsBlocked() → bool
startTimer(int) → int
thread() → QThread
timerEvent(QTimerEvent)
tr(str, str disambiguation=None, int n=-1) → str
trUtf8(str, str disambiguation=None, int n=-1) → str
class guiqwt.tools.ReverseYAxisTool(manager)[source]
activate_command(plot, checked)[source]

Activate tool

blockSignals(bool) → bool
childEvent(QChildEvent)
children() → list-of-QObject
connect(QObject, SIGNAL(), QObject, SLOT(), Qt.ConnectionType=Qt.AutoConnection) → bool

QObject.connect(QObject, SIGNAL(), callable, Qt.ConnectionType=Qt.AutoConnection) -> bool QObject.connect(QObject, SIGNAL(), SLOT(), Qt.ConnectionType=Qt.AutoConnection) -> bool

connectNotify(SIGNAL())
create_action(manager)

Create and return tool’s action

create_action_menu(manager)

Create and return menu for the tool’s action

customEvent(QEvent)
deleteLater()
destroyed

QObject.destroyed[QObject] [signal] QObject.destroyed [signal]

disconnect(QObject, SIGNAL(), QObject, SLOT()) → bool

QObject.disconnect(QObject, SIGNAL(), callable) -> bool

disconnectNotify(SIGNAL())
dumpObjectInfo()
dumpObjectTree()
dynamicPropertyNames() → list-of-QByteArray
emit(SIGNAL(), ...)
event(QEvent) → bool
eventFilter(QObject, QEvent) → bool
findChild(type, str name='') → QObject

QObject.findChild(tuple, str name=’‘) -> QObject

findChildren(type, str name='') → list-of-QObject

QObject.findChildren(tuple, str name=’‘) -> list-of-QObject QObject.findChildren(type, QRegExp) -> list-of-QObject QObject.findChildren(tuple, QRegExp) -> list-of-QObject

inherits(str) → bool
installEventFilter(QObject)
isWidgetType() → bool
killTimer(int)
metaObject() → QMetaObject
moveToThread(QThread)
objectName() → str
parent() → QObject
property(str) → object
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(SIGNAL()) → int
register_plot(baseplot)

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

removeEventFilter(QObject)
sender() → QObject
senderSignalIndex() → int
setObjectName(str)
setParent(QObject)
setProperty(str, object) → bool
set_parent_tool(tool)

Used to organize tools automatically in menu items

setup_toolbar(toolbar)

Setup tool’s toolbar

signalsBlocked() → bool
startTimer(int) → int
thread() → QThread
timerEvent(QTimerEvent)
tr(str, str disambiguation=None, int n=-1) → str
trUtf8(str, str disambiguation=None, int n=-1) → str
class guiqwt.tools.AspectRatioTool(manager)[source]
create_action_menu(manager)[source]

Create and return menu for the tool’s action

activate_command(plot, checked)[source]

Activate tool

lock_aspect_ratio(checked)[source]

Lock aspect ratio

blockSignals(bool) → bool
childEvent(QChildEvent)
children() → list-of-QObject
connect(QObject, SIGNAL(), QObject, SLOT(), Qt.ConnectionType=Qt.AutoConnection) → bool

QObject.connect(QObject, SIGNAL(), callable, Qt.ConnectionType=Qt.AutoConnection) -> bool QObject.connect(QObject, SIGNAL(), SLOT(), Qt.ConnectionType=Qt.AutoConnection) -> bool

connectNotify(SIGNAL())
create_action(manager)

Create and return tool’s action

customEvent(QEvent)
deleteLater()
destroyed

QObject.destroyed[QObject] [signal] QObject.destroyed [signal]

disconnect(QObject, SIGNAL(), QObject, SLOT()) → bool

QObject.disconnect(QObject, SIGNAL(), callable) -> bool

disconnectNotify(SIGNAL())
dumpObjectInfo()
dumpObjectTree()
dynamicPropertyNames() → list-of-QByteArray
emit(SIGNAL(), ...)
event(QEvent) → bool
eventFilter(QObject, QEvent) → bool
findChild(type, str name='') → QObject

QObject.findChild(tuple, str name=’‘) -> QObject

findChildren(type, str name='') → list-of-QObject

QObject.findChildren(tuple, str name=’‘) -> list-of-QObject QObject.findChildren(type, QRegExp) -> list-of-QObject QObject.findChildren(tuple, QRegExp) -> list-of-QObject

inherits(str) → bool
installEventFilter(QObject)
isWidgetType() → bool
killTimer(int)
metaObject() → QMetaObject
moveToThread(QThread)
objectName() → str
parent() → QObject
property(str) → object
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(SIGNAL()) → int
register_plot(baseplot)

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

removeEventFilter(QObject)
sender() → QObject
senderSignalIndex() → int
setObjectName(str)
setParent(QObject)
setProperty(str, object) → bool
set_parent_tool(tool)

Used to organize tools automatically in menu items

setup_toolbar(toolbar)

Setup tool’s toolbar

signalsBlocked() → bool
startTimer(int) → int
thread() → QThread
timerEvent(QTimerEvent)
tr(str, str disambiguation=None, int n=-1) → str
trUtf8(str, str disambiguation=None, int n=-1) → str
class guiqwt.tools.PanelTool(manager)[source]
activate_command(plot, checked)[source]

Activate tool

blockSignals(bool) → bool
childEvent(QChildEvent)
children() → list-of-QObject
connect(QObject, SIGNAL(), QObject, SLOT(), Qt.ConnectionType=Qt.AutoConnection) → bool

QObject.connect(QObject, SIGNAL(), callable, Qt.ConnectionType=Qt.AutoConnection) -> bool QObject.connect(QObject, SIGNAL(), SLOT(), Qt.ConnectionType=Qt.AutoConnection) -> bool

connectNotify(SIGNAL())
create_action(manager)

Create and return tool’s action

create_action_menu(manager)

Create and return menu for the tool’s action

customEvent(QEvent)
deleteLater()
destroyed

QObject.destroyed[QObject] [signal] QObject.destroyed [signal]

disconnect(QObject, SIGNAL(), QObject, SLOT()) → bool

QObject.disconnect(QObject, SIGNAL(), callable) -> bool

disconnectNotify(SIGNAL())
dumpObjectInfo()
dumpObjectTree()
dynamicPropertyNames() → list-of-QByteArray
emit(SIGNAL(), ...)
event(QEvent) → bool
eventFilter(QObject, QEvent) → bool
findChild(type, str name='') → QObject

QObject.findChild(tuple, str name=’‘) -> QObject

findChildren(type, str name='') → list-of-QObject

QObject.findChildren(tuple, str name=’‘) -> list-of-QObject QObject.findChildren(type, QRegExp) -> list-of-QObject QObject.findChildren(tuple, QRegExp) -> list-of-QObject

inherits(str) → bool
installEventFilter(QObject)
isWidgetType() → bool
killTimer(int)
metaObject() → QMetaObject
moveToThread(QThread)
objectName() → str
parent() → QObject
property(str) → object
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(SIGNAL()) → int
register_plot(baseplot)

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

removeEventFilter(QObject)
sender() → QObject
senderSignalIndex() → int
setObjectName(str)
setParent(QObject)
setProperty(str, object) → bool
set_parent_tool(tool)

Used to organize tools automatically in menu items

setup_toolbar(toolbar)

Setup tool’s toolbar

signalsBlocked() → bool
startTimer(int) → int
thread() → QThread
timerEvent(QTimerEvent)
tr(str, str disambiguation=None, int n=-1) → str
trUtf8(str, str disambiguation=None, int n=-1) → str
class guiqwt.tools.ItemListPanelTool(manager)[source]
activate_command(plot, checked)

Activate tool

blockSignals(bool) → bool
childEvent(QChildEvent)
children() → list-of-QObject
connect(QObject, SIGNAL(), QObject, SLOT(), Qt.ConnectionType=Qt.AutoConnection) → bool

QObject.connect(QObject, SIGNAL(), callable, Qt.ConnectionType=Qt.AutoConnection) -> bool QObject.connect(QObject, SIGNAL(), SLOT(), Qt.ConnectionType=Qt.AutoConnection) -> bool

connectNotify(SIGNAL())
create_action(manager)

Create and return tool’s action

create_action_menu(manager)

Create and return menu for the tool’s action

customEvent(QEvent)
deleteLater()
destroyed

QObject.destroyed[QObject] [signal] QObject.destroyed [signal]

disconnect(QObject, SIGNAL(), QObject, SLOT()) → bool

QObject.disconnect(QObject, SIGNAL(), callable) -> bool

disconnectNotify(SIGNAL())
dumpObjectInfo()
dumpObjectTree()
dynamicPropertyNames() → list-of-QByteArray
emit(SIGNAL(), ...)
event(QEvent) → bool
eventFilter(QObject, QEvent) → bool
findChild(type, str name='') → QObject

QObject.findChild(tuple, str name=’‘) -> QObject

findChildren(type, str name='') → list-of-QObject

QObject.findChildren(tuple, str name=’‘) -> list-of-QObject QObject.findChildren(type, QRegExp) -> list-of-QObject QObject.findChildren(tuple, QRegExp) -> list-of-QObject

inherits(str) → bool
installEventFilter(QObject)
isWidgetType() → bool
killTimer(int)
metaObject() → QMetaObject
moveToThread(QThread)
objectName() → str
parent() → QObject
property(str) → object
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(SIGNAL()) → int
register_plot(baseplot)

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

removeEventFilter(QObject)
sender() → QObject
senderSignalIndex() → int
setObjectName(str)
setParent(QObject)
setProperty(str, object) → bool
set_parent_tool(tool)

Used to organize tools automatically in menu items

setup_toolbar(toolbar)

Setup tool’s toolbar

signalsBlocked() → bool
startTimer(int) → int
thread() → QThread
timerEvent(QTimerEvent)
tr(str, str disambiguation=None, int n=-1) → str
trUtf8(str, str disambiguation=None, int n=-1) → str
class guiqwt.tools.ContrastPanelTool(manager)[source]
activate_command(plot, checked)

Activate tool

blockSignals(bool) → bool
childEvent(QChildEvent)
children() → list-of-QObject
connect(QObject, SIGNAL(), QObject, SLOT(), Qt.ConnectionType=Qt.AutoConnection) → bool

QObject.connect(QObject, SIGNAL(), callable, Qt.ConnectionType=Qt.AutoConnection) -> bool QObject.connect(QObject, SIGNAL(), SLOT(), Qt.ConnectionType=Qt.AutoConnection) -> bool

connectNotify(SIGNAL())
create_action(manager)

Create and return tool’s action

create_action_menu(manager)

Create and return menu for the tool’s action

customEvent(QEvent)
deleteLater()
destroyed

QObject.destroyed[QObject] [signal] QObject.destroyed [signal]

disconnect(QObject, SIGNAL(), QObject, SLOT()) → bool

QObject.disconnect(QObject, SIGNAL(), callable) -> bool

disconnectNotify(SIGNAL())
dumpObjectInfo()
dumpObjectTree()
dynamicPropertyNames() → list-of-QByteArray
emit(SIGNAL(), ...)
event(QEvent) → bool
eventFilter(QObject, QEvent) → bool
findChild(type, str name='') → QObject

QObject.findChild(tuple, str name=’‘) -> QObject

findChildren(type, str name='') → list-of-QObject

QObject.findChildren(tuple, str name=’‘) -> list-of-QObject QObject.findChildren(type, QRegExp) -> list-of-QObject QObject.findChildren(tuple, QRegExp) -> list-of-QObject

inherits(str) → bool
installEventFilter(QObject)
isWidgetType() → bool
killTimer(int)
metaObject() → QMetaObject
moveToThread(QThread)
objectName() → str
parent() → QObject
property(str) → object
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(SIGNAL()) → int
register_plot(baseplot)

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

removeEventFilter(QObject)
sender() → QObject
senderSignalIndex() → int
setObjectName(str)
setParent(QObject)
setProperty(str, object) → bool
set_parent_tool(tool)

Used to organize tools automatically in menu items

setup_toolbar(toolbar)

Setup tool’s toolbar

signalsBlocked() → bool
startTimer(int) → int
thread() → QThread
timerEvent(QTimerEvent)
tr(str, str disambiguation=None, int n=-1) → str
trUtf8(str, str disambiguation=None, int n=-1) → str
class guiqwt.tools.ColormapTool(manager, toolbar_id=<class 'guiqwt.tools.DefaultToolbarID'>)[source]
create_action_menu(manager)[source]

Create and return menu for the tool’s action

activate_command(plot, checked)[source]

Activate tool

blockSignals(bool) → bool
childEvent(QChildEvent)
children() → list-of-QObject
connect(QObject, SIGNAL(), QObject, SLOT(), Qt.ConnectionType=Qt.AutoConnection) → bool

QObject.connect(QObject, SIGNAL(), callable, Qt.ConnectionType=Qt.AutoConnection) -> bool QObject.connect(QObject, SIGNAL(), SLOT(), Qt.ConnectionType=Qt.AutoConnection) -> bool

connectNotify(SIGNAL())
create_action(manager)

Create and return tool’s action

customEvent(QEvent)
deleteLater()
destroyed

QObject.destroyed[QObject] [signal] QObject.destroyed [signal]

disconnect(QObject, SIGNAL(), QObject, SLOT()) → bool

QObject.disconnect(QObject, SIGNAL(), callable) -> bool

disconnectNotify(SIGNAL())
dumpObjectInfo()
dumpObjectTree()
dynamicPropertyNames() → list-of-QByteArray
emit(SIGNAL(), ...)
event(QEvent) → bool
eventFilter(QObject, QEvent) → bool
findChild(type, str name='') → QObject

QObject.findChild(tuple, str name=’‘) -> QObject

findChildren(type, str name='') → list-of-QObject

QObject.findChildren(tuple, str name=’‘) -> list-of-QObject QObject.findChildren(type, QRegExp) -> list-of-QObject QObject.findChildren(tuple, QRegExp) -> list-of-QObject

inherits(str) → bool
installEventFilter(QObject)
isWidgetType() → bool
killTimer(int)
metaObject() → QMetaObject
moveToThread(QThread)
objectName() → str
parent() → QObject
property(str) → object
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(SIGNAL()) → int
register_plot(baseplot)

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

removeEventFilter(QObject)
sender() → QObject
senderSignalIndex() → int
setObjectName(str)
setParent(QObject)
setProperty(str, object) → bool
set_parent_tool(tool)

Used to organize tools automatically in menu items

setup_toolbar(toolbar)

Setup tool’s toolbar

signalsBlocked() → bool
startTimer(int) → int
thread() → QThread
timerEvent(QTimerEvent)
tr(str, str disambiguation=None, int n=-1) → str
trUtf8(str, str disambiguation=None, int n=-1) → str
class guiqwt.tools.XCSPanelTool(manager)[source]
activate_command(plot, checked)

Activate tool

blockSignals(bool) → bool
childEvent(QChildEvent)
children() → list-of-QObject
connect(QObject, SIGNAL(), QObject, SLOT(), Qt.ConnectionType=Qt.AutoConnection) → bool

QObject.connect(QObject, SIGNAL(), callable, Qt.ConnectionType=Qt.AutoConnection) -> bool QObject.connect(QObject, SIGNAL(), SLOT(), Qt.ConnectionType=Qt.AutoConnection) -> bool

connectNotify(SIGNAL())
create_action(manager)

Create and return tool’s action

create_action_menu(manager)

Create and return menu for the tool’s action

customEvent(QEvent)
deleteLater()
destroyed

QObject.destroyed[QObject] [signal] QObject.destroyed [signal]

disconnect(QObject, SIGNAL(), QObject, SLOT()) → bool

QObject.disconnect(QObject, SIGNAL(), callable) -> bool

disconnectNotify(SIGNAL())
dumpObjectInfo()
dumpObjectTree()
dynamicPropertyNames() → list-of-QByteArray
emit(SIGNAL(), ...)
event(QEvent) → bool
eventFilter(QObject, QEvent) → bool
findChild(type, str name='') → QObject

QObject.findChild(tuple, str name=’‘) -> QObject

findChildren(type, str name='') → list-of-QObject

QObject.findChildren(tuple, str name=’‘) -> list-of-QObject QObject.findChildren(type, QRegExp) -> list-of-QObject QObject.findChildren(tuple, QRegExp) -> list-of-QObject

inherits(str) → bool
installEventFilter(QObject)
isWidgetType() → bool
killTimer(int)
metaObject() → QMetaObject
moveToThread(QThread)
objectName() → str
parent() → QObject
property(str) → object
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(SIGNAL()) → int
register_plot(baseplot)

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

removeEventFilter(QObject)
sender() → QObject
senderSignalIndex() → int
setObjectName(str)
setParent(QObject)
setProperty(str, object) → bool
set_parent_tool(tool)

Used to organize tools automatically in menu items

setup_toolbar(toolbar)

Setup tool’s toolbar

signalsBlocked() → bool
startTimer(int) → int
thread() → QThread
timerEvent(QTimerEvent)
tr(str, str disambiguation=None, int n=-1) → str
trUtf8(str, str disambiguation=None, int n=-1) → str
class guiqwt.tools.YCSPanelTool(manager)[source]
activate_command(plot, checked)

Activate tool

blockSignals(bool) → bool
childEvent(QChildEvent)
children() → list-of-QObject
connect(QObject, SIGNAL(), QObject, SLOT(), Qt.ConnectionType=Qt.AutoConnection) → bool

QObject.connect(QObject, SIGNAL(), callable, Qt.ConnectionType=Qt.AutoConnection) -> bool QObject.connect(QObject, SIGNAL(), SLOT(), Qt.ConnectionType=Qt.AutoConnection) -> bool

connectNotify(SIGNAL())
create_action(manager)

Create and return tool’s action

create_action_menu(manager)

Create and return menu for the tool’s action

customEvent(QEvent)
deleteLater()
destroyed

QObject.destroyed[QObject] [signal] QObject.destroyed [signal]

disconnect(QObject, SIGNAL(), QObject, SLOT()) → bool

QObject.disconnect(QObject, SIGNAL(), callable) -> bool

disconnectNotify(SIGNAL())
dumpObjectInfo()
dumpObjectTree()
dynamicPropertyNames() → list-of-QByteArray
emit(SIGNAL(), ...)
event(QEvent) → bool
eventFilter(QObject, QEvent) → bool
findChild(type, str name='') → QObject

QObject.findChild(tuple, str name=’‘) -> QObject

findChildren(type, str name='') → list-of-QObject

QObject.findChildren(tuple, str name=’‘) -> list-of-QObject QObject.findChildren(type, QRegExp) -> list-of-QObject QObject.findChildren(tuple, QRegExp) -> list-of-QObject

inherits(str) → bool
installEventFilter(QObject)
isWidgetType() → bool
killTimer(int)
metaObject() → QMetaObject
moveToThread(QThread)
objectName() → str
parent() → QObject
property(str) → object
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(SIGNAL()) → int
register_plot(baseplot)

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

removeEventFilter(QObject)
sender() → QObject
senderSignalIndex() → int
setObjectName(str)
setParent(QObject)
setProperty(str, object) → bool
set_parent_tool(tool)

Used to organize tools automatically in menu items

setup_toolbar(toolbar)

Setup tool’s toolbar

signalsBlocked() → bool
startTimer(int) → int
thread() → QThread
timerEvent(QTimerEvent)
tr(str, str disambiguation=None, int n=-1) → str
trUtf8(str, str disambiguation=None, int n=-1) → str
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)[source]
activate()[source]

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(bool) → bool
childEvent(QChildEvent)
children() → list-of-QObject
connect(QObject, SIGNAL(), QObject, SLOT(), Qt.ConnectionType=Qt.AutoConnection) → bool

QObject.connect(QObject, SIGNAL(), callable, Qt.ConnectionType=Qt.AutoConnection) -> bool QObject.connect(QObject, SIGNAL(), SLOT(), Qt.ConnectionType=Qt.AutoConnection) -> bool

connectNotify(SIGNAL())
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(QEvent)
deactivate()

Deactivate tool

deleteLater()
destroyed

QObject.destroyed[QObject] [signal] QObject.destroyed [signal]

disconnect(QObject, SIGNAL(), QObject, SLOT()) → bool

QObject.disconnect(QObject, SIGNAL(), callable) -> bool

disconnectNotify(SIGNAL())
dumpObjectInfo()
dumpObjectTree()
dynamicPropertyNames() → list-of-QByteArray
emit(SIGNAL(), ...)
event(QEvent) → bool
eventFilter(QObject, QEvent) → bool
findChild(type, str name='') → QObject

QObject.findChild(tuple, str name=’‘) -> QObject

findChildren(type, str name='') → list-of-QObject

QObject.findChildren(tuple, str name=’‘) -> list-of-QObject QObject.findChildren(type, QRegExp) -> list-of-QObject QObject.findChildren(tuple, QRegExp) -> list-of-QObject

get_shape()

Reimplemented RectangularActionTool method

inherits(str) → bool
installEventFilter(QObject)
isWidgetType() → bool
killTimer(int)
metaObject() → QMetaObject
moveToThread(QThread)
objectName() → str
parent() → QObject
property(str) → object
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(SIGNAL()) → int
removeEventFilter(QObject)
sender() → QObject
senderSignalIndex() → int
setObjectName(str)
setParent(QObject)
setProperty(str, object) → 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() → bool
startTimer(int) → int
thread() → QThread
timerEvent(QTimerEvent)
tr(str, str disambiguation=None, int n=-1) → str
trUtf8(str, str disambiguation=None, int n=-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.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)[source]
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(bool) → bool
childEvent(QChildEvent)
children() → list-of-QObject
connect(QObject, SIGNAL(), QObject, SLOT(), Qt.ConnectionType=Qt.AutoConnection) → bool

QObject.connect(QObject, SIGNAL(), callable, Qt.ConnectionType=Qt.AutoConnection) -> bool QObject.connect(QObject, SIGNAL(), SLOT(), Qt.ConnectionType=Qt.AutoConnection) -> bool

connectNotify(SIGNAL())
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(QEvent)
deactivate()

Deactivate tool

deleteLater()
destroyed

QObject.destroyed[QObject] [signal] QObject.destroyed [signal]

disconnect(QObject, SIGNAL(), QObject, SLOT()) → bool

QObject.disconnect(QObject, SIGNAL(), callable) -> bool

disconnectNotify(SIGNAL())
dumpObjectInfo()
dumpObjectTree()
dynamicPropertyNames() → list-of-QByteArray
emit(SIGNAL(), ...)
event(QEvent) → bool
eventFilter(QObject, QEvent) → bool
findChild(type, str name='') → QObject

QObject.findChild(tuple, str name=’‘) -> QObject

findChildren(type, str name='') → list-of-QObject

QObject.findChildren(tuple, str name=’‘) -> list-of-QObject QObject.findChildren(type, QRegExp) -> list-of-QObject QObject.findChildren(tuple, QRegExp) -> list-of-QObject

get_shape()

Reimplemented RectangularActionTool method

inherits(str) → bool
installEventFilter(QObject)
isWidgetType() → bool
killTimer(int)
metaObject() → QMetaObject
moveToThread(QThread)
objectName() → str
parent() → QObject
property(str) → object
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(SIGNAL()) → int
removeEventFilter(QObject)
sender() → QObject
senderSignalIndex() → int
setObjectName(str)
setParent(QObject)
setProperty(str, object) → 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() → bool
startTimer(int) → int
thread() → QThread
timerEvent(QTimerEvent)
tr(str, str disambiguation=None, int n=-1) → str
trUtf8(str, str disambiguation=None, int n=-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'>)[source]
activate_command(plot, checked)[source]

Activate tool

blockSignals(bool) → bool
childEvent(QChildEvent)
children() → list-of-QObject
connect(QObject, SIGNAL(), QObject, SLOT(), Qt.ConnectionType=Qt.AutoConnection) → bool

QObject.connect(QObject, SIGNAL(), callable, Qt.ConnectionType=Qt.AutoConnection) -> bool QObject.connect(QObject, SIGNAL(), SLOT(), Qt.ConnectionType=Qt.AutoConnection) -> bool

connectNotify(SIGNAL())
create_action(manager)

Create and return tool’s action

create_action_menu(manager)

Create and return menu for the tool’s action

customEvent(QEvent)
deleteLater()
destroyed

QObject.destroyed[QObject] [signal] QObject.destroyed [signal]

disconnect(QObject, SIGNAL(), QObject, SLOT()) → bool

QObject.disconnect(QObject, SIGNAL(), callable) -> bool

disconnectNotify(SIGNAL())
dumpObjectInfo()
dumpObjectTree()
dynamicPropertyNames() → list-of-QByteArray
emit(SIGNAL(), ...)
event(QEvent) → bool
eventFilter(QObject, QEvent) → bool
findChild(type, str name='') → QObject

QObject.findChild(tuple, str name=’‘) -> QObject

findChildren(type, str name='') → list-of-QObject

QObject.findChildren(tuple, str name=’‘) -> list-of-QObject QObject.findChildren(type, QRegExp) -> list-of-QObject QObject.findChildren(tuple, QRegExp) -> list-of-QObject

inherits(str) → bool
installEventFilter(QObject)
isWidgetType() → bool
killTimer(int)
metaObject() → QMetaObject
moveToThread(QThread)
objectName() → str
parent() → QObject
property(str) → object
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(SIGNAL()) → int
register_plot(baseplot)

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

removeEventFilter(QObject)
sender() → QObject
senderSignalIndex() → int
setObjectName(str)
setParent(QObject)
setProperty(str, object) → bool
set_parent_tool(tool)

Used to organize tools automatically in menu items

setup_toolbar(toolbar)

Setup tool’s toolbar

signalsBlocked() → bool
startTimer(int) → int
thread() → QThread
timerEvent(QTimerEvent)
tr(str, str disambiguation=None, int n=-1) → str
trUtf8(str, str disambiguation=None, int n=-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'>)[source]
activate_command(plot, checked)[source]

Activate tool

blockSignals(bool) → bool
childEvent(QChildEvent)
children() → list-of-QObject
connect(QObject, SIGNAL(), QObject, SLOT(), Qt.ConnectionType=Qt.AutoConnection) → bool

QObject.connect(QObject, SIGNAL(), callable, Qt.ConnectionType=Qt.AutoConnection) -> bool QObject.connect(QObject, SIGNAL(), SLOT(), Qt.ConnectionType=Qt.AutoConnection) -> bool

connectNotify(SIGNAL())
create_action(manager)

Create and return tool’s action

create_action_menu(manager)

Create and return menu for the tool’s action

customEvent(QEvent)
deleteLater()
destroyed

QObject.destroyed[QObject] [signal] QObject.destroyed [signal]

disconnect(QObject, SIGNAL(), QObject, SLOT()) → bool

QObject.disconnect(QObject, SIGNAL(), callable) -> bool

disconnectNotify(SIGNAL())
dumpObjectInfo()
dumpObjectTree()
dynamicPropertyNames() → list-of-QByteArray
emit(SIGNAL(), ...)
event(QEvent) → bool
eventFilter(QObject, QEvent) → bool
findChild(type, str name='') → QObject

QObject.findChild(tuple, str name=’‘) -> QObject

findChildren(type, str name='') → list-of-QObject

QObject.findChildren(tuple, str name=’‘) -> list-of-QObject QObject.findChildren(type, QRegExp) -> list-of-QObject QObject.findChildren(tuple, QRegExp) -> list-of-QObject

inherits(str) → bool
installEventFilter(QObject)
isWidgetType() → bool
killTimer(int)
metaObject() → QMetaObject
moveToThread(QThread)
objectName() → str
parent() → QObject
property(str) → object
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(SIGNAL()) → int
register_plot(baseplot)

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

removeEventFilter(QObject)
sender() → QObject
senderSignalIndex() → int
setObjectName(str)
setParent(QObject)
setProperty(str, object) → bool
set_parent_tool(tool)

Used to organize tools automatically in menu items

setup_toolbar(toolbar)

Setup tool’s toolbar

signalsBlocked() → bool
startTimer(int) → int
thread() → QThread
timerEvent(QTimerEvent)
tr(str, str disambiguation=None, int n=-1) → str
trUtf8(str, str disambiguation=None, int n=-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'>)[source]
SIG_OPEN_FILE

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

activate_command(plot, checked)

Activate tool

blockSignals(bool) → bool
childEvent(QChildEvent)
children() → list-of-QObject
connect(QObject, SIGNAL(), QObject, SLOT(), Qt.ConnectionType=Qt.AutoConnection) → bool

QObject.connect(QObject, SIGNAL(), callable, Qt.ConnectionType=Qt.AutoConnection) -> bool QObject.connect(QObject, SIGNAL(), SLOT(), Qt.ConnectionType=Qt.AutoConnection) -> bool

connectNotify(SIGNAL())
create_action(manager)

Create and return tool’s action

create_action_menu(manager)

Create and return menu for the tool’s action

customEvent(QEvent)
deleteLater()
destroyed

QObject.destroyed[QObject] [signal] QObject.destroyed [signal]

disconnect(QObject, SIGNAL(), QObject, SLOT()) → bool

QObject.disconnect(QObject, SIGNAL(), callable) -> bool

disconnectNotify(SIGNAL())
dumpObjectInfo()
dumpObjectTree()
dynamicPropertyNames() → list-of-QByteArray
emit(SIGNAL(), ...)
event(QEvent) → bool
eventFilter(QObject, QEvent) → bool
findChild(type, str name='') → QObject

QObject.findChild(tuple, str name=’‘) -> QObject

findChildren(type, str name='') → list-of-QObject

QObject.findChildren(tuple, str name=’‘) -> list-of-QObject QObject.findChildren(type, QRegExp) -> list-of-QObject QObject.findChildren(tuple, QRegExp) -> list-of-QObject

inherits(str) → bool
installEventFilter(QObject)
isWidgetType() → bool
killTimer(int)
metaObject() → QMetaObject
moveToThread(QThread)
objectName() → str
parent() → QObject
property(str) → object
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(SIGNAL()) → int
register_plot(baseplot)

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

removeEventFilter(QObject)
sender() → QObject
senderSignalIndex() → int
setObjectName(str)
setParent(QObject)
setProperty(str, object) → bool
set_parent_tool(tool)

Used to organize tools automatically in menu items

setup_toolbar(toolbar)

Setup tool’s toolbar

signalsBlocked() → bool
startTimer(int) → int
thread() → QThread
timerEvent(QTimerEvent)
tr(str, str disambiguation=None, int n=-1) → str
trUtf8(str, str disambiguation=None, int n=-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'>)[source]
activate_command(plot, checked)

Activate tool

blockSignals(bool) → bool
childEvent(QChildEvent)
children() → list-of-QObject
connect(QObject, SIGNAL(), QObject, SLOT(), Qt.ConnectionType=Qt.AutoConnection) → bool

QObject.connect(QObject, SIGNAL(), callable, Qt.ConnectionType=Qt.AutoConnection) -> bool QObject.connect(QObject, SIGNAL(), SLOT(), Qt.ConnectionType=Qt.AutoConnection) -> bool

connectNotify(SIGNAL())
create_action(manager)

Create and return tool’s action

create_action_menu(manager)

Create and return menu for the tool’s action

customEvent(QEvent)
deleteLater()
destroyed

QObject.destroyed[QObject] [signal] QObject.destroyed [signal]

disconnect(QObject, SIGNAL(), QObject, SLOT()) → bool

QObject.disconnect(QObject, SIGNAL(), callable) -> bool

disconnectNotify(SIGNAL())
dumpObjectInfo()
dumpObjectTree()
dynamicPropertyNames() → list-of-QByteArray
emit(SIGNAL(), ...)
event(QEvent) → bool
eventFilter(QObject, QEvent) → bool
findChild(type, str name='') → QObject

QObject.findChild(tuple, str name=’‘) -> QObject

findChildren(type, str name='') → list-of-QObject

QObject.findChildren(tuple, str name=’‘) -> list-of-QObject QObject.findChildren(type, QRegExp) -> list-of-QObject QObject.findChildren(tuple, QRegExp) -> list-of-QObject

inherits(str) → bool
installEventFilter(QObject)
isWidgetType() → bool
killTimer(int)
metaObject() → QMetaObject
moveToThread(QThread)
objectName() → str
parent() → QObject
property(str) → object
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(SIGNAL()) → int
register_plot(baseplot)

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

removeEventFilter(QObject)
sender() → QObject
senderSignalIndex() → int
setObjectName(str)
setParent(QObject)
setProperty(str, object) → bool
set_parent_tool(tool)

Used to organize tools automatically in menu items

setup_toolbar(toolbar)

Setup tool’s toolbar

signalsBlocked() → bool
startTimer(int) → int
thread() → QThread
timerEvent(QTimerEvent)
tr(str, str disambiguation=None, int n=-1) → str
trUtf8(str, str disambiguation=None, int n=-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'>)[source]
activate()

Activate tool

blockSignals(bool) → bool
childEvent(QChildEvent)
children() → list-of-QObject
connect(QObject, SIGNAL(), QObject, SLOT(), Qt.ConnectionType=Qt.AutoConnection) → bool

QObject.connect(QObject, SIGNAL(), callable, Qt.ConnectionType=Qt.AutoConnection) -> bool QObject.connect(QObject, SIGNAL(), SLOT(), Qt.ConnectionType=Qt.AutoConnection) -> bool

connectNotify(SIGNAL())
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(QEvent)
deactivate()

Deactivate tool

deleteLater()
destroyed

QObject.destroyed[QObject] [signal] QObject.destroyed [signal]

disconnect(QObject, SIGNAL(), QObject, SLOT()) → bool

QObject.disconnect(QObject, SIGNAL(), callable) -> bool

disconnectNotify(SIGNAL())
dumpObjectInfo()
dumpObjectTree()
dynamicPropertyNames() → list-of-QByteArray
emit(SIGNAL(), ...)
event(QEvent) → bool
eventFilter(QObject, QEvent) → bool
findChild(type, str name='') → QObject

QObject.findChild(tuple, str name=’‘) -> QObject

findChildren(type, str name='') → list-of-QObject

QObject.findChildren(tuple, str name=’‘) -> list-of-QObject QObject.findChildren(type, QRegExp) -> list-of-QObject QObject.findChildren(tuple, QRegExp) -> list-of-QObject

get_shape()

Reimplemented RectangularActionTool method

inherits(str) → bool
installEventFilter(QObject)
isWidgetType() → bool
killTimer(int)
metaObject() → QMetaObject
moveToThread(QThread)
objectName() → str
parent() → QObject
property(str) → object
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(SIGNAL()) → int
removeEventFilter(QObject)
sender() → QObject
senderSignalIndex() → int
setObjectName(str)
setParent(QObject)
setProperty(str, object) → 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() → bool
startTimer(int) → int
thread() → QThread
timerEvent(QTimerEvent)
tr(str, str disambiguation=None, int n=-1) → str
trUtf8(str, str disambiguation=None, int n=-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'>)[source]
activate_command(plot, checked)[source]

Activate tool

blockSignals(bool) → bool
childEvent(QChildEvent)
children() → list-of-QObject
connect(QObject, SIGNAL(), QObject, SLOT(), Qt.ConnectionType=Qt.AutoConnection) → bool

QObject.connect(QObject, SIGNAL(), callable, Qt.ConnectionType=Qt.AutoConnection) -> bool QObject.connect(QObject, SIGNAL(), SLOT(), Qt.ConnectionType=Qt.AutoConnection) -> bool

connectNotify(SIGNAL())
create_action(manager)

Create and return tool’s action

create_action_menu(manager)

Create and return menu for the tool’s action

customEvent(QEvent)
deleteLater()
destroyed

QObject.destroyed[QObject] [signal] QObject.destroyed [signal]

disconnect(QObject, SIGNAL(), QObject, SLOT()) → bool

QObject.disconnect(QObject, SIGNAL(), callable) -> bool

disconnectNotify(SIGNAL())
dumpObjectInfo()
dumpObjectTree()
dynamicPropertyNames() → list-of-QByteArray
emit(SIGNAL(), ...)
event(QEvent) → bool
eventFilter(QObject, QEvent) → bool
findChild(type, str name='') → QObject

QObject.findChild(tuple, str name=’‘) -> QObject

findChildren(type, str name='') → list-of-QObject

QObject.findChildren(tuple, str name=’‘) -> list-of-QObject QObject.findChildren(type, QRegExp) -> list-of-QObject QObject.findChildren(tuple, QRegExp) -> list-of-QObject

inherits(str) → bool
installEventFilter(QObject)
isWidgetType() → bool
killTimer(int)
metaObject() → QMetaObject
moveToThread(QThread)
objectName() → str
parent() → QObject
property(str) → object
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(SIGNAL()) → int
register_plot(baseplot)

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

removeEventFilter(QObject)
sender() → QObject
senderSignalIndex() → int
setObjectName(str)
setParent(QObject)
setProperty(str, object) → bool
set_parent_tool(tool)

Used to organize tools automatically in menu items

setup_toolbar(toolbar)

Setup tool’s toolbar

signalsBlocked() → bool
startTimer(int) → int
thread() → QThread
timerEvent(QTimerEvent)
tr(str, str disambiguation=None, int n=-1) → str
trUtf8(str, str disambiguation=None, int n=-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'>)[source]
activate_command(plot, checked)[source]

Activate tool

blockSignals(bool) → bool
childEvent(QChildEvent)
children() → list-of-QObject
connect(QObject, SIGNAL(), QObject, SLOT(), Qt.ConnectionType=Qt.AutoConnection) → bool

QObject.connect(QObject, SIGNAL(), callable, Qt.ConnectionType=Qt.AutoConnection) -> bool QObject.connect(QObject, SIGNAL(), SLOT(), Qt.ConnectionType=Qt.AutoConnection) -> bool

connectNotify(SIGNAL())
create_action(manager)

Create and return tool’s action

create_action_menu(manager)

Create and return menu for the tool’s action

customEvent(QEvent)
deleteLater()
destroyed

QObject.destroyed[QObject] [signal] QObject.destroyed [signal]

disconnect(QObject, SIGNAL(), QObject, SLOT()) → bool

QObject.disconnect(QObject, SIGNAL(), callable) -> bool

disconnectNotify(SIGNAL())
dumpObjectInfo()
dumpObjectTree()
dynamicPropertyNames() → list-of-QByteArray
emit(SIGNAL(), ...)
event(QEvent) → bool
eventFilter(QObject, QEvent) → bool
findChild(type, str name='') → QObject

QObject.findChild(tuple, str name=’‘) -> QObject

findChildren(type, str name='') → list-of-QObject

QObject.findChildren(tuple, str name=’‘) -> list-of-QObject QObject.findChildren(type, QRegExp) -> list-of-QObject QObject.findChildren(tuple, QRegExp) -> list-of-QObject

inherits(str) → bool
installEventFilter(QObject)
isWidgetType() → bool
killTimer(int)
metaObject() → QMetaObject
moveToThread(QThread)
objectName() → str
parent() → QObject
property(str) → object
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(SIGNAL()) → int
register_plot(baseplot)

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

removeEventFilter(QObject)
sender() → QObject
senderSignalIndex() → int
setObjectName(str)
setParent(QObject)
setProperty(str, object) → bool
set_parent_tool(tool)

Used to organize tools automatically in menu items

setup_toolbar(toolbar)

Setup tool’s toolbar

signalsBlocked() → bool
startTimer(int) → int
thread() → QThread
timerEvent(QTimerEvent)
tr(str, str disambiguation=None, int n=-1) → str
trUtf8(str, str disambiguation=None, int n=-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'>)[source]
activate_command(plot, checked)[source]

Activate tool

blockSignals(bool) → bool
childEvent(QChildEvent)
children() → list-of-QObject
connect(QObject, SIGNAL(), QObject, SLOT(), Qt.ConnectionType=Qt.AutoConnection) → bool

QObject.connect(QObject, SIGNAL(), callable, Qt.ConnectionType=Qt.AutoConnection) -> bool QObject.connect(QObject, SIGNAL(), SLOT(), Qt.ConnectionType=Qt.AutoConnection) -> bool

connectNotify(SIGNAL())
create_action(manager)

Create and return tool’s action

create_action_menu(manager)

Create and return menu for the tool’s action

customEvent(QEvent)
deleteLater()
destroyed

QObject.destroyed[QObject] [signal] QObject.destroyed [signal]

disconnect(QObject, SIGNAL(), QObject, SLOT()) → bool

QObject.disconnect(QObject, SIGNAL(), callable) -> bool

disconnectNotify(SIGNAL())
dumpObjectInfo()
dumpObjectTree()
dynamicPropertyNames() → list-of-QByteArray
emit(SIGNAL(), ...)
event(QEvent) → bool
eventFilter(QObject, QEvent) → bool
findChild(type, str name='') → QObject

QObject.findChild(tuple, str name=’‘) -> QObject

findChildren(type, str name='') → list-of-QObject

QObject.findChildren(tuple, str name=’‘) -> list-of-QObject QObject.findChildren(type, QRegExp) -> list-of-QObject QObject.findChildren(tuple, QRegExp) -> list-of-QObject

inherits(str) → bool
installEventFilter(QObject)
isWidgetType() → bool
killTimer(int)
metaObject() → QMetaObject
moveToThread(QThread)
objectName() → str
parent() → QObject
property(str) → object
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(SIGNAL()) → int
register_plot(baseplot)

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

removeEventFilter(QObject)
sender() → QObject
senderSignalIndex() → int
setObjectName(str)
setParent(QObject)
setProperty(str, object) → bool
set_parent_tool(tool)

Used to organize tools automatically in menu items

setup_toolbar(toolbar)

Setup tool’s toolbar

signalsBlocked() → bool
startTimer(int) → int
thread() → QThread
timerEvent(QTimerEvent)
tr(str, str disambiguation=None, int n=-1) → str
trUtf8(str, str disambiguation=None, int n=-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)[source]
create_action_menu(manager)[source]

Create and return menu for the tool’s action

blockSignals(bool) → bool
childEvent(QChildEvent)
children() → list-of-QObject
connect(QObject, SIGNAL(), QObject, SLOT(), Qt.ConnectionType=Qt.AutoConnection) → bool

QObject.connect(QObject, SIGNAL(), callable, Qt.ConnectionType=Qt.AutoConnection) -> bool QObject.connect(QObject, SIGNAL(), SLOT(), Qt.ConnectionType=Qt.AutoConnection) -> bool

connectNotify(SIGNAL())
create_action(manager)

Create and return tool’s action

customEvent(QEvent)
deleteLater()
destroyed

QObject.destroyed[QObject] [signal] QObject.destroyed [signal]

disconnect(QObject, SIGNAL(), QObject, SLOT()) → bool

QObject.disconnect(QObject, SIGNAL(), callable) -> bool

disconnectNotify(SIGNAL())
dumpObjectInfo()
dumpObjectTree()
dynamicPropertyNames() → list-of-QByteArray
emit(SIGNAL(), ...)
event(QEvent) → bool
eventFilter(QObject, QEvent) → bool
findChild(type, str name='') → QObject

QObject.findChild(tuple, str name=’‘) -> QObject

findChildren(type, str name='') → list-of-QObject

QObject.findChildren(tuple, str name=’‘) -> list-of-QObject QObject.findChildren(type, QRegExp) -> list-of-QObject QObject.findChildren(tuple, QRegExp) -> list-of-QObject

inherits(str) → bool
installEventFilter(QObject)
isWidgetType() → bool
killTimer(int)
metaObject() → QMetaObject
moveToThread(QThread)
objectName() → str
parent() → QObject
property(str) → object
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(SIGNAL()) → int
register_plot(baseplot)

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

removeEventFilter(QObject)
sender() → QObject
senderSignalIndex() → int
setObjectName(str)
setParent(QObject)
setProperty(str, object) → bool
set_parent_tool(tool)

Used to organize tools automatically in menu items

setup_toolbar(toolbar)

Setup tool’s toolbar

signalsBlocked() → bool
startTimer(int) → int
thread() → QThread
timerEvent(QTimerEvent)
tr(str, str disambiguation=None, int n=-1) → str
trUtf8(str, str disambiguation=None, int n=-1) → str
class guiqwt.tools.HelpTool(manager, toolbar_id=<class 'guiqwt.tools.DefaultToolbarID'>)[source]
activate_command(plot, checked)[source]

Activate tool

blockSignals(bool) → bool
childEvent(QChildEvent)
children() → list-of-QObject
connect(QObject, SIGNAL(), QObject, SLOT(), Qt.ConnectionType=Qt.AutoConnection) → bool

QObject.connect(QObject, SIGNAL(), callable, Qt.ConnectionType=Qt.AutoConnection) -> bool QObject.connect(QObject, SIGNAL(), SLOT(), Qt.ConnectionType=Qt.AutoConnection) -> bool

connectNotify(SIGNAL())
create_action(manager)

Create and return tool’s action

create_action_menu(manager)

Create and return menu for the tool’s action

customEvent(QEvent)
deleteLater()
destroyed

QObject.destroyed[QObject] [signal] QObject.destroyed [signal]

disconnect(QObject, SIGNAL(), QObject, SLOT()) → bool

QObject.disconnect(QObject, SIGNAL(), callable) -> bool

disconnectNotify(SIGNAL())
dumpObjectInfo()
dumpObjectTree()
dynamicPropertyNames() → list-of-QByteArray
emit(SIGNAL(), ...)
event(QEvent) → bool
eventFilter(QObject, QEvent) → bool
findChild(type, str name='') → QObject

QObject.findChild(tuple, str name=’‘) -> QObject

findChildren(type, str name='') → list-of-QObject

QObject.findChildren(tuple, str name=’‘) -> list-of-QObject QObject.findChildren(type, QRegExp) -> list-of-QObject QObject.findChildren(tuple, QRegExp) -> list-of-QObject

inherits(str) → bool
installEventFilter(QObject)
isWidgetType() → bool
killTimer(int)
metaObject() → QMetaObject
moveToThread(QThread)
objectName() → str
parent() → QObject
property(str) → object
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(SIGNAL()) → int
register_plot(baseplot)

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

removeEventFilter(QObject)
sender() → QObject
senderSignalIndex() → int
setObjectName(str)
setParent(QObject)
setProperty(str, object) → bool
set_parent_tool(tool)

Used to organize tools automatically in menu items

setup_toolbar(toolbar)

Setup tool’s toolbar

signalsBlocked() → bool
startTimer(int) → int
thread() → QThread
timerEvent(QTimerEvent)
tr(str, str disambiguation=None, int n=-1) → str
trUtf8(str, str disambiguation=None, int n=-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)[source]
activate_command(plot, checked)

Activate tool

blockSignals(bool) → bool
childEvent(QChildEvent)
children() → list-of-QObject
connect(QObject, SIGNAL(), QObject, SLOT(), Qt.ConnectionType=Qt.AutoConnection) → bool

QObject.connect(QObject, SIGNAL(), callable, Qt.ConnectionType=Qt.AutoConnection) -> bool QObject.connect(QObject, SIGNAL(), SLOT(), Qt.ConnectionType=Qt.AutoConnection) -> bool

connectNotify(SIGNAL())
create_action(manager)

Create and return tool’s action

create_action_menu(manager)

Create and return menu for the tool’s action

customEvent(QEvent)
deleteLater()
destroyed

QObject.destroyed[QObject] [signal] QObject.destroyed [signal]

disconnect(QObject, SIGNAL(), QObject, SLOT()) → bool

QObject.disconnect(QObject, SIGNAL(), callable) -> bool

disconnectNotify(SIGNAL())
dumpObjectInfo()
dumpObjectTree()
dynamicPropertyNames() → list-of-QByteArray
emit(SIGNAL(), ...)
event(QEvent) → bool
eventFilter(QObject, QEvent) → bool
findChild(type, str name='') → QObject

QObject.findChild(tuple, str name=’‘) -> QObject

findChildren(type, str name='') → list-of-QObject

QObject.findChildren(tuple, str name=’‘) -> list-of-QObject QObject.findChildren(type, QRegExp) -> list-of-QObject QObject.findChildren(tuple, QRegExp) -> list-of-QObject

inherits(str) → bool
installEventFilter(QObject)
isWidgetType() → bool
killTimer(int)
metaObject() → QMetaObject
moveToThread(QThread)
objectName() → str
parent() → QObject
property(str) → object
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(SIGNAL()) → int
register_plot(baseplot)

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

removeEventFilter(QObject)
sender() → QObject
senderSignalIndex() → int
setObjectName(str)
setParent(QObject)
setProperty(str, object) → bool
set_parent_tool(tool)

Used to organize tools automatically in menu items

setup_toolbar(toolbar)

Setup tool’s toolbar

signalsBlocked() → bool
startTimer(int) → int
thread() → QThread
timerEvent(QTimerEvent)
tr(str, str disambiguation=None, int n=-1) → str
trUtf8(str, str disambiguation=None, int n=-1) → str
class guiqwt.tools.EditItemDataTool(manager, toolbar_id=None)[source]

Edit item data (requires spyderlib)

activate_command(plot, checked)

Activate tool

blockSignals(bool) → bool
childEvent(QChildEvent)
children() → list-of-QObject
connect(QObject, SIGNAL(), QObject, SLOT(), Qt.ConnectionType=Qt.AutoConnection) → bool

QObject.connect(QObject, SIGNAL(), callable, Qt.ConnectionType=Qt.AutoConnection) -> bool QObject.connect(QObject, SIGNAL(), SLOT(), Qt.ConnectionType=Qt.AutoConnection) -> bool

connectNotify(SIGNAL())
create_action(manager)

Create and return tool’s action

create_action_menu(manager)

Create and return menu for the tool’s action

customEvent(QEvent)
deleteLater()
destroyed

QObject.destroyed[QObject] [signal] QObject.destroyed [signal]

disconnect(QObject, SIGNAL(), QObject, SLOT()) → bool

QObject.disconnect(QObject, SIGNAL(), callable) -> bool

disconnectNotify(SIGNAL())
dumpObjectInfo()
dumpObjectTree()
dynamicPropertyNames() → list-of-QByteArray
emit(SIGNAL(), ...)
event(QEvent) → bool
eventFilter(QObject, QEvent) → bool
findChild(type, str name='') → QObject

QObject.findChild(tuple, str name=’‘) -> QObject

findChildren(type, str name='') → list-of-QObject

QObject.findChildren(tuple, str name=’‘) -> list-of-QObject QObject.findChildren(type, QRegExp) -> list-of-QObject QObject.findChildren(tuple, QRegExp) -> list-of-QObject

inherits(str) → bool
installEventFilter(QObject)
isWidgetType() → bool
killTimer(int)
metaObject() → QMetaObject
moveToThread(QThread)
objectName() → str
parent() → QObject
property(str) → object
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(SIGNAL()) → int
register_plot(baseplot)

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

removeEventFilter(QObject)
sender() → QObject
senderSignalIndex() → int
setObjectName(str)
setParent(QObject)
setProperty(str, object) → bool
set_parent_tool(tool)

Used to organize tools automatically in menu items

setup_toolbar(toolbar)

Setup tool’s toolbar

signalsBlocked() → bool
startTimer(int) → int
thread() → QThread
timerEvent(QTimerEvent)
tr(str, str disambiguation=None, int n=-1) → str
trUtf8(str, str disambiguation=None, int n=-1) → str
class guiqwt.tools.ItemCenterTool(manager, toolbar_id=None)[source]
activate_command(plot, checked)[source]

Activate tool

blockSignals(bool) → bool
childEvent(QChildEvent)
children() → list-of-QObject
connect(QObject, SIGNAL(), QObject, SLOT(), Qt.ConnectionType=Qt.AutoConnection) → bool

QObject.connect(QObject, SIGNAL(), callable, Qt.ConnectionType=Qt.AutoConnection) -> bool QObject.connect(QObject, SIGNAL(), SLOT(), Qt.ConnectionType=Qt.AutoConnection) -> bool

connectNotify(SIGNAL())
create_action(manager)

Create and return tool’s action

create_action_menu(manager)

Create and return menu for the tool’s action

customEvent(QEvent)
deleteLater()
destroyed

QObject.destroyed[QObject] [signal] QObject.destroyed [signal]

disconnect(QObject, SIGNAL(), QObject, SLOT()) → bool

QObject.disconnect(QObject, SIGNAL(), callable) -> bool

disconnectNotify(SIGNAL())
dumpObjectInfo()
dumpObjectTree()
dynamicPropertyNames() → list-of-QByteArray
emit(SIGNAL(), ...)
event(QEvent) → bool
eventFilter(QObject, QEvent) → bool
findChild(type, str name='') → QObject

QObject.findChild(tuple, str name=’‘) -> QObject

findChildren(type, str name='') → list-of-QObject

QObject.findChildren(tuple, str name=’‘) -> list-of-QObject QObject.findChildren(type, QRegExp) -> list-of-QObject QObject.findChildren(tuple, QRegExp) -> list-of-QObject

inherits(str) → bool
installEventFilter(QObject)
isWidgetType() → bool
killTimer(int)
metaObject() → QMetaObject
moveToThread(QThread)
objectName() → str
parent() → QObject
property(str) → object
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(SIGNAL()) → int
register_plot(baseplot)

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

removeEventFilter(QObject)
sender() → QObject
senderSignalIndex() → int
setObjectName(str)
setParent(QObject)
setProperty(str, object) → bool
set_parent_tool(tool)

Used to organize tools automatically in menu items

setup_toolbar(toolbar)

Setup tool’s toolbar

signalsBlocked() → bool
startTimer(int) → int
thread() → QThread
timerEvent(QTimerEvent)
tr(str, str disambiguation=None, int n=-1) → str
trUtf8(str, str disambiguation=None, int n=-1) → str
class guiqwt.tools.DeleteItemTool(manager, toolbar_id=None)[source]
activate_command(plot, checked)[source]

Activate tool

blockSignals(bool) → bool
childEvent(QChildEvent)
children() → list-of-QObject
connect(QObject, SIGNAL(), QObject, SLOT(), Qt.ConnectionType=Qt.AutoConnection) → bool

QObject.connect(QObject, SIGNAL(), callable, Qt.ConnectionType=Qt.AutoConnection) -> bool QObject.connect(QObject, SIGNAL(), SLOT(), Qt.ConnectionType=Qt.AutoConnection) -> bool

connectNotify(SIGNAL())
create_action(manager)

Create and return tool’s action

create_action_menu(manager)

Create and return menu for the tool’s action

customEvent(QEvent)
deleteLater()
destroyed

QObject.destroyed[QObject] [signal] QObject.destroyed [signal]

disconnect(QObject, SIGNAL(), QObject, SLOT()) → bool

QObject.disconnect(QObject, SIGNAL(), callable) -> bool

disconnectNotify(SIGNAL())
dumpObjectInfo()
dumpObjectTree()
dynamicPropertyNames() → list-of-QByteArray
emit(SIGNAL(), ...)
event(QEvent) → bool
eventFilter(QObject, QEvent) → bool
findChild(type, str name='') → QObject

QObject.findChild(tuple, str name=’‘) -> QObject

findChildren(type, str name='') → list-of-QObject

QObject.findChildren(tuple, str name=’‘) -> list-of-QObject QObject.findChildren(type, QRegExp) -> list-of-QObject QObject.findChildren(tuple, QRegExp) -> list-of-QObject

inherits(str) → bool
installEventFilter(QObject)
isWidgetType() → bool
killTimer(int)
metaObject() → QMetaObject
moveToThread(QThread)
objectName() → str
parent() → QObject
property(str) → object
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(SIGNAL()) → int
register_plot(baseplot)

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

removeEventFilter(QObject)
sender() → QObject
senderSignalIndex() → int
setObjectName(str)
setParent(QObject)
setProperty(str, object) → bool
set_parent_tool(tool)

Used to organize tools automatically in menu items

setup_toolbar(toolbar)

Setup tool’s toolbar

signalsBlocked() → bool
startTimer(int) → int
thread() → QThread
timerEvent(QTimerEvent)
tr(str, str disambiguation=None, int n=-1) → str
trUtf8(str, str disambiguation=None, int n=-1) → str