Skip to content

GuiApplicationMixin

Base classes

Name Children Inherits
CoreApplicationMixin
prettyqt.core.coreapplication

Subclasses

Class Module Description
GuiApplication prettyqt.gui.guiapplication
ApplicationMixin prettyqt.widgets.application

⋔ Inheritance diagram

graph TD
  1473245637296["gui.GuiApplicationMixin"]
  1473299836496["core.CoreApplicationMixin"]
  1473299815024["core.ObjectMixin"]
  140713234304496["builtins.object"]
  1473299836496 --> 1473245637296
  1473299815024 --> 1473299836496
  140713234304496 --> 1473299815024

🛈 DocStrings

Bases: CoreApplicationMixin

Source code in prettyqt\gui\guiapplication.py 
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
class GuiApplicationMixin(core.CoreApplicationMixin):
    palette_changed = core.Signal(gui.Palette)

    def __init__(self, *args, **kwargs):
        self._window_icon_color = "darkcyan"
        super().__init__(*args, **kwargs)

    def event(self, e):
        match e.type():
            case core.QEvent.Type.ApplicationPaletteChange:
                self.palette_changed.emit(gui.Palette(self.palette()))
        return super().event(e)

    @classmethod
    @contextlib.contextmanager
    def override_cursor(cls, cursor: constants.CursorShapeStr):
        cls.set_override_cursor(cursor)
        yield cursor
        cls.restore_override_cursor()

    @classmethod
    def set_override_cursor(cls, cursor: constants.CursorShapeStr):
        crs = gui.Cursor(constants.CURSOR_SHAPE[cursor])
        cls.setOverrideCursor(crs)

    @classmethod
    def restore_override_cursor(cls):
        cls.restoreOverrideCursor()

    @classmethod
    def get_clipboard(cls) -> gui.Clipboard:
        return gui.Clipboard(cls.clipboard())

    @classmethod
    @contextlib.contextmanager
    def edit_palette(cls) -> Iterator[gui.Palette]:
        palette = gui.Palette(cls.palette())
        yield palette
        cls.setPalette(palette)

    @classmethod
    def find_window(cls, h_wnd: SupportsInt) -> gui.QWindow:
        for window in cls.topLevelWindows():
            if window and int(window.winId()) == int(h_wnd):
                return window
        return None

    def set_layout_direction(
        self, direction: constants.LayoutDirectionStr | constants.LayoutDirection
    ):
        """Set layout direction.

        Args:
            direction: layout direction
        """
        self.setLayoutDirection(constants.LAYOUT_DIRECTION.get_enum_value(direction))

    def get_layout_direction(self) -> constants.LayoutDirectionStr:
        """Get the current layout direction.

        Returns:
            layout direction
        """
        return constants.LAYOUT_DIRECTION.inverse[self.layoutDirection()]

    @classmethod
    def set_high_dpi_scale_factor_rounding_policy(
        cls,
        policy: constants.HighDpiScaleFactorRoundingPolicyStr
        | constants.HighDpiScaleFactorRoundingPolicy,
    ):
        """Set high dpi scale factor rounding policy.

        Args:
            policy: rounding policy
        """
        cls.setHighDpiScaleFactorRoundingPolicy(
            constants.HIGH_DPI_SCALE_FACTOR_ROUNDING_POLICY.get_enum_value(policy)
        )

    @classmethod
    def get_high_dpi_scale_factor_rounding_policy(
        cls,
    ) -> constants.HighDpiScaleFactorRoundingPolicyStr:
        """Get the current high dpi scale factor rounding policy.

        Returns:
            rounding policy
        """
        return constants.HIGH_DPI_SCALE_FACTOR_ROUNDING_POLICY.inverse[
            cls.highDpiScaleFactorRoundingPolicy()
        ]

    @classmethod
    def get_application_state(cls) -> list[constants.ApplicationStateStr]:
        """Get the current application state.

        Returns:
            application state
        """
        return [
            k
            for k, v in constants.APPLICATION_STATES.items()
            if v & cls.applicationState()  # type: ignore
        ]

    def get_primary_screen(self) -> gui.Screen:
        return gui.Screen(self.primaryScreen())

    def get_screen_at(self, point: datatypes.PointType) -> gui.Screen:
        p = datatypes.to_point(point)
        return gui.Screen(self.screenAt(p))

    def get_screens(self) -> list[gui.Screen]:
        return [gui.Screen(i) for i in self.screens()]

    @classmethod
    def get_input_method(cls) -> gui.InputMethod:
        return gui.InputMethod(cls.inputMethod())

    @classmethod
    def copy_to_clipboard(cls, text: str):
        """Sets clipboard to supplied text."""
        cb = cls.clipboard()
        cb.clear(mode=cb.Mode.Clipboard)
        cb.setText(text, mode=cb.Mode.Clipboard)

    @classmethod
    def get_font(cls) -> gui.Font:
        return gui.Font(cls.font())

    def set_icon(self, icon: datatypes.IconType):
        """Set the default window icon.

        Args:
            icon: icon to use
        """
        color = self.get_window_icon_color()
        icon = iconprovider.get_icon(icon, color=color)
        self.setWindowIcon(icon)

    def get_icon(self) -> gui.Icon | None:
        icon = self.windowIcon()
        return None if icon.isNull() else gui.Icon(self.windowIcon())

    @classmethod
    def set_palette(cls, palette: constants.ThemeStr | gui.QPalette):
        match palette:
            case "default":
                pal = gui.Palette()
            case "dark":
                pal = gui.Palette.create_dark_palette()
            case _:
                pal = palette
        cls.setPalette(pal)

    @classmethod
    def get_keyboard_modifiers(cls) -> list[constants.KeyboardModifierStr]:
        return constants.KEYBOARD_MODIFIERS.get_list(cls.keyboardModifiers())

    @classmethod
    def query_keyboard_modifiers(cls) -> list[constants.KeyboardModifierStr]:
        return constants.KEYBOARD_MODIFIERS.get_list(cls.queryKeyboardModifiers())

    @classmethod
    def get_palette(cls) -> gui.Palette:
        return gui.Palette(cls.palette())

    def set_badge_number(self, number: int | None):
        self.setBadgeNumber(number or 0)

    def set_progress_value(self, value: int, total: int = 100):
        windows = self.topLevelWindows()
        if not windows:
            return None
        if sys.platform.startswith("win"):
            from prettyqt.utils.platforms.windows import taskbaritem

            window_id = windows[0].winId()
            tb = taskbaritem.TaskBarItem(window_id)
            tb.set_progress_value(value, total)

    def set_window_icon_color(self, color: datatypes.ColorType):
        self._window_icon_color = colors.get_color(color).name()

    def get_window_icon_color(self):
        return self._window_icon_color

    window_icon_color = core.Property(
        str,
        get_window_icon_color,
        set_window_icon_color,
        doc="Global window icon color",
    )

