Documentation

type QAbstractSocket a = QIODevice (CQAbstractSocket a) #

type TQAbstractSocket a = TQIODevice (CQAbstractSocket a) #

data CQAbstractSocket a #

qCast_QAbstractSocket :: Object a -> IO (QAbstractSocket ()) #

type QAbstractSocketSc a = QAbstractSocket (CQAbstractSocketSc a) #

type TQAbstractSocketSc a = TQAbstractSocket (CQAbstractSocketSc a) #

data CQAbstractSocketSc a #

qCastList_QAbstractSocket :: QqCastList_QAbstractSocket a r => a -> r #

withQAbstractSocketResult :: IO (Ptr (TQAbstractSocket a)) -> IO (QAbstractSocket a) #

qAbstractSocketFromPtr :: Ptr (TQAbstractSocket a) -> IO (QAbstractSocket a) #

qAbstractSocketAddFinalizer :: QAbstractSocket a -> IO () #

type QAbstractNetworkCache a = QObject (CQAbstractNetworkCache a) #

type TQAbstractNetworkCache a = TQObject (CQAbstractNetworkCache a) #

data CQAbstractNetworkCache a #

qCast_QAbstractNetworkCache :: Object a -> IO (QAbstractNetworkCache ()) #

type QAbstractNetworkCacheSc a = QAbstractNetworkCache (CQAbstractNetworkCacheSc a) #

type TQAbstractNetworkCacheSc a = TQAbstractNetworkCache (CQAbstractNetworkCacheSc a) #

data CQAbstractNetworkCacheSc a #

qCastList_QAbstractNetworkCache :: QqCastList_QAbstractNetworkCache a r => a -> r #

withQAbstractNetworkCacheResult :: IO (Ptr (TQAbstractNetworkCache a)) -> IO (QAbstractNetworkCache a) #

qAbstractNetworkCacheFromPtr :: Ptr (TQAbstractNetworkCache a) -> IO (QAbstractNetworkCache a) #

qAbstractNetworkCacheAddFinalizer :: QAbstractNetworkCache a -> IO () #

type QIPv6Address a = Object (CQIPv6Address a) #

type TQIPv6Address a = CQIPv6Address a #

data CQIPv6Address a #

qCast_QIPv6Address :: Object a -> IO (QIPv6Address ()) #

type QIPv6AddressSc a = QIPv6Address (CQIPv6AddressSc a) #

type TQIPv6AddressSc a = TQIPv6Address (CQIPv6AddressSc a) #

data CQIPv6AddressSc a #

qCastList_QIPv6Address :: QqCastList_QIPv6Address a r => a -> r #

withQIPv6AddressResult :: IO (Ptr (TQIPv6Address a)) -> IO (QIPv6Address a) #

type QSslPreSharedKeyAuthenticator a = Object (CQSslPreSharedKeyAuthenticator a) #

type TQSslPreSharedKeyAuthenticator a = CQSslPreSharedKeyAuthenticator a #

data CQSslPreSharedKeyAuthenticator a #

qCast_QSslPreSharedKeyAuthenticator :: Object a -> IO (QSslPreSharedKeyAuthenticator ()) #

type QSslPreSharedKeyAuthenticatorSc a = QSslPreSharedKeyAuthenticator (CQSslPreSharedKeyAuthenticatorSc a) #

type TQSslPreSharedKeyAuthenticatorSc a = TQSslPreSharedKeyAuthenticator (CQSslPreSharedKeyAuthenticatorSc a) #

data CQSslPreSharedKeyAuthenticatorSc a #

qCastList_QSslPreSharedKeyAuthenticator :: QqCastList_QSslPreSharedKeyAuthenticator a r => a -> r #

withQSslPreSharedKeyAuthenticatorResult :: IO (Ptr (TQSslPreSharedKeyAuthenticator a)) -> IO (QSslPreSharedKeyAuthenticator a) #

type QNetworkInterface a = Object (CQNetworkInterface a) #

type TQNetworkInterface a = CQNetworkInterface a #

data CQNetworkInterface a #

qCast_QNetworkInterface :: Object a -> IO (QNetworkInterface ()) #

type QNetworkInterfaceSc a = QNetworkInterface (CQNetworkInterfaceSc a) #

type TQNetworkInterfaceSc a = TQNetworkInterface (CQNetworkInterfaceSc a) #

data CQNetworkInterfaceSc a #

qCastList_QNetworkInterface :: QqCastList_QNetworkInterface a r => a -> r #

withQNetworkInterfaceResult :: IO (Ptr (TQNetworkInterface a)) -> IO (QNetworkInterface a) #

withQListQNetworkInterfaceResult :: IO (Ptr (TQListQNetworkInterface ())) -> IO [QNetworkInterface ()] #

qNetworkInterfaceListFromPtrList :: [Ptr (TQNetworkInterface a)] -> IO [QNetworkInterface a] #

type QListQNetworkInterface a = Object (CQListQNetworkInterface a) #

type TQListQNetworkInterface a = CQListQNetworkInterface a #

data CQListQNetworkInterface a #

type QNetworkProxyFactory a = Object (CQNetworkProxyFactory a) #

type TQNetworkProxyFactory a = CQNetworkProxyFactory a #

data CQNetworkProxyFactory a #

qCast_QNetworkProxyFactory :: Object a -> IO (QNetworkProxyFactory ()) #

type QNetworkProxyFactorySc a = QNetworkProxyFactory (CQNetworkProxyFactorySc a) #

type TQNetworkProxyFactorySc a = TQNetworkProxyFactory (CQNetworkProxyFactorySc a) #

data CQNetworkProxyFactorySc a #

qCastList_QNetworkProxyFactory :: QqCastList_QNetworkProxyFactory a r => a -> r #

withQNetworkProxyFactoryResult :: IO (Ptr (TQNetworkProxyFactory a)) -> IO (QNetworkProxyFactory a) #

type QDnsTextRecord a = Object (CQDnsTextRecord a) #

type TQDnsTextRecord a = CQDnsTextRecord a #

data CQDnsTextRecord a #

qCast_QDnsTextRecord :: Object a -> IO (QDnsTextRecord ()) #

type QDnsTextRecordSc a = QDnsTextRecord (CQDnsTextRecordSc a) #

type TQDnsTextRecordSc a = TQDnsTextRecord (CQDnsTextRecordSc a) #

data CQDnsTextRecordSc a #

qCastList_QDnsTextRecord :: QqCastList_QDnsTextRecord a r => a -> r #

withQDnsTextRecordResult :: IO (Ptr (TQDnsTextRecord a)) -> IO (QDnsTextRecord a) #

withQListQDnsTextRecordResult :: IO (Ptr (TQListQDnsTextRecord ())) -> IO [QDnsTextRecord ()] #

qDnsTextRecordListFromPtrList :: [Ptr (TQDnsTextRecord a)] -> IO [QDnsTextRecord a] #

type QListQDnsTextRecord a = Object (CQListQDnsTextRecord a) #

type TQListQDnsTextRecord a = CQListQDnsTextRecord a #

data CQListQDnsTextRecord a #

type QNetworkRequest a = Object (CQNetworkRequest a) #

type TQNetworkRequest a = CQNetworkRequest a #

data CQNetworkRequest a #

qCast_QNetworkRequest :: Object a -> IO (QNetworkRequest ()) #

type QNetworkRequestSc a = QNetworkRequest (CQNetworkRequestSc a) #

type TQNetworkRequestSc a = TQNetworkRequest (CQNetworkRequestSc a) #

data CQNetworkRequestSc a #

qCastList_QNetworkRequest :: QqCastList_QNetworkRequest a r => a -> r #

withQNetworkRequestResult :: IO (Ptr (TQNetworkRequest a)) -> IO (QNetworkRequest a) #

type QSslConfiguration a = Object (CQSslConfiguration a) #

type TQSslConfiguration a = CQSslConfiguration a #

data CQSslConfiguration a #

qCast_QSslConfiguration :: Object a -> IO (QSslConfiguration ()) #

type QSslConfigurationSc a = QSslConfiguration (CQSslConfigurationSc a) #

type TQSslConfigurationSc a = TQSslConfiguration (CQSslConfigurationSc a) #

data CQSslConfigurationSc a #

qCastList_QSslConfiguration :: QqCastList_QSslConfiguration a r => a -> r #

withQSslConfigurationResult :: IO (Ptr (TQSslConfiguration a)) -> IO (QSslConfiguration a) #

type QHostAddress a = Object (CQHostAddress a) #

type TQHostAddress a = CQHostAddress a #

data CQHostAddress a #

qCast_QHostAddress :: Object a -> IO (QHostAddress ()) #

type QHostAddressSc a = QHostAddress (CQHostAddressSc a) #

type TQHostAddressSc a = TQHostAddress (CQHostAddressSc a) #

data CQHostAddressSc a #

qCastList_QHostAddress :: QqCastList_QHostAddress a r => a -> r #

withQHostAddressResult :: IO (Ptr (TQHostAddress a)) -> IO (QHostAddress a) #

withQListQHostAddressResult :: IO (Ptr (TQListQHostAddress ())) -> IO [QHostAddress ()] #

qHostAddressListFromPtrList :: [Ptr (TQHostAddress a)] -> IO [QHostAddress a] #

type QListQHostAddress a = Object (CQListQHostAddress a) #

type TQListQHostAddress a = CQListQHostAddress a #

data CQListQHostAddress a #

type QDnsServiceRecord a = Object (CQDnsServiceRecord a) #

type TQDnsServiceRecord a = CQDnsServiceRecord a #

data CQDnsServiceRecord a #

qCast_QDnsServiceRecord :: Object a -> IO (QDnsServiceRecord ()) #

type QDnsServiceRecordSc a = QDnsServiceRecord (CQDnsServiceRecordSc a) #

type TQDnsServiceRecordSc a = TQDnsServiceRecord (CQDnsServiceRecordSc a) #

data CQDnsServiceRecordSc a #

qCastList_QDnsServiceRecord :: QqCastList_QDnsServiceRecord a r => a -> r #

withQDnsServiceRecordResult :: IO (Ptr (TQDnsServiceRecord a)) -> IO (QDnsServiceRecord a) #

withQListQDnsServiceRecordResult :: IO (Ptr (TQListQDnsServiceRecord ())) -> IO [QDnsServiceRecord ()] #

qDnsServiceRecordListFromPtrList :: [Ptr (TQDnsServiceRecord a)] -> IO [QDnsServiceRecord a] #

type QListQDnsServiceRecord a = Object (CQListQDnsServiceRecord a) #

type TQListQDnsServiceRecord a = CQListQDnsServiceRecord a #

data CQListQDnsServiceRecord a #

type QSslCertificate a = Object (CQSslCertificate a) #

type TQSslCertificate a = CQSslCertificate a #

data CQSslCertificate a #

qCast_QSslCertificate :: Object a -> IO (QSslCertificate ()) #

type QSslCertificateSc a = QSslCertificate (CQSslCertificateSc a) #

type TQSslCertificateSc a = TQSslCertificate (CQSslCertificateSc a) #

data CQSslCertificateSc a #

qCastList_QSslCertificate :: QqCastList_QSslCertificate a r => a -> r #

withQSslCertificateResult :: IO (Ptr (TQSslCertificate a)) -> IO (QSslCertificate a) #

withQListQSslCertificateResult :: IO (Ptr (TQListQSslCertificate ())) -> IO [QSslCertificate ()] #

qSslCertificateListFromPtrList :: [Ptr (TQSslCertificate a)] -> IO [QSslCertificate a] #

type QListQSslCertificate a = Object (CQListQSslCertificate a) #

type TQListQSslCertificate a = CQListQSslCertificate a #

data CQListQSslCertificate a #

type QSslCipher a = Object (CQSslCipher a) #

type TQSslCipher a = CQSslCipher a #

data CQSslCipher a #

qCast_QSslCipher :: Object a -> IO (QSslCipher ()) #

type QSslCipherSc a = QSslCipher (CQSslCipherSc a) #

type TQSslCipherSc a = TQSslCipher (CQSslCipherSc a) #

data CQSslCipherSc a #

qCastList_QSslCipher :: QqCastList_QSslCipher a r => a -> r #

withQSslCipherResult :: IO (Ptr (TQSslCipher a)) -> IO (QSslCipher a) #

withQListQSslCipherResult :: IO (Ptr (TQListQSslCipher ())) -> IO [QSslCipher ()] #

qSslCipherListFromPtrList :: [Ptr (TQSslCipher a)] -> IO [QSslCipher a] #

type QListQSslCipher a = Object (CQListQSslCipher a) #

type TQListQSslCipher a = CQListQSslCipher a #

data CQListQSslCipher a #

type QSslError a = Object (CQSslError a) #

type TQSslError a = CQSslError a #

data CQSslError a #

qCast_QSslError :: Object a -> IO (QSslError ()) #

type QSslErrorSc a = QSslError (CQSslErrorSc a) #

type TQSslErrorSc a = TQSslError (CQSslErrorSc a) #

data CQSslErrorSc a #

qCastList_QSslError :: QqCastList_QSslError a r => a -> r #

withQSslErrorResult :: IO (Ptr (TQSslError a)) -> IO (QSslError a) #

withQListQSslErrorResult :: IO (Ptr (TQListQSslError ())) -> IO [QSslError ()] #

qSslErrorListFromPtrList :: [Ptr (TQSslError a)] -> IO [QSslError a] #

type QListQSslError a = Object (CQListQSslError a) #

type TQListQSslError a = CQListQSslError a #

data CQListQSslError a #

type QDnsMailExchangeRecord a = Object (CQDnsMailExchangeRecord a) #

type TQDnsMailExchangeRecord a = CQDnsMailExchangeRecord a #

data CQDnsMailExchangeRecord a #

qCast_QDnsMailExchangeRecord :: Object a -> IO (QDnsMailExchangeRecord ()) #

type QDnsMailExchangeRecordSc a = QDnsMailExchangeRecord (CQDnsMailExchangeRecordSc a) #

type TQDnsMailExchangeRecordSc a = TQDnsMailExchangeRecord (CQDnsMailExchangeRecordSc a) #

data CQDnsMailExchangeRecordSc a #

qCastList_QDnsMailExchangeRecord :: QqCastList_QDnsMailExchangeRecord a r => a -> r #

withQDnsMailExchangeRecordResult :: IO (Ptr (TQDnsMailExchangeRecord a)) -> IO (QDnsMailExchangeRecord a) #

withQListQDnsMailExchangeRecordResult :: IO (Ptr (TQListQDnsMailExchangeRecord ())) -> IO [QDnsMailExchangeRecord ()] #

qDnsMailExchangeRecordListFromPtrList :: [Ptr (TQDnsMailExchangeRecord a)] -> IO [QDnsMailExchangeRecord a] #

type QListQDnsMailExchangeRecord a = Object (CQListQDnsMailExchangeRecord a) #

type TQListQDnsMailExchangeRecord a = CQListQDnsMailExchangeRecord a #

data CQListQDnsMailExchangeRecord a #

type QSslKey a = Object (CQSslKey a) #

type TQSslKey a = CQSslKey a #

data CQSslKey a #

qCast_QSslKey :: Object a -> IO (QSslKey ()) #

type QSslKeySc a = QSslKey (CQSslKeySc a) #

type TQSslKeySc a = TQSslKey (CQSslKeySc a) #

data CQSslKeySc a #

qCastList_QSslKey :: QqCastList_QSslKey a r => a -> r #

withQSslKeyResult :: IO (Ptr (TQSslKey a)) -> IO (QSslKey a) #

type QNSockAddr a = Object (CQNSockAddr a) #

type TQNSockAddr a = CQNSockAddr a #

data CQNSockAddr a #

qCast_QNSockAddr :: Object a -> IO (QNSockAddr ()) #

type QNSockAddrSc a = QNSockAddr (CQNSockAddrSc a) #

type TQNSockAddrSc a = TQNSockAddr (CQNSockAddrSc a) #

data CQNSockAddrSc a #

qCastList_QNSockAddr :: QqCastList_QNSockAddr a r => a -> r #

type QSslSocket a = Object (CQSslSocket a) #

type TQSslSocket a = CQSslSocket a #

data CQSslSocket a #

qCast_QSslSocket :: Object a -> IO (QSslSocket ()) #

type QSslSocketSc a = QSslSocket (CQSslSocketSc a) #

type TQSslSocketSc a = TQSslSocket (CQSslSocketSc a) #

data CQSslSocketSc a #

qCastList_QSslSocket :: QqCastList_QSslSocket a r => a -> r #

withQSslSocketResult :: IO (Ptr (TQSslSocket a)) -> IO (QSslSocket a) #

type QAuthenticator a = Object (CQAuthenticator a) #

type TQAuthenticator a = CQAuthenticator a #

data CQAuthenticator a #

qCast_QAuthenticator :: Object a -> IO (QAuthenticator ()) #

type QAuthenticatorSc a = QAuthenticator (CQAuthenticatorSc a) #

type TQAuthenticatorSc a = TQAuthenticator (CQAuthenticatorSc a) #

data CQAuthenticatorSc a #

qCastList_QAuthenticator :: QqCastList_QAuthenticator a r => a -> r #

withQAuthenticatorResult :: IO (Ptr (TQAuthenticator a)) -> IO (QAuthenticator a) #

type QHstsPolicy a = Object (CQHstsPolicy a) #

type TQHstsPolicy a = CQHstsPolicy a #

data CQHstsPolicy a #

qCast_QHstsPolicy :: Object a -> IO (QHstsPolicy ()) #

type QHstsPolicySc a = QHstsPolicy (CQHstsPolicySc a) #

type TQHstsPolicySc a = TQHstsPolicy (CQHstsPolicySc a) #

data CQHstsPolicySc a #

qCastList_QHstsPolicy :: QqCastList_QHstsPolicy a r => a -> r #

withQHstsPolicyResult :: IO (Ptr (TQHstsPolicy a)) -> IO (QHstsPolicy a) #

withQVectorQHstsPolicyResult :: IO (Ptr (TQVectorQHstsPolicy ())) -> IO [QHstsPolicy ()] #

qHstsPolicyVectorFromPtrList :: [Ptr (TQHstsPolicy a)] -> IO [QHstsPolicy a] #

type QVectorQHstsPolicy a = Object (CQVectorQHstsPolicy a) #

type TQVectorQHstsPolicy a = CQVectorQHstsPolicy a #

data CQVectorQHstsPolicy a #

type QDnsDomainNameRecord a = Object (CQDnsDomainNameRecord a) #

type TQDnsDomainNameRecord a = CQDnsDomainNameRecord a #

data CQDnsDomainNameRecord a #

qCast_QDnsDomainNameRecord :: Object a -> IO (QDnsDomainNameRecord ()) #

type QDnsDomainNameRecordSc a = QDnsDomainNameRecord (CQDnsDomainNameRecordSc a) #

type TQDnsDomainNameRecordSc a = TQDnsDomainNameRecord (CQDnsDomainNameRecordSc a) #

data CQDnsDomainNameRecordSc a #

qCastList_QDnsDomainNameRecord :: QqCastList_QDnsDomainNameRecord a r => a -> r #

withQDnsDomainNameRecordResult :: IO (Ptr (TQDnsDomainNameRecord a)) -> IO (QDnsDomainNameRecord a) #

withQListQDnsDomainNameRecordResult :: IO (Ptr (TQListQDnsDomainNameRecord ())) -> IO [QDnsDomainNameRecord ()] #

qDnsDomainNameRecordListFromPtrList :: [Ptr (TQDnsDomainNameRecord a)] -> IO [QDnsDomainNameRecord a] #

type QListQDnsDomainNameRecord a = Object (CQListQDnsDomainNameRecord a) #

type TQListQDnsDomainNameRecord a = CQListQDnsDomainNameRecord a #

data CQListQDnsDomainNameRecord a #

type QNetworkConfiguration a = Object (CQNetworkConfiguration a) #

type TQNetworkConfiguration a = CQNetworkConfiguration a #

data CQNetworkConfiguration a #

qCast_QNetworkConfiguration :: Object a -> IO (QNetworkConfiguration ()) #

type QNetworkConfigurationSc a = QNetworkConfiguration (CQNetworkConfigurationSc a) #

type TQNetworkConfigurationSc a = TQNetworkConfiguration (CQNetworkConfigurationSc a) #

data CQNetworkConfigurationSc a #

qCastList_QNetworkConfiguration :: QqCastList_QNetworkConfiguration a r => a -> r #

withQNetworkConfigurationResult :: IO (Ptr (TQNetworkConfiguration a)) -> IO (QNetworkConfiguration a) #

withQListQNetworkConfigurationResult :: IO (Ptr (TQListQNetworkConfiguration ())) -> IO [QNetworkConfiguration ()] #

qNetworkConfigurationListFromPtrList :: [Ptr (TQNetworkConfiguration a)] -> IO [QNetworkConfiguration a] #

type QListQNetworkConfiguration a = Object (CQListQNetworkConfiguration a) #

type TQListQNetworkConfiguration a = CQListQNetworkConfiguration a #

data CQListQNetworkConfiguration a #

type QSslEllipticCurve a = Object (CQSslEllipticCurve a) #

type TQSslEllipticCurve a = CQSslEllipticCurve a #

data CQSslEllipticCurve a #

qCast_QSslEllipticCurve :: Object a -> IO (QSslEllipticCurve ()) #

type QSslEllipticCurveSc a = QSslEllipticCurve (CQSslEllipticCurveSc a) #

type TQSslEllipticCurveSc a = TQSslEllipticCurve (CQSslEllipticCurveSc a) #

data CQSslEllipticCurveSc a #

qCastList_QSslEllipticCurve :: QqCastList_QSslEllipticCurve a r => a -> r #

withQSslEllipticCurveResult :: IO (Ptr (TQSslEllipticCurve a)) -> IO (QSslEllipticCurve a) #

withQVectorQSslEllipticCurveResult :: IO (Ptr (TQVectorQSslEllipticCurve ())) -> IO [QSslEllipticCurve ()] #

qSslEllipticCurveVectorFromPtrList :: [Ptr (TQSslEllipticCurve a)] -> IO [QSslEllipticCurve a] #

type QVectorQSslEllipticCurve a = Object (CQVectorQSslEllipticCurve a) #

type TQVectorQSslEllipticCurve a = CQVectorQSslEllipticCurve a #

data CQVectorQSslEllipticCurve a #

type QSsl a = Object (CQSsl a) #

type TQSsl a = CQSsl a #

data CQSsl a #

type QHttpPart a = Object (CQHttpPart a) #

type TQHttpPart a = CQHttpPart a #

data CQHttpPart a #

qCast_QHttpPart :: Object a -> IO (QHttpPart ()) #

type QHttpPartSc a = QHttpPart (CQHttpPartSc a) #

type TQHttpPartSc a = TQHttpPart (CQHttpPartSc a) #

data CQHttpPartSc a #

qCastList_QHttpPart :: QqCastList_QHttpPart a r => a -> r #

withQHttpPartResult :: IO (Ptr (TQHttpPart a)) -> IO (QHttpPart a) #

type QNetworkProxyQuery a = Object (CQNetworkProxyQuery a) #

type TQNetworkProxyQuery a = CQNetworkProxyQuery a #

data CQNetworkProxyQuery a #

qCast_QNetworkProxyQuery :: Object a -> IO (QNetworkProxyQuery ()) #

type QNetworkProxyQuerySc a = QNetworkProxyQuery (CQNetworkProxyQuerySc a) #

type TQNetworkProxyQuerySc a = TQNetworkProxyQuery (CQNetworkProxyQuerySc a) #

data CQNetworkProxyQuerySc a #

qCastList_QNetworkProxyQuery :: QqCastList_QNetworkProxyQuery a r => a -> r #

withQNetworkProxyQueryResult :: IO (Ptr (TQNetworkProxyQuery a)) -> IO (QNetworkProxyQuery a) #

type QNetworkAddressEntry a = Object (CQNetworkAddressEntry a) #

type TQNetworkAddressEntry a = CQNetworkAddressEntry a #

data CQNetworkAddressEntry a #

qCast_QNetworkAddressEntry :: Object a -> IO (QNetworkAddressEntry ()) #

type QNetworkAddressEntrySc a = QNetworkAddressEntry (CQNetworkAddressEntrySc a) #

type TQNetworkAddressEntrySc a = TQNetworkAddressEntry (CQNetworkAddressEntrySc a) #

data CQNetworkAddressEntrySc a #

qCastList_QNetworkAddressEntry :: QqCastList_QNetworkAddressEntry a r => a -> r #

withQNetworkAddressEntryResult :: IO (Ptr (TQNetworkAddressEntry a)) -> IO (QNetworkAddressEntry a) #

withQListQNetworkAddressEntryResult :: IO (Ptr (TQListQNetworkAddressEntry ())) -> IO [QNetworkAddressEntry ()] #

qNetworkAddressEntryListFromPtrList :: [Ptr (TQNetworkAddressEntry a)] -> IO [QNetworkAddressEntry a] #

type QListQNetworkAddressEntry a = Object (CQListQNetworkAddressEntry a) #

type TQListQNetworkAddressEntry a = CQListQNetworkAddressEntry a #

data CQListQNetworkAddressEntry a #

type QHostInfo a = Object (CQHostInfo a) #

type TQHostInfo a = CQHostInfo a #

data CQHostInfo a #

qCast_QHostInfo :: Object a -> IO (QHostInfo ()) #

type QHostInfoSc a = QHostInfo (CQHostInfoSc a) #

type TQHostInfoSc a = TQHostInfo (CQHostInfoSc a) #

data CQHostInfoSc a #

qCastList_QHostInfo :: QqCastList_QHostInfo a r => a -> r #

withQHostInfoResult :: IO (Ptr (TQHostInfo a)) -> IO (QHostInfo a) #

type QNetworkCacheMetaData a = Object (CQNetworkCacheMetaData a) #

type TQNetworkCacheMetaData a = CQNetworkCacheMetaData a #

data CQNetworkCacheMetaData a #

qCast_QNetworkCacheMetaData :: Object a -> IO (QNetworkCacheMetaData ()) #

type QNetworkCacheMetaDataSc a = QNetworkCacheMetaData (CQNetworkCacheMetaDataSc a) #

type TQNetworkCacheMetaDataSc a = TQNetworkCacheMetaData (CQNetworkCacheMetaDataSc a) #

data CQNetworkCacheMetaDataSc a #

qCastList_QNetworkCacheMetaData :: QqCastList_QNetworkCacheMetaData a r => a -> r #

withQNetworkCacheMetaDataResult :: IO (Ptr (TQNetworkCacheMetaData a)) -> IO (QNetworkCacheMetaData a) #

type QNetworkCookie a = Object (CQNetworkCookie a) #

type TQNetworkCookie a = CQNetworkCookie a #

data CQNetworkCookie a #

qCast_QNetworkCookie :: Object a -> IO (QNetworkCookie ()) #

type QNetworkCookieSc a = QNetworkCookie (CQNetworkCookieSc a) #

type TQNetworkCookieSc a = TQNetworkCookie (CQNetworkCookieSc a) #

data CQNetworkCookieSc a #

qCastList_QNetworkCookie :: QqCastList_QNetworkCookie a r => a -> r #

withQNetworkCookieResult :: IO (Ptr (TQNetworkCookie a)) -> IO (QNetworkCookie a) #

withQListQNetworkCookieResult :: IO (Ptr (TQListQNetworkCookie ())) -> IO [QNetworkCookie ()] #

qNetworkCookieListFromPtrList :: [Ptr (TQNetworkCookie a)] -> IO [QNetworkCookie a] #

type QListQNetworkCookie a = Object (CQListQNetworkCookie a) #

type TQListQNetworkCookie a = CQListQNetworkCookie a #

data CQListQNetworkCookie a #

type QNetworkDatagram a = Object (CQNetworkDatagram a) #

type TQNetworkDatagram a = CQNetworkDatagram a #

data CQNetworkDatagram a #

qCast_QNetworkDatagram :: Object a -> IO (QNetworkDatagram ()) #

type QNetworkDatagramSc a = QNetworkDatagram (CQNetworkDatagramSc a) #

type TQNetworkDatagramSc a = TQNetworkDatagram (CQNetworkDatagramSc a) #

data CQNetworkDatagramSc a #

qCastList_QNetworkDatagram :: QqCastList_QNetworkDatagram a r => a -> r #

withQNetworkDatagramResult :: IO (Ptr (TQNetworkDatagram a)) -> IO (QNetworkDatagram a) #

type QDnsHostAddressRecord a = Object (CQDnsHostAddressRecord a) #

type TQDnsHostAddressRecord a = CQDnsHostAddressRecord a #

data CQDnsHostAddressRecord a #

qCast_QDnsHostAddressRecord :: Object a -> IO (QDnsHostAddressRecord ()) #

type QDnsHostAddressRecordSc a = QDnsHostAddressRecord (CQDnsHostAddressRecordSc a) #

type TQDnsHostAddressRecordSc a = TQDnsHostAddressRecord (CQDnsHostAddressRecordSc a) #

data CQDnsHostAddressRecordSc a #

qCastList_QDnsHostAddressRecord :: QqCastList_QDnsHostAddressRecord a r => a -> r #

withQDnsHostAddressRecordResult :: IO (Ptr (TQDnsHostAddressRecord a)) -> IO (QDnsHostAddressRecord a) #

withQListQDnsHostAddressRecordResult :: IO (Ptr (TQListQDnsHostAddressRecord ())) -> IO [QDnsHostAddressRecord ()] #

qDnsHostAddressRecordListFromPtrList :: [Ptr (TQDnsHostAddressRecord a)] -> IO [QDnsHostAddressRecord a] #

type QListQDnsHostAddressRecord a = Object (CQListQDnsHostAddressRecord a) #

type TQListQDnsHostAddressRecord a = CQListQDnsHostAddressRecord a #

data CQListQDnsHostAddressRecord a #

type QSslDiffieHellmanParameters a = Object (CQSslDiffieHellmanParameters a) #

type TQSslDiffieHellmanParameters a = CQSslDiffieHellmanParameters a #

data CQSslDiffieHellmanParameters a #

qCast_QSslDiffieHellmanParameters :: Object a -> IO (QSslDiffieHellmanParameters ()) #

type QSslDiffieHellmanParametersSc a = QSslDiffieHellmanParameters (CQSslDiffieHellmanParametersSc a) #

type TQSslDiffieHellmanParametersSc a = TQSslDiffieHellmanParameters (CQSslDiffieHellmanParametersSc a) #

data CQSslDiffieHellmanParametersSc a #

qCastList_QSslDiffieHellmanParameters :: QqCastList_QSslDiffieHellmanParameters a r => a -> r #

withQSslDiffieHellmanParametersResult :: IO (Ptr (TQSslDiffieHellmanParameters a)) -> IO (QSslDiffieHellmanParameters a) #

type QNetworkProxy a = Object (CQNetworkProxy a) #

type TQNetworkProxy a = CQNetworkProxy a #

