{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- /No description available in the introspection data./

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

module GI.Vips.Objects.Interpolate
    ( 

-- * Exported types
    Interpolate(..)                         ,
    IsInterpolate                           ,
    toInterpolate                           ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [argumentIsset]("GI.Vips.Objects.Object#g:method:argumentIsset"), [argumentNeedsstring]("GI.Vips.Objects.Object#g:method:argumentNeedsstring"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [build]("GI.Vips.Objects.Object#g:method:build"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [localCb]("GI.Vips.Objects.Object#g:method:localCb"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [preclose]("GI.Vips.Objects.Object#g:method:preclose"), [printDump]("GI.Vips.Objects.Object#g:method:printDump"), [printName]("GI.Vips.Objects.Object#g:method:printName"), [printSummary]("GI.Vips.Objects.Object#g:method:printSummary"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [rewind]("GI.Vips.Objects.Object#g:method:rewind"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [sanity]("GI.Vips.Objects.Object#g:method:sanity"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [unrefOutputs]("GI.Vips.Objects.Object#g:method:unrefOutputs"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getArgumentFlags]("GI.Vips.Objects.Object#g:method:getArgumentFlags"), [getArgumentPriority]("GI.Vips.Objects.Object#g:method:getArgumentPriority"), [getArgumentToString]("GI.Vips.Objects.Object#g:method:getArgumentToString"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getDescription]("GI.Vips.Objects.Object#g:method:getDescription"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getWindowOffset]("GI.Vips.Objects.Interpolate#g:method:getWindowOffset"), [getWindowSize]("GI.Vips.Objects.Interpolate#g:method:getWindowSize").
-- 
-- ==== Setters
-- [setArgumentFromString]("GI.Vips.Objects.Object#g:method:setArgumentFromString"), [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setFromString]("GI.Vips.Objects.Object#g:method:setFromString"), [setRequired]("GI.Vips.Objects.Object#g:method:setRequired"), [setStatic]("GI.Vips.Objects.Object#g:method:setStatic").

#if defined(ENABLE_OVERLOADING)
    ResolveInterpolateMethod                ,
#endif

-- ** bilinearStatic #method:bilinearStatic#

    interpolateBilinearStatic               ,


-- ** getWindowOffset #method:getWindowOffset#

#if defined(ENABLE_OVERLOADING)
    InterpolateGetWindowOffsetMethodInfo    ,
#endif
    interpolateGetWindowOffset              ,


-- ** getWindowSize #method:getWindowSize#

#if defined(ENABLE_OVERLOADING)
    InterpolateGetWindowSizeMethodInfo      ,
#endif
    interpolateGetWindowSize                ,


-- ** nearestStatic #method:nearestStatic#

    interpolateNearestStatic                ,


-- ** new #method:new#

    interpolateNew                          ,




    ) 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.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.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 GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Vips.Objects.Object as Vips.Object

-- | Memory-managed wrapper type.
newtype Interpolate = Interpolate (SP.ManagedPtr Interpolate)
    deriving (Interpolate -> Interpolate -> Bool
(Interpolate -> Interpolate -> Bool)
-> (Interpolate -> Interpolate -> Bool) -> Eq Interpolate
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Interpolate -> Interpolate -> Bool
$c/= :: Interpolate -> Interpolate -> Bool
== :: Interpolate -> Interpolate -> Bool
$c== :: Interpolate -> Interpolate -> Bool
Eq)

instance SP.ManagedPtrNewtype Interpolate where
    toManagedPtr :: Interpolate -> ManagedPtr Interpolate
toManagedPtr (Interpolate ManagedPtr Interpolate
p) = ManagedPtr Interpolate
p

foreign import ccall "vips_interpolate_get_type"
    c_vips_interpolate_get_type :: IO B.Types.GType

instance B.Types.TypedObject Interpolate where
    glibType :: IO GType
glibType = IO GType
c_vips_interpolate_get_type

instance B.Types.GObject Interpolate

-- | Type class for types which can be safely cast to `Interpolate`, for instance with `toInterpolate`.
class (SP.GObject o, O.IsDescendantOf Interpolate o) => IsInterpolate o
instance (SP.GObject o, O.IsDescendantOf Interpolate o) => IsInterpolate o

instance O.HasParentTypes Interpolate
type instance O.ParentTypes Interpolate = '[Vips.Object.Object, GObject.Object.Object]

-- | Cast to `Interpolate`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toInterpolate :: (MIO.MonadIO m, IsInterpolate o) => o -> m Interpolate
toInterpolate :: forall (m :: * -> *) o.
(MonadIO m, IsInterpolate o) =>
o -> m Interpolate
toInterpolate = IO Interpolate -> m Interpolate
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Interpolate -> m Interpolate)
-> (o -> IO Interpolate) -> o -> m Interpolate
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr Interpolate -> Interpolate) -> o -> IO Interpolate
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
 ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr Interpolate -> Interpolate
Interpolate

-- | Convert 'Interpolate' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue (Maybe Interpolate) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_vips_interpolate_get_type
    gvalueSet_ :: Ptr GValue -> Maybe Interpolate -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Interpolate
P.Nothing = Ptr GValue -> Ptr Interpolate -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr Interpolate
forall a. Ptr a
FP.nullPtr :: FP.Ptr Interpolate)
    gvalueSet_ Ptr GValue
gv (P.Just Interpolate
obj) = Interpolate -> (Ptr Interpolate -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Interpolate
obj (Ptr GValue -> Ptr Interpolate -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe Interpolate)
gvalueGet_ Ptr GValue
gv = do
        Ptr Interpolate
ptr <- Ptr GValue -> IO (Ptr Interpolate)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr Interpolate)
        if Ptr Interpolate
ptr Ptr Interpolate -> Ptr Interpolate -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr Interpolate
forall a. Ptr a
FP.nullPtr
        then Interpolate -> Maybe Interpolate
forall a. a -> Maybe a
P.Just (Interpolate -> Maybe Interpolate)
-> IO Interpolate -> IO (Maybe Interpolate)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr Interpolate -> Interpolate)
-> Ptr Interpolate -> IO Interpolate
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr Interpolate -> Interpolate
Interpolate Ptr Interpolate
ptr
        else Maybe Interpolate -> IO (Maybe Interpolate)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Interpolate
forall a. Maybe a
P.Nothing
        
    

#if defined(ENABLE_OVERLOADING)
type family ResolveInterpolateMethod (t :: Symbol) (o :: *) :: * where
    ResolveInterpolateMethod "argumentIsset" o = Vips.Object.ObjectArgumentIssetMethodInfo
    ResolveInterpolateMethod "argumentNeedsstring" o = Vips.Object.ObjectArgumentNeedsstringMethodInfo
    ResolveInterpolateMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveInterpolateMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveInterpolateMethod "build" o = Vips.Object.ObjectBuildMethodInfo
    ResolveInterpolateMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveInterpolateMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveInterpolateMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveInterpolateMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveInterpolateMethod "localCb" o = Vips.Object.ObjectLocalCbMethodInfo
    ResolveInterpolateMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveInterpolateMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveInterpolateMethod "preclose" o = Vips.Object.ObjectPrecloseMethodInfo
    ResolveInterpolateMethod "printDump" o = Vips.Object.ObjectPrintDumpMethodInfo
    ResolveInterpolateMethod "printName" o = Vips.Object.ObjectPrintNameMethodInfo
    ResolveInterpolateMethod "printSummary" o = Vips.Object.ObjectPrintSummaryMethodInfo
    ResolveInterpolateMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveInterpolateMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveInterpolateMethod "rewind" o = Vips.Object.ObjectRewindMethodInfo
    ResolveInterpolateMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveInterpolateMethod "sanity" o = Vips.Object.ObjectSanityMethodInfo
    ResolveInterpolateMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveInterpolateMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveInterpolateMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveInterpolateMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveInterpolateMethod "unrefOutputs" o = Vips.Object.ObjectUnrefOutputsMethodInfo
    ResolveInterpolateMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveInterpolateMethod "getArgumentFlags" o = Vips.Object.ObjectGetArgumentFlagsMethodInfo
    ResolveInterpolateMethod "getArgumentPriority" o = Vips.Object.ObjectGetArgumentPriorityMethodInfo
    ResolveInterpolateMethod "getArgumentToString" o = Vips.Object.ObjectGetArgumentToStringMethodInfo
    ResolveInterpolateMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveInterpolateMethod "getDescription" o = Vips.Object.ObjectGetDescriptionMethodInfo
    ResolveInterpolateMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveInterpolateMethod "getWindowOffset" o = InterpolateGetWindowOffsetMethodInfo
    ResolveInterpolateMethod "getWindowSize" o = InterpolateGetWindowSizeMethodInfo
    ResolveInterpolateMethod "setArgumentFromString" o = Vips.Object.ObjectSetArgumentFromStringMethodInfo
    ResolveInterpolateMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveInterpolateMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveInterpolateMethod "setFromString" o = Vips.Object.ObjectSetFromStringMethodInfo
    ResolveInterpolateMethod "setRequired" o = Vips.Object.ObjectSetRequiredMethodInfo
    ResolveInterpolateMethod "setStatic" o = Vips.Object.ObjectSetStaticMethodInfo
    ResolveInterpolateMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveInterpolateMethod t Interpolate, O.OverloadedMethod info Interpolate p) => OL.IsLabel t (Interpolate -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod @info
#else
    fromLabel _ = O.overloadedMethod @info
#endif

#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveInterpolateMethod t Interpolate, O.OverloadedMethod info Interpolate p, R.HasField t Interpolate p) => R.HasField t Interpolate p where
    getField = O.overloadedMethod @info

#endif

instance (info ~ ResolveInterpolateMethod t Interpolate, O.OverloadedMethodInfo info Interpolate) => OL.IsLabel t (O.MethodProxy info Interpolate) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#endif

#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Interpolate
type instance O.AttributeList Interpolate = InterpolateAttributeList
type InterpolateAttributeList = ('[ '("description", Vips.Object.ObjectDescriptionPropertyInfo), '("nickname", Vips.Object.ObjectNicknamePropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Interpolate = InterpolateSignalList
type InterpolateSignalList = ('[ '("close", Vips.Object.ObjectCloseSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("postbuild", Vips.Object.ObjectPostbuildSignalInfo), '("postclose", Vips.Object.ObjectPostcloseSignalInfo), '("preclose", Vips.Object.ObjectPrecloseSignalInfo)] :: [(Symbol, *)])

#endif

-- method Interpolate::new
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "nickname"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "nickname for interpolator"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Vips" , name = "Interpolate" })
-- throws : False
-- Skip return : False

foreign import ccall "vips_interpolate_new" vips_interpolate_new :: 
    CString ->                              -- nickname : TBasicType TUTF8
    IO (Ptr Interpolate)

-- | Look up an interpolator from a nickname and make one. You need to free the
-- result with 'GI.GObject.Objects.Object.objectUnref' when you\'re done with it.
-- 
-- See also: 'GI.Vips.Functions.typeFind'.
interpolateNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    -- ^ /@nickname@/: nickname for interpolator
    -> m Interpolate
    -- ^ __Returns:__ an interpolator, or 'P.Nothing' on error.
interpolateNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> m Interpolate
interpolateNew Text
nickname = IO Interpolate -> m Interpolate
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Interpolate -> m Interpolate)
-> IO Interpolate -> m Interpolate
forall a b. (a -> b) -> a -> b
$ do
    CString
nickname' <- Text -> IO CString
textToCString Text
nickname
    Ptr Interpolate
result <- CString -> IO (Ptr Interpolate)
vips_interpolate_new CString
nickname'
    Text -> Ptr Interpolate -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"interpolateNew" Ptr Interpolate
result
    Interpolate
result' <- ((ManagedPtr Interpolate -> Interpolate)
-> Ptr Interpolate -> IO Interpolate
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Interpolate -> Interpolate
Interpolate) Ptr Interpolate
result
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
nickname'
    Interpolate -> IO Interpolate
forall (m :: * -> *) a. Monad m => a -> m a
return Interpolate
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method Interpolate::get_window_offset
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "interpolate"
--           , argType =
--               TInterface Name { namespace = "Vips" , name = "Interpolate" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "interpolator to use"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "vips_interpolate_get_window_offset" vips_interpolate_get_window_offset :: 
    Ptr Interpolate ->                      -- interpolate : TInterface (Name {namespace = "Vips", name = "Interpolate"})
    IO Int32

-- | Look up an interpolators desired window offset.
interpolateGetWindowOffset ::
    (B.CallStack.HasCallStack, MonadIO m, IsInterpolate a) =>
    a
    -- ^ /@interpolate@/: interpolator to use
    -> m Int32
    -- ^ __Returns:__ the interpolators required window offset
interpolateGetWindowOffset :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsInterpolate a) =>
a -> m Int32
interpolateGetWindowOffset a
interpolate = IO Int32 -> m Int32
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
    Ptr Interpolate
interpolate' <- a -> IO (Ptr Interpolate)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
interpolate
    Int32
result <- Ptr Interpolate -> IO Int32
vips_interpolate_get_window_offset Ptr Interpolate
interpolate'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
interpolate
    Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result

#if defined(ENABLE_OVERLOADING)
data InterpolateGetWindowOffsetMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsInterpolate a) => O.OverloadedMethod InterpolateGetWindowOffsetMethodInfo a signature where
    overloadedMethod = interpolateGetWindowOffset

instance O.OverloadedMethodInfo InterpolateGetWindowOffsetMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vips.Objects.Interpolate.interpolateGetWindowOffset",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vips-8.0.2/docs/GI-Vips-Objects-Interpolate.html#v:interpolateGetWindowOffset"
        })


