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

The 'GI.Pango.Objects.FontFace.FontFace' structure is used to represent a group of fonts with
the same family, slant, weight, width, but varying sizes.
-}

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

module GI.Pango.Objects.FontFace
    (

-- * Exported types
    FontFace(..)                            ,
    IsFontFace                              ,
    toFontFace                              ,
    noFontFace                              ,


 -- * Methods
-- ** describe #method:describe#

#if ENABLE_OVERLOADING
    FontFaceDescribeMethodInfo              ,
#endif
    fontFaceDescribe                        ,


-- ** getFaceName #method:getFaceName#

#if ENABLE_OVERLOADING
    FontFaceGetFaceNameMethodInfo           ,
#endif
    fontFaceGetFaceName                     ,


-- ** isSynthesized #method:isSynthesized#

#if ENABLE_OVERLOADING
    FontFaceIsSynthesizedMethodInfo         ,
#endif
    fontFaceIsSynthesized                   ,


-- ** listSizes #method:listSizes#

#if ENABLE_OVERLOADING
    FontFaceListSizesMethodInfo             ,
#endif
    fontFaceListSizes                       ,




    ) 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
import {-# SOURCE #-} qualified GI.Pango.Structs.FontDescription as Pango.FontDescription

-- | Memory-managed wrapper type.
newtype FontFace = FontFace (ManagedPtr FontFace)
foreign import ccall "pango_font_face_get_type"
    c_pango_font_face_get_type :: IO GType

instance GObject FontFace where
    gobjectType = c_pango_font_face_get_type


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

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

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

-- | A convenience alias for `Nothing` :: `Maybe` `FontFace`.
noFontFace :: Maybe FontFace
noFontFace = Nothing

#if ENABLE_OVERLOADING
type family ResolveFontFaceMethod (t :: Symbol) (o :: *) :: * where
    ResolveFontFaceMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveFontFaceMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveFontFaceMethod "describe" o = FontFaceDescribeMethodInfo
    ResolveFontFaceMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveFontFaceMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveFontFaceMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveFontFaceMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveFontFaceMethod "isSynthesized" o = FontFaceIsSynthesizedMethodInfo
    ResolveFontFaceMethod "listSizes" o = FontFaceListSizesMethodInfo
    ResolveFontFaceMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveFontFaceMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveFontFaceMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveFontFaceMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveFontFaceMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveFontFaceMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveFontFaceMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveFontFaceMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveFontFaceMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveFontFaceMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveFontFaceMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveFontFaceMethod "getFaceName" o = FontFaceGetFaceNameMethodInfo
    ResolveFontFaceMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveFontFaceMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveFontFaceMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveFontFaceMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveFontFaceMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveFontFaceMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveFontFaceMethod t FontFace, O.MethodInfo info FontFace p) => OL.IsLabel t (FontFace -> 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

#if ENABLE_OVERLOADING
instance O.HasAttributeList FontFace
type instance O.AttributeList FontFace = FontFaceAttributeList
type FontFaceAttributeList = ('[ ] :: [(Symbol, *)])
#endif

#if ENABLE_OVERLOADING
#endif

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

#endif

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

foreign import ccall "pango_font_face_describe" pango_font_face_describe ::
    Ptr FontFace ->                         -- face : TInterface (Name {namespace = "Pango", name = "FontFace"})
    IO (Ptr Pango.FontDescription.FontDescription)

{- |
Returns the family, style, variant, weight and stretch of
a 'GI.Pango.Objects.FontFace.FontFace'. The size field of the resulting font description
will be unset.
-}
fontFaceDescribe ::
    (B.CallStack.HasCallStack, MonadIO m, IsFontFace a) =>
    a
    {- ^ /@face@/: a 'GI.Pango.Objects.FontFace.FontFace' -}
    -> m Pango.FontDescription.FontDescription
    {- ^ __Returns:__ a newly-created 'GI.Pango.Structs.FontDescription.FontDescription' structure
 holding the description of the face. Use 'GI.Pango.Structs.FontDescription.fontDescriptionFree'
 to free the result. -}
fontFaceDescribe face = liftIO $ do
    face' <- unsafeManagedPtrCastPtr face
    result <- pango_font_face_describe face'
    checkUnexpectedReturnNULL "fontFaceDescribe" result
    result' <- (wrapBoxed Pango.FontDescription.FontDescription) result
    touchManagedPtr face
    return result'

#if ENABLE_OVERLOADING
data FontFaceDescribeMethodInfo
instance (signature ~ (m Pango.FontDescription.FontDescription), MonadIO m, IsFontFace a) => O.MethodInfo FontFaceDescribeMethodInfo a signature where
    overloadedMethod _ = fontFaceDescribe

#endif

-- method FontFace::get_face_name
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "face", argType = TInterface (Name {namespace = "Pango", name = "FontFace"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoFontFace.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "pango_font_face_get_face_name" pango_font_face_get_face_name ::
    Ptr FontFace ->                         -- face : TInterface (Name {namespace = "Pango", name = "FontFace"})
    IO CString

{- |
Gets a name representing the style of this face among the
different faces in the 'GI.Pango.Objects.FontFamily.FontFamily' for the face. This
name is unique among all faces in the family and is suitable
for displaying to users.
-}
fontFaceGetFaceName ::
    (B.CallStack.HasCallStack, MonadIO m, IsFontFace a) =>
    a
    {- ^ /@face@/: a 'GI.Pango.Objects.FontFace.FontFace'. -}
    -> m T.Text
    {- ^ __Returns:__ the face name for the face. This string is
  owned by the face object and must not be modified or freed. -}
fontFaceGetFaceName face = liftIO $ do
    face' <- unsafeManagedPtrCastPtr face
    result <- pango_font_face_get_face_name face'
    checkUnexpectedReturnNULL "fontFaceGetFaceName" result
    result' <- cstringToText result
    touchManagedPtr face
    return result'

#if ENABLE_OVERLOADING
data FontFaceGetFaceNameMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsFontFace a) => O.MethodInfo FontFaceGetFaceNameMethodInfo a signature where
    overloadedMethod _ = fontFaceGetFaceName

#endif

-- method FontFace::is_synthesized
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "face", argType = TInterface (Name {namespace = "Pango", name = "FontFace"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoFontFace", 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 "pango_font_face_is_synthesized" pango_font_face_is_synthesized ::
    Ptr FontFace ->                         -- face : TInterface (Name {namespace = "Pango", name = "FontFace"})
    IO CInt

{- |
Returns whether a 'GI.Pango.Objects.FontFace.FontFace' is synthesized by the underlying
font rendering engine from another face, perhaps by shearing, emboldening,
or lightening it.

/Since: 1.18/
-}
fontFaceIsSynthesized ::
    (B.CallStack.HasCallStack, MonadIO m, IsFontFace a) =>
    a
    {- ^ /@face@/: a 'GI.Pango.Objects.FontFace.FontFace' -}
    -> m Bool
    {- ^ __Returns:__ whether /@face@/ is synthesized. -}
fontFaceIsSynthesized face = liftIO $ do
    face' <- unsafeManagedPtrCastPtr face
    result <- pango_font_face_is_synthesized face'
    let result' = (/= 0) result
    touchManagedPtr face
    return result'

#if ENABLE_OVERLOADING
data FontFaceIsSynthesizedMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsFontFace a) => O.MethodInfo FontFaceIsSynthesizedMethodInfo a signature where
    overloadedMethod _ = fontFaceIsSynthesized

#endif

-- method FontFace::list_sizes
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "face", argType = TInterface (Name {namespace = "Pango", name = "FontFace"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #PangoFontFace.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "sizes", argType = TCArray False (-1) 2 (TBasicType TInt), direction = DirectionOut, mayBeNull = True, argDoc = Documentation {rawDocText = Just "\n        location to store a pointer to an array of int. This array\n        should be freed with g_free().", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "n_sizes", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store the number of elements in @sizes", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- Lengths : [Arg {argCName = "n_sizes", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store the number of elements in @sizes", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "pango_font_face_list_sizes" pango_font_face_list_sizes ::
    Ptr FontFace ->                         -- face : TInterface (Name {namespace = "Pango", name = "FontFace"})
    Ptr (Ptr Int32) ->                      -- sizes : TCArray False (-1) 2 (TBasicType TInt)
    Ptr Int32 ->                            -- n_sizes : TBasicType TInt
    IO ()

{- |
List the available sizes for a font. This is only applicable to bitmap
fonts. For scalable fonts, stores 'Nothing' at the location pointed to by
/@sizes@/ and 0 at the location pointed to by /@nSizes@/. The sizes returned
are in Pango units and are sorted in ascending order.

/Since: 1.4/
-}
fontFaceListSizes ::
    (B.CallStack.HasCallStack, MonadIO m, IsFontFace a) =>
    a
    {- ^ /@face@/: a 'GI.Pango.Objects.FontFace.FontFace'. -}
    -> m ((Maybe [Int32]))
fontFaceListSizes face = liftIO $ do
    face' <- unsafeManagedPtrCastPtr face
    sizes <- allocMem :: IO (Ptr (Ptr Int32))
    nSizes <- allocMem :: IO (Ptr Int32)
    pango_font_face_list_sizes face' sizes nSizes
    nSizes' <- peek nSizes
    sizes' <- peek sizes
    maybeSizes' <- convertIfNonNull sizes' $ \sizes'' -> do
        sizes''' <- (unpackStorableArrayWithLength nSizes') sizes''
        freeMem sizes''
        return sizes'''
    touchManagedPtr face
    freeMem sizes
    freeMem nSizes
    return maybeSizes'

#if ENABLE_OVERLOADING
data FontFaceListSizesMethodInfo
instance (signature ~ (m ((Maybe [Int32]))), MonadIO m, IsFontFace a) => O.MethodInfo FontFaceListSizesMethodInfo a signature where
    overloadedMethod _ = fontFaceListSizes

#endif