MainWindow

Qt Base Class: QMainWindow

Signature: QMainWindow(self, parent: Optional[PySide6.QtWidgets.QWidget] = None, flags: PySide6.QtCore.Qt.WindowType = Default(Qt.WindowFlags)) -> None

Base classes

Name	Children	Inherits
WidgetMixin prettyqt.widgets.widget	Widget FrameMixin FocusFrame AbstractSliderMixin AbstractButtonMixin LineEdit AbstractSpinBoxMixin RubberBandMixin DialogButtonBox DialogMixin ...	ObjectMixin PaintDeviceMixin
QMainWindow PySide6.QtWidgets QMainWindow(self, parent: Optional[PySide6.QtWidgets.QWidget] \= None, flags: PySide6.QtCore.Qt.WindowType \= Default(Qt.WindowFlags)) -> None	MainWindow	QWidget

Subclasses

Class	Module	Description
DetachedTab	prettyqt.widgets.tabwidget
IconBrowser	prettyqt.custom_widgets.iconbrowser
ObjectBrowser	prettyqt.custom_widgets.objectbrowser
SidebarWidget	prettyqt.custom_widgets.sidebarwidget
QObjectDetailsDialog	prettyqt.debugging.qobjectdetailsdialog

⋔ Inheritance diagram

graph TD
  1473296227584["widgets.MainWindow"]
  1473293688240["widgets.WidgetMixin"]
  1473299815024["core.ObjectMixin"]
  140713234304496["builtins.object"]
  1473245548480["gui.PaintDeviceMixin"]
  1473290635936["QtWidgets.QMainWindow"]
  1473290849680["QtWidgets.QWidget"]
  1473288842240["QtCore.QObject"]
  1473291690208["Shiboken.Object"]
  1473300082368["QtGui.QPaintDevice"]
  1473293688240 --> 1473296227584
  1473299815024 --> 1473293688240
  140713234304496 --> 1473299815024
  1473245548480 --> 1473293688240
  140713234304496 --> 1473245548480
  1473290635936 --> 1473296227584
  1473290849680 --> 1473290635936
  1473288842240 --> 1473290849680
  1473291690208 --> 1473288842240
  140713234304496 --> 1473291690208
  1473300082368 --> 1473290849680
  1473291690208 --> 1473300082368

🛈 DocStrings

Bases: WidgetMixin, QMainWindow

Main application window.

Source code in prettyqt\widgets\mainwindow.py

