rotatecrop

The rotatecrop module provides a dialog box providing essential GUI elements for rotating (arbitrary angle) and cropping an image:

• guiqwt.widgets.rotatecrop.RotateCropDialog: dialog box
• guiqwt.widgets.rotatecrop.RotateCropWidget: equivalent widget

Reference

class guiqwt.widgets.rotatecrop.RotateCropDialog(parent, wintitle=None, options=None, resize_to=None)

Rotate & Crop Dialog

Rotate and crop a guiqwt.image.TrImageItem plot item

class RenderFlags(QWidget.RenderFlags)

QWidget.RenderFlags(int) QWidget.RenderFlags()

RotateCropDialog.accept(self)

RotateCropDialog.acceptDrops(self) → bool

RotateCropDialog.accept_changes()

Computed rotated/cropped array and apply changes to item

RotateCropDialog.accepted

accepted(self) [signal]

RotateCropDialog.accessibleDescription(self) → object

RotateCropDialog.accessibleName(self) → object

RotateCropDialog.actionEvent(self, QActionEvent)

RotateCropDialog.actions(self) → object

RotateCropDialog.activateWindow(self)

RotateCropDialog.activate_default_tool()

Activate default tool

RotateCropDialog.addAction(self, QAction)

RotateCropDialog.addActions(self, object)

RotateCropDialog.add_apply_button(layout)

Add the standard apply button

RotateCropDialog.add_buttons_to_layout(layout)

Add tool buttons to layout

RotateCropDialog.add_panel(panel)

Register a panel to the plot manager

Plot manager’s registration sequence is the following:

1. add plots
2. add panels
3. add tools

RotateCropDialog.add_plot(plot, plot_id=<class 'guiqwt.plot.DefaultPlotID'>)

Register a plot to the plot manager:

• plot: guiqwt.curve.CurvePlot or guiqwt.image.ImagePlot object
• plot_id (default id is the plot object’s id: id(plot)): unique ID identifying the plot (any Python object), this ID will be asked by the manager to access this plot later.

Plot manager’s registration sequence is the following:

1. add plots
2. add panels
3. add tools

RotateCropDialog.add_reset_button(layout)

Add the standard reset button

RotateCropDialog.add_separator_tool(toolbar_id=None)

Register a separator tool to the plot manager: the separator tool is just a tool which insert a separator in the plot context menu

RotateCropDialog.add_tool(ToolKlass, *args, **kwargs)

Register a tool to the manager

• ToolKlass: tool’s class (guiqwt builtin tools are defined in module guiqwt.tools)
• args: arguments sent to the tool’s class
• kwargs: keyword arguments sent to the tool’s class

Plot manager’s registration sequence is the following:

1. add plots
2. add panels
3. add tools

RotateCropDialog.add_toolbar(toolbar, toolbar_id='default')

Add toolbar to the plot manager

toolbar: a QToolBar object toolbar_id: toolbar’s id (default id is string “default”)

RotateCropDialog.adjustSize(self)

RotateCropDialog.apply_transformation()

Apply transformation, e.g. crop or rotate

RotateCropDialog.autoFillBackground(self) → bool

RotateCropDialog.backgroundRole(self) → QPalette.ColorRole

RotateCropDialog.baseSize(self) → QSize

RotateCropDialog.blockSignals(self, bool) → bool

RotateCropDialog.changeEvent(self, QEvent)

RotateCropDialog.childAt(self, QPoint) → QWidget

childAt(self, int, int) -> QWidget

RotateCropDialog.childEvent(self, QChildEvent)

RotateCropDialog.children(self) → object

RotateCropDialog.childrenRect(self) → QRect

RotateCropDialog.childrenRegion(self) → QRegion

RotateCropDialog.clearFocus(self)

RotateCropDialog.clearMask(self)

RotateCropDialog.close(self) → bool

RotateCropDialog.closeEvent(self, QCloseEvent)

RotateCropDialog.colorCount(self) → int

RotateCropDialog.compute_transformation()

Compute transformation, return compute output array

RotateCropDialog.configure_panels()

Call all the registred panels ‘configure_panel’ methods to finalize the object construction (this allows to use tools registered to the same plot manager as the panel itself with breaking the registration sequence: “add plots, then panels, then tools”)

RotateCropDialog.connect(QObject, QT_SIGNAL, QObject, QT_SLOT_QT_SIGNAL, Qt.ConnectionType = Qt.AutoConnection) → object

connect(QObject, QT_SIGNAL, Callable[..., None], Qt.ConnectionType = Qt.AutoConnection) -> object connect(self, QObject, QT_SIGNAL, QT_SLOT_QT_SIGNAL, Qt.ConnectionType = Qt.AutoConnection) -> object

RotateCropDialog.connectNotify(self, QT_SIGNAL)

RotateCropDialog.contentsMargins(self) → QMargins

RotateCropDialog.contentsRect(self) → QRect

RotateCropDialog.contextMenuEvent(self, QContextMenuEvent)

RotateCropDialog.contextMenuPolicy(self) → Qt.ContextMenuPolicy

RotateCropDialog.create(self, window: int = 0, initializeWindow: bool = True, destroyOldWindow: bool = True)

RotateCropDialog.create_action(title, triggered=None, toggled=None, shortcut=None, icon=None, tip=None, checkable=None, context=1, enabled=None)

Create a new QAction

RotateCropDialog.create_plot(options, row=0, column=0, rowspan=1, columnspan=1)

Create the plotting widget (which is an instance of class guiqwt.plot.BaseImageWidget), add it to the dialog box main layout (guiqwt.plot.CurveDialog.plot_layout) and then add the item list, contrast adjustment and X/Y axes cross section panels.

May be overriden to customize the plot layout (guiqwt.plot.CurveDialog.plot_layout)

RotateCropDialog.cursor(self) → QCursor

RotateCropDialog.customContextMenuRequested

customContextMenuRequested(self, QPoint) [signal]

RotateCropDialog.customEvent(self, QEvent)

RotateCropDialog.deleteLater(self)

RotateCropDialog.depth(self) → int

RotateCropDialog.destroy(self, destroyWindow: bool = True, destroySubWindows: bool = True)

RotateCropDialog.destroyed

destroyed(self, QObject = None) [signal] destroyed(self) [signal]

RotateCropDialog.devType(self) → int

RotateCropDialog.disconnect(QObject, QT_SIGNAL, QObject, QT_SLOT_QT_SIGNAL) → object

disconnect(QObject, QT_SIGNAL, Callable[..., None]) -> object

RotateCropDialog.disconnectNotify(self, QT_SIGNAL)

RotateCropDialog.done(self, int)

RotateCropDialog.dragEnterEvent(self, QDragEnterEvent)

RotateCropDialog.dragLeaveEvent(self, QDragLeaveEvent)

RotateCropDialog.dragMoveEvent(self, QDragMoveEvent)

RotateCropDialog.dropEvent(self, QDropEvent)

RotateCropDialog.dumpObjectInfo(self)

RotateCropDialog.dumpObjectTree(self)

RotateCropDialog.dynamicPropertyNames(self) → object

RotateCropDialog.effectiveWinId(self) → int

RotateCropDialog.emit(self, QT_SIGNAL, *)

RotateCropDialog.enabledChange(self, bool)

RotateCropDialog.ensurePolished(self)

RotateCropDialog.enterEvent(self, QEvent)

RotateCropDialog.event(self, QEvent) → bool

RotateCropDialog.eventFilter(self, QObject, QEvent) → bool

RotateCropDialog.exec(self) → int

RotateCropDialog.exec_(self) → int

RotateCropDialog.extension(self) → QWidget

RotateCropDialog.find(int) → QWidget

RotateCropDialog.findChild(self, type, name: object = '') → object

findChild(self, Tuple, name: object = ‘’) -> object

RotateCropDialog.findChildren(self, type, name: object = '') → List

findChildren(self, Tuple, name: object = ‘’) -> List findChildren(self, type, QRegExp) -> List findChildren(self, Tuple, QRegExp) -> List

RotateCropDialog.finished

finished(self, int) [signal]

RotateCropDialog.focusInEvent(self, QFocusEvent)

RotateCropDialog.focusNextChild(self) → bool

RotateCropDialog.focusNextPrevChild(self, bool) → bool

RotateCropDialog.focusOutEvent(self, QFocusEvent)

RotateCropDialog.focusPolicy(self) → Qt.FocusPolicy

RotateCropDialog.focusPreviousChild(self) → bool

RotateCropDialog.focusProxy(self) → QWidget

RotateCropDialog.focusWidget(self) → QWidget

RotateCropDialog.font(self) → QFont

RotateCropDialog.fontChange(self, QFont)

RotateCropDialog.fontInfo(self) → QFontInfo

RotateCropDialog.fontMetrics(self) → QFontMetrics

RotateCropDialog.foregroundRole(self) → QPalette.ColorRole

RotateCropDialog.frameGeometry(self) → QRect

RotateCropDialog.frameSize(self) → QSize

RotateCropDialog.geometry(self) → QRect

RotateCropDialog.getContentsMargins(self) → Tuple[int, int, int, int]

RotateCropDialog.get_active_plot()

Return the active plot

The active plot is the plot whose canvas has the focus otherwise it’s the “default” plot

RotateCropDialog.get_active_tool()

Return active tool

RotateCropDialog.get_context_menu(plot=None)

Return widget context menu – built using active tools

RotateCropDialog.get_contrast_panel()

Convenience function to get the contrast adjustment panel

Return None if the contrast adjustment panel has not been added to this manager

RotateCropDialog.get_default_plot()

Return default plot

The default plot is the plot on which tools and panels will act.

RotateCropDialog.get_default_tool()

Get default tool

RotateCropDialog.get_default_toolbar()

Return default toolbar

RotateCropDialog.get_itemlist_panel()

Convenience function to get the item list panel

Return None if the item list panel has not been added to this manager

RotateCropDialog.get_main()

Return the main (parent) widget

Note that for py:class:guiqwt.plot.CurveWidget or guiqwt.plot.ImageWidget objects, this method will return the widget itself because the plot manager is integrated to it.

RotateCropDialog.get_panel(panel_id)

Return panel from its ID Panel IDs are listed in module guiqwt.panels

RotateCropDialog.get_plot(plot_id=<class 'guiqwt.plot.DefaultPlotID'>)

Return plot associated to plot_id (if method is called without specifying the plot_id parameter, return the default plot)

RotateCropDialog.get_plots()

Return all registered plots

RotateCropDialog.get_tool(ToolKlass)

Return tool instance from its class

RotateCropDialog.get_toolbar(toolbar_id='default')

Return toolbar from its ID

toolbar_id: toolbar’s id (default id is string “default”)

RotateCropDialog.get_xcs_panel()

Convenience function to get the X-axis cross section panel

Return None if the X-axis cross section panel has not been added to this manager

RotateCropDialog.get_ycs_panel()

Convenience function to get the Y-axis cross section panel

Return None if the Y-axis cross section panel has not been added to this manager

RotateCropDialog.grabGesture(self, Qt.GestureType, flags: Qt.GestureFlags = Qt.GestureFlags(0))

RotateCropDialog.grabKeyboard(self)

RotateCropDialog.grabMouse(self)

grabMouse(self, QCursor)

RotateCropDialog.grabShortcut(self, QKeySequence, context: Qt.ShortcutContext = Qt.WindowShortcut) → int

RotateCropDialog.graphicsEffect(self) → QGraphicsEffect

RotateCropDialog.graphicsProxyWidget(self) → QGraphicsProxyWidget

RotateCropDialog.handle(self) → int

RotateCropDialog.hasFocus(self) → bool

RotateCropDialog.hasMouseTracking(self) → bool

RotateCropDialog.height(self) → int

RotateCropDialog.heightForWidth(self, int) → int

RotateCropDialog.heightMM(self) → int

RotateCropDialog.hide(self)

RotateCropDialog.hideEvent(self, QHideEvent)

RotateCropDialog.inherits(self, str) → bool

RotateCropDialog.inputContext(self) → QInputContext

RotateCropDialog.inputMethodEvent(self, QInputMethodEvent)

RotateCropDialog.inputMethodHints(self) → Qt.InputMethodHints

RotateCropDialog.inputMethodQuery(self, Qt.InputMethodQuery) → object

RotateCropDialog.insertAction(self, QAction, QAction)

RotateCropDialog.insertActions(self, QAction, object)

RotateCropDialog.installEventFilter(self, QObject)

RotateCropDialog.install_button_layout()

Reimplemented ImageDialog method

RotateCropDialog.isActiveWindow(self) → bool

RotateCropDialog.isAncestorOf(self, QWidget) → bool

RotateCropDialog.isEnabled(self) → bool

RotateCropDialog.isEnabledTo(self, QWidget) → bool

RotateCropDialog.isEnabledToTLW(self) → bool

RotateCropDialog.isFullScreen(self) → bool

