pyrobopath.toolpath.visualization.pyqtgraph_backend.ToolpathViewer#

class pyrobopath.toolpath.visualization.pyqtgraph_backend.ToolpathViewer[source]#

Bases: QMainWindow

Methods

`acceptDrops`	acceptDrops(self) -> bool
`accessibleDescription`	accessibleDescription(self) -> str
`accessibleName`	accessibleName(self) -> str
`actionEvent`	actionEvent(self, a0: Optional[QActionEvent])
`actions`	actions(self) -> List[QAction]
`activateWindow`	activateWindow(self)
`addAction`	addAction(self, action: Optional[QAction])
`addActions`	addActions(self, actions: Iterable[QAction])
`addDockWidget`	addDockWidget(self, area: Qt.DockWidgetArea, dockwidget: Optional[QDockWidget]) addDockWidget(self, area: Qt.DockWidgetArea, dockwidget: Optional[QDockWidget], orientation: Qt.Orientation)
`addToolBar`	addToolBar(self, area: Qt.ToolBarArea, toolbar: Optional[QToolBar]) addToolBar(self, toolbar: Optional[QToolBar]) addToolBar(self, title: Optional[str]) -> Optional[QToolBar]
`addToolBarBreak`	addToolBarBreak(self, area: Qt.ToolBarArea = Qt.TopToolBarArea)
`add_contour`
`add_toolpath`
`adjustSize`	adjustSize(self)
`autoFillBackground`	autoFillBackground(self) -> bool
`backgroundRole`	backgroundRole(self) -> QPalette.ColorRole
`baseSize`	baseSize(self) -> QSize
`blockSignals`	blockSignals(self, b: bool) -> bool
`centralWidget`	centralWidget(self) -> Optional[QWidget]
`changeEvent`	changeEvent(self, a0: Optional[QEvent])
`childAt`	childAt(self, p: QPoint) -> Optional[QWidget] childAt(self, ax: int, ay: int) -> Optional[QWidget]
`childEvent`	childEvent(self, a0: Optional[QChildEvent])
`children`	children(self) -> List[QObject]
`childrenRect`	childrenRect(self) -> QRect
`childrenRegion`	childrenRegion(self) -> QRegion
`clearFocus`	clearFocus(self)
`clearMask`	clearMask(self)
`close`	close(self) -> bool
`closeEvent`	closeEvent(self, a0: Optional[QCloseEvent])
`colorCount`	colorCount(self) -> int
`connectNotify`	connectNotify(self, signal: QMetaMethod)
`contentsMargins`	contentsMargins(self) -> QMargins
`contentsRect`	contentsRect(self) -> QRect
`contextMenuEvent`	contextMenuEvent(self, event: Optional[QContextMenuEvent])
`contextMenuPolicy`	contextMenuPolicy(self) -> Qt.ContextMenuPolicy
`corner`	corner(self, corner: Qt.Corner) -> Qt.DockWidgetArea
`create`	create(self, window: PyQt5.sip.voidptr = None, initializeWindow: bool = True, destroyOldWindow: bool = True)
`createPopupMenu`	createPopupMenu(self) -> Optional[QMenu]
`createWindowContainer`	createWindowContainer(window: Optional[QWindow], parent: Optional[QWidget] = None, flags: Union[Qt.WindowFlags, Qt.WindowType] = 0) -> QWidget
`cursor`	cursor(self) -> QCursor
`customEvent`	customEvent(self, a0: Optional[QEvent])
`deleteLater`	deleteLater(self)
`depth`	depth(self) -> int
`destroy`	destroy(self, destroyWindow: bool = True, destroySubWindows: bool = True)
`devType`	devType(self) -> int
`devicePixelRatio`	devicePixelRatio(self) -> int
`devicePixelRatioF`	devicePixelRatioF(self) -> float
`devicePixelRatioFScale`	devicePixelRatioFScale() -> float
`disconnect`	disconnect(a0: QMetaObject.Connection) -> bool disconnect(self)
`disconnectNotify`	disconnectNotify(self, signal: QMetaMethod)
`dockOptions`	dockOptions(self) -> QMainWindow.DockOptions
`dockWidgetArea`	dockWidgetArea(self, dockwidget: Optional[QDockWidget]) -> Qt.DockWidgetArea
`documentMode`	documentMode(self) -> bool
`dragEnterEvent`	dragEnterEvent(self, a0: Optional[QDragEnterEvent])
`dragLeaveEvent`	dragLeaveEvent(self, a0: Optional[QDragLeaveEvent])
`dragMoveEvent`	dragMoveEvent(self, a0: Optional[QDragMoveEvent])
`dropEvent`	dropEvent(self, a0: Optional[QDropEvent])
`dumpObjectInfo`	dumpObjectInfo(self)
`dumpObjectTree`	dumpObjectTree(self)
`dynamicPropertyNames`	dynamicPropertyNames(self) -> List[QByteArray]
`effectiveWinId`	effectiveWinId(self) -> PyQt5.sip.voidptr
`ensurePolished`	ensurePolished(self)
`enterEvent`	enterEvent(self, a0: Optional[QEvent])
`event`	event(self, event: Optional[QEvent]) -> bool
`eventFilter`	eventFilter(self, a0: Optional[QObject], a1: Optional[QEvent]) -> bool
`find`	find(a0: PyQt5.sip.voidptr) -> Optional[QWidget]
`findChild`	findChild(self, type: Type[QObjectT], name: Optional[str] = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) -> QObjectT findChild(self, types: Tuple[Type[QObjectT], ...], name: Optional[str] = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) -> QObjectT
`findChildren`	findChildren(self, type: Type[QObjectT], name: Optional[str] = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) -> List[QObjectT] findChildren(self, types: Tuple[Type[QObjectT], ...], name: Optional[str] = '', options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) -> List[QObjectT] findChildren(self, type: Type[QObjectT], regExp: QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) -> List[QObjectT] findChildren(self, types: Tuple[Type[QObjectT], ...], regExp: QRegExp, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) -> List[QObjectT] findChildren(self, type: Type[QObjectT], re: QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) -> List[QObjectT] findChildren(self, types: Tuple[Type[QObjectT], ...], re: QRegularExpression, options: Union[Qt.FindChildOptions, Qt.FindChildOption] = Qt.FindChildrenRecursively) -> List[QObjectT]
`focusInEvent`	focusInEvent(self, a0: Optional[QFocusEvent])
`focusNextChild`	focusNextChild(self) -> bool
`focusNextPrevChild`	focusNextPrevChild(self, next: bool) -> bool
`focusOutEvent`	focusOutEvent(self, a0: Optional[QFocusEvent])
`focusPolicy`	focusPolicy(self) -> Qt.FocusPolicy
`focusPreviousChild`	focusPreviousChild(self) -> bool
`focusProxy`	focusProxy(self) -> Optional[QWidget]
`focusWidget`	focusWidget(self) -> Optional[QWidget]
`font`	font(self) -> QFont
`fontInfo`	fontInfo(self) -> QFontInfo
`fontMetrics`	fontMetrics(self) -> QFontMetrics
`foregroundRole`	foregroundRole(self) -> QPalette.ColorRole
`frameGeometry`	frameGeometry(self) -> QRect
`frameSize`	frameSize(self) -> QSize
`geometry`	geometry(self) -> QRect
`getContentsMargins`	getContentsMargins(self) -> (Optional[int], Optional[int], Optional[int], Optional[int])
`grab`	grab(self, rectangle: QRect = QRect(QPoint(0, 0), QSize(-1, -1))) -> QPixmap
`grabGesture`	grabGesture(self, type: Qt.GestureType, flags: Union[Qt.GestureFlags, Qt.GestureFlag] = Qt.GestureFlags())
`grabKeyboard`	grabKeyboard(self)
`grabMouse`	grabMouse(self) grabMouse(self, a0: Union[QCursor, Qt.CursorShape])
`grabShortcut`	grabShortcut(self, key: Union[QKeySequence, QKeySequence.StandardKey, Optional[str], int], context: Qt.ShortcutContext = Qt.WindowShortcut) -> int
`graphicsEffect`	graphicsEffect(self) -> Optional[QGraphicsEffect]
`graphicsProxyWidget`	graphicsProxyWidget(self) -> Optional[QGraphicsProxyWidget]
`hasFocus`	hasFocus(self) -> bool
`hasHeightForWidth`	hasHeightForWidth(self) -> bool
`hasMouseTracking`	hasMouseTracking(self) -> bool
`hasTabletTracking`	hasTabletTracking(self) -> bool
`height`	height(self) -> int
`heightForWidth`	heightForWidth(self, a0: int) -> int
`heightMM`	heightMM(self) -> int
`hide`	hide(self)
`hideEvent`	hideEvent(self, a0: Optional[QHideEvent])
`iconSize`	iconSize(self) -> QSize
`inherits`	inherits(self, classname: Optional[str]) -> bool
`initPainter`	initPainter(self, painter: Optional[QPainter])
`inputMethodEvent`	inputMethodEvent(self, a0: Optional[QInputMethodEvent])
`inputMethodHints`	inputMethodHints(self) -> Qt.InputMethodHints
`inputMethodQuery`	inputMethodQuery(self, a0: Qt.InputMethodQuery) -> Any
`insertAction`	insertAction(self, before: Optional[QAction], action: Optional[QAction])
`insertActions`	insertActions(self, before: Optional[QAction], actions: Iterable[QAction])
`insertToolBar`	insertToolBar(self, before: Optional[QToolBar], toolbar: Optional[QToolBar])
`insertToolBarBreak`	insertToolBarBreak(self, before: Optional[QToolBar])
`installEventFilter`	installEventFilter(self, a0: Optional[QObject])
`isActiveWindow`	isActiveWindow(self) -> bool
`isAncestorOf`	isAncestorOf(self, child: Optional[QWidget]) -> bool
`isAnimated`	isAnimated(self) -> bool
`isDockNestingEnabled`	isDockNestingEnabled(self) -> bool
`isEnabled`	isEnabled(self) -> bool
`isEnabledTo`	isEnabledTo(self, a0: Optional[QWidget]) -> bool
`isFullScreen`	isFullScreen(self) -> bool
`isHidden`	isHidden(self) -> bool
`isLeftToRight`	isLeftToRight(self) -> bool
`isMaximized`	isMaximized(self) -> bool
`isMinimized`	isMinimized(self) -> bool
`isModal`	isModal(self) -> bool
`isRightToLeft`	isRightToLeft(self) -> bool
`isSeparator`	isSeparator(self, pos: QPoint) -> bool
`isSignalConnected`	isSignalConnected(self, signal: QMetaMethod) -> bool
`isVisible`	isVisible(self) -> bool
`isVisibleTo`	isVisibleTo(self, a0: Optional[QWidget]) -> bool
`isWidgetType`	isWidgetType(self) -> bool
`isWindow`	isWindow(self) -> bool
`isWindowModified`	isWindowModified(self) -> bool
`isWindowType`	isWindowType(self) -> bool
`keyPressEvent`	keyPressEvent(self, a0: Optional[QKeyEvent])
`keyReleaseEvent`	keyReleaseEvent(self, a0: Optional[QKeyEvent])
`keyboardGrabber`	keyboardGrabber() -> Optional[QWidget]
`killTimer`	killTimer(self, id: int)
`layout`	layout(self) -> Optional[QLayout]
`layoutDirection`	layoutDirection(self) -> Qt.LayoutDirection
`leaveEvent`	leaveEvent(self, a0: Optional[QEvent])
`locale`	locale(self) -> QLocale
`logicalDpiX`	logicalDpiX(self) -> int
`logicalDpiY`	logicalDpiY(self) -> int
`lower`	lower(self)
`mapFrom`	mapFrom(self, a0: Optional[QWidget], a1: QPoint) -> QPoint
`mapFromGlobal`	mapFromGlobal(self, a0: QPoint) -> QPoint
`mapFromParent`	mapFromParent(self, a0: QPoint) -> QPoint
`mapTo`	mapTo(self, a0: Optional[QWidget], a1: QPoint) -> QPoint
`mapToGlobal`	mapToGlobal(self, a0: QPoint) -> QPoint
`mapToParent`	mapToParent(self, a0: QPoint) -> QPoint
`mask`	mask(self) -> QRegion
`maximumHeight`	maximumHeight(self) -> int
`maximumSize`	maximumSize(self) -> QSize
`maximumWidth`	maximumWidth(self) -> int
`menuBar`	menuBar(self) -> Optional[QMenuBar]
`menuWidget`	menuWidget(self) -> Optional[QWidget]
`metaObject`	metaObject(self) -> Optional[QMetaObject]
`metric`	metric(self, a0: QPaintDevice.PaintDeviceMetric) -> int
`minimumHeight`	minimumHeight(self) -> int
`minimumSize`	minimumSize(self) -> QSize
`minimumSizeHint`	minimumSizeHint(self) -> QSize
`minimumWidth`	minimumWidth(self) -> int
`mouseDoubleClickEvent`	mouseDoubleClickEvent(self, a0: Optional[QMouseEvent])
`mouseGrabber`	mouseGrabber() -> Optional[QWidget]
`mouseMoveEvent`	mouseMoveEvent(self, a0: Optional[QMouseEvent])
`mousePressEvent`	mousePressEvent(self, a0: Optional[QMouseEvent])
`mouseReleaseEvent`	mouseReleaseEvent(self, a0: Optional[QMouseEvent])
`move`	move(self, a0: QPoint) move(self, ax: int, ay: int)
`moveEvent`	moveEvent(self, a0: Optional[QMoveEvent])
`moveToThread`	moveToThread(self, thread: Optional[QThread])
`nativeEvent`	nativeEvent(self, eventType: Union[QByteArray, bytes, bytearray], message: Optional[PyQt5.sip.voidptr]) -> (bool, Optional[int])
`nativeParentWidget`	nativeParentWidget(self) -> Optional[QWidget]
`nextInFocusChain`	nextInFocusChain(self) -> Optional[QWidget]
`normalGeometry`	normalGeometry(self) -> QRect
`objectName`	objectName(self) -> str
`overrideWindowFlags`	overrideWindowFlags(self, type: Union[Qt.WindowFlags, Qt.WindowType])
`overrideWindowState`	overrideWindowState(self, state: Union[Qt.WindowStates, Qt.WindowState])
`paintEngine`	paintEngine(self) -> Optional[QPaintEngine]
`paintEvent`	paintEvent(self, a0: Optional[QPaintEvent])
`paintingActive`	paintingActive(self) -> bool
`palette`	palette(self) -> QPalette
`parent`	parent(self) -> Optional[QObject]
`parentWidget`	parentWidget(self) -> Optional[QWidget]
`physicalDpiX`	physicalDpiX(self) -> int
`physicalDpiY`	physicalDpiY(self) -> int
`pos`	pos(self) -> QPoint
`previousInFocusChain`	previousInFocusChain(self) -> Optional[QWidget]
`property`	property(self, name: Optional[str]) -> Any
`pyqtConfigure`	QObject.pyqtConfigure(...)
`raise_`	raise_(self)
`receivers`	receivers(self, signal: PYQT_SIGNAL) -> int
`rect`	rect(self) -> QRect
`releaseKeyboard`	releaseKeyboard(self)
`releaseMouse`	releaseMouse(self)
`releaseShortcut`	releaseShortcut(self, id: int)
`removeAction`	removeAction(self, action: Optional[QAction])
`removeDockWidget`	removeDockWidget(self, dockwidget: Optional[QDockWidget])
`removeEventFilter`	removeEventFilter(self, a0: Optional[QObject])
`removeToolBar`	removeToolBar(self, toolbar: Optional[QToolBar])
`removeToolBarBreak`	removeToolBarBreak(self, before: Optional[QToolBar])
`render`	render(self, target: Optional[QPaintDevice], targetOffset: QPoint = QPoint(), sourceRegion: QRegion = QRegion(), flags: Union[QWidget.RenderFlags, QWidget.RenderFlag] = QWidget.RenderFlags(QWidget.RenderFlag.DrawWindowBackground\|QWidget.RenderFlag.DrawChildren)) render(self, painter: Optional[QPainter], targetOffset: QPoint = QPoint(), sourceRegion: QRegion = QRegion(), flags: Union[QWidget.RenderFlags, QWidget.RenderFlag] = QWidget.RenderFlags(QWidget.RenderFlag.DrawWindowBackground\|QWidget.RenderFlag.DrawChildren))
`repaint`	repaint(self) repaint(self, x: int, y: int, w: int, h: int) repaint(self, a0: QRect) repaint(self, a0: QRegion)
`resize`	resize(self, a0: QSize) resize(self, w: int, h: int)
`resizeDocks`	resizeDocks(self, docks: Iterable[QDockWidget], sizes: Iterable[int], orientation: Qt.Orientation)
`resizeEvent`	resizeEvent(self, a0: Optional[QResizeEvent])
`restoreDockWidget`	restoreDockWidget(self, dockwidget: Optional[QDockWidget]) -> bool
`restoreGeometry`	restoreGeometry(self, geometry: Union[QByteArray, bytes, bytearray]) -> bool
`restoreState`	restoreState(self, state: Union[QByteArray, bytes, bytearray], version: int = 0) -> bool
`saveGeometry`	saveGeometry(self) -> QByteArray
`saveState`	saveState(self, version: int = 0) -> QByteArray
`screen`	screen(self) -> Optional[QScreen]
`scroll`	scroll(self, dx: int, dy: int) scroll(self, dx: int, dy: int, a2: QRect)
`sender`	sender(self) -> Optional[QObject]
`senderSignalIndex`	senderSignalIndex(self) -> int
`setAcceptDrops`	setAcceptDrops(self, on: bool)
`setAccessibleDescription`	setAccessibleDescription(self, description: Optional[str])
`setAccessibleName`	setAccessibleName(self, name: Optional[str])
`setAnimated`	setAnimated(self, enabled: bool)
`setAttribute`	setAttribute(self, attribute: Qt.WidgetAttribute, on: bool = True)
`setAutoFillBackground`	setAutoFillBackground(self, enabled: bool)
`setBackgroundRole`	setBackgroundRole(self, a0: QPalette.ColorRole)
`setBaseSize`	setBaseSize(self, basew: int, baseh: int) setBaseSize(self, s: QSize)
`setCentralWidget`	setCentralWidget(self, widget: Optional[QWidget])
`setContentsMargins`	setContentsMargins(self, left: int, top: int, right: int, bottom: int) setContentsMargins(self, margins: QMargins)
`setContextMenuPolicy`	setContextMenuPolicy(self, policy: Qt.ContextMenuPolicy)
`setCorner`	setCorner(self, corner: Qt.Corner, area: Qt.DockWidgetArea)
`setCursor`	setCursor(self, a0: Union[QCursor, Qt.CursorShape])
`setDisabled`	setDisabled(self, a0: bool)
`setDockNestingEnabled`	setDockNestingEnabled(self, enabled: bool)
`setDockOptions`	setDockOptions(self, options: Union[QMainWindow.DockOptions, QMainWindow.DockOption])
`setDocumentMode`	setDocumentMode(self, enabled: bool)
`setEnabled`	setEnabled(self, a0: bool)
`setFixedHeight`	setFixedHeight(self, h: int)
`setFixedSize`	setFixedSize(self, a0: QSize) setFixedSize(self, w: int, h: int)
`setFixedWidth`	setFixedWidth(self, w: int)
`setFocus`	setFocus(self) setFocus(self, reason: Qt.FocusReason)
`setFocusPolicy`	setFocusPolicy(self, policy: Qt.FocusPolicy)
`setFocusProxy`	setFocusProxy(self, a0: Optional[QWidget])
`setFont`	setFont(self, a0: QFont)
`setForegroundRole`	setForegroundRole(self, a0: QPalette.ColorRole)
`setGeometry`	setGeometry(self, a0: QRect) setGeometry(self, ax: int, ay: int, aw: int, ah: int)
`setGraphicsEffect`	setGraphicsEffect(self, effect: Optional[QGraphicsEffect])
`setHidden`	setHidden(self, hidden: bool)
`setIconSize`	setIconSize(self, iconSize: QSize)
`setInputMethodHints`	setInputMethodHints(self, hints: Union[Qt.InputMethodHints, Qt.InputMethodHint])
`setLayout`	setLayout(self, a0: Optional[QLayout])
`setLayoutDirection`	setLayoutDirection(self, direction: Qt.LayoutDirection)
`setLocale`	setLocale(self, locale: QLocale)
`setMask`	setMask(self, a0: QBitmap) setMask(self, a0: QRegion)
`setMaximumHeight`	setMaximumHeight(self, maxh: int)
`setMaximumSize`	setMaximumSize(self, maxw: int, maxh: int) setMaximumSize(self, s: QSize)
`setMaximumWidth`	setMaximumWidth(self, maxw: int)
`setMenuBar`	setMenuBar(self, menubar: Optional[QMenuBar])
`setMenuWidget`	setMenuWidget(self, menubar: Optional[QWidget])
`setMinimumHeight`	setMinimumHeight(self, minh: int)
`setMinimumSize`	setMinimumSize(self, minw: int, minh: int) setMinimumSize(self, s: QSize)
`setMinimumWidth`	setMinimumWidth(self, minw: int)
`setMouseTracking`	setMouseTracking(self, enable: bool)
`setObjectName`	setObjectName(self, name: Optional[str])
`setPalette`	setPalette(self, a0: QPalette)
`setParent`	setParent(self, parent: Optional[QWidget]) setParent(self, parent: Optional[QWidget], f: Union[Qt.WindowFlags, Qt.WindowType])
`setProperty`	setProperty(self, name: Optional[str], value: Any) -> bool
`setShortcutAutoRepeat`	setShortcutAutoRepeat(self, id: int, enabled: bool = True)
`setShortcutEnabled`	setShortcutEnabled(self, id: int, enabled: bool = True)
`setSizeIncrement`	setSizeIncrement(self, w: int, h: int) setSizeIncrement(self, s: QSize)
`setSizePolicy`	setSizePolicy(self, a0: QSizePolicy) setSizePolicy(self, hor: QSizePolicy.Policy, ver: QSizePolicy.Policy)
`setStatusBar`	setStatusBar(self, statusbar: Optional[QStatusBar])
`setStatusTip`	setStatusTip(self, a0: Optional[str])
`setStyle`	setStyle(self, a0: Optional[QStyle])
`setStyleSheet`	setStyleSheet(self, styleSheet: Optional[str])
`setTabOrder`	setTabOrder(a0: Optional[QWidget], a1: Optional[QWidget])
`setTabPosition`	setTabPosition(self, areas: Union[Qt.DockWidgetAreas, Qt.DockWidgetArea], tabPosition: QTabWidget.TabPosition)
`setTabShape`	setTabShape(self, tabShape: QTabWidget.TabShape)
`setTabletTracking`	setTabletTracking(self, enable: bool)
`setToolButtonStyle`	setToolButtonStyle(self, toolButtonStyle: Qt.ToolButtonStyle)
`setToolTip`	setToolTip(self, a0: Optional[str])
`setToolTipDuration`	setToolTipDuration(self, msec: int)
`setUnifiedTitleAndToolBarOnMac`	setUnifiedTitleAndToolBarOnMac(self, set: bool)
`setUpdatesEnabled`	setUpdatesEnabled(self, enable: bool)
`setVisible`	setVisible(self, visible: bool)
`setWhatsThis`	setWhatsThis(self, a0: Optional[str])
`setWindowFilePath`	setWindowFilePath(self, filePath: Optional[str])
`setWindowFlag`	setWindowFlag(self, a0: Qt.WindowType, on: bool = True)
`setWindowFlags`	setWindowFlags(self, type: Union[Qt.WindowFlags, Qt.WindowType])
`setWindowIcon`	setWindowIcon(self, icon: QIcon)
`setWindowIconText`	setWindowIconText(self, a0: Optional[str])
`setWindowModality`	setWindowModality(self, windowModality: Qt.WindowModality)
`setWindowModified`	setWindowModified(self, a0: bool)
`setWindowOpacity`	setWindowOpacity(self, level: float)
`setWindowRole`	setWindowRole(self, a0: Optional[str])
`setWindowState`	setWindowState(self, state: Union[Qt.WindowStates, Qt.WindowState])
`setWindowTitle`	setWindowTitle(self, a0: Optional[str])
`sharedPainter`	sharedPainter(self) -> Optional[QPainter]
`show`	show(self)
`showEvent`	showEvent(self, a0: Optional[QShowEvent])
`showFullScreen`	showFullScreen(self)
`showMaximized`	showMaximized(self)
`showMinimized`	showMinimized(self)
`showNormal`	showNormal(self)
`signalsBlocked`	signalsBlocked(self) -> bool
`size`	size(self) -> QSize
`sizeHint`	sizeHint(self) -> QSize
`sizeIncrement`	sizeIncrement(self) -> QSize
`sizePolicy`	sizePolicy(self) -> QSizePolicy
`splitDockWidget`	splitDockWidget(self, after: Optional[QDockWidget], dockwidget: Optional[QDockWidget], orientation: Qt.Orientation)
`stackUnder`	stackUnder(self, a0: Optional[QWidget])
`startTimer`	startTimer(self, interval: int, timerType: Qt.TimerType = Qt.CoarseTimer) -> int
`statusBar`	statusBar(self) -> Optional[QStatusBar]
`statusTip`	statusTip(self) -> str
`style`	style(self) -> Optional[QStyle]
`styleSheet`	styleSheet(self) -> str
`tabPosition`	tabPosition(self, area: Qt.DockWidgetArea) -> QTabWidget.TabPosition
`tabShape`	tabShape(self) -> QTabWidget.TabShape
`tabifiedDockWidgets`	tabifiedDockWidgets(self, dockwidget: Optional[QDockWidget]) -> List[QDockWidget]
`tabifyDockWidget`	tabifyDockWidget(self, first: Optional[QDockWidget], second: Optional[QDockWidget])
`tabletEvent`	tabletEvent(self, a0: Optional[QTabletEvent])
`takeCentralWidget`	takeCentralWidget(self) -> Optional[QWidget]
`testAttribute`	testAttribute(self, attribute: Qt.WidgetAttribute) -> bool
`thread`	thread(self) -> Optional[QThread]
`timerEvent`	timerEvent(self, a0: Optional[QTimerEvent])
`toolBarArea`	toolBarArea(self, toolbar: Optional[QToolBar]) -> Qt.ToolBarArea
`toolBarBreak`	toolBarBreak(self, toolbar: Optional[QToolBar]) -> bool
`toolButtonStyle`	toolButtonStyle(self) -> Qt.ToolButtonStyle
`toolTip`	toolTip(self) -> str
`toolTipDuration`	toolTipDuration(self) -> int
`tr`	tr(self, sourceText: Optional[str], disambiguation: Optional[str] = None, n: int = -1) -> str
`underMouse`	underMouse(self) -> bool
`ungrabGesture`	ungrabGesture(self, type: Qt.GestureType)
`unifiedTitleAndToolBarOnMac`	unifiedTitleAndToolBarOnMac(self) -> bool
`unsetCursor`	unsetCursor(self)
`unsetLayoutDirection`	unsetLayoutDirection(self)
`unsetLocale`	unsetLocale(self)
`update`	update(self) update(self, a0: QRect) update(self, a0: QRegion) update(self, ax: int, ay: int, aw: int, ah: int)
`updateGeometry`	updateGeometry(self)
`updateMicroFocus`	updateMicroFocus(self)
`updatesEnabled`	updatesEnabled(self) -> bool
`visibleRegion`	visibleRegion(self) -> QRegion
`whatsThis`	whatsThis(self) -> str
`wheelEvent`	wheelEvent(self, a0: Optional[QWheelEvent])
`width`	width(self) -> int
`widthMM`	widthMM(self) -> int
`winId`	winId(self) -> PyQt5.sip.voidptr
`window`	window(self) -> Optional[QWidget]
`windowFilePath`	windowFilePath(self) -> str
`windowFlags`	windowFlags(self) -> Qt.WindowFlags
`windowHandle`	windowHandle(self) -> Optional[QWindow]
`windowIcon`	windowIcon(self) -> QIcon
`windowIconText`	windowIconText(self) -> str
`windowModality`	windowModality(self) -> Qt.WindowModality
`windowOpacity`	windowOpacity(self) -> float
`windowRole`	windowRole(self) -> str
`windowState`	windowState(self) -> Qt.WindowStates
`windowTitle`	windowTitle(self) -> str
`windowType`	windowType(self) -> Qt.WindowType
`x`	x(self) -> int
`y`	y(self) -> int

Attributes

`AllowNestedDocks`
`AllowTabbedDocks`
`AnimatedDocks`
`DrawChildren`
`DrawWindowBackground`
`ForceTabbedDocks`
`GroupedDragging`
`IgnoreMask`
`PdmDepth`
`PdmDevicePixelRatio`
`PdmDevicePixelRatioScaled`
`PdmDpiX`
`PdmDpiY`
`PdmHeight`
`PdmHeightMM`
`PdmNumColors`
`PdmPhysicalDpiX`
`PdmPhysicalDpiY`
`PdmWidth`
`PdmWidthMM`
`VerticalTabs`
`customContextMenuRequested`	int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL
`destroyed`	int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL
`iconSizeChanged`	int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL
`objectNameChanged`	int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL
`staticMetaObject`
`tabifiedDockWidgetActivated`	int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL
`toolButtonStyleChanged`	int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL
`windowIconChanged`	int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL
`windowIconTextChanged`	int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL
`windowTitleChanged`	int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL

class DockOption#: Bases: int

class DockOptions#
class DockOptions(f: QMainWindow.DockOptions | QMainWindow.DockOption)
class DockOptions(a0: QMainWindow.DockOptions): Bases: simplewrapper

class PaintDeviceMetric#: Bases: int

class RenderFlag#: Bases: int

