{- | Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte License : LGPL-2.1 Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) A type for representing D-Bus messages that can be sent or received on a 'GI.Gio.Objects.DBusConnection.DBusConnection'. /Since: 2.26/ -} #define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ && !defined(__HADDOCK_VERSION__)) module GI.Gio.Objects.DBusMessage ( -- * Exported types DBusMessage(..) , IsDBusMessage , toDBusMessage , noDBusMessage , -- * Methods -- ** bytesNeeded #method:bytesNeeded# dBusMessageBytesNeeded , -- ** copy #method:copy# #if ENABLE_OVERLOADING DBusMessageCopyMethodInfo , #endif dBusMessageCopy , -- ** getArg0 #method:getArg0# #if ENABLE_OVERLOADING DBusMessageGetArg0MethodInfo , #endif dBusMessageGetArg0 , -- ** getBody #method:getBody# #if ENABLE_OVERLOADING DBusMessageGetBodyMethodInfo , #endif dBusMessageGetBody , -- ** getByteOrder #method:getByteOrder# #if ENABLE_OVERLOADING DBusMessageGetByteOrderMethodInfo , #endif dBusMessageGetByteOrder , -- ** getDestination #method:getDestination# #if ENABLE_OVERLOADING DBusMessageGetDestinationMethodInfo , #endif dBusMessageGetDestination , -- ** getErrorName #method:getErrorName# #if ENABLE_OVERLOADING DBusMessageGetErrorNameMethodInfo , #endif dBusMessageGetErrorName , -- ** getFlags #method:getFlags# #if ENABLE_OVERLOADING DBusMessageGetFlagsMethodInfo , #endif dBusMessageGetFlags , -- ** getHeader #method:getHeader# #if ENABLE_OVERLOADING DBusMessageGetHeaderMethodInfo , #endif dBusMessageGetHeader , -- ** getHeaderFields #method:getHeaderFields# #if ENABLE_OVERLOADING DBusMessageGetHeaderFieldsMethodInfo , #endif dBusMessageGetHeaderFields , -- ** getInterface #method:getInterface# #if ENABLE_OVERLOADING DBusMessageGetInterfaceMethodInfo , #endif dBusMessageGetInterface , -- ** getLocked #method:getLocked# #if ENABLE_OVERLOADING DBusMessageGetLockedMethodInfo , #endif dBusMessageGetLocked , -- ** getMember #method:getMember# #if ENABLE_OVERLOADING DBusMessageGetMemberMethodInfo , #endif dBusMessageGetMember , -- ** getMessageType #method:getMessageType# #if ENABLE_OVERLOADING DBusMessageGetMessageTypeMethodInfo , #endif dBusMessageGetMessageType , -- ** getNumUnixFds #method:getNumUnixFds# #if ENABLE_OVERLOADING DBusMessageGetNumUnixFdsMethodInfo , #endif dBusMessageGetNumUnixFds , -- ** getPath #method:getPath# #if ENABLE_OVERLOADING DBusMessageGetPathMethodInfo , #endif dBusMessageGetPath , -- ** getReplySerial #method:getReplySerial# #if ENABLE_OVERLOADING DBusMessageGetReplySerialMethodInfo , #endif dBusMessageGetReplySerial , -- ** getSender #method:getSender# #if ENABLE_OVERLOADING DBusMessageGetSenderMethodInfo , #endif dBusMessageGetSender , -- ** getSerial #method:getSerial# #if ENABLE_OVERLOADING DBusMessageGetSerialMethodInfo , #endif dBusMessageGetSerial , -- ** getSignature #method:getSignature# #if ENABLE_OVERLOADING DBusMessageGetSignatureMethodInfo , #endif dBusMessageGetSignature , -- ** getUnixFdList #method:getUnixFdList# #if ENABLE_OVERLOADING DBusMessageGetUnixFdListMethodInfo , #endif dBusMessageGetUnixFdList , -- ** lock #method:lock# #if ENABLE_OVERLOADING DBusMessageLockMethodInfo , #endif dBusMessageLock , -- ** new #method:new# dBusMessageNew , -- ** newFromBlob #method:newFromBlob# dBusMessageNewFromBlob , -- ** newMethodCall #method:newMethodCall# dBusMessageNewMethodCall , -- ** newMethodErrorLiteral #method:newMethodErrorLiteral# #if ENABLE_OVERLOADING DBusMessageNewMethodErrorLiteralMethodInfo, #endif dBusMessageNewMethodErrorLiteral , -- ** newMethodReply #method:newMethodReply# #if ENABLE_OVERLOADING DBusMessageNewMethodReplyMethodInfo , #endif dBusMessageNewMethodReply , -- ** newSignal #method:newSignal# dBusMessageNewSignal , -- ** print #method:print# #if ENABLE_OVERLOADING DBusMessagePrintMethodInfo , #endif dBusMessagePrint , -- ** setBody #method:setBody# #if ENABLE_OVERLOADING DBusMessageSetBodyMethodInfo , #endif dBusMessageSetBody , -- ** setByteOrder #method:setByteOrder# #if ENABLE_OVERLOADING DBusMessageSetByteOrderMethodInfo , #endif dBusMessageSetByteOrder , -- ** setDestination #method:setDestination# #if ENABLE_OVERLOADING DBusMessageSetDestinationMethodInfo , #endif dBusMessageSetDestination , -- ** setErrorName #method:setErrorName# #if ENABLE_OVERLOADING DBusMessageSetErrorNameMethodInfo , #endif dBusMessageSetErrorName , -- ** setFlags #method:setFlags# #if ENABLE_OVERLOADING DBusMessageSetFlagsMethodInfo , #endif dBusMessageSetFlags , -- ** setHeader #method:setHeader# #if ENABLE_OVERLOADING DBusMessageSetHeaderMethodInfo , #endif dBusMessageSetHeader , -- ** setInterface #method:setInterface# #if ENABLE_OVERLOADING DBusMessageSetInterfaceMethodInfo , #endif dBusMessageSetInterface , -- ** setMember #method:setMember# #if ENABLE_OVERLOADING DBusMessageSetMemberMethodInfo , #endif dBusMessageSetMember , -- ** setMessageType #method:setMessageType# #if ENABLE_OVERLOADING DBusMessageSetMessageTypeMethodInfo , #endif dBusMessageSetMessageType , -- ** setNumUnixFds #method:setNumUnixFds# #if ENABLE_OVERLOADING DBusMessageSetNumUnixFdsMethodInfo , #endif dBusMessageSetNumUnixFds , -- ** setPath #method:setPath# #if ENABLE_OVERLOADING DBusMessageSetPathMethodInfo , #endif dBusMessageSetPath , -- ** setReplySerial #method:setReplySerial# #if ENABLE_OVERLOADING DBusMessageSetReplySerialMethodInfo , #endif dBusMessageSetReplySerial , -- ** setSender #method:setSender# #if ENABLE_OVERLOADING DBusMessageSetSenderMethodInfo , #endif dBusMessageSetSender , -- ** setSerial #method:setSerial# #if ENABLE_OVERLOADING DBusMessageSetSerialMethodInfo , #endif dBusMessageSetSerial , -- ** setSignature #method:setSignature# #if ENABLE_OVERLOADING DBusMessageSetSignatureMethodInfo , #endif dBusMessageSetSignature , -- ** setUnixFdList #method:setUnixFdList# #if ENABLE_OVERLOADING DBusMessageSetUnixFdListMethodInfo , #endif dBusMessageSetUnixFdList , -- ** toBlob #method:toBlob# #if ENABLE_OVERLOADING DBusMessageToBlobMethodInfo , #endif dBusMessageToBlob , -- ** toGerror #method:toGerror# #if ENABLE_OVERLOADING DBusMessageToGerrorMethodInfo , #endif dBusMessageToGerror , -- * Properties -- ** locked #attr:locked# {- | /No description available in the introspection data./ -} #if ENABLE_OVERLOADING DBusMessageLockedPropertyInfo , #endif #if ENABLE_OVERLOADING dBusMessageLocked , #endif getDBusMessageLocked , ) where import Data.GI.Base.ShortPrelude import qualified Data.GI.Base.ShortPrelude as SP import qualified Data.GI.Base.Overloading as O import qualified Prelude as P import qualified Data.GI.Base.Attributes as GI.Attributes import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr import qualified Data.GI.Base.GClosure as B.GClosure import qualified Data.GI.Base.GError as B.GError import qualified Data.GI.Base.GVariant as B.GVariant import qualified Data.GI.Base.GValue as B.GValue import qualified Data.GI.Base.GParamSpec as B.GParamSpec import qualified Data.GI.Base.CallStack as B.CallStack import qualified Data.GI.Base.Properties as B.Properties import qualified Data.Text as T import qualified Data.ByteString.Char8 as B import qualified Data.Map as Map import qualified Foreign.Ptr as FP import qualified GHC.OverloadedLabels as OL import qualified GI.GObject.Objects.Object as GObject.Object import {-# SOURCE #-} qualified GI.Gio.Enums as Gio.Enums import {-# SOURCE #-} qualified GI.Gio.Flags as Gio.Flags import {-# SOURCE #-} qualified GI.Gio.Objects.UnixFDList as Gio.UnixFDList -- | Memory-managed wrapper type. newtype DBusMessage = DBusMessage (ManagedPtr DBusMessage) foreign import ccall "g_dbus_message_get_type" c_g_dbus_message_get_type :: IO GType instance GObject DBusMessage where gobjectType = c_g_dbus_message_get_type -- | Type class for types which can be safely cast to `DBusMessage`, for instance with `toDBusMessage`. class (GObject o, O.IsDescendantOf DBusMessage o) => IsDBusMessage o instance (GObject o, O.IsDescendantOf DBusMessage o) => IsDBusMessage o instance O.HasParentTypes DBusMessage type instance O.ParentTypes DBusMessage = '[GObject.Object.Object] -- | Cast to `DBusMessage`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. toDBusMessage :: (MonadIO m, IsDBusMessage o) => o -> m DBusMessage toDBusMessage = liftIO . unsafeCastTo DBusMessage -- | A convenience alias for `Nothing` :: `Maybe` `DBusMessage`. noDBusMessage :: Maybe DBusMessage noDBusMessage = Nothing #if ENABLE_OVERLOADING type family ResolveDBusMessageMethod (t :: Symbol) (o :: *) :: * where ResolveDBusMessageMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo ResolveDBusMessageMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo ResolveDBusMessageMethod "copy" o = DBusMessageCopyMethodInfo ResolveDBusMessageMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo ResolveDBusMessageMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo ResolveDBusMessageMethod "getv" o = GObject.Object.ObjectGetvMethodInfo ResolveDBusMessageMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo ResolveDBusMessageMethod "lock" o = DBusMessageLockMethodInfo ResolveDBusMessageMethod "newMethodErrorLiteral" o = DBusMessageNewMethodErrorLiteralMethodInfo ResolveDBusMessageMethod "newMethodReply" o = DBusMessageNewMethodReplyMethodInfo ResolveDBusMessageMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo ResolveDBusMessageMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo ResolveDBusMessageMethod "print" o = DBusMessagePrintMethodInfo ResolveDBusMessageMethod "ref" o = GObject.Object.ObjectRefMethodInfo ResolveDBusMessageMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo ResolveDBusMessageMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo ResolveDBusMessageMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo ResolveDBusMessageMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo ResolveDBusMessageMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo ResolveDBusMessageMethod "toBlob" o = DBusMessageToBlobMethodInfo ResolveDBusMessageMethod "toGerror" o = DBusMessageToGerrorMethodInfo ResolveDBusMessageMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo ResolveDBusMessageMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo ResolveDBusMessageMethod "getArg0" o = DBusMessageGetArg0MethodInfo ResolveDBusMessageMethod "getBody" o = DBusMessageGetBodyMethodInfo ResolveDBusMessageMethod "getByteOrder" o = DBusMessageGetByteOrderMethodInfo ResolveDBusMessageMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo ResolveDBusMessageMethod "getDestination" o = DBusMessageGetDestinationMethodInfo ResolveDBusMessageMethod "getErrorName" o = DBusMessageGetErrorNameMethodInfo ResolveDBusMessageMethod "getFlags" o = DBusMessageGetFlagsMethodInfo ResolveDBusMessageMethod "getHeader" o = DBusMessageGetHeaderMethodInfo ResolveDBusMessageMethod "getHeaderFields" o = DBusMessageGetHeaderFieldsMethodInfo ResolveDBusMessageMethod "getInterface" o = DBusMessageGetInterfaceMethodInfo ResolveDBusMessageMethod "getLocked" o = DBusMessageGetLockedMethodInfo ResolveDBusMessageMethod "getMember" o = DBusMessageGetMemberMethodInfo ResolveDBusMessageMethod "getMessageType" o = DBusMessageGetMessageTypeMethodInfo ResolveDBusMessageMethod "getNumUnixFds" o = DBusMessageGetNumUnixFdsMethodInfo ResolveDBusMessageMethod "getPath" o = DBusMessageGetPathMethodInfo ResolveDBusMessageMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo ResolveDBusMessageMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo ResolveDBusMessageMethod "getReplySerial" o = DBusMessageGetReplySerialMethodInfo ResolveDBusMessageMethod "getSender" o = DBusMessageGetSenderMethodInfo ResolveDBusMessageMethod "getSerial" o = DBusMessageGetSerialMethodInfo ResolveDBusMessageMethod "getSignature" o = DBusMessageGetSignatureMethodInfo ResolveDBusMessageMethod "getUnixFdList" o = DBusMessageGetUnixFdListMethodInfo ResolveDBusMessageMethod "setBody" o = DBusMessageSetBodyMethodInfo ResolveDBusMessageMethod "setByteOrder" o = DBusMessageSetByteOrderMethodInfo ResolveDBusMessageMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo ResolveDBusMessageMethod "setDestination" o = DBusMessageSetDestinationMethodInfo ResolveDBusMessageMethod "setErrorName" o = DBusMessageSetErrorNameMethodInfo ResolveDBusMessageMethod "setFlags" o = DBusMessageSetFlagsMethodInfo ResolveDBusMessageMethod "setHeader" o = DBusMessageSetHeaderMethodInfo ResolveDBusMessageMethod "setInterface" o = DBusMessageSetInterfaceMethodInfo ResolveDBusMessageMethod "setMember" o = DBusMessageSetMemberMethodInfo ResolveDBusMessageMethod "setMessageType" o = DBusMessageSetMessageTypeMethodInfo ResolveDBusMessageMethod "setNumUnixFds" o = DBusMessageSetNumUnixFdsMethodInfo ResolveDBusMessageMethod "setPath" o = DBusMessageSetPathMethodInfo ResolveDBusMessageMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo ResolveDBusMessageMethod "setReplySerial" o = DBusMessageSetReplySerialMethodInfo ResolveDBusMessageMethod "setSender" o = DBusMessageSetSenderMethodInfo ResolveDBusMessageMethod "setSerial" o = DBusMessageSetSerialMethodInfo ResolveDBusMessageMethod "setSignature" o = DBusMessageSetSignatureMethodInfo ResolveDBusMessageMethod "setUnixFdList" o = DBusMessageSetUnixFdListMethodInfo ResolveDBusMessageMethod l o = O.MethodResolutionFailed l o instance (info ~ ResolveDBusMessageMethod t DBusMessage, O.MethodInfo info DBusMessage p) => OL.IsLabel t (DBusMessage -> p) where #if MIN_VERSION_base(4,10,0) fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) #else fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) #endif #endif -- VVV Prop "locked" -- Type: TBasicType TBoolean -- Flags: [PropertyReadable] -- Nullable: (Just False,Nothing) {- | Get the value of the “@locked@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' dBusMessage #locked @ -} getDBusMessageLocked :: (MonadIO m, IsDBusMessage o) => o -> m Bool getDBusMessageLocked obj = liftIO $ B.Properties.getObjectPropertyBool obj "locked" #if ENABLE_OVERLOADING data DBusMessageLockedPropertyInfo instance AttrInfo DBusMessageLockedPropertyInfo where type AttrAllowedOps DBusMessageLockedPropertyInfo = '[ 'AttrGet] type AttrSetTypeConstraint DBusMessageLockedPropertyInfo = (~) () type AttrBaseTypeConstraint DBusMessageLockedPropertyInfo = IsDBusMessage type AttrGetType DBusMessageLockedPropertyInfo = Bool type AttrLabel DBusMessageLockedPropertyInfo = "locked" type AttrOrigin DBusMessageLockedPropertyInfo = DBusMessage attrGet _ = getDBusMessageLocked attrSet _ = undefined attrConstruct _ = undefined attrClear _ = undefined #endif #if ENABLE_OVERLOADING instance O.HasAttributeList DBusMessage type instance O.AttributeList DBusMessage = DBusMessageAttributeList type DBusMessageAttributeList = ('[ '("locked", DBusMessageLockedPropertyInfo)] :: [(Symbol, *)]) #endif #if ENABLE_OVERLOADING dBusMessageLocked :: AttrLabelProxy "locked" dBusMessageLocked = AttrLabelProxy #endif #if ENABLE_OVERLOADING type instance O.SignalList DBusMessage = DBusMessageSignalList type DBusMessageSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) #endif -- method DBusMessage::new -- method type : Constructor -- Args : [] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gio", name = "DBusMessage"})) -- throws : False -- Skip return : False foreign import ccall "g_dbus_message_new" g_dbus_message_new :: IO (Ptr DBusMessage) {- | Creates a new empty 'GI.Gio.Objects.DBusMessage.DBusMessage'. /Since: 2.26/ -} dBusMessageNew :: (B.CallStack.HasCallStack, MonadIO m) => m DBusMessage {- ^ __Returns:__ A 'GI.Gio.Objects.DBusMessage.DBusMessage'. Free with 'GI.GObject.Objects.Object.objectUnref'. -} dBusMessageNew = liftIO $ do result <- g_dbus_message_new checkUnexpectedReturnNULL "dBusMessageNew" result result' <- (wrapObject DBusMessage) result return result' #if ENABLE_OVERLOADING #endif -- method DBusMessage::new_from_blob -- method type : Constructor -- Args : [Arg {argCName = "blob", argType = TCArray False (-1) 1 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A blob representing a binary D-Bus message.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "blob_len", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The length of @blob.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "capabilities", argType = TInterface (Name {namespace = "Gio", name = "DBusCapabilityFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusCapabilityFlags describing what protocol features are supported.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [Arg {argCName = "blob_len", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The length of @blob.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- returnType : Just (TInterface (Name {namespace = "Gio", name = "DBusMessage"})) -- throws : True -- Skip return : False foreign import ccall "g_dbus_message_new_from_blob" g_dbus_message_new_from_blob :: Ptr Word8 -> -- blob : TCArray False (-1) 1 (TBasicType TUInt8) Word64 -> -- blob_len : TBasicType TUInt64 CUInt -> -- capabilities : TInterface (Name {namespace = "Gio", name = "DBusCapabilityFlags"}) Ptr (Ptr GError) -> -- error IO (Ptr DBusMessage) {- | Creates a new 'GI.Gio.Objects.DBusMessage.DBusMessage' from the data stored at /@blob@/. The byte order that the message was in can be retrieved using 'GI.Gio.Objects.DBusMessage.dBusMessageGetByteOrder'. If the /@blob@/ cannot be parsed, contains invalid fields, or contains invalid headers, 'GI.Gio.Enums.IOErrorEnumInvalidArgument' will be returned. /Since: 2.26/ -} dBusMessageNewFromBlob :: (B.CallStack.HasCallStack, MonadIO m) => ByteString {- ^ /@blob@/: A blob representing a binary D-Bus message. -} -> [Gio.Flags.DBusCapabilityFlags] {- ^ /@capabilities@/: A 'GI.Gio.Flags.DBusCapabilityFlags' describing what protocol features are supported. -} -> m DBusMessage {- ^ __Returns:__ A new 'GI.Gio.Objects.DBusMessage.DBusMessage' or 'Nothing' if /@error@/ is set. Free with 'GI.GObject.Objects.Object.objectUnref'. /(Can throw 'Data.GI.Base.GError.GError')/ -} dBusMessageNewFromBlob blob capabilities = liftIO $ do let blobLen = fromIntegral $ B.length blob blob' <- packByteString blob let capabilities' = gflagsToWord capabilities onException (do result <- propagateGError $ g_dbus_message_new_from_blob blob' blobLen capabilities' checkUnexpectedReturnNULL "dBusMessageNewFromBlob" result result' <- (wrapObject DBusMessage) result freeMem blob' return result' ) (do freeMem blob' ) #if ENABLE_OVERLOADING #endif -- method DBusMessage::new_method_call -- method type : Constructor -- Args : [Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "A valid D-Bus name or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A valid object path.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "interface_", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "A valid D-Bus interface name or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "method", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A valid method name.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gio", name = "DBusMessage"})) -- throws : False -- Skip return : False foreign import ccall "g_dbus_message_new_method_call" g_dbus_message_new_method_call :: CString -> -- name : TBasicType TUTF8 CString -> -- path : TBasicType TUTF8 CString -> -- interface_ : TBasicType TUTF8 CString -> -- method : TBasicType TUTF8 IO (Ptr DBusMessage) {- | Creates a new 'GI.Gio.Objects.DBusMessage.DBusMessage' for a method call. /Since: 2.26/ -} dBusMessageNewMethodCall :: (B.CallStack.HasCallStack, MonadIO m) => Maybe (T.Text) {- ^ /@name@/: A valid D-Bus name or 'Nothing'. -} -> T.Text {- ^ /@path@/: A valid object path. -} -> Maybe (T.Text) {- ^ /@interface_@/: A valid D-Bus interface name or 'Nothing'. -} -> T.Text {- ^ /@method@/: A valid method name. -} -> m DBusMessage {- ^ __Returns:__ A 'GI.Gio.Objects.DBusMessage.DBusMessage'. Free with 'GI.GObject.Objects.Object.objectUnref'. -} dBusMessageNewMethodCall name path interface_ method = liftIO $ do maybeName <- case name of Nothing -> return nullPtr Just jName -> do jName' <- textToCString jName return jName' path' <- textToCString path maybeInterface_ <- case interface_ of Nothing -> return nullPtr Just jInterface_ -> do jInterface_' <- textToCString jInterface_ return jInterface_' method' <- textToCString method result <- g_dbus_message_new_method_call maybeName path' maybeInterface_ method' checkUnexpectedReturnNULL "dBusMessageNewMethodCall" result result' <- (wrapObject DBusMessage) result freeMem maybeName freeMem path' freeMem maybeInterface_ freeMem method' return result' #if ENABLE_OVERLOADING #endif -- method DBusMessage::new_signal -- method type : Constructor -- Args : [Arg {argCName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A valid object path.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "interface_", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A valid D-Bus interface name.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "signal", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A valid signal name.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gio", name = "DBusMessage"})) -- throws : False -- Skip return : False foreign import ccall "g_dbus_message_new_signal" g_dbus_message_new_signal :: CString -> -- path : TBasicType TUTF8 CString -> -- interface_ : TBasicType TUTF8 CString -> -- signal : TBasicType TUTF8 IO (Ptr DBusMessage) {- | Creates a new 'GI.Gio.Objects.DBusMessage.DBusMessage' for a signal emission. /Since: 2.26/ -} dBusMessageNewSignal :: (B.CallStack.HasCallStack, MonadIO m) => T.Text {- ^ /@path@/: A valid object path. -} -> T.Text {- ^ /@interface_@/: A valid D-Bus interface name. -} -> T.Text {- ^ /@signal@/: A valid signal name. -} -> m DBusMessage {- ^ __Returns:__ A 'GI.Gio.Objects.DBusMessage.DBusMessage'. Free with 'GI.GObject.Objects.Object.objectUnref'. -} dBusMessageNewSignal path interface_ signal = liftIO $ do path' <- textToCString path interface_' <- textToCString interface_ signal' <- textToCString signal result <- g_dbus_message_new_signal path' interface_' signal' checkUnexpectedReturnNULL "dBusMessageNewSignal" result result' <- (wrapObject DBusMessage) result freeMem path' freeMem interface_' freeMem signal' return result' #if ENABLE_OVERLOADING #endif -- method DBusMessage::copy -- method type : OrdinaryMethod -- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gio", name = "DBusMessage"})) -- throws : True -- Skip return : False foreign import ccall "g_dbus_message_copy" g_dbus_message_copy :: Ptr DBusMessage -> -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"}) Ptr (Ptr GError) -> -- error IO (Ptr DBusMessage) {- | Copies /@message@/. The copy is a deep copy and the returned 'GI.Gio.Objects.DBusMessage.DBusMessage' is completely identical except that it is guaranteed to not be locked. This operation can fail if e.g. /@message@/ contains file descriptors and the per-process or system-wide open files limit is reached. /Since: 2.26/ -} dBusMessageCopy :: (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) => a {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -} -> m DBusMessage {- ^ __Returns:__ A new 'GI.Gio.Objects.DBusMessage.DBusMessage' or 'Nothing' if /@error@/ is set. Free with 'GI.GObject.Objects.Object.objectUnref'. /(Can throw 'Data.GI.Base.GError.GError')/ -} dBusMessageCopy message = liftIO $ do message' <- unsafeManagedPtrCastPtr message onException (do result <- propagateGError $ g_dbus_message_copy message' checkUnexpectedReturnNULL "dBusMessageCopy" result result' <- (wrapObject DBusMessage) result touchManagedPtr message return result' ) (do return () ) #if ENABLE_OVERLOADING data DBusMessageCopyMethodInfo instance (signature ~ (m DBusMessage), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageCopyMethodInfo a signature where overloadedMethod _ = dBusMessageCopy #endif -- method DBusMessage::get_arg0 -- method type : OrdinaryMethod -- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TUTF8) -- throws : False -- Skip return : False foreign import ccall "g_dbus_message_get_arg0" g_dbus_message_get_arg0 :: Ptr DBusMessage -> -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"}) IO CString {- | Convenience to get the first item in the body of /@message@/. /Since: 2.26/ -} dBusMessageGetArg0 :: (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) => a {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -} -> m T.Text {- ^ __Returns:__ The string item or 'Nothing' if the first item in the body of /@message@/ is not a string. -} dBusMessageGetArg0 message = liftIO $ do message' <- unsafeManagedPtrCastPtr message result <- g_dbus_message_get_arg0 message' checkUnexpectedReturnNULL "dBusMessageGetArg0" result result' <- cstringToText result touchManagedPtr message return result' #if ENABLE_OVERLOADING data DBusMessageGetArg0MethodInfo instance (signature ~ (m T.Text), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageGetArg0MethodInfo a signature where overloadedMethod _ = dBusMessageGetArg0 #endif -- method DBusMessage::get_body -- method type : OrdinaryMethod -- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just TVariant -- throws : False -- Skip return : False foreign import ccall "g_dbus_message_get_body" g_dbus_message_get_body :: Ptr DBusMessage -> -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"}) IO (Ptr GVariant) {- | Gets the body of a message. /Since: 2.26/ -} dBusMessageGetBody :: (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) => a {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -} -> m GVariant {- ^ __Returns:__ A 'GVariant' or 'Nothing' if the body is empty. Do not free, it is owned by /@message@/. -} dBusMessageGetBody message = liftIO $ do message' <- unsafeManagedPtrCastPtr message result <- g_dbus_message_get_body message' checkUnexpectedReturnNULL "dBusMessageGetBody" result result' <- B.GVariant.newGVariantFromPtr result touchManagedPtr message return result' #if ENABLE_OVERLOADING data DBusMessageGetBodyMethodInfo instance (signature ~ (m GVariant), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageGetBodyMethodInfo a signature where overloadedMethod _ = dBusMessageGetBody #endif -- method DBusMessage::get_byte_order -- method type : OrdinaryMethod -- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gio", name = "DBusMessageByteOrder"})) -- throws : False -- Skip return : False foreign import ccall "g_dbus_message_get_byte_order" g_dbus_message_get_byte_order :: Ptr DBusMessage -> -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"}) IO CUInt {- | Gets the byte order of /@message@/. -} dBusMessageGetByteOrder :: (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) => a {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -} -> m Gio.Enums.DBusMessageByteOrder {- ^ __Returns:__ The byte order. -} dBusMessageGetByteOrder message = liftIO $ do message' <- unsafeManagedPtrCastPtr message result <- g_dbus_message_get_byte_order message' let result' = (toEnum . fromIntegral) result touchManagedPtr message return result' #if ENABLE_OVERLOADING data DBusMessageGetByteOrderMethodInfo instance (signature ~ (m Gio.Enums.DBusMessageByteOrder), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageGetByteOrderMethodInfo a signature where overloadedMethod _ = dBusMessageGetByteOrder #endif -- method DBusMessage::get_destination -- method type : OrdinaryMethod -- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TUTF8) -- throws : False -- Skip return : False foreign import ccall "g_dbus_message_get_destination" g_dbus_message_get_destination :: Ptr DBusMessage -> -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"}) IO CString {- | Convenience getter for the 'GI.Gio.Enums.DBusMessageHeaderFieldDestination' header field. /Since: 2.26/ -} dBusMessageGetDestination :: (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) => a {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -} -> m T.Text {- ^ __Returns:__ The value. -} dBusMessageGetDestination message = liftIO $ do message' <- unsafeManagedPtrCastPtr message result <- g_dbus_message_get_destination message' checkUnexpectedReturnNULL "dBusMessageGetDestination" result result' <- cstringToText result touchManagedPtr message return result' #if ENABLE_OVERLOADING data DBusMessageGetDestinationMethodInfo instance (signature ~ (m T.Text), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageGetDestinationMethodInfo a signature where overloadedMethod _ = dBusMessageGetDestination #endif -- method DBusMessage::get_error_name -- method type : OrdinaryMethod -- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TUTF8) -- throws : False -- Skip return : False foreign import ccall "g_dbus_message_get_error_name" g_dbus_message_get_error_name :: Ptr DBusMessage -> -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"}) IO CString {- | Convenience getter for the 'GI.Gio.Enums.DBusMessageHeaderFieldErrorName' header field. /Since: 2.26/ -} dBusMessageGetErrorName :: (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) => a {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -} -> m T.Text {- ^ __Returns:__ The value. -} dBusMessageGetErrorName message = liftIO $ do message' <- unsafeManagedPtrCastPtr message result <- g_dbus_message_get_error_name message' checkUnexpectedReturnNULL "dBusMessageGetErrorName" result result' <- cstringToText result touchManagedPtr message return result' #if ENABLE_OVERLOADING data DBusMessageGetErrorNameMethodInfo instance (signature ~ (m T.Text), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageGetErrorNameMethodInfo a signature where overloadedMethod _ = dBusMessageGetErrorName #endif -- method DBusMessage::get_flags -- method type : OrdinaryMethod -- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gio", name = "DBusMessageFlags"})) -- throws : False -- Skip return : False foreign import ccall "g_dbus_message_get_flags" g_dbus_message_get_flags :: Ptr DBusMessage -> -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"}) IO CUInt {- | Gets the flags for /@message@/. /Since: 2.26/ -} dBusMessageGetFlags :: (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) => a {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -} -> m [Gio.Flags.DBusMessageFlags] {- ^ __Returns:__ Flags that are set (typically values from the 'GI.Gio.Flags.DBusMessageFlags' enumeration bitwise ORed together). -} dBusMessageGetFlags message = liftIO $ do message' <- unsafeManagedPtrCastPtr message result <- g_dbus_message_get_flags message' let result' = wordToGFlags result touchManagedPtr message return result' #if ENABLE_OVERLOADING data DBusMessageGetFlagsMethodInfo instance (signature ~ (m [Gio.Flags.DBusMessageFlags]), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageGetFlagsMethodInfo a signature where overloadedMethod _ = dBusMessageGetFlags #endif -- method DBusMessage::get_header -- method type : OrdinaryMethod -- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "header_field", argType = TInterface (Name {namespace = "Gio", name = "DBusMessageHeaderField"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A 8-bit unsigned integer (typically a value from the #GDBusMessageHeaderField enumeration)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just TVariant -- throws : False -- Skip return : False foreign import ccall "g_dbus_message_get_header" g_dbus_message_get_header :: Ptr DBusMessage -> -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"}) CUInt -> -- header_field : TInterface (Name {namespace = "Gio", name = "DBusMessageHeaderField"}) IO (Ptr GVariant) {- | Gets a header field on /@message@/. The caller is responsible for checking the type of the returned 'GVariant' matches what is expected. /Since: 2.26/ -} dBusMessageGetHeader :: (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) => a {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -} -> Gio.Enums.DBusMessageHeaderField {- ^ /@headerField@/: A 8-bit unsigned integer (typically a value from the 'GI.Gio.Enums.DBusMessageHeaderField' enumeration) -} -> m (Maybe GVariant) {- ^ __Returns:__ A 'GVariant' with the value if the header was found, 'Nothing' otherwise. Do not free, it is owned by /@message@/. -} dBusMessageGetHeader message headerField = liftIO $ do message' <- unsafeManagedPtrCastPtr message let headerField' = (fromIntegral . fromEnum) headerField result <- g_dbus_message_get_header message' headerField' maybeResult <- convertIfNonNull result $ \result' -> do result'' <- B.GVariant.newGVariantFromPtr result' return result'' touchManagedPtr message return maybeResult #if ENABLE_OVERLOADING data DBusMessageGetHeaderMethodInfo instance (signature ~ (Gio.Enums.DBusMessageHeaderField -> m (Maybe GVariant)), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageGetHeaderMethodInfo a signature where overloadedMethod _ = dBusMessageGetHeader #endif -- method DBusMessage::get_header_fields -- method type : OrdinaryMethod -- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TCArray True (-1) (-1) (TBasicType TUInt8)) -- throws : False -- Skip return : False foreign import ccall "g_dbus_message_get_header_fields" g_dbus_message_get_header_fields :: Ptr DBusMessage -> -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"}) IO (Ptr Word8) {- | Gets an array of all header fields on /@message@/ that are set. /Since: 2.26/ -} dBusMessageGetHeaderFields :: (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) => a {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -} -> m ByteString {- ^ __Returns:__ An array of header fields terminated by 'GI.Gio.Enums.DBusMessageHeaderFieldInvalid'. Each element is a @/guchar/@. Free with 'GI.GLib.Functions.free'. -} dBusMessageGetHeaderFields message = liftIO $ do message' <- unsafeManagedPtrCastPtr message result <- g_dbus_message_get_header_fields message' checkUnexpectedReturnNULL "dBusMessageGetHeaderFields" result result' <- unpackZeroTerminatedByteString result touchManagedPtr message return result' #if ENABLE_OVERLOADING data DBusMessageGetHeaderFieldsMethodInfo instance (signature ~ (m ByteString), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageGetHeaderFieldsMethodInfo a signature where overloadedMethod _ = dBusMessageGetHeaderFields #endif -- method DBusMessage::get_interface -- method type : OrdinaryMethod -- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TUTF8) -- throws : False -- Skip return : False foreign import ccall "g_dbus_message_get_interface" g_dbus_message_get_interface :: Ptr DBusMessage -> -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"}) IO CString {- | Convenience getter for the 'GI.Gio.Enums.DBusMessageHeaderFieldInterface' header field. /Since: 2.26/ -} dBusMessageGetInterface :: (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) => a {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -} -> m T.Text {- ^ __Returns:__ The value. -} dBusMessageGetInterface message = liftIO $ do message' <- unsafeManagedPtrCastPtr message result <- g_dbus_message_get_interface message' checkUnexpectedReturnNULL "dBusMessageGetInterface" result result' <- cstringToText result touchManagedPtr message return result' #if ENABLE_OVERLOADING data DBusMessageGetInterfaceMethodInfo instance (signature ~ (m T.Text), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageGetInterfaceMethodInfo a signature where overloadedMethod _ = dBusMessageGetInterface #endif -- method DBusMessage::get_locked -- method type : OrdinaryMethod -- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : False -- Skip return : False foreign import ccall "g_dbus_message_get_locked" g_dbus_message_get_locked :: Ptr DBusMessage -> -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"}) IO CInt {- | Checks whether /@message@/ is locked. To monitor changes to this value, conncet to the 'GI.GObject.Objects.Object.Object'::@/notify/@ signal to listen for changes on the 'GI.Gio.Objects.DBusMessage.DBusMessage':@/locked/@ property. /Since: 2.26/ -} dBusMessageGetLocked :: (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) => a {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -} -> m Bool {- ^ __Returns:__ 'True' if /@message@/ is locked, 'False' otherwise. -} dBusMessageGetLocked message = liftIO $ do message' <- unsafeManagedPtrCastPtr message result <- g_dbus_message_get_locked message' let result' = (/= 0) result touchManagedPtr message return result' #if ENABLE_OVERLOADING data DBusMessageGetLockedMethodInfo instance (signature ~ (m Bool), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageGetLockedMethodInfo a signature where overloadedMethod _ = dBusMessageGetLocked #endif -- method DBusMessage::get_member -- method type : OrdinaryMethod -- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TUTF8) -- throws : False -- Skip return : False foreign import ccall "g_dbus_message_get_member" g_dbus_message_get_member :: Ptr DBusMessage -> -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"}) IO CString {- | Convenience getter for the 'GI.Gio.Enums.DBusMessageHeaderFieldMember' header field. /Since: 2.26/ -} dBusMessageGetMember :: (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) => a {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -} -> m T.Text {- ^ __Returns:__ The value. -} dBusMessageGetMember message = liftIO $ do message' <- unsafeManagedPtrCastPtr message result <- g_dbus_message_get_member message' checkUnexpectedReturnNULL "dBusMessageGetMember" result result' <- cstringToText result touchManagedPtr message return result' #if ENABLE_OVERLOADING data DBusMessageGetMemberMethodInfo instance (signature ~ (m T.Text), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageGetMemberMethodInfo a signature where overloadedMethod _ = dBusMessageGetMember #endif -- method DBusMessage::get_message_type -- method type : OrdinaryMethod -- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gio", name = "DBusMessageType"})) -- throws : False -- Skip return : False foreign import ccall "g_dbus_message_get_message_type" g_dbus_message_get_message_type :: Ptr DBusMessage -> -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"}) IO CUInt {- | Gets the type of /@message@/. /Since: 2.26/ -} dBusMessageGetMessageType :: (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) => a {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -} -> m Gio.Enums.DBusMessageType {- ^ __Returns:__ A 8-bit unsigned integer (typically a value from the 'GI.Gio.Enums.DBusMessageType' enumeration). -} dBusMessageGetMessageType message = liftIO $ do message' <- unsafeManagedPtrCastPtr message result <- g_dbus_message_get_message_type message' let result' = (toEnum . fromIntegral) result touchManagedPtr message return result' #if ENABLE_OVERLOADING data DBusMessageGetMessageTypeMethodInfo instance (signature ~ (m Gio.Enums.DBusMessageType), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageGetMessageTypeMethodInfo a signature where overloadedMethod _ = dBusMessageGetMessageType #endif -- method DBusMessage::get_num_unix_fds -- method type : OrdinaryMethod -- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TUInt32) -- throws : False -- Skip return : False foreign import ccall "g_dbus_message_get_num_unix_fds" g_dbus_message_get_num_unix_fds :: Ptr DBusMessage -> -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"}) IO Word32 {- | Convenience getter for the 'GI.Gio.Enums.DBusMessageHeaderFieldNumUnixFds' header field. /Since: 2.26/ -} dBusMessageGetNumUnixFds :: (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) => a {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -} -> m Word32 {- ^ __Returns:__ The value. -} dBusMessageGetNumUnixFds message = liftIO $ do message' <- unsafeManagedPtrCastPtr message result <- g_dbus_message_get_num_unix_fds message' touchManagedPtr message return result #if ENABLE_OVERLOADING data DBusMessageGetNumUnixFdsMethodInfo instance (signature ~ (m Word32), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageGetNumUnixFdsMethodInfo a signature where overloadedMethod _ = dBusMessageGetNumUnixFds #endif -- method DBusMessage::get_path -- method type : OrdinaryMethod -- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TUTF8) -- throws : False -- Skip return : False foreign import ccall "g_dbus_message_get_path" g_dbus_message_get_path :: Ptr DBusMessage -> -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"}) IO CString {- | Convenience getter for the 'GI.Gio.Enums.DBusMessageHeaderFieldPath' header field. /Since: 2.26/ -} dBusMessageGetPath :: (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) => a {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -} -> m T.Text {- ^ __Returns:__ The value. -} dBusMessageGetPath message = liftIO $ do message' <- unsafeManagedPtrCastPtr message result <- g_dbus_message_get_path message' checkUnexpectedReturnNULL "dBusMessageGetPath" result result' <- cstringToText result touchManagedPtr message return result' #if ENABLE_OVERLOADING data DBusMessageGetPathMethodInfo instance (signature ~ (m T.Text), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageGetPathMethodInfo a signature where overloadedMethod _ = dBusMessageGetPath #endif -- method DBusMessage::get_reply_serial -- method type : OrdinaryMethod -- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TUInt32) -- throws : False -- Skip return : False foreign import ccall "g_dbus_message_get_reply_serial" g_dbus_message_get_reply_serial :: Ptr DBusMessage -> -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"}) IO Word32 {- | Convenience getter for the 'GI.Gio.Enums.DBusMessageHeaderFieldReplySerial' header field. /Since: 2.26/ -} dBusMessageGetReplySerial :: (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) => a {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -} -> m Word32 {- ^ __Returns:__ The value. -} dBusMessageGetReplySerial message = liftIO $ do message' <- unsafeManagedPtrCastPtr message result <- g_dbus_message_get_reply_serial message' touchManagedPtr message return result #if ENABLE_OVERLOADING data DBusMessageGetReplySerialMethodInfo instance (signature ~ (m Word32), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageGetReplySerialMethodInfo a signature where overloadedMethod _ = dBusMessageGetReplySerial #endif -- method DBusMessage::get_sender -- method type : OrdinaryMethod -- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TUTF8) -- throws : False -- Skip return : False foreign import ccall "g_dbus_message_get_sender" g_dbus_message_get_sender :: Ptr DBusMessage -> -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"}) IO CString {- | Convenience getter for the 'GI.Gio.Enums.DBusMessageHeaderFieldSender' header field. /Since: 2.26/ -} dBusMessageGetSender :: (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) => a {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -} -> m T.Text {- ^ __Returns:__ The value. -} dBusMessageGetSender message = liftIO $ do message' <- unsafeManagedPtrCastPtr message result <- g_dbus_message_get_sender message' checkUnexpectedReturnNULL "dBusMessageGetSender" result result' <- cstringToText result touchManagedPtr message return result' #if ENABLE_OVERLOADING data DBusMessageGetSenderMethodInfo instance (signature ~ (m T.Text), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageGetSenderMethodInfo a signature where overloadedMethod _ = dBusMessageGetSender #endif -- method DBusMessage::get_serial -- method type : OrdinaryMethod -- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TUInt32) -- throws : False -- Skip return : False foreign import ccall "g_dbus_message_get_serial" g_dbus_message_get_serial :: Ptr DBusMessage -> -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"}) IO Word32 {- | Gets the serial for /@message@/. /Since: 2.26/ -} dBusMessageGetSerial :: (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) => a {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -} -> m Word32 {- ^ __Returns:__ A @/guint32/@. -} dBusMessageGetSerial message = liftIO $ do message' <- unsafeManagedPtrCastPtr message result <- g_dbus_message_get_serial message' touchManagedPtr message return result #if ENABLE_OVERLOADING data DBusMessageGetSerialMethodInfo instance (signature ~ (m Word32), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageGetSerialMethodInfo a signature where overloadedMethod _ = dBusMessageGetSerial #endif -- method DBusMessage::get_signature -- method type : OrdinaryMethod -- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TUTF8) -- throws : False -- Skip return : False foreign import ccall "g_dbus_message_get_signature" g_dbus_message_get_signature :: Ptr DBusMessage -> -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"}) IO CString {- | Convenience getter for the 'GI.Gio.Enums.DBusMessageHeaderFieldSignature' header field. /Since: 2.26/ -} dBusMessageGetSignature :: (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) => a {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -} -> m T.Text {- ^ __Returns:__ The value. -} dBusMessageGetSignature message = liftIO $ do message' <- unsafeManagedPtrCastPtr message result <- g_dbus_message_get_signature message' checkUnexpectedReturnNULL "dBusMessageGetSignature" result result' <- cstringToText result touchManagedPtr message return result' #if ENABLE_OVERLOADING data DBusMessageGetSignatureMethodInfo instance (signature ~ (m T.Text), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageGetSignatureMethodInfo a signature where overloadedMethod _ = dBusMessageGetSignature #endif -- method DBusMessage::get_unix_fd_list -- method type : OrdinaryMethod -- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gio", name = "UnixFDList"})) -- throws : False -- Skip return : False foreign import ccall "g_dbus_message_get_unix_fd_list" g_dbus_message_get_unix_fd_list :: Ptr DBusMessage -> -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"}) IO (Ptr Gio.UnixFDList.UnixFDList) {- | Gets the UNIX file descriptors associated with /@message@/, if any. This method is only available on UNIX. /Since: 2.26/ -} dBusMessageGetUnixFdList :: (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) => a {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -} -> m Gio.UnixFDList.UnixFDList {- ^ __Returns:__ A 'GI.Gio.Objects.UnixFDList.UnixFDList' or 'Nothing' if no file descriptors are associated. Do not free, this object is owned by /@message@/. -} dBusMessageGetUnixFdList message = liftIO $ do message' <- unsafeManagedPtrCastPtr message result <- g_dbus_message_get_unix_fd_list message' checkUnexpectedReturnNULL "dBusMessageGetUnixFdList" result result' <- (newObject Gio.UnixFDList.UnixFDList) result touchManagedPtr message return result' #if ENABLE_OVERLOADING data DBusMessageGetUnixFdListMethodInfo instance (signature ~ (m Gio.UnixFDList.UnixFDList), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageGetUnixFdListMethodInfo a signature where overloadedMethod _ = dBusMessageGetUnixFdList #endif -- method DBusMessage::lock -- method type : OrdinaryMethod -- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "g_dbus_message_lock" g_dbus_message_lock :: Ptr DBusMessage -> -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"}) IO () {- | If /@message@/ is locked, does nothing. Otherwise locks the message. /Since: 2.26/ -} dBusMessageLock :: (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) => a {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -} -> m () dBusMessageLock message = liftIO $ do message' <- unsafeManagedPtrCastPtr message g_dbus_message_lock message' touchManagedPtr message return () #if ENABLE_OVERLOADING data DBusMessageLockMethodInfo instance (signature ~ (m ()), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageLockMethodInfo a signature where overloadedMethod _ = dBusMessageLock #endif -- method DBusMessage::new_method_error_literal -- method type : OrdinaryMethod -- Args : [Arg {argCName = "method_call_message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A message of type %G_DBUS_MESSAGE_TYPE_METHOD_CALL to\ncreate a reply message to.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "error_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A valid D-Bus error name.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "error_message", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The D-Bus error message.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gio", name = "DBusMessage"})) -- throws : False -- Skip return : False foreign import ccall "g_dbus_message_new_method_error_literal" g_dbus_message_new_method_error_literal :: Ptr DBusMessage -> -- method_call_message : TInterface (Name {namespace = "Gio", name = "DBusMessage"}) CString -> -- error_name : TBasicType TUTF8 CString -> -- error_message : TBasicType TUTF8 IO (Ptr DBusMessage) {- | Creates a new 'GI.Gio.Objects.DBusMessage.DBusMessage' that is an error reply to /@methodCallMessage@/. /Since: 2.26/ -} dBusMessageNewMethodErrorLiteral :: (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) => a {- ^ /@methodCallMessage@/: A message of type 'GI.Gio.Enums.DBusMessageTypeMethodCall' to create a reply message to. -} -> T.Text {- ^ /@errorName@/: A valid D-Bus error name. -} -> T.Text {- ^ /@errorMessage@/: The D-Bus error message. -} -> m DBusMessage {- ^ __Returns:__ A 'GI.Gio.Objects.DBusMessage.DBusMessage'. Free with 'GI.GObject.Objects.Object.objectUnref'. -} dBusMessageNewMethodErrorLiteral methodCallMessage errorName errorMessage = liftIO $ do methodCallMessage' <- unsafeManagedPtrCastPtr methodCallMessage errorName' <- textToCString errorName errorMessage' <- textToCString errorMessage result <- g_dbus_message_new_method_error_literal methodCallMessage' errorName' errorMessage' checkUnexpectedReturnNULL "dBusMessageNewMethodErrorLiteral" result result' <- (wrapObject DBusMessage) result touchManagedPtr methodCallMessage freeMem errorName' freeMem errorMessage' return result' #if ENABLE_OVERLOADING data DBusMessageNewMethodErrorLiteralMethodInfo instance (signature ~ (T.Text -> T.Text -> m DBusMessage), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageNewMethodErrorLiteralMethodInfo a signature where overloadedMethod _ = dBusMessageNewMethodErrorLiteral #endif -- method DBusMessage::new_method_reply -- method type : OrdinaryMethod -- Args : [Arg {argCName = "method_call_message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A message of type %G_DBUS_MESSAGE_TYPE_METHOD_CALL to\ncreate a reply message to.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gio", name = "DBusMessage"})) -- throws : False -- Skip return : False foreign import ccall "g_dbus_message_new_method_reply" g_dbus_message_new_method_reply :: Ptr DBusMessage -> -- method_call_message : TInterface (Name {namespace = "Gio", name = "DBusMessage"}) IO (Ptr DBusMessage) {- | Creates a new 'GI.Gio.Objects.DBusMessage.DBusMessage' that is a reply to /@methodCallMessage@/. /Since: 2.26/ -} dBusMessageNewMethodReply :: (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) => a {- ^ /@methodCallMessage@/: A message of type 'GI.Gio.Enums.DBusMessageTypeMethodCall' to create a reply message to. -} -> m DBusMessage {- ^ __Returns:__ 'GI.Gio.Objects.DBusMessage.DBusMessage'. Free with 'GI.GObject.Objects.Object.objectUnref'. -} dBusMessageNewMethodReply methodCallMessage = liftIO $ do methodCallMessage' <- unsafeManagedPtrCastPtr methodCallMessage result <- g_dbus_message_new_method_reply methodCallMessage' checkUnexpectedReturnNULL "dBusMessageNewMethodReply" result result' <- (wrapObject DBusMessage) result touchManagedPtr methodCallMessage return result' #if ENABLE_OVERLOADING data DBusMessageNewMethodReplyMethodInfo instance (signature ~ (m DBusMessage), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageNewMethodReplyMethodInfo a signature where overloadedMethod _ = dBusMessageNewMethodReply #endif -- method DBusMessage::print -- method type : OrdinaryMethod -- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "indent", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Indentation level.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TUTF8) -- throws : False -- Skip return : False foreign import ccall "g_dbus_message_print" g_dbus_message_print :: Ptr DBusMessage -> -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"}) Word32 -> -- indent : TBasicType TUInt IO CString {- | Produces a human-readable multi-line description of /@message@/. The contents of the description has no ABI guarantees, the contents and formatting is subject to change at any time. Typical output looks something like this: > >Flags: none >Version: 0 >Serial: 4 >Headers: > path -> objectpath '/org/gtk/GDBus/TestObject' > interface -> 'org.gtk.GDBus.TestInterface' > member -> 'GimmeStdout' > destination -> ':1.146' >Body: () >UNIX File Descriptors: > (none) or > >Flags: no-reply-expected >Version: 0 >Serial: 477 >Headers: > reply-serial -> uint32 4 > destination -> ':1.159' > sender -> ':1.146' > num-unix-fds -> uint32 1 >Body: () >UNIX File Descriptors: > fd 12: dev=0:10,mode=020620,ino=5,uid=500,gid=5,rdev=136:2,size=0,atime=1273085037,mtime=1273085851,ctime=1272982635 /Since: 2.26/ -} dBusMessagePrint :: (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) => a {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -} -> Word32 {- ^ /@indent@/: Indentation level. -} -> m T.Text {- ^ __Returns:__ A string that should be freed with 'GI.GLib.Functions.free'. -} dBusMessagePrint message indent = liftIO $ do message' <- unsafeManagedPtrCastPtr message result <- g_dbus_message_print message' indent checkUnexpectedReturnNULL "dBusMessagePrint" result result' <- cstringToText result freeMem result touchManagedPtr message return result' #if ENABLE_OVERLOADING data DBusMessagePrintMethodInfo instance (signature ~ (Word32 -> m T.Text), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessagePrintMethodInfo a signature where overloadedMethod _ = dBusMessagePrint #endif -- method DBusMessage::set_body -- method type : OrdinaryMethod -- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "body", argType = TVariant, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Either %NULL or a #GVariant that is a tuple.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "g_dbus_message_set_body" g_dbus_message_set_body :: Ptr DBusMessage -> -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"}) Ptr GVariant -> -- body : TVariant IO () {- | Sets the body /@message@/. As a side-effect the 'GI.Gio.Enums.DBusMessageHeaderFieldSignature' header field is set to the type string of /@body@/ (or cleared if /@body@/ is 'Nothing'). If /@body@/ is floating, /@message@/ assumes ownership of /@body@/. /Since: 2.26/ -} dBusMessageSetBody :: (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) => a {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -} -> GVariant {- ^ /@body@/: Either 'Nothing' or a 'GVariant' that is a tuple. -} -> m () dBusMessageSetBody message body = liftIO $ do message' <- unsafeManagedPtrCastPtr message body' <- unsafeManagedPtrGetPtr body g_dbus_message_set_body message' body' touchManagedPtr message touchManagedPtr body return () #if ENABLE_OVERLOADING data DBusMessageSetBodyMethodInfo instance (signature ~ (GVariant -> m ()), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageSetBodyMethodInfo a signature where overloadedMethod _ = dBusMessageSetBody #endif -- method DBusMessage::set_byte_order -- method type : OrdinaryMethod -- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "byte_order", argType = TInterface (Name {namespace = "Gio", name = "DBusMessageByteOrder"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The byte order.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "g_dbus_message_set_byte_order" g_dbus_message_set_byte_order :: Ptr DBusMessage -> -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"}) CUInt -> -- byte_order : TInterface (Name {namespace = "Gio", name = "DBusMessageByteOrder"}) IO () {- | Sets the byte order of /@message@/. -} dBusMessageSetByteOrder :: (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) => a {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -} -> Gio.Enums.DBusMessageByteOrder {- ^ /@byteOrder@/: The byte order. -} -> m () dBusMessageSetByteOrder message byteOrder = liftIO $ do message' <- unsafeManagedPtrCastPtr message let byteOrder' = (fromIntegral . fromEnum) byteOrder g_dbus_message_set_byte_order message' byteOrder' touchManagedPtr message return () #if ENABLE_OVERLOADING data DBusMessageSetByteOrderMethodInfo instance (signature ~ (Gio.Enums.DBusMessageByteOrder -> m ()), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageSetByteOrderMethodInfo a signature where overloadedMethod _ = dBusMessageSetByteOrder #endif -- method DBusMessage::set_destination -- method type : OrdinaryMethod -- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The value to set.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "g_dbus_message_set_destination" g_dbus_message_set_destination :: Ptr DBusMessage -> -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"}) CString -> -- value : TBasicType TUTF8 IO () {- | Convenience setter for the 'GI.Gio.Enums.DBusMessageHeaderFieldDestination' header field. /Since: 2.26/ -} dBusMessageSetDestination :: (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) => a {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -} -> T.Text {- ^ /@value@/: The value to set. -} -> m () dBusMessageSetDestination message value = liftIO $ do message' <- unsafeManagedPtrCastPtr message value' <- textToCString value g_dbus_message_set_destination message' value' touchManagedPtr message freeMem value' return () #if ENABLE_OVERLOADING data DBusMessageSetDestinationMethodInfo instance (signature ~ (T.Text -> m ()), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageSetDestinationMethodInfo a signature where overloadedMethod _ = dBusMessageSetDestination #endif -- method DBusMessage::set_error_name -- method type : OrdinaryMethod -- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The value to set.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "g_dbus_message_set_error_name" g_dbus_message_set_error_name :: Ptr DBusMessage -> -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"}) CString -> -- value : TBasicType TUTF8 IO () {- | Convenience setter for the 'GI.Gio.Enums.DBusMessageHeaderFieldErrorName' header field. /Since: 2.26/ -} dBusMessageSetErrorName :: (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) => a {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -} -> T.Text {- ^ /@value@/: The value to set. -} -> m () dBusMessageSetErrorName message value = liftIO $ do message' <- unsafeManagedPtrCastPtr message value' <- textToCString value g_dbus_message_set_error_name message' value' touchManagedPtr message freeMem value' return () #if ENABLE_OVERLOADING data DBusMessageSetErrorNameMethodInfo instance (signature ~ (T.Text -> m ()), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageSetErrorNameMethodInfo a signature where overloadedMethod _ = dBusMessageSetErrorName #endif -- method DBusMessage::set_flags -- method type : OrdinaryMethod -- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Gio", name = "DBusMessageFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Flags for @message that are set (typically values from the #GDBusMessageFlags\nenumeration bitwise ORed together).", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "g_dbus_message_set_flags" g_dbus_message_set_flags :: Ptr DBusMessage -> -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"}) CUInt -> -- flags : TInterface (Name {namespace = "Gio", name = "DBusMessageFlags"}) IO () {- | Sets the flags to set on /@message@/. /Since: 2.26/ -} dBusMessageSetFlags :: (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) => a {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -} -> [Gio.Flags.DBusMessageFlags] {- ^ /@flags@/: Flags for /@message@/ that are set (typically values from the 'GI.Gio.Flags.DBusMessageFlags' enumeration bitwise ORed together). -} -> m () dBusMessageSetFlags message flags = liftIO $ do message' <- unsafeManagedPtrCastPtr message let flags' = gflagsToWord flags g_dbus_message_set_flags message' flags' touchManagedPtr message return () #if ENABLE_OVERLOADING data DBusMessageSetFlagsMethodInfo instance (signature ~ ([Gio.Flags.DBusMessageFlags] -> m ()), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageSetFlagsMethodInfo a signature where overloadedMethod _ = dBusMessageSetFlags #endif -- method DBusMessage::set_header -- method type : OrdinaryMethod -- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "header_field", argType = TInterface (Name {namespace = "Gio", name = "DBusMessageHeaderField"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A 8-bit unsigned integer (typically a value from the #GDBusMessageHeaderField enumeration)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TVariant, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "A #GVariant to set the header field or %NULL to clear the header field.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "g_dbus_message_set_header" g_dbus_message_set_header :: Ptr DBusMessage -> -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"}) CUInt -> -- header_field : TInterface (Name {namespace = "Gio", name = "DBusMessageHeaderField"}) Ptr GVariant -> -- value : TVariant IO () {- | Sets a header field on /@message@/. If /@value@/ is floating, /@message@/ assumes ownership of /@value@/. /Since: 2.26/ -} dBusMessageSetHeader :: (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) => a {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -} -> Gio.Enums.DBusMessageHeaderField {- ^ /@headerField@/: A 8-bit unsigned integer (typically a value from the 'GI.Gio.Enums.DBusMessageHeaderField' enumeration) -} -> Maybe (GVariant) {- ^ /@value@/: A 'GVariant' to set the header field or 'Nothing' to clear the header field. -} -> m () dBusMessageSetHeader message headerField value = liftIO $ do message' <- unsafeManagedPtrCastPtr message let headerField' = (fromIntegral . fromEnum) headerField maybeValue <- case value of Nothing -> return nullPtr Just jValue -> do jValue' <- unsafeManagedPtrGetPtr jValue return jValue' g_dbus_message_set_header message' headerField' maybeValue touchManagedPtr message whenJust value touchManagedPtr return () #if ENABLE_OVERLOADING data DBusMessageSetHeaderMethodInfo instance (signature ~ (Gio.Enums.DBusMessageHeaderField -> Maybe (GVariant) -> m ()), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageSetHeaderMethodInfo a signature where overloadedMethod _ = dBusMessageSetHeader #endif -- method DBusMessage::set_interface -- method type : OrdinaryMethod -- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The value to set.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "g_dbus_message_set_interface" g_dbus_message_set_interface :: Ptr DBusMessage -> -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"}) CString -> -- value : TBasicType TUTF8 IO () {- | Convenience setter for the 'GI.Gio.Enums.DBusMessageHeaderFieldInterface' header field. /Since: 2.26/ -} dBusMessageSetInterface :: (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) => a {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -} -> T.Text {- ^ /@value@/: The value to set. -} -> m () dBusMessageSetInterface message value = liftIO $ do message' <- unsafeManagedPtrCastPtr message value' <- textToCString value g_dbus_message_set_interface message' value' touchManagedPtr message freeMem value' return () #if ENABLE_OVERLOADING data DBusMessageSetInterfaceMethodInfo instance (signature ~ (T.Text -> m ()), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageSetInterfaceMethodInfo a signature where overloadedMethod _ = dBusMessageSetInterface #endif -- method DBusMessage::set_member -- method type : OrdinaryMethod -- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The value to set.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "g_dbus_message_set_member" g_dbus_message_set_member :: Ptr DBusMessage -> -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"}) CString -> -- value : TBasicType TUTF8 IO () {- | Convenience setter for the 'GI.Gio.Enums.DBusMessageHeaderFieldMember' header field. /Since: 2.26/ -} dBusMessageSetMember :: (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) => a {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -} -> T.Text {- ^ /@value@/: The value to set. -} -> m () dBusMessageSetMember message value = liftIO $ do message' <- unsafeManagedPtrCastPtr message value' <- textToCString value g_dbus_message_set_member message' value' touchManagedPtr message freeMem value' return () #if ENABLE_OVERLOADING data DBusMessageSetMemberMethodInfo instance (signature ~ (T.Text -> m ()), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageSetMemberMethodInfo a signature where overloadedMethod _ = dBusMessageSetMember #endif -- method DBusMessage::set_message_type -- method type : OrdinaryMethod -- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TInterface (Name {namespace = "Gio", name = "DBusMessageType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A 8-bit unsigned integer (typically a value from the #GDBusMessageType enumeration).", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "g_dbus_message_set_message_type" g_dbus_message_set_message_type :: Ptr DBusMessage -> -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"}) CUInt -> -- type : TInterface (Name {namespace = "Gio", name = "DBusMessageType"}) IO () {- | Sets /@message@/ to be of /@type@/. /Since: 2.26/ -} dBusMessageSetMessageType :: (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) => a {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -} -> Gio.Enums.DBusMessageType {- ^ /@type@/: A 8-bit unsigned integer (typically a value from the 'GI.Gio.Enums.DBusMessageType' enumeration). -} -> m () dBusMessageSetMessageType message type_ = liftIO $ do message' <- unsafeManagedPtrCastPtr message let type_' = (fromIntegral . fromEnum) type_ g_dbus_message_set_message_type message' type_' touchManagedPtr message return () #if ENABLE_OVERLOADING data DBusMessageSetMessageTypeMethodInfo instance (signature ~ (Gio.Enums.DBusMessageType -> m ()), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageSetMessageTypeMethodInfo a signature where overloadedMethod _ = dBusMessageSetMessageType #endif -- method DBusMessage::set_num_unix_fds -- method type : OrdinaryMethod -- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The value to set.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "g_dbus_message_set_num_unix_fds" g_dbus_message_set_num_unix_fds :: Ptr DBusMessage -> -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"}) Word32 -> -- value : TBasicType TUInt32 IO () {- | Convenience setter for the 'GI.Gio.Enums.DBusMessageHeaderFieldNumUnixFds' header field. /Since: 2.26/ -} dBusMessageSetNumUnixFds :: (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) => a {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -} -> Word32 {- ^ /@value@/: The value to set. -} -> m () dBusMessageSetNumUnixFds message value = liftIO $ do message' <- unsafeManagedPtrCastPtr message g_dbus_message_set_num_unix_fds message' value touchManagedPtr message return () #if ENABLE_OVERLOADING data DBusMessageSetNumUnixFdsMethodInfo instance (signature ~ (Word32 -> m ()), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageSetNumUnixFdsMethodInfo a signature where overloadedMethod _ = dBusMessageSetNumUnixFds #endif -- method DBusMessage::set_path -- method type : OrdinaryMethod -- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The value to set.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "g_dbus_message_set_path" g_dbus_message_set_path :: Ptr DBusMessage -> -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"}) CString -> -- value : TBasicType TUTF8 IO () {- | Convenience setter for the 'GI.Gio.Enums.DBusMessageHeaderFieldPath' header field. /Since: 2.26/ -} dBusMessageSetPath :: (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) => a {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -} -> T.Text {- ^ /@value@/: The value to set. -} -> m () dBusMessageSetPath message value = liftIO $ do message' <- unsafeManagedPtrCastPtr message value' <- textToCString value g_dbus_message_set_path message' value' touchManagedPtr message freeMem value' return () #if ENABLE_OVERLOADING data DBusMessageSetPathMethodInfo instance (signature ~ (T.Text -> m ()), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageSetPathMethodInfo a signature where overloadedMethod _ = dBusMessageSetPath #endif -- method DBusMessage::set_reply_serial -- method type : OrdinaryMethod -- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The value to set.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "g_dbus_message_set_reply_serial" g_dbus_message_set_reply_serial :: Ptr DBusMessage -> -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"}) Word32 -> -- value : TBasicType TUInt32 IO () {- | Convenience setter for the 'GI.Gio.Enums.DBusMessageHeaderFieldReplySerial' header field. /Since: 2.26/ -} dBusMessageSetReplySerial :: (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) => a {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -} -> Word32 {- ^ /@value@/: The value to set. -} -> m () dBusMessageSetReplySerial message value = liftIO $ do message' <- unsafeManagedPtrCastPtr message g_dbus_message_set_reply_serial message' value touchManagedPtr message return () #if ENABLE_OVERLOADING data DBusMessageSetReplySerialMethodInfo instance (signature ~ (Word32 -> m ()), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageSetReplySerialMethodInfo a signature where overloadedMethod _ = dBusMessageSetReplySerial #endif -- method DBusMessage::set_sender -- method type : OrdinaryMethod -- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The value to set.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "g_dbus_message_set_sender" g_dbus_message_set_sender :: Ptr DBusMessage -> -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"}) CString -> -- value : TBasicType TUTF8 IO () {- | Convenience setter for the 'GI.Gio.Enums.DBusMessageHeaderFieldSender' header field. /Since: 2.26/ -} dBusMessageSetSender :: (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) => a {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -} -> T.Text {- ^ /@value@/: The value to set. -} -> m () dBusMessageSetSender message value = liftIO $ do message' <- unsafeManagedPtrCastPtr message value' <- textToCString value g_dbus_message_set_sender message' value' touchManagedPtr message freeMem value' return () #if ENABLE_OVERLOADING data DBusMessageSetSenderMethodInfo instance (signature ~ (T.Text -> m ()), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageSetSenderMethodInfo a signature where overloadedMethod _ = dBusMessageSetSender #endif -- method DBusMessage::set_serial -- method type : OrdinaryMethod -- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "serial", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #guint32.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "g_dbus_message_set_serial" g_dbus_message_set_serial :: Ptr DBusMessage -> -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"}) Word32 -> -- serial : TBasicType TUInt32 IO () {- | Sets the serial for /@message@/. /Since: 2.26/ -} dBusMessageSetSerial :: (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) => a {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -} -> Word32 {- ^ /@serial@/: A @/guint32/@. -} -> m () dBusMessageSetSerial message serial = liftIO $ do message' <- unsafeManagedPtrCastPtr message g_dbus_message_set_serial message' serial touchManagedPtr message return () #if ENABLE_OVERLOADING data DBusMessageSetSerialMethodInfo instance (signature ~ (Word32 -> m ()), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageSetSerialMethodInfo a signature where overloadedMethod _ = dBusMessageSetSerial #endif -- method DBusMessage::set_signature -- method type : OrdinaryMethod -- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The value to set.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "g_dbus_message_set_signature" g_dbus_message_set_signature :: Ptr DBusMessage -> -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"}) CString -> -- value : TBasicType TUTF8 IO () {- | Convenience setter for the 'GI.Gio.Enums.DBusMessageHeaderFieldSignature' header field. /Since: 2.26/ -} dBusMessageSetSignature :: (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) => a {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -} -> T.Text {- ^ /@value@/: The value to set. -} -> m () dBusMessageSetSignature message value = liftIO $ do message' <- unsafeManagedPtrCastPtr message value' <- textToCString value g_dbus_message_set_signature message' value' touchManagedPtr message freeMem value' return () #if ENABLE_OVERLOADING data DBusMessageSetSignatureMethodInfo instance (signature ~ (T.Text -> m ()), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageSetSignatureMethodInfo a signature where overloadedMethod _ = dBusMessageSetSignature #endif -- method DBusMessage::set_unix_fd_list -- method type : OrdinaryMethod -- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fd_list", argType = TInterface (Name {namespace = "Gio", name = "UnixFDList"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "A #GUnixFDList or %NULL.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "g_dbus_message_set_unix_fd_list" g_dbus_message_set_unix_fd_list :: Ptr DBusMessage -> -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"}) Ptr Gio.UnixFDList.UnixFDList -> -- fd_list : TInterface (Name {namespace = "Gio", name = "UnixFDList"}) IO () {- | Sets the UNIX file descriptors associated with /@message@/. As a side-effect the 'GI.Gio.Enums.DBusMessageHeaderFieldNumUnixFds' header field is set to the number of fds in /@fdList@/ (or cleared if /@fdList@/ is 'Nothing'). This method is only available on UNIX. /Since: 2.26/ -} dBusMessageSetUnixFdList :: (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a, Gio.UnixFDList.IsUnixFDList b) => a {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -} -> Maybe (b) {- ^ /@fdList@/: A 'GI.Gio.Objects.UnixFDList.UnixFDList' or 'Nothing'. -} -> m () dBusMessageSetUnixFdList message fdList = liftIO $ do message' <- unsafeManagedPtrCastPtr message maybeFdList <- case fdList of Nothing -> return nullPtr Just jFdList -> do jFdList' <- unsafeManagedPtrCastPtr jFdList return jFdList' g_dbus_message_set_unix_fd_list message' maybeFdList touchManagedPtr message whenJust fdList touchManagedPtr return () #if ENABLE_OVERLOADING data DBusMessageSetUnixFdListMethodInfo instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsDBusMessage a, Gio.UnixFDList.IsUnixFDList b) => O.MethodInfo DBusMessageSetUnixFdListMethodInfo a signature where overloadedMethod _ = dBusMessageSetUnixFdList #endif -- method DBusMessage::to_blob -- method type : OrdinaryMethod -- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "out_size", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Return location for size of generated blob.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "capabilities", argType = TInterface (Name {namespace = "Gio", name = "DBusCapabilityFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusCapabilityFlags describing what protocol features are supported.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [Arg {argCName = "out_size", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Return location for size of generated blob.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] -- returnType : Just (TCArray False (-1) 1 (TBasicType TUInt8)) -- throws : True -- Skip return : False foreign import ccall "g_dbus_message_to_blob" g_dbus_message_to_blob :: Ptr DBusMessage -> -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"}) Ptr Word64 -> -- out_size : TBasicType TUInt64 CUInt -> -- capabilities : TInterface (Name {namespace = "Gio", name = "DBusCapabilityFlags"}) Ptr (Ptr GError) -> -- error IO (Ptr Word8) {- | Serializes /@message@/ to a blob. The byte order returned by 'GI.Gio.Objects.DBusMessage.dBusMessageGetByteOrder' will be used. /Since: 2.26/ -} dBusMessageToBlob :: (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) => a {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -} -> [Gio.Flags.DBusCapabilityFlags] {- ^ /@capabilities@/: A 'GI.Gio.Flags.DBusCapabilityFlags' describing what protocol features are supported. -} -> m ByteString {- ^ __Returns:__ A pointer to a valid binary D-Bus message of /@outSize@/ bytes generated by /@message@/ or 'Nothing' if /@error@/ is set. Free with 'GI.GLib.Functions.free'. /(Can throw 'Data.GI.Base.GError.GError')/ -} dBusMessageToBlob message capabilities = liftIO $ do message' <- unsafeManagedPtrCastPtr message outSize <- allocMem :: IO (Ptr Word64) let capabilities' = gflagsToWord capabilities onException (do result <- propagateGError $ g_dbus_message_to_blob message' outSize capabilities' outSize' <- peek outSize checkUnexpectedReturnNULL "dBusMessageToBlob" result result' <- (unpackByteStringWithLength outSize') result freeMem result touchManagedPtr message freeMem outSize return result' ) (do freeMem outSize ) #if ENABLE_OVERLOADING data DBusMessageToBlobMethodInfo instance (signature ~ ([Gio.Flags.DBusCapabilityFlags] -> m ByteString), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageToBlobMethodInfo a signature where overloadedMethod _ = dBusMessageToBlob #endif -- method DBusMessage::to_gerror -- method type : OrdinaryMethod -- Args : [Arg {argCName = "message", argType = TInterface (Name {namespace = "Gio", name = "DBusMessage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GDBusMessage.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : True -- Skip return : False foreign import ccall "g_dbus_message_to_gerror" g_dbus_message_to_gerror :: Ptr DBusMessage -> -- message : TInterface (Name {namespace = "Gio", name = "DBusMessage"}) Ptr (Ptr GError) -> -- error IO CInt {- | If /@message@/ is not of type 'GI.Gio.Enums.DBusMessageTypeError' does nothing and returns 'False'. Otherwise this method encodes the error in /@message@/ as a 'GError' using @/g_dbus_error_set_dbus_error()/@ using the information in the 'GI.Gio.Enums.DBusMessageHeaderFieldErrorName' header field of /@message@/ as well as the first string item in /@message@/\'s body. /Since: 2.26/ -} dBusMessageToGerror :: (B.CallStack.HasCallStack, MonadIO m, IsDBusMessage a) => a {- ^ /@message@/: A 'GI.Gio.Objects.DBusMessage.DBusMessage'. -} -> m () {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} dBusMessageToGerror message = liftIO $ do message' <- unsafeManagedPtrCastPtr message onException (do _ <- propagateGError $ g_dbus_message_to_gerror message' touchManagedPtr message return () ) (do return () ) #if ENABLE_OVERLOADING data DBusMessageToGerrorMethodInfo instance (signature ~ (m ()), MonadIO m, IsDBusMessage a) => O.MethodInfo DBusMessageToGerrorMethodInfo a signature where overloadedMethod _ = dBusMessageToGerror #endif -- method DBusMessage::bytes_needed -- method type : MemberFunction -- Args : [Arg {argCName = "blob", argType = TCArray False (-1) 1 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A blob representing a binary D-Bus message.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "blob_len", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The length of @blob (must be at least 16).", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [Arg {argCName = "blob_len", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The length of @blob (must be at least 16).", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- returnType : Just (TBasicType TInt64) -- throws : True -- Skip return : False foreign import ccall "g_dbus_message_bytes_needed" g_dbus_message_bytes_needed :: Ptr Word8 -> -- blob : TCArray False (-1) 1 (TBasicType TUInt8) Word64 -> -- blob_len : TBasicType TUInt64 Ptr (Ptr GError) -> -- error IO Int64 {- | Utility function to calculate how many bytes are needed to completely deserialize the D-Bus message stored at /@blob@/. /Since: 2.26/ -} dBusMessageBytesNeeded :: (B.CallStack.HasCallStack, MonadIO m) => ByteString {- ^ /@blob@/: A blob representing a binary D-Bus message. -} -> m Int64 {- ^ __Returns:__ Number of bytes needed or -1 if /@error@/ is set (e.g. if /@blob@/ contains invalid data or not enough data is available to determine the size). /(Can throw 'Data.GI.Base.GError.GError')/ -} dBusMessageBytesNeeded blob = liftIO $ do let blobLen = fromIntegral $ B.length blob blob' <- packByteString blob onException (do result <- propagateGError $ g_dbus_message_bytes_needed blob' blobLen freeMem blob' return result ) (do freeMem blob' ) #if ENABLE_OVERLOADING #endif