#endif

-- method Interpolate::get_window_size
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "interpolate"
--           , argType =
--               TInterface Name { namespace = "Vips" , name = "Interpolate" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "interpolator to use"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "vips_interpolate_get_window_size" vips_interpolate_get_window_size :: 
    Ptr Interpolate ->                      -- interpolate : TInterface (Name {namespace = "Vips", name = "Interpolate"})
    IO Int32

-- | Look up an interpolators desired window size.
interpolateGetWindowSize ::
    (B.CallStack.HasCallStack, MonadIO m, IsInterpolate a) =>
    a
    -- ^ /@interpolate@/: interpolator to use
    -> m Int32
    -- ^ __Returns:__ the interpolators required window size
interpolateGetWindowSize :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsInterpolate a) =>
a -> m Int32
interpolateGetWindowSize a
interpolate = IO Int32 -> m Int32
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
    Ptr Interpolate
interpolate' <- a -> IO (Ptr Interpolate)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
interpolate
    Int32
result <- Ptr Interpolate -> IO Int32
vips_interpolate_get_window_size Ptr Interpolate
interpolate'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
interpolate
    Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result

#if defined(ENABLE_OVERLOADING)
data InterpolateGetWindowSizeMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsInterpolate a) => O.OverloadedMethod InterpolateGetWindowSizeMethodInfo a signature where
    overloadedMethod = interpolateGetWindowSize