RotateCropDialog.isHidden(self) → bool

RotateCropDialog.isLeftToRight(self) → bool

RotateCropDialog.isMaximized(self) → bool

RotateCropDialog.isMinimized(self) → bool

RotateCropDialog.isModal(self) → bool

RotateCropDialog.isRightToLeft(self) → bool

RotateCropDialog.isSizeGripEnabled(self) → bool

RotateCropDialog.isTopLevel(self) → bool

RotateCropDialog.isVisible(self) → bool

RotateCropDialog.isVisibleTo(self, QWidget) → bool

RotateCropDialog.isWidgetType(self) → bool

RotateCropDialog.isWindow(self) → bool

RotateCropDialog.isWindowModified(self) → bool

RotateCropDialog.keyPressEvent(self, QKeyEvent)

RotateCropDialog.keyReleaseEvent(self, QKeyEvent)

RotateCropDialog.keyboardGrabber() → QWidget

RotateCropDialog.killTimer(self, int)

RotateCropDialog.languageChange(self)

RotateCropDialog.layout(self) → QLayout

RotateCropDialog.layoutDirection(self) → Qt.LayoutDirection

RotateCropDialog.leaveEvent(self, QEvent)

RotateCropDialog.locale(self) → QLocale

RotateCropDialog.logicalDpiX(self) → int

RotateCropDialog.logicalDpiY(self) → int

RotateCropDialog.lower(self)

RotateCropDialog.mapFrom(self, QWidget, QPoint) → QPoint

RotateCropDialog.mapFromGlobal(self, QPoint) → QPoint

RotateCropDialog.mapFromParent(self, QPoint) → QPoint

RotateCropDialog.mapTo(self, QWidget, QPoint) → QPoint

RotateCropDialog.mapToGlobal(self, QPoint) → QPoint

RotateCropDialog.mapToParent(self, QPoint) → QPoint

RotateCropDialog.mask(self) → QRegion

RotateCropDialog.maximumHeight(self) → int

RotateCropDialog.maximumSize(self) → QSize

RotateCropDialog.maximumWidth(self) → int

RotateCropDialog.metaObject(self) → QMetaObject

RotateCropDialog.metric(self, QPaintDevice.PaintDeviceMetric) → int

RotateCropDialog.minimumHeight(self) → int

RotateCropDialog.minimumSize(self) → QSize

RotateCropDialog.minimumSizeHint(self) → QSize

RotateCropDialog.minimumWidth(self) → int

RotateCropDialog.mouseDoubleClickEvent(self, QMouseEvent)

RotateCropDialog.mouseGrabber() → QWidget

RotateCropDialog.mouseMoveEvent(self, QMouseEvent)

RotateCropDialog.mousePressEvent(self, QMouseEvent)

RotateCropDialog.mouseReleaseEvent(self, QMouseEvent)

RotateCropDialog.move(self, QPoint)

move(self, int, int)

RotateCropDialog.moveEvent(self, QMoveEvent)

RotateCropDialog.moveToThread(self, QThread)

RotateCropDialog.nativeParentWidget(self) → QWidget

RotateCropDialog.nextInFocusChain(self) → QWidget

RotateCropDialog.normalGeometry(self) → QRect

RotateCropDialog.numColors(self) → int

RotateCropDialog.objectName(self) → object

RotateCropDialog.open(self)

RotateCropDialog.orientation(self) → Qt.Orientation

RotateCropDialog.overrideWindowFlags(self, Qt.WindowFlags)

RotateCropDialog.overrideWindowState(self, Qt.WindowStates)

RotateCropDialog.paintEngine(self) → QPaintEngine

RotateCropDialog.paintEvent(self, QPaintEvent)

RotateCropDialog.paintingActive(self) → bool

RotateCropDialog.palette(self) → QPalette

RotateCropDialog.paletteChange(self, QPalette)

RotateCropDialog.parent(self) → QObject

RotateCropDialog.parentWidget(self) → QWidget

RotateCropDialog.physicalDpiX(self) → int

RotateCropDialog.physicalDpiY(self) → int

RotateCropDialog.pos(self) → QPoint

RotateCropDialog.previousInFocusChain(self) → QWidget

RotateCropDialog.property(self, str) → object

RotateCropDialog.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.

RotateCropDialog.raise_(self)

RotateCropDialog.receivers(self, QT_SIGNAL) → int

RotateCropDialog.rect(self) → QRect

RotateCropDialog.register_all_curve_tools()

Register standard, curve-related and other tools

See also

guiqwt.plot.PlotManager.add_tool()

guiqwt.plot.PlotManager.register_standard_tools()

guiqwt.plot.PlotManager.register_other_tools()

guiqwt.plot.PlotManager.register_curve_tools()

guiqwt.plot.PlotManager.register_image_tools()

guiqwt.plot.PlotManager.register_all_image_tools()

RotateCropDialog.register_all_image_tools()

Register standard, image-related and other tools

See also

guiqwt.plot.PlotManager.add_tool()

guiqwt.plot.PlotManager.register_standard_tools()

guiqwt.plot.PlotManager.register_other_tools()

guiqwt.plot.PlotManager.register_curve_tools()

guiqwt.plot.PlotManager.register_image_tools()

guiqwt.plot.PlotManager.register_all_curve_tools()

RotateCropDialog.register_curve_tools()

Register only curve-related tools

See also

guiqwt.plot.PlotManager.add_tool()

guiqwt.plot.PlotManager.register_standard_tools()

guiqwt.plot.PlotManager.register_other_tools()

guiqwt.plot.PlotManager.register_image_tools()

RotateCropDialog.register_image_tools()

Register only image-related tools

See also

guiqwt.plot.PlotManager.add_tool()

guiqwt.plot.PlotManager.register_standard_tools()

guiqwt.plot.PlotManager.register_other_tools()

guiqwt.plot.PlotManager.register_curve_tools()

RotateCropDialog.register_other_tools()

Register other common tools

See also

guiqwt.plot.PlotManager.add_tool()

guiqwt.plot.PlotManager.register_standard_tools()

guiqwt.plot.PlotManager.register_curve_tools()

guiqwt.plot.PlotManager.register_image_tools()

RotateCropDialog.register_standard_tools()

Registering basic tools for standard plot dialog –> top of the context-menu

RotateCropDialog.register_tools()

Register the plotting dialog box tools: the base implementation provides standard, image-related and other tools - i.e. calling this method is exactly the same as calling guiqwt.plot.CurveDialog.register_all_image_tools()

This method may be overriden to provide a fully customized set of tools

RotateCropDialog.reject(self)

RotateCropDialog.reject_changes()

Restore item original transform settings

RotateCropDialog.rejected

rejected(self) [signal]

RotateCropDialog.releaseKeyboard(self)

RotateCropDialog.releaseMouse(self)

RotateCropDialog.releaseShortcut(self, int)

RotateCropDialog.removeAction(self, QAction)

RotateCropDialog.removeEventFilter(self, QObject)

RotateCropDialog.render(self, QPaintDevice, targetOffset: QPoint = QPoint(), sourceRegion: QRegion = QRegion(), flags: QWidget.RenderFlags = QWidget.DrawWindowBackground|QWidget.DrawChildren)

render(self, QPainter, targetOffset: QPoint = QPoint(), sourceRegion: QRegion = QRegion(), flags: QWidget.RenderFlags = QWidget.DrawWindowBackground|QWidget.DrawChildren)

RotateCropDialog.repaint(self)

repaint(self, int, int, int, int) repaint(self, QRect) repaint(self, QRegion)

RotateCropDialog.reset()

Reset crop/transform image settings

RotateCropDialog.resetInputContext(self)

RotateCropDialog.reset_transformation()

Reset transformation

RotateCropDialog.resize(self, QSize)

resize(self, int, int)

RotateCropDialog.resizeEvent(self, QResizeEvent)

RotateCropDialog.restoreGeometry(self, QByteArray) → bool

RotateCropDialog.restore_original_state()

Restore item original state

RotateCropDialog.result(self) → int

RotateCropDialog.saveGeometry(self) → QByteArray

RotateCropDialog.scroll(self, int, int)

scroll(self, int, int, QRect)

RotateCropDialog.sender(self) → QObject

RotateCropDialog.senderSignalIndex(self) → int

RotateCropDialog.setAcceptDrops(self, bool)

RotateCropDialog.setAccessibleDescription(self, object)

RotateCropDialog.setAccessibleName(self, object)

RotateCropDialog.setAttribute(self, Qt.WidgetAttribute, on: bool = True)

RotateCropDialog.setAutoFillBackground(self, bool)

RotateCropDialog.setBackgroundRole(self, QPalette.ColorRole)

RotateCropDialog.setBaseSize(self, int, int)

setBaseSize(self, QSize)

RotateCropDialog.setContentsMargins(self, int, int, int, int)

setContentsMargins(self, QMargins)

RotateCropDialog.setContextMenuPolicy(self, Qt.ContextMenuPolicy)

RotateCropDialog.setCursor(self, QCursor)

RotateCropDialog.setDisabled(self, bool)

RotateCropDialog.setEnabled(self, bool)

RotateCropDialog.setExtension(self, QWidget)

RotateCropDialog.setFixedHeight(self, int)

RotateCropDialog.setFixedSize(self, QSize)

setFixedSize(self, int, int)

RotateCropDialog.setFixedWidth(self, int)

RotateCropDialog.setFocus(self)

setFocus(self, Qt.FocusReason)

RotateCropDialog.setFocusPolicy(self, Qt.FocusPolicy)

RotateCropDialog.setFocusProxy(self, QWidget)

RotateCropDialog.setFont(self, QFont)

RotateCropDialog.setForegroundRole(self, QPalette.ColorRole)

RotateCropDialog.setGeometry(self, QRect)

setGeometry(self, int, int, int, int)

RotateCropDialog.setGraphicsEffect(self, QGraphicsEffect)

RotateCropDialog.setHidden(self, bool)

RotateCropDialog.setInputContext(self, QInputContext)

RotateCropDialog.setInputMethodHints(self, Qt.InputMethodHints)

RotateCropDialog.setLayout(self, QLayout)

RotateCropDialog.setLayoutDirection(self, Qt.LayoutDirection)

RotateCropDialog.setLocale(self, QLocale)

RotateCropDialog.setMask(self, QBitmap)

setMask(self, QRegion)

RotateCropDialog.setMaximumHeight(self, int)

RotateCropDialog.setMaximumSize(self, int, int)

setMaximumSize(self, QSize)

RotateCropDialog.setMaximumWidth(self, int)

RotateCropDialog.setMinimumHeight(self, int)

RotateCropDialog.setMinimumSize(self, int, int)

setMinimumSize(self, QSize)

RotateCropDialog.setMinimumWidth(self, int)

RotateCropDialog.setModal(self, bool)

RotateCropDialog.setMouseTracking(self, bool)

RotateCropDialog.setObjectName(self, object)

RotateCropDialog.setOrientation(self, Qt.Orientation)

RotateCropDialog.setPalette(self, QPalette)

RotateCropDialog.setParent(self, QWidget)

setParent(self, QWidget, Qt.WindowFlags)

RotateCropDialog.setProperty(self, str, object) → bool

RotateCropDialog.setResult(self, int)

RotateCropDialog.setShortcutAutoRepeat(self, int, enabled: bool = True)

RotateCropDialog.setShortcutEnabled(self, int, enabled: bool = True)

RotateCropDialog.setShown(self, bool)

RotateCropDialog.setSizeGripEnabled(self, bool)

RotateCropDialog.setSizeIncrement(self, int, int)

setSizeIncrement(self, QSize)

RotateCropDialog.setSizePolicy(self, QSizePolicy)

setSizePolicy(self, QSizePolicy.Policy, QSizePolicy.Policy)

RotateCropDialog.setStatusTip(self, object)

RotateCropDialog.setStyle(self, QStyle)

RotateCropDialog.setStyleSheet(self, object)

RotateCropDialog.setTabOrder(QWidget, QWidget)

RotateCropDialog.setToolTip(self, object)

RotateCropDialog.setUpdatesEnabled(self, bool)

RotateCropDialog.setVisible(self, bool)

RotateCropDialog.setWhatsThis(self, object)

RotateCropDialog.setWindowFilePath(self, object)

RotateCropDialog.setWindowFlags(self, Qt.WindowFlags)

RotateCropDialog.setWindowIcon(self, QIcon)

RotateCropDialog.setWindowIconText(self, object)

RotateCropDialog.setWindowModality(self, Qt.WindowModality)

RotateCropDialog.setWindowModified(self, bool)

RotateCropDialog.setWindowOpacity(self, float)

RotateCropDialog.setWindowRole(self, object)

RotateCropDialog.setWindowState(self, Qt.WindowStates)

RotateCropDialog.setWindowTitle(self, object)

RotateCropDialog.set_active_tool(tool=None)

