# encoding: utf-8
# module PyQt5.QtGui
# from C:\Programs\Python\Python313\Lib\site-packages\PyQt5\QtGui.pyd
# by generator 1.147
# no doc

# imports
import PyQt5.QtCore as __PyQt5_QtCore
import sip as __sip


class QStyleHints(__PyQt5_QtCore.QObject):
    # no doc
    def cursorFlashTime(self): # real signature unknown; restored from __doc__
        """ cursorFlashTime(self) -> int """
        return 0

    def cursorFlashTimeChanged(self, *args, **kwargs): # real signature unknown
        """
        pyqtSignal(*types, name: str = ..., revision: int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL
        
        types is normally a sequence of individual types.  Each type is either a
        type object or a string that is the name of a C++ type.  Alternatively
        each type could itself be a sequence of types each describing a different
        overloaded signal.
        name is the optional C++ name of the signal.  If it is not specified then
        the name of the class attribute that is bound to the signal is used.
        revision is the optional revision of the signal that is exported to QML.
        If it is not specified then 0 is used.
        arguments is the optional sequence of the names of the signal's arguments.
        """
        pass

    def fontSmoothingGamma(self): # real signature unknown; restored from __doc__
        """ fontSmoothingGamma(self) -> float """
        return 0.0

    def keyboardAutoRepeatRate(self): # real signature unknown; restored from __doc__
        """ keyboardAutoRepeatRate(self) -> int """
        return 0

    def keyboardInputInterval(self): # real signature unknown; restored from __doc__
        """ keyboardInputInterval(self) -> int """
        return 0

    def keyboardInputIntervalChanged(self, *args, **kwargs): # real signature unknown
        """
        pyqtSignal(*types, name: str = ..., revision: int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL
        
        types is normally a sequence of individual types.  Each type is either a
        type object or a string that is the name of a C++ type.  Alternatively
        each type could itself be a sequence of types each describing a different
        overloaded signal.
        name is the optional C++ name of the signal.  If it is not specified then
        the name of the class attribute that is bound to the signal is used.
        revision is the optional revision of the signal that is exported to QML.
        If it is not specified then 0 is used.
        arguments is the optional sequence of the names of the signal's arguments.
        """
        pass

    def mouseDoubleClickDistance(self): # real signature unknown; restored from __doc__
        """ mouseDoubleClickDistance(self) -> int """
        return 0

    def mouseDoubleClickInterval(self): # real signature unknown; restored from __doc__
        """ mouseDoubleClickInterval(self) -> int """
        return 0

    def mouseDoubleClickIntervalChanged(self, *args, **kwargs): # real signature unknown
        """
        pyqtSignal(*types, name: str = ..., revision: int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL
        
        types is normally a sequence of individual types.  Each type is either a
        type object or a string that is the name of a C++ type.  Alternatively
        each type could itself be a sequence of types each describing a different
        overloaded signal.
        name is the optional C++ name of the signal.  If it is not specified then
        the name of the class attribute that is bound to the signal is used.
        revision is the optional revision of the signal that is exported to QML.
        If it is not specified then 0 is used.
        arguments is the optional sequence of the names of the signal's arguments.
        """
        pass

    def mousePressAndHoldInterval(self): # real signature unknown; restored from __doc__
        """ mousePressAndHoldInterval(self) -> int """
        return 0

    def mousePressAndHoldIntervalChanged(self, *args, **kwargs): # real signature unknown
        """
        pyqtSignal(*types, name: str = ..., revision: int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL
        
        types is normally a sequence of individual types.  Each type is either a
        type object or a string that is the name of a C++ type.  Alternatively
        each type could itself be a sequence of types each describing a different
        overloaded signal.
        name is the optional C++ name of the signal.  If it is not specified then
        the name of the class attribute that is bound to the signal is used.
        revision is the optional revision of the signal that is exported to QML.
        If it is not specified then 0 is used.
        arguments is the optional sequence of the names of the signal's arguments.
        """
        pass

    def mouseQuickSelectionThreshold(self): # real signature unknown; restored from __doc__
        """ mouseQuickSelectionThreshold(self) -> int """
        return 0

    def mouseQuickSelectionThresholdChanged(self, *args, **kwargs): # real signature unknown
        """
        pyqtSignal(*types, name: str = ..., revision: int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL
        
        types is normally a sequence of individual types.  Each type is either a
        type object or a string that is the name of a C++ type.  Alternatively
        each type could itself be a sequence of types each describing a different
        overloaded signal.
        name is the optional C++ name of the signal.  If it is not specified then
        the name of the class attribute that is bound to the signal is used.
        revision is the optional revision of the signal that is exported to QML.
        If it is not specified then 0 is used.
        arguments is the optional sequence of the names of the signal's arguments.
        """
        pass

    def passwordMaskCharacter(self): # real signature unknown; restored from __doc__
        """ passwordMaskCharacter(self) -> str """
        return ""

    def passwordMaskDelay(self): # real signature unknown; restored from __doc__
        """ passwordMaskDelay(self) -> int """
        return 0

    def setFocusOnTouchRelease(self): # real signature unknown; restored from __doc__
        """ setFocusOnTouchRelease(self) -> bool """
        return False

    def setShowShortcutsInContextMenus(self, showShortcutsInContextMenus): # real signature unknown; restored from __doc__
        """ setShowShortcutsInContextMenus(self, showShortcutsInContextMenus: bool) """
        pass

    def setUseHoverEffects(self, useHoverEffects): # real signature unknown; restored from __doc__
        """ setUseHoverEffects(self, useHoverEffects: bool) """
        pass

    def showIsFullScreen(self): # real signature unknown; restored from __doc__
        """ showIsFullScreen(self) -> bool """
        return False

    def showIsMaximized(self): # real signature unknown; restored from __doc__
        """ showIsMaximized(self) -> bool """
        return False

    def showShortcutsInContextMenus(self): # real signature unknown; restored from __doc__
        """ showShortcutsInContextMenus(self) -> bool """
        return False

    def showShortcutsInContextMenusChanged(self, *args, **kwargs): # real signature unknown
        """
        pyqtSignal(*types, name: str = ..., revision: int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL
        
        types is normally a sequence of individual types.  Each type is either a
        type object or a string that is the name of a C++ type.  Alternatively
        each type could itself be a sequence of types each describing a different
        overloaded signal.
        name is the optional C++ name of the signal.  If it is not specified then
        the name of the class attribute that is bound to the signal is used.
        revision is the optional revision of the signal that is exported to QML.
        If it is not specified then 0 is used.
        arguments is the optional sequence of the names of the signal's arguments.
        """
        pass

    def singleClickActivation(self): # real signature unknown; restored from __doc__
        """ singleClickActivation(self) -> bool """
        return False

    def startDragDistance(self): # real signature unknown; restored from __doc__
        """ startDragDistance(self) -> int """
        return 0

    def startDragDistanceChanged(self, *args, **kwargs): # real signature unknown
        """
        pyqtSignal(*types, name: str = ..., revision: int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL
        
        types is normally a sequence of individual types.  Each type is either a
        type object or a string that is the name of a C++ type.  Alternatively
        each type could itself be a sequence of types each describing a different
        overloaded signal.
        name is the optional C++ name of the signal.  If it is not specified then
        the name of the class attribute that is bound to the signal is used.
        revision is the optional revision of the signal that is exported to QML.
        If it is not specified then 0 is used.
        arguments is the optional sequence of the names of the signal's arguments.
        """
        pass

    def startDragTime(self): # real signature unknown; restored from __doc__
        """ startDragTime(self) -> int """
        return 0

    def startDragTimeChanged(self, *args, **kwargs): # real signature unknown
        """
        pyqtSignal(*types, name: str = ..., revision: int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL
        
        types is normally a sequence of individual types.  Each type is either a
        type object or a string that is the name of a C++ type.  Alternatively
        each type could itself be a sequence of types each describing a different
        overloaded signal.
        name is the optional C++ name of the signal.  If it is not specified then
        the name of the class attribute that is bound to the signal is used.
        revision is the optional revision of the signal that is exported to QML.
        If it is not specified then 0 is used.
        arguments is the optional sequence of the names of the signal's arguments.
        """
        pass

    def startDragVelocity(self): # real signature unknown; restored from __doc__
        """ startDragVelocity(self) -> int """
        return 0

    def tabFocusBehavior(self): # real signature unknown; restored from __doc__
        """ tabFocusBehavior(self) -> Qt.TabFocusBehavior """
        pass

    def tabFocusBehaviorChanged(self, *args, **kwargs): # real signature unknown
        """
        pyqtSignal(*types, name: str = ..., revision: int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL
        
        types is normally a sequence of individual types.  Each type is either a
        type object or a string that is the name of a C++ type.  Alternatively
        each type could itself be a sequence of types each describing a different
        overloaded signal.
        name is the optional C++ name of the signal.  If it is not specified then
        the name of the class attribute that is bound to the signal is used.
        revision is the optional revision of the signal that is exported to QML.
        If it is not specified then 0 is used.
        arguments is the optional sequence of the names of the signal's arguments.
        """
        pass

    def touchDoubleTapDistance(self): # real signature unknown; restored from __doc__
        """ touchDoubleTapDistance(self) -> int """
        return 0

    def useHoverEffects(self): # real signature unknown; restored from __doc__
        """ useHoverEffects(self) -> bool """
        return False

    def useHoverEffectsChanged(self, *args, **kwargs): # real signature unknown
        """
        pyqtSignal(*types, name: str = ..., revision: int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL
        
        types is normally a sequence of individual types.  Each type is either a
        type object or a string that is the name of a C++ type.  Alternatively
        each type could itself be a sequence of types each describing a different
        overloaded signal.
        name is the optional C++ name of the signal.  If it is not specified then
        the name of the class attribute that is bound to the signal is used.
        revision is the optional revision of the signal that is exported to QML.
        If it is not specified then 0 is used.
        arguments is the optional sequence of the names of the signal's arguments.
        """
        pass

    def useRtlExtensions(self): # real signature unknown; restored from __doc__
        """ useRtlExtensions(self) -> bool """
        return False

    def wheelScrollLines(self): # real signature unknown; restored from __doc__
        """ wheelScrollLines(self) -> int """
        return 0

    def wheelScrollLinesChanged(self, *args, **kwargs): # real signature unknown
        """
        pyqtSignal(*types, name: str = ..., revision: int = ..., arguments: Sequence = ...) -> PYQT_SIGNAL
        
        types is normally a sequence of individual types.  Each type is either a
        type object or a string that is the name of a C++ type.  Alternatively
        each type could itself be a sequence of types each describing a different
        overloaded signal.
        name is the optional C++ name of the signal.  If it is not specified then
        the name of the class attribute that is bound to the signal is used.
        revision is the optional revision of the signal that is exported to QML.
        If it is not specified then 0 is used.
        arguments is the optional sequence of the names of the signal's arguments.
        """
        pass

    def __init__(self, *args, **kwargs): # real signature unknown
        pass