class RenderFlags#
class RenderFlags(f: QWidget.RenderFlags | QWidget.RenderFlag)
class RenderFlags(a0: QWidget.RenderFlags): Bases: simplewrapper

acceptDrops(self) → bool#

accessibleDescription(self) → str#

accessibleName(self) → str#

actionEvent(self, a0: QActionEvent | None)#

actions(self) → List[QAction]#

activateWindow(self)#

addAction(self, action: QAction | None)#

addActions(self, actions: Iterable[QAction])#

addDockWidget(self, area: Qt.DockWidgetArea, dockwidget: QDockWidget | None)#
addDockWidget(self, area: Qt.DockWidgetArea, dockwidget: QDockWidget | None, orientation: Qt.Orientation) → None

addToolBar(self, area: Qt.ToolBarArea, toolbar: QToolBar | None)#
addToolBar(self, toolbar: QToolBar | None) → None
addToolBar(self, title: str | None) → QToolBar | None

addToolBarBreak(self, area: Qt.ToolBarArea = Qt.TopToolBarArea)#

adjustSize(self)#

autoFillBackground(self) → bool#

backgroundRole(self) → QPalette.ColorRole#

baseSize(self) → QSize#

blockSignals(self, b: bool) → bool#

centralWidget(self) → QWidget | None#

changeEvent(self, a0: QEvent | None)#

childAt(self, p: QPoint) → QWidget | None#
childAt(self, ax: int, ay: int) → QWidget | None

childEvent(self, a0: QChildEvent | None)#

children(self) → List[QObject]#

childrenRect(self) → QRect#

childrenRegion(self) → QRegion#

clearFocus(self)#

clearMask(self)#

close(self) → bool#

closeEvent(self, a0: QCloseEvent | None)#

colorCount(self) → int#

connectNotify(self, signal: QMetaMethod)#

contentsMargins(self) → QMargins#

contentsRect(self) → QRect#

contextMenuEvent(self, event: QContextMenuEvent | None)#

contextMenuPolicy(self) → Qt.ContextMenuPolicy#

corner(self, corner: Qt.Corner) → Qt.DockWidgetArea#

create(self, window: PyQt5.sip.voidptr = None, initializeWindow: bool = True, destroyOldWindow: bool = True)#

createPopupMenu(self) → QMenu | None#

createWindowContainer(window: QWindow | None, parent: QWidget | None = None, flags: Qt.WindowFlags | Qt.WindowType = 0) → QWidget#

cursor(self) → QCursor#

customEvent(self, a0: QEvent | None)#

deleteLater(self)#

depth(self) → int#

destroy(self, destroyWindow: bool = True, destroySubWindows: bool = True)#

devType(self) → int#

devicePixelRatio(self) → int#

devicePixelRatioF(self) → float#

devicePixelRatioFScale() → float#

disconnect(a0: QMetaObject.Connection) → bool#
disconnect(self) → None

disconnectNotify(self, signal: QMetaMethod)#

dockOptions(self) → QMainWindow.DockOptions#

dockWidgetArea(self, dockwidget: QDockWidget | None) → Qt.DockWidgetArea#

documentMode(self) → bool#

dragEnterEvent(self, a0: QDragEnterEvent | None)#

dragLeaveEvent(self, a0: QDragLeaveEvent | None)#

dragMoveEvent(self, a0: QDragMoveEvent | None)#

dropEvent(self, a0: QDropEvent | None)#

dumpObjectInfo(self)#

dumpObjectTree(self)#

dynamicPropertyNames(self) → List[QByteArray]#

effectiveWinId(self) → PyQt5.sip.voidptr#

ensurePolished(self)#

enterEvent(self, a0: QEvent | None)#

event(self, event: QEvent | None) → bool#

eventFilter(self, a0: QObject | None, a1: QEvent | None) → bool#

find(a0: PyQt5.sip.voidptr) → QWidget | None#