class MainWindow(widgets.WidgetMixin, widgets.QMainWindow):
    """Main application window."""

    def __init__(self, *args, **kwargs):
        super().__init__(*args, dock_options=DEFAULT_OPTS, **kwargs)
        self.setMenuBar(widgets.MenuBar())

    def __getitem__(self, index: str) -> widgets.QWidget:
        result = self.find_child(widgets.QWidget, index)
        if result is None:
            raise KeyError("Widget not found")
        return result

    def _get_map(self):
        maps = super()._get_map()
        maps |= {
            "toolButtonStyle": constants.TOOLBUTTON_STYLE,
            "tabShape": widgets.tabwidget.TAB_SHAPES,
        }
        return maps

    def set_widget(self, widget: widgets.QWidget | None) -> widgets.QWidget | None:
        """Set widget and return previous one if existing."""
        previous = self.takeCentralWidget()
        if widget:
            self.setCentralWidget(widget)
        return previous

    def createPopupMenu(self) -> widgets.Menu:
        menu = widgets.Menu(parent=self, title="Window")
        for i, item in enumerate(self.get_docks()):
            action = gui.Action(
                text=item.windowTitle(),
                parent=self,
                checkable=True,
                checked=item.isVisible(),
                shortcut=f"Ctrl+Shift+{i}",
                shortcut_context="application",
                toggled=item.setVisible,
            )
            menu.add(action)
        menu.add_separator()
        for tb in self.get_toolbars():
            action = gui.Action(
                text=tb.windowTitle(),
                parent=self,
                checkable=True,
                toggled=tb.setVisible,
                checked=tb.isVisible(),
            )
            menu.add(action)
        return menu

    def add(self, widget: widgets.QWidget, **kwargs):
        match widget:
            case widgets.QToolBar():
                self.add_toolbar(widget, **kwargs)
            case widgets.QDockWidget():
                self.add_dockwidget(widget, **kwargs)
            case widgets.QWidget():
                self.centralWidget().layout().add(widget, **kwargs)

    def get_corner(
        self, corner: constants.CornerStr | constants.Corner
    ) -> constants.DockWidgetAreaStr:
        corner_flag = constants.CORNER.get_enum_value(corner)
        area = self.corner(corner_flag)
        return constants.DOCK_WIDGET_AREAS.inverse[area]

    def set_corner(
        self,
        corner: constants.CornerStr | constants.Corner,
        area: constants.DockWidgetAreaStr | constants.DockWidgetArea,
    ):
        corner_flag = constants.CORNER.get_enum_value(corner)
        area_flag = constants.DOCK_WIDGET_AREAS.get_enum_value(area)
        self.setCorner(corner_flag, area_flag)

    def add_toolbar(
        self,
        toolbar: widgets.QToolBar,
        area: constants.ToolbarAreaStr | constants.ToolBarArea | Literal["auto"] = "auto",
    ):
        """Adds a toolbar to the mainmenu at specified area.

        Args:
            toolbar: toolbar to use
            area: area of the toolbar
        """
        if area == "auto":
            area = self._get_preferred_toolbar_position()
        self.addToolBar(constants.TOOLBAR_AREA.get_enum_value(area), toolbar)

    def add_toolbar_break(
        self, position: constants.ToolbarAreaStr | constants.ToolBarArea = "top"
    ):
        """Adds a toolbar break to the given area behind the last item.

        Args:
            position: position of the toolbar
        """
        self.addToolBarBreak(constants.TOOLBAR_AREA.get_enum_value(position))

    def load_window_state(self, recursive: bool = False) -> bool:
        settings = core.Settings()
        name = self.objectName()
        geom = settings.get(f"{name}.geometry")
        state = settings.get(f"{name}.state")
        restored = False
        if geom is not None and state is not None:
            try:
                logger.debug(f"Loading window state for {self.windowTitle()!r}...")
                self.restoreGeometry(geom)
                if isinstance(state, str):
                    state = state.encode()
                self.restoreState(state)
                restored = True
            except TypeError:
                logger.error("Wrong type for window state. Probably Qt binding switch?")
        if recursive:
            for window in self.find_children(MainWindow, recursive=True):
                if window.objectName():
                    window.load_window_state()
        return restored

    def save_window_state(self, recursive: bool = False):
        """Save current window state as QSetting.

        Args:
            recursive (bool, optional): Description
        """
        settings = core.Settings()
        name = self.objectName()
        logger.debug(f"Saving window state for {self.windowTitle()!r}...")
        settings[f"{name}.geometry"] = self.saveGeometry()
        settings[f"{name}.state"] = self.saveState()
        if recursive:
            for window in self.find_children(MainWindow, recursive=True):
                if window.objectName():
                    window.save_window_state()

    def add_widget_as_dock(
        self,
        name: str,
        title: str,
        layout: widgets.layout.LayoutTypeStr | widgets.QLayout = "horizontal",
        position: constants.DockWidgetAreaStr | constants.DockWidgetArea = "left",
    ) -> widgets.DockWidget:
        dock_widget = widgets.DockWidget(self, object_name=name, window_title=title)
        widget = widgets.Widget()
        widget.setObjectName(f"{name}.widget")
        widget.set_layout(layout, margin=0)
        dock_widget.setWidget(widget)
        self.add_dockwidget(dock_widget, position)
        return dock_widget

    def add_dockwidget(
        self,
        widget: widgets.QWidget,
        position: constants.DockWidgetAreaStr
        | constants.DockWidgetArea
        | Literal["auto"] = "auto",
        **kwargs,
    ):
        if position == "auto":
            position = self._get_preferred_dock_position()
        if not isinstance(widget, widgets.QDockWidget):
            dock_widget = widgets.DockWidget(self, **kwargs)
            dock_widget.set_widget(widget)
            self.addDockWidget(
                constants.DOCK_WIDGET_AREA.get_enum_value(position), dock_widget
            )
            return dock_widget
        else:
            self.addDockWidget(
                constants.DOCK_WIDGET_AREA.get_enum_value(position), widget
            )

    def remove(
        self,
        items: Sequence[widgets.QDockWidget | widgets.QToolBar | gui.QAction]
        | widgets.QDockWidget
        | widgets.QToolBar
        | gui.QAction,
    ):
        widget_list = items if isinstance(items, list) else [items]
        for i in widget_list:
            match i:
                case widgets.QDockWidget():
                    self.removeDockWidget(i)
                case widgets.QToolBar():
                    self.removeToolBar(i)
                case gui.QAction():
                    self.removeAction(i)

    def show_blocking(self):
        self.set_modality("application")
        self.show()

    def get_dock_area(self, widget: widgets.QDockWidget) -> constants.DockWidgetAreaStr:
        area = self.dockWidgetArea(widget)
        return constants.DOCK_WIDGET_AREAS.inverse[area]

    def get_toolbar_area(self, widget: widgets.QToolBar) -> constants.ToolbarAreaStr:
        area = self.toolBarArea(widget)
        return constants.TOOLBAR_AREA.inverse[area]

    def set_tool_button_style(
        self, style: constants.ToolButtonStyleStr | constants.ToolButtonStyle
    ):
        self.setToolButtonStyle(constants.TOOLBUTTON_STYLE.get_enum_value(style))

    def get_tool_button_style(self) -> constants.ToolButtonStyleStr:
        """Return current tool button style.

        Returns:
            tool button style
        """
        return constants.TOOLBUTTON_STYLE.inverse[self.toolButtonStyle()]

    def set_tab_shape(
        self, shape: widgets.tabwidget.TabShapeStr | widgets.QTabWidget.TabShape
    ):
        """Set tab shape for the tabwidget.

        Args:
            shape: tab shape to use
        """
        self.setTabShape(widgets.tabwidget.TAB_SHAPES.get_enum_value(shape))

    def get_tab_shape(self) -> widgets.tabwidget.TabShapeStr:
        """Return tab shape.

        Returns:
            tab shape
        """
        return widgets.tabwidget.TAB_SHAPES.inverse[self.tabShape()]

    def get_docks(
        self, position: constants.DockWidgetAreaStr | None = None
    ) -> listdelegators.ListDelegator[widgets.QDockWidget]:
        docks = self.find_children(widgets.QDockWidget, recursive=False)
        if position is None:
            return docks
        else:
            return [i for i in docks if self.get_dock_area(i) == position]

    def _get_preferred_dock_position(
        self,
        preference: constants.DockWidgetAreaStr = "left",
    ) -> constants.DockWidgetAreaStr:
        """Get location with least amount of docks. If same score, use preference."""
        areas = [self.get_dock_area(i) for i in self.get_docks()]
        # by prepending the prio order, we can choose order because
        # collections.Counter takes insertion order into account.
        positions = ["bottom", "top", "right", "left"]
        positions.remove(preference)
        positions.append(preference)
        counter = collections.Counter(positions + areas)  # type: ignore[operator]
        return counter.most_common()[-1][0]  # type: ignore[return-value]

    def _get_preferred_toolbar_position(
        self,
        preference: constants.ToolbarAreaStr = "top",
    ) -> constants.ToolbarAreaStr:
        """See _get_preferred_dock_position."""
        areas = [self.get_toolbar_area(i) for i in self.get_toolbars()]
        positions = ["right", "left", "bottom", "top"]
        positions.remove(preference)
        positions.append(preference)
        counter = collections.Counter(positions + areas)  # type: ignore[operator]
        return counter.most_common()[-1][0]  # type: ignore[return-value]

    def get_toolbars(
        self, position: constants.ToolbarAreaStr | None = None
    ) -> listdelegators.ListDelegator[widgets.QToolBar]:
        toolbars = self.find_children(widgets.QToolBar, recursive=False)
        if position is None:
            return toolbars
        else:
            return [i for i in toolbars if self.get_toolbar_area(i) == position]

add_toolbar(toolbar: widgets.QToolBar, area: constants.ToolbarAreaStr | constants.ToolBarArea | Literal['auto'] = 'auto')

Adds a toolbar to the mainmenu at specified area.

Parameters:

Name	Type	Description	Default
toolbar	QToolBar	toolbar to use	required
area	ToolbarAreaStr | ToolBarArea | Literal['auto']	area of the toolbar	'auto'

Source code in prettyqt\widgets\mainwindow.py

def add_toolbar(
    self,
    toolbar: widgets.QToolBar,
    area: constants.ToolbarAreaStr | constants.ToolBarArea | Literal["auto"] = "auto",
):
    """Adds a toolbar to the mainmenu at specified area.

    Args:
        toolbar: toolbar to use
        area: area of the toolbar
    """
    if area == "auto":
        area = self._get_preferred_toolbar_position()
    self.addToolBar(constants.TOOLBAR_AREA.get_enum_value(area), toolbar)

add_toolbar_break(position: constants.ToolbarAreaStr | constants.ToolBarArea = 'top')

Adds a toolbar break to the given area behind the last item.

Parameters:

Name	Type	Description	Default
position	ToolbarAreaStr | ToolBarArea	position of the toolbar	'top'

Source code in prettyqt\widgets\mainwindow.py

def add_toolbar_break(
    self, position: constants.ToolbarAreaStr | constants.ToolBarArea = "top"
):
    """Adds a toolbar break to the given area behind the last item.

    Args:
        position: position of the toolbar
    """
    self.addToolBarBreak(constants.TOOLBAR_AREA.get_enum_value(position))

get_tab_shape() -> widgets.tabwidget.TabShapeStr

Return tab shape.

Source code in prettyqt\widgets\mainwindow.py

def get_tab_shape(self) -> widgets.tabwidget.TabShapeStr:
    """Return tab shape.

    Returns:
        tab shape
    """
    return widgets.tabwidget.TAB_SHAPES.inverse[self.tabShape()]

get_tool_button_style() -> constants.ToolButtonStyleStr

Return current tool button style.

Source code in prettyqt\widgets\mainwindow.py

def get_tool_button_style(self) -> constants.ToolButtonStyleStr:
    """Return current tool button style.

    Returns:
        tool button style
    """
    return constants.TOOLBUTTON_STYLE.inverse[self.toolButtonStyle()]

save_window_state(recursive: bool = False)

Save current window state as QSetting.

Parameters:

Name	Type	Description	Default
recursive	bool	Description	False

Source code in prettyqt\widgets\mainwindow.py

def save_window_state(self, recursive: bool = False):
    """Save current window state as QSetting.

    Args:
        recursive (bool, optional): Description
    """
    settings = core.Settings()
    name = self.objectName()
    logger.debug(f"Saving window state for {self.windowTitle()!r}...")
    settings[f"{name}.geometry"] = self.saveGeometry()
    settings[f"{name}.state"] = self.saveState()
    if recursive:
        for window in self.find_children(MainWindow, recursive=True):
            if window.objectName():
                window.save_window_state()

set_tab_shape(shape: widgets.tabwidget.TabShapeStr | widgets.QTabWidget.TabShape)

Set tab shape for the tabwidget.

Parameters:

Name	Type	Description	Default
shape	TabShapeStr | TabShape	tab shape to use	required

Source code in prettyqt\widgets\mainwindow.py

def set_tab_shape(
    self, shape: widgets.tabwidget.TabShapeStr | widgets.QTabWidget.TabShape
):
    """Set tab shape for the tabwidget.

    Args:
        shape: tab shape to use
    """
    self.setTabShape(widgets.tabwidget.TAB_SHAPES.get_enum_value(shape))

set_widget(widget: widgets.QWidget | None) -> widgets.QWidget | None

Set widget and return previous one if existing.

Source code in prettyqt\widgets\mainwindow.py

def set_widget(self, widget: widgets.QWidget | None) -> widgets.QWidget | None:
    """Set widget and return previous one if existing."""
    previous = self.takeCentralWidget()
    if widget:
        self.setCentralWidget(widget)
    return previous

⌗ Property table

Qt Property	Type	Doc
objectName	QString
modal	bool
windowModality	Qt::WindowModality
enabled	bool
geometry	QRect
frameGeometry	QRect
normalGeometry	QRect
x	int
y	int
pos	QPoint
frameSize	QSize
size	QSize
width	int
height	int
rect	QRect
childrenRect	QRect
childrenRegion	QRegion
sizePolicy	QSizePolicy
minimumSize	QSize
maximumSize	QSize
minimumWidth	int
minimumHeight	int
maximumWidth	int
maximumHeight	int
sizeIncrement	QSize
baseSize	QSize
palette	QPalette
font	QFont
cursor	QCursor
mouseTracking	bool
tabletTracking	bool
isActiveWindow	bool
focusPolicy	Qt::FocusPolicy
focus	bool
contextMenuPolicy	Qt::ContextMenuPolicy
updatesEnabled	bool
visible	bool
minimized	bool
maximized	bool
fullScreen	bool
sizeHint	QSize
minimumSizeHint	QSize
acceptDrops	bool
windowTitle	QString
windowIcon	QIcon
windowIconText	QString
windowOpacity	double
windowModified	bool
toolTip	QString
toolTipDuration	int
statusTip	QString
whatsThis	QString
accessibleName	QString
accessibleDescription	QString
layoutDirection	Qt::LayoutDirection
autoFillBackground	bool
styleSheet	QString
locale	QLocale
windowFilePath	QString
inputMethodHints	QFlags
iconSize	QSize
toolButtonStyle	Qt::ToolButtonStyle
animated	bool
documentMode	bool
tabShape	QTabWidget::TabShape
dockNestingEnabled	bool
dockOptions	QFlags
unifiedTitleAndToolBarOnMac	bool