data CQNetworkProxy a #

qCast_QNetworkProxy :: Object a -> IO (QNetworkProxy ()) #

type QNetworkProxySc a = QNetworkProxy (CQNetworkProxySc a) #

type TQNetworkProxySc a = TQNetworkProxy (CQNetworkProxySc a) #

data CQNetworkProxySc a #

qCastList_QNetworkProxy :: QqCastList_QNetworkProxy a r => a -> r #

withQNetworkProxyResult :: IO (Ptr (TQNetworkProxy a)) -> IO (QNetworkProxy a) #

withQListQNetworkProxyResult :: IO (Ptr (TQListQNetworkProxy ())) -> IO [QNetworkProxy ()] #

qNetworkProxyListFromPtrList :: [Ptr (TQNetworkProxy a)] -> IO [QNetworkProxy a] #

type QListQNetworkProxy a = Object (CQListQNetworkProxy a) #

type TQListQNetworkProxy a = CQListQNetworkProxy a #

data CQListQNetworkProxy a #

type QSslCertificateExtension a = Object (CQSslCertificateExtension a) #

type TQSslCertificateExtension a = CQSslCertificateExtension a #

data CQSslCertificateExtension a #

qCast_QSslCertificateExtension :: Object a -> IO (QSslCertificateExtension ()) #

type QSslCertificateExtensionSc a = QSslCertificateExtension (CQSslCertificateExtensionSc a) #

type TQSslCertificateExtensionSc a = TQSslCertificateExtension (CQSslCertificateExtensionSc a) #

data CQSslCertificateExtensionSc a #

qCastList_QSslCertificateExtension :: QqCastList_QSslCertificateExtension a r => a -> r #

withQSslCertificateExtensionResult :: IO (Ptr (TQSslCertificateExtension a)) -> IO (QSslCertificateExtension a) #

withQListQSslCertificateExtensionResult :: IO (Ptr (TQListQSslCertificateExtension ())) -> IO [QSslCertificateExtension ()] #

qSslCertificateExtensionListFromPtrList :: [Ptr (TQSslCertificateExtension a)] -> IO [QSslCertificateExtension a] #

type QListQSslCertificateExtension a = Object (CQListQSslCertificateExtension a) #

type TQListQSslCertificateExtension a = CQListQSslCertificateExtension a #

data CQListQSslCertificateExtension a #

type QNetworkReply a = QIODevice (CQNetworkReply a) #

type TQNetworkReply a = TQIODevice (CQNetworkReply a) #

data CQNetworkReply a #

qCast_QNetworkReply :: Object a -> IO (QNetworkReply ()) #

type QNetworkReplySc a = QNetworkReply (CQNetworkReplySc a) #

type TQNetworkReplySc a = TQNetworkReply (CQNetworkReplySc a) #

data CQNetworkReplySc a #

qCastList_QNetworkReply :: QqCastList_QNetworkReply a r => a -> r #

withQNetworkReplyResult :: IO (Ptr (TQNetworkReply a)) -> IO (QNetworkReply a) #

qNetworkReplyFromPtr :: Ptr (TQNetworkReply a) -> IO (QNetworkReply a) #

qNetworkReplyAddFinalizer :: QNetworkReply a -> IO () #

type QLocalSocket a = QIODevice (CQLocalSocket a) #

type TQLocalSocket a = TQIODevice (CQLocalSocket a) #

data CQLocalSocket a #

qCast_QLocalSocket :: Object a -> IO (QLocalSocket ()) #

type QLocalSocketSc a = QLocalSocket (CQLocalSocketSc a) #

type TQLocalSocketSc a = TQLocalSocket (CQLocalSocketSc a) #

data CQLocalSocketSc a #

qCastList_QLocalSocket :: QqCastList_QLocalSocket a r => a -> r #

withQLocalSocketResult :: IO (Ptr (TQLocalSocket a)) -> IO (QLocalSocket a) #

qLocalSocketFromPtr :: Ptr (TQLocalSocket a) -> IO (QLocalSocket a) #

qLocalSocketAddFinalizer :: QLocalSocket a -> IO () #

type QTcpServer a = QObject (CQTcpServer a) #

type TQTcpServer a = TQObject (CQTcpServer a) #

data CQTcpServer a #

qCast_QTcpServer :: Object a -> IO (QTcpServer ()) #

type QTcpServerSc a = QTcpServer (CQTcpServerSc a) #

type TQTcpServerSc a = TQTcpServer (CQTcpServerSc a) #

data CQTcpServerSc a #

qCastList_QTcpServer :: QqCastList_QTcpServer a r => a -> r #

withQTcpServerResult :: IO (Ptr (TQTcpServer a)) -> IO (QTcpServer a) #

qTcpServerFromPtr :: Ptr (TQTcpServer a) -> IO (QTcpServer a) #

qTcpServerAddFinalizer :: QTcpServer a -> IO () #

type QHttpMultiPart a = QObject (CQHttpMultiPart a) #

type TQHttpMultiPart a = TQObject (CQHttpMultiPart a) #

data CQHttpMultiPart a #

qCast_QHttpMultiPart :: Object a -> IO (QHttpMultiPart ()) #

type QHttpMultiPartSc a = QHttpMultiPart (CQHttpMultiPartSc a) #

type TQHttpMultiPartSc a = TQHttpMultiPart (CQHttpMultiPartSc a) #

data CQHttpMultiPartSc a #

qCastList_QHttpMultiPart :: QqCastList_QHttpMultiPart a r => a -> r #

withQHttpMultiPartResult :: IO (Ptr (TQHttpMultiPart a)) -> IO (QHttpMultiPart a) #

qHttpMultiPartFromPtr :: Ptr (TQHttpMultiPart a) -> IO (QHttpMultiPart a) #

qHttpMultiPartAddFinalizer :: QHttpMultiPart a -> IO () #

type QNetworkSession a = QObject (CQNetworkSession a) #

type TQNetworkSession a = TQObject (CQNetworkSession a) #

data CQNetworkSession a #

qCast_QNetworkSession :: Object a -> IO (QNetworkSession ()) #

type QNetworkSessionSc a = QNetworkSession (CQNetworkSessionSc a) #

type TQNetworkSessionSc a = TQNetworkSession (CQNetworkSessionSc a) #

data CQNetworkSessionSc a #

qCastList_QNetworkSession :: QqCastList_QNetworkSession a r => a -> r #

