{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Vips.Objects.Interpolate
(
Interpolate(..) ,
IsInterpolate ,
toInterpolate ,
#if defined(ENABLE_OVERLOADING)
ResolveInterpolateMethod ,
#endif
interpolateBilinearStatic ,
#if defined(ENABLE_OVERLOADING)
InterpolateGetWindowOffsetMethodInfo ,
#endif
interpolateGetWindowOffset ,
#if defined(ENABLE_OVERLOADING)
InterpolateGetWindowSizeMethodInfo ,
#endif
interpolateGetWindowSize ,
interpolateNearestStatic ,
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
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
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]
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
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
foreign import ccall "vips_interpolate_new" vips_interpolate_new ::
CString ->
IO (Ptr Interpolate)
interpolateNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m Interpolate
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
foreign import ccall "vips_interpolate_get_window_offset" vips_interpolate_get_window_offset ::
Ptr Interpolate ->
IO Int32
interpolateGetWindowOffset ::
(B.CallStack.HasCallStack, MonadIO m, IsInterpolate a) =>
a
-> m Int32
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
foreign import ccall "vips_interpolate_get_window_size" vips_interpolate_get_window_size ::
Ptr Interpolate ->
IO Int32
interpolateGetWindowSize ::
(B.CallStack.HasCallStack, MonadIO m, IsInterpolate a) =>
a
-> m Int32
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
foreign import ccall "vips_interpolate_bilinear_static" vips_interpolate_bilinear_static ::
IO (Ptr Interpolate)
interpolateBilinearStatic ::
(B.CallStack.HasCallStack, MonadIO m) =>
m Interpolate
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
foreign import ccall "vips_interpolate_nearest_static" vips_interpolate_nearest_static ::
IO (Ptr Interpolate)
interpolateNearestStatic ::
(B.CallStack.HasCallStack, MonadIO m) =>
m Interpolate
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