{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.GLib.Structs.BookmarkFile
(
BookmarkFile(..) ,
#if defined(ENABLE_OVERLOADING)
ResolveBookmarkFileMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
BookmarkFileAddApplicationMethodInfo ,
#endif
bookmarkFileAddApplication ,
#if defined(ENABLE_OVERLOADING)
BookmarkFileAddGroupMethodInfo ,
#endif
bookmarkFileAddGroup ,
#if defined(ENABLE_OVERLOADING)
BookmarkFileCopyMethodInfo ,
#endif
bookmarkFileCopy ,
bookmarkFileErrorQuark ,
#if defined(ENABLE_OVERLOADING)
BookmarkFileFreeMethodInfo ,
#endif
bookmarkFileFree ,
#if defined(ENABLE_OVERLOADING)
BookmarkFileGetAddedMethodInfo ,
#endif
bookmarkFileGetAdded ,
#if defined(ENABLE_OVERLOADING)
BookmarkFileGetAddedDateTimeMethodInfo ,
#endif
bookmarkFileGetAddedDateTime ,
#if defined(ENABLE_OVERLOADING)
BookmarkFileGetAppInfoMethodInfo ,
#endif
bookmarkFileGetAppInfo ,
#if defined(ENABLE_OVERLOADING)
BookmarkFileGetApplicationInfoMethodInfo,
#endif
bookmarkFileGetApplicationInfo ,
#if defined(ENABLE_OVERLOADING)
BookmarkFileGetApplicationsMethodInfo ,
#endif
bookmarkFileGetApplications ,
#if defined(ENABLE_OVERLOADING)
BookmarkFileGetDescriptionMethodInfo ,
#endif
bookmarkFileGetDescription ,
#if defined(ENABLE_OVERLOADING)
BookmarkFileGetGroupsMethodInfo ,
#endif
bookmarkFileGetGroups ,
#if defined(ENABLE_OVERLOADING)
BookmarkFileGetIconMethodInfo ,
#endif
bookmarkFileGetIcon ,
#if defined(ENABLE_OVERLOADING)
BookmarkFileGetIsPrivateMethodInfo ,
#endif
bookmarkFileGetIsPrivate ,
#if defined(ENABLE_OVERLOADING)
BookmarkFileGetMimeTypeMethodInfo ,
#endif
bookmarkFileGetMimeType ,
#if defined(ENABLE_OVERLOADING)
BookmarkFileGetModifiedMethodInfo ,
#endif
bookmarkFileGetModified ,
#if defined(ENABLE_OVERLOADING)
BookmarkFileGetModifiedDateTimeMethodInfo,
#endif
bookmarkFileGetModifiedDateTime ,
#if defined(ENABLE_OVERLOADING)
BookmarkFileGetSizeMethodInfo ,
#endif
bookmarkFileGetSize ,
#if defined(ENABLE_OVERLOADING)
BookmarkFileGetTitleMethodInfo ,
#endif
bookmarkFileGetTitle ,
#if defined(ENABLE_OVERLOADING)
BookmarkFileGetUrisMethodInfo ,
#endif
bookmarkFileGetUris ,
#if defined(ENABLE_OVERLOADING)
BookmarkFileGetVisitedMethodInfo ,
#endif
bookmarkFileGetVisited ,
#if defined(ENABLE_OVERLOADING)
BookmarkFileGetVisitedDateTimeMethodInfo,
#endif
bookmarkFileGetVisitedDateTime ,
#if defined(ENABLE_OVERLOADING)
BookmarkFileHasApplicationMethodInfo ,
#endif
bookmarkFileHasApplication ,
#if defined(ENABLE_OVERLOADING)
BookmarkFileHasGroupMethodInfo ,
#endif
bookmarkFileHasGroup ,
#if defined(ENABLE_OVERLOADING)
BookmarkFileHasItemMethodInfo ,
#endif
bookmarkFileHasItem ,
#if defined(ENABLE_OVERLOADING)
BookmarkFileLoadFromDataMethodInfo ,
#endif
bookmarkFileLoadFromData ,
#if defined(ENABLE_OVERLOADING)
BookmarkFileLoadFromDataDirsMethodInfo ,
#endif
bookmarkFileLoadFromDataDirs ,
#if defined(ENABLE_OVERLOADING)
BookmarkFileLoadFromFileMethodInfo ,
#endif
bookmarkFileLoadFromFile ,
#if defined(ENABLE_OVERLOADING)
BookmarkFileMoveItemMethodInfo ,
#endif
bookmarkFileMoveItem ,
bookmarkFileNew ,
#if defined(ENABLE_OVERLOADING)
BookmarkFileRemoveApplicationMethodInfo ,
#endif
bookmarkFileRemoveApplication ,
#if defined(ENABLE_OVERLOADING)
BookmarkFileRemoveGroupMethodInfo ,
#endif
bookmarkFileRemoveGroup ,
#if defined(ENABLE_OVERLOADING)
BookmarkFileRemoveItemMethodInfo ,
#endif
bookmarkFileRemoveItem ,
#if defined(ENABLE_OVERLOADING)
BookmarkFileSetAddedMethodInfo ,
#endif
bookmarkFileSetAdded ,
#if defined(ENABLE_OVERLOADING)
BookmarkFileSetAddedDateTimeMethodInfo ,
#endif
bookmarkFileSetAddedDateTime ,
#if defined(ENABLE_OVERLOADING)
BookmarkFileSetAppInfoMethodInfo ,
#endif
bookmarkFileSetAppInfo ,
#if defined(ENABLE_OVERLOADING)
BookmarkFileSetApplicationInfoMethodInfo,
#endif
bookmarkFileSetApplicationInfo ,
#if defined(ENABLE_OVERLOADING)
BookmarkFileSetDescriptionMethodInfo ,
#endif
bookmarkFileSetDescription ,
#if defined(ENABLE_OVERLOADING)
BookmarkFileSetGroupsMethodInfo ,
#endif
bookmarkFileSetGroups ,
#if defined(ENABLE_OVERLOADING)
BookmarkFileSetIconMethodInfo ,
#endif
bookmarkFileSetIcon ,
#if defined(ENABLE_OVERLOADING)
BookmarkFileSetIsPrivateMethodInfo ,
#endif
bookmarkFileSetIsPrivate ,
#if defined(ENABLE_OVERLOADING)
BookmarkFileSetMimeTypeMethodInfo ,
#endif
bookmarkFileSetMimeType ,
#if defined(ENABLE_OVERLOADING)
BookmarkFileSetModifiedMethodInfo ,
#endif
bookmarkFileSetModified ,
#if defined(ENABLE_OVERLOADING)
BookmarkFileSetModifiedDateTimeMethodInfo,
#endif
bookmarkFileSetModifiedDateTime ,
#if defined(ENABLE_OVERLOADING)
BookmarkFileSetTitleMethodInfo ,
#endif
bookmarkFileSetTitle ,
#if defined(ENABLE_OVERLOADING)
BookmarkFileSetVisitedMethodInfo ,
#endif
bookmarkFileSetVisited ,
#if defined(ENABLE_OVERLOADING)
BookmarkFileSetVisitedDateTimeMethodInfo,
#endif
bookmarkFileSetVisitedDateTime ,
#if defined(ENABLE_OVERLOADING)
BookmarkFileToDataMethodInfo ,
#endif
bookmarkFileToData ,
#if defined(ENABLE_OVERLOADING)
BookmarkFileToFileMethodInfo ,
#endif
bookmarkFileToFile ,
) 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.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
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.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.Kind as DK
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 GHC.Records as R
import qualified Data.Word as DW
import qualified Data.Int as DI
import qualified Data.Bits as DB
import qualified System.Posix.Types as SPT
import qualified Foreign.C.Types as FCT
#if MIN_VERSION_base(4,18,0)
import {-# SOURCE #-} qualified GI.GLib.Enums as GLib.Enums
import {-# SOURCE #-} qualified GI.GLib.Structs.DateTime as GLib.DateTime
import {-# SOURCE #-} qualified GI.GLib.Structs.TimeVal as GLib.TimeVal
import {-# SOURCE #-} qualified GI.GLib.Structs.TimeZone as GLib.TimeZone
#else
import {-# SOURCE #-} qualified GI.GLib.Structs.DateTime as GLib.DateTime
#endif
newtype BookmarkFile = BookmarkFile (SP.ManagedPtr BookmarkFile)
deriving (BookmarkFile -> BookmarkFile -> Bool
(BookmarkFile -> BookmarkFile -> Bool)
-> (BookmarkFile -> BookmarkFile -> Bool) -> Eq BookmarkFile
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BookmarkFile -> BookmarkFile -> Bool
== :: BookmarkFile -> BookmarkFile -> Bool
$c/= :: BookmarkFile -> BookmarkFile -> Bool
/= :: BookmarkFile -> BookmarkFile -> Bool
Eq)
instance SP.ManagedPtrNewtype BookmarkFile where
toManagedPtr :: BookmarkFile -> ManagedPtr BookmarkFile
toManagedPtr (BookmarkFile ManagedPtr BookmarkFile
p) = ManagedPtr BookmarkFile
p
foreign import ccall "g_bookmark_file_get_type" c_g_bookmark_file_get_type ::
IO GType
type instance O.ParentTypes BookmarkFile = '[]
instance O.HasParentTypes BookmarkFile
instance B.Types.TypedObject BookmarkFile where
glibType :: IO GType
glibType = IO GType
c_g_bookmark_file_get_type
instance B.Types.GBoxed BookmarkFile
instance B.GValue.IsGValue (Maybe BookmarkFile) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_g_bookmark_file_get_type
gvalueSet_ :: Ptr GValue -> Maybe BookmarkFile -> IO ()
gvalueSet_ Ptr GValue
gv Maybe BookmarkFile
P.Nothing = Ptr GValue -> Ptr BookmarkFile -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (Ptr BookmarkFile
forall a. Ptr a
FP.nullPtr :: FP.Ptr BookmarkFile)
gvalueSet_ Ptr GValue
gv (P.Just BookmarkFile
obj) = BookmarkFile -> (Ptr BookmarkFile -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr BookmarkFile
obj (Ptr GValue -> Ptr BookmarkFile -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe BookmarkFile)
gvalueGet_ Ptr GValue
gv = do
ptr <- Ptr GValue -> IO (Ptr BookmarkFile)
forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr BookmarkFile)
if ptr /= FP.nullPtr
then P.Just <$> B.ManagedPtr.newBoxed BookmarkFile ptr
else return P.Nothing
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList BookmarkFile
type instance O.AttributeList BookmarkFile = BookmarkFileAttributeList
type BookmarkFileAttributeList = ('[ ] :: [(Symbol, DK.Type)])
#endif
foreign import ccall "g_bookmark_file_new" g_bookmark_file_new ::
IO (Ptr BookmarkFile)
bookmarkFileNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
m BookmarkFile
bookmarkFileNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m BookmarkFile
bookmarkFileNew = IO BookmarkFile -> m BookmarkFile
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO BookmarkFile -> m BookmarkFile)
-> IO BookmarkFile -> m BookmarkFile
forall a b. (a -> b) -> a -> b
$ do
result <- IO (Ptr BookmarkFile)
g_bookmark_file_new
checkUnexpectedReturnNULL "bookmarkFileNew" result
result' <- (wrapBoxed BookmarkFile) result
return result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_bookmark_file_add_application" g_bookmark_file_add_application ::
Ptr BookmarkFile ->
CString ->
CString ->
CString ->
IO ()
bookmarkFileAddApplication ::
(B.CallStack.HasCallStack, MonadIO m) =>
BookmarkFile
-> T.Text
-> Maybe (T.Text)
-> Maybe (T.Text)
-> m ()
bookmarkFileAddApplication :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> Maybe Text -> Maybe Text -> m ()
bookmarkFileAddApplication BookmarkFile
bookmark Text
uri Maybe Text
name Maybe Text
exec = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
uri' <- textToCString uri
maybeName <- case name of
Maybe Text
Nothing -> CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
FP.nullPtr
Just Text
jName -> do
jName' <- Text -> IO CString
textToCString Text
jName
return jName'
maybeExec <- case exec of
Maybe Text
Nothing -> CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
FP.nullPtr
Just Text
jExec -> do
jExec' <- Text -> IO CString
textToCString Text
jExec
return jExec'
g_bookmark_file_add_application bookmark' uri' maybeName maybeExec
touchManagedPtr bookmark
freeMem uri'
freeMem maybeName
freeMem maybeExec
return ()
#if defined(ENABLE_OVERLOADING)
data BookmarkFileAddApplicationMethodInfo
instance (signature ~ (T.Text -> Maybe (T.Text) -> Maybe (T.Text) -> m ()), MonadIO m) => O.OverloadedMethod BookmarkFileAddApplicationMethodInfo BookmarkFile signature where
overloadedMethod :: BookmarkFile -> signature
overloadedMethod = BookmarkFile -> signature
BookmarkFile -> Text -> Maybe Text -> Maybe Text -> m ()
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> Maybe Text -> Maybe Text -> m ()
bookmarkFileAddApplication
instance O.OverloadedMethodInfo BookmarkFileAddApplicationMethodInfo BookmarkFile where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.BookmarkFile.bookmarkFileAddApplication",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-BookmarkFile.html#v:bookmarkFileAddApplication"
})
#endif
foreign import ccall "g_bookmark_file_add_group" g_bookmark_file_add_group ::
Ptr BookmarkFile ->
CString ->
CString ->
IO ()
bookmarkFileAddGroup ::
(B.CallStack.HasCallStack, MonadIO m) =>
BookmarkFile
-> T.Text
-> T.Text
-> m ()
bookmarkFileAddGroup :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> Text -> m ()
bookmarkFileAddGroup BookmarkFile
bookmark Text
uri Text
group = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
uri' <- textToCString uri
group' <- textToCString group
g_bookmark_file_add_group bookmark' uri' group'
touchManagedPtr bookmark
freeMem uri'
freeMem group'
return ()
#if defined(ENABLE_OVERLOADING)
data BookmarkFileAddGroupMethodInfo
instance (signature ~ (T.Text -> T.Text -> m ()), MonadIO m) => O.OverloadedMethod BookmarkFileAddGroupMethodInfo BookmarkFile signature where
overloadedMethod :: BookmarkFile -> signature
overloadedMethod = BookmarkFile -> signature
BookmarkFile -> Text -> Text -> m ()
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> Text -> m ()
bookmarkFileAddGroup
instance O.OverloadedMethodInfo BookmarkFileAddGroupMethodInfo BookmarkFile where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.BookmarkFile.bookmarkFileAddGroup",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-BookmarkFile.html#v:bookmarkFileAddGroup"
})
#endif
foreign import ccall "g_bookmark_file_copy" g_bookmark_file_copy ::
Ptr BookmarkFile ->
IO (Ptr BookmarkFile)
bookmarkFileCopy ::
(B.CallStack.HasCallStack, MonadIO m) =>
BookmarkFile
-> m BookmarkFile
bookmarkFileCopy :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> m BookmarkFile
bookmarkFileCopy BookmarkFile
bookmark = IO BookmarkFile -> m BookmarkFile
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO BookmarkFile -> m BookmarkFile)
-> IO BookmarkFile -> m BookmarkFile
forall a b. (a -> b) -> a -> b
$ do
bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
result <- g_bookmark_file_copy bookmark'
checkUnexpectedReturnNULL "bookmarkFileCopy" result
result' <- (wrapBoxed BookmarkFile) result
touchManagedPtr bookmark
return result'
#if defined(ENABLE_OVERLOADING)
data BookmarkFileCopyMethodInfo
instance (signature ~ (m BookmarkFile), MonadIO m) => O.OverloadedMethod BookmarkFileCopyMethodInfo BookmarkFile signature where
overloadedMethod :: BookmarkFile -> signature
overloadedMethod = BookmarkFile -> signature
BookmarkFile -> m BookmarkFile
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> m BookmarkFile
bookmarkFileCopy
instance O.OverloadedMethodInfo BookmarkFileCopyMethodInfo BookmarkFile where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.BookmarkFile.bookmarkFileCopy",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-BookmarkFile.html#v:bookmarkFileCopy"
})
#endif
foreign import ccall "g_bookmark_file_free" g_bookmark_file_free ::
Ptr BookmarkFile ->
IO ()
bookmarkFileFree ::
(B.CallStack.HasCallStack, MonadIO m) =>
BookmarkFile
-> m ()
bookmarkFileFree :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> m ()
bookmarkFileFree BookmarkFile
bookmark = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
g_bookmark_file_free bookmark'
touchManagedPtr bookmark
return ()
#if defined(ENABLE_OVERLOADING)
data BookmarkFileFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod BookmarkFileFreeMethodInfo BookmarkFile signature where
overloadedMethod :: BookmarkFile -> signature
overloadedMethod = BookmarkFile -> signature
BookmarkFile -> m ()
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> m ()
bookmarkFileFree
instance O.OverloadedMethodInfo BookmarkFileFreeMethodInfo BookmarkFile where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.BookmarkFile.bookmarkFileFree",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-BookmarkFile.html#v:bookmarkFileFree"
})
#endif
foreign import ccall "g_bookmark_file_get_added" g_bookmark_file_get_added ::
Ptr BookmarkFile ->
CString ->
Ptr (Ptr GError) ->
IO FCT.CTime
{-# DEPRECATED bookmarkFileGetAdded ["(Since version 2.66)","Use 'GI.GLib.Structs.BookmarkFile.bookmarkFileGetAddedDateTime' instead, as"," @time_t@ is deprecated due to the year 2038 problem."] #-}
bookmarkFileGetAdded ::
(B.CallStack.HasCallStack, MonadIO m) =>
BookmarkFile
-> T.Text
-> m FCT.CTime
bookmarkFileGetAdded :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> m CTime
bookmarkFileGetAdded BookmarkFile
bookmark Text
uri = IO CTime -> m CTime
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CTime -> m CTime) -> IO CTime -> m CTime
forall a b. (a -> b) -> a -> b
$ do
bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
uri' <- textToCString uri
onException (do
result <- propagateGError $ g_bookmark_file_get_added bookmark' uri'
touchManagedPtr bookmark
freeMem uri'
return result
) (do
freeMem uri'
)
#if defined(ENABLE_OVERLOADING)
data BookmarkFileGetAddedMethodInfo
instance (signature ~ (T.Text -> m FCT.CTime), MonadIO m) => O.OverloadedMethod BookmarkFileGetAddedMethodInfo BookmarkFile signature where
overloadedMethod :: BookmarkFile -> signature
overloadedMethod = BookmarkFile -> signature
BookmarkFile -> Text -> m CTime
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> m CTime
bookmarkFileGetAdded
instance O.OverloadedMethodInfo BookmarkFileGetAddedMethodInfo BookmarkFile where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.BookmarkFile.bookmarkFileGetAdded",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-BookmarkFile.html#v:bookmarkFileGetAdded"
})
#endif
foreign import ccall "g_bookmark_file_get_added_date_time" g_bookmark_file_get_added_date_time ::
Ptr BookmarkFile ->
CString ->
Ptr (Ptr GError) ->
IO (Ptr GLib.DateTime.DateTime)
bookmarkFileGetAddedDateTime ::
(B.CallStack.HasCallStack, MonadIO m) =>
BookmarkFile
-> T.Text
-> m GLib.DateTime.DateTime
bookmarkFileGetAddedDateTime :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> m DateTime
bookmarkFileGetAddedDateTime BookmarkFile
bookmark Text
uri = IO DateTime -> m DateTime
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DateTime -> m DateTime) -> IO DateTime -> m DateTime
forall a b. (a -> b) -> a -> b
$ do
bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
uri' <- textToCString uri
onException (do
result <- propagateGError $ g_bookmark_file_get_added_date_time bookmark' uri'
checkUnexpectedReturnNULL "bookmarkFileGetAddedDateTime" result
result' <- (newBoxed GLib.DateTime.DateTime) result
touchManagedPtr bookmark
freeMem uri'
return result'
) (do
freeMem uri'
)
#if defined(ENABLE_OVERLOADING)
data BookmarkFileGetAddedDateTimeMethodInfo
instance (signature ~ (T.Text -> m GLib.DateTime.DateTime), MonadIO m) => O.OverloadedMethod BookmarkFileGetAddedDateTimeMethodInfo BookmarkFile signature where
overloadedMethod :: BookmarkFile -> signature
overloadedMethod = BookmarkFile -> signature
BookmarkFile -> Text -> m DateTime
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> m DateTime
bookmarkFileGetAddedDateTime
instance O.OverloadedMethodInfo BookmarkFileGetAddedDateTimeMethodInfo BookmarkFile where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.BookmarkFile.bookmarkFileGetAddedDateTime",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-BookmarkFile.html#v:bookmarkFileGetAddedDateTime"
})
#endif
foreign import ccall "g_bookmark_file_get_app_info" g_bookmark_file_get_app_info ::
Ptr BookmarkFile ->
CString ->
CString ->
Ptr CString ->
Ptr Word32 ->
Ptr FCT.CTime ->
Ptr (Ptr GError) ->
IO CInt
{-# DEPRECATED bookmarkFileGetAppInfo ["(Since version 2.66)","Use 'GI.GLib.Structs.BookmarkFile.bookmarkFileGetApplicationInfo' instead, as"," @time_t@ is deprecated due to the year 2038 problem."] #-}
bookmarkFileGetAppInfo ::
(B.CallStack.HasCallStack, MonadIO m) =>
BookmarkFile
-> T.Text
-> T.Text
-> m ((T.Text, Word32, FCT.CTime))
bookmarkFileGetAppInfo :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> Text -> m (Text, Word32, CTime)
bookmarkFileGetAppInfo BookmarkFile
bookmark Text
uri Text
name = IO (Text, Word32, CTime) -> m (Text, Word32, CTime)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Text, Word32, CTime) -> m (Text, Word32, CTime))
-> IO (Text, Word32, CTime) -> m (Text, Word32, CTime)
forall a b. (a -> b) -> a -> b
$ do
bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
uri' <- textToCString uri
name' <- textToCString name
exec <- callocMem :: IO (Ptr CString)
count <- allocMem :: IO (Ptr Word32)
stamp <- allocMem :: IO (Ptr FCT.CTime)
onException (do
_ <- propagateGError $ g_bookmark_file_get_app_info bookmark' uri' name' exec count stamp
exec' <- peek exec
exec'' <- cstringToText exec'
freeMem exec'
count' <- peek count
stamp' <- peek stamp
touchManagedPtr bookmark
freeMem uri'
freeMem name'
freeMem exec
freeMem count
freeMem stamp
return (exec'', count', stamp')
) (do
freeMem uri'
freeMem name'
freeMem exec
freeMem count
freeMem stamp
)
#if defined(ENABLE_OVERLOADING)
data BookmarkFileGetAppInfoMethodInfo
instance (signature ~ (T.Text -> T.Text -> m ((T.Text, Word32, FCT.CTime))), MonadIO m) => O.OverloadedMethod BookmarkFileGetAppInfoMethodInfo BookmarkFile signature where
overloadedMethod :: BookmarkFile -> signature
overloadedMethod = BookmarkFile -> signature
BookmarkFile -> Text -> Text -> m (Text, Word32, CTime)
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> Text -> m (Text, Word32, CTime)
bookmarkFileGetAppInfo
instance O.OverloadedMethodInfo BookmarkFileGetAppInfoMethodInfo BookmarkFile where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.BookmarkFile.bookmarkFileGetAppInfo",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-BookmarkFile.html#v:bookmarkFileGetAppInfo"
})
#endif
foreign import ccall "g_bookmark_file_get_application_info" g_bookmark_file_get_application_info ::
Ptr BookmarkFile ->
CString ->
CString ->
Ptr CString ->
Ptr Word32 ->
Ptr (Ptr GLib.DateTime.DateTime) ->
Ptr (Ptr GError) ->
IO CInt
bookmarkFileGetApplicationInfo ::
(B.CallStack.HasCallStack, MonadIO m) =>
BookmarkFile
-> T.Text
-> T.Text
-> m ((T.Text, Word32, GLib.DateTime.DateTime))
bookmarkFileGetApplicationInfo :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> Text -> m (Text, Word32, DateTime)
bookmarkFileGetApplicationInfo BookmarkFile
bookmark Text
uri Text
name = IO (Text, Word32, DateTime) -> m (Text, Word32, DateTime)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Text, Word32, DateTime) -> m (Text, Word32, DateTime))
-> IO (Text, Word32, DateTime) -> m (Text, Word32, DateTime)
forall a b. (a -> b) -> a -> b
$ do
bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
uri' <- textToCString uri
name' <- textToCString name
exec <- callocMem :: IO (Ptr CString)
count <- allocMem :: IO (Ptr Word32)
stamp <- callocMem :: IO (Ptr (Ptr GLib.DateTime.DateTime))
onException (do
_ <- propagateGError $ g_bookmark_file_get_application_info bookmark' uri' name' exec count stamp
exec' <- peek exec
exec'' <- cstringToText exec'
freeMem exec'
count' <- peek count
stamp' <- peek stamp
stamp'' <- (newBoxed GLib.DateTime.DateTime) stamp'
touchManagedPtr bookmark
freeMem uri'
freeMem name'
freeMem exec
freeMem count
freeMem stamp
return (exec'', count', stamp'')
) (do
freeMem uri'
freeMem name'
freeMem exec
freeMem count
freeMem stamp
)
#if defined(ENABLE_OVERLOADING)
data BookmarkFileGetApplicationInfoMethodInfo
instance (signature ~ (T.Text -> T.Text -> m ((T.Text, Word32, GLib.DateTime.DateTime))), MonadIO m) => O.OverloadedMethod BookmarkFileGetApplicationInfoMethodInfo BookmarkFile signature where
overloadedMethod :: BookmarkFile -> signature
overloadedMethod = BookmarkFile -> signature
BookmarkFile -> Text -> Text -> m (Text, Word32, DateTime)
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> Text -> m (Text, Word32, DateTime)
bookmarkFileGetApplicationInfo
instance O.OverloadedMethodInfo BookmarkFileGetApplicationInfoMethodInfo BookmarkFile where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.BookmarkFile.bookmarkFileGetApplicationInfo",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-BookmarkFile.html#v:bookmarkFileGetApplicationInfo"
})
#endif
foreign import ccall "g_bookmark_file_get_applications" g_bookmark_file_get_applications ::
Ptr BookmarkFile ->
CString ->
Ptr FCT.CSize ->
Ptr (Ptr GError) ->
IO (Ptr CString)
bookmarkFileGetApplications ::
(B.CallStack.HasCallStack, MonadIO m) =>
BookmarkFile
-> T.Text
-> m [T.Text]
bookmarkFileGetApplications :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> m [Text]
bookmarkFileGetApplications BookmarkFile
bookmark Text
uri = IO [Text] -> m [Text]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [Text] -> m [Text]) -> IO [Text] -> m [Text]
forall a b. (a -> b) -> a -> b
$ do
bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
uri' <- textToCString uri
length_ <- allocMem :: IO (Ptr FCT.CSize)
onException (do
result <- propagateGError $ g_bookmark_file_get_applications bookmark' uri' length_
length_' <- peek length_
checkUnexpectedReturnNULL "bookmarkFileGetApplications" result
result' <- (unpackUTF8CArrayWithLength length_') result
(mapCArrayWithLength length_') freeMem result
freeMem result
touchManagedPtr bookmark
freeMem uri'
freeMem length_
return result'
) (do
freeMem uri'
freeMem length_
)
#if defined(ENABLE_OVERLOADING)
data BookmarkFileGetApplicationsMethodInfo
instance (signature ~ (T.Text -> m [T.Text]), MonadIO m) => O.OverloadedMethod BookmarkFileGetApplicationsMethodInfo BookmarkFile signature where
overloadedMethod :: BookmarkFile -> signature
overloadedMethod = BookmarkFile -> signature
BookmarkFile -> Text -> m [Text]
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> m [Text]
bookmarkFileGetApplications
instance O.OverloadedMethodInfo BookmarkFileGetApplicationsMethodInfo BookmarkFile where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.BookmarkFile.bookmarkFileGetApplications",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-BookmarkFile.html#v:bookmarkFileGetApplications"
})
#endif
foreign import ccall "g_bookmark_file_get_description" g_bookmark_file_get_description ::
Ptr BookmarkFile ->
CString ->
Ptr (Ptr GError) ->
IO CString
bookmarkFileGetDescription ::
(B.CallStack.HasCallStack, MonadIO m) =>
BookmarkFile
-> T.Text
-> m T.Text
bookmarkFileGetDescription :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> m Text
bookmarkFileGetDescription BookmarkFile
bookmark Text
uri = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
uri' <- textToCString uri
onException (do
result <- propagateGError $ g_bookmark_file_get_description bookmark' uri'
checkUnexpectedReturnNULL "bookmarkFileGetDescription" result
result' <- cstringToText result
freeMem result
touchManagedPtr bookmark
freeMem uri'
return result'
) (do
freeMem uri'
)
#if defined(ENABLE_OVERLOADING)
data BookmarkFileGetDescriptionMethodInfo
instance (signature ~ (T.Text -> m T.Text), MonadIO m) => O.OverloadedMethod BookmarkFileGetDescriptionMethodInfo BookmarkFile signature where
overloadedMethod :: BookmarkFile -> signature
overloadedMethod = BookmarkFile -> signature
BookmarkFile -> Text -> m Text
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> m Text
bookmarkFileGetDescription
instance O.OverloadedMethodInfo BookmarkFileGetDescriptionMethodInfo BookmarkFile where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.BookmarkFile.bookmarkFileGetDescription",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-BookmarkFile.html#v:bookmarkFileGetDescription"
})
#endif
foreign import ccall "g_bookmark_file_get_groups" g_bookmark_file_get_groups ::
Ptr BookmarkFile ->
CString ->
Ptr FCT.CSize ->
Ptr (Ptr GError) ->
IO (Ptr CString)
bookmarkFileGetGroups ::
(B.CallStack.HasCallStack, MonadIO m) =>
BookmarkFile
-> T.Text
-> m [T.Text]
bookmarkFileGetGroups :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> m [Text]
bookmarkFileGetGroups BookmarkFile
bookmark Text
uri = IO [Text] -> m [Text]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [Text] -> m [Text]) -> IO [Text] -> m [Text]
forall a b. (a -> b) -> a -> b
$ do
bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
uri' <- textToCString uri
length_ <- allocMem :: IO (Ptr FCT.CSize)
onException (do
result <- propagateGError $ g_bookmark_file_get_groups bookmark' uri' length_
length_' <- peek length_
checkUnexpectedReturnNULL "bookmarkFileGetGroups" result
result' <- (unpackUTF8CArrayWithLength length_') result
(mapCArrayWithLength length_') freeMem result
freeMem result
touchManagedPtr bookmark
freeMem uri'
freeMem length_
return result'
) (do
freeMem uri'
freeMem length_
)
#if defined(ENABLE_OVERLOADING)
data BookmarkFileGetGroupsMethodInfo
instance (signature ~ (T.Text -> m [T.Text]), MonadIO m) => O.OverloadedMethod BookmarkFileGetGroupsMethodInfo BookmarkFile signature where
overloadedMethod :: BookmarkFile -> signature
overloadedMethod = BookmarkFile -> signature
BookmarkFile -> Text -> m [Text]
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> m [Text]
bookmarkFileGetGroups
instance O.OverloadedMethodInfo BookmarkFileGetGroupsMethodInfo BookmarkFile where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.BookmarkFile.bookmarkFileGetGroups",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-BookmarkFile.html#v:bookmarkFileGetGroups"
})
#endif
foreign import ccall "g_bookmark_file_get_icon" g_bookmark_file_get_icon ::
Ptr BookmarkFile ->
CString ->
Ptr CString ->
Ptr CString ->
Ptr (Ptr GError) ->
IO CInt
bookmarkFileGetIcon ::
(B.CallStack.HasCallStack, MonadIO m) =>
BookmarkFile
-> T.Text
-> m ((T.Text, T.Text))
bookmarkFileGetIcon :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> m (Text, Text)
bookmarkFileGetIcon BookmarkFile
bookmark Text
uri = IO (Text, Text) -> m (Text, Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Text, Text) -> m (Text, Text))
-> IO (Text, Text) -> m (Text, Text)
forall a b. (a -> b) -> a -> b
$ do
bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
uri' <- textToCString uri
href <- callocMem :: IO (Ptr CString)
mimeType <- callocMem :: IO (Ptr CString)
onException (do
_ <- propagateGError $ g_bookmark_file_get_icon bookmark' uri' href mimeType
href' <- peek href
href'' <- cstringToText href'
freeMem href'
mimeType' <- peek mimeType
mimeType'' <- cstringToText mimeType'
freeMem mimeType'
touchManagedPtr bookmark
freeMem uri'
freeMem href
freeMem mimeType
return (href'', mimeType'')
) (do
freeMem uri'
freeMem href
freeMem mimeType
)
#if defined(ENABLE_OVERLOADING)
data BookmarkFileGetIconMethodInfo
instance (signature ~ (T.Text -> m ((T.Text, T.Text))), MonadIO m) => O.OverloadedMethod BookmarkFileGetIconMethodInfo BookmarkFile signature where
overloadedMethod :: BookmarkFile -> signature
overloadedMethod = BookmarkFile -> signature
BookmarkFile -> Text -> m (Text, Text)
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> m (Text, Text)
bookmarkFileGetIcon
instance O.OverloadedMethodInfo BookmarkFileGetIconMethodInfo BookmarkFile where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.BookmarkFile.bookmarkFileGetIcon",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-BookmarkFile.html#v:bookmarkFileGetIcon"
})
#endif
foreign import ccall "g_bookmark_file_get_is_private" g_bookmark_file_get_is_private ::
Ptr BookmarkFile ->
CString ->
Ptr (Ptr GError) ->
IO CInt
bookmarkFileGetIsPrivate ::
(B.CallStack.HasCallStack, MonadIO m) =>
BookmarkFile
-> T.Text
-> m ()
bookmarkFileGetIsPrivate :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> m ()
bookmarkFileGetIsPrivate BookmarkFile
bookmark Text
uri = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
uri' <- textToCString uri
onException (do
_ <- propagateGError $ g_bookmark_file_get_is_private bookmark' uri'
touchManagedPtr bookmark
freeMem uri'
return ()
) (do
freeMem uri'
)
#if defined(ENABLE_OVERLOADING)
data BookmarkFileGetIsPrivateMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m) => O.OverloadedMethod BookmarkFileGetIsPrivateMethodInfo BookmarkFile signature where
overloadedMethod :: BookmarkFile -> signature
overloadedMethod = BookmarkFile -> signature
BookmarkFile -> Text -> m ()
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> m ()
bookmarkFileGetIsPrivate
instance O.OverloadedMethodInfo BookmarkFileGetIsPrivateMethodInfo BookmarkFile where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.BookmarkFile.bookmarkFileGetIsPrivate",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-BookmarkFile.html#v:bookmarkFileGetIsPrivate"
})
#endif
foreign import ccall "g_bookmark_file_get_mime_type" g_bookmark_file_get_mime_type ::
Ptr BookmarkFile ->
CString ->
Ptr (Ptr GError) ->
IO CString
bookmarkFileGetMimeType ::
(B.CallStack.HasCallStack, MonadIO m) =>
BookmarkFile
-> T.Text
-> m T.Text
bookmarkFileGetMimeType :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> m Text
bookmarkFileGetMimeType BookmarkFile
bookmark Text
uri = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
uri' <- textToCString uri
onException (do
result <- propagateGError $ g_bookmark_file_get_mime_type bookmark' uri'
checkUnexpectedReturnNULL "bookmarkFileGetMimeType" result
result' <- cstringToText result
freeMem result
touchManagedPtr bookmark
freeMem uri'
return result'
) (do
freeMem uri'
)
#if defined(ENABLE_OVERLOADING)
data BookmarkFileGetMimeTypeMethodInfo
instance (signature ~ (T.Text -> m T.Text), MonadIO m) => O.OverloadedMethod BookmarkFileGetMimeTypeMethodInfo BookmarkFile signature where
overloadedMethod :: BookmarkFile -> signature
overloadedMethod = BookmarkFile -> signature
BookmarkFile -> Text -> m Text
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> m Text
bookmarkFileGetMimeType
instance O.OverloadedMethodInfo BookmarkFileGetMimeTypeMethodInfo BookmarkFile where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.BookmarkFile.bookmarkFileGetMimeType",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-BookmarkFile.html#v:bookmarkFileGetMimeType"
})
#endif
foreign import ccall "g_bookmark_file_get_modified" g_bookmark_file_get_modified ::
Ptr BookmarkFile ->
CString ->
Ptr (Ptr GError) ->
IO FCT.CTime
{-# DEPRECATED bookmarkFileGetModified ["(Since version 2.66)","Use 'GI.GLib.Structs.BookmarkFile.bookmarkFileGetModifiedDateTime' instead, as"," @time_t@ is deprecated due to the year 2038 problem."] #-}
bookmarkFileGetModified ::
(B.CallStack.HasCallStack, MonadIO m) =>
BookmarkFile
-> T.Text
-> m FCT.CTime
bookmarkFileGetModified :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> m CTime
bookmarkFileGetModified BookmarkFile
bookmark Text
uri = IO CTime -> m CTime
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CTime -> m CTime) -> IO CTime -> m CTime
forall a b. (a -> b) -> a -> b
$ do
bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
uri' <- textToCString uri
onException (do
result <- propagateGError $ g_bookmark_file_get_modified bookmark' uri'
touchManagedPtr bookmark
freeMem uri'
return result
) (do
freeMem uri'
)
#if defined(ENABLE_OVERLOADING)
data BookmarkFileGetModifiedMethodInfo
instance (signature ~ (T.Text -> m FCT.CTime), MonadIO m) => O.OverloadedMethod BookmarkFileGetModifiedMethodInfo BookmarkFile signature where
overloadedMethod :: BookmarkFile -> signature
overloadedMethod = BookmarkFile -> signature
BookmarkFile -> Text -> m CTime
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> m CTime
bookmarkFileGetModified
instance O.OverloadedMethodInfo BookmarkFileGetModifiedMethodInfo BookmarkFile where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.BookmarkFile.bookmarkFileGetModified",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-BookmarkFile.html#v:bookmarkFileGetModified"
})
#endif
foreign import ccall "g_bookmark_file_get_modified_date_time" g_bookmark_file_get_modified_date_time ::
Ptr BookmarkFile ->
CString ->
Ptr (Ptr GError) ->
IO (Ptr GLib.DateTime.DateTime)
bookmarkFileGetModifiedDateTime ::
(B.CallStack.HasCallStack, MonadIO m) =>
BookmarkFile
-> T.Text
-> m GLib.DateTime.DateTime
bookmarkFileGetModifiedDateTime :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> m DateTime
bookmarkFileGetModifiedDateTime BookmarkFile
bookmark Text
uri = IO DateTime -> m DateTime
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DateTime -> m DateTime) -> IO DateTime -> m DateTime
forall a b. (a -> b) -> a -> b
$ do
bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
uri' <- textToCString uri
onException (do
result <- propagateGError $ g_bookmark_file_get_modified_date_time bookmark' uri'
checkUnexpectedReturnNULL "bookmarkFileGetModifiedDateTime" result
result' <- (newBoxed GLib.DateTime.DateTime) result
touchManagedPtr bookmark
freeMem uri'
return result'
) (do
freeMem uri'
)
#if defined(ENABLE_OVERLOADING)
data BookmarkFileGetModifiedDateTimeMethodInfo
instance (signature ~ (T.Text -> m GLib.DateTime.DateTime), MonadIO m) => O.OverloadedMethod BookmarkFileGetModifiedDateTimeMethodInfo BookmarkFile signature where
overloadedMethod :: BookmarkFile -> signature
overloadedMethod = BookmarkFile -> signature
BookmarkFile -> Text -> m DateTime
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> m DateTime
bookmarkFileGetModifiedDateTime
instance O.OverloadedMethodInfo BookmarkFileGetModifiedDateTimeMethodInfo BookmarkFile where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.BookmarkFile.bookmarkFileGetModifiedDateTime",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-BookmarkFile.html#v:bookmarkFileGetModifiedDateTime"
})
#endif
foreign import ccall "g_bookmark_file_get_size" g_bookmark_file_get_size ::
Ptr BookmarkFile ->
IO Int32
bookmarkFileGetSize ::
(B.CallStack.HasCallStack, MonadIO m) =>
BookmarkFile
-> m Int32
bookmarkFileGetSize :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> m Int32
bookmarkFileGetSize BookmarkFile
bookmark = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
result <- g_bookmark_file_get_size bookmark'
touchManagedPtr bookmark
return result
#if defined(ENABLE_OVERLOADING)
data BookmarkFileGetSizeMethodInfo
instance (signature ~ (m Int32), MonadIO m) => O.OverloadedMethod BookmarkFileGetSizeMethodInfo BookmarkFile signature where
overloadedMethod :: BookmarkFile -> signature
overloadedMethod = BookmarkFile -> signature
BookmarkFile -> m Int32
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> m Int32
bookmarkFileGetSize
instance O.OverloadedMethodInfo BookmarkFileGetSizeMethodInfo BookmarkFile where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.BookmarkFile.bookmarkFileGetSize",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-BookmarkFile.html#v:bookmarkFileGetSize"
})
#endif
foreign import ccall "g_bookmark_file_get_title" g_bookmark_file_get_title ::
Ptr BookmarkFile ->
CString ->
Ptr (Ptr GError) ->
IO CString
bookmarkFileGetTitle ::
(B.CallStack.HasCallStack, MonadIO m) =>
BookmarkFile
-> Maybe (T.Text)
-> m T.Text
bookmarkFileGetTitle :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Maybe Text -> m Text
bookmarkFileGetTitle BookmarkFile
bookmark Maybe Text
uri = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
maybeUri <- case uri of
Maybe Text
Nothing -> CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
FP.nullPtr
Just Text
jUri -> do
jUri' <- Text -> IO CString
textToCString Text
jUri
return jUri'
onException (do
result <- propagateGError $ g_bookmark_file_get_title bookmark' maybeUri
checkUnexpectedReturnNULL "bookmarkFileGetTitle" result
result' <- cstringToText result
freeMem result
touchManagedPtr bookmark
freeMem maybeUri
return result'
) (do
freeMem maybeUri
)
#if defined(ENABLE_OVERLOADING)
data BookmarkFileGetTitleMethodInfo
instance (signature ~ (Maybe (T.Text) -> m T.Text), MonadIO m) => O.OverloadedMethod BookmarkFileGetTitleMethodInfo BookmarkFile signature where
overloadedMethod :: BookmarkFile -> signature
overloadedMethod = BookmarkFile -> signature
BookmarkFile -> Maybe Text -> m Text
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Maybe Text -> m Text
bookmarkFileGetTitle
instance O.OverloadedMethodInfo BookmarkFileGetTitleMethodInfo BookmarkFile where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.BookmarkFile.bookmarkFileGetTitle",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-BookmarkFile.html#v:bookmarkFileGetTitle"
})
#endif
foreign import ccall "g_bookmark_file_get_uris" g_bookmark_file_get_uris ::
Ptr BookmarkFile ->
Ptr FCT.CSize ->
IO (Ptr CString)
bookmarkFileGetUris ::
(B.CallStack.HasCallStack, MonadIO m) =>
BookmarkFile
-> m [T.Text]
bookmarkFileGetUris :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> m [Text]
bookmarkFileGetUris BookmarkFile
bookmark = IO [Text] -> m [Text]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [Text] -> m [Text]) -> IO [Text] -> m [Text]
forall a b. (a -> b) -> a -> b
$ do
bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
length_ <- allocMem :: IO (Ptr FCT.CSize)
result <- g_bookmark_file_get_uris bookmark' length_
length_' <- peek length_
checkUnexpectedReturnNULL "bookmarkFileGetUris" result
result' <- (unpackUTF8CArrayWithLength length_') result
(mapCArrayWithLength length_') freeMem result
freeMem result
touchManagedPtr bookmark
freeMem length_
return result'
#if defined(ENABLE_OVERLOADING)
data BookmarkFileGetUrisMethodInfo
instance (signature ~ (m [T.Text]), MonadIO m) => O.OverloadedMethod BookmarkFileGetUrisMethodInfo BookmarkFile signature where
overloadedMethod :: BookmarkFile -> signature
overloadedMethod = BookmarkFile -> signature
BookmarkFile -> m [Text]
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> m [Text]
bookmarkFileGetUris
instance O.OverloadedMethodInfo BookmarkFileGetUrisMethodInfo BookmarkFile where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.BookmarkFile.bookmarkFileGetUris",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-BookmarkFile.html#v:bookmarkFileGetUris"
})
#endif
foreign import ccall "g_bookmark_file_get_visited" g_bookmark_file_get_visited ::
Ptr BookmarkFile ->
CString ->
Ptr (Ptr GError) ->
IO FCT.CTime
{-# DEPRECATED bookmarkFileGetVisited ["(Since version 2.66)","Use 'GI.GLib.Structs.BookmarkFile.bookmarkFileGetVisitedDateTime' instead, as"," @time_t@ is deprecated due to the year 2038 problem."] #-}
bookmarkFileGetVisited ::
(B.CallStack.HasCallStack, MonadIO m) =>
BookmarkFile
-> T.Text
-> m FCT.CTime
bookmarkFileGetVisited :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> m CTime
bookmarkFileGetVisited BookmarkFile
bookmark Text
uri = IO CTime -> m CTime
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CTime -> m CTime) -> IO CTime -> m CTime
forall a b. (a -> b) -> a -> b
$ do
bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
uri' <- textToCString uri
onException (do
result <- propagateGError $ g_bookmark_file_get_visited bookmark' uri'
touchManagedPtr bookmark
freeMem uri'
return result
) (do
freeMem uri'
)
#if defined(ENABLE_OVERLOADING)
data BookmarkFileGetVisitedMethodInfo
instance (signature ~ (T.Text -> m FCT.CTime), MonadIO m) => O.OverloadedMethod BookmarkFileGetVisitedMethodInfo BookmarkFile signature where
overloadedMethod :: BookmarkFile -> signature
overloadedMethod = BookmarkFile -> signature
BookmarkFile -> Text -> m CTime
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> m CTime
bookmarkFileGetVisited
instance O.OverloadedMethodInfo BookmarkFileGetVisitedMethodInfo BookmarkFile where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.BookmarkFile.bookmarkFileGetVisited",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-BookmarkFile.html#v:bookmarkFileGetVisited"
})
#endif
foreign import ccall "g_bookmark_file_get_visited_date_time" g_bookmark_file_get_visited_date_time ::
Ptr BookmarkFile ->
CString ->
Ptr (Ptr GError) ->
IO (Ptr GLib.DateTime.DateTime)
bookmarkFileGetVisitedDateTime ::
(B.CallStack.HasCallStack, MonadIO m) =>
BookmarkFile
-> T.Text
-> m GLib.DateTime.DateTime
bookmarkFileGetVisitedDateTime :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> m DateTime
bookmarkFileGetVisitedDateTime BookmarkFile
bookmark Text
uri = IO DateTime -> m DateTime
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DateTime -> m DateTime) -> IO DateTime -> m DateTime
forall a b. (a -> b) -> a -> b
$ do
bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
uri' <- textToCString uri
onException (do
result <- propagateGError $ g_bookmark_file_get_visited_date_time bookmark' uri'
checkUnexpectedReturnNULL "bookmarkFileGetVisitedDateTime" result
result' <- (newBoxed GLib.DateTime.DateTime) result
touchManagedPtr bookmark
freeMem uri'
return result'
) (do
freeMem uri'
)
#if defined(ENABLE_OVERLOADING)
data BookmarkFileGetVisitedDateTimeMethodInfo
instance (signature ~ (T.Text -> m GLib.DateTime.DateTime), MonadIO m) => O.OverloadedMethod BookmarkFileGetVisitedDateTimeMethodInfo BookmarkFile signature where
overloadedMethod :: BookmarkFile -> signature
overloadedMethod = BookmarkFile -> signature
BookmarkFile -> Text -> m DateTime
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> m DateTime
bookmarkFileGetVisitedDateTime
instance O.OverloadedMethodInfo BookmarkFileGetVisitedDateTimeMethodInfo BookmarkFile where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.BookmarkFile.bookmarkFileGetVisitedDateTime",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-BookmarkFile.html#v:bookmarkFileGetVisitedDateTime"
})
#endif
foreign import ccall "g_bookmark_file_has_application" g_bookmark_file_has_application ::
Ptr BookmarkFile ->
CString ->
CString ->
Ptr (Ptr GError) ->
IO CInt
bookmarkFileHasApplication ::
(B.CallStack.HasCallStack, MonadIO m) =>
BookmarkFile
-> T.Text
-> T.Text
-> m ()
bookmarkFileHasApplication :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> Text -> m ()
bookmarkFileHasApplication BookmarkFile
bookmark Text
uri Text
name = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
uri' <- textToCString uri
name' <- textToCString name
onException (do
_ <- propagateGError $ g_bookmark_file_has_application bookmark' uri' name'
touchManagedPtr bookmark
freeMem uri'
freeMem name'
return ()
) (do
freeMem uri'
freeMem name'
)
#if defined(ENABLE_OVERLOADING)
data BookmarkFileHasApplicationMethodInfo
instance (signature ~ (T.Text -> T.Text -> m ()), MonadIO m) => O.OverloadedMethod BookmarkFileHasApplicationMethodInfo BookmarkFile signature where
overloadedMethod :: BookmarkFile -> signature
overloadedMethod = BookmarkFile -> signature
BookmarkFile -> Text -> Text -> m ()
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> Text -> m ()
bookmarkFileHasApplication
instance O.OverloadedMethodInfo BookmarkFileHasApplicationMethodInfo BookmarkFile where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.BookmarkFile.bookmarkFileHasApplication",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-BookmarkFile.html#v:bookmarkFileHasApplication"
})
#endif
foreign import ccall "g_bookmark_file_has_group" g_bookmark_file_has_group ::
Ptr BookmarkFile ->
CString ->
CString ->
Ptr (Ptr GError) ->
IO CInt
bookmarkFileHasGroup ::
(B.CallStack.HasCallStack, MonadIO m) =>
BookmarkFile
-> T.Text
-> T.Text
-> m ()
bookmarkFileHasGroup :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> Text -> m ()
bookmarkFileHasGroup BookmarkFile
bookmark Text
uri Text
group = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
uri' <- textToCString uri
group' <- textToCString group
onException (do
_ <- propagateGError $ g_bookmark_file_has_group bookmark' uri' group'
touchManagedPtr bookmark
freeMem uri'
freeMem group'
return ()
) (do
freeMem uri'
freeMem group'
)
#if defined(ENABLE_OVERLOADING)
data BookmarkFileHasGroupMethodInfo
instance (signature ~ (T.Text -> T.Text -> m ()), MonadIO m) => O.OverloadedMethod BookmarkFileHasGroupMethodInfo BookmarkFile signature where
overloadedMethod :: BookmarkFile -> signature
overloadedMethod = BookmarkFile -> signature
BookmarkFile -> Text -> Text -> m ()
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> Text -> m ()
bookmarkFileHasGroup
instance O.OverloadedMethodInfo BookmarkFileHasGroupMethodInfo BookmarkFile where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.BookmarkFile.bookmarkFileHasGroup",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-BookmarkFile.html#v:bookmarkFileHasGroup"
})
#endif
foreign import ccall "g_bookmark_file_has_item" g_bookmark_file_has_item ::
Ptr BookmarkFile ->
CString ->
IO CInt
bookmarkFileHasItem ::
(B.CallStack.HasCallStack, MonadIO m) =>
BookmarkFile
-> T.Text
-> m Bool
bookmarkFileHasItem :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> m Bool
bookmarkFileHasItem BookmarkFile
bookmark Text
uri = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
uri' <- textToCString uri
result <- g_bookmark_file_has_item bookmark' uri'
let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
touchManagedPtr bookmark
freeMem uri'
return result'
#if defined(ENABLE_OVERLOADING)
data BookmarkFileHasItemMethodInfo
instance (signature ~ (T.Text -> m Bool), MonadIO m) => O.OverloadedMethod BookmarkFileHasItemMethodInfo BookmarkFile signature where
overloadedMethod :: BookmarkFile -> signature
overloadedMethod = BookmarkFile -> signature
BookmarkFile -> Text -> m Bool
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> m Bool
bookmarkFileHasItem
instance O.OverloadedMethodInfo BookmarkFileHasItemMethodInfo BookmarkFile where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.BookmarkFile.bookmarkFileHasItem",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-BookmarkFile.html#v:bookmarkFileHasItem"
})
#endif
foreign import ccall "g_bookmark_file_load_from_data" g_bookmark_file_load_from_data ::
Ptr BookmarkFile ->
Ptr Word8 ->
FCT.CSize ->
Ptr (Ptr GError) ->
IO CInt
bookmarkFileLoadFromData ::
(B.CallStack.HasCallStack, MonadIO m) =>
BookmarkFile
-> ByteString
-> m ()
bookmarkFileLoadFromData :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> ByteString -> m ()
bookmarkFileLoadFromData BookmarkFile
bookmark ByteString
data_ = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
let length_ :: CSize
length_ = Int -> CSize
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CSize) -> Int -> CSize
forall a b. (a -> b) -> a -> b
$ ByteString -> Int
B.length ByteString
data_
bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
data_' <- packByteString data_
onException (do
_ <- propagateGError $ g_bookmark_file_load_from_data bookmark' data_' length_
touchManagedPtr bookmark
freeMem data_'
return ()
) (do
freeMem data_'
)
#if defined(ENABLE_OVERLOADING)
data BookmarkFileLoadFromDataMethodInfo
instance (signature ~ (ByteString -> m ()), MonadIO m) => O.OverloadedMethod BookmarkFileLoadFromDataMethodInfo BookmarkFile signature where
overloadedMethod :: BookmarkFile -> signature
overloadedMethod = BookmarkFile -> signature
BookmarkFile -> ByteString -> m ()
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> ByteString -> m ()
bookmarkFileLoadFromData
instance O.OverloadedMethodInfo BookmarkFileLoadFromDataMethodInfo BookmarkFile where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.BookmarkFile.bookmarkFileLoadFromData",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-BookmarkFile.html#v:bookmarkFileLoadFromData"
})
#endif
foreign import ccall "g_bookmark_file_load_from_data_dirs" g_bookmark_file_load_from_data_dirs ::
Ptr BookmarkFile ->
CString ->
Ptr CString ->
Ptr (Ptr GError) ->
IO CInt
bookmarkFileLoadFromDataDirs ::
(B.CallStack.HasCallStack, MonadIO m) =>
BookmarkFile
-> [Char]
-> m ((Maybe [Char]))
bookmarkFileLoadFromDataDirs :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> String -> m (Maybe String)
bookmarkFileLoadFromDataDirs BookmarkFile
bookmark String
file = IO (Maybe String) -> m (Maybe String)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe String) -> m (Maybe String))
-> IO (Maybe String) -> m (Maybe String)
forall a b. (a -> b) -> a -> b
$ do
bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
file' <- stringToCString file
fullPath <- callocMem :: IO (Ptr CString)
onException (do
_ <- propagateGError $ g_bookmark_file_load_from_data_dirs bookmark' file' fullPath
fullPath' <- peek fullPath
maybeFullPath' <- convertIfNonNull fullPath' $ \CString
fullPath'' -> do
fullPath''' <- HasCallStack => CString -> IO String
CString -> IO String
cstringToString CString
fullPath''
return fullPath'''
freeMem fullPath'
touchManagedPtr bookmark
freeMem file'
freeMem fullPath
return maybeFullPath'
) (do
freeMem file'
freeMem fullPath
)
#if defined(ENABLE_OVERLOADING)
data BookmarkFileLoadFromDataDirsMethodInfo
instance (signature ~ ([Char] -> m ((Maybe [Char]))), MonadIO m) => O.OverloadedMethod BookmarkFileLoadFromDataDirsMethodInfo BookmarkFile signature where
overloadedMethod :: BookmarkFile -> signature
overloadedMethod = BookmarkFile -> signature
BookmarkFile -> String -> m (Maybe String)
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> String -> m (Maybe String)
bookmarkFileLoadFromDataDirs
instance O.OverloadedMethodInfo BookmarkFileLoadFromDataDirsMethodInfo BookmarkFile where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.BookmarkFile.bookmarkFileLoadFromDataDirs",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-BookmarkFile.html#v:bookmarkFileLoadFromDataDirs"
})
#endif
foreign import ccall "g_bookmark_file_load_from_file" g_bookmark_file_load_from_file ::
Ptr BookmarkFile ->
CString ->
Ptr (Ptr GError) ->
IO CInt
bookmarkFileLoadFromFile ::
(B.CallStack.HasCallStack, MonadIO m) =>
BookmarkFile
-> [Char]
-> m ()
bookmarkFileLoadFromFile :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> String -> m ()
bookmarkFileLoadFromFile BookmarkFile
bookmark String
filename = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
filename' <- stringToCString filename
onException (do
_ <- propagateGError $ g_bookmark_file_load_from_file bookmark' filename'
touchManagedPtr bookmark
freeMem filename'
return ()
) (do
freeMem filename'
)
#if defined(ENABLE_OVERLOADING)
data BookmarkFileLoadFromFileMethodInfo
instance (signature ~ ([Char] -> m ()), MonadIO m) => O.OverloadedMethod BookmarkFileLoadFromFileMethodInfo BookmarkFile signature where
overloadedMethod :: BookmarkFile -> signature
overloadedMethod = BookmarkFile -> signature
BookmarkFile -> String -> m ()
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> String -> m ()
bookmarkFileLoadFromFile
instance O.OverloadedMethodInfo BookmarkFileLoadFromFileMethodInfo BookmarkFile where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.BookmarkFile.bookmarkFileLoadFromFile",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-BookmarkFile.html#v:bookmarkFileLoadFromFile"
})
#endif
foreign import ccall "g_bookmark_file_move_item" g_bookmark_file_move_item ::
Ptr BookmarkFile ->
CString ->
CString ->
Ptr (Ptr GError) ->
IO CInt
bookmarkFileMoveItem ::
(B.CallStack.HasCallStack, MonadIO m) =>
BookmarkFile
-> T.Text
-> Maybe (T.Text)
-> m ()
bookmarkFileMoveItem :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> Maybe Text -> m ()
bookmarkFileMoveItem BookmarkFile
bookmark Text
oldUri Maybe Text
newUri = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
oldUri' <- textToCString oldUri
maybeNewUri <- case newUri of
Maybe Text
Nothing -> CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
FP.nullPtr
Just Text
jNewUri -> do
jNewUri' <- Text -> IO CString
textToCString Text
jNewUri
return jNewUri'
onException (do
_ <- propagateGError $ g_bookmark_file_move_item bookmark' oldUri' maybeNewUri
touchManagedPtr bookmark
freeMem oldUri'
freeMem maybeNewUri
return ()
) (do
freeMem oldUri'
freeMem maybeNewUri
)
#if defined(ENABLE_OVERLOADING)
data BookmarkFileMoveItemMethodInfo
instance (signature ~ (T.Text -> Maybe (T.Text) -> m ()), MonadIO m) => O.OverloadedMethod BookmarkFileMoveItemMethodInfo BookmarkFile signature where
overloadedMethod :: BookmarkFile -> signature
overloadedMethod = BookmarkFile -> signature
BookmarkFile -> Text -> Maybe Text -> m ()
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> Maybe Text -> m ()
bookmarkFileMoveItem
instance O.OverloadedMethodInfo BookmarkFileMoveItemMethodInfo BookmarkFile where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.BookmarkFile.bookmarkFileMoveItem",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-BookmarkFile.html#v:bookmarkFileMoveItem"
})
#endif
foreign import ccall "g_bookmark_file_remove_application" g_bookmark_file_remove_application ::
Ptr BookmarkFile ->
CString ->
CString ->
Ptr (Ptr GError) ->
IO CInt
bookmarkFileRemoveApplication ::
(B.CallStack.HasCallStack, MonadIO m) =>
BookmarkFile
-> T.Text
-> T.Text
-> m ()
bookmarkFileRemoveApplication :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> Text -> m ()
bookmarkFileRemoveApplication BookmarkFile
bookmark Text
uri Text
name = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
uri' <- textToCString uri
name' <- textToCString name
onException (do
_ <- propagateGError $ g_bookmark_file_remove_application bookmark' uri' name'
touchManagedPtr bookmark
freeMem uri'
freeMem name'
return ()
) (do
freeMem uri'
freeMem name'
)
#if defined(ENABLE_OVERLOADING)
data BookmarkFileRemoveApplicationMethodInfo
instance (signature ~ (T.Text -> T.Text -> m ()), MonadIO m) => O.OverloadedMethod BookmarkFileRemoveApplicationMethodInfo BookmarkFile signature where
overloadedMethod :: BookmarkFile -> signature
overloadedMethod = BookmarkFile -> signature
BookmarkFile -> Text -> Text -> m ()
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> Text -> m ()
bookmarkFileRemoveApplication
instance O.OverloadedMethodInfo BookmarkFileRemoveApplicationMethodInfo BookmarkFile where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.BookmarkFile.bookmarkFileRemoveApplication",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-BookmarkFile.html#v:bookmarkFileRemoveApplication"
})
#endif
foreign import ccall "g_bookmark_file_remove_group" g_bookmark_file_remove_group ::
Ptr BookmarkFile ->
CString ->
CString ->
Ptr (Ptr GError) ->
IO CInt
bookmarkFileRemoveGroup ::
(B.CallStack.HasCallStack, MonadIO m) =>
BookmarkFile
-> T.Text
-> T.Text
-> m ()
bookmarkFileRemoveGroup :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> Text -> m ()
bookmarkFileRemoveGroup BookmarkFile
bookmark Text
uri Text
group = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
uri' <- textToCString uri
group' <- textToCString group
onException (do
_ <- propagateGError $ g_bookmark_file_remove_group bookmark' uri' group'
touchManagedPtr bookmark
freeMem uri'
freeMem group'
return ()
) (do
freeMem uri'
freeMem group'
)
#if defined(ENABLE_OVERLOADING)
data BookmarkFileRemoveGroupMethodInfo
instance (signature ~ (T.Text -> T.Text -> m ()), MonadIO m) => O.OverloadedMethod BookmarkFileRemoveGroupMethodInfo BookmarkFile signature where
overloadedMethod :: BookmarkFile -> signature
overloadedMethod = BookmarkFile -> signature
BookmarkFile -> Text -> Text -> m ()
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> Text -> m ()
bookmarkFileRemoveGroup
instance O.OverloadedMethodInfo BookmarkFileRemoveGroupMethodInfo BookmarkFile where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.BookmarkFile.bookmarkFileRemoveGroup",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-BookmarkFile.html#v:bookmarkFileRemoveGroup"
})
#endif
foreign import ccall "g_bookmark_file_remove_item" g_bookmark_file_remove_item ::
Ptr BookmarkFile ->
CString ->
Ptr (Ptr GError) ->
IO CInt
bookmarkFileRemoveItem ::
(B.CallStack.HasCallStack, MonadIO m) =>
BookmarkFile
-> T.Text
-> m ()
bookmarkFileRemoveItem :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> m ()
bookmarkFileRemoveItem BookmarkFile
bookmark Text
uri = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
uri' <- textToCString uri
onException (do
_ <- propagateGError $ g_bookmark_file_remove_item bookmark' uri'
touchManagedPtr bookmark
freeMem uri'
return ()
) (do
freeMem uri'
)
#if defined(ENABLE_OVERLOADING)
data BookmarkFileRemoveItemMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m) => O.OverloadedMethod BookmarkFileRemoveItemMethodInfo BookmarkFile signature where
overloadedMethod :: BookmarkFile -> signature
overloadedMethod = BookmarkFile -> signature
BookmarkFile -> Text -> m ()
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> m ()
bookmarkFileRemoveItem
instance O.OverloadedMethodInfo BookmarkFileRemoveItemMethodInfo BookmarkFile where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.BookmarkFile.bookmarkFileRemoveItem",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-BookmarkFile.html#v:bookmarkFileRemoveItem"
})
#endif
foreign import ccall "g_bookmark_file_set_added" g_bookmark_file_set_added ::
Ptr BookmarkFile ->
CString ->
FCT.CTime ->
IO ()
{-# DEPRECATED bookmarkFileSetAdded ["(Since version 2.66)","Use 'GI.GLib.Structs.BookmarkFile.bookmarkFileSetAddedDateTime' instead, as"," @time_t@ is deprecated due to the year 2038 problem."] #-}
bookmarkFileSetAdded ::
(B.CallStack.HasCallStack, MonadIO m) =>
BookmarkFile
-> T.Text
-> FCT.CTime
-> m ()
bookmarkFileSetAdded :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> CTime -> m ()
bookmarkFileSetAdded BookmarkFile
bookmark Text
uri CTime
added = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
uri' <- textToCString uri
g_bookmark_file_set_added bookmark' uri' added
touchManagedPtr bookmark
freeMem uri'
return ()
#if defined(ENABLE_OVERLOADING)
data BookmarkFileSetAddedMethodInfo
instance (signature ~ (T.Text -> FCT.CTime -> m ()), MonadIO m) => O.OverloadedMethod BookmarkFileSetAddedMethodInfo BookmarkFile signature where
overloadedMethod :: BookmarkFile -> signature
overloadedMethod = BookmarkFile -> signature
BookmarkFile -> Text -> CTime -> m ()
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> CTime -> m ()
bookmarkFileSetAdded
instance O.OverloadedMethodInfo BookmarkFileSetAddedMethodInfo BookmarkFile where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.BookmarkFile.bookmarkFileSetAdded",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-BookmarkFile.html#v:bookmarkFileSetAdded"
})
#endif
foreign import ccall "g_bookmark_file_set_added_date_time" g_bookmark_file_set_added_date_time ::
Ptr BookmarkFile ->
CString ->
Ptr GLib.DateTime.DateTime ->
IO ()
bookmarkFileSetAddedDateTime ::
(B.CallStack.HasCallStack, MonadIO m) =>
BookmarkFile
-> T.Text
-> GLib.DateTime.DateTime
-> m ()
bookmarkFileSetAddedDateTime :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> DateTime -> m ()
bookmarkFileSetAddedDateTime BookmarkFile
bookmark Text
uri DateTime
added = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
uri' <- textToCString uri
added' <- unsafeManagedPtrGetPtr added
g_bookmark_file_set_added_date_time bookmark' uri' added'
touchManagedPtr bookmark
touchManagedPtr added
freeMem uri'
return ()
#if defined(ENABLE_OVERLOADING)
data BookmarkFileSetAddedDateTimeMethodInfo
instance (signature ~ (T.Text -> GLib.DateTime.DateTime -> m ()), MonadIO m) => O.OverloadedMethod BookmarkFileSetAddedDateTimeMethodInfo BookmarkFile signature where
overloadedMethod :: BookmarkFile -> signature
overloadedMethod = BookmarkFile -> signature
BookmarkFile -> Text -> DateTime -> m ()
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> DateTime -> m ()
bookmarkFileSetAddedDateTime
instance O.OverloadedMethodInfo BookmarkFileSetAddedDateTimeMethodInfo BookmarkFile where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.BookmarkFile.bookmarkFileSetAddedDateTime",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-BookmarkFile.html#v:bookmarkFileSetAddedDateTime"
})
#endif
foreign import ccall "g_bookmark_file_set_app_info" g_bookmark_file_set_app_info ::
Ptr BookmarkFile ->
CString ->
CString ->
CString ->
Int32 ->
FCT.CTime ->
Ptr (Ptr GError) ->
IO CInt
{-# DEPRECATED bookmarkFileSetAppInfo ["(Since version 2.66)","Use 'GI.GLib.Structs.BookmarkFile.bookmarkFileSetApplicationInfo' instead, as"," @time_t@ is deprecated due to the year 2038 problem."] #-}
bookmarkFileSetAppInfo ::
(B.CallStack.HasCallStack, MonadIO m) =>
BookmarkFile
-> T.Text
-> T.Text
-> T.Text
-> Int32
-> FCT.CTime
-> m ()
bookmarkFileSetAppInfo :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> Text -> Text -> Int32 -> CTime -> m ()
bookmarkFileSetAppInfo BookmarkFile
bookmark Text
uri Text
name Text
exec Int32
count CTime
stamp = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
uri' <- textToCString uri
name' <- textToCString name
exec' <- textToCString exec
onException (do
_ <- propagateGError $ g_bookmark_file_set_app_info bookmark' uri' name' exec' count stamp
touchManagedPtr bookmark
freeMem uri'
freeMem name'
freeMem exec'
return ()
) (do
freeMem uri'
freeMem name'
freeMem exec'
)
#if defined(ENABLE_OVERLOADING)
data BookmarkFileSetAppInfoMethodInfo
instance (signature ~ (T.Text -> T.Text -> T.Text -> Int32 -> FCT.CTime -> m ()), MonadIO m) => O.OverloadedMethod BookmarkFileSetAppInfoMethodInfo BookmarkFile signature where
overloadedMethod :: BookmarkFile -> signature
overloadedMethod = BookmarkFile -> signature
BookmarkFile -> Text -> Text -> Text -> Int32 -> CTime -> m ()
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> Text -> Text -> Int32 -> CTime -> m ()
bookmarkFileSetAppInfo
instance O.OverloadedMethodInfo BookmarkFileSetAppInfoMethodInfo BookmarkFile where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.BookmarkFile.bookmarkFileSetAppInfo",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-BookmarkFile.html#v:bookmarkFileSetAppInfo"
})
#endif
foreign import ccall "g_bookmark_file_set_application_info" g_bookmark_file_set_application_info ::
Ptr BookmarkFile ->
CString ->
CString ->
CString ->
Int32 ->
Ptr GLib.DateTime.DateTime ->
Ptr (Ptr GError) ->
IO CInt
bookmarkFileSetApplicationInfo ::
(B.CallStack.HasCallStack, MonadIO m) =>
BookmarkFile
-> T.Text
-> T.Text
-> T.Text
-> Int32
-> Maybe (GLib.DateTime.DateTime)
-> m ()
bookmarkFileSetApplicationInfo :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile
-> Text -> Text -> Text -> Int32 -> Maybe DateTime -> m ()
bookmarkFileSetApplicationInfo BookmarkFile
bookmark Text
uri Text
name Text
exec Int32
count Maybe DateTime
stamp = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
uri' <- textToCString uri
name' <- textToCString name
exec' <- textToCString exec
maybeStamp <- case stamp of
Maybe DateTime
Nothing -> Ptr DateTime -> IO (Ptr DateTime)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr DateTime
forall a. Ptr a
FP.nullPtr
Just DateTime
jStamp -> do
jStamp' <- DateTime -> IO (Ptr DateTime)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr DateTime
jStamp
return jStamp'
onException (do
_ <- propagateGError $ g_bookmark_file_set_application_info bookmark' uri' name' exec' count maybeStamp
touchManagedPtr bookmark
whenJust stamp touchManagedPtr
freeMem uri'
freeMem name'
freeMem exec'
return ()
) (do
freeMem uri'
freeMem name'
freeMem exec'
)
#if defined(ENABLE_OVERLOADING)
data BookmarkFileSetApplicationInfoMethodInfo
instance (signature ~ (T.Text -> T.Text -> T.Text -> Int32 -> Maybe (GLib.DateTime.DateTime) -> m ()), MonadIO m) => O.OverloadedMethod BookmarkFileSetApplicationInfoMethodInfo BookmarkFile signature where
overloadedMethod :: BookmarkFile -> signature
overloadedMethod = BookmarkFile -> signature
BookmarkFile
-> Text -> Text -> Text -> Int32 -> Maybe DateTime -> m ()
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile
-> Text -> Text -> Text -> Int32 -> Maybe DateTime -> m ()
bookmarkFileSetApplicationInfo
instance O.OverloadedMethodInfo BookmarkFileSetApplicationInfoMethodInfo BookmarkFile where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.BookmarkFile.bookmarkFileSetApplicationInfo",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-BookmarkFile.html#v:bookmarkFileSetApplicationInfo"
})
#endif
foreign import ccall "g_bookmark_file_set_description" g_bookmark_file_set_description ::
Ptr BookmarkFile ->
CString ->
CString ->
IO ()
bookmarkFileSetDescription ::
(B.CallStack.HasCallStack, MonadIO m) =>
BookmarkFile
-> Maybe (T.Text)
-> T.Text
-> m ()
bookmarkFileSetDescription :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Maybe Text -> Text -> m ()
bookmarkFileSetDescription BookmarkFile
bookmark Maybe Text
uri Text
description = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
maybeUri <- case uri of
Maybe Text
Nothing -> CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
FP.nullPtr
Just Text
jUri -> do
jUri' <- Text -> IO CString
textToCString Text
jUri
return jUri'
description' <- textToCString description
g_bookmark_file_set_description bookmark' maybeUri description'
touchManagedPtr bookmark
freeMem maybeUri
freeMem description'
return ()
#if defined(ENABLE_OVERLOADING)
data BookmarkFileSetDescriptionMethodInfo
instance (signature ~ (Maybe (T.Text) -> T.Text -> m ()), MonadIO m) => O.OverloadedMethod BookmarkFileSetDescriptionMethodInfo BookmarkFile signature where
overloadedMethod :: BookmarkFile -> signature
overloadedMethod = BookmarkFile -> signature
BookmarkFile -> Maybe Text -> Text -> m ()
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Maybe Text -> Text -> m ()
bookmarkFileSetDescription
instance O.OverloadedMethodInfo BookmarkFileSetDescriptionMethodInfo BookmarkFile where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.BookmarkFile.bookmarkFileSetDescription",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-BookmarkFile.html#v:bookmarkFileSetDescription"
})
#endif
foreign import ccall "g_bookmark_file_set_groups" g_bookmark_file_set_groups ::
Ptr BookmarkFile ->
CString ->
Ptr CString ->
FCT.CSize ->
IO ()
bookmarkFileSetGroups ::
(B.CallStack.HasCallStack, MonadIO m) =>
BookmarkFile
-> T.Text
-> Maybe ([T.Text])
-> m ()
bookmarkFileSetGroups :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> Maybe [Text] -> m ()
bookmarkFileSetGroups BookmarkFile
bookmark Text
uri Maybe [Text]
groups = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
let length_ :: CSize
length_ = case Maybe [Text]
groups of
Maybe [Text]
Nothing -> CSize
0
Just [Text]
jGroups -> Int -> CSize
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CSize) -> Int -> CSize
forall a b. (a -> b) -> a -> b
$ [Text] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
P.length [Text]
jGroups
bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
uri' <- textToCString uri
maybeGroups <- case groups of
Maybe [Text]
Nothing -> Ptr CString -> IO (Ptr CString)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CString
forall a. Ptr a
FP.nullPtr
Just [Text]
jGroups -> do
jGroups' <- [Text] -> IO (Ptr CString)
packUTF8CArray [Text]
jGroups
return jGroups'
g_bookmark_file_set_groups bookmark' uri' maybeGroups length_
touchManagedPtr bookmark
freeMem uri'
(mapCArrayWithLength length_) freeMem maybeGroups
freeMem maybeGroups
return ()
#if defined(ENABLE_OVERLOADING)
data BookmarkFileSetGroupsMethodInfo
instance (signature ~ (T.Text -> Maybe ([T.Text]) -> m ()), MonadIO m) => O.OverloadedMethod BookmarkFileSetGroupsMethodInfo BookmarkFile signature where
overloadedMethod :: BookmarkFile -> signature
overloadedMethod = BookmarkFile -> signature
BookmarkFile -> Text -> Maybe [Text] -> m ()
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> Maybe [Text] -> m ()
bookmarkFileSetGroups
instance O.OverloadedMethodInfo BookmarkFileSetGroupsMethodInfo BookmarkFile where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.BookmarkFile.bookmarkFileSetGroups",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-BookmarkFile.html#v:bookmarkFileSetGroups"
})
#endif
foreign import ccall "g_bookmark_file_set_icon" g_bookmark_file_set_icon ::
Ptr BookmarkFile ->
CString ->
CString ->
CString ->
IO ()
bookmarkFileSetIcon ::
(B.CallStack.HasCallStack, MonadIO m) =>
BookmarkFile
-> T.Text
-> Maybe (T.Text)
-> T.Text
-> m ()
bookmarkFileSetIcon :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> Maybe Text -> Text -> m ()
bookmarkFileSetIcon BookmarkFile
bookmark Text
uri Maybe Text
href Text
mimeType = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
uri' <- textToCString uri
maybeHref <- case href of
Maybe Text
Nothing -> CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
FP.nullPtr
Just Text
jHref -> do
jHref' <- Text -> IO CString
textToCString Text
jHref
return jHref'
mimeType' <- textToCString mimeType
g_bookmark_file_set_icon bookmark' uri' maybeHref mimeType'
touchManagedPtr bookmark
freeMem uri'
freeMem maybeHref
freeMem mimeType'
return ()
#if defined(ENABLE_OVERLOADING)
data BookmarkFileSetIconMethodInfo
instance (signature ~ (T.Text -> Maybe (T.Text) -> T.Text -> m ()), MonadIO m) => O.OverloadedMethod BookmarkFileSetIconMethodInfo BookmarkFile signature where
overloadedMethod :: BookmarkFile -> signature
overloadedMethod = BookmarkFile -> signature
BookmarkFile -> Text -> Maybe Text -> Text -> m ()
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> Maybe Text -> Text -> m ()
bookmarkFileSetIcon
instance O.OverloadedMethodInfo BookmarkFileSetIconMethodInfo BookmarkFile where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.BookmarkFile.bookmarkFileSetIcon",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-BookmarkFile.html#v:bookmarkFileSetIcon"
})
#endif
foreign import ccall "g_bookmark_file_set_is_private" g_bookmark_file_set_is_private ::
Ptr BookmarkFile ->
CString ->
CInt ->
IO ()
bookmarkFileSetIsPrivate ::
(B.CallStack.HasCallStack, MonadIO m) =>
BookmarkFile
-> T.Text
-> Bool
-> m ()
bookmarkFileSetIsPrivate :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> Bool -> m ()
bookmarkFileSetIsPrivate BookmarkFile
bookmark Text
uri Bool
isPrivate = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
uri' <- textToCString uri
let isPrivate' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
isPrivate
g_bookmark_file_set_is_private bookmark' uri' isPrivate'
touchManagedPtr bookmark
freeMem uri'
return ()
#if defined(ENABLE_OVERLOADING)
data BookmarkFileSetIsPrivateMethodInfo
instance (signature ~ (T.Text -> Bool -> m ()), MonadIO m) => O.OverloadedMethod BookmarkFileSetIsPrivateMethodInfo BookmarkFile signature where
overloadedMethod :: BookmarkFile -> signature
overloadedMethod = BookmarkFile -> signature
BookmarkFile -> Text -> Bool -> m ()
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> Bool -> m ()
bookmarkFileSetIsPrivate
instance O.OverloadedMethodInfo BookmarkFileSetIsPrivateMethodInfo BookmarkFile where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.BookmarkFile.bookmarkFileSetIsPrivate",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-BookmarkFile.html#v:bookmarkFileSetIsPrivate"
})
#endif
foreign import ccall "g_bookmark_file_set_mime_type" g_bookmark_file_set_mime_type ::
Ptr BookmarkFile ->
CString ->
CString ->
IO ()
bookmarkFileSetMimeType ::
(B.CallStack.HasCallStack, MonadIO m) =>
BookmarkFile
-> T.Text
-> T.Text
-> m ()
bookmarkFileSetMimeType :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> Text -> m ()
bookmarkFileSetMimeType BookmarkFile
bookmark Text
uri Text
mimeType = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
uri' <- textToCString uri
mimeType' <- textToCString mimeType
g_bookmark_file_set_mime_type bookmark' uri' mimeType'
touchManagedPtr bookmark
freeMem uri'
freeMem mimeType'
return ()
#if defined(ENABLE_OVERLOADING)
data BookmarkFileSetMimeTypeMethodInfo
instance (signature ~ (T.Text -> T.Text -> m ()), MonadIO m) => O.OverloadedMethod BookmarkFileSetMimeTypeMethodInfo BookmarkFile signature where
overloadedMethod :: BookmarkFile -> signature
overloadedMethod = BookmarkFile -> signature
BookmarkFile -> Text -> Text -> m ()
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> Text -> m ()
bookmarkFileSetMimeType
instance O.OverloadedMethodInfo BookmarkFileSetMimeTypeMethodInfo BookmarkFile where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.BookmarkFile.bookmarkFileSetMimeType",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-BookmarkFile.html#v:bookmarkFileSetMimeType"
})
#endif
foreign import ccall "g_bookmark_file_set_modified" g_bookmark_file_set_modified ::
Ptr BookmarkFile ->
CString ->
FCT.CTime ->
IO ()
{-# DEPRECATED bookmarkFileSetModified ["(Since version 2.66)","Use 'GI.GLib.Structs.BookmarkFile.bookmarkFileSetModifiedDateTime' instead, as"," @time_t@ is deprecated due to the year 2038 problem."] #-}
bookmarkFileSetModified ::
(B.CallStack.HasCallStack, MonadIO m) =>
BookmarkFile
-> T.Text
-> FCT.CTime
-> m ()
bookmarkFileSetModified :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> CTime -> m ()
bookmarkFileSetModified BookmarkFile
bookmark Text
uri CTime
modified = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
uri' <- textToCString uri
g_bookmark_file_set_modified bookmark' uri' modified
touchManagedPtr bookmark
freeMem uri'
return ()
#if defined(ENABLE_OVERLOADING)
data BookmarkFileSetModifiedMethodInfo
instance (signature ~ (T.Text -> FCT.CTime -> m ()), MonadIO m) => O.OverloadedMethod BookmarkFileSetModifiedMethodInfo BookmarkFile signature where
overloadedMethod :: BookmarkFile -> signature
overloadedMethod = BookmarkFile -> signature
BookmarkFile -> Text -> CTime -> m ()
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> CTime -> m ()
bookmarkFileSetModified
instance O.OverloadedMethodInfo BookmarkFileSetModifiedMethodInfo BookmarkFile where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.BookmarkFile.bookmarkFileSetModified",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-BookmarkFile.html#v:bookmarkFileSetModified"
})
#endif
foreign import ccall "g_bookmark_file_set_modified_date_time" g_bookmark_file_set_modified_date_time ::
Ptr BookmarkFile ->
CString ->
Ptr GLib.DateTime.DateTime ->
IO ()
bookmarkFileSetModifiedDateTime ::
(B.CallStack.HasCallStack, MonadIO m) =>
BookmarkFile
-> T.Text
-> GLib.DateTime.DateTime
-> m ()
bookmarkFileSetModifiedDateTime :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> DateTime -> m ()
bookmarkFileSetModifiedDateTime BookmarkFile
bookmark Text
uri DateTime
modified = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
uri' <- textToCString uri
modified' <- unsafeManagedPtrGetPtr modified
g_bookmark_file_set_modified_date_time bookmark' uri' modified'
touchManagedPtr bookmark
touchManagedPtr modified
freeMem uri'
return ()
#if defined(ENABLE_OVERLOADING)
data BookmarkFileSetModifiedDateTimeMethodInfo
instance (signature ~ (T.Text -> GLib.DateTime.DateTime -> m ()), MonadIO m) => O.OverloadedMethod BookmarkFileSetModifiedDateTimeMethodInfo BookmarkFile signature where
overloadedMethod :: BookmarkFile -> signature
overloadedMethod = BookmarkFile -> signature
BookmarkFile -> Text -> DateTime -> m ()
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> DateTime -> m ()
bookmarkFileSetModifiedDateTime
instance O.OverloadedMethodInfo BookmarkFileSetModifiedDateTimeMethodInfo BookmarkFile where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.BookmarkFile.bookmarkFileSetModifiedDateTime",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-BookmarkFile.html#v:bookmarkFileSetModifiedDateTime"
})
#endif
foreign import ccall "g_bookmark_file_set_title" g_bookmark_file_set_title ::
Ptr BookmarkFile ->
CString ->
CString ->
IO ()
bookmarkFileSetTitle ::
(B.CallStack.HasCallStack, MonadIO m) =>
BookmarkFile
-> Maybe (T.Text)
-> T.Text
-> m ()
bookmarkFileSetTitle :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Maybe Text -> Text -> m ()
bookmarkFileSetTitle BookmarkFile
bookmark Maybe Text
uri Text
title = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
maybeUri <- case uri of
Maybe Text
Nothing -> CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
FP.nullPtr
Just Text
jUri -> do
jUri' <- Text -> IO CString
textToCString Text
jUri
return jUri'
title' <- textToCString title
g_bookmark_file_set_title bookmark' maybeUri title'
touchManagedPtr bookmark
freeMem maybeUri
freeMem title'
return ()
#if defined(ENABLE_OVERLOADING)
data BookmarkFileSetTitleMethodInfo
instance (signature ~ (Maybe (T.Text) -> T.Text -> m ()), MonadIO m) => O.OverloadedMethod BookmarkFileSetTitleMethodInfo BookmarkFile signature where
overloadedMethod :: BookmarkFile -> signature
overloadedMethod = BookmarkFile -> signature
BookmarkFile -> Maybe Text -> Text -> m ()
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Maybe Text -> Text -> m ()
bookmarkFileSetTitle
instance O.OverloadedMethodInfo BookmarkFileSetTitleMethodInfo BookmarkFile where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.BookmarkFile.bookmarkFileSetTitle",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-BookmarkFile.html#v:bookmarkFileSetTitle"
})
#endif
foreign import ccall "g_bookmark_file_set_visited" g_bookmark_file_set_visited ::
Ptr BookmarkFile ->
CString ->
FCT.CTime ->
IO ()
{-# DEPRECATED bookmarkFileSetVisited ["(Since version 2.66)","Use 'GI.GLib.Structs.BookmarkFile.bookmarkFileSetVisitedDateTime' instead, as"," @time_t@ is deprecated due to the year 2038 problem."] #-}
bookmarkFileSetVisited ::
(B.CallStack.HasCallStack, MonadIO m) =>
BookmarkFile
-> T.Text
-> FCT.CTime
-> m ()
bookmarkFileSetVisited :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> CTime -> m ()
bookmarkFileSetVisited BookmarkFile
bookmark Text
uri CTime
visited = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
uri' <- textToCString uri
g_bookmark_file_set_visited bookmark' uri' visited
touchManagedPtr bookmark
freeMem uri'
return ()
#if defined(ENABLE_OVERLOADING)
data BookmarkFileSetVisitedMethodInfo
instance (signature ~ (T.Text -> FCT.CTime -> m ()), MonadIO m) => O.OverloadedMethod BookmarkFileSetVisitedMethodInfo BookmarkFile signature where
overloadedMethod :: BookmarkFile -> signature
overloadedMethod = BookmarkFile -> signature
BookmarkFile -> Text -> CTime -> m ()
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> CTime -> m ()
bookmarkFileSetVisited
instance O.OverloadedMethodInfo BookmarkFileSetVisitedMethodInfo BookmarkFile where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.BookmarkFile.bookmarkFileSetVisited",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-BookmarkFile.html#v:bookmarkFileSetVisited"
})
#endif
foreign import ccall "g_bookmark_file_set_visited_date_time" g_bookmark_file_set_visited_date_time ::
Ptr BookmarkFile ->
CString ->
Ptr GLib.DateTime.DateTime ->
IO ()
bookmarkFileSetVisitedDateTime ::
(B.CallStack.HasCallStack, MonadIO m) =>
BookmarkFile
-> T.Text
-> GLib.DateTime.DateTime
-> m ()
bookmarkFileSetVisitedDateTime :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> DateTime -> m ()
bookmarkFileSetVisitedDateTime BookmarkFile
bookmark Text
uri DateTime
visited = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
uri' <- textToCString uri
visited' <- unsafeManagedPtrGetPtr visited
g_bookmark_file_set_visited_date_time bookmark' uri' visited'
touchManagedPtr bookmark
touchManagedPtr visited
freeMem uri'
return ()
#if defined(ENABLE_OVERLOADING)
data BookmarkFileSetVisitedDateTimeMethodInfo
instance (signature ~ (T.Text -> GLib.DateTime.DateTime -> m ()), MonadIO m) => O.OverloadedMethod BookmarkFileSetVisitedDateTimeMethodInfo BookmarkFile signature where
overloadedMethod :: BookmarkFile -> signature
overloadedMethod = BookmarkFile -> signature
BookmarkFile -> Text -> DateTime -> m ()
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> Text -> DateTime -> m ()
bookmarkFileSetVisitedDateTime
instance O.OverloadedMethodInfo BookmarkFileSetVisitedDateTimeMethodInfo BookmarkFile where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.BookmarkFile.bookmarkFileSetVisitedDateTime",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-BookmarkFile.html#v:bookmarkFileSetVisitedDateTime"
})
#endif
foreign import ccall "g_bookmark_file_to_data" g_bookmark_file_to_data ::
Ptr BookmarkFile ->
Ptr FCT.CSize ->
Ptr (Ptr GError) ->
IO (Ptr Word8)
bookmarkFileToData ::
(B.CallStack.HasCallStack, MonadIO m) =>
BookmarkFile
-> m ByteString
bookmarkFileToData :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> m ByteString
bookmarkFileToData BookmarkFile
bookmark = IO ByteString -> m ByteString
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ByteString -> m ByteString) -> IO ByteString -> m ByteString
forall a b. (a -> b) -> a -> b
$ do
bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
length_ <- allocMem :: IO (Ptr FCT.CSize)
onException (do
result <- propagateGError $ g_bookmark_file_to_data bookmark' length_
length_' <- peek length_
checkUnexpectedReturnNULL "bookmarkFileToData" result
result' <- (unpackByteStringWithLength length_') result
freeMem result
touchManagedPtr bookmark
freeMem length_
return result'
) (do
freeMem length_
)
#if defined(ENABLE_OVERLOADING)
data BookmarkFileToDataMethodInfo
instance (signature ~ (m ByteString), MonadIO m) => O.OverloadedMethod BookmarkFileToDataMethodInfo BookmarkFile signature where
overloadedMethod :: BookmarkFile -> signature
overloadedMethod = BookmarkFile -> signature
BookmarkFile -> m ByteString
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> m ByteString
bookmarkFileToData
instance O.OverloadedMethodInfo BookmarkFileToDataMethodInfo BookmarkFile where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.BookmarkFile.bookmarkFileToData",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-BookmarkFile.html#v:bookmarkFileToData"
})
#endif
foreign import ccall "g_bookmark_file_to_file" g_bookmark_file_to_file ::
Ptr BookmarkFile ->
CString ->
Ptr (Ptr GError) ->
IO CInt
bookmarkFileToFile ::
(B.CallStack.HasCallStack, MonadIO m) =>
BookmarkFile
-> [Char]
-> m ()
bookmarkFileToFile :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> String -> m ()
bookmarkFileToFile BookmarkFile
bookmark String
filename = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
bookmark' <- BookmarkFile -> IO (Ptr BookmarkFile)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BookmarkFile
bookmark
filename' <- stringToCString filename
onException (do
_ <- propagateGError $ g_bookmark_file_to_file bookmark' filename'
touchManagedPtr bookmark
freeMem filename'
return ()
) (do
freeMem filename'
)
#if defined(ENABLE_OVERLOADING)
data BookmarkFileToFileMethodInfo
instance (signature ~ ([Char] -> m ()), MonadIO m) => O.OverloadedMethod BookmarkFileToFileMethodInfo BookmarkFile signature where
overloadedMethod :: BookmarkFile -> signature
overloadedMethod = BookmarkFile -> signature
BookmarkFile -> String -> m ()
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BookmarkFile -> String -> m ()
bookmarkFileToFile
instance O.OverloadedMethodInfo BookmarkFileToFileMethodInfo BookmarkFile where
overloadedMethodInfo :: Maybe ResolvedSymbolInfo
overloadedMethodInfo = ResolvedSymbolInfo -> Maybe ResolvedSymbolInfo
forall a. a -> Maybe a
P.Just (O.ResolvedSymbolInfo {
resolvedSymbolName :: Text
O.resolvedSymbolName = Text
"GI.GLib.Structs.BookmarkFile.bookmarkFileToFile",
resolvedSymbolURL :: Text
O.resolvedSymbolURL = Text
"https://hackage.haskell.org/package/gi-glib-2.0.31/docs/GI-GLib-Structs-BookmarkFile.html#v:bookmarkFileToFile"
})
#endif
foreign import ccall "g_bookmark_file_error_quark" g_bookmark_file_error_quark ::
IO Word32
bookmarkFileErrorQuark ::
(B.CallStack.HasCallStack, MonadIO m) =>
m Word32
bookmarkFileErrorQuark :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Word32
bookmarkFileErrorQuark = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
result <- IO Word32
g_bookmark_file_error_quark
return result
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveBookmarkFileMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveBookmarkFileMethod "addApplication" o = BookmarkFileAddApplicationMethodInfo
ResolveBookmarkFileMethod "addGroup" o = BookmarkFileAddGroupMethodInfo
ResolveBookmarkFileMethod "copy" o = BookmarkFileCopyMethodInfo
ResolveBookmarkFileMethod "free" o = BookmarkFileFreeMethodInfo
ResolveBookmarkFileMethod "hasApplication" o = BookmarkFileHasApplicationMethodInfo
ResolveBookmarkFileMethod "hasGroup" o = BookmarkFileHasGroupMethodInfo
ResolveBookmarkFileMethod "hasItem" o = BookmarkFileHasItemMethodInfo
ResolveBookmarkFileMethod "loadFromData" o = BookmarkFileLoadFromDataMethodInfo
ResolveBookmarkFileMethod "loadFromDataDirs" o = BookmarkFileLoadFromDataDirsMethodInfo
ResolveBookmarkFileMethod "loadFromFile" o = BookmarkFileLoadFromFileMethodInfo
ResolveBookmarkFileMethod "moveItem" o = BookmarkFileMoveItemMethodInfo
ResolveBookmarkFileMethod "removeApplication" o = BookmarkFileRemoveApplicationMethodInfo
ResolveBookmarkFileMethod "removeGroup" o = BookmarkFileRemoveGroupMethodInfo
ResolveBookmarkFileMethod "removeItem" o = BookmarkFileRemoveItemMethodInfo
ResolveBookmarkFileMethod "toData" o = BookmarkFileToDataMethodInfo
ResolveBookmarkFileMethod "toFile" o = BookmarkFileToFileMethodInfo
ResolveBookmarkFileMethod "getAdded" o = BookmarkFileGetAddedMethodInfo
ResolveBookmarkFileMethod "getAddedDateTime" o = BookmarkFileGetAddedDateTimeMethodInfo
ResolveBookmarkFileMethod "getAppInfo" o = BookmarkFileGetAppInfoMethodInfo
ResolveBookmarkFileMethod "getApplicationInfo" o = BookmarkFileGetApplicationInfoMethodInfo
ResolveBookmarkFileMethod "getApplications" o = BookmarkFileGetApplicationsMethodInfo
ResolveBookmarkFileMethod "getDescription" o = BookmarkFileGetDescriptionMethodInfo
ResolveBookmarkFileMethod "getGroups" o = BookmarkFileGetGroupsMethodInfo
ResolveBookmarkFileMethod "getIcon" o = BookmarkFileGetIconMethodInfo
ResolveBookmarkFileMethod "getIsPrivate" o = BookmarkFileGetIsPrivateMethodInfo
ResolveBookmarkFileMethod "getMimeType" o = BookmarkFileGetMimeTypeMethodInfo
ResolveBookmarkFileMethod "getModified" o = BookmarkFileGetModifiedMethodInfo
ResolveBookmarkFileMethod "getModifiedDateTime" o = BookmarkFileGetModifiedDateTimeMethodInfo
ResolveBookmarkFileMethod "getSize" o = BookmarkFileGetSizeMethodInfo
ResolveBookmarkFileMethod "getTitle" o = BookmarkFileGetTitleMethodInfo
ResolveBookmarkFileMethod "getUris" o = BookmarkFileGetUrisMethodInfo
ResolveBookmarkFileMethod "getVisited" o = BookmarkFileGetVisitedMethodInfo
ResolveBookmarkFileMethod "getVisitedDateTime" o = BookmarkFileGetVisitedDateTimeMethodInfo
ResolveBookmarkFileMethod "setAdded" o = BookmarkFileSetAddedMethodInfo
ResolveBookmarkFileMethod "setAddedDateTime" o = BookmarkFileSetAddedDateTimeMethodInfo
ResolveBookmarkFileMethod "setAppInfo" o = BookmarkFileSetAppInfoMethodInfo
ResolveBookmarkFileMethod "setApplicationInfo" o = BookmarkFileSetApplicationInfoMethodInfo
ResolveBookmarkFileMethod "setDescription" o = BookmarkFileSetDescriptionMethodInfo
ResolveBookmarkFileMethod "setGroups" o = BookmarkFileSetGroupsMethodInfo
ResolveBookmarkFileMethod "setIcon" o = BookmarkFileSetIconMethodInfo
ResolveBookmarkFileMethod "setIsPrivate" o = BookmarkFileSetIsPrivateMethodInfo
ResolveBookmarkFileMethod "setMimeType" o = BookmarkFileSetMimeTypeMethodInfo
ResolveBookmarkFileMethod "setModified" o = BookmarkFileSetModifiedMethodInfo
ResolveBookmarkFileMethod "setModifiedDateTime" o = BookmarkFileSetModifiedDateTimeMethodInfo
ResolveBookmarkFileMethod "setTitle" o = BookmarkFileSetTitleMethodInfo
ResolveBookmarkFileMethod "setVisited" o = BookmarkFileSetVisitedMethodInfo
ResolveBookmarkFileMethod "setVisitedDateTime" o = BookmarkFileSetVisitedDateTimeMethodInfo
ResolveBookmarkFileMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveBookmarkFileMethod t BookmarkFile, O.OverloadedMethod info BookmarkFile p) => OL.IsLabel t (BookmarkFile -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel :: BookmarkFile -> p
fromLabel = forall {k} (i :: k) o s. OverloadedMethod i o s => o -> s
forall i o s. OverloadedMethod i o s => o -> s
O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveBookmarkFileMethod t BookmarkFile, O.OverloadedMethod info BookmarkFile p, R.HasField t BookmarkFile p) => R.HasField t BookmarkFile p where
getField :: BookmarkFile -> p
getField = forall {k} (i :: k) o s. OverloadedMethod i o s => o -> s
forall i o s. OverloadedMethod i o s => o -> s
O.overloadedMethod @info
#endif
instance (info ~ ResolveBookmarkFileMethod t BookmarkFile, O.OverloadedMethodInfo info BookmarkFile) => OL.IsLabel t (O.MethodProxy info BookmarkFile) where
#if MIN_VERSION_base(4,10,0)
fromLabel :: MethodProxy info BookmarkFile
fromLabel = MethodProxy info BookmarkFile
forall info obj. MethodProxy info obj
O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif