EditorState.hs


{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)

/No description available in the introspection data./
-}

#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
       && !defined(__HADDOCK_VERSION__))

module GI.WebKit2.Objects.EditorState
    ( 

-- * Exported types
    EditorState(..)                         ,
    IsEditorState                           ,
    toEditorState                           ,
    noEditorState                           ,


 -- * Methods
-- ** getTypingAttributes #method:getTypingAttributes#

#if ENABLE_OVERLOADING
    EditorStateGetTypingAttributesMethodInfo,
#endif
    editorStateGetTypingAttributes          ,


-- ** isCopyAvailable #method:isCopyAvailable#

#if ENABLE_OVERLOADING
    EditorStateIsCopyAvailableMethodInfo    ,
#endif
    editorStateIsCopyAvailable              ,


-- ** isCutAvailable #method:isCutAvailable#

#if ENABLE_OVERLOADING
    EditorStateIsCutAvailableMethodInfo     ,
#endif
    editorStateIsCutAvailable               ,


-- ** isPasteAvailable #method:isPasteAvailable#

#if ENABLE_OVERLOADING
    EditorStateIsPasteAvailableMethodInfo   ,
#endif
    editorStateIsPasteAvailable             ,


-- ** isRedoAvailable #method:isRedoAvailable#

#if ENABLE_OVERLOADING
    EditorStateIsRedoAvailableMethodInfo    ,
#endif
    editorStateIsRedoAvailable              ,


-- ** isUndoAvailable #method:isUndoAvailable#

#if ENABLE_OVERLOADING
    EditorStateIsUndoAvailableMethodInfo    ,
#endif
    editorStateIsUndoAvailable              ,




 -- * Properties
-- ** typingAttributes #attr:typingAttributes#
{- | Bitmask of 'GI.WebKit2.Flags.EditorTypingAttributes' flags.
See 'GI.WebKit2.Objects.EditorState.editorStateGetTypingAttributes' for more information.

/Since: 2.10/
-}
#if ENABLE_OVERLOADING
    EditorStateTypingAttributesPropertyInfo ,
#endif
#if ENABLE_OVERLOADING
    editorStateTypingAttributes             ,
#endif
    getEditorStateTypingAttributes          ,




    ) where

import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL

import qualified GI.GObject.Objects.Object as GObject.Object

-- | Memory-managed wrapper type.
newtype EditorState = EditorState (ManagedPtr EditorState)
foreign import ccall "webkit_editor_state_get_type"
    c_webkit_editor_state_get_type :: IO GType

instance GObject EditorState where
    gobjectType = c_webkit_editor_state_get_type
    

-- | Type class for types which can be safely cast to `EditorState`, for instance with `toEditorState`.
class (GObject o, O.IsDescendantOf EditorState o) => IsEditorState o
instance (GObject o, O.IsDescendantOf EditorState o) => IsEditorState o

instance O.HasParentTypes EditorState
type instance O.ParentTypes EditorState = '[GObject.Object.Object]

-- | Cast to `EditorState`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toEditorState :: (MonadIO m, IsEditorState o) => o -> m EditorState
toEditorState = liftIO . unsafeCastTo EditorState

-- | A convenience alias for `Nothing` :: `Maybe` `EditorState`.
noEditorState :: Maybe EditorState
noEditorState = Nothing

#if ENABLE_OVERLOADING
type family ResolveEditorStateMethod (t :: Symbol) (o :: *) :: * where
    ResolveEditorStateMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveEditorStateMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveEditorStateMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveEditorStateMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveEditorStateMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveEditorStateMethod "isCopyAvailable" o = EditorStateIsCopyAvailableMethodInfo
    ResolveEditorStateMethod "isCutAvailable" o = EditorStateIsCutAvailableMethodInfo
    ResolveEditorStateMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveEditorStateMethod "isPasteAvailable" o = EditorStateIsPasteAvailableMethodInfo
    ResolveEditorStateMethod "isRedoAvailable" o = EditorStateIsRedoAvailableMethodInfo
    ResolveEditorStateMethod "isUndoAvailable" o = EditorStateIsUndoAvailableMethodInfo
    ResolveEditorStateMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveEditorStateMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveEditorStateMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveEditorStateMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveEditorStateMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveEditorStateMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveEditorStateMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveEditorStateMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveEditorStateMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveEditorStateMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveEditorStateMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveEditorStateMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveEditorStateMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveEditorStateMethod "getTypingAttributes" o = EditorStateGetTypingAttributesMethodInfo
    ResolveEditorStateMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveEditorStateMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveEditorStateMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveEditorStateMethod t EditorState, O.MethodInfo info EditorState p) => OL.IsLabel t (EditorState -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#else
    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif

#endif

-- VVV Prop "typing-attributes"
   -- Type: TBasicType TUInt
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

{- |
Get the value of the “@typing-attributes@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' editorState #typingAttributes
@
-}
getEditorStateTypingAttributes :: (MonadIO m, IsEditorState o) => o -> m Word32
getEditorStateTypingAttributes obj = liftIO $ B.Properties.getObjectPropertyUInt32 obj "typing-attributes"

#if ENABLE_OVERLOADING
data EditorStateTypingAttributesPropertyInfo
instance AttrInfo EditorStateTypingAttributesPropertyInfo where
    type AttrAllowedOps EditorStateTypingAttributesPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint EditorStateTypingAttributesPropertyInfo = (~) ()
    type AttrBaseTypeConstraint EditorStateTypingAttributesPropertyInfo = IsEditorState
    type AttrGetType EditorStateTypingAttributesPropertyInfo = Word32
    type AttrLabel EditorStateTypingAttributesPropertyInfo = "typing-attributes"
    type AttrOrigin EditorStateTypingAttributesPropertyInfo = EditorState
    attrGet _ = getEditorStateTypingAttributes
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined
#endif

#if ENABLE_OVERLOADING
instance O.HasAttributeList EditorState
type instance O.AttributeList EditorState = EditorStateAttributeList
type EditorStateAttributeList = ('[ '("typingAttributes", EditorStateTypingAttributesPropertyInfo)] :: [(Symbol, *)])
#endif

#if ENABLE_OVERLOADING
editorStateTypingAttributes :: AttrLabelProxy "typingAttributes"
editorStateTypingAttributes = AttrLabelProxy

#endif

#if ENABLE_OVERLOADING
type instance O.SignalList EditorState = EditorStateSignalList
type EditorStateSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

#endif

-- method EditorState::get_typing_attributes
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "editor_state", argType = TInterface (Name {namespace = "WebKit2", name = "EditorState"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitEditorState", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUInt)
-- throws : False
-- Skip return : False

foreign import ccall "webkit_editor_state_get_typing_attributes" webkit_editor_state_get_typing_attributes :: 
    Ptr EditorState ->                      -- editor_state : TInterface (Name {namespace = "WebKit2", name = "EditorState"})
    IO Word32

{- |
Gets the typing attributes at the current cursor position.
If there is a selection, this returns the typing attributes
of the selected text. Note that in case of a selection,
typing attributes are considered active only when they are
present throughout the selection.

/Since: 2.10/
-}
editorStateGetTypingAttributes ::
    (B.CallStack.HasCallStack, MonadIO m, IsEditorState a) =>
    a
    {- ^ /@editorState@/: a 'GI.WebKit2.Objects.EditorState.EditorState' -}
    -> m Word32
    {- ^ __Returns:__ a bitmask of 'GI.WebKit2.Flags.EditorTypingAttributes' flags -}
editorStateGetTypingAttributes editorState = liftIO $ do
    editorState' <- unsafeManagedPtrCastPtr editorState
    result <- webkit_editor_state_get_typing_attributes editorState'
    touchManagedPtr editorState
    return result

#if ENABLE_OVERLOADING
data EditorStateGetTypingAttributesMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsEditorState a) => O.MethodInfo EditorStateGetTypingAttributesMethodInfo a signature where
    overloadedMethod _ = editorStateGetTypingAttributes

#endif

-- method EditorState::is_copy_available
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "editor_state", argType = TInterface (Name {namespace = "WebKit2", name = "EditorState"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitEditorState", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "webkit_editor_state_is_copy_available" webkit_editor_state_is_copy_available :: 
    Ptr EditorState ->                      -- editor_state : TInterface (Name {namespace = "WebKit2", name = "EditorState"})
    IO CInt

{- |
Gets whether a copy command can be issued.

/Since: 2.20/
-}
editorStateIsCopyAvailable ::
    (B.CallStack.HasCallStack, MonadIO m, IsEditorState a) =>
    a
    {- ^ /@editorState@/: a 'GI.WebKit2.Objects.EditorState.EditorState' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if copy is currently available -}
editorStateIsCopyAvailable editorState = liftIO $ do
    editorState' <- unsafeManagedPtrCastPtr editorState
    result <- webkit_editor_state_is_copy_available editorState'
    let result' = (/= 0) result
    touchManagedPtr editorState
    return result'

#if ENABLE_OVERLOADING
data EditorStateIsCopyAvailableMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsEditorState a) => O.MethodInfo EditorStateIsCopyAvailableMethodInfo a signature where
    overloadedMethod _ = editorStateIsCopyAvailable

#endif

-- method EditorState::is_cut_available
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "editor_state", argType = TInterface (Name {namespace = "WebKit2", name = "EditorState"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitEditorState", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "webkit_editor_state_is_cut_available" webkit_editor_state_is_cut_available :: 
    Ptr EditorState ->                      -- editor_state : TInterface (Name {namespace = "WebKit2", name = "EditorState"})
    IO CInt

{- |
Gets whether a cut command can be issued.

/Since: 2.20/
-}
editorStateIsCutAvailable ::
    (B.CallStack.HasCallStack, MonadIO m, IsEditorState a) =>
    a
    {- ^ /@editorState@/: a 'GI.WebKit2.Objects.EditorState.EditorState' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if cut is currently available -}
editorStateIsCutAvailable editorState = liftIO $ do
    editorState' <- unsafeManagedPtrCastPtr editorState
    result <- webkit_editor_state_is_cut_available editorState'
    let result' = (/= 0) result
    touchManagedPtr editorState
    return result'

#if ENABLE_OVERLOADING
data EditorStateIsCutAvailableMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsEditorState a) => O.MethodInfo EditorStateIsCutAvailableMethodInfo a signature where
    overloadedMethod _ = editorStateIsCutAvailable

#endif

-- method EditorState::is_paste_available
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "editor_state", argType = TInterface (Name {namespace = "WebKit2", name = "EditorState"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitEditorState", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "webkit_editor_state_is_paste_available" webkit_editor_state_is_paste_available :: 
    Ptr EditorState ->                      -- editor_state : TInterface (Name {namespace = "WebKit2", name = "EditorState"})
    IO CInt

{- |
Gets whether a paste command can be issued.

/Since: 2.20/
-}
editorStateIsPasteAvailable ::
    (B.CallStack.HasCallStack, MonadIO m, IsEditorState a) =>
    a
    {- ^ /@editorState@/: a 'GI.WebKit2.Objects.EditorState.EditorState' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if paste is currently available -}
editorStateIsPasteAvailable editorState = liftIO $ do
    editorState' <- unsafeManagedPtrCastPtr editorState
    result <- webkit_editor_state_is_paste_available editorState'
    let result' = (/= 0) result
    touchManagedPtr editorState
    return result'

#if ENABLE_OVERLOADING
data EditorStateIsPasteAvailableMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsEditorState a) => O.MethodInfo EditorStateIsPasteAvailableMethodInfo a signature where
    overloadedMethod _ = editorStateIsPasteAvailable

#endif

-- method EditorState::is_redo_available
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "editor_state", argType = TInterface (Name {namespace = "WebKit2", name = "EditorState"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitEditorState", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "webkit_editor_state_is_redo_available" webkit_editor_state_is_redo_available :: 
    Ptr EditorState ->                      -- editor_state : TInterface (Name {namespace = "WebKit2", name = "EditorState"})
    IO CInt

{- |
Gets whether a redo command can be issued.

/Since: 2.20/
-}
editorStateIsRedoAvailable ::
    (B.CallStack.HasCallStack, MonadIO m, IsEditorState a) =>
    a
    {- ^ /@editorState@/: a 'GI.WebKit2.Objects.EditorState.EditorState' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if redo is currently available -}
editorStateIsRedoAvailable editorState = liftIO $ do
    editorState' <- unsafeManagedPtrCastPtr editorState
    result <- webkit_editor_state_is_redo_available editorState'
    let result' = (/= 0) result
    touchManagedPtr editorState
    return result'

#if ENABLE_OVERLOADING
data EditorStateIsRedoAvailableMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsEditorState a) => O.MethodInfo EditorStateIsRedoAvailableMethodInfo a signature where
    overloadedMethod _ = editorStateIsRedoAvailable

#endif

-- method EditorState::is_undo_available
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "editor_state", argType = TInterface (Name {namespace = "WebKit2", name = "EditorState"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitEditorState", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "webkit_editor_state_is_undo_available" webkit_editor_state_is_undo_available :: 
    Ptr EditorState ->                      -- editor_state : TInterface (Name {namespace = "WebKit2", name = "EditorState"})
    IO CInt

{- |
Gets whether an undo command can be issued.

/Since: 2.20/
-}
editorStateIsUndoAvailable ::
    (B.CallStack.HasCallStack, MonadIO m, IsEditorState a) =>
    a
    {- ^ /@editorState@/: a 'GI.WebKit2.Objects.EditorState.EditorState' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if undo is currently available -}
editorStateIsUndoAvailable editorState = liftIO $ do
    editorState' <- unsafeManagedPtrCastPtr editorState
    result <- webkit_editor_state_is_undo_available editorState'
    let result' = (/= 0) result
    touchManagedPtr editorState
    return result'

#if ENABLE_OVERLOADING
data EditorStateIsUndoAvailableMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsEditorState a) => O.MethodInfo EditorStateIsUndoAvailableMethodInfo a signature where
    overloadedMethod _ = editorStateIsUndoAvailable

#endif