Documentation

type QSensorFilter a = Object (CQSensorFilter a) #

type TQSensorFilter a = CQSensorFilter a #

data CQSensorFilter a #

qCast_QSensorFilter :: Object a -> IO (QSensorFilter ()) #

type QSensorFilterSc a = QSensorFilter (CQSensorFilterSc a) #

type TQSensorFilterSc a = TQSensorFilter (CQSensorFilterSc a) #

data CQSensorFilterSc a #

qCastList_QSensorFilter :: QqCastList_QSensorFilter a r => a -> r #

withQSensorFilterResult :: IO (Ptr (TQSensorFilter a)) -> IO (QSensorFilter a) #

withQListQSensorFilterResult :: IO (Ptr (TQListQSensorFilter ())) -> IO [QSensorFilter ()] #

qSensorFilterListFromPtrList :: [Ptr (TQSensorFilter a)] -> IO [QSensorFilter a] #

type QListQSensorFilter a = Object (CQListQSensorFilter a) #

type TQListQSensorFilter a = CQListQSensorFilter a #

data CQListQSensorFilter a #

type QSensorReading a = QObject (CQSensorReading a) #

type TQSensorReading a = TQObject (CQSensorReading a) #

data CQSensorReading a #

qCast_QSensorReading :: Object a -> IO (QSensorReading ()) #

type QSensorReadingSc a = QSensorReading (CQSensorReadingSc a) #

type TQSensorReadingSc a = TQSensorReading (CQSensorReadingSc a) #

data CQSensorReadingSc a #

qCastList_QSensorReading :: QqCastList_QSensorReading a r => a -> r #

withQSensorReadingResult :: IO (Ptr (TQSensorReading a)) -> IO (QSensorReading a) #

qSensorReadingFromPtr :: Ptr (TQSensorReading a) -> IO (QSensorReading a) #

qSensorReadingAddFinalizer :: QSensorReading a -> IO () #

type QSensor a = QObject (CQSensor a) #

type TQSensor a = TQObject (CQSensor a) #

data CQSensor a #

qCast_QSensor :: Object a -> IO (QSensor ()) #

type QSensorSc a = QSensor (CQSensorSc a) #

type TQSensorSc a = TQSensor (CQSensorSc a) #

data CQSensorSc a #

qCastList_QSensor :: QqCastList_QSensor a r => a -> r #

withQSensorResult :: IO (Ptr (TQSensor a)) -> IO (QSensor a) #

qSensorFromPtr :: Ptr (TQSensor a) -> IO (QSensor a) #

qSensorAddFinalizer :: QSensor a -> IO () #

type Qoutputrange a = Object (CQoutputrange a) #

type TQoutputrange a = CQoutputrange a #

data CQoutputrange a #

qCast_Qoutputrange :: Object a -> IO (Qoutputrange ()) #

type QoutputrangeSc a = Qoutputrange (CQoutputrangeSc a) #

type TQoutputrangeSc a = TQoutputrange (CQoutputrangeSc a) #

data CQoutputrangeSc a #

qCastList_Qoutputrange :: QqCastList_Qoutputrange a r => a -> r #

withQoutputrangeResult :: IO (Ptr (TQoutputrange a)) -> IO (Qoutputrange a) #

withQListQoutputrangeResult :: IO (Ptr (TQListQoutputrange ())) -> IO [Qoutputrange ()] #

qoutputrangeListFromPtrList :: [Ptr (TQoutputrange a)] -> IO [Qoutputrange a] #

type QListQoutputrange a = Object (CQListQoutputrange a) #

type TQListQoutputrange a = CQListQoutputrange a #

data CQListQoutputrange a #

type QSensorBackendFactory a = Object (CQSensorBackendFactory a) #

type TQSensorBackendFactory a = CQSensorBackendFactory a #

data CQSensorBackendFactory a #

qCast_QSensorBackendFactory :: Object a -> IO (QSensorBackendFactory ()) #

type QSensorBackendFactorySc a = QSensorBackendFactory (CQSensorBackendFactorySc a) #

type TQSensorBackendFactorySc a = TQSensorBackendFactory (CQSensorBackendFactorySc a) #

data CQSensorBackendFactorySc a #

qCastList_QSensorBackendFactory :: QqCastList_QSensorBackendFactory a r => a -> r #

withQSensorBackendFactoryResult :: IO (Ptr (TQSensorBackendFactory a)) -> IO (QSensorBackendFactory a) #

type QSensorChangesInterface a = Object (CQSensorChangesInterface a) #

type TQSensorChangesInterface a = CQSensorChangesInterface a #

data CQSensorChangesInterface a #

qCast_QSensorChangesInterface :: Object a -> IO (QSensorChangesInterface ()) #

type QSensorChangesInterfaceSc a = QSensorChangesInterface (CQSensorChangesInterfaceSc a) #

type TQSensorChangesInterfaceSc a = TQSensorChangesInterface (CQSensorChangesInterfaceSc a) #

data CQSensorChangesInterfaceSc a #

qCastList_QSensorChangesInterface :: QqCastList_QSensorChangesInterface a r => a -> r #

withQSensorChangesInterfaceResult :: IO (Ptr (TQSensorChangesInterface a)) -> IO (QSensorChangesInterface a) #

type QSensorReadingPrivate a = Object (CQSensorReadingPrivate a) #

type TQSensorReadingPrivate a = CQSensorReadingPrivate a #

data CQSensorReadingPrivate a #

qCast_QSensorReadingPrivate :: Object a -> IO (QSensorReadingPrivate ()) #

type QSensorReadingPrivateSc a = QSensorReadingPrivate (CQSensorReadingPrivateSc a) #

type TQSensorReadingPrivateSc a = TQSensorReadingPrivate (CQSensorReadingPrivateSc a) #

data CQSensorReadingPrivateSc a #

qCastList_QSensorReadingPrivate :: QqCastList_QSensorReadingPrivate a r => a -> r #

withQSensorReadingPrivateResult :: IO (Ptr (TQSensorReadingPrivate a)) -> IO (QSensorReadingPrivate a) #

type QSensorGesturePluginInterface a = Object (CQSensorGesturePluginInterface a) #

type TQSensorGesturePluginInterface a = CQSensorGesturePluginInterface a #

data CQSensorGesturePluginInterface a #

qCast_QSensorGesturePluginInterface :: Object a -> IO (QSensorGesturePluginInterface ()) #

type QSensorGesturePluginInterfaceSc a = QSensorGesturePluginInterface (CQSensorGesturePluginInterfaceSc a) #

type TQSensorGesturePluginInterfaceSc a = TQSensorGesturePluginInterface (CQSensorGesturePluginInterfaceSc a) #

data CQSensorGesturePluginInterfaceSc a #

qCastList_QSensorGesturePluginInterface :: QqCastList_QSensorGesturePluginInterface a r => a -> r #

withQSensorGesturePluginInterfaceResult :: IO (Ptr (TQSensorGesturePluginInterface a)) -> IO (QSensorGesturePluginInterface a) #

type QSensorPluginInterface a = Object (CQSensorPluginInterface a) #

type TQSensorPluginInterface a = CQSensorPluginInterface a #

data CQSensorPluginInterface a #

qCast_QSensorPluginInterface :: Object a -> IO (QSensorPluginInterface ()) #

type QSensorPluginInterfaceSc a = QSensorPluginInterface (CQSensorPluginInterfaceSc a) #

type TQSensorPluginInterfaceSc a = TQSensorPluginInterface (CQSensorPluginInterfaceSc a) #

data CQSensorPluginInterfaceSc a #

qCastList_QSensorPluginInterface :: QqCastList_QSensorPluginInterface a r => a -> r #

withQSensorPluginInterfaceResult :: IO (Ptr (TQSensorPluginInterface a)) -> IO (QSensorPluginInterface a) #

type QSensorManager a = Object (CQSensorManager a) #

type TQSensorManager a = CQSensorManager a #

data CQSensorManager a #

qCast_QSensorManager :: Object a -> IO (QSensorManager ()) #

type QSensorManagerSc a = QSensorManager (CQSensorManagerSc a) #

type TQSensorManagerSc a = TQSensorManager (CQSensorManagerSc a) #

data CQSensorManagerSc a #

qCastList_QSensorManager :: QqCastList_QSensorManager a r => a -> r #

withQSensorManagerResult :: IO (Ptr (TQSensorManager a)) -> IO (QSensorManager a) #

type QSensorGestureRecognizer a = QObject (CQSensorGestureRecognizer a) #

type TQSensorGestureRecognizer a = TQObject (CQSensorGestureRecognizer a) #

data CQSensorGestureRecognizer a #

qCast_QSensorGestureRecognizer :: Object a -> IO (QSensorGestureRecognizer ()) #

type QSensorGestureRecognizerSc a = QSensorGestureRecognizer (CQSensorGestureRecognizerSc a) #

type TQSensorGestureRecognizerSc a = TQSensorGestureRecognizer (CQSensorGestureRecognizerSc a) #

data CQSensorGestureRecognizerSc a #

qCastList_QSensorGestureRecognizer :: QqCastList_QSensorGestureRecognizer a r => a -> r #

withQSensorGestureRecognizerResult :: IO (Ptr (TQSensorGestureRecognizer a)) -> IO (QSensorGestureRecognizer a) #

qSensorGestureRecognizerFromPtr :: Ptr (TQSensorGestureRecognizer a) -> IO (QSensorGestureRecognizer a) #

qSensorGestureRecognizerAddFinalizer :: QSensorGestureRecognizer a -> IO () #

withQListQSensorGestureRecognizerResult :: IO (Ptr (TQListQSensorGestureRecognizer ())) -> IO [QSensorGestureRecognizer ()] #

qSensorGestureRecognizerListFromPtrList :: [Ptr (TQSensorGestureRecognizer a)] -> IO [QSensorGestureRecognizer a] #

type QListQSensorGestureRecognizer a = Object (CQListQSensorGestureRecognizer a) #

type TQListQSensorGestureRecognizer a = CQListQSensorGestureRecognizer a #

data CQListQSensorGestureRecognizer a #

type QSensorGesture a = QObject (CQSensorGesture a) #

type TQSensorGesture a = TQObject (CQSensorGesture a) #

data CQSensorGesture a #

qCast_QSensorGesture :: Object a -> IO (QSensorGesture ()) #

type QSensorGestureSc a = QSensorGesture (CQSensorGestureSc a) #

type TQSensorGestureSc a = TQSensorGesture (CQSensorGestureSc a) #

data CQSensorGestureSc a #

qCastList_QSensorGesture :: QqCastList_QSensorGesture a r => a -> r #

withQSensorGestureResult :: IO (Ptr (TQSensorGesture a)) -> IO (QSensorGesture a) #

qSensorGestureFromPtr :: Ptr (TQSensorGesture a) -> IO (QSensorGesture a) #

qSensorGestureAddFinalizer :: QSensorGesture a -> IO () #

type QSensorGestureManager a = QObject (CQSensorGestureManager a) #

type TQSensorGestureManager a = TQObject (CQSensorGestureManager a) #

data CQSensorGestureManager a #

qCast_QSensorGestureManager :: Object a -> IO (QSensorGestureManager ()) #

type QSensorGestureManagerSc a = QSensorGestureManager (CQSensorGestureManagerSc a) #

type TQSensorGestureManagerSc a = TQSensorGestureManager (CQSensorGestureManagerSc a) #

data CQSensorGestureManagerSc a #

qCastList_QSensorGestureManager :: QqCastList_QSensorGestureManager a r => a -> r #

withQSensorGestureManagerResult :: IO (Ptr (TQSensorGestureManager a)) -> IO (QSensorGestureManager a) #

qSensorGestureManagerFromPtr :: Ptr (TQSensorGestureManager a) -> IO (QSensorGestureManager a) #

qSensorGestureManagerAddFinalizer :: QSensorGestureManager a -> IO () #

type QSensorBackend a = QObject (CQSensorBackend a) #

type TQSensorBackend a = TQObject (CQSensorBackend a) #

data CQSensorBackend a #

qCast_QSensorBackend :: Object a -> IO (QSensorBackend ()) #

type QSensorBackendSc a = QSensorBackend (CQSensorBackendSc a) #

type TQSensorBackendSc a = TQSensorBackend (CQSensorBackendSc a) #

data CQSensorBackendSc a #

qCastList_QSensorBackend :: QqCastList_QSensorBackend a r => a -> r #

withQSensorBackendResult :: IO (Ptr (TQSensorBackend a)) -> IO (QSensorBackend a) #

qSensorBackendFromPtr :: Ptr (TQSensorBackend a) -> IO (QSensorBackend a) #

qSensorBackendAddFinalizer :: QSensorBackend a -> IO () #

type QCompass a = QSensor (CQCompass a) #

type TQCompass a = TQSensor (CQCompass a) #

data CQCompass a #

qCast_QCompass :: Object a -> IO (QCompass ()) #

type QCompassSc a = QCompass (CQCompassSc a) #

type TQCompassSc a = TQCompass (CQCompassSc a) #

data CQCompassSc a #

qCastList_QCompass :: QqCastList_QCompass a r => a -> r #

withQCompassResult :: IO (Ptr (TQCompass a)) -> IO (QCompass a) #

qCompassFromPtr :: Ptr (TQCompass a) -> IO (QCompass a) #

qCompassAddFinalizer :: QCompass a -> IO () #

type QPressureSensor a = QSensor (CQPressureSensor a) #

type TQPressureSensor a = TQSensor (CQPressureSensor a) #

data CQPressureSensor a #

qCast_QPressureSensor :: Object a -> IO (QPressureSensor ()) #

type QPressureSensorSc a = QPressureSensor (CQPressureSensorSc a) #

type TQPressureSensorSc a = TQPressureSensor (CQPressureSensorSc a) #

data CQPressureSensorSc a #

qCastList_QPressureSensor :: QqCastList_QPressureSensor a r => a -> r #

withQPressureSensorResult :: IO (Ptr (TQPressureSensor a)) -> IO (QPressureSensor a) #

qPressureSensorFromPtr :: Ptr (TQPressureSensor a) -> IO (QPressureSensor a) #

qPressureSensorAddFinalizer :: QPressureSensor a -> IO () #

type QTapSensor a = QSensor (CQTapSensor a) #

type TQTapSensor a = TQSensor (CQTapSensor a) #

data CQTapSensor a #

qCast_QTapSensor :: Object a -> IO (QTapSensor ()) #

type QTapSensorSc a = QTapSensor (CQTapSensorSc a) #

type TQTapSensorSc a = TQTapSensor (CQTapSensorSc a) #

data CQTapSensorSc a #

qCastList_QTapSensor :: QqCastList_QTapSensor a r => a -> r #

withQTapSensorResult :: IO (Ptr (TQTapSensor a)) -> IO (QTapSensor a) #

qTapSensorFromPtr :: Ptr (TQTapSensor a) -> IO (QTapSensor a) #

qTapSensorAddFinalizer :: QTapSensor a -> IO () #

type QAccelerometer a = QSensor (CQAccelerometer a) #

type TQAccelerometer a = TQSensor (CQAccelerometer a) #

data CQAccelerometer a #

qCast_QAccelerometer :: Object a -> IO (QAccelerometer ()) #

type QAccelerometerSc a = QAccelerometer (CQAccelerometerSc a) #

type TQAccelerometerSc a = TQAccelerometer (CQAccelerometerSc a) #

data CQAccelerometerSc a #

qCastList_QAccelerometer :: QqCastList_QAccelerometer a r => a -> r #

withQAccelerometerResult :: IO (Ptr (TQAccelerometer a)) -> IO (QAccelerometer a) #

qAccelerometerFromPtr :: Ptr (TQAccelerometer a) -> IO (QAccelerometer a) #

qAccelerometerAddFinalizer :: QAccelerometer a -> IO () #

type QProximitySensor a = QSensor (CQProximitySensor a) #

type TQProximitySensor a = TQSensor (CQProximitySensor a) #

data CQProximitySensor a #

qCast_QProximitySensor :: Object a -> IO (QProximitySensor ()) #

type QProximitySensorSc a = QProximitySensor (CQProximitySensorSc a) #

type TQProximitySensorSc a = TQProximitySensor (CQProximitySensorSc a) #

data CQProximitySensorSc a #

qCastList_QProximitySensor :: QqCastList_QProximitySensor a r => a -> r #

withQProximitySensorResult :: IO (Ptr (TQProximitySensor a)) -> IO (QProximitySensor a) #

qProximitySensorFromPtr :: Ptr (TQProximitySensor a) -> IO (QProximitySensor a) #

qProximitySensorAddFinalizer :: QProximitySensor a -> IO () #

type QAmbientTemperatureSensor a = QSensor (CQAmbientTemperatureSensor a) #

type TQAmbientTemperatureSensor a = TQSensor (CQAmbientTemperatureSensor a) #

data CQAmbientTemperatureSensor a #

qCast_QAmbientTemperatureSensor :: Object a -> IO (QAmbientTemperatureSensor ()) #

type QAmbientTemperatureSensorSc a = QAmbientTemperatureSensor (CQAmbientTemperatureSensorSc a) #

type TQAmbientTemperatureSensorSc a = TQAmbientTemperatureSensor (CQAmbientTemperatureSensorSc a) #

data CQAmbientTemperatureSensorSc a #

qCastList_QAmbientTemperatureSensor :: QqCastList_QAmbientTemperatureSensor a r => a -> r #

withQAmbientTemperatureSensorResult :: IO (Ptr (TQAmbientTemperatureSensor a)) -> IO (QAmbientTemperatureSensor a) #

qAmbientTemperatureSensorFromPtr :: Ptr (TQAmbientTemperatureSensor a) -> IO (QAmbientTemperatureSensor a) #

qAmbientTemperatureSensorAddFinalizer :: QAmbientTemperatureSensor a -> IO () #

type QGyroscope a = QSensor (CQGyroscope a) #

type TQGyroscope a = TQSensor (CQGyroscope a) #

data CQGyroscope a #

qCast_QGyroscope :: Object a -> IO (QGyroscope ()) #

type QGyroscopeSc a = QGyroscope (CQGyroscopeSc a) #

type TQGyroscopeSc a = TQGyroscope (CQGyroscopeSc a) #

data CQGyroscopeSc a #

qCastList_QGyroscope :: QqCastList_QGyroscope a r => a -> r #

withQGyroscopeResult :: IO (Ptr (TQGyroscope a)) -> IO (QGyroscope a) #

qGyroscopeFromPtr :: Ptr (TQGyroscope a) -> IO (QGyroscope a) #

qGyroscopeAddFinalizer :: QGyroscope a -> IO () #

type QAmbientLightSensor a = QSensor (CQAmbientLightSensor a) #

type TQAmbientLightSensor a = TQSensor (CQAmbientLightSensor a) #

data CQAmbientLightSensor a #

qCast_QAmbientLightSensor :: Object a -> IO (QAmbientLightSensor ()) #

type QAmbientLightSensorSc a = QAmbientLightSensor (CQAmbientLightSensorSc a) #

type TQAmbientLightSensorSc a = TQAmbientLightSensor (CQAmbientLightSensorSc a) #

data CQAmbientLightSensorSc a #

qCastList_QAmbientLightSensor :: QqCastList_QAmbientLightSensor a r => a -> r #

withQAmbientLightSensorResult :: IO (Ptr (TQAmbientLightSensor a)) -> IO (QAmbientLightSensor a) #

qAmbientLightSensorFromPtr :: Ptr (TQAmbientLightSensor a) -> IO (QAmbientLightSensor a) #

qAmbientLightSensorAddFinalizer :: QAmbientLightSensor a -> IO () #

type QOrientationSensor a = QSensor (CQOrientationSensor a) #

type TQOrientationSensor a = TQSensor (CQOrientationSensor a) #

data CQOrientationSensor a #

qCast_QOrientationSensor :: Object a -> IO (QOrientationSensor ()) #

type QOrientationSensorSc a = QOrientationSensor (CQOrientationSensorSc a) #

type TQOrientationSensorSc a = TQOrientationSensor (CQOrientationSensorSc a) #

data CQOrientationSensorSc a #

qCastList_QOrientationSensor :: QqCastList_QOrientationSensor a r => a -> r #

withQOrientationSensorResult :: IO (Ptr (TQOrientationSensor a)) -> IO (QOrientationSensor a) #

qOrientationSensorFromPtr :: Ptr (TQOrientationSensor a) -> IO (QOrientationSensor a) #

qOrientationSensorAddFinalizer :: QOrientationSensor a -> IO () #

type QIRProximitySensor a = QSensor (CQIRProximitySensor a) #

type TQIRProximitySensor a = TQSensor (CQIRProximitySensor a) #

data CQIRProximitySensor a #

qCast_QIRProximitySensor :: Object a -> IO (QIRProximitySensor ()) #

type QIRProximitySensorSc a = QIRProximitySensor (CQIRProximitySensorSc a) #

type TQIRProximitySensorSc a = TQIRProximitySensor (CQIRProximitySensorSc a) #

data CQIRProximitySensorSc a #

qCastList_QIRProximitySensor :: QqCastList_QIRProximitySensor a r => a -> r #

withQIRProximitySensorResult :: IO (Ptr (TQIRProximitySensor a)) -> IO (QIRProximitySensor a) #

qIRProximitySensorFromPtr :: Ptr (TQIRProximitySensor a) -> IO (QIRProximitySensor a) #

qIRProximitySensorAddFinalizer :: QIRProximitySensor a -> IO () #

type QRotationSensor a = QSensor (CQRotationSensor a) #

type TQRotationSensor a = TQSensor (CQRotationSensor a) #

data CQRotationSensor a #

qCast_QRotationSensor :: Object a -> IO (QRotationSensor ()) #

type QRotationSensorSc a = QRotationSensor (CQRotationSensorSc a) #

type TQRotationSensorSc a = TQRotationSensor (CQRotationSensorSc a) #

data CQRotationSensorSc a #

qCastList_QRotationSensor :: QqCastList_QRotationSensor a r => a -> r #

withQRotationSensorResult :: IO (Ptr (TQRotationSensor a)) -> IO (QRotationSensor a) #

qRotationSensorFromPtr :: Ptr (TQRotationSensor a) -> IO (QRotationSensor a) #

qRotationSensorAddFinalizer :: QRotationSensor a -> IO () #

type QHolsterSensor a = QSensor (CQHolsterSensor a) #

type TQHolsterSensor a = TQSensor (CQHolsterSensor a) #

data CQHolsterSensor a #

qCast_QHolsterSensor :: Object a -> IO (QHolsterSensor ()) #

type QHolsterSensorSc a = QHolsterSensor (CQHolsterSensorSc a) #

type TQHolsterSensorSc a = TQHolsterSensor (CQHolsterSensorSc a) #

data CQHolsterSensorSc a #

qCastList_QHolsterSensor :: QqCastList_QHolsterSensor a r => a -> r #

withQHolsterSensorResult :: IO (Ptr (TQHolsterSensor a)) -> IO (QHolsterSensor a) #

qHolsterSensorFromPtr :: Ptr (TQHolsterSensor a) -> IO (QHolsterSensor a) #

qHolsterSensorAddFinalizer :: QHolsterSensor a -> IO () #

type QAltimeter a = QSensor (CQAltimeter a) #

type TQAltimeter a = TQSensor (CQAltimeter a) #

data CQAltimeter a #

qCast_QAltimeter :: Object a -> IO (QAltimeter ()) #

type QAltimeterSc a = QAltimeter (CQAltimeterSc a) #

type TQAltimeterSc a = TQAltimeter (CQAltimeterSc a) #

data CQAltimeterSc a #

qCastList_QAltimeter :: QqCastList_QAltimeter a r => a -> r #

withQAltimeterResult :: IO (Ptr (TQAltimeter a)) -> IO (QAltimeter a) #

qAltimeterFromPtr :: Ptr (TQAltimeter a) -> IO (QAltimeter a) #

qAltimeterAddFinalizer :: QAltimeter a -> IO () #

type QMagnetometer a = QSensor (CQMagnetometer a) #

type TQMagnetometer a = TQSensor (CQMagnetometer a) #

data CQMagnetometer a #

qCast_QMagnetometer :: Object a -> IO (QMagnetometer ()) #

type QMagnetometerSc a = QMagnetometer (CQMagnetometerSc a) #

type TQMagnetometerSc a = TQMagnetometer (CQMagnetometerSc a) #

data CQMagnetometerSc a #

qCastList_QMagnetometer :: QqCastList_QMagnetometer a r => a -> r #

withQMagnetometerResult :: IO (Ptr (TQMagnetometer a)) -> IO (QMagnetometer a) #

qMagnetometerFromPtr :: Ptr (TQMagnetometer a) -> IO (QMagnetometer a) #

qMagnetometerAddFinalizer :: QMagnetometer a -> IO () #

type QLightSensor a = QSensor (CQLightSensor a) #

type TQLightSensor a = TQSensor (CQLightSensor a) #

data CQLightSensor a #

qCast_QLightSensor :: Object a -> IO (QLightSensor ()) #

type QLightSensorSc a = QLightSensor (CQLightSensorSc a) #

type TQLightSensorSc a = TQLightSensor (CQLightSensorSc a) #

data CQLightSensorSc a #

qCastList_QLightSensor :: QqCastList_QLightSensor a r => a -> r #

withQLightSensorResult :: IO (Ptr (TQLightSensor a)) -> IO (QLightSensor a) #

qLightSensorFromPtr :: Ptr (TQLightSensor a) -> IO (QLightSensor a) #

qLightSensorAddFinalizer :: QLightSensor a -> IO () #

type QTiltSensor a = QSensor (CQTiltSensor a) #

type TQTiltSensor a = TQSensor (CQTiltSensor a) #

data CQTiltSensor a #

qCast_QTiltSensor :: Object a -> IO (QTiltSensor ()) #

type QTiltSensorSc a = QTiltSensor (CQTiltSensorSc a) #

type TQTiltSensorSc a = TQTiltSensor (CQTiltSensorSc a) #

data CQTiltSensorSc a #

qCastList_QTiltSensor :: QqCastList_QTiltSensor a r => a -> r #

withQTiltSensorResult :: IO (Ptr (TQTiltSensor a)) -> IO (QTiltSensor a) #

qTiltSensorFromPtr :: Ptr (TQTiltSensor a) -> IO (QTiltSensor a) #

qTiltSensorAddFinalizer :: QTiltSensor a -> IO () #

type QLightFilter a = QSensorFilter (CQLightFilter a) #

type TQLightFilter a = TQSensorFilter (CQLightFilter a) #

data CQLightFilter a #

qCast_QLightFilter :: Object a -> IO (QLightFilter ()) #

type QLightFilterSc a = QLightFilter (CQLightFilterSc a) #

type TQLightFilterSc a = TQLightFilter (CQLightFilterSc a) #

data CQLightFilterSc a #

qCastList_QLightFilter :: QqCastList_QLightFilter a r => a -> r #

withQLightFilterResult :: IO (Ptr (TQLightFilter a)) -> IO (QLightFilter a) #

type QPressureFilter a = QSensorFilter (CQPressureFilter a) #

type TQPressureFilter a = TQSensorFilter (CQPressureFilter a) #

data CQPressureFilter a #

qCast_QPressureFilter :: Object a -> IO (QPressureFilter ()) #

type QPressureFilterSc a = QPressureFilter (CQPressureFilterSc a) #

type TQPressureFilterSc a = TQPressureFilter (CQPressureFilterSc a) #

data CQPressureFilterSc a #

qCastList_QPressureFilter :: QqCastList_QPressureFilter a r => a -> r #

withQPressureFilterResult :: IO (Ptr (TQPressureFilter a)) -> IO (QPressureFilter a) #

type QTiltFilter a = QSensorFilter (CQTiltFilter a) #

type TQTiltFilter a = TQSensorFilter (CQTiltFilter a) #

data CQTiltFilter a #

qCast_QTiltFilter :: Object a -> IO (QTiltFilter ()) #

type QTiltFilterSc a = QTiltFilter (CQTiltFilterSc a) #

type TQTiltFilterSc a = TQTiltFilter (CQTiltFilterSc a) #

data CQTiltFilterSc a #

qCastList_QTiltFilter :: QqCastList_QTiltFilter a r => a -> r #

withQTiltFilterResult :: IO (Ptr (TQTiltFilter a)) -> IO (QTiltFilter a) #

type QAmbientLightFilter a = QSensorFilter (CQAmbientLightFilter a) #

type TQAmbientLightFilter a = TQSensorFilter (CQAmbientLightFilter a) #

data CQAmbientLightFilter a #

qCast_QAmbientLightFilter :: Object a -> IO (QAmbientLightFilter ()) #

type QAmbientLightFilterSc a = QAmbientLightFilter (CQAmbientLightFilterSc a) #

type TQAmbientLightFilterSc a = TQAmbientLightFilter (CQAmbientLightFilterSc a) #

data CQAmbientLightFilterSc a #

qCastList_QAmbientLightFilter :: QqCastList_QAmbientLightFilter a r => a -> r #

withQAmbientLightFilterResult :: IO (Ptr (TQAmbientLightFilter a)) -> IO (QAmbientLightFilter a) #

type QRotationFilter a = QSensorFilter (CQRotationFilter a) #

type TQRotationFilter a = TQSensorFilter (CQRotationFilter a) #

data CQRotationFilter a #

qCast_QRotationFilter :: Object a -> IO (QRotationFilter ()) #

type QRotationFilterSc a = QRotationFilter (CQRotationFilterSc a) #

type TQRotationFilterSc a = TQRotationFilter (CQRotationFilterSc a) #

data CQRotationFilterSc a #

qCastList_QRotationFilter :: QqCastList_QRotationFilter a r => a -> r #

withQRotationFilterResult :: IO (Ptr (TQRotationFilter a)) -> IO (QRotationFilter a) #

type QMagnetometerFilter a = QSensorFilter (CQMagnetometerFilter a) #

type TQMagnetometerFilter a = TQSensorFilter (CQMagnetometerFilter a) #

data CQMagnetometerFilter a #

qCast_QMagnetometerFilter :: Object a -> IO (QMagnetometerFilter ()) #

type QMagnetometerFilterSc a = QMagnetometerFilter (CQMagnetometerFilterSc a) #

type TQMagnetometerFilterSc a = TQMagnetometerFilter (CQMagnetometerFilterSc a) #

data CQMagnetometerFilterSc a #

qCastList_QMagnetometerFilter :: QqCastList_QMagnetometerFilter a r => a -> r #

withQMagnetometerFilterResult :: IO (Ptr (TQMagnetometerFilter a)) -> IO (QMagnetometerFilter a) #

type QHolsterFilter a = QSensorFilter (CQHolsterFilter a) #

type TQHolsterFilter a = TQSensorFilter (CQHolsterFilter a) #

data CQHolsterFilter a #

qCast_QHolsterFilter :: Object a -> IO (QHolsterFilter ()) #

type QHolsterFilterSc a = QHolsterFilter (CQHolsterFilterSc a) #

type TQHolsterFilterSc a = TQHolsterFilter (CQHolsterFilterSc a) #

data CQHolsterFilterSc a #

qCastList_QHolsterFilter :: QqCastList_QHolsterFilter a r => a -> r #

withQHolsterFilterResult :: IO (Ptr (TQHolsterFilter a)) -> IO (QHolsterFilter a) #

type QCompassFilter a = QSensorFilter (CQCompassFilter a) #

type TQCompassFilter a = TQSensorFilter (CQCompassFilter a) #

data CQCompassFilter a #

qCast_QCompassFilter :: Object a -> IO (QCompassFilter ()) #

type QCompassFilterSc a = QCompassFilter (CQCompassFilterSc a) #

type TQCompassFilterSc a = TQCompassFilter (CQCompassFilterSc a) #

data CQCompassFilterSc a #

qCastList_QCompassFilter :: QqCastList_QCompassFilter a r => a -> r #

withQCompassFilterResult :: IO (Ptr (TQCompassFilter a)) -> IO (QCompassFilter a) #

type QGyroscopeFilter a = QSensorFilter (CQGyroscopeFilter a) #

type TQGyroscopeFilter a = TQSensorFilter (CQGyroscopeFilter a) #

data CQGyroscopeFilter a #

qCast_QGyroscopeFilter :: Object a -> IO (QGyroscopeFilter ()) #

type QGyroscopeFilterSc a = QGyroscopeFilter (CQGyroscopeFilterSc a) #

type TQGyroscopeFilterSc a = TQGyroscopeFilter (CQGyroscopeFilterSc a) #

data CQGyroscopeFilterSc a #

qCastList_QGyroscopeFilter :: QqCastList_QGyroscopeFilter a r => a -> r #

withQGyroscopeFilterResult :: IO (Ptr (TQGyroscopeFilter a)) -> IO (QGyroscopeFilter a) #

type QAltimeterFilter a = QSensorFilter (CQAltimeterFilter a) #

type TQAltimeterFilter a = TQSensorFilter (CQAltimeterFilter a) #

data CQAltimeterFilter a #

qCast_QAltimeterFilter :: Object a -> IO (QAltimeterFilter ()) #

type QAltimeterFilterSc a = QAltimeterFilter (CQAltimeterFilterSc a) #

type TQAltimeterFilterSc a = TQAltimeterFilter (CQAltimeterFilterSc a) #

data CQAltimeterFilterSc a #

qCastList_QAltimeterFilter :: QqCastList_QAltimeterFilter a r => a -> r #

withQAltimeterFilterResult :: IO (Ptr (TQAltimeterFilter a)) -> IO (QAltimeterFilter a) #

type QIRProximityFilter a = QSensorFilter (CQIRProximityFilter a) #

type TQIRProximityFilter a = TQSensorFilter (CQIRProximityFilter a) #

data CQIRProximityFilter a #

qCast_QIRProximityFilter :: Object a -> IO (QIRProximityFilter ()) #

type QIRProximityFilterSc a = QIRProximityFilter (CQIRProximityFilterSc a) #

type TQIRProximityFilterSc a = TQIRProximityFilter (CQIRProximityFilterSc a) #

data CQIRProximityFilterSc a #

qCastList_QIRProximityFilter :: QqCastList_QIRProximityFilter a r => a -> r #

withQIRProximityFilterResult :: IO (Ptr (TQIRProximityFilter a)) -> IO (QIRProximityFilter a) #

type QProximityFilter a = QSensorFilter (CQProximityFilter a) #

type TQProximityFilter a = TQSensorFilter (CQProximityFilter a) #

data CQProximityFilter a #

qCast_QProximityFilter :: Object a -> IO (QProximityFilter ()) #

type QProximityFilterSc a = QProximityFilter (CQProximityFilterSc a) #

type TQProximityFilterSc a = TQProximityFilter (CQProximityFilterSc a) #

data CQProximityFilterSc a #

qCastList_QProximityFilter :: QqCastList_QProximityFilter a r => a -> r #

withQProximityFilterResult :: IO (Ptr (TQProximityFilter a)) -> IO (QProximityFilter a) #

type QAmbientTemperatureFilter a = QSensorFilter (CQAmbientTemperatureFilter a) #

type TQAmbientTemperatureFilter a = TQSensorFilter (CQAmbientTemperatureFilter a) #

data CQAmbientTemperatureFilter a #

qCast_QAmbientTemperatureFilter :: Object a -> IO (QAmbientTemperatureFilter ()) #

type QAmbientTemperatureFilterSc a = QAmbientTemperatureFilter (CQAmbientTemperatureFilterSc a) #

type TQAmbientTemperatureFilterSc a = TQAmbientTemperatureFilter (CQAmbientTemperatureFilterSc a) #

data CQAmbientTemperatureFilterSc a #

qCastList_QAmbientTemperatureFilter :: QqCastList_QAmbientTemperatureFilter a r => a -> r #

withQAmbientTemperatureFilterResult :: IO (Ptr (TQAmbientTemperatureFilter a)) -> IO (QAmbientTemperatureFilter a) #

type QOrientationFilter a = QSensorFilter (CQOrientationFilter a) #

type TQOrientationFilter a = TQSensorFilter (CQOrientationFilter a) #

data CQOrientationFilter a #

qCast_QOrientationFilter :: Object a -> IO (QOrientationFilter ()) #

type QOrientationFilterSc a = QOrientationFilter (CQOrientationFilterSc a) #

type TQOrientationFilterSc a = TQOrientationFilter (CQOrientationFilterSc a) #

data CQOrientationFilterSc a #

qCastList_QOrientationFilter :: QqCastList_QOrientationFilter a r => a -> r #

withQOrientationFilterResult :: IO (Ptr (TQOrientationFilter a)) -> IO (QOrientationFilter a) #

type QTapFilter a = QSensorFilter (CQTapFilter a) #

type TQTapFilter a = TQSensorFilter (CQTapFilter a) #

data CQTapFilter a #

qCast_QTapFilter :: Object a -> IO (QTapFilter ()) #

type QTapFilterSc a = QTapFilter (CQTapFilterSc a) #

type TQTapFilterSc a = TQTapFilter (CQTapFilterSc a) #

data CQTapFilterSc a #

qCastList_QTapFilter :: QqCastList_QTapFilter a r => a -> r #

withQTapFilterResult :: IO (Ptr (TQTapFilter a)) -> IO (QTapFilter a) #

type QAccelerometerFilter a = QSensorFilter (CQAccelerometerFilter a) #

type TQAccelerometerFilter a = TQSensorFilter (CQAccelerometerFilter a) #

data CQAccelerometerFilter a #

qCast_QAccelerometerFilter :: Object a -> IO (QAccelerometerFilter ()) #

type QAccelerometerFilterSc a = QAccelerometerFilter (CQAccelerometerFilterSc a) #

type TQAccelerometerFilterSc a = TQAccelerometerFilter (CQAccelerometerFilterSc a) #

data CQAccelerometerFilterSc a #

qCastList_QAccelerometerFilter :: QqCastList_QAccelerometerFilter a r => a -> r #

withQAccelerometerFilterResult :: IO (Ptr (TQAccelerometerFilter a)) -> IO (QAccelerometerFilter a) #

type QPressureReading a = QSensorReading (CQPressureReading a) #

type TQPressureReading a = TQSensorReading (CQPressureReading a) #

data CQPressureReading a #

qCast_QPressureReading :: Object a -> IO (QPressureReading ()) #

type QPressureReadingSc a = QPressureReading (CQPressureReadingSc a) #

type TQPressureReadingSc a = TQPressureReading (CQPressureReadingSc a) #

data CQPressureReadingSc a #

qCastList_QPressureReading :: QqCastList_QPressureReading a r => a -> r #

withQPressureReadingResult :: IO (Ptr (TQPressureReading a)) -> IO (QPressureReading a) #

qPressureReadingFromPtr :: Ptr (TQPressureReading a) -> IO (QPressureReading a) #

qPressureReadingAddFinalizer :: QPressureReading a -> IO () #

type QCompassReading a = QSensorReading (CQCompassReading a) #

type TQCompassReading a = TQSensorReading (CQCompassReading a) #

data CQCompassReading a #

qCast_QCompassReading :: Object a -> IO (QCompassReading ()) #

type QCompassReadingSc a = QCompassReading (CQCompassReadingSc a) #

type TQCompassReadingSc a = TQCompassReading (CQCompassReadingSc a) #

data CQCompassReadingSc a #

qCastList_QCompassReading :: QqCastList_QCompassReading a r => a -> r #

withQCompassReadingResult :: IO (Ptr (TQCompassReading a)) -> IO (QCompassReading a) #

qCompassReadingFromPtr :: Ptr (TQCompassReading a) -> IO (QCompassReading a) #

qCompassReadingAddFinalizer :: QCompassReading a -> IO () #

type QAccelerometerReading a = QSensorReading (CQAccelerometerReading a) #

type TQAccelerometerReading a = TQSensorReading (CQAccelerometerReading a) #