instance O.OverloadedMethodInfo InterpolateGetWindowSizeMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Vips.Objects.Interpolate.interpolateGetWindowSize",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-vips-8.0.2/docs/GI-Vips-Objects-Interpolate.html#v:interpolateGetWindowSize"
        })


#endif

-- method Interpolate::bilinear_static
-- method type : MemberFunction
-- Args: []
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Vips" , name = "Interpolate" })
-- throws : False
-- Skip return : False

foreign import ccall "vips_interpolate_bilinear_static" vips_interpolate_bilinear_static :: 
    IO (Ptr Interpolate)

-- | A convenience function that returns a bilinear interpolator you
-- don\'t need to free.
interpolateBilinearStatic ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m Interpolate
    -- ^ __Returns:__ a bilinear interpolator
interpolateBilinearStatic :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Interpolate
interpolateBilinearStatic  = IO Interpolate -> m Interpolate
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Interpolate -> m Interpolate)
-> IO Interpolate -> m Interpolate
forall a b. (a -> b) -> a -> b
$ do
    Ptr Interpolate
result <- IO (Ptr Interpolate)
vips_interpolate_bilinear_static
    Text -> Ptr Interpolate -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"interpolateBilinearStatic" Ptr Interpolate
result
    Interpolate
result' <- ((ManagedPtr Interpolate -> Interpolate)
-> Ptr Interpolate -> IO Interpolate
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Interpolate -> Interpolate
Interpolate) Ptr Interpolate
result
    Interpolate -> IO Interpolate
forall (m :: * -> *) a. Monad m => a -> m a
return Interpolate
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method Interpolate::nearest_static
-- method type : MemberFunction
-- Args: []
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Vips" , name = "Interpolate" })
-- throws : False
-- Skip return : False

foreign import ccall "vips_interpolate_nearest_static" vips_interpolate_nearest_static :: 
    IO (Ptr Interpolate)

-- | A convenience function that returns a nearest-neighbour interpolator you
-- don\'t need to free.
interpolateNearestStatic ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m Interpolate
    -- ^ __Returns:__ a nearest-neighbour interpolator
interpolateNearestStatic :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Interpolate
interpolateNearestStatic  = IO Interpolate -> m Interpolate
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Interpolate -> m Interpolate)
-> IO Interpolate -> m Interpolate
forall a b. (a -> b) -> a -> b
$ do
    Ptr Interpolate
result <- IO (Ptr Interpolate)
vips_interpolate_nearest_static
    Text -> Ptr Interpolate -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"interpolateNearestStatic" Ptr Interpolate
result
    Interpolate
result' <- ((ManagedPtr Interpolate -> Interpolate)
-> Ptr Interpolate -> IO Interpolate
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Interpolate -> Interpolate
Interpolate) Ptr Interpolate
result
    Interpolate -> IO Interpolate
forall (m :: * -> *) a. Monad m => a -> m a
return Interpolate
result'

#if defined(ENABLE_OVERLOADING)
#endif