withQNetworkSessionResult :: IO (Ptr (TQNetworkSession a)) -> IO (QNetworkSession a) #

qNetworkSessionFromPtr :: Ptr (TQNetworkSession a) -> IO (QNetworkSession a) #

qNetworkSessionAddFinalizer :: QNetworkSession a -> IO () #

type QDnsLookup a = QObject (CQDnsLookup a) #

type TQDnsLookup a = TQObject (CQDnsLookup a) #

data CQDnsLookup a #

qCast_QDnsLookup :: Object a -> IO (QDnsLookup ()) #

type QDnsLookupSc a = QDnsLookup (CQDnsLookupSc a) #

type TQDnsLookupSc a = TQDnsLookup (CQDnsLookupSc a) #

data CQDnsLookupSc a #

qCastList_QDnsLookup :: QqCastList_QDnsLookup a r => a -> r #

withQDnsLookupResult :: IO (Ptr (TQDnsLookup a)) -> IO (QDnsLookup a) #

qDnsLookupFromPtr :: Ptr (TQDnsLookup a) -> IO (QDnsLookup a) #

qDnsLookupAddFinalizer :: QDnsLookup a -> IO () #

type QNetworkCookieJar a = QObject (CQNetworkCookieJar a) #

type TQNetworkCookieJar a = TQObject (CQNetworkCookieJar a) #

data CQNetworkCookieJar a #

qCast_QNetworkCookieJar :: Object a -> IO (QNetworkCookieJar ()) #

type QNetworkCookieJarSc a = QNetworkCookieJar (CQNetworkCookieJarSc a) #

type TQNetworkCookieJarSc a = TQNetworkCookieJar (CQNetworkCookieJarSc a) #

data CQNetworkCookieJarSc a #

qCastList_QNetworkCookieJar :: QqCastList_QNetworkCookieJar a r => a -> r #

withQNetworkCookieJarResult :: IO (Ptr (TQNetworkCookieJar a)) -> IO (QNetworkCookieJar a) #

qNetworkCookieJarFromPtr :: Ptr (TQNetworkCookieJar a) -> IO (QNetworkCookieJar a) #

qNetworkCookieJarAddFinalizer :: QNetworkCookieJar a -> IO () #

type QLocalServer a = QObject (CQLocalServer a) #

type TQLocalServer a = TQObject (CQLocalServer a) #

data CQLocalServer a #

qCast_QLocalServer :: Object a -> IO (QLocalServer ()) #

type QLocalServerSc a = QLocalServer (CQLocalServerSc a) #

type TQLocalServerSc a = TQLocalServer (CQLocalServerSc a) #

data CQLocalServerSc a #

qCastList_QLocalServer :: QqCastList_QLocalServer a r => a -> r #

withQLocalServerResult :: IO (Ptr (TQLocalServer a)) -> IO (QLocalServer a) #

qLocalServerFromPtr :: Ptr (TQLocalServer a) -> IO (QLocalServer a) #

qLocalServerAddFinalizer :: QLocalServer a -> IO () #

type QNetworkConfigurationManager a = QObject (CQNetworkConfigurationManager a) #

type TQNetworkConfigurationManager a = TQObject (CQNetworkConfigurationManager a) #

data CQNetworkConfigurationManager a #

qCast_QNetworkConfigurationManager :: Object a -> IO (QNetworkConfigurationManager ()) #

type QNetworkConfigurationManagerSc a = QNetworkConfigurationManager (CQNetworkConfigurationManagerSc a) #

type TQNetworkConfigurationManagerSc a = TQNetworkConfigurationManager (CQNetworkConfigurationManagerSc a) #

data CQNetworkConfigurationManagerSc a #

qCastList_QNetworkConfigurationManager :: QqCastList_QNetworkConfigurationManager a r => a -> r #

withQNetworkConfigurationManagerResult :: IO (Ptr (TQNetworkConfigurationManager a)) -> IO (QNetworkConfigurationManager a) #

qNetworkConfigurationManagerFromPtr :: Ptr (TQNetworkConfigurationManager a) -> IO (QNetworkConfigurationManager a) #

qNetworkConfigurationManagerAddFinalizer :: QNetworkConfigurationManager a -> IO () #

type QNetworkAccessManager a = QObject (CQNetworkAccessManager a) #

type TQNetworkAccessManager a = TQObject (CQNetworkAccessManager a) #

data CQNetworkAccessManager a #

qCast_QNetworkAccessManager :: Object a -> IO (QNetworkAccessManager ()) #

type QNetworkAccessManagerSc a = QNetworkAccessManager (CQNetworkAccessManagerSc a) #

type TQNetworkAccessManagerSc a = TQNetworkAccessManager (CQNetworkAccessManagerSc a) #

data CQNetworkAccessManagerSc a #

qCastList_QNetworkAccessManager :: QqCastList_QNetworkAccessManager a r => a -> r #

withQNetworkAccessManagerResult :: IO (Ptr (TQNetworkAccessManager a)) -> IO (QNetworkAccessManager a) #

qNetworkAccessManagerFromPtr :: Ptr (TQNetworkAccessManager a) -> IO (QNetworkAccessManager a) #

qNetworkAccessManagerAddFinalizer :: QNetworkAccessManager a -> IO () #

type QNetworkDiskCache a = QAbstractNetworkCache (CQNetworkDiskCache a) #

type TQNetworkDiskCache a = TQAbstractNetworkCache (CQNetworkDiskCache a) #

data CQNetworkDiskCache a #

qCast_QNetworkDiskCache :: Object a -> IO (QNetworkDiskCache ()) #

type QNetworkDiskCacheSc a = QNetworkDiskCache (CQNetworkDiskCacheSc a) #

type TQNetworkDiskCacheSc a = TQNetworkDiskCache (CQNetworkDiskCacheSc a) #

data CQNetworkDiskCacheSc a #

qCastList_QNetworkDiskCache :: QqCastList_QNetworkDiskCache a r => a -> r #

withQNetworkDiskCacheResult :: IO (Ptr (TQNetworkDiskCache a)) -> IO (QNetworkDiskCache a) #

qNetworkDiskCacheFromPtr :: Ptr (TQNetworkDiskCache a) -> IO (QNetworkDiskCache a) #

qNetworkDiskCacheAddFinalizer :: QNetworkDiskCache a -> IO () #

