File indexing completed on 2024-05-12 16:09:06

 class pyqtSignal():
  def connect(self, targetSignal): pass
  def emit(self, *args): pass
 from QtCore import *
 
 from QtWidgets import *
 
 import datetime
 
 class QSensorReading(QObject):
     """"""
     def value(self, index):
         '''QVariant QSensorReading.value(int index)'''
         return QVariant()
     def valueCount(self):
         '''int QSensorReading.valueCount()'''
         return int()
     def setTimestamp(self, timestamp):
         '''void QSensorReading.setTimestamp(int timestamp)'''
     def timestamp(self):
         '''int QSensorReading.timestamp()'''
         return int()
 
 
 class QAccelerometerReading(QSensorReading):
     """"""
     def setZ(self, z):
         '''void QAccelerometerReading.setZ(float z)'''
     def z(self):
         '''float QAccelerometerReading.z()'''
         return float()
     def setY(self, y):
         '''void QAccelerometerReading.setY(float y)'''
     def y(self):
         '''float QAccelerometerReading.y()'''
         return float()
     def setX(self, x):
         '''void QAccelerometerReading.setX(float x)'''
     def x(self):
         '''float QAccelerometerReading.x()'''
         return float()
 
 
 class QSensorFilter():
     """"""
     def __init__(self):
         '''void QSensorFilter.__init__()'''
     def __init__(self):
         '''QSensorFilter QSensorFilter.__init__()'''
         return QSensorFilter()
     def filter(self, reading):
         '''abstract bool QSensorFilter.filter(QSensorReading reading)'''
         return bool()
 
 
 class QAccelerometerFilter(QSensorFilter):
     """"""
     def __init__(self):
         '''void QAccelerometerFilter.__init__()'''
     def __init__(self):
         '''QAccelerometerFilter QAccelerometerFilter.__init__()'''
         return QAccelerometerFilter()
     def filter(self, reading):
         '''abstract bool QAccelerometerFilter.filter(QAccelerometerReading reading)'''
         return bool()
 
 
 class QSensor(QObject):
     """"""
     # Enum QSensor.AxesOrientationMode
     FixedOrientation = 0
     AutomaticOrientation = 0
     UserOrientation = 0
 
     # Enum QSensor.Feature
     Buffering = 0
     AlwaysOn = 0
     GeoValues = 0
     FieldOfView = 0
     AccelerationMode = 0
     SkipDuplicates = 0
     AxesOrientation = 0
     PressureSensorTemperature = 0
 
     def __init__(self, type, parent = None):
         '''void QSensor.__init__(QByteArray type, QObject parent = None)'''
     bufferSizeChanged = pyqtSignal() # void bufferSizeChanged(int) - signal
     efficientBufferSizeChanged = pyqtSignal() # void efficientBufferSizeChanged(int) - signal
     maxBufferSizeChanged = pyqtSignal() # void maxBufferSizeChanged(int) - signal
     userOrientationChanged = pyqtSignal() # void userOrientationChanged(int) - signal
     currentOrientationChanged = pyqtSignal() # void currentOrientationChanged(int) - signal
     axesOrientationModeChanged = pyqtSignal() # void axesOrientationModeChanged(QSensor::AxesOrientationMode) - signal
     skipDuplicatesChanged = pyqtSignal() # void skipDuplicatesChanged(bool) - signal
     dataRateChanged = pyqtSignal() # void dataRateChanged() - signal
     alwaysOnChanged = pyqtSignal() # void alwaysOnChanged() - signal
     availableSensorsChanged = pyqtSignal() # void availableSensorsChanged() - signal
     sensorError = pyqtSignal() # void sensorError(int) - signal
     readingChanged = pyqtSignal() # void readingChanged() - signal
     activeChanged = pyqtSignal() # void activeChanged() - signal
     busyChanged = pyqtSignal() # void busyChanged() - signal
     def stop(self):
         '''void QSensor.stop()'''
     def start(self):
         '''bool QSensor.start()'''
         return bool()
     def setBufferSize(self, bufferSize):
         '''void QSensor.setBufferSize(int bufferSize)'''
     def bufferSize(self):
         '''int QSensor.bufferSize()'''
         return int()
     def setEfficientBufferSize(self, efficientBufferSize):
         '''void QSensor.setEfficientBufferSize(int efficientBufferSize)'''
     def efficientBufferSize(self):
         '''int QSensor.efficientBufferSize()'''
         return int()
     def setMaxBufferSize(self, maxBufferSize):
         '''void QSensor.setMaxBufferSize(int maxBufferSize)'''
     def maxBufferSize(self):
         '''int QSensor.maxBufferSize()'''
         return int()
     def setUserOrientation(self, userOrientation):
         '''void QSensor.setUserOrientation(int userOrientation)'''
     def userOrientation(self):
         '''int QSensor.userOrientation()'''
         return int()
     def setCurrentOrientation(self, currentOrientation):
         '''void QSensor.setCurrentOrientation(int currentOrientation)'''
     def currentOrientation(self):
         '''int QSensor.currentOrientation()'''
         return int()
     def setAxesOrientationMode(self, axesOrientationMode):
         '''void QSensor.setAxesOrientationMode(QSensor.AxesOrientationMode axesOrientationMode)'''
     def axesOrientationMode(self):
         '''QSensor.AxesOrientationMode QSensor.axesOrientationMode()'''
         return QSensor.AxesOrientationMode()
     def isFeatureSupported(self, feature):
         '''bool QSensor.isFeatureSupported(QSensor.Feature feature)'''
         return bool()
     def defaultSensorForType(self, type):
         '''static QByteArray QSensor.defaultSensorForType(QByteArray type)'''
         return QByteArray()
     def sensorsForType(self, type):
         '''static list-of-QByteArray QSensor.sensorsForType(QByteArray type)'''
         return [QByteArray()]
     def sensorTypes(self):
         '''static list-of-QByteArray QSensor.sensorTypes()'''
         return [QByteArray()]
     def reading(self):
         '''QSensorReading QSensor.reading()'''
         return QSensorReading()
     def filters(self):
         '''list-of-QSensorFilter QSensor.filters()'''
         return [QSensorFilter()]
     def removeFilter(self, filter):
         '''void QSensor.removeFilter(QSensorFilter filter)'''
     def addFilter(self, filter):
         '''void QSensor.addFilter(QSensorFilter filter)'''
     def error(self):
         '''int QSensor.error()'''
         return int()
     def description(self):
         '''str QSensor.description()'''
         return str()
     def setOutputRange(self, index):
         '''void QSensor.setOutputRange(int index)'''
     def outputRange(self):
         '''int QSensor.outputRange()'''
         return int()
     def outputRanges(self):
         '''list-of-qoutputrange QSensor.outputRanges()'''
         return [qoutputrange()]
     def setDataRate(self, rate):
         '''void QSensor.setDataRate(int rate)'''
     def dataRate(self):
         '''int QSensor.dataRate()'''
         return int()
     def availableDataRates(self):
         '''list-of-tuple-of-int-int QSensor.availableDataRates()'''
         return [tuple-of-int-int()]
     def setSkipDuplicates(self, skipDuplicates):
         '''void QSensor.setSkipDuplicates(bool skipDuplicates)'''
     def skipDuplicates(self):
         '''bool QSensor.skipDuplicates()'''
         return bool()
     def setAlwaysOn(self, alwaysOn):
         '''void QSensor.setAlwaysOn(bool alwaysOn)'''
     def isAlwaysOn(self):
         '''bool QSensor.isAlwaysOn()'''
         return bool()
     def isActive(self):
         '''bool QSensor.isActive()'''
         return bool()
     def setActive(self, active):
         '''void QSensor.setActive(bool active)'''
     def isBusy(self):
         '''bool QSensor.isBusy()'''
         return bool()
     def isConnectedToBackend(self):
         '''bool QSensor.isConnectedToBackend()'''
         return bool()
     def connectToBackend(self):
         '''bool QSensor.connectToBackend()'''
         return bool()
     def type(self):
         '''QByteArray QSensor.type()'''
         return QByteArray()
     def setIdentifier(self, identifier):
         '''void QSensor.setIdentifier(QByteArray identifier)'''
     def identifier(self):
         '''QByteArray QSensor.identifier()'''
         return QByteArray()
 
 
 class QAccelerometer(QSensor):
     """"""
     # Enum QAccelerometer.AccelerationMode
     Combined = 0
     Gravity = 0
     User = 0
 
     def __init__(self, parent = None):
         '''void QAccelerometer.__init__(QObject parent = None)'''
     accelerationModeChanged = pyqtSignal() # void accelerationModeChanged(QAccelerometer::AccelerationMode) - signal
     def reading(self):
         '''QAccelerometerReading QAccelerometer.reading()'''
         return QAccelerometerReading()
     def setAccelerationMode(self, accelerationMode):
         '''void QAccelerometer.setAccelerationMode(QAccelerometer.AccelerationMode accelerationMode)'''
     def accelerationMode(self):
         '''QAccelerometer.AccelerationMode QAccelerometer.accelerationMode()'''
         return QAccelerometer.AccelerationMode()
 
 
 class QAltimeterReading(QSensorReading):
     """"""
     def setAltitude(self, altitude):
         '''void QAltimeterReading.setAltitude(float altitude)'''
     def altitude(self):
         '''float QAltimeterReading.altitude()'''
         return float()
 
 
 class QAltimeterFilter(QSensorFilter):
     """"""
     def __init__(self):
         '''void QAltimeterFilter.__init__()'''
     def __init__(self):
         '''QAltimeterFilter QAltimeterFilter.__init__()'''
         return QAltimeterFilter()
     def filter(self, reading):
         '''abstract bool QAltimeterFilter.filter(QAltimeterReading reading)'''
         return bool()
 
 
 class QAltimeter(QSensor):
     """"""
     def __init__(self, parent = None):
         '''void QAltimeter.__init__(QObject parent = None)'''
     def reading(self):
         '''QAltimeterReading QAltimeter.reading()'''
         return QAltimeterReading()
 
 
 class QAmbientLightReading(QSensorReading):
     """"""
     # Enum QAmbientLightReading.LightLevel
     Undefined = 0
     Dark = 0
     Twilight = 0
     Light = 0
     Bright = 0
     Sunny = 0
 
     def setLightLevel(self, lightLevel):
         '''void QAmbientLightReading.setLightLevel(QAmbientLightReading.LightLevel lightLevel)'''
     def lightLevel(self):
         '''QAmbientLightReading.LightLevel QAmbientLightReading.lightLevel()'''
         return QAmbientLightReading.LightLevel()
 
 
 class QAmbientLightFilter(QSensorFilter):
     """"""
     def __init__(self):
         '''void QAmbientLightFilter.__init__()'''
     def __init__(self):
         '''QAmbientLightFilter QAmbientLightFilter.__init__()'''
         return QAmbientLightFilter()
     def filter(self, reading):
         '''abstract bool QAmbientLightFilter.filter(QAmbientLightReading reading)'''
         return bool()
 
 
 class QAmbientLightSensor(QSensor):
     """"""
     def __init__(self, parent = None):
         '''void QAmbientLightSensor.__init__(QObject parent = None)'''
     def reading(self):
         '''QAmbientLightReading QAmbientLightSensor.reading()'''
         return QAmbientLightReading()
 
 
 class QAmbientTemperatureReading(QSensorReading):
     """"""
     def setTemperature(self, temperature):
         '''void QAmbientTemperatureReading.setTemperature(float temperature)'''
     def temperature(self):
         '''float QAmbientTemperatureReading.temperature()'''
         return float()
 
 
 class QAmbientTemperatureFilter(QSensorFilter):
     """"""
     def __init__(self):
         '''void QAmbientTemperatureFilter.__init__()'''
     def __init__(self):
         '''QAmbientTemperatureFilter QAmbientTemperatureFilter.__init__()'''
         return QAmbientTemperatureFilter()
     def filter(self, reading):
         '''abstract bool QAmbientTemperatureFilter.filter(QAmbientTemperatureReading reading)'''
         return bool()
 
 
 class QAmbientTemperatureSensor(QSensor):
     """"""
     def __init__(self, parent = None):
         '''void QAmbientTemperatureSensor.__init__(QObject parent = None)'''
     def reading(self):
         '''QAmbientTemperatureReading QAmbientTemperatureSensor.reading()'''
         return QAmbientTemperatureReading()
 
 
 class QCompassReading(QSensorReading):
     """"""
     def setCalibrationLevel(self, calibrationLevel):
         '''void QCompassReading.setCalibrationLevel(float calibrationLevel)'''
     def calibrationLevel(self):
         '''float QCompassReading.calibrationLevel()'''
         return float()
     def setAzimuth(self, azimuth):
         '''void QCompassReading.setAzimuth(float azimuth)'''
     def azimuth(self):
         '''float QCompassReading.azimuth()'''
         return float()
 
 
 class QCompassFilter(QSensorFilter):
     """"""
     def __init__(self):
         '''void QCompassFilter.__init__()'''
     def __init__(self):
         '''QCompassFilter QCompassFilter.__init__()'''
         return QCompassFilter()
     def filter(self, reading):
         '''abstract bool QCompassFilter.filter(QCompassReading reading)'''
         return bool()
 
 
 class QCompass(QSensor):
     """"""
     def __init__(self, parent = None):
         '''void QCompass.__init__(QObject parent = None)'''
     def reading(self):
         '''QCompassReading QCompass.reading()'''
         return QCompassReading()
 
 
 class QDistanceReading(QSensorReading):
     """"""
     def setDistance(self, distance):
         '''void QDistanceReading.setDistance(float distance)'''
     def distance(self):
         '''float QDistanceReading.distance()'''
         return float()
 
 
 class QDistanceFilter(QSensorFilter):
     """"""
     def __init__(self):
         '''void QDistanceFilter.__init__()'''
     def __init__(self):
         '''QDistanceFilter QDistanceFilter.__init__()'''
         return QDistanceFilter()
     def filter(self, reading):
         '''abstract bool QDistanceFilter.filter(QDistanceReading reading)'''
         return bool()
 
 
 class QDistanceSensor(QSensor):
     """"""
     def __init__(self, parent = None):
         '''void QDistanceSensor.__init__(QObject parent = None)'''
     def reading(self):
         '''QDistanceReading QDistanceSensor.reading()'''
         return QDistanceReading()
 
 
 class QGyroscopeReading(QSensorReading):
     """"""
     def setZ(self, z):
         '''void QGyroscopeReading.setZ(float z)'''
     def z(self):
         '''float QGyroscopeReading.z()'''
         return float()
     def setY(self, y):
         '''void QGyroscopeReading.setY(float y)'''
     def y(self):
         '''float QGyroscopeReading.y()'''
         return float()
     def setX(self, x):
         '''void QGyroscopeReading.setX(float x)'''
     def x(self):
         '''float QGyroscopeReading.x()'''
         return float()
 
 
 class QGyroscopeFilter(QSensorFilter):
     """"""
     def __init__(self):
         '''void QGyroscopeFilter.__init__()'''
     def __init__(self):
         '''QGyroscopeFilter QGyroscopeFilter.__init__()'''
         return QGyroscopeFilter()
     def filter(self, reading):
         '''abstract bool QGyroscopeFilter.filter(QGyroscopeReading reading)'''
         return bool()
 
 
 class QGyroscope(QSensor):
     """"""
     def __init__(self, parent = None):
         '''void QGyroscope.__init__(QObject parent = None)'''
     def reading(self):
         '''QGyroscopeReading QGyroscope.reading()'''
         return QGyroscopeReading()
 
 
 class QHolsterReading(QSensorReading):
     """"""
     def setHolstered(self, holstered):
         '''void QHolsterReading.setHolstered(bool holstered)'''
     def holstered(self):
         '''bool QHolsterReading.holstered()'''
         return bool()
 
 
 class QHolsterFilter(QSensorFilter):
     """"""
     def __init__(self):
         '''void QHolsterFilter.__init__()'''
     def __init__(self):
         '''QHolsterFilter QHolsterFilter.__init__()'''
         return QHolsterFilter()
     def filter(self, reading):
         '''abstract bool QHolsterFilter.filter(QHolsterReading reading)'''
         return bool()
 
 
 class QHolsterSensor(QSensor):
     """"""
     def __init__(self, parent = None):
         '''void QHolsterSensor.__init__(QObject parent = None)'''
     def reading(self):
         '''QHolsterReading QHolsterSensor.reading()'''
         return QHolsterReading()
 
 
 class QIRProximityReading(QSensorReading):
     """"""
     def setReflectance(self, reflectance):
         '''void QIRProximityReading.setReflectance(float reflectance)'''
     def reflectance(self):
         '''float QIRProximityReading.reflectance()'''
         return float()
 
 
 class QIRProximityFilter(QSensorFilter):
     """"""
     def __init__(self):
         '''void QIRProximityFilter.__init__()'''
     def __init__(self):
         '''QIRProximityFilter QIRProximityFilter.__init__()'''
         return QIRProximityFilter()
     def filter(self, reading):
         '''abstract bool QIRProximityFilter.filter(QIRProximityReading reading)'''
         return bool()
 
 
 class QIRProximitySensor(QSensor):
     """"""
     def __init__(self, parent = None):
         '''void QIRProximitySensor.__init__(QObject parent = None)'''
     def reading(self):
         '''QIRProximityReading QIRProximitySensor.reading()'''
         return QIRProximityReading()
 
 
 class QLightReading(QSensorReading):
     """"""
     def setLux(self, lux):
         '''void QLightReading.setLux(float lux)'''
     def lux(self):
         '''float QLightReading.lux()'''
         return float()
 
 
 class QLightFilter(QSensorFilter):
     """"""
     def __init__(self):
         '''void QLightFilter.__init__()'''
     def __init__(self):
         '''QLightFilter QLightFilter.__init__()'''
         return QLightFilter()
     def filter(self, reading):
         '''abstract bool QLightFilter.filter(QLightReading reading)'''
         return bool()
 
 
 class QLightSensor(QSensor):
     """"""
     def __init__(self, parent = None):
         '''void QLightSensor.__init__(QObject parent = None)'''
     fieldOfViewChanged = pyqtSignal() # void fieldOfViewChanged(qreal) - signal
     def setFieldOfView(self, fieldOfView):
         '''void QLightSensor.setFieldOfView(float fieldOfView)'''
     def fieldOfView(self):
         '''float QLightSensor.fieldOfView()'''
         return float()
     def reading(self):
         '''QLightReading QLightSensor.reading()'''
         return QLightReading()
 
 
 class QMagnetometerReading(QSensorReading):
     """"""
     def setCalibrationLevel(self, calibrationLevel):
         '''void QMagnetometerReading.setCalibrationLevel(float calibrationLevel)'''
     def calibrationLevel(self):
         '''float QMagnetometerReading.calibrationLevel()'''
         return float()
     def setZ(self, z):
         '''void QMagnetometerReading.setZ(float z)'''
     def z(self):
         '''float QMagnetometerReading.z()'''
         return float()
     def setY(self, y):
         '''void QMagnetometerReading.setY(float y)'''
     def y(self):
         '''float QMagnetometerReading.y()'''
         return float()
     def setX(self, x):
         '''void QMagnetometerReading.setX(float x)'''
     def x(self):
         '''float QMagnetometerReading.x()'''
         return float()
 
 
 class QMagnetometerFilter(QSensorFilter):
     """"""
     def __init__(self):
         '''void QMagnetometerFilter.__init__()'''
     def __init__(self):
         '''QMagnetometerFilter QMagnetometerFilter.__init__()'''
         return QMagnetometerFilter()
     def filter(self, reading):
         '''abstract bool QMagnetometerFilter.filter(QMagnetometerReading reading)'''
         return bool()
 
 
 class QMagnetometer(QSensor):
     """"""
     def __init__(self, parent = None):
         '''void QMagnetometer.__init__(QObject parent = None)'''
     returnGeoValuesChanged = pyqtSignal() # void returnGeoValuesChanged(bool) - signal
     def setReturnGeoValues(self, returnGeoValues):
         '''void QMagnetometer.setReturnGeoValues(bool returnGeoValues)'''
     def returnGeoValues(self):
         '''bool QMagnetometer.returnGeoValues()'''
         return bool()
     def reading(self):
         '''QMagnetometerReading QMagnetometer.reading()'''
         return QMagnetometerReading()
 
 
 class QOrientationReading(QSensorReading):
     """"""
     # Enum QOrientationReading.Orientation
     Undefined = 0
     TopUp = 0
     TopDown = 0
     LeftUp = 0
     RightUp = 0
     FaceUp = 0
     FaceDown = 0
 
     def setOrientation(self, orientation):
         '''void QOrientationReading.setOrientation(QOrientationReading.Orientation orientation)'''
     def orientation(self):
         '''QOrientationReading.Orientation QOrientationReading.orientation()'''
         return QOrientationReading.Orientation()
 
 
 class QOrientationFilter(QSensorFilter):
     """"""
     def __init__(self):
         '''void QOrientationFilter.__init__()'''
     def __init__(self):
         '''QOrientationFilter QOrientationFilter.__init__()'''
         return QOrientationFilter()
     def filter(self, reading):
         '''abstract bool QOrientationFilter.filter(QOrientationReading reading)'''
         return bool()
 
 
 class QOrientationSensor(QSensor):
     """"""
     def __init__(self, parent = None):
         '''void QOrientationSensor.__init__(QObject parent = None)'''
     def reading(self):
         '''QOrientationReading QOrientationSensor.reading()'''
         return QOrientationReading()
 
 
 class QPressureReading(QSensorReading):
     """"""
     def setTemperature(self, temperature):
         '''void QPressureReading.setTemperature(float temperature)'''
     def temperature(self):
         '''float QPressureReading.temperature()'''
         return float()
     def setPressure(self, pressure):
         '''void QPressureReading.setPressure(float pressure)'''
     def pressure(self):
         '''float QPressureReading.pressure()'''
         return float()
 
 
 class QPressureFilter(QSensorFilter):
     """"""
     def __init__(self):
         '''void QPressureFilter.__init__()'''
     def __init__(self):
         '''QPressureFilter QPressureFilter.__init__()'''
         return QPressureFilter()
     def filter(self, reading):
         '''abstract bool QPressureFilter.filter(QPressureReading reading)'''
         return bool()
 
 
 class QPressureSensor(QSensor):
     """"""
     def __init__(self, parent = None):
         '''void QPressureSensor.__init__(QObject parent = None)'''
     def reading(self):
         '''QPressureReading QPressureSensor.reading()'''
         return QPressureReading()
 
 
 class QProximityReading(QSensorReading):
     """"""
     def setClose(self, close):
         '''void QProximityReading.setClose(bool close)'''
     def close(self):
         '''bool QProximityReading.close()'''
         return bool()
 
 
 class QProximityFilter(QSensorFilter):
     """"""
     def __init__(self):
         '''void QProximityFilter.__init__()'''
     def __init__(self):
         '''QProximityFilter QProximityFilter.__init__()'''
         return QProximityFilter()
     def filter(self, reading):
         '''abstract bool QProximityFilter.filter(QProximityReading reading)'''
         return bool()
 
 
 class QProximitySensor(QSensor):
     """"""
     def __init__(self, parent = None):
         '''void QProximitySensor.__init__(QObject parent = None)'''
     def reading(self):
         '''QProximityReading QProximitySensor.reading()'''
         return QProximityReading()
 
 
 class qoutputrange():
     """"""
     accuracy = None # float - member
     maximum = None # float - member
     minimum = None # float - member
     def __init__(self):
         '''void qoutputrange.__init__()'''
     def __init__(self):
         '''qoutputrange qoutputrange.__init__()'''
         return qoutputrange()
 
 
 class QTapReading(QSensorReading):
     """"""
     # Enum QTapReading.TapDirection
     Undefined = 0
     X = 0
     Y = 0
     Z = 0
     X_Pos = 0
     Y_Pos = 0
     Z_Pos = 0
     X_Neg = 0
     Y_Neg = 0
     Z_Neg = 0
     X_Both = 0
     Y_Both = 0
     Z_Both = 0
 
     def setDoubleTap(self, doubleTap):
         '''void QTapReading.setDoubleTap(bool doubleTap)'''
     def isDoubleTap(self):
         '''bool QTapReading.isDoubleTap()'''
         return bool()
     def setTapDirection(self, tapDirection):
         '''void QTapReading.setTapDirection(QTapReading.TapDirection tapDirection)'''
     def tapDirection(self):
         '''QTapReading.TapDirection QTapReading.tapDirection()'''
         return QTapReading.TapDirection()
 
 
 class QTapFilter(QSensorFilter):
     """"""
     def __init__(self):
         '''void QTapFilter.__init__()'''
     def __init__(self):
         '''QTapFilter QTapFilter.__init__()'''
         return QTapFilter()
     def filter(self, reading):
         '''abstract bool QTapFilter.filter(QTapReading reading)'''
         return bool()
 
 
 class QTapSensor(QSensor):
     """"""
     def __init__(self, parent = None):
         '''void QTapSensor.__init__(QObject parent = None)'''
     returnDoubleTapEventsChanged = pyqtSignal() # void returnDoubleTapEventsChanged(bool) - signal
     def setReturnDoubleTapEvents(self, returnDoubleTapEvents):
         '''void QTapSensor.setReturnDoubleTapEvents(bool returnDoubleTapEvents)'''
     def returnDoubleTapEvents(self):
         '''bool QTapSensor.returnDoubleTapEvents()'''
         return bool()
     def reading(self):
         '''QTapReading QTapSensor.reading()'''
         return QTapReading()
 
 
 class QTiltReading(QSensorReading):
     """"""
     def setXRotation(self, x):
         '''void QTiltReading.setXRotation(float x)'''
     def xRotation(self):
         '''float QTiltReading.xRotation()'''
         return float()
     def setYRotation(self, y):
         '''void QTiltReading.setYRotation(float y)'''
     def yRotation(self):
         '''float QTiltReading.yRotation()'''
         return float()
 
 
 class QTiltFilter(QSensorFilter):
     """"""
     def __init__(self):
         '''void QTiltFilter.__init__()'''
     def __init__(self):
         '''QTiltFilter QTiltFilter.__init__()'''
         return QTiltFilter()
     def filter(self, reading):
         '''abstract bool QTiltFilter.filter(QTiltReading reading)'''
         return bool()
 
 
 class QTiltSensor(QSensor):
     """"""
     def __init__(self, parent = None):
         '''void QTiltSensor.__init__(QObject parent = None)'''
     def calibrate(self):
         '''void QTiltSensor.calibrate()'''
     def reading(self):
         '''QTiltReading QTiltSensor.reading()'''
         return QTiltReading()
 
 
 class QRotationReading(QSensorReading):
     """"""
     def setFromEuler(self, x, y, z):
         '''void QRotationReading.setFromEuler(float x, float y, float z)'''
     def z(self):
         '''float QRotationReading.z()'''
         return float()
     def y(self):
         '''float QRotationReading.y()'''
         return float()
     def x(self):
         '''float QRotationReading.x()'''
         return float()
 
 
 class QRotationFilter(QSensorFilter):
     """"""
     def __init__(self):
         '''void QRotationFilter.__init__()'''
     def __init__(self):
         '''QRotationFilter QRotationFilter.__init__()'''
         return QRotationFilter()
     def filter(self, reading):
         '''abstract bool QRotationFilter.filter(QRotationReading reading)'''
         return bool()
 
 
 class QRotationSensor(QSensor):
     """"""
     def __init__(self, parent = None):
         '''void QRotationSensor.__init__(QObject parent = None)'''
     hasZChanged = pyqtSignal() # void hasZChanged(bool) - signal
     def setHasZ(self, hasZ):
         '''void QRotationSensor.setHasZ(bool hasZ)'''
     def hasZ(self):
         '''bool QRotationSensor.hasZ()'''
         return bool()
     def reading(self):
         '''QRotationReading QRotationSensor.reading()'''
         return QRotationReading()