Set active tool (if tool argument is None, the active tool will be the default tool)

RotateCropDialog.set_contrast_range(zmin, zmax)

Convenience function to set the contrast adjustment panel range

This is strictly equivalent to the following:

# Here, *widget* is for example a CurveWidget instance
# (the same apply for CurvePlot, ImageWidget, ImagePlot or any 
#  class deriving from PlotManager)
widget.get_contrast_panel().set_range(zmin, zmax)

RotateCropDialog.set_default_plot(plot)

Set default plot

The default plot is the plot on which tools and panels will act.

RotateCropDialog.set_default_tool(tool)

Set default tool

RotateCropDialog.set_default_toolbar(toolbar)

Set default toolbar

RotateCropDialog.set_item(item)

Set associated item – must be a TrImageItem object

RotateCropDialog.show(self)

RotateCropDialog.showEvent(self, QShowEvent)

RotateCropDialog.showExtension(self, bool)

RotateCropDialog.showFullScreen(self)

RotateCropDialog.showMaximized(self)

RotateCropDialog.showMinimized(self)

RotateCropDialog.showNormal(self)

RotateCropDialog.show_crop_rect(state)

Show/hide cropping rectangle shape

RotateCropDialog.signalsBlocked(self) → bool

RotateCropDialog.size(self) → QSize

RotateCropDialog.sizeHint(self) → QSize

RotateCropDialog.sizeIncrement(self) → QSize

RotateCropDialog.sizePolicy(self) → QSizePolicy

RotateCropDialog.stackUnder(self, QWidget)

RotateCropDialog.startTimer(self, int) → int

RotateCropDialog.statusTip(self) → object

RotateCropDialog.style(self) → QStyle

RotateCropDialog.styleSheet(self) → object

RotateCropDialog.tabletEvent(self, QTabletEvent)

RotateCropDialog.testAttribute(self, Qt.WidgetAttribute) → bool

RotateCropDialog.thread(self) → QThread

RotateCropDialog.timerEvent(self, QTimerEvent)

RotateCropDialog.toolTip(self) → object

RotateCropDialog.topLevelWidget(self) → QWidget

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

RotateCropDialog.trUtf8(self, object, disambiguation: str = None, n: int = -1) → object

RotateCropDialog.underMouse(self) → bool

RotateCropDialog.ungrabGesture(self, Qt.GestureType)

RotateCropDialog.unsetCursor(self)

RotateCropDialog.unsetLayoutDirection(self)

RotateCropDialog.unsetLocale(self)

RotateCropDialog.unset_item()

Unset the associated item, freeing memory

RotateCropDialog.update(self)

update(self, QRect) update(self, QRegion) update(self, int, int, int, int)

RotateCropDialog.updateGeometry(self)

RotateCropDialog.updateMicroFocus(self)

RotateCropDialog.update_cross_sections()

Convenience function to update the cross section panels at once

This is strictly equivalent to the following:

# Here, *widget* is for example a CurveWidget instance
# (the same apply for CurvePlot, ImageWidget, ImagePlot or any 
#  class deriving from PlotManager)
widget.get_xcs_panel().update_plot()
widget.get_ycs_panel().update_plot()

RotateCropDialog.update_tools_status(plot=None)

Update tools for current plot

RotateCropDialog.updatesEnabled(self) → bool

RotateCropDialog.visibleRegion(self) → QRegion

RotateCropDialog.whatsThis(self) → object

RotateCropDialog.wheelEvent(self, QWheelEvent)

RotateCropDialog.width(self) → int

RotateCropDialog.widthMM(self) → int

RotateCropDialog.winId(self) → int

RotateCropDialog.window(self) → QWidget

RotateCropDialog.windowActivationChange(self, bool)

RotateCropDialog.windowFilePath(self) → object

RotateCropDialog.windowFlags(self) → Qt.WindowFlags

RotateCropDialog.windowIcon(self) → QIcon

RotateCropDialog.windowIconText(self) → object

RotateCropDialog.windowModality(self) → Qt.WindowModality

RotateCropDialog.windowOpacity(self) → float

RotateCropDialog.windowRole(self) → object

RotateCropDialog.windowState(self) → Qt.WindowStates

RotateCropDialog.windowTitle(self) → object

RotateCropDialog.windowType(self) → Qt.WindowType

RotateCropDialog.x(self) → int

RotateCropDialog.x11Info(self) → QX11Info

RotateCropDialog.x11PictureHandle(self) → int

RotateCropDialog.y(self) → int

class guiqwt.widgets.rotatecrop.RotateCropWidget(parent, options=None)

Rotate & Crop Widget

Rotate and crop a guiqwt.image.TrImageItem plot item

class RenderFlags(QWidget.RenderFlags)

QWidget.RenderFlags(int) QWidget.RenderFlags()

RotateCropWidget.acceptDrops(self) → bool

RotateCropWidget.accept_changes()

Computed rotated/cropped array and apply changes to item

RotateCropWidget.accessibleDescription(self) → object

RotateCropWidget.accessibleName(self) → object

RotateCropWidget.actionEvent(self, QActionEvent)

RotateCropWidget.actions(self) → object

RotateCropWidget.activateWindow(self)

RotateCropWidget.addAction(self, QAction)

RotateCropWidget.addActions(self, object)

RotateCropWidget.add_apply_button(layout)

Add the standard apply button

RotateCropWidget.add_buttons_to_layout(layout)

Add tool buttons to layout

RotateCropWidget.add_reset_button(layout)

Add the standard reset button

RotateCropWidget.adjustSize(self)

RotateCropWidget.apply_transformation()

Apply transformation, e.g. crop or rotate

RotateCropWidget.autoFillBackground(self) → bool

RotateCropWidget.backgroundRole(self) → QPalette.ColorRole

RotateCropWidget.baseSize(self) → QSize

RotateCropWidget.blockSignals(self, bool) → bool

RotateCropWidget.changeEvent(self, QEvent)

RotateCropWidget.childAt(self, QPoint) → QWidget

childAt(self, int, int) -> QWidget

RotateCropWidget.childEvent(self, QChildEvent)

RotateCropWidget.children(self) → object

RotateCropWidget.childrenRect(self) → QRect

RotateCropWidget.childrenRegion(self) → QRegion

RotateCropWidget.clearFocus(self)

RotateCropWidget.clearMask(self)

RotateCropWidget.close(self) → bool

RotateCropWidget.closeEvent(self, QCloseEvent)

RotateCropWidget.colorCount(self) → int

RotateCropWidget.compute_transformation()

Compute transformation, return compute output array

RotateCropWidget.connect(QObject, QT_SIGNAL, QObject, QT_SLOT_QT_SIGNAL, Qt.ConnectionType = Qt.AutoConnection) → object

connect(QObject, QT_SIGNAL, Callable[..., None], Qt.ConnectionType = Qt.AutoConnection) -> object connect(self, QObject, QT_SIGNAL, QT_SLOT_QT_SIGNAL, Qt.ConnectionType = Qt.AutoConnection) -> object

RotateCropWidget.connectNotify(self, QT_SIGNAL)

RotateCropWidget.contentsMargins(self) → QMargins

RotateCropWidget.contentsRect(self) → QRect

RotateCropWidget.contextMenuEvent(self, QContextMenuEvent)

RotateCropWidget.contextMenuPolicy(self) → Qt.ContextMenuPolicy

RotateCropWidget.create(self, window: int = 0, initializeWindow: bool = True, destroyOldWindow: bool = True)

RotateCropWidget.cursor(self) → QCursor

RotateCropWidget.customContextMenuRequested

customContextMenuRequested(self, QPoint) [signal]

RotateCropWidget.customEvent(self, QEvent)

RotateCropWidget.deleteLater(self)

RotateCropWidget.depth(self) → int

RotateCropWidget.destroy(self, destroyWindow: bool = True, destroySubWindows: bool = True)

RotateCropWidget.destroyed

destroyed(self, QObject = None) [signal] destroyed(self) [signal]

RotateCropWidget.devType(self) → int

RotateCropWidget.disconnect(QObject, QT_SIGNAL, QObject, QT_SLOT_QT_SIGNAL) → object

disconnect(QObject, QT_SIGNAL, Callable[..., None]) -> object

RotateCropWidget.disconnectNotify(self, QT_SIGNAL)

RotateCropWidget.dragEnterEvent(self, QDragEnterEvent)

RotateCropWidget.dragLeaveEvent(self, QDragLeaveEvent)

RotateCropWidget.dragMoveEvent(self, QDragMoveEvent)

RotateCropWidget.dropEvent(self, QDropEvent)

RotateCropWidget.dumpObjectInfo(self)

RotateCropWidget.dumpObjectTree(self)

RotateCropWidget.dynamicPropertyNames(self) → object

RotateCropWidget.effectiveWinId(self) → int

RotateCropWidget.emit(self, QT_SIGNAL, *)

RotateCropWidget.enabledChange(self, bool)

RotateCropWidget.ensurePolished(self)

RotateCropWidget.enterEvent(self, QEvent)

RotateCropWidget.event(self, QEvent) → bool

RotateCropWidget.eventFilter(self, QObject, QEvent) → bool

RotateCropWidget.find(int) → QWidget

RotateCropWidget.findChild(self, type, name: object = '') → object

findChild(self, Tuple, name: object = ‘’) -> object

RotateCropWidget.findChildren(self, type, name: object = '') → List

findChildren(self, Tuple, name: object = ‘’) -> List findChildren(self, type, QRegExp) -> List findChildren(self, Tuple, QRegExp) -> List

RotateCropWidget.focusInEvent(self, QFocusEvent)

RotateCropWidget.focusNextChild(self) → bool

RotateCropWidget.focusNextPrevChild(self, bool) → bool

RotateCropWidget.focusOutEvent(self, QFocusEvent)

RotateCropWidget.focusPolicy(self) → Qt.FocusPolicy

RotateCropWidget.focusPreviousChild(self) → bool

RotateCropWidget.focusProxy(self) → QWidget

RotateCropWidget.focusWidget(self) → QWidget

RotateCropWidget.font(self) → QFont

RotateCropWidget.fontChange(self, QFont)

RotateCropWidget.fontInfo(self) → QFontInfo

RotateCropWidget.fontMetrics(self) → QFontMetrics

RotateCropWidget.foregroundRole(self) → QPalette.ColorRole

RotateCropWidget.frameGeometry(self) → QRect

RotateCropWidget.frameSize(self) → QSize

RotateCropWidget.geometry(self) → QRect

RotateCropWidget.getContentsMargins(self) → Tuple[int, int, int, int]

RotateCropWidget.get_plot()

Required for BaseTransformMixin

RotateCropWidget.grabGesture(self, Qt.GestureType, flags: Qt.GestureFlags = Qt.GestureFlags(0))

RotateCropWidget.grabKeyboard(self)

RotateCropWidget.grabMouse(self)

grabMouse(self, QCursor)

RotateCropWidget.grabShortcut(self, QKeySequence, context: Qt.ShortcutContext = Qt.WindowShortcut) → int

RotateCropWidget.graphicsEffect(self) → QGraphicsEffect

RotateCropWidget.graphicsProxyWidget(self) → QGraphicsProxyWidget

RotateCropWidget.handle(self) → int

RotateCropWidget.hasFocus(self) → bool

RotateCropWidget.hasMouseTracking(self) → bool

RotateCropWidget.height(self) → int

RotateCropWidget.heightForWidth(self, int) → int

RotateCropWidget.heightMM(self) → int

RotateCropWidget.hide(self)

RotateCropWidget.hideEvent(self, QHideEvent)

RotateCropWidget.inherits(self, str) → bool

RotateCropWidget.inputContext(self) → QInputContext

RotateCropWidget.inputMethodEvent(self, QInputMethodEvent)

RotateCropWidget.inputMethodHints(self) → Qt.InputMethodHints

RotateCropWidget.inputMethodQuery(self, Qt.InputMethodQuery) → object

RotateCropWidget.insertAction(self, QAction, QAction)

RotateCropWidget.insertActions(self, QAction, object)

RotateCropWidget.installEventFilter(self, QObject)

RotateCropWidget.isActiveWindow(self) → bool

RotateCropWidget.isAncestorOf(self, QWidget) → bool

RotateCropWidget.isEnabled(self) → bool

RotateCropWidget.isEnabledTo(self, QWidget) → bool

RotateCropWidget.isEnabledToTLW(self) → bool

RotateCropWidget.isFullScreen(self) → bool

RotateCropWidget.isHidden(self) → bool

RotateCropWidget.isLeftToRight(self) → bool

RotateCropWidget.isMaximized(self) → bool

RotateCropWidget.isMinimized(self) → bool

RotateCropWidget.isModal(self) → bool

RotateCropWidget.isRightToLeft(self) → bool

RotateCropWidget.isTopLevel(self) → bool

RotateCropWidget.isVisible(self) → bool