type QUdpSocket a = QAbstractSocket (CQUdpSocket a) #

type TQUdpSocket a = TQAbstractSocket (CQUdpSocket a) #

data CQUdpSocket a #

qCast_QUdpSocket :: Object a -> IO (QUdpSocket ()) #

type QUdpSocketSc a = QUdpSocket (CQUdpSocketSc a) #

type TQUdpSocketSc a = TQUdpSocket (CQUdpSocketSc a) #

data CQUdpSocketSc a #

qCastList_QUdpSocket :: QqCastList_QUdpSocket a r => a -> r #

withQUdpSocketResult :: IO (Ptr (TQUdpSocket a)) -> IO (QUdpSocket a) #

qUdpSocketFromPtr :: Ptr (TQUdpSocket a) -> IO (QUdpSocket a) #

qUdpSocketAddFinalizer :: QUdpSocket a -> IO () #

type QTcpSocket a = QAbstractSocket (CQTcpSocket a) #

type TQTcpSocket a = TQAbstractSocket (CQTcpSocket a) #

data CQTcpSocket a #

qCast_QTcpSocket :: Object a -> IO (QTcpSocket ()) #

type QTcpSocketSc a = QTcpSocket (CQTcpSocketSc a) #

type TQTcpSocketSc a = TQTcpSocket (CQTcpSocketSc a) #

data CQTcpSocketSc a #

qCastList_QTcpSocket :: QqCastList_QTcpSocket a r => a -> r #

withQTcpSocketResult :: IO (Ptr (TQTcpSocket a)) -> IO (QTcpSocket a) #

qTcpSocketFromPtr :: Ptr (TQTcpSocket a) -> IO (QTcpSocket a) #

qTcpSocketAddFinalizer :: QTcpSocket a -> IO () #

qListFromQListQNetworkConfigurationPtr :: Ptr (TQListQNetworkConfiguration ()) -> IO [QNetworkConfiguration t0] #

qListFromQListQNetworkCookiePtr :: Ptr (TQListQNetworkCookie ()) -> IO [QNetworkCookie t0] #

qListFromQListQNetworkProxyPtr :: Ptr (TQListQNetworkProxy ()) -> IO [QNetworkProxy t0] #

qListFromQListQSslErrorPtr :: Ptr (TQListQSslError ()) -> IO [QSslError t0] #

withQListQNetworkCookieHResult :: [QNetworkCookie t0] -> IO (Ptr (TQListQNetworkCookie ())) #

withQListQNetworkProxyHResult :: [QNetworkProxy t0] -> IO (Ptr (TQListQNetworkProxy ())) #

withQListQSslErrorHResult :: [QSslError t0] -> IO (Ptr (TQListQSslError ())) #

withQListQNetworkConfigurationHResult :: [QNetworkConfiguration t0] -> IO (Ptr (TQListQNetworkConfiguration ())) #

withQPairQHostAddressInt :: (QHostAddress t1, Int) -> (Ptr (TQHostAddress t1) -> CInt -> IO a) -> IO a #

withQPairQHostAddressIntResult :: IO (Ptr (TQPairQHostAddressInt a)) -> IO (QHostAddress (), Int) #

type QPairQHostAddressInt a = Object (CQPairQHostAddressInt a) #

type TQPairQHostAddressInt a = CQPairQHostAddressInt a #

data CQPairQHostAddressInt a #

type QMultiMapAlternativeNameEntryTypeQString a = Object (CQMultiMapAlternativeNameEntryTypeQString a) #

type TQMultiMapAlternativeNameEntryTypeQString a = CQMultiMapAlternativeNameEntryTypeQString a #

data CQMultiMapAlternativeNameEntryTypeQString a #

type QHashQNetworkRequest_AttributeQVariant a = Object (CQHashQNetworkRequest_AttributeQVariant a) #

type TQHashQNetworkRequest_AttributeQVariant a = CQHashQNetworkRequest_AttributeQVariant a #

data CQHashQNetworkRequest_AttributeQVariant a #

type QNetworkRequest_Attribute = QEnum (CQNetworkRequest_Attribute Int) #

ieQNetworkRequest_Attribute :: Int -> QNetworkRequest_Attribute #

type AlternativeNameEntryType = QEnum (CAlternativeNameEntryType Int) #

ieAlternativeNameEntryType :: Int -> AlternativeNameEntryType #

type QConstSockaddrPtr a = Object (CQConstSockaddrPtr a) #

type TQConstSockaddrPtr a = CQConstSockaddrPtr a #

data CQConstSockaddrPtr a #

withQConstSockaddrPtrResult :: IO (Ptr (TQConstSockaddrPtr a)) -> IO (QConstSockaddrPtr a) #

type QListQSslCertificatePtr a = Object (CQListQSslCertificatePtr a) #

type TQListQSslCertificatePtr a = CQListQSslCertificatePtr a #

data CQListQSslCertificatePtr a #

withQListQSslCertificatePtrResult :: IO (Ptr (TQListQSslCertificatePtr a)) -> IO (QListQSslCertificatePtr a) #

withQMultiMapAlternativeNameEntryTypeQString :: [(AlternativeNameEntryType, String)] -> (CInt -> Ptr CLong -> Ptr CWString -> IO a) -> IO a #

qtc_QMultiMapAlternativeNameEntryTypeQString :: CInt -> Ptr CLong -> Ptr CWString -> IO (Ptr (TQMultiMapAlternativeNameEntryTypeQString a)) #

withQMultiMapAlternativeNameEntryTypeQStringListResult :: IO (Ptr (TQMultiMapAlternativeNameEntryTypeQString a)) -> IO [(AlternativeNameEntryType, String)] #

withQHashQNetworkRequest_AttributeQVariant :: [(QNetworkRequest_Attribute, QVariant t1)] -> (CInt -> Ptr CLong -> Ptr (Ptr (TQVariant t1)) -> IO a) -> IO a #

qtc_QHashQNetworkRequest_AttributeQVariant :: CInt -> Ptr CLong -> Ptr (Ptr (TQVariant ())) -> IO (Ptr (TQHashQNetworkRequest_AttributeQVariant a)) #

withQHashQNetworkRequest_AttributeQVariantListResult :: IO (Ptr (TQHashQNetworkRequest_AttributeQVariant a)) -> IO [(QNetworkRequest_Attribute, QVariant ())] #