copy_to_clipboard(text: str) classmethod

Sets clipboard to supplied text.

Source code in prettyqt\gui\guiapplication.py 
133
134
135
136
137
138
@classmethod
def copy_to_clipboard(cls, text: str):
    """Sets clipboard to supplied text."""
    cb = cls.clipboard()
    cb.clear(mode=cb.Mode.Clipboard)
    cb.setText(text, mode=cb.Mode.Clipboard)

get_application_state() -> list[constants.ApplicationStateStr] classmethod

Get the current application state.

Source code in prettyqt\gui\guiapplication.py 
106
107
108
109
110
111
112
113
114
115
116
117
@classmethod
def get_application_state(cls) -> list[constants.ApplicationStateStr]:
    """Get the current application state.

    Returns:
        application state
    """
    return [
        k
        for k, v in constants.APPLICATION_STATES.items()
        if v & cls.applicationState()  # type: ignore
    ]

get_high_dpi_scale_factor_rounding_policy() -> constants.HighDpiScaleFactorRoundingPolicyStr classmethod

Get the current high dpi scale factor rounding policy.

Source code in prettyqt\gui\guiapplication.py 
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
@classmethod
def get_high_dpi_scale_factor_rounding_policy(
    cls,
) -> constants.HighDpiScaleFactorRoundingPolicyStr:
    """Get the current high dpi scale factor rounding policy.

    Returns:
        rounding policy
    """
    return constants.HIGH_DPI_SCALE_FACTOR_ROUNDING_POLICY.inverse[
        cls.highDpiScaleFactorRoundingPolicy()
    ]

get_layout_direction() -> constants.LayoutDirectionStr

Get the current layout direction.

Source code in prettyqt\gui\guiapplication.py 
70
71
72
73
74
75
76
def get_layout_direction(self) -> constants.LayoutDirectionStr:
    """Get the current layout direction.

    Returns:
        layout direction
    """
    return constants.LAYOUT_DIRECTION.inverse[self.layoutDirection()]

set_high_dpi_scale_factor_rounding_policy(policy: constants.HighDpiScaleFactorRoundingPolicyStr | constants.HighDpiScaleFactorRoundingPolicy) classmethod

Set high dpi scale factor rounding policy.

Parameters:

Name Type Description Default
policy HighDpiScaleFactorRoundingPolicyStr | HighDpiScaleFactorRoundingPolicy

rounding policy

 required
Source code in prettyqt\gui\guiapplication.py 
78
79
80
81
82
83
84
85
86
87
88
89
90
91
@classmethod
def set_high_dpi_scale_factor_rounding_policy(
    cls,
    policy: constants.HighDpiScaleFactorRoundingPolicyStr
    | constants.HighDpiScaleFactorRoundingPolicy,
):
    """Set high dpi scale factor rounding policy.

    Args:
        policy: rounding policy
    """
    cls.setHighDpiScaleFactorRoundingPolicy(
        constants.HIGH_DPI_SCALE_FACTOR_ROUNDING_POLICY.get_enum_value(policy)
    )

set_icon(icon: datatypes.IconType)

Set the default window icon.

Parameters:

Name Type Description Default
icon IconType

icon to use

 required
Source code in prettyqt\gui\guiapplication.py 
144
145
146
147
148
149
150
151
152
def set_icon(self, icon: datatypes.IconType):
    """Set the default window icon.

    Args:
        icon: icon to use
    """
    color = self.get_window_icon_color()
    icon = iconprovider.get_icon(icon, color=color)
    self.setWindowIcon(icon)

set_layout_direction(direction: constants.LayoutDirectionStr | constants.LayoutDirection)

Set layout direction.

Parameters:

Name Type Description Default
direction LayoutDirectionStr | LayoutDirection

layout direction

 required
Source code in prettyqt\gui\guiapplication.py 
60
61
62
63
64
65
66
67
68
def set_layout_direction(
    self, direction: constants.LayoutDirectionStr | constants.LayoutDirection
):
    """Set layout direction.

    Args:
        direction: layout direction
    """
    self.setLayoutDirection(constants.LAYOUT_DIRECTION.get_enum_value(direction))