findChild(self, type: Type[QObjectT], name: str | None = '', options: Qt.FindChildOptions | Qt.FindChildOption = Qt.FindChildrenRecursively) → QObjectT#
findChild(self, types: Tuple[Type[QObjectT], ...], name: str | None = '', options: Qt.FindChildOptions | Qt.FindChildOption = Qt.FindChildrenRecursively) → QObjectT

findChildren(self, type: Type[QObjectT], name: str | None = '', options: Qt.FindChildOptions | Qt.FindChildOption = Qt.FindChildrenRecursively) → List[QObjectT]#
findChildren(self, types: Tuple[Type[QObjectT], ...], name: str | None = '', options: Qt.FindChildOptions | Qt.FindChildOption = Qt.FindChildrenRecursively) → List[QObjectT]
findChildren(self, type: Type[QObjectT], regExp: QRegExp, options: Qt.FindChildOptions | Qt.FindChildOption = Qt.FindChildrenRecursively) → List[QObjectT]
findChildren(self, types: Tuple[Type[QObjectT], ...], regExp: QRegExp, options: Qt.FindChildOptions | Qt.FindChildOption = Qt.FindChildrenRecursively) → List[QObjectT]
findChildren(self, type: Type[QObjectT], re: QRegularExpression, options: Qt.FindChildOptions | Qt.FindChildOption = Qt.FindChildrenRecursively) → List[QObjectT]
findChildren(self, types: Tuple[Type[QObjectT], ...], re: QRegularExpression, options: Qt.FindChildOptions | Qt.FindChildOption = Qt.FindChildrenRecursively) → List[QObjectT]

focusInEvent(self, a0: QFocusEvent | None)#

focusNextChild(self) → bool#

focusNextPrevChild(self, next: bool) → bool#

focusOutEvent(self, a0: QFocusEvent | None)#

focusPolicy(self) → Qt.FocusPolicy#

focusPreviousChild(self) → bool#

focusProxy(self) → QWidget | None#

focusWidget(self) → QWidget | None#

font(self) → QFont#

fontInfo(self) → QFontInfo#

fontMetrics(self) → QFontMetrics#

foregroundRole(self) → QPalette.ColorRole#

frameGeometry(self) → QRect#

frameSize(self) → QSize#

geometry(self) → QRect#

getContentsMargins(self)#

grab(self, rectangle: QRect = QRect(QPoint(0, 0), QSize(-1, -1))) → QPixmap#

grabGesture(self, type: Qt.GestureType, flags: Qt.GestureFlags | Qt.GestureFlag = Qt.GestureFlags())#

grabKeyboard(self)#

grabMouse(self)#
grabMouse(self, a0: QCursor | Qt.CursorShape) → None

grabShortcut(self, key: QKeySequence | QKeySequence.StandardKey | str | None | int, context: Qt.ShortcutContext = Qt.WindowShortcut) → int#

graphicsEffect(self) → QGraphicsEffect | None#

graphicsProxyWidget(self) → QGraphicsProxyWidget | None#

hasFocus(self) → bool#

hasHeightForWidth(self) → bool#

hasMouseTracking(self) → bool#

hasTabletTracking(self) → bool#

height(self) → int#

heightForWidth(self, a0: int) → int#

heightMM(self) → int#

hide(self)#

hideEvent(self, a0: QHideEvent | None)#

iconSize(self) → QSize#

inherits(self, classname: str | None) → bool#

initPainter(self, painter: QPainter | None)#

inputMethodEvent(self, a0: QInputMethodEvent | None)#

inputMethodHints(self) → Qt.InputMethodHints#

inputMethodQuery(self, a0: Qt.InputMethodQuery) → Any#

insertAction(self, before: QAction | None, action: QAction | None)#

insertActions(self, before: QAction | None, actions: Iterable[QAction])#

insertToolBar(self, before: QToolBar | None, toolbar: QToolBar | None)#

insertToolBarBreak(self, before: QToolBar | None)#

installEventFilter(self, a0: QObject | None)#

isActiveWindow(self) → bool#

isAncestorOf(self, child: QWidget | None) → bool#

isAnimated(self) → bool#

isDockNestingEnabled(self) → bool#

isEnabled(self) → bool#

isEnabledTo(self, a0: QWidget | None) → bool#

isFullScreen(self) → bool#

isHidden(self) → bool#

isLeftToRight(self) → bool#

isMaximized(self) → bool#

isMinimized(self) → bool#

isModal(self) → bool#

isRightToLeft(self) → bool#

isSeparator(self, pos: QPoint) → bool#

isSignalConnected(self, signal: QMetaMethod) → bool#

isVisible(self) → bool#

isVisibleTo(self, a0: QWidget | None) → bool#