data CQAccelerometerReading a #

qCast_QAccelerometerReading :: Object a -> IO (QAccelerometerReading ()) #

type QAccelerometerReadingSc a = QAccelerometerReading (CQAccelerometerReadingSc a) #

type TQAccelerometerReadingSc a = TQAccelerometerReading (CQAccelerometerReadingSc a) #

data CQAccelerometerReadingSc a #

qCastList_QAccelerometerReading :: QqCastList_QAccelerometerReading a r => a -> r #

withQAccelerometerReadingResult :: IO (Ptr (TQAccelerometerReading a)) -> IO (QAccelerometerReading a) #

qAccelerometerReadingFromPtr :: Ptr (TQAccelerometerReading a) -> IO (QAccelerometerReading a) #

qAccelerometerReadingAddFinalizer :: QAccelerometerReading a -> IO () #

type QTapReading a = QSensorReading (CQTapReading a) #

type TQTapReading a = TQSensorReading (CQTapReading a) #

data CQTapReading a #

qCast_QTapReading :: Object a -> IO (QTapReading ()) #

type QTapReadingSc a = QTapReading (CQTapReadingSc a) #

type TQTapReadingSc a = TQTapReading (CQTapReadingSc a) #

data CQTapReadingSc a #

qCastList_QTapReading :: QqCastList_QTapReading a r => a -> r #

withQTapReadingResult :: IO (Ptr (TQTapReading a)) -> IO (QTapReading a) #

qTapReadingFromPtr :: Ptr (TQTapReading a) -> IO (QTapReading a) #

qTapReadingAddFinalizer :: QTapReading a -> IO () #

type QGyroscopeReading a = QSensorReading (CQGyroscopeReading a) #

type TQGyroscopeReading a = TQSensorReading (CQGyroscopeReading a) #

data CQGyroscopeReading a #

qCast_QGyroscopeReading :: Object a -> IO (QGyroscopeReading ()) #

type QGyroscopeReadingSc a = QGyroscopeReading (CQGyroscopeReadingSc a) #

type TQGyroscopeReadingSc a = TQGyroscopeReading (CQGyroscopeReadingSc a) #

data CQGyroscopeReadingSc a #

qCastList_QGyroscopeReading :: QqCastList_QGyroscopeReading a r => a -> r #

withQGyroscopeReadingResult :: IO (Ptr (TQGyroscopeReading a)) -> IO (QGyroscopeReading a) #

qGyroscopeReadingFromPtr :: Ptr (TQGyroscopeReading a) -> IO (QGyroscopeReading a) #

qGyroscopeReadingAddFinalizer :: QGyroscopeReading a -> IO () #

type QOrientationReading a = QSensorReading (CQOrientationReading a) #

type TQOrientationReading a = TQSensorReading (CQOrientationReading a) #

data CQOrientationReading a #

qCast_QOrientationReading :: Object a -> IO (QOrientationReading ()) #

type QOrientationReadingSc a = QOrientationReading (CQOrientationReadingSc a) #

type TQOrientationReadingSc a = TQOrientationReading (CQOrientationReadingSc a) #

data CQOrientationReadingSc a #

qCastList_QOrientationReading :: QqCastList_QOrientationReading a r => a -> r #

withQOrientationReadingResult :: IO (Ptr (TQOrientationReading a)) -> IO (QOrientationReading a) #

qOrientationReadingFromPtr :: Ptr (TQOrientationReading a) -> IO (QOrientationReading a) #

qOrientationReadingAddFinalizer :: QOrientationReading a -> IO () #

type QProximityReading a = QSensorReading (CQProximityReading a) #

type TQProximityReading a = TQSensorReading (CQProximityReading a) #

data CQProximityReading a #

qCast_QProximityReading :: Object a -> IO (QProximityReading ()) #

type QProximityReadingSc a = QProximityReading (CQProximityReadingSc a) #

type TQProximityReadingSc a = TQProximityReading (CQProximityReadingSc a) #

data CQProximityReadingSc a #

qCastList_QProximityReading :: QqCastList_QProximityReading a r => a -> r #

withQProximityReadingResult :: IO (Ptr (TQProximityReading a)) -> IO (QProximityReading a) #

qProximityReadingFromPtr :: Ptr (TQProximityReading a) -> IO (QProximityReading a) #

qProximityReadingAddFinalizer :: QProximityReading a -> IO () #

type QAmbientLightReading a = QSensorReading (CQAmbientLightReading a) #

type TQAmbientLightReading a = TQSensorReading (CQAmbientLightReading a) #

data CQAmbientLightReading a #

qCast_QAmbientLightReading :: Object a -> IO (QAmbientLightReading ()) #

type QAmbientLightReadingSc a = QAmbientLightReading (CQAmbientLightReadingSc a) #

type TQAmbientLightReadingSc a = TQAmbientLightReading (CQAmbientLightReadingSc a) #

data CQAmbientLightReadingSc a #

qCastList_QAmbientLightReading :: QqCastList_QAmbientLightReading a r => a -> r #

withQAmbientLightReadingResult :: IO (Ptr (TQAmbientLightReading a)) -> IO (QAmbientLightReading a) #

qAmbientLightReadingFromPtr :: Ptr (TQAmbientLightReading a) -> IO (QAmbientLightReading a) #

qAmbientLightReadingAddFinalizer :: QAmbientLightReading a -> IO () #

type QHolsterReading a = QSensorReading (CQHolsterReading a) #

type TQHolsterReading a = TQSensorReading (CQHolsterReading a) #

data CQHolsterReading a #

qCast_QHolsterReading :: Object a -> IO (QHolsterReading ()) #

type QHolsterReadingSc a = QHolsterReading (CQHolsterReadingSc a) #

type TQHolsterReadingSc a = TQHolsterReading (CQHolsterReadingSc a) #

data CQHolsterReadingSc a #

qCastList_QHolsterReading :: QqCastList_QHolsterReading a r => a -> r #

withQHolsterReadingResult :: IO (Ptr (TQHolsterReading a)) -> IO (QHolsterReading a) #

qHolsterReadingFromPtr :: Ptr (TQHolsterReading a) -> IO (QHolsterReading a) #

qHolsterReadingAddFinalizer :: QHolsterReading a -> IO () #

type QTiltReading a = QSensorReading (CQTiltReading a) #

type TQTiltReading a = TQSensorReading (CQTiltReading a) #

data CQTiltReading a #

qCast_QTiltReading :: Object a -> IO (QTiltReading ()) #

type QTiltReadingSc a = QTiltReading (CQTiltReadingSc a) #

type TQTiltReadingSc a = TQTiltReading (CQTiltReadingSc a) #

data CQTiltReadingSc a #

qCastList_QTiltReading :: QqCastList_QTiltReading a r => a -> r #