RotateCropWidget.isVisibleTo(self, QWidget) → bool

RotateCropWidget.isWidgetType(self) → bool

RotateCropWidget.isWindow(self) → bool

RotateCropWidget.isWindowModified(self) → bool

RotateCropWidget.keyPressEvent(self, QKeyEvent)

RotateCropWidget.keyReleaseEvent(self, QKeyEvent)

RotateCropWidget.keyboardGrabber() → QWidget

RotateCropWidget.killTimer(self, int)

RotateCropWidget.languageChange(self)

RotateCropWidget.layout(self) → QLayout

RotateCropWidget.layoutDirection(self) → Qt.LayoutDirection

RotateCropWidget.leaveEvent(self, QEvent)

RotateCropWidget.locale(self) → QLocale

RotateCropWidget.logicalDpiX(self) → int

RotateCropWidget.logicalDpiY(self) → int

RotateCropWidget.lower(self)

RotateCropWidget.mapFrom(self, QWidget, QPoint) → QPoint

RotateCropWidget.mapFromGlobal(self, QPoint) → QPoint

RotateCropWidget.mapFromParent(self, QPoint) → QPoint

RotateCropWidget.mapTo(self, QWidget, QPoint) → QPoint

RotateCropWidget.mapToGlobal(self, QPoint) → QPoint

RotateCropWidget.mapToParent(self, QPoint) → QPoint

RotateCropWidget.mask(self) → QRegion

RotateCropWidget.maximumHeight(self) → int

RotateCropWidget.maximumSize(self) → QSize

RotateCropWidget.maximumWidth(self) → int

RotateCropWidget.metaObject(self) → QMetaObject

RotateCropWidget.metric(self, QPaintDevice.PaintDeviceMetric) → int

RotateCropWidget.minimumHeight(self) → int

RotateCropWidget.minimumSize(self) → QSize

RotateCropWidget.minimumSizeHint(self) → QSize

RotateCropWidget.minimumWidth(self) → int

RotateCropWidget.mouseDoubleClickEvent(self, QMouseEvent)

RotateCropWidget.mouseGrabber() → QWidget

RotateCropWidget.mouseMoveEvent(self, QMouseEvent)

RotateCropWidget.mousePressEvent(self, QMouseEvent)

RotateCropWidget.mouseReleaseEvent(self, QMouseEvent)

RotateCropWidget.move(self, QPoint)

move(self, int, int)

RotateCropWidget.moveEvent(self, QMoveEvent)

RotateCropWidget.moveToThread(self, QThread)

RotateCropWidget.nativeParentWidget(self) → QWidget

RotateCropWidget.nextInFocusChain(self) → QWidget

RotateCropWidget.normalGeometry(self) → QRect

RotateCropWidget.numColors(self) → int

RotateCropWidget.objectName(self) → object

RotateCropWidget.overrideWindowFlags(self, Qt.WindowFlags)

RotateCropWidget.overrideWindowState(self, Qt.WindowStates)

RotateCropWidget.paintEngine(self) → QPaintEngine

RotateCropWidget.paintEvent(self, QPaintEvent)

RotateCropWidget.paintingActive(self) → bool

RotateCropWidget.palette(self) → QPalette

RotateCropWidget.paletteChange(self, QPalette)

RotateCropWidget.parent(self) → QObject

RotateCropWidget.parentWidget(self) → QWidget

RotateCropWidget.physicalDpiX(self) → int

RotateCropWidget.physicalDpiY(self) → int

RotateCropWidget.pos(self) → QPoint

RotateCropWidget.previousInFocusChain(self) → QWidget

RotateCropWidget.property(self, str) → object

RotateCropWidget.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.

RotateCropWidget.raise_(self)

RotateCropWidget.receivers(self, QT_SIGNAL) → int

RotateCropWidget.rect(self) → QRect

RotateCropWidget.reject_changes()

Restore item original transform settings

RotateCropWidget.releaseKeyboard(self)

RotateCropWidget.releaseMouse(self)

RotateCropWidget.releaseShortcut(self, int)

RotateCropWidget.removeAction(self, QAction)

RotateCropWidget.removeEventFilter(self, QObject)

RotateCropWidget.render(self, QPaintDevice, targetOffset: QPoint = QPoint(), sourceRegion: QRegion = QRegion(), flags: QWidget.RenderFlags = QWidget.DrawWindowBackground|QWidget.DrawChildren)

render(self, QPainter, targetOffset: QPoint = QPoint(), sourceRegion: QRegion = QRegion(), flags: QWidget.RenderFlags = QWidget.DrawWindowBackground|QWidget.DrawChildren)

RotateCropWidget.repaint(self)

repaint(self, int, int, int, int) repaint(self, QRect) repaint(self, QRegion)

RotateCropWidget.reset()

Reset crop/transform image settings

RotateCropWidget.resetInputContext(self)

RotateCropWidget.reset_transformation()

Reset transformation

RotateCropWidget.resize(self, QSize)

resize(self, int, int)

RotateCropWidget.resizeEvent(self, QResizeEvent)

RotateCropWidget.restoreGeometry(self, QByteArray) → bool

RotateCropWidget.restore_original_state()

Restore item original state

RotateCropWidget.saveGeometry(self) → QByteArray

RotateCropWidget.scroll(self, int, int)

scroll(self, int, int, QRect)

RotateCropWidget.sender(self) → QObject

RotateCropWidget.senderSignalIndex(self) → int

RotateCropWidget.setAcceptDrops(self, bool)

RotateCropWidget.setAccessibleDescription(self, object)

RotateCropWidget.setAccessibleName(self, object)

RotateCropWidget.setAttribute(self, Qt.WidgetAttribute, on: bool = True)

RotateCropWidget.setAutoFillBackground(self, bool)

RotateCropWidget.setBackgroundRole(self, QPalette.ColorRole)

RotateCropWidget.setBaseSize(self, int, int)

setBaseSize(self, QSize)

RotateCropWidget.setContentsMargins(self, int, int, int, int)

setContentsMargins(self, QMargins)

RotateCropWidget.setContextMenuPolicy(self, Qt.ContextMenuPolicy)

RotateCropWidget.setCursor(self, QCursor)

RotateCropWidget.setDisabled(self, bool)

RotateCropWidget.setEnabled(self, bool)

RotateCropWidget.setFixedHeight(self, int)

RotateCropWidget.setFixedSize(self, QSize)

setFixedSize(self, int, int)

RotateCropWidget.setFixedWidth(self, int)

RotateCropWidget.setFocus(self)

setFocus(self, Qt.FocusReason)

RotateCropWidget.setFocusPolicy(self, Qt.FocusPolicy)

RotateCropWidget.setFocusProxy(self, QWidget)

RotateCropWidget.setFont(self, QFont)

RotateCropWidget.setForegroundRole(self, QPalette.ColorRole)

RotateCropWidget.setGeometry(self, QRect)

setGeometry(self, int, int, int, int)

RotateCropWidget.setGraphicsEffect(self, QGraphicsEffect)

RotateCropWidget.setHidden(self, bool)

RotateCropWidget.setInputContext(self, QInputContext)

RotateCropWidget.setInputMethodHints(self, Qt.InputMethodHints)

RotateCropWidget.setLayout(self, QLayout)

RotateCropWidget.setLayoutDirection(self, Qt.LayoutDirection)

RotateCropWidget.setLocale(self, QLocale)

RotateCropWidget.setMask(self, QBitmap)

setMask(self, QRegion)

RotateCropWidget.setMaximumHeight(self, int)

RotateCropWidget.setMaximumSize(self, int, int)

setMaximumSize(self, QSize)

RotateCropWidget.setMaximumWidth(self, int)

RotateCropWidget.setMinimumHeight(self, int)

RotateCropWidget.setMinimumSize(self, int, int)

setMinimumSize(self, QSize)

RotateCropWidget.setMinimumWidth(self, int)

RotateCropWidget.setMouseTracking(self, bool)

RotateCropWidget.setObjectName(self, object)

RotateCropWidget.setPalette(self, QPalette)

RotateCropWidget.setParent(self, QWidget)

setParent(self, QWidget, Qt.WindowFlags)

RotateCropWidget.setProperty(self, str, object) → bool

RotateCropWidget.setShortcutAutoRepeat(self, int, enabled: bool = True)

RotateCropWidget.setShortcutEnabled(self, int, enabled: bool = True)

RotateCropWidget.setShown(self, bool)

RotateCropWidget.setSizeIncrement(self, int, int)

setSizeIncrement(self, QSize)

RotateCropWidget.setSizePolicy(self, QSizePolicy)

setSizePolicy(self, QSizePolicy.Policy, QSizePolicy.Policy)

RotateCropWidget.setStatusTip(self, object)

RotateCropWidget.setStyle(self, QStyle)

RotateCropWidget.setStyleSheet(self, object)

RotateCropWidget.setTabOrder(QWidget, QWidget)

RotateCropWidget.setToolTip(self, object)

RotateCropWidget.setUpdatesEnabled(self, bool)

RotateCropWidget.setVisible(self, bool)

RotateCropWidget.setWhatsThis(self, object)

RotateCropWidget.setWindowFilePath(self, object)

RotateCropWidget.setWindowFlags(self, Qt.WindowFlags)

RotateCropWidget.setWindowIcon(self, QIcon)

RotateCropWidget.setWindowIconText(self, object)

RotateCropWidget.setWindowModality(self, Qt.WindowModality)

RotateCropWidget.setWindowModified(self, bool)

RotateCropWidget.setWindowOpacity(self, float)

RotateCropWidget.setWindowRole(self, object)

RotateCropWidget.setWindowState(self, Qt.WindowStates)

RotateCropWidget.setWindowTitle(self, object)

RotateCropWidget.set_item(item)

Set associated item – must be a TrImageItem object

RotateCropWidget.show(self)

RotateCropWidget.showEvent(self, QShowEvent)

RotateCropWidget.showFullScreen(self)

RotateCropWidget.showMaximized(self)

RotateCropWidget.showMinimized(self)

RotateCropWidget.showNormal(self)

RotateCropWidget.show_crop_rect(state)

Show/hide cropping rectangle shape

RotateCropWidget.signalsBlocked(self) → bool

RotateCropWidget.size(self) → QSize

RotateCropWidget.sizeHint(self) → QSize

RotateCropWidget.sizeIncrement(self) → QSize

RotateCropWidget.sizePolicy(self) → QSizePolicy

RotateCropWidget.stackUnder(self, QWidget)

RotateCropWidget.startTimer(self, int) → int

RotateCropWidget.statusTip(self) → object

RotateCropWidget.style(self) → QStyle

RotateCropWidget.styleSheet(self) → object

RotateCropWidget.tabletEvent(self, QTabletEvent)

RotateCropWidget.testAttribute(self, Qt.WidgetAttribute) → bool

RotateCropWidget.thread(self) → QThread

RotateCropWidget.timerEvent(self, QTimerEvent)

RotateCropWidget.toolTip(self) → object

RotateCropWidget.topLevelWidget(self) → QWidget

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

RotateCropWidget.trUtf8(self, object, disambiguation: str = None, n: int = -1) → object

RotateCropWidget.underMouse(self) → bool

RotateCropWidget.ungrabGesture(self, Qt.GestureType)

RotateCropWidget.unsetCursor(self)

RotateCropWidget.unsetLayoutDirection(self)

RotateCropWidget.unsetLocale(self)

RotateCropWidget.unset_item()

Unset the associated item, freeing memory

RotateCropWidget.update(self)

update(self, QRect) update(self, QRegion) update(self, int, int, int, int)

RotateCropWidget.updateGeometry(self)

RotateCropWidget.updateMicroFocus(self)

RotateCropWidget.updatesEnabled(self) → bool

RotateCropWidget.visibleRegion(self) → QRegion

RotateCropWidget.whatsThis(self) → object

RotateCropWidget.wheelEvent(self, QWheelEvent)

RotateCropWidget.width(self) → int

RotateCropWidget.widthMM(self) → int

RotateCropWidget.winId(self) → int

RotateCropWidget.window(self) → QWidget

RotateCropWidget.windowActivationChange(self, bool)

RotateCropWidget.windowFilePath(self) → object

RotateCropWidget.windowFlags(self) → Qt.WindowFlags

RotateCropWidget.windowIcon(self) → QIcon

RotateCropWidget.windowIconText(self) → object

RotateCropWidget.windowModality(self) → Qt.WindowModality

RotateCropWidget.windowOpacity(self) → float

RotateCropWidget.windowRole(self) → object

RotateCropWidget.windowState(self) → Qt.WindowStates

RotateCropWidget.windowTitle(self) → object

RotateCropWidget.windowType(self) → Qt.WindowType

RotateCropWidget.x(self) → int

RotateCropWidget.x11Info(self) → QX11Info

RotateCropWidget.x11PictureHandle(self) → int

RotateCropWidget.y(self) → int