isWidgetType(self) → bool#

isWindow(self) → bool#

isWindowModified(self) → bool#

isWindowType(self) → bool#

keyPressEvent(self, a0: QKeyEvent | None)#

keyReleaseEvent(self, a0: QKeyEvent | None)#

keyboardGrabber() → QWidget | None#

killTimer(self, id: int)#

layout(self) → QLayout | None#

layoutDirection(self) → Qt.LayoutDirection#

leaveEvent(self, a0: QEvent | None)#

locale(self) → QLocale#

logicalDpiX(self) → int#

logicalDpiY(self) → int#

lower(self)#

mapFrom(self, a0: QWidget | None, a1: QPoint) → QPoint#

mapFromGlobal(self, a0: QPoint) → QPoint#

mapFromParent(self, a0: QPoint) → QPoint#

mapTo(self, a0: QWidget | None, a1: QPoint) → QPoint#

mapToGlobal(self, a0: QPoint) → QPoint#

mapToParent(self, a0: QPoint) → QPoint#

mask(self) → QRegion#

maximumHeight(self) → int#

maximumSize(self) → QSize#

maximumWidth(self) → int#

menuBar(self) → QMenuBar | None#

menuWidget(self) → QWidget | None#

metaObject(self) → QMetaObject | None#

metric(self, a0: QPaintDevice.PaintDeviceMetric) → int#

minimumHeight(self) → int#

minimumSize(self) → QSize#

minimumSizeHint(self) → QSize#

minimumWidth(self) → int#

mouseDoubleClickEvent(self, a0: QMouseEvent | None)#

mouseGrabber() → QWidget | None#

mouseMoveEvent(self, a0: QMouseEvent | None)#

mousePressEvent(self, a0: QMouseEvent | None)#

mouseReleaseEvent(self, a0: QMouseEvent | None)#

move(self, a0: QPoint)#
move(self, ax: int, ay: int) → None

moveEvent(self, a0: QMoveEvent | None)#

moveToThread(self, thread: QThread | None)#

nativeEvent(self, eventType: QByteArray | bytes | bytearray, message: PyQt5.sip.voidptr | None)#

nativeParentWidget(self) → QWidget | None#

nextInFocusChain(self) → QWidget | None#

normalGeometry(self) → QRect#

objectName(self) → str#

overrideWindowFlags(self, type: Qt.WindowFlags | Qt.WindowType)#

overrideWindowState(self, state: Qt.WindowStates | Qt.WindowState)#

paintEngine(self) → QPaintEngine | None#

paintEvent(self, a0: QPaintEvent | None)#

paintingActive(self) → bool#

palette(self) → QPalette#

parent(self) → QObject | None#

parentWidget(self) → QWidget | None#

physicalDpiX(self) → int#

physicalDpiY(self) → int#

pos(self) → QPoint#

previousInFocusChain(self) → QWidget | None#

property(self, name: str | None) → Any#

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

raise_(self)#

receivers(self, signal: PYQT_SIGNAL) → int#

rect(self) → QRect#

releaseKeyboard(self)#

releaseMouse(self)#

releaseShortcut(self, id: int)#

removeAction(self, action: QAction | None)#

removeDockWidget(self, dockwidget: QDockWidget | None)#

removeEventFilter(self, a0: QObject | None)#

removeToolBar(self, toolbar: QToolBar | None)#

removeToolBarBreak(self, before: QToolBar | None)#

render(self, target: QPaintDevice | None, targetOffset: QPoint = QPoint(), sourceRegion: QRegion = QRegion(), flags: QWidget.RenderFlags | QWidget.RenderFlag = QWidget.RenderFlags(QWidget.RenderFlag.DrawWindowBackground | QWidget.RenderFlag.DrawChildren))#
render(self, painter: QPainter | None, targetOffset: QPoint = QPoint(), sourceRegion: QRegion = QRegion(), flags: QWidget.RenderFlags | QWidget.RenderFlag = QWidget.RenderFlags(QWidget.RenderFlag.DrawWindowBackground | QWidget.RenderFlag.DrawChildren)) → None

repaint(self)#
repaint(self, x: int, y: int, w: int, h: int) → None
repaint(self, a0: QRect) → None
repaint(self, a0: QRegion) → None

resize(self, a0: QSize)#
resize(self, w: int, h: int) → None

resizeDocks(self, docks: Iterable[QDockWidget], sizes: Iterable[int], orientation: Qt.Orientation)#

resizeEvent(self, a0: QResizeEvent | None)#

restoreDockWidget(self, dockwidget: QDockWidget | None) → bool#

restoreGeometry(self, geometry: QByteArray | bytes | bytearray) → bool#

restoreState(self, state: QByteArray | bytes | bytearray, version: int = 0) → bool#

saveGeometry(self) → QByteArray#

saveState(self, version: int = 0) → QByteArray#

screen(self) → QScreen | None#

scroll(self, dx: int, dy: int)#
scroll(self, dx: int, dy: int, a2: QRect) → None

sender(self) → QObject | None#

senderSignalIndex(self) → int#

setAcceptDrops(self, on: bool)#

setAccessibleDescription(self, description: str | None)#

setAccessibleName(self, name: str | None)#

setAnimated(self, enabled: bool)#

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

setAutoFillBackground(self, enabled: bool)#

setBackgroundRole(self, a0: QPalette.ColorRole)#

setBaseSize(self, basew: int, baseh: int)#
setBaseSize(self, s: QSize) → None

setCentralWidget(self, widget: QWidget | None)#

setContentsMargins(self, left: int, top: int, right: int, bottom: int)#
setContentsMargins(self, margins: QMargins) → None

setContextMenuPolicy(self, policy: Qt.ContextMenuPolicy)#

setCorner(self, corner: Qt.Corner, area: Qt.DockWidgetArea)#

setCursor(self, a0: QCursor | Qt.CursorShape)#

setDisabled(self, a0: bool)#

setDockNestingEnabled(self, enabled: bool)#

setDockOptions(self, options: QMainWindow.DockOptions | QMainWindow.DockOption)#

setDocumentMode(self, enabled: bool)#

setEnabled(self, a0: bool)#

setFixedHeight(self, h: int)#

setFixedSize(self, a0: QSize)#
setFixedSize(self, w: int, h: int) → None

setFixedWidth(self, w: int)#

setFocus(self)#
setFocus(self, reason: Qt.FocusReason) → None

setFocusPolicy(self, policy: Qt.FocusPolicy)#

setFocusProxy(self, a0: QWidget | None)#

setFont(self, a0: QFont)#

setForegroundRole(self, a0: QPalette.ColorRole)#

setGeometry(self, a0: QRect)#
setGeometry(self, ax: int, ay: int, aw: int, ah: int) → None

setGraphicsEffect(self, effect: QGraphicsEffect | None)#

setHidden(self, hidden: bool)#

setIconSize(self, iconSize: QSize)#

setInputMethodHints(self, hints: Qt.InputMethodHints | Qt.InputMethodHint)#

setLayout(self, a0: QLayout | None)#

setLayoutDirection(self, direction: Qt.LayoutDirection)#

setLocale(self, locale: QLocale)#

setMask(self, a0: QBitmap)#
setMask(self, a0: QRegion) → None

setMaximumHeight(self, maxh: int)#

setMaximumSize(self, maxw: int, maxh: int)#
setMaximumSize(self, s: QSize) → None

setMaximumWidth(self, maxw: int)#

setMenuBar(self, menubar: QMenuBar | None)#

setMenuWidget(self, menubar: QWidget | None)#

setMinimumHeight(self, minh: int)#

setMinimumSize(self, minw: int, minh: int)#
setMinimumSize(self, s: QSize) → None

setMinimumWidth(self, minw: int)#

setMouseTracking(self, enable: bool)#

setObjectName(self, name: str | None)#

setPalette(self, a0: QPalette)#

setParent(self, parent: QWidget | None)#
setParent(self, parent: QWidget | None, f: Qt.WindowFlags | Qt.WindowType) → None

setProperty(self, name: str | None, value: Any) → bool#

setShortcutAutoRepeat(self, id: int, enabled: bool = True)#

setShortcutEnabled(self, id: int, enabled: bool = True)#

setSizeIncrement(self, w: int, h: int)#
setSizeIncrement(self, s: QSize) → None

setSizePolicy(self, a0: QSizePolicy)#
setSizePolicy(self, hor: QSizePolicy.Policy, ver: QSizePolicy.Policy) → None

setStatusBar(self, statusbar: QStatusBar | None)#

setStatusTip(self, a0: str | None)#

setStyle(self, a0: QStyle | None)#

setStyleSheet(self, styleSheet: str | None)#

setTabOrder(a0: QWidget | None, a1: QWidget | None)#

setTabPosition(self, areas: Qt.DockWidgetAreas | Qt.DockWidgetArea, tabPosition: QTabWidget.TabPosition)#

setTabShape(self, tabShape: QTabWidget.TabShape)#

setTabletTracking(self, enable: bool)#

setToolButtonStyle(self, toolButtonStyle: Qt.ToolButtonStyle)#

setToolTip(self, a0: str | None)#

setToolTipDuration(self, msec: int)#

setUnifiedTitleAndToolBarOnMac(self, set: bool)#

setUpdatesEnabled(self, enable: bool)#

setVisible(self, visible: bool)#

setWhatsThis(self, a0: str | None)#

setWindowFilePath(self, filePath: str | None)#

setWindowFlag(self, a0: Qt.WindowType, on: bool = True)#

setWindowFlags(self, type: Qt.WindowFlags | Qt.WindowType)#

setWindowIcon(self, icon: QIcon)#

setWindowIconText(self, a0: str | None)#

setWindowModality(self, windowModality: Qt.WindowModality)#

setWindowModified(self, a0: bool)#

setWindowOpacity(self, level: float)#

setWindowRole(self, a0: str | None)#

setWindowState(self, state: Qt.WindowStates | Qt.WindowState)#

setWindowTitle(self, a0: str | None)#

sharedPainter(self) → QPainter | None#

show(self)#

showEvent(self, a0: QShowEvent | None)#

showFullScreen(self)#

showMaximized(self)#

showMinimized(self)#

showNormal(self)#

signalsBlocked(self) → bool#

size(self) → QSize#

sizeHint(self) → QSize#

sizeIncrement(self) → QSize#

sizePolicy(self) → QSizePolicy#

splitDockWidget(self, after: QDockWidget | None, dockwidget: QDockWidget | None, orientation: Qt.Orientation)#

stackUnder(self, a0: QWidget | None)#

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

statusBar(self) → QStatusBar | None#

statusTip(self) → str#

style(self) → QStyle | None#

styleSheet(self) → str#

tabPosition(self, area: Qt.DockWidgetArea) → QTabWidget.TabPosition#

tabShape(self) → QTabWidget.TabShape#

tabifiedDockWidgets(self, dockwidget: QDockWidget | None) → List[QDockWidget]#

tabifyDockWidget(self, first: QDockWidget | None, second: QDockWidget | None)#

tabletEvent(self, a0: QTabletEvent | None)#

takeCentralWidget(self) → QWidget | None#

testAttribute(self, attribute: Qt.WidgetAttribute) → bool#

thread(self) → QThread | None#

timerEvent(self, a0: QTimerEvent | None)#

toolBarArea(self, toolbar: QToolBar | None) → Qt.ToolBarArea#

toolBarBreak(self, toolbar: QToolBar | None) → bool#

toolButtonStyle(self) → Qt.ToolButtonStyle#

toolTip(self) → str#

toolTipDuration(self) → int#

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

underMouse(self) → bool#

ungrabGesture(self, type: Qt.GestureType)#

unifiedTitleAndToolBarOnMac(self) → bool#

unsetCursor(self)#

unsetLayoutDirection(self)#

unsetLocale(self)#

update(self)#
update(self, a0: QRect) → None
update(self, a0: QRegion) → None
update(self, ax: int, ay: int, aw: int, ah: int) → None

updateGeometry(self)#

updateMicroFocus(self)#

updatesEnabled(self) → bool#

visibleRegion(self) → QRegion#

whatsThis(self) → str#

wheelEvent(self, a0: QWheelEvent | None)#

width(self) → int#

widthMM(self) → int#

winId(self) → PyQt5.sip.voidptr#

window(self) → QWidget | None#

windowFilePath(self) → str#

windowFlags(self) → Qt.WindowFlags#

windowHandle(self) → QWindow | None#

windowIcon(self) → QIcon#

windowIconText(self) → str#

windowModality(self) → Qt.WindowModality#

windowOpacity(self) → float#

windowRole(self) → str#

windowState(self) → Qt.WindowStates#

windowTitle(self) → str#

windowType(self) → Qt.WindowType#

x(self) → int#

y(self) → int#

pyrobopath.toolpath.visualization.pyqtgraph_backend.ToolpathViewer#

This Page