withQTiltReadingResult :: IO (Ptr (TQTiltReading a)) -> IO (QTiltReading a) #

qTiltReadingFromPtr :: Ptr (TQTiltReading a) -> IO (QTiltReading a) #

qTiltReadingAddFinalizer :: QTiltReading a -> IO () #

type QAmbientTemperatureReading a = QSensorReading (CQAmbientTemperatureReading a) #

type TQAmbientTemperatureReading a = TQSensorReading (CQAmbientTemperatureReading a) #

data CQAmbientTemperatureReading a #

qCast_QAmbientTemperatureReading :: Object a -> IO (QAmbientTemperatureReading ()) #

type QAmbientTemperatureReadingSc a = QAmbientTemperatureReading (CQAmbientTemperatureReadingSc a) #

type TQAmbientTemperatureReadingSc a = TQAmbientTemperatureReading (CQAmbientTemperatureReadingSc a) #

data CQAmbientTemperatureReadingSc a #

qCastList_QAmbientTemperatureReading :: QqCastList_QAmbientTemperatureReading a r => a -> r #

withQAmbientTemperatureReadingResult :: IO (Ptr (TQAmbientTemperatureReading a)) -> IO (QAmbientTemperatureReading a) #

qAmbientTemperatureReadingFromPtr :: Ptr (TQAmbientTemperatureReading a) -> IO (QAmbientTemperatureReading a) #

qAmbientTemperatureReadingAddFinalizer :: QAmbientTemperatureReading a -> IO () #

type QRotationReading a = QSensorReading (CQRotationReading a) #

type TQRotationReading a = TQSensorReading (CQRotationReading a) #

data CQRotationReading a #

qCast_QRotationReading :: Object a -> IO (QRotationReading ()) #

type QRotationReadingSc a = QRotationReading (CQRotationReadingSc a) #

type TQRotationReadingSc a = TQRotationReading (CQRotationReadingSc a) #

data CQRotationReadingSc a #

qCastList_QRotationReading :: QqCastList_QRotationReading a r => a -> r #

withQRotationReadingResult :: IO (Ptr (TQRotationReading a)) -> IO (QRotationReading a) #

qRotationReadingFromPtr :: Ptr (TQRotationReading a) -> IO (QRotationReading a) #

qRotationReadingAddFinalizer :: QRotationReading a -> IO () #

type QMagnetometerReading a = QSensorReading (CQMagnetometerReading a) #

type TQMagnetometerReading a = TQSensorReading (CQMagnetometerReading a) #

data CQMagnetometerReading a #

qCast_QMagnetometerReading :: Object a -> IO (QMagnetometerReading ()) #

type QMagnetometerReadingSc a = QMagnetometerReading (CQMagnetometerReadingSc a) #

type TQMagnetometerReadingSc a = TQMagnetometerReading (CQMagnetometerReadingSc a) #

data CQMagnetometerReadingSc a #

qCastList_QMagnetometerReading :: QqCastList_QMagnetometerReading a r => a -> r #

withQMagnetometerReadingResult :: IO (Ptr (TQMagnetometerReading a)) -> IO (QMagnetometerReading a) #

qMagnetometerReadingFromPtr :: Ptr (TQMagnetometerReading a) -> IO (QMagnetometerReading a) #

qMagnetometerReadingAddFinalizer :: QMagnetometerReading a -> IO () #

type QLightReading a = QSensorReading (CQLightReading a) #

type TQLightReading a = TQSensorReading (CQLightReading a) #

data CQLightReading a #

qCast_QLightReading :: Object a -> IO (QLightReading ()) #

type QLightReadingSc a = QLightReading (CQLightReadingSc a) #

type TQLightReadingSc a = TQLightReading (CQLightReadingSc a) #

data CQLightReadingSc a #

qCastList_QLightReading :: QqCastList_QLightReading a r => a -> r #

withQLightReadingResult :: IO (Ptr (TQLightReading a)) -> IO (QLightReading a) #

qLightReadingFromPtr :: Ptr (TQLightReading a) -> IO (QLightReading a) #

qLightReadingAddFinalizer :: QLightReading a -> IO () #

type QIRProximityReading a = QSensorReading (CQIRProximityReading a) #

type TQIRProximityReading a = TQSensorReading (CQIRProximityReading a) #

data CQIRProximityReading a #

qCast_QIRProximityReading :: Object a -> IO (QIRProximityReading ()) #

type QIRProximityReadingSc a = QIRProximityReading (CQIRProximityReadingSc a) #

type TQIRProximityReadingSc a = TQIRProximityReading (CQIRProximityReadingSc a) #

data CQIRProximityReadingSc a #

qCastList_QIRProximityReading :: QqCastList_QIRProximityReading a r => a -> r #

withQIRProximityReadingResult :: IO (Ptr (TQIRProximityReading a)) -> IO (QIRProximityReading a) #

qIRProximityReadingFromPtr :: Ptr (TQIRProximityReading a) -> IO (QIRProximityReading a) #

qIRProximityReadingAddFinalizer :: QIRProximityReading a -> IO () #

type QAltimeterReading a = QSensorReading (CQAltimeterReading a) #

type TQAltimeterReading a = TQSensorReading (CQAltimeterReading a) #

data CQAltimeterReading a #

qCast_QAltimeterReading :: Object a -> IO (QAltimeterReading ()) #

type QAltimeterReadingSc a = QAltimeterReading (CQAltimeterReadingSc a) #

type TQAltimeterReadingSc a = TQAltimeterReading (CQAltimeterReadingSc a) #

data CQAltimeterReadingSc a #

qCastList_QAltimeterReading :: QqCastList_QAltimeterReading a r => a -> r #

withQAltimeterReadingResult :: IO (Ptr (TQAltimeterReading a)) -> IO (QAltimeterReading a) #

qAltimeterReadingFromPtr :: Ptr (TQAltimeterReading a) -> IO (QAltimeterReading a) #

qAltimeterReadingAddFinalizer :: QAltimeterReading a -> IO () #

type QSP_QSensorReadingPrivatePtr a = Object (CQSP_QSensorReadingPrivatePtr a) #

type TQSP_QSensorReadingPrivatePtr a = CQSP_QSensorReadingPrivatePtr a #

data CQSP_QSensorReadingPrivatePtr a #

withQSP_QSensorReadingPrivatePtrResult :: IO (Ptr (TQSP_QSensorReadingPrivatePtr a)) -> IO (QSP_QSensorReadingPrivatePtr a) #

qListFromQListQSensorGestureRecognizerPtr :: Ptr (TQListQSensorGestureRecognizer ()) -> IO [QSensorGestureRecognizer t0] #

withQListQSensorGestureRecognizerHResult :: [QSensorGestureRecognizer t0] -> IO (Ptr (TQListQSensorGestureRecognizer ())) #