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

'GI.Gtk.Objects.EventController.EventController' is a base, low-level implementation for event
controllers. Those react to a series of @/GdkEvents/@, and possibly trigger
actions as a consequence of those.
-}

module GI.Gtk.Objects.EventController
    ( 

-- * Exported types
    EventController(..)                     ,
    IsEventController                       ,
    toEventController                       ,
    noEventController                       ,


 -- * Methods
-- ** getPropagationPhase #method:getPropagationPhase#
    EventControllerGetPropagationPhaseMethodInfo,
    eventControllerGetPropagationPhase      ,


-- ** getWidget #method:getWidget#
    EventControllerGetWidgetMethodInfo      ,
    eventControllerGetWidget                ,


-- ** handleEvent #method:handleEvent#
    EventControllerHandleEventMethodInfo    ,
    eventControllerHandleEvent              ,


-- ** reset #method:reset#
    EventControllerResetMethodInfo          ,
    eventControllerReset                    ,


-- ** setPropagationPhase #method:setPropagationPhase#
    EventControllerSetPropagationPhaseMethodInfo,
    eventControllerSetPropagationPhase      ,




 -- * Properties
-- ** propagationPhase #attr:propagationPhase#
    EventControllerPropagationPhasePropertyInfo,
    constructEventControllerPropagationPhase,
    eventControllerPropagationPhase         ,
    getEventControllerPropagationPhase      ,
    setEventControllerPropagationPhase      ,


-- ** widget #attr:widget#
    EventControllerWidgetPropertyInfo       ,
    constructEventControllerWidget          ,
    eventControllerWidget                   ,
    getEventControllerWidget                ,




    ) 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.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
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 GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gdk.Unions.Event as Gdk.Event
import {-# SOURCE #-} qualified GI.Gtk.Enums as Gtk.Enums
import {-# SOURCE #-} qualified GI.Gtk.Objects.Widget as Gtk.Widget

newtype EventController = EventController (ManagedPtr EventController)
foreign import ccall "gtk_event_controller_get_type"
    c_gtk_event_controller_get_type :: IO GType

instance GObject EventController where
    gobjectType _ = c_gtk_event_controller_get_type
    

class GObject o => IsEventController o
#if MIN_VERSION_base(4,9,0)
instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError EventController a) =>
    IsEventController a
#endif
instance IsEventController EventController
instance GObject.Object.IsObject EventController

toEventController :: IsEventController o => o -> IO EventController
toEventController = unsafeCastTo EventController

noEventController :: Maybe EventController
noEventController = Nothing

type family ResolveEventControllerMethod (t :: Symbol) (o :: *) :: * where
    ResolveEventControllerMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveEventControllerMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveEventControllerMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveEventControllerMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveEventControllerMethod "handleEvent" o = EventControllerHandleEventMethodInfo
    ResolveEventControllerMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveEventControllerMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveEventControllerMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveEventControllerMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveEventControllerMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveEventControllerMethod "replaceData" o = GObject.Object.ObjectReplaceDataMethodInfo
    ResolveEventControllerMethod "replaceQdata" o = GObject.Object.ObjectReplaceQdataMethodInfo
    ResolveEventControllerMethod "reset" o = EventControllerResetMethodInfo
    ResolveEventControllerMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveEventControllerMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveEventControllerMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveEventControllerMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveEventControllerMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveEventControllerMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveEventControllerMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveEventControllerMethod "getPropagationPhase" o = EventControllerGetPropagationPhaseMethodInfo
    ResolveEventControllerMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveEventControllerMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveEventControllerMethod "getWidget" o = EventControllerGetWidgetMethodInfo
    ResolveEventControllerMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveEventControllerMethod "setPropagationPhase" o = EventControllerSetPropagationPhaseMethodInfo
    ResolveEventControllerMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveEventControllerMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveEventControllerMethod t EventController, O.MethodInfo info EventController p) => O.IsLabelProxy t (EventController -> p) where
    fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveEventControllerMethod t EventController, O.MethodInfo info EventController p) => O.IsLabel t (EventController -> p) where
    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif

-- VVV Prop "propagation-phase"
   -- Type: TInterface (Name {namespace = "Gtk", name = "PropagationPhase"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getEventControllerPropagationPhase :: (MonadIO m, IsEventController o) => o -> m Gtk.Enums.PropagationPhase
getEventControllerPropagationPhase obj = liftIO $ getObjectPropertyEnum obj "propagation-phase"

setEventControllerPropagationPhase :: (MonadIO m, IsEventController o) => o -> Gtk.Enums.PropagationPhase -> m ()
setEventControllerPropagationPhase obj val = liftIO $ setObjectPropertyEnum obj "propagation-phase" val

constructEventControllerPropagationPhase :: (IsEventController o) => Gtk.Enums.PropagationPhase -> IO (GValueConstruct o)
constructEventControllerPropagationPhase val = constructObjectPropertyEnum "propagation-phase" val

data EventControllerPropagationPhasePropertyInfo
instance AttrInfo EventControllerPropagationPhasePropertyInfo where
    type AttrAllowedOps EventControllerPropagationPhasePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint EventControllerPropagationPhasePropertyInfo = (~) Gtk.Enums.PropagationPhase
    type AttrBaseTypeConstraint EventControllerPropagationPhasePropertyInfo = IsEventController
    type AttrGetType EventControllerPropagationPhasePropertyInfo = Gtk.Enums.PropagationPhase
    type AttrLabel EventControllerPropagationPhasePropertyInfo = "propagation-phase"
    type AttrOrigin EventControllerPropagationPhasePropertyInfo = EventController
    attrGet _ = getEventControllerPropagationPhase
    attrSet _ = setEventControllerPropagationPhase
    attrConstruct _ = constructEventControllerPropagationPhase
    attrClear _ = undefined

-- VVV Prop "widget"
   -- Type: TInterface (Name {namespace = "Gtk", name = "Widget"})
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Just False,Nothing)

getEventControllerWidget :: (MonadIO m, IsEventController o) => o -> m Gtk.Widget.Widget
getEventControllerWidget obj = liftIO $ checkUnexpectedNothing "getEventControllerWidget" $ getObjectPropertyObject obj "widget" Gtk.Widget.Widget

constructEventControllerWidget :: (IsEventController o, Gtk.Widget.IsWidget a) => a -> IO (GValueConstruct o)
constructEventControllerWidget val = constructObjectPropertyObject "widget" (Just val)

data EventControllerWidgetPropertyInfo
instance AttrInfo EventControllerWidgetPropertyInfo where
    type AttrAllowedOps EventControllerWidgetPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint EventControllerWidgetPropertyInfo = Gtk.Widget.IsWidget
    type AttrBaseTypeConstraint EventControllerWidgetPropertyInfo = IsEventController
    type AttrGetType EventControllerWidgetPropertyInfo = Gtk.Widget.Widget
    type AttrLabel EventControllerWidgetPropertyInfo = "widget"
    type AttrOrigin EventControllerWidgetPropertyInfo = EventController
    attrGet _ = getEventControllerWidget
    attrSet _ = undefined
    attrConstruct _ = constructEventControllerWidget
    attrClear _ = undefined

instance O.HasAttributeList EventController
type instance O.AttributeList EventController = EventControllerAttributeList
type EventControllerAttributeList = ('[ '("propagationPhase", EventControllerPropagationPhasePropertyInfo), '("widget", EventControllerWidgetPropertyInfo)] :: [(Symbol, *)])

eventControllerPropagationPhase :: AttrLabelProxy "propagationPhase"
eventControllerPropagationPhase = AttrLabelProxy

eventControllerWidget :: AttrLabelProxy "widget"
eventControllerWidget = AttrLabelProxy

type instance O.SignalList EventController = EventControllerSignalList
type EventControllerSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

-- method EventController::get_propagation_phase
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "controller", argType = TInterface (Name {namespace = "Gtk", name = "EventController"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkEventController", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "PropagationPhase"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_event_controller_get_propagation_phase" gtk_event_controller_get_propagation_phase :: 
    Ptr EventController ->                  -- controller : TInterface (Name {namespace = "Gtk", name = "EventController"})
    IO CUInt

{- |
Gets the propagation phase at which /@controller@/ handles events.

@since 3.14
-}
eventControllerGetPropagationPhase ::
    (B.CallStack.HasCallStack, MonadIO m, IsEventController a) =>
    a
    {- ^ /@controller@/: a 'GI.Gtk.Objects.EventController.EventController' -}
    -> m Gtk.Enums.PropagationPhase
    {- ^ __Returns:__ the propagation phase -}
eventControllerGetPropagationPhase controller = liftIO $ do
    controller' <- unsafeManagedPtrCastPtr controller
    result <- gtk_event_controller_get_propagation_phase controller'
    let result' = (toEnum . fromIntegral) result
    touchManagedPtr controller
    return result'

data EventControllerGetPropagationPhaseMethodInfo
instance (signature ~ (m Gtk.Enums.PropagationPhase), MonadIO m, IsEventController a) => O.MethodInfo EventControllerGetPropagationPhaseMethodInfo a signature where
    overloadedMethod _ = eventControllerGetPropagationPhase

-- method EventController::get_widget
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "controller", argType = TInterface (Name {namespace = "Gtk", name = "EventController"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkEventController", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gtk", name = "Widget"}))
-- throws : False
-- Skip return : False

foreign import ccall "gtk_event_controller_get_widget" gtk_event_controller_get_widget :: 
    Ptr EventController ->                  -- controller : TInterface (Name {namespace = "Gtk", name = "EventController"})
    IO (Ptr Gtk.Widget.Widget)

{- |
Returns the 'GI.Gtk.Objects.Widget.Widget' this controller relates to.

@since 3.14
-}
eventControllerGetWidget ::
    (B.CallStack.HasCallStack, MonadIO m, IsEventController a) =>
    a
    {- ^ /@controller@/: a 'GI.Gtk.Objects.EventController.EventController' -}
    -> m Gtk.Widget.Widget
    {- ^ __Returns:__ a 'GI.Gtk.Objects.Widget.Widget' -}
eventControllerGetWidget controller = liftIO $ do
    controller' <- unsafeManagedPtrCastPtr controller
    result <- gtk_event_controller_get_widget controller'
    checkUnexpectedReturnNULL "eventControllerGetWidget" result
    result' <- (newObject Gtk.Widget.Widget) result
    touchManagedPtr controller
    return result'

data EventControllerGetWidgetMethodInfo
instance (signature ~ (m Gtk.Widget.Widget), MonadIO m, IsEventController a) => O.MethodInfo EventControllerGetWidgetMethodInfo a signature where
    overloadedMethod _ = eventControllerGetWidget

-- method EventController::handle_event
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "controller", argType = TInterface (Name {namespace = "Gtk", name = "EventController"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkEventController", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "event", argType = TInterface (Name {namespace = "Gdk", name = "Event"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkEvent", 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 "gtk_event_controller_handle_event" gtk_event_controller_handle_event :: 
    Ptr EventController ->                  -- controller : TInterface (Name {namespace = "Gtk", name = "EventController"})
    Ptr Gdk.Event.Event ->                  -- event : TInterface (Name {namespace = "Gdk", name = "Event"})
    IO CInt

{- |
Feeds an events into /@controller@/, so it can be interpreted
and the controller actions triggered.

@since 3.14
-}
eventControllerHandleEvent ::
    (B.CallStack.HasCallStack, MonadIO m, IsEventController a) =>
    a
    {- ^ /@controller@/: a 'GI.Gtk.Objects.EventController.EventController' -}
    -> Gdk.Event.Event
    {- ^ /@event@/: a 'GI.Gdk.Unions.Event.Event' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the event was potentially useful to trigger the
         controller action -}
eventControllerHandleEvent controller event = liftIO $ do
    controller' <- unsafeManagedPtrCastPtr controller
    event' <- unsafeManagedPtrGetPtr event
    result <- gtk_event_controller_handle_event controller' event'
    let result' = (/= 0) result
    touchManagedPtr controller
    touchManagedPtr event
    return result'

data EventControllerHandleEventMethodInfo
instance (signature ~ (Gdk.Event.Event -> m Bool), MonadIO m, IsEventController a) => O.MethodInfo EventControllerHandleEventMethodInfo a signature where
    overloadedMethod _ = eventControllerHandleEvent

-- method EventController::reset
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "controller", argType = TInterface (Name {namespace = "Gtk", name = "EventController"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkEventController", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_event_controller_reset" gtk_event_controller_reset :: 
    Ptr EventController ->                  -- controller : TInterface (Name {namespace = "Gtk", name = "EventController"})
    IO ()

{- |
Resets the /@controller@/ to a clean state. Every interaction
the controller did through 'GI.Gtk.Objects.EventController.EventController'::@/handle-event/@
will be dropped at this point.

@since 3.14
-}
eventControllerReset ::
    (B.CallStack.HasCallStack, MonadIO m, IsEventController a) =>
    a
    {- ^ /@controller@/: a 'GI.Gtk.Objects.EventController.EventController' -}
    -> m ()
eventControllerReset controller = liftIO $ do
    controller' <- unsafeManagedPtrCastPtr controller
    gtk_event_controller_reset controller'
    touchManagedPtr controller
    return ()

data EventControllerResetMethodInfo
instance (signature ~ (m ()), MonadIO m, IsEventController a) => O.MethodInfo EventControllerResetMethodInfo a signature where
    overloadedMethod _ = eventControllerReset

-- method EventController::set_propagation_phase
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "controller", argType = TInterface (Name {namespace = "Gtk", name = "EventController"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GtkEventController", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "phase", argType = TInterface (Name {namespace = "Gtk", name = "PropagationPhase"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a propagation phase", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_event_controller_set_propagation_phase" gtk_event_controller_set_propagation_phase :: 
    Ptr EventController ->                  -- controller : TInterface (Name {namespace = "Gtk", name = "EventController"})
    CUInt ->                                -- phase : TInterface (Name {namespace = "Gtk", name = "PropagationPhase"})
    IO ()

{- |
Sets the propagation phase at which a controller handles events.

If /@phase@/ is 'GI.Gtk.Enums.PropagationPhaseNone', no automatic event handling will be
performed, but other additional gesture maintenance will. In that phase,
the events can be managed by calling 'GI.Gtk.Objects.EventController.eventControllerHandleEvent'.

@since 3.14
-}
eventControllerSetPropagationPhase ::
    (B.CallStack.HasCallStack, MonadIO m, IsEventController a) =>
    a
    {- ^ /@controller@/: a 'GI.Gtk.Objects.EventController.EventController' -}
    -> Gtk.Enums.PropagationPhase
    {- ^ /@phase@/: a propagation phase -}
    -> m ()
eventControllerSetPropagationPhase controller phase = liftIO $ do
    controller' <- unsafeManagedPtrCastPtr controller
    let phase' = (fromIntegral . fromEnum) phase
    gtk_event_controller_set_propagation_phase controller' phase'
    touchManagedPtr controller
    return ()

data EventControllerSetPropagationPhaseMethodInfo
instance (signature ~ (Gtk.Enums.PropagationPhase -> m ()), MonadIO m, IsEventController a) => O.MethodInfo EventControllerSetPropagationPhaseMethodInfo a signature where
    overloadedMethod _ = eventControllerSetPropagationPhase