diff --git a/ChangeLog.md b/ChangeLog.md --- a/ChangeLog.md +++ b/ChangeLog.md @@ -1,3 +1,7 @@ +### 3.0.5 + ++ Update to haskell-gi(-base) 0.22 + ### 3.0.3 + Update stack version to 12.10 diff --git a/GI/GdkX11.hs b/GI/GdkX11.hs new file mode 100644 --- /dev/null +++ b/GI/GdkX11.hs @@ -0,0 +1,48 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.GdkX11 + ( module GI.GdkX11.Functions , + module GI.GdkX11.Objects , + + + + module Data.GI.Base , + + + ) where + +import GI.GdkX11.Functions +import GI.GdkX11.Objects + +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 Data.GI.Base + diff --git a/GI/GdkX11/Functions.hs b/GI/GdkX11/Functions.hs new file mode 100644 --- /dev/null +++ b/GI/GdkX11/Functions.hs @@ -0,0 +1,839 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.GdkX11.Functions + ( + + -- * Methods +-- ** x11AtomToXatom #method:x11AtomToXatom# + + x11AtomToXatom , + + +-- ** x11AtomToXatomForDisplay #method:x11AtomToXatomForDisplay# + + x11AtomToXatomForDisplay , + + +-- ** x11DeviceGetId #method:x11DeviceGetId# + + x11DeviceGetId , + + +-- ** x11DeviceManagerLookup #method:x11DeviceManagerLookup# + + x11DeviceManagerLookup , + + +-- ** x11FreeCompoundText #method:x11FreeCompoundText# + + x11FreeCompoundText , + + +-- ** x11FreeTextList #method:x11FreeTextList# + + x11FreeTextList , + + +-- ** x11GetDefaultRootXwindow #method:x11GetDefaultRootXwindow# + + x11GetDefaultRootXwindow , + + +-- ** x11GetDefaultScreen #method:x11GetDefaultScreen# + + x11GetDefaultScreen , + + +-- ** x11GetDefaultXdisplay #method:x11GetDefaultXdisplay# + + x11GetDefaultXdisplay , + + +-- ** x11GetParentRelativePattern #method:x11GetParentRelativePattern# + + x11GetParentRelativePattern , + + +-- ** x11GetServerTime #method:x11GetServerTime# + + x11GetServerTime , + + +-- ** x11GetXatomByName #method:x11GetXatomByName# + + x11GetXatomByName , + + +-- ** x11GetXatomByNameForDisplay #method:x11GetXatomByNameForDisplay# + + x11GetXatomByNameForDisplay , + + +-- ** x11GetXatomName #method:x11GetXatomName# + + x11GetXatomName , + + +-- ** x11GetXatomNameForDisplay #method:x11GetXatomNameForDisplay# + + x11GetXatomNameForDisplay , + + +-- ** x11GrabServer #method:x11GrabServer# + + x11GrabServer , + + +-- ** x11LookupXdisplay #method:x11LookupXdisplay# + + x11LookupXdisplay , + + +-- ** x11RegisterStandardEventType #method:x11RegisterStandardEventType# + + x11RegisterStandardEventType , + + +-- ** x11SetSmClientId #method:x11SetSmClientId# + + x11SetSmClientId , + + +-- ** x11UngrabServer #method:x11UngrabServer# + + x11UngrabServer , + + +-- ** x11XatomToAtom #method:x11XatomToAtom# + + x11XatomToAtom , + + +-- ** x11XatomToAtomForDisplay #method:x11XatomToAtomForDisplay# + + x11XatomToAtomForDisplay , + + + + + ) 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.Cairo.Structs.Pattern as Cairo.Pattern +import qualified GI.Gdk.Structs.Atom as Gdk.Atom +import {-# SOURCE #-} qualified GI.GdkX11.Objects.X11DeviceCore as GdkX11.X11DeviceCore +import {-# SOURCE #-} qualified GI.GdkX11.Objects.X11DeviceManagerCore as GdkX11.X11DeviceManagerCore +import {-# SOURCE #-} qualified GI.GdkX11.Objects.X11Display as GdkX11.X11Display +import {-# SOURCE #-} qualified GI.GdkX11.Objects.X11Window as GdkX11.X11Window +import qualified GI.Xlib.Structs.Display as Xlib.Display + +-- function gdk_x11_xatom_to_atom_for_display +-- Args : [Arg {argCName = "display", argType = TInterface (Name {namespace = "GdkX11", name = "X11Display"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GdkDisplay", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "xatom", argType = TBasicType TULong, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an X atom", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Gdk", name = "Atom"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gdk_x11_xatom_to_atom_for_display" gdk_x11_xatom_to_atom_for_display :: + Ptr GdkX11.X11Display.X11Display -> -- display : TInterface (Name {namespace = "GdkX11", name = "X11Display"}) + CULong -> -- xatom : TBasicType TULong + IO (Ptr Gdk.Atom.Atom) + +{- | +Convert from an X atom for a 'GI.Gdk.Objects.Display.Display' to the corresponding +'GI.Gdk.Structs.Atom.Atom'. + +/Since: 2.2/ +-} +x11XatomToAtomForDisplay :: + (B.CallStack.HasCallStack, MonadIO m, GdkX11.X11Display.IsX11Display a) => + a + {- ^ /@display@/: A 'GI.Gdk.Objects.Display.Display' -} + -> CULong + {- ^ /@xatom@/: an X atom -} + -> m Gdk.Atom.Atom + {- ^ __Returns:__ the corresponding 'GI.Gdk.Structs.Atom.Atom'. -} +x11XatomToAtomForDisplay display xatom = liftIO $ do + display' <- unsafeManagedPtrCastPtr display + result <- gdk_x11_xatom_to_atom_for_display display' xatom + checkUnexpectedReturnNULL "x11XatomToAtomForDisplay" result + result' <- (newPtr Gdk.Atom.Atom) result + touchManagedPtr display + return result' + + +-- function gdk_x11_xatom_to_atom +-- Args : [Arg {argCName = "xatom", argType = TBasicType TULong, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an X atom for the default GDK display", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "Gdk", name = "Atom"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gdk_x11_xatom_to_atom" gdk_x11_xatom_to_atom :: + CULong -> -- xatom : TBasicType TULong + IO (Ptr Gdk.Atom.Atom) + +{- | +Convert from an X atom for the default display to the corresponding +'GI.Gdk.Structs.Atom.Atom'. +-} +x11XatomToAtom :: + (B.CallStack.HasCallStack, MonadIO m) => + CULong + {- ^ /@xatom@/: an X atom for the default GDK display -} + -> m Gdk.Atom.Atom + {- ^ __Returns:__ the corresponding G@/dkAtom/@. -} +x11XatomToAtom xatom = liftIO $ do + result <- gdk_x11_xatom_to_atom xatom + checkUnexpectedReturnNULL "x11XatomToAtom" result + result' <- (newPtr Gdk.Atom.Atom) result + return result' + + +-- function gdk_x11_ungrab_server +-- Args : [] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gdk_x11_ungrab_server" gdk_x11_ungrab_server :: + IO () + +{- | +Ungrab the default display after it has been grabbed with +'GI.GdkX11.Functions.x11GrabServer'. +-} +x11UngrabServer :: + (B.CallStack.HasCallStack, MonadIO m) => + m () +x11UngrabServer = liftIO $ do + gdk_x11_ungrab_server + return () + + +-- function gdk_x11_set_sm_client_id +-- Args : [Arg {argCName = "sm_client_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the client id assigned by the session manager\n when the connection was opened, or %NULL to remove the property.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gdk_x11_set_sm_client_id" gdk_x11_set_sm_client_id :: + CString -> -- sm_client_id : TBasicType TUTF8 + IO () + +{- | +Sets the @SM_CLIENT_ID@ property on the application’s leader window so that +the window manager can save the application’s state using the X11R6 ICCCM +session management protocol. + +See the X Session Management Library documentation for more information on +session management and the Inter-Client Communication Conventions Manual + +/Since: 2.24/ +-} +x11SetSmClientId :: + (B.CallStack.HasCallStack, MonadIO m) => + Maybe (T.Text) + {- ^ /@smClientId@/: the client id assigned by the session manager + when the connection was opened, or 'Nothing' to remove the property. -} + -> m () +x11SetSmClientId smClientId = liftIO $ do + maybeSmClientId <- case smClientId of + Nothing -> return nullPtr + Just jSmClientId -> do + jSmClientId' <- textToCString jSmClientId + return jSmClientId' + gdk_x11_set_sm_client_id maybeSmClientId + freeMem maybeSmClientId + return () + + +-- function gdk_x11_register_standard_event_type +-- Args : [Arg {argCName = "display", argType = TInterface (Name {namespace = "GdkX11", name = "X11Display"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDisplay", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "event_base", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "first event type code to register", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_events", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "number of event type codes to register", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gdk_x11_register_standard_event_type" gdk_x11_register_standard_event_type :: + Ptr GdkX11.X11Display.X11Display -> -- display : TInterface (Name {namespace = "GdkX11", name = "X11Display"}) + Int32 -> -- event_base : TBasicType TInt + Int32 -> -- n_events : TBasicType TInt + IO () + +{- | +Registers interest in receiving extension events with type codes +between /@eventBase@/ and @event_base + n_events - 1@. +The registered events must have the window field in the same place +as core X events (this is not the case for e.g. XKB extension events). + +If an event type is registered, events of this type will go through +global and window-specific filters (see @/gdk_window_add_filter()/@). +Unregistered events will only go through global filters. +GDK may register the events of some X extensions on its own. + +This function should only be needed in unusual circumstances, e.g. +when filtering XInput extension events on the root window. + +/Since: 2.4/ +-} +x11RegisterStandardEventType :: + (B.CallStack.HasCallStack, MonadIO m, GdkX11.X11Display.IsX11Display a) => + a + {- ^ /@display@/: a 'GI.Gdk.Objects.Display.Display' -} + -> Int32 + {- ^ /@eventBase@/: first event type code to register -} + -> Int32 + {- ^ /@nEvents@/: number of event type codes to register -} + -> m () +x11RegisterStandardEventType display eventBase nEvents = liftIO $ do + display' <- unsafeManagedPtrCastPtr display + gdk_x11_register_standard_event_type display' eventBase nEvents + touchManagedPtr display + return () + + +-- function gdk_x11_lookup_xdisplay +-- Args : [Arg {argCName = "xdisplay", argType = TInterface (Name {namespace = "xlib", name = "Display"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a pointer to an X Display", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GdkX11", name = "X11Display"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gdk_x11_lookup_xdisplay" gdk_x11_lookup_xdisplay :: + Ptr Xlib.Display.Display -> -- xdisplay : TInterface (Name {namespace = "xlib", name = "Display"}) + IO (Ptr GdkX11.X11Display.X11Display) + +{- | +Find the 'GI.Gdk.Objects.Display.Display' corresponding to /@xdisplay@/, if any exists. + +/Since: 2.2/ +-} +x11LookupXdisplay :: + (B.CallStack.HasCallStack, MonadIO m) => + Xlib.Display.Display + {- ^ /@xdisplay@/: a pointer to an X Display -} + -> m GdkX11.X11Display.X11Display + {- ^ __Returns:__ the 'GI.Gdk.Objects.Display.Display', if found, otherwise 'Nothing'. -} +x11LookupXdisplay xdisplay = liftIO $ do + xdisplay' <- unsafeManagedPtrGetPtr xdisplay + result <- gdk_x11_lookup_xdisplay xdisplay' + checkUnexpectedReturnNULL "x11LookupXdisplay" result + result' <- (newObject GdkX11.X11Display.X11Display) result + touchManagedPtr xdisplay + return result' + + +-- function gdk_x11_grab_server +-- Args : [] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gdk_x11_grab_server" gdk_x11_grab_server :: + IO () + +{- | +Call 'GI.GdkX11.Objects.X11Display.x11DisplayGrab' on the default display. +To ungrab the server again, use 'GI.GdkX11.Functions.x11UngrabServer'. + +'GI.GdkX11.Functions.x11GrabServer'\/'GI.GdkX11.Functions.x11UngrabServer' calls can be nested. +-} +x11GrabServer :: + (B.CallStack.HasCallStack, MonadIO m) => + m () +x11GrabServer = liftIO $ do + gdk_x11_grab_server + return () + + +-- function gdk_x11_get_xatom_name_for_display +-- Args : [Arg {argCName = "display", argType = TInterface (Name {namespace = "GdkX11", name = "X11Display"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GdkDisplay where @xatom is defined", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "xatom", argType = TBasicType TULong, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an X atom", 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 "gdk_x11_get_xatom_name_for_display" gdk_x11_get_xatom_name_for_display :: + Ptr GdkX11.X11Display.X11Display -> -- display : TInterface (Name {namespace = "GdkX11", name = "X11Display"}) + CULong -> -- xatom : TBasicType TULong + IO CString + +{- | +Returns the name of an X atom for its display. This +function is meant mainly for debugging, so for convenience, unlike +@/XAtomName()/@ and 'GI.Gdk.Structs.Atom.atomName', the result doesn’t need to +be freed. + +/Since: 2.2/ +-} +x11GetXatomNameForDisplay :: + (B.CallStack.HasCallStack, MonadIO m, GdkX11.X11Display.IsX11Display a) => + a + {- ^ /@display@/: the 'GI.Gdk.Objects.Display.Display' where /@xatom@/ is defined -} + -> CULong + {- ^ /@xatom@/: an X atom -} + -> m T.Text + {- ^ __Returns:__ name of the X atom; this string is owned by GDK, + so it shouldn’t be modifed or freed. -} +x11GetXatomNameForDisplay display xatom = liftIO $ do + display' <- unsafeManagedPtrCastPtr display + result <- gdk_x11_get_xatom_name_for_display display' xatom + checkUnexpectedReturnNULL "x11GetXatomNameForDisplay" result + result' <- cstringToText result + touchManagedPtr display + return result' + + +-- function gdk_x11_get_xatom_name +-- Args : [Arg {argCName = "xatom", argType = TBasicType TULong, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an X atom for GDK\8217s default display", 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 "gdk_x11_get_xatom_name" gdk_x11_get_xatom_name :: + CULong -> -- xatom : TBasicType TULong + IO CString + +{- | +Returns the name of an X atom for GDK’s default display. This +function is meant mainly for debugging, so for convenience, unlike +@/XAtomName()/@ and 'GI.Gdk.Structs.Atom.atomName', the result +doesn’t need to be freed. Also, this function will never return 'Nothing', +even if /@xatom@/ is invalid. +-} +x11GetXatomName :: + (B.CallStack.HasCallStack, MonadIO m) => + CULong + {- ^ /@xatom@/: an X atom for GDK’s default display -} + -> m T.Text + {- ^ __Returns:__ name of the X atom; this string is owned by GTK+, + so it shouldn’t be modifed or freed. -} +x11GetXatomName xatom = liftIO $ do + result <- gdk_x11_get_xatom_name xatom + checkUnexpectedReturnNULL "x11GetXatomName" result + result' <- cstringToText result + return result' + + +-- function gdk_x11_get_xatom_by_name_for_display +-- Args : [Arg {argCName = "display", argType = TInterface (Name {namespace = "GdkX11", name = "X11Display"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDisplay", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "atom_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a string", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TULong) +-- throws : False +-- Skip return : False + +foreign import ccall "gdk_x11_get_xatom_by_name_for_display" gdk_x11_get_xatom_by_name_for_display :: + Ptr GdkX11.X11Display.X11Display -> -- display : TInterface (Name {namespace = "GdkX11", name = "X11Display"}) + CString -> -- atom_name : TBasicType TUTF8 + IO CULong + +{- | +Returns the X atom for a 'GI.Gdk.Objects.Display.Display' corresponding to /@atomName@/. +This function caches the result, so if called repeatedly it is much +faster than @/XInternAtom()/@, which is a round trip to the server each time. + +/Since: 2.2/ +-} +x11GetXatomByNameForDisplay :: + (B.CallStack.HasCallStack, MonadIO m, GdkX11.X11Display.IsX11Display a) => + a + {- ^ /@display@/: a 'GI.Gdk.Objects.Display.Display' -} + -> T.Text + {- ^ /@atomName@/: a string -} + -> m CULong + {- ^ __Returns:__ a X atom for a 'GI.Gdk.Objects.Display.Display' -} +x11GetXatomByNameForDisplay display atomName = liftIO $ do + display' <- unsafeManagedPtrCastPtr display + atomName' <- textToCString atomName + result <- gdk_x11_get_xatom_by_name_for_display display' atomName' + touchManagedPtr display + freeMem atomName' + return result + + +-- function gdk_x11_get_xatom_by_name +-- Args : [Arg {argCName = "atom_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a string", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TULong) +-- throws : False +-- Skip return : False + +foreign import ccall "gdk_x11_get_xatom_by_name" gdk_x11_get_xatom_by_name :: + CString -> -- atom_name : TBasicType TUTF8 + IO CULong + +{- | +Returns the X atom for GDK’s default display corresponding to /@atomName@/. +This function caches the result, so if called repeatedly it is much +faster than @/XInternAtom()/@, which is a round trip to the server each time. +-} +x11GetXatomByName :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + {- ^ /@atomName@/: a string -} + -> m CULong + {- ^ __Returns:__ a X atom for GDK’s default display. -} +x11GetXatomByName atomName = liftIO $ do + atomName' <- textToCString atomName + result <- gdk_x11_get_xatom_by_name atomName' + freeMem atomName' + return result + + +-- function gdk_x11_get_server_time +-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "GdkX11", name = "X11Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkWindow, used for communication\n with the server. The window must have\n GDK_PROPERTY_CHANGE_MASK in its events mask or a hang will\n result.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt32) +-- throws : False +-- Skip return : False + +foreign import ccall "gdk_x11_get_server_time" gdk_x11_get_server_time :: + Ptr GdkX11.X11Window.X11Window -> -- window : TInterface (Name {namespace = "GdkX11", name = "X11Window"}) + IO Word32 + +{- | +Routine to get the current X server time stamp. +-} +x11GetServerTime :: + (B.CallStack.HasCallStack, MonadIO m, GdkX11.X11Window.IsX11Window a) => + a + {- ^ /@window@/: a 'GI.Gdk.Objects.Window.Window', used for communication + with the server. The window must have + GDK_PROPERTY_CHANGE_MASK in its events mask or a hang will + result. -} + -> m Word32 + {- ^ __Returns:__ the time stamp. -} +x11GetServerTime window = liftIO $ do + window' <- unsafeManagedPtrCastPtr window + result <- gdk_x11_get_server_time window' + touchManagedPtr window + return result + + +-- function gdk_x11_get_parent_relative_pattern +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "cairo", name = "Pattern"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gdk_x11_get_parent_relative_pattern" gdk_x11_get_parent_relative_pattern :: + IO (Ptr Cairo.Pattern.Pattern) + +{-# DEPRECATED x11GetParentRelativePattern ["(Since version 3.24)","Don\\'t use this function"] #-} +{- | +Used with 'GI.Gdk.Objects.Window.windowSetBackgroundPattern' to inherit background from +parent window. Useful for imitating transparency when compositing is not +available. Otherwise behaves like a transparent pattern. + +/Since: 3.24.2/ +-} +x11GetParentRelativePattern :: + (B.CallStack.HasCallStack, MonadIO m) => + m Cairo.Pattern.Pattern +x11GetParentRelativePattern = liftIO $ do + result <- gdk_x11_get_parent_relative_pattern + checkUnexpectedReturnNULL "x11GetParentRelativePattern" result + result' <- (wrapBoxed Cairo.Pattern.Pattern) result + return result' + + +-- function gdk_x11_get_default_xdisplay +-- Args : [] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "xlib", name = "Display"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gdk_x11_get_default_xdisplay" gdk_x11_get_default_xdisplay :: + IO (Ptr Xlib.Display.Display) + +{- | +Gets the default GTK+ display. +-} +x11GetDefaultXdisplay :: + (B.CallStack.HasCallStack, MonadIO m) => + m Xlib.Display.Display + {- ^ __Returns:__ the Xlib Display* for +the display specified in the @--display@ command +line option or the @DISPLAY@ environment variable. -} +x11GetDefaultXdisplay = liftIO $ do + result <- gdk_x11_get_default_xdisplay + checkUnexpectedReturnNULL "x11GetDefaultXdisplay" result + result' <- (newPtr Xlib.Display.Display) result + return result' + + +-- function gdk_x11_get_default_screen +-- Args : [] +-- Lengths : [] +-- returnType : Just (TBasicType TInt) +-- throws : False +-- Skip return : False + +foreign import ccall "gdk_x11_get_default_screen" gdk_x11_get_default_screen :: + IO Int32 + +{- | +Gets the default GTK+ screen number. +-} +x11GetDefaultScreen :: + (B.CallStack.HasCallStack, MonadIO m) => + m Int32 + {- ^ __Returns:__ returns the screen number specified by + the --display command line option or the DISPLAY environment + variable when 'GI.Gdk.Functions.init' calls 'GI.Xlib.Functions.openDisplay'. -} +x11GetDefaultScreen = liftIO $ do + result <- gdk_x11_get_default_screen + return result + + +-- function gdk_x11_get_default_root_xwindow +-- Args : [] +-- Lengths : [] +-- returnType : Just (TBasicType TULong) +-- throws : False +-- Skip return : False + +foreign import ccall "gdk_x11_get_default_root_xwindow" gdk_x11_get_default_root_xwindow :: + IO CULong + +{- | +Gets the root window of the default screen +(see 'GI.GdkX11.Functions.x11GetDefaultScreen'). +-} +x11GetDefaultRootXwindow :: + (B.CallStack.HasCallStack, MonadIO m) => + m CULong + {- ^ __Returns:__ an Xlib Window. -} +x11GetDefaultRootXwindow = liftIO $ do + result <- gdk_x11_get_default_root_xwindow + return result + + +-- function gdk_x11_free_text_list +-- Args : [Arg {argCName = "list", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the value stored in the @list parameter by\n a call to gdk_x11_display_text_property_to_text_list().", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gdk_x11_free_text_list" gdk_x11_free_text_list :: + CString -> -- list : TBasicType TUTF8 + IO () + +{- | +Frees the array of strings created by +'GI.GdkX11.Objects.X11Display.x11DisplayTextPropertyToTextList'. + +/Since: 2.24/ +-} +x11FreeTextList :: + (B.CallStack.HasCallStack, MonadIO m) => + T.Text + {- ^ /@list@/: the value stored in the /@list@/ parameter by + a call to 'GI.GdkX11.Objects.X11Display.x11DisplayTextPropertyToTextList'. -} + -> m () +x11FreeTextList list = liftIO $ do + list' <- textToCString list + gdk_x11_free_text_list list' + freeMem list' + return () + + +-- function gdk_x11_free_compound_text +-- Args : [Arg {argCName = "ctext", argType = TBasicType TUInt8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The pointer stored in @ctext from a call to\n gdk_x11_display_string_to_compound_text().", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gdk_x11_free_compound_text" gdk_x11_free_compound_text :: + Word8 -> -- ctext : TBasicType TUInt8 + IO () + +{- | +Frees the data returned from 'GI.GdkX11.Objects.X11Display.x11DisplayStringToCompoundText'. + +/Since: 2.24/ +-} +x11FreeCompoundText :: + (B.CallStack.HasCallStack, MonadIO m) => + Word8 + {- ^ /@ctext@/: The pointer stored in /@ctext@/ from a call to + 'GI.GdkX11.Objects.X11Display.x11DisplayStringToCompoundText'. -} + -> m () +x11FreeCompoundText ctext = liftIO $ do + gdk_x11_free_compound_text ctext + return () + + +-- function gdk_x11_device_manager_lookup +-- Args : [Arg {argCName = "device_manager", argType = TInterface (Name {namespace = "GdkX11", name = "X11DeviceManagerCore"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDeviceManager", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "device_id", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a device ID, as understood by the XInput2 protocol", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GdkX11", name = "X11DeviceCore"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gdk_x11_device_manager_lookup" gdk_x11_device_manager_lookup :: + Ptr GdkX11.X11DeviceManagerCore.X11DeviceManagerCore -> -- device_manager : TInterface (Name {namespace = "GdkX11", name = "X11DeviceManagerCore"}) + Int32 -> -- device_id : TBasicType TInt + IO (Ptr GdkX11.X11DeviceCore.X11DeviceCore) + +{- | +Returns the 'GI.Gdk.Objects.Device.Device' that wraps the given device ID. + +/Since: 3.2/ +-} +x11DeviceManagerLookup :: + (B.CallStack.HasCallStack, MonadIO m, GdkX11.X11DeviceManagerCore.IsX11DeviceManagerCore a) => + a + {- ^ /@deviceManager@/: a 'GI.Gdk.Objects.DeviceManager.DeviceManager' -} + -> Int32 + {- ^ /@deviceId@/: a device ID, as understood by the XInput2 protocol -} + -> m (Maybe GdkX11.X11DeviceCore.X11DeviceCore) + {- ^ __Returns:__ The 'GI.Gdk.Objects.Device.Device' wrapping the device ID, + or 'Nothing' if the given ID doesn’t currently represent a device. -} +x11DeviceManagerLookup deviceManager deviceId = liftIO $ do + deviceManager' <- unsafeManagedPtrCastPtr deviceManager + result <- gdk_x11_device_manager_lookup deviceManager' deviceId + maybeResult <- convertIfNonNull result $ \result' -> do + result'' <- (newObject GdkX11.X11DeviceCore.X11DeviceCore) result' + return result'' + touchManagedPtr deviceManager + return maybeResult + + +-- function gdk_x11_device_get_id +-- Args : [Arg {argCName = "device", argType = TInterface (Name {namespace = "GdkX11", name = "X11DeviceCore"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDevice", 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 "gdk_x11_device_get_id" gdk_x11_device_get_id :: + Ptr GdkX11.X11DeviceCore.X11DeviceCore -> -- device : TInterface (Name {namespace = "GdkX11", name = "X11DeviceCore"}) + IO Int32 + +{- | +Returns the device ID as seen by XInput2. + +> If 'GI.Gdk.Functions.disableMultidevice' has been called, this function +> will respectively return 2\/3 for the core pointer and keyboard, +> (matching the IDs for the Virtual Core Pointer and Keyboard in +> XInput 2), but calling this function on any slave devices (i.e. +> those managed via XInput 1.x), will return 0. + +/Since: 3.2/ +-} +x11DeviceGetId :: + (B.CallStack.HasCallStack, MonadIO m, GdkX11.X11DeviceCore.IsX11DeviceCore a) => + a + {- ^ /@device@/: a 'GI.Gdk.Objects.Device.Device' -} + -> m Int32 + {- ^ __Returns:__ the XInput2 device ID. -} +x11DeviceGetId device = liftIO $ do + device' <- unsafeManagedPtrCastPtr device + result <- gdk_x11_device_get_id device' + touchManagedPtr device + return result + + +-- function gdk_x11_atom_to_xatom_for_display +-- Args : [Arg {argCName = "display", argType = TInterface (Name {namespace = "GdkX11", name = "X11Display"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GdkDisplay", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "atom", argType = TInterface (Name {namespace = "Gdk", name = "Atom"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GdkAtom, or %GDK_NONE", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TULong) +-- throws : False +-- Skip return : False + +foreign import ccall "gdk_x11_atom_to_xatom_for_display" gdk_x11_atom_to_xatom_for_display :: + Ptr GdkX11.X11Display.X11Display -> -- display : TInterface (Name {namespace = "GdkX11", name = "X11Display"}) + Ptr Gdk.Atom.Atom -> -- atom : TInterface (Name {namespace = "Gdk", name = "Atom"}) + IO CULong + +{- | +Converts from a 'GI.Gdk.Structs.Atom.Atom' to the X atom for a 'GI.Gdk.Objects.Display.Display' +with the same string value. The special value @/GDK_NONE/@ +is converted to @/None/@. + +/Since: 2.2/ +-} +x11AtomToXatomForDisplay :: + (B.CallStack.HasCallStack, MonadIO m, GdkX11.X11Display.IsX11Display a) => + a + {- ^ /@display@/: A 'GI.Gdk.Objects.Display.Display' -} + -> Gdk.Atom.Atom + {- ^ /@atom@/: A 'GI.Gdk.Structs.Atom.Atom', or @/GDK_NONE/@ -} + -> m CULong + {- ^ __Returns:__ the X atom corresponding to /@atom@/, or @/None/@ -} +x11AtomToXatomForDisplay display atom = liftIO $ do + display' <- unsafeManagedPtrCastPtr display + atom' <- unsafeManagedPtrGetPtr atom + result <- gdk_x11_atom_to_xatom_for_display display' atom' + touchManagedPtr display + touchManagedPtr atom + return result + + +-- function gdk_x11_atom_to_xatom +-- Args : [Arg {argCName = "atom", argType = TInterface (Name {namespace = "Gdk", name = "Atom"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GdkAtom", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TULong) +-- throws : False +-- Skip return : False + +foreign import ccall "gdk_x11_atom_to_xatom" gdk_x11_atom_to_xatom :: + Ptr Gdk.Atom.Atom -> -- atom : TInterface (Name {namespace = "Gdk", name = "Atom"}) + IO CULong + +{- | +Converts from a 'GI.Gdk.Structs.Atom.Atom' to the X atom for the default GDK display +with the same string value. +-} +x11AtomToXatom :: + (B.CallStack.HasCallStack, MonadIO m) => + Gdk.Atom.Atom + {- ^ /@atom@/: A 'GI.Gdk.Structs.Atom.Atom' -} + -> m CULong + {- ^ __Returns:__ the X atom corresponding to /@atom@/. -} +x11AtomToXatom atom = liftIO $ do + atom' <- unsafeManagedPtrGetPtr atom + result <- gdk_x11_atom_to_xatom atom' + touchManagedPtr atom + return result + + + diff --git a/GI/GdkX11/Objects.hs b/GI/GdkX11/Objects.hs new file mode 100644 --- /dev/null +++ b/GI/GdkX11/Objects.hs @@ -0,0 +1,69 @@ + + +{- | +Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte +License : LGPL-2.1 +Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) +-} + +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) + +module GI.GdkX11.Objects + ( module GI.GdkX11.Objects.X11AppLaunchContext, + module GI.GdkX11.Objects.X11Cursor , + module GI.GdkX11.Objects.X11DeviceCore , + module GI.GdkX11.Objects.X11DeviceManagerCore, + module GI.GdkX11.Objects.X11DeviceManagerXI2, + module GI.GdkX11.Objects.X11DeviceXI2 , + module GI.GdkX11.Objects.X11Display , + module GI.GdkX11.Objects.X11DisplayManager, + module GI.GdkX11.Objects.X11DragContext , + module GI.GdkX11.Objects.X11GLContext , + module GI.GdkX11.Objects.X11Keymap , + module GI.GdkX11.Objects.X11Monitor , + module GI.GdkX11.Objects.X11Screen , + module GI.GdkX11.Objects.X11Visual , + module GI.GdkX11.Objects.X11Window , + + + ) where + +import GI.GdkX11.Objects.X11AppLaunchContext +import GI.GdkX11.Objects.X11Cursor +import GI.GdkX11.Objects.X11DeviceCore +import GI.GdkX11.Objects.X11DeviceManagerCore +import GI.GdkX11.Objects.X11DeviceManagerXI2 +import GI.GdkX11.Objects.X11DeviceXI2 +import GI.GdkX11.Objects.X11Display +import GI.GdkX11.Objects.X11DisplayManager +import GI.GdkX11.Objects.X11DragContext +import GI.GdkX11.Objects.X11GLContext +import GI.GdkX11.Objects.X11Keymap +import GI.GdkX11.Objects.X11Monitor +import GI.GdkX11.Objects.X11Screen +import GI.GdkX11.Objects.X11Visual +import GI.GdkX11.Objects.X11Window + +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 + + + diff --git a/GI/GdkX11/Objects/X11AppLaunchContext.hs b/GI/GdkX11/Objects/X11AppLaunchContext.hs new file mode 100644 --- /dev/null +++ b/GI/GdkX11/Objects/X11AppLaunchContext.hs @@ -0,0 +1,135 @@ + + +{- | +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.GdkX11.Objects.X11AppLaunchContext + ( + +-- * Exported types + X11AppLaunchContext(..) , + IsX11AppLaunchContext , + toX11AppLaunchContext , + noX11AppLaunchContext , + + + ) 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 qualified GI.Gdk.Objects.AppLaunchContext as Gdk.AppLaunchContext +import qualified GI.Gio.Objects.AppLaunchContext as Gio.AppLaunchContext + +-- | Memory-managed wrapper type. +newtype X11AppLaunchContext = X11AppLaunchContext (ManagedPtr X11AppLaunchContext) +foreign import ccall "gdk_x11_app_launch_context_get_type" + c_gdk_x11_app_launch_context_get_type :: IO GType + +instance GObject X11AppLaunchContext where + gobjectType = c_gdk_x11_app_launch_context_get_type + + +-- | Type class for types which can be safely cast to `X11AppLaunchContext`, for instance with `toX11AppLaunchContext`. +class (GObject o, O.IsDescendantOf X11AppLaunchContext o) => IsX11AppLaunchContext o +instance (GObject o, O.IsDescendantOf X11AppLaunchContext o) => IsX11AppLaunchContext o + +instance O.HasParentTypes X11AppLaunchContext +type instance O.ParentTypes X11AppLaunchContext = '[Gdk.AppLaunchContext.AppLaunchContext, Gio.AppLaunchContext.AppLaunchContext, GObject.Object.Object] + +-- | Cast to `X11AppLaunchContext`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toX11AppLaunchContext :: (MonadIO m, IsX11AppLaunchContext o) => o -> m X11AppLaunchContext +toX11AppLaunchContext = liftIO . unsafeCastTo X11AppLaunchContext + +-- | A convenience alias for `Nothing` :: `Maybe` `X11AppLaunchContext`. +noX11AppLaunchContext :: Maybe X11AppLaunchContext +noX11AppLaunchContext = Nothing + +#if ENABLE_OVERLOADING +type family ResolveX11AppLaunchContextMethod (t :: Symbol) (o :: *) :: * where + ResolveX11AppLaunchContextMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveX11AppLaunchContextMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveX11AppLaunchContextMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveX11AppLaunchContextMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveX11AppLaunchContextMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveX11AppLaunchContextMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveX11AppLaunchContextMethod "launchFailed" o = Gio.AppLaunchContext.AppLaunchContextLaunchFailedMethodInfo + ResolveX11AppLaunchContextMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveX11AppLaunchContextMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveX11AppLaunchContextMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveX11AppLaunchContextMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveX11AppLaunchContextMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveX11AppLaunchContextMethod "setenv" o = Gio.AppLaunchContext.AppLaunchContextSetenvMethodInfo + ResolveX11AppLaunchContextMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveX11AppLaunchContextMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveX11AppLaunchContextMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveX11AppLaunchContextMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveX11AppLaunchContextMethod "unsetenv" o = Gio.AppLaunchContext.AppLaunchContextUnsetenvMethodInfo + ResolveX11AppLaunchContextMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveX11AppLaunchContextMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveX11AppLaunchContextMethod "getDisplay" o = Gio.AppLaunchContext.AppLaunchContextGetDisplayMethodInfo + ResolveX11AppLaunchContextMethod "getEnvironment" o = Gio.AppLaunchContext.AppLaunchContextGetEnvironmentMethodInfo + ResolveX11AppLaunchContextMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveX11AppLaunchContextMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveX11AppLaunchContextMethod "getStartupNotifyId" o = Gio.AppLaunchContext.AppLaunchContextGetStartupNotifyIdMethodInfo + ResolveX11AppLaunchContextMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveX11AppLaunchContextMethod "setDesktop" o = Gdk.AppLaunchContext.AppLaunchContextSetDesktopMethodInfo + ResolveX11AppLaunchContextMethod "setDisplay" o = Gdk.AppLaunchContext.AppLaunchContextSetDisplayMethodInfo + ResolveX11AppLaunchContextMethod "setIcon" o = Gdk.AppLaunchContext.AppLaunchContextSetIconMethodInfo + ResolveX11AppLaunchContextMethod "setIconName" o = Gdk.AppLaunchContext.AppLaunchContextSetIconNameMethodInfo + ResolveX11AppLaunchContextMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveX11AppLaunchContextMethod "setScreen" o = Gdk.AppLaunchContext.AppLaunchContextSetScreenMethodInfo + ResolveX11AppLaunchContextMethod "setTimestamp" o = Gdk.AppLaunchContext.AppLaunchContextSetTimestampMethodInfo + ResolveX11AppLaunchContextMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveX11AppLaunchContextMethod t X11AppLaunchContext, O.MethodInfo info X11AppLaunchContext p) => OL.IsLabel t (X11AppLaunchContext -> 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 X11AppLaunchContext +type instance O.AttributeList X11AppLaunchContext = X11AppLaunchContextAttributeList +type X11AppLaunchContextAttributeList = ('[ '("display", Gdk.AppLaunchContext.AppLaunchContextDisplayPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList X11AppLaunchContext = X11AppLaunchContextSignalList +type X11AppLaunchContextSignalList = ('[ '("launchFailed", Gio.AppLaunchContext.AppLaunchContextLaunchFailedSignalInfo), '("launched", Gio.AppLaunchContext.AppLaunchContextLaunchedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + + diff --git a/GI/GdkX11/Objects/X11AppLaunchContext.hs-boot b/GI/GdkX11/Objects/X11AppLaunchContext.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GdkX11/Objects/X11AppLaunchContext.hs-boot @@ -0,0 +1,29 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GdkX11.Objects.X11AppLaunchContext 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 + +newtype X11AppLaunchContext = X11AppLaunchContext (ManagedPtr X11AppLaunchContext) +instance GObject X11AppLaunchContext where +class (GObject o, O.IsDescendantOf X11AppLaunchContext o) => IsX11AppLaunchContext o +instance (GObject o, O.IsDescendantOf X11AppLaunchContext o) => IsX11AppLaunchContext o +instance O.HasParentTypes X11AppLaunchContext diff --git a/GI/GdkX11/Objects/X11Cursor.hs b/GI/GdkX11/Objects/X11Cursor.hs new file mode 100644 --- /dev/null +++ b/GI/GdkX11/Objects/X11Cursor.hs @@ -0,0 +1,218 @@ + + +{- | +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.GdkX11.Objects.X11Cursor + ( + +-- * Exported types + X11Cursor(..) , + IsX11Cursor , + toX11Cursor , + noX11Cursor , + + + -- * Methods +-- ** getXcursor #method:getXcursor# + +#if ENABLE_OVERLOADING + X11CursorGetXcursorMethodInfo , +#endif + x11CursorGetXcursor , + + +-- ** getXdisplay #method:getXdisplay# + +#if ENABLE_OVERLOADING + X11CursorGetXdisplayMethodInfo , +#endif + x11CursorGetXdisplay , + + + + + ) 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 qualified GI.Gdk.Objects.Cursor as Gdk.Cursor +import qualified GI.Xlib.Structs.Display as Xlib.Display + +-- | Memory-managed wrapper type. +newtype X11Cursor = X11Cursor (ManagedPtr X11Cursor) +foreign import ccall "gdk_x11_cursor_get_type" + c_gdk_x11_cursor_get_type :: IO GType + +instance GObject X11Cursor where + gobjectType = c_gdk_x11_cursor_get_type + + +-- | Type class for types which can be safely cast to `X11Cursor`, for instance with `toX11Cursor`. +class (GObject o, O.IsDescendantOf X11Cursor o) => IsX11Cursor o +instance (GObject o, O.IsDescendantOf X11Cursor o) => IsX11Cursor o + +instance O.HasParentTypes X11Cursor +type instance O.ParentTypes X11Cursor = '[Gdk.Cursor.Cursor, GObject.Object.Object] + +-- | Cast to `X11Cursor`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toX11Cursor :: (MonadIO m, IsX11Cursor o) => o -> m X11Cursor +toX11Cursor = liftIO . unsafeCastTo X11Cursor + +-- | A convenience alias for `Nothing` :: `Maybe` `X11Cursor`. +noX11Cursor :: Maybe X11Cursor +noX11Cursor = Nothing + +#if ENABLE_OVERLOADING +type family ResolveX11CursorMethod (t :: Symbol) (o :: *) :: * where + ResolveX11CursorMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveX11CursorMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveX11CursorMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveX11CursorMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveX11CursorMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveX11CursorMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveX11CursorMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveX11CursorMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveX11CursorMethod "ref" o = Gdk.Cursor.CursorRefMethodInfo + ResolveX11CursorMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveX11CursorMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveX11CursorMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveX11CursorMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveX11CursorMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveX11CursorMethod "unref" o = Gdk.Cursor.CursorUnrefMethodInfo + ResolveX11CursorMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveX11CursorMethod "getCursorType" o = Gdk.Cursor.CursorGetCursorTypeMethodInfo + ResolveX11CursorMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveX11CursorMethod "getDisplay" o = Gdk.Cursor.CursorGetDisplayMethodInfo + ResolveX11CursorMethod "getImage" o = Gdk.Cursor.CursorGetImageMethodInfo + ResolveX11CursorMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveX11CursorMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveX11CursorMethod "getSurface" o = Gdk.Cursor.CursorGetSurfaceMethodInfo + ResolveX11CursorMethod "getXcursor" o = X11CursorGetXcursorMethodInfo + ResolveX11CursorMethod "getXdisplay" o = X11CursorGetXdisplayMethodInfo + ResolveX11CursorMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveX11CursorMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveX11CursorMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveX11CursorMethod t X11Cursor, O.MethodInfo info X11Cursor p) => OL.IsLabel t (X11Cursor -> 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 X11Cursor +type instance O.AttributeList X11Cursor = X11CursorAttributeList +type X11CursorAttributeList = ('[ '("cursorType", Gdk.Cursor.CursorCursorTypePropertyInfo), '("display", Gdk.Cursor.CursorDisplayPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList X11Cursor = X11CursorSignalList +type X11CursorSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method X11Cursor::get_xcursor +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "cursor", argType = TInterface (Name {namespace = "GdkX11", name = "X11Cursor"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkCursor.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TULong) +-- throws : False +-- Skip return : False + +foreign import ccall "gdk_x11_cursor_get_xcursor" gdk_x11_cursor_get_xcursor :: + Ptr X11Cursor -> -- cursor : TInterface (Name {namespace = "GdkX11", name = "X11Cursor"}) + IO CULong + +{- | +Returns the X cursor belonging to a 'GI.Gdk.Objects.Cursor.Cursor'. +-} +x11CursorGetXcursor :: + (B.CallStack.HasCallStack, MonadIO m, IsX11Cursor a) => + a + {- ^ /@cursor@/: a 'GI.Gdk.Objects.Cursor.Cursor'. -} + -> m CULong + {- ^ __Returns:__ an Xlib Cursor. -} +x11CursorGetXcursor cursor = liftIO $ do + cursor' <- unsafeManagedPtrCastPtr cursor + result <- gdk_x11_cursor_get_xcursor cursor' + touchManagedPtr cursor + return result + +#if ENABLE_OVERLOADING +data X11CursorGetXcursorMethodInfo +instance (signature ~ (m CULong), MonadIO m, IsX11Cursor a) => O.MethodInfo X11CursorGetXcursorMethodInfo a signature where + overloadedMethod _ = x11CursorGetXcursor + +#endif + +-- method X11Cursor::get_xdisplay +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "cursor", argType = TInterface (Name {namespace = "GdkX11", name = "X11Cursor"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkCursor.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "xlib", name = "Display"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gdk_x11_cursor_get_xdisplay" gdk_x11_cursor_get_xdisplay :: + Ptr X11Cursor -> -- cursor : TInterface (Name {namespace = "GdkX11", name = "X11Cursor"}) + IO (Ptr Xlib.Display.Display) + +{- | +Returns the display of a 'GI.Gdk.Objects.Cursor.Cursor'. +-} +x11CursorGetXdisplay :: + (B.CallStack.HasCallStack, MonadIO m, IsX11Cursor a) => + a + {- ^ /@cursor@/: a 'GI.Gdk.Objects.Cursor.Cursor'. -} + -> m Xlib.Display.Display + {- ^ __Returns:__ an Xlib Display*. -} +x11CursorGetXdisplay cursor = liftIO $ do + cursor' <- unsafeManagedPtrCastPtr cursor + result <- gdk_x11_cursor_get_xdisplay cursor' + checkUnexpectedReturnNULL "x11CursorGetXdisplay" result + result' <- (newPtr Xlib.Display.Display) result + touchManagedPtr cursor + return result' + +#if ENABLE_OVERLOADING +data X11CursorGetXdisplayMethodInfo +instance (signature ~ (m Xlib.Display.Display), MonadIO m, IsX11Cursor a) => O.MethodInfo X11CursorGetXdisplayMethodInfo a signature where + overloadedMethod _ = x11CursorGetXdisplay + +#endif + + diff --git a/GI/GdkX11/Objects/X11Cursor.hs-boot b/GI/GdkX11/Objects/X11Cursor.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GdkX11/Objects/X11Cursor.hs-boot @@ -0,0 +1,35 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GdkX11.Objects.X11Cursor 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 + +newtype X11Cursor = X11Cursor (ManagedPtr X11Cursor) +instance GObject X11Cursor where +class (GObject o, O.IsDescendantOf X11Cursor o) => IsX11Cursor o +instance (GObject o, O.IsDescendantOf X11Cursor o) => IsX11Cursor o +instance O.HasParentTypes X11Cursor +#if ENABLE_OVERLOADING +data X11CursorGetXcursorMethodInfo +#endif +#if ENABLE_OVERLOADING +data X11CursorGetXdisplayMethodInfo +#endif diff --git a/GI/GdkX11/Objects/X11DeviceCore.hs b/GI/GdkX11/Objects/X11DeviceCore.hs new file mode 100644 --- /dev/null +++ b/GI/GdkX11/Objects/X11DeviceCore.hs @@ -0,0 +1,150 @@ + + +{- | +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.GdkX11.Objects.X11DeviceCore + ( + +-- * Exported types + X11DeviceCore(..) , + IsX11DeviceCore , + toX11DeviceCore , + noX11DeviceCore , + + + ) 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 qualified GI.Gdk.Objects.Device as Gdk.Device + +-- | Memory-managed wrapper type. +newtype X11DeviceCore = X11DeviceCore (ManagedPtr X11DeviceCore) +foreign import ccall "gdk_x11_device_core_get_type" + c_gdk_x11_device_core_get_type :: IO GType + +instance GObject X11DeviceCore where + gobjectType = c_gdk_x11_device_core_get_type + + +-- | Type class for types which can be safely cast to `X11DeviceCore`, for instance with `toX11DeviceCore`. +class (GObject o, O.IsDescendantOf X11DeviceCore o) => IsX11DeviceCore o +instance (GObject o, O.IsDescendantOf X11DeviceCore o) => IsX11DeviceCore o + +instance O.HasParentTypes X11DeviceCore +type instance O.ParentTypes X11DeviceCore = '[Gdk.Device.Device, GObject.Object.Object] + +-- | Cast to `X11DeviceCore`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toX11DeviceCore :: (MonadIO m, IsX11DeviceCore o) => o -> m X11DeviceCore +toX11DeviceCore = liftIO . unsafeCastTo X11DeviceCore + +-- | A convenience alias for `Nothing` :: `Maybe` `X11DeviceCore`. +noX11DeviceCore :: Maybe X11DeviceCore +noX11DeviceCore = Nothing + +#if ENABLE_OVERLOADING +type family ResolveX11DeviceCoreMethod (t :: Symbol) (o :: *) :: * where + ResolveX11DeviceCoreMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveX11DeviceCoreMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveX11DeviceCoreMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveX11DeviceCoreMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveX11DeviceCoreMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveX11DeviceCoreMethod "grab" o = Gdk.Device.DeviceGrabMethodInfo + ResolveX11DeviceCoreMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveX11DeviceCoreMethod "listAxes" o = Gdk.Device.DeviceListAxesMethodInfo + ResolveX11DeviceCoreMethod "listSlaveDevices" o = Gdk.Device.DeviceListSlaveDevicesMethodInfo + ResolveX11DeviceCoreMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveX11DeviceCoreMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveX11DeviceCoreMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveX11DeviceCoreMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveX11DeviceCoreMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveX11DeviceCoreMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveX11DeviceCoreMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveX11DeviceCoreMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveX11DeviceCoreMethod "ungrab" o = Gdk.Device.DeviceUngrabMethodInfo + ResolveX11DeviceCoreMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveX11DeviceCoreMethod "warp" o = Gdk.Device.DeviceWarpMethodInfo + ResolveX11DeviceCoreMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveX11DeviceCoreMethod "getAssociatedDevice" o = Gdk.Device.DeviceGetAssociatedDeviceMethodInfo + ResolveX11DeviceCoreMethod "getAxes" o = Gdk.Device.DeviceGetAxesMethodInfo + ResolveX11DeviceCoreMethod "getAxisUse" o = Gdk.Device.DeviceGetAxisUseMethodInfo + ResolveX11DeviceCoreMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveX11DeviceCoreMethod "getDeviceType" o = Gdk.Device.DeviceGetDeviceTypeMethodInfo + ResolveX11DeviceCoreMethod "getDisplay" o = Gdk.Device.DeviceGetDisplayMethodInfo + ResolveX11DeviceCoreMethod "getHasCursor" o = Gdk.Device.DeviceGetHasCursorMethodInfo + ResolveX11DeviceCoreMethod "getKey" o = Gdk.Device.DeviceGetKeyMethodInfo + ResolveX11DeviceCoreMethod "getLastEventWindow" o = Gdk.Device.DeviceGetLastEventWindowMethodInfo + ResolveX11DeviceCoreMethod "getMode" o = Gdk.Device.DeviceGetModeMethodInfo + ResolveX11DeviceCoreMethod "getNAxes" o = Gdk.Device.DeviceGetNAxesMethodInfo + ResolveX11DeviceCoreMethod "getNKeys" o = Gdk.Device.DeviceGetNKeysMethodInfo + ResolveX11DeviceCoreMethod "getName" o = Gdk.Device.DeviceGetNameMethodInfo + ResolveX11DeviceCoreMethod "getPosition" o = Gdk.Device.DeviceGetPositionMethodInfo + ResolveX11DeviceCoreMethod "getPositionDouble" o = Gdk.Device.DeviceGetPositionDoubleMethodInfo + ResolveX11DeviceCoreMethod "getProductId" o = Gdk.Device.DeviceGetProductIdMethodInfo + ResolveX11DeviceCoreMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveX11DeviceCoreMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveX11DeviceCoreMethod "getSeat" o = Gdk.Device.DeviceGetSeatMethodInfo + ResolveX11DeviceCoreMethod "getSource" o = Gdk.Device.DeviceGetSourceMethodInfo + ResolveX11DeviceCoreMethod "getVendorId" o = Gdk.Device.DeviceGetVendorIdMethodInfo + ResolveX11DeviceCoreMethod "getWindowAtPosition" o = Gdk.Device.DeviceGetWindowAtPositionMethodInfo + ResolveX11DeviceCoreMethod "getWindowAtPositionDouble" o = Gdk.Device.DeviceGetWindowAtPositionDoubleMethodInfo + ResolveX11DeviceCoreMethod "setAxisUse" o = Gdk.Device.DeviceSetAxisUseMethodInfo + ResolveX11DeviceCoreMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveX11DeviceCoreMethod "setKey" o = Gdk.Device.DeviceSetKeyMethodInfo + ResolveX11DeviceCoreMethod "setMode" o = Gdk.Device.DeviceSetModeMethodInfo + ResolveX11DeviceCoreMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveX11DeviceCoreMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveX11DeviceCoreMethod t X11DeviceCore, O.MethodInfo info X11DeviceCore p) => OL.IsLabel t (X11DeviceCore -> 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 X11DeviceCore +type instance O.AttributeList X11DeviceCore = X11DeviceCoreAttributeList +type X11DeviceCoreAttributeList = ('[ '("associatedDevice", Gdk.Device.DeviceAssociatedDevicePropertyInfo), '("axes", Gdk.Device.DeviceAxesPropertyInfo), '("deviceManager", Gdk.Device.DeviceDeviceManagerPropertyInfo), '("display", Gdk.Device.DeviceDisplayPropertyInfo), '("hasCursor", Gdk.Device.DeviceHasCursorPropertyInfo), '("inputMode", Gdk.Device.DeviceInputModePropertyInfo), '("inputSource", Gdk.Device.DeviceInputSourcePropertyInfo), '("nAxes", Gdk.Device.DeviceNAxesPropertyInfo), '("name", Gdk.Device.DeviceNamePropertyInfo), '("numTouches", Gdk.Device.DeviceNumTouchesPropertyInfo), '("productId", Gdk.Device.DeviceProductIdPropertyInfo), '("seat", Gdk.Device.DeviceSeatPropertyInfo), '("tool", Gdk.Device.DeviceToolPropertyInfo), '("type", Gdk.Device.DeviceTypePropertyInfo), '("vendorId", Gdk.Device.DeviceVendorIdPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList X11DeviceCore = X11DeviceCoreSignalList +type X11DeviceCoreSignalList = ('[ '("changed", Gdk.Device.DeviceChangedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("toolChanged", Gdk.Device.DeviceToolChangedSignalInfo)] :: [(Symbol, *)]) + +#endif + + diff --git a/GI/GdkX11/Objects/X11DeviceCore.hs-boot b/GI/GdkX11/Objects/X11DeviceCore.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GdkX11/Objects/X11DeviceCore.hs-boot @@ -0,0 +1,29 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GdkX11.Objects.X11DeviceCore 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 + +newtype X11DeviceCore = X11DeviceCore (ManagedPtr X11DeviceCore) +instance GObject X11DeviceCore where +class (GObject o, O.IsDescendantOf X11DeviceCore o) => IsX11DeviceCore o +instance (GObject o, O.IsDescendantOf X11DeviceCore o) => IsX11DeviceCore o +instance O.HasParentTypes X11DeviceCore diff --git a/GI/GdkX11/Objects/X11DeviceManagerCore.hs b/GI/GdkX11/Objects/X11DeviceManagerCore.hs new file mode 100644 --- /dev/null +++ b/GI/GdkX11/Objects/X11DeviceManagerCore.hs @@ -0,0 +1,125 @@ + + +{- | +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.GdkX11.Objects.X11DeviceManagerCore + ( + +-- * Exported types + X11DeviceManagerCore(..) , + IsX11DeviceManagerCore , + toX11DeviceManagerCore , + noX11DeviceManagerCore , + + + ) 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 qualified GI.Gdk.Objects.DeviceManager as Gdk.DeviceManager + +-- | Memory-managed wrapper type. +newtype X11DeviceManagerCore = X11DeviceManagerCore (ManagedPtr X11DeviceManagerCore) +foreign import ccall "gdk_x11_device_manager_core_get_type" + c_gdk_x11_device_manager_core_get_type :: IO GType + +instance GObject X11DeviceManagerCore where + gobjectType = c_gdk_x11_device_manager_core_get_type + + +-- | Type class for types which can be safely cast to `X11DeviceManagerCore`, for instance with `toX11DeviceManagerCore`. +class (GObject o, O.IsDescendantOf X11DeviceManagerCore o) => IsX11DeviceManagerCore o +instance (GObject o, O.IsDescendantOf X11DeviceManagerCore o) => IsX11DeviceManagerCore o + +instance O.HasParentTypes X11DeviceManagerCore +type instance O.ParentTypes X11DeviceManagerCore = '[Gdk.DeviceManager.DeviceManager, GObject.Object.Object] + +-- | Cast to `X11DeviceManagerCore`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toX11DeviceManagerCore :: (MonadIO m, IsX11DeviceManagerCore o) => o -> m X11DeviceManagerCore +toX11DeviceManagerCore = liftIO . unsafeCastTo X11DeviceManagerCore + +-- | A convenience alias for `Nothing` :: `Maybe` `X11DeviceManagerCore`. +noX11DeviceManagerCore :: Maybe X11DeviceManagerCore +noX11DeviceManagerCore = Nothing + +#if ENABLE_OVERLOADING +type family ResolveX11DeviceManagerCoreMethod (t :: Symbol) (o :: *) :: * where + ResolveX11DeviceManagerCoreMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveX11DeviceManagerCoreMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveX11DeviceManagerCoreMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveX11DeviceManagerCoreMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveX11DeviceManagerCoreMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveX11DeviceManagerCoreMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveX11DeviceManagerCoreMethod "listDevices" o = Gdk.DeviceManager.DeviceManagerListDevicesMethodInfo + ResolveX11DeviceManagerCoreMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveX11DeviceManagerCoreMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveX11DeviceManagerCoreMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveX11DeviceManagerCoreMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveX11DeviceManagerCoreMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveX11DeviceManagerCoreMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveX11DeviceManagerCoreMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveX11DeviceManagerCoreMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveX11DeviceManagerCoreMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveX11DeviceManagerCoreMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveX11DeviceManagerCoreMethod "getClientPointer" o = Gdk.DeviceManager.DeviceManagerGetClientPointerMethodInfo + ResolveX11DeviceManagerCoreMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveX11DeviceManagerCoreMethod "getDisplay" o = Gdk.DeviceManager.DeviceManagerGetDisplayMethodInfo + ResolveX11DeviceManagerCoreMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveX11DeviceManagerCoreMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveX11DeviceManagerCoreMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveX11DeviceManagerCoreMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveX11DeviceManagerCoreMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveX11DeviceManagerCoreMethod t X11DeviceManagerCore, O.MethodInfo info X11DeviceManagerCore p) => OL.IsLabel t (X11DeviceManagerCore -> 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 X11DeviceManagerCore +type instance O.AttributeList X11DeviceManagerCore = X11DeviceManagerCoreAttributeList +type X11DeviceManagerCoreAttributeList = ('[ '("display", Gdk.DeviceManager.DeviceManagerDisplayPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList X11DeviceManagerCore = X11DeviceManagerCoreSignalList +type X11DeviceManagerCoreSignalList = ('[ '("deviceAdded", Gdk.DeviceManager.DeviceManagerDeviceAddedSignalInfo), '("deviceChanged", Gdk.DeviceManager.DeviceManagerDeviceChangedSignalInfo), '("deviceRemoved", Gdk.DeviceManager.DeviceManagerDeviceRemovedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + + diff --git a/GI/GdkX11/Objects/X11DeviceManagerCore.hs-boot b/GI/GdkX11/Objects/X11DeviceManagerCore.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GdkX11/Objects/X11DeviceManagerCore.hs-boot @@ -0,0 +1,29 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GdkX11.Objects.X11DeviceManagerCore 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 + +newtype X11DeviceManagerCore = X11DeviceManagerCore (ManagedPtr X11DeviceManagerCore) +instance GObject X11DeviceManagerCore where +class (GObject o, O.IsDescendantOf X11DeviceManagerCore o) => IsX11DeviceManagerCore o +instance (GObject o, O.IsDescendantOf X11DeviceManagerCore o) => IsX11DeviceManagerCore o +instance O.HasParentTypes X11DeviceManagerCore diff --git a/GI/GdkX11/Objects/X11DeviceManagerXI2.hs b/GI/GdkX11/Objects/X11DeviceManagerXI2.hs new file mode 100644 --- /dev/null +++ b/GI/GdkX11/Objects/X11DeviceManagerXI2.hs @@ -0,0 +1,288 @@ + + +{- | +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.GdkX11.Objects.X11DeviceManagerXI2 + ( + +-- * Exported types + X11DeviceManagerXI2(..) , + IsX11DeviceManagerXI2 , + toX11DeviceManagerXI2 , + noX11DeviceManagerXI2 , + + + -- * Properties +-- ** major #attr:major# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + X11DeviceManagerXI2MajorPropertyInfo , +#endif + constructX11DeviceManagerXI2Major , + getX11DeviceManagerXI2Major , +#if ENABLE_OVERLOADING + x11DeviceManagerXI2Major , +#endif + + +-- ** minor #attr:minor# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + X11DeviceManagerXI2MinorPropertyInfo , +#endif + constructX11DeviceManagerXI2Minor , + getX11DeviceManagerXI2Minor , +#if ENABLE_OVERLOADING + x11DeviceManagerXI2Minor , +#endif + + +-- ** opcode #attr:opcode# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + X11DeviceManagerXI2OpcodePropertyInfo , +#endif + constructX11DeviceManagerXI2Opcode , + getX11DeviceManagerXI2Opcode , +#if ENABLE_OVERLOADING + x11DeviceManagerXI2Opcode , +#endif + + + + + ) 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 qualified GI.Gdk.Objects.DeviceManager as Gdk.DeviceManager +import {-# SOURCE #-} qualified GI.GdkX11.Objects.X11DeviceManagerCore as GdkX11.X11DeviceManagerCore + +-- | Memory-managed wrapper type. +newtype X11DeviceManagerXI2 = X11DeviceManagerXI2 (ManagedPtr X11DeviceManagerXI2) +foreign import ccall "gdk_x11_device_manager_xi2_get_type" + c_gdk_x11_device_manager_xi2_get_type :: IO GType + +instance GObject X11DeviceManagerXI2 where + gobjectType = c_gdk_x11_device_manager_xi2_get_type + + +-- | Type class for types which can be safely cast to `X11DeviceManagerXI2`, for instance with `toX11DeviceManagerXI2`. +class (GObject o, O.IsDescendantOf X11DeviceManagerXI2 o) => IsX11DeviceManagerXI2 o +instance (GObject o, O.IsDescendantOf X11DeviceManagerXI2 o) => IsX11DeviceManagerXI2 o + +instance O.HasParentTypes X11DeviceManagerXI2 +type instance O.ParentTypes X11DeviceManagerXI2 = '[GdkX11.X11DeviceManagerCore.X11DeviceManagerCore, Gdk.DeviceManager.DeviceManager, GObject.Object.Object] + +-- | Cast to `X11DeviceManagerXI2`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toX11DeviceManagerXI2 :: (MonadIO m, IsX11DeviceManagerXI2 o) => o -> m X11DeviceManagerXI2 +toX11DeviceManagerXI2 = liftIO . unsafeCastTo X11DeviceManagerXI2 + +-- | A convenience alias for `Nothing` :: `Maybe` `X11DeviceManagerXI2`. +noX11DeviceManagerXI2 :: Maybe X11DeviceManagerXI2 +noX11DeviceManagerXI2 = Nothing + +#if ENABLE_OVERLOADING +type family ResolveX11DeviceManagerXI2Method (t :: Symbol) (o :: *) :: * where + ResolveX11DeviceManagerXI2Method "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveX11DeviceManagerXI2Method "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveX11DeviceManagerXI2Method "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveX11DeviceManagerXI2Method "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveX11DeviceManagerXI2Method "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveX11DeviceManagerXI2Method "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveX11DeviceManagerXI2Method "listDevices" o = Gdk.DeviceManager.DeviceManagerListDevicesMethodInfo + ResolveX11DeviceManagerXI2Method "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveX11DeviceManagerXI2Method "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveX11DeviceManagerXI2Method "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveX11DeviceManagerXI2Method "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveX11DeviceManagerXI2Method "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveX11DeviceManagerXI2Method "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveX11DeviceManagerXI2Method "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveX11DeviceManagerXI2Method "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveX11DeviceManagerXI2Method "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveX11DeviceManagerXI2Method "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveX11DeviceManagerXI2Method "getClientPointer" o = Gdk.DeviceManager.DeviceManagerGetClientPointerMethodInfo + ResolveX11DeviceManagerXI2Method "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveX11DeviceManagerXI2Method "getDisplay" o = Gdk.DeviceManager.DeviceManagerGetDisplayMethodInfo + ResolveX11DeviceManagerXI2Method "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveX11DeviceManagerXI2Method "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveX11DeviceManagerXI2Method "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveX11DeviceManagerXI2Method "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveX11DeviceManagerXI2Method l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveX11DeviceManagerXI2Method t X11DeviceManagerXI2, O.MethodInfo info X11DeviceManagerXI2 p) => OL.IsLabel t (X11DeviceManagerXI2 -> 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 "major" + -- Type: TBasicType TInt + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@major@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' x11DeviceManagerXI2 #major +@ +-} +getX11DeviceManagerXI2Major :: (MonadIO m, IsX11DeviceManagerXI2 o) => o -> m Int32 +getX11DeviceManagerXI2Major obj = liftIO $ B.Properties.getObjectPropertyInt32 obj "major" + +{- | +Construct a `GValueConstruct` with valid value for the “@major@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructX11DeviceManagerXI2Major :: (IsX11DeviceManagerXI2 o) => Int32 -> IO (GValueConstruct o) +constructX11DeviceManagerXI2Major val = B.Properties.constructObjectPropertyInt32 "major" val + +#if ENABLE_OVERLOADING +data X11DeviceManagerXI2MajorPropertyInfo +instance AttrInfo X11DeviceManagerXI2MajorPropertyInfo where + type AttrAllowedOps X11DeviceManagerXI2MajorPropertyInfo = '[ 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint X11DeviceManagerXI2MajorPropertyInfo = (~) Int32 + type AttrBaseTypeConstraint X11DeviceManagerXI2MajorPropertyInfo = IsX11DeviceManagerXI2 + type AttrGetType X11DeviceManagerXI2MajorPropertyInfo = Int32 + type AttrLabel X11DeviceManagerXI2MajorPropertyInfo = "major" + type AttrOrigin X11DeviceManagerXI2MajorPropertyInfo = X11DeviceManagerXI2 + attrGet _ = getX11DeviceManagerXI2Major + attrSet _ = undefined + attrConstruct _ = constructX11DeviceManagerXI2Major + attrClear _ = undefined +#endif + +-- VVV Prop "minor" + -- Type: TBasicType TInt + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@minor@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' x11DeviceManagerXI2 #minor +@ +-} +getX11DeviceManagerXI2Minor :: (MonadIO m, IsX11DeviceManagerXI2 o) => o -> m Int32 +getX11DeviceManagerXI2Minor obj = liftIO $ B.Properties.getObjectPropertyInt32 obj "minor" + +{- | +Construct a `GValueConstruct` with valid value for the “@minor@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructX11DeviceManagerXI2Minor :: (IsX11DeviceManagerXI2 o) => Int32 -> IO (GValueConstruct o) +constructX11DeviceManagerXI2Minor val = B.Properties.constructObjectPropertyInt32 "minor" val + +#if ENABLE_OVERLOADING +data X11DeviceManagerXI2MinorPropertyInfo +instance AttrInfo X11DeviceManagerXI2MinorPropertyInfo where + type AttrAllowedOps X11DeviceManagerXI2MinorPropertyInfo = '[ 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint X11DeviceManagerXI2MinorPropertyInfo = (~) Int32 + type AttrBaseTypeConstraint X11DeviceManagerXI2MinorPropertyInfo = IsX11DeviceManagerXI2 + type AttrGetType X11DeviceManagerXI2MinorPropertyInfo = Int32 + type AttrLabel X11DeviceManagerXI2MinorPropertyInfo = "minor" + type AttrOrigin X11DeviceManagerXI2MinorPropertyInfo = X11DeviceManagerXI2 + attrGet _ = getX11DeviceManagerXI2Minor + attrSet _ = undefined + attrConstruct _ = constructX11DeviceManagerXI2Minor + attrClear _ = undefined +#endif + +-- VVV Prop "opcode" + -- Type: TBasicType TInt + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@opcode@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' x11DeviceManagerXI2 #opcode +@ +-} +getX11DeviceManagerXI2Opcode :: (MonadIO m, IsX11DeviceManagerXI2 o) => o -> m Int32 +getX11DeviceManagerXI2Opcode obj = liftIO $ B.Properties.getObjectPropertyInt32 obj "opcode" + +{- | +Construct a `GValueConstruct` with valid value for the “@opcode@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructX11DeviceManagerXI2Opcode :: (IsX11DeviceManagerXI2 o) => Int32 -> IO (GValueConstruct o) +constructX11DeviceManagerXI2Opcode val = B.Properties.constructObjectPropertyInt32 "opcode" val + +#if ENABLE_OVERLOADING +data X11DeviceManagerXI2OpcodePropertyInfo +instance AttrInfo X11DeviceManagerXI2OpcodePropertyInfo where + type AttrAllowedOps X11DeviceManagerXI2OpcodePropertyInfo = '[ 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint X11DeviceManagerXI2OpcodePropertyInfo = (~) Int32 + type AttrBaseTypeConstraint X11DeviceManagerXI2OpcodePropertyInfo = IsX11DeviceManagerXI2 + type AttrGetType X11DeviceManagerXI2OpcodePropertyInfo = Int32 + type AttrLabel X11DeviceManagerXI2OpcodePropertyInfo = "opcode" + type AttrOrigin X11DeviceManagerXI2OpcodePropertyInfo = X11DeviceManagerXI2 + attrGet _ = getX11DeviceManagerXI2Opcode + attrSet _ = undefined + attrConstruct _ = constructX11DeviceManagerXI2Opcode + attrClear _ = undefined +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList X11DeviceManagerXI2 +type instance O.AttributeList X11DeviceManagerXI2 = X11DeviceManagerXI2AttributeList +type X11DeviceManagerXI2AttributeList = ('[ '("display", Gdk.DeviceManager.DeviceManagerDisplayPropertyInfo), '("major", X11DeviceManagerXI2MajorPropertyInfo), '("minor", X11DeviceManagerXI2MinorPropertyInfo), '("opcode", X11DeviceManagerXI2OpcodePropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +x11DeviceManagerXI2Major :: AttrLabelProxy "major" +x11DeviceManagerXI2Major = AttrLabelProxy + +x11DeviceManagerXI2Minor :: AttrLabelProxy "minor" +x11DeviceManagerXI2Minor = AttrLabelProxy + +x11DeviceManagerXI2Opcode :: AttrLabelProxy "opcode" +x11DeviceManagerXI2Opcode = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList X11DeviceManagerXI2 = X11DeviceManagerXI2SignalList +type X11DeviceManagerXI2SignalList = ('[ '("deviceAdded", Gdk.DeviceManager.DeviceManagerDeviceAddedSignalInfo), '("deviceChanged", Gdk.DeviceManager.DeviceManagerDeviceChangedSignalInfo), '("deviceRemoved", Gdk.DeviceManager.DeviceManagerDeviceRemovedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + + diff --git a/GI/GdkX11/Objects/X11DeviceManagerXI2.hs-boot b/GI/GdkX11/Objects/X11DeviceManagerXI2.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GdkX11/Objects/X11DeviceManagerXI2.hs-boot @@ -0,0 +1,38 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GdkX11.Objects.X11DeviceManagerXI2 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 + +newtype X11DeviceManagerXI2 = X11DeviceManagerXI2 (ManagedPtr X11DeviceManagerXI2) +instance GObject X11DeviceManagerXI2 where +class (GObject o, O.IsDescendantOf X11DeviceManagerXI2 o) => IsX11DeviceManagerXI2 o +instance (GObject o, O.IsDescendantOf X11DeviceManagerXI2 o) => IsX11DeviceManagerXI2 o +instance O.HasParentTypes X11DeviceManagerXI2 +#if ENABLE_OVERLOADING +data X11DeviceManagerXI2MajorPropertyInfo +#endif +#if ENABLE_OVERLOADING +data X11DeviceManagerXI2MinorPropertyInfo +#endif +#if ENABLE_OVERLOADING +data X11DeviceManagerXI2OpcodePropertyInfo +#endif diff --git a/GI/GdkX11/Objects/X11DeviceXI2.hs b/GI/GdkX11/Objects/X11DeviceXI2.hs new file mode 100644 --- /dev/null +++ b/GI/GdkX11/Objects/X11DeviceXI2.hs @@ -0,0 +1,206 @@ + + +{- | +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.GdkX11.Objects.X11DeviceXI2 + ( + +-- * Exported types + X11DeviceXI2(..) , + IsX11DeviceXI2 , + toX11DeviceXI2 , + noX11DeviceXI2 , + + + -- * Properties +-- ** deviceId #attr:deviceId# +{- | /No description available in the introspection data./ +-} +#if ENABLE_OVERLOADING + X11DeviceXI2DeviceIdPropertyInfo , +#endif + constructX11DeviceXI2DeviceId , + getX11DeviceXI2DeviceId , +#if ENABLE_OVERLOADING + x11DeviceXI2DeviceId , +#endif + + + + + ) 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 qualified GI.Gdk.Objects.Device as Gdk.Device + +-- | Memory-managed wrapper type. +newtype X11DeviceXI2 = X11DeviceXI2 (ManagedPtr X11DeviceXI2) +foreign import ccall "gdk_x11_device_xi2_get_type" + c_gdk_x11_device_xi2_get_type :: IO GType + +instance GObject X11DeviceXI2 where + gobjectType = c_gdk_x11_device_xi2_get_type + + +-- | Type class for types which can be safely cast to `X11DeviceXI2`, for instance with `toX11DeviceXI2`. +class (GObject o, O.IsDescendantOf X11DeviceXI2 o) => IsX11DeviceXI2 o +instance (GObject o, O.IsDescendantOf X11DeviceXI2 o) => IsX11DeviceXI2 o + +instance O.HasParentTypes X11DeviceXI2 +type instance O.ParentTypes X11DeviceXI2 = '[Gdk.Device.Device, GObject.Object.Object] + +-- | Cast to `X11DeviceXI2`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toX11DeviceXI2 :: (MonadIO m, IsX11DeviceXI2 o) => o -> m X11DeviceXI2 +toX11DeviceXI2 = liftIO . unsafeCastTo X11DeviceXI2 + +-- | A convenience alias for `Nothing` :: `Maybe` `X11DeviceXI2`. +noX11DeviceXI2 :: Maybe X11DeviceXI2 +noX11DeviceXI2 = Nothing + +#if ENABLE_OVERLOADING +type family ResolveX11DeviceXI2Method (t :: Symbol) (o :: *) :: * where + ResolveX11DeviceXI2Method "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveX11DeviceXI2Method "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveX11DeviceXI2Method "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveX11DeviceXI2Method "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveX11DeviceXI2Method "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveX11DeviceXI2Method "grab" o = Gdk.Device.DeviceGrabMethodInfo + ResolveX11DeviceXI2Method "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveX11DeviceXI2Method "listAxes" o = Gdk.Device.DeviceListAxesMethodInfo + ResolveX11DeviceXI2Method "listSlaveDevices" o = Gdk.Device.DeviceListSlaveDevicesMethodInfo + ResolveX11DeviceXI2Method "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveX11DeviceXI2Method "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveX11DeviceXI2Method "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveX11DeviceXI2Method "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveX11DeviceXI2Method "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveX11DeviceXI2Method "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveX11DeviceXI2Method "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveX11DeviceXI2Method "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveX11DeviceXI2Method "ungrab" o = Gdk.Device.DeviceUngrabMethodInfo + ResolveX11DeviceXI2Method "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveX11DeviceXI2Method "warp" o = Gdk.Device.DeviceWarpMethodInfo + ResolveX11DeviceXI2Method "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveX11DeviceXI2Method "getAssociatedDevice" o = Gdk.Device.DeviceGetAssociatedDeviceMethodInfo + ResolveX11DeviceXI2Method "getAxes" o = Gdk.Device.DeviceGetAxesMethodInfo + ResolveX11DeviceXI2Method "getAxisUse" o = Gdk.Device.DeviceGetAxisUseMethodInfo + ResolveX11DeviceXI2Method "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveX11DeviceXI2Method "getDeviceType" o = Gdk.Device.DeviceGetDeviceTypeMethodInfo + ResolveX11DeviceXI2Method "getDisplay" o = Gdk.Device.DeviceGetDisplayMethodInfo + ResolveX11DeviceXI2Method "getHasCursor" o = Gdk.Device.DeviceGetHasCursorMethodInfo + ResolveX11DeviceXI2Method "getKey" o = Gdk.Device.DeviceGetKeyMethodInfo + ResolveX11DeviceXI2Method "getLastEventWindow" o = Gdk.Device.DeviceGetLastEventWindowMethodInfo + ResolveX11DeviceXI2Method "getMode" o = Gdk.Device.DeviceGetModeMethodInfo + ResolveX11DeviceXI2Method "getNAxes" o = Gdk.Device.DeviceGetNAxesMethodInfo + ResolveX11DeviceXI2Method "getNKeys" o = Gdk.Device.DeviceGetNKeysMethodInfo + ResolveX11DeviceXI2Method "getName" o = Gdk.Device.DeviceGetNameMethodInfo + ResolveX11DeviceXI2Method "getPosition" o = Gdk.Device.DeviceGetPositionMethodInfo + ResolveX11DeviceXI2Method "getPositionDouble" o = Gdk.Device.DeviceGetPositionDoubleMethodInfo + ResolveX11DeviceXI2Method "getProductId" o = Gdk.Device.DeviceGetProductIdMethodInfo + ResolveX11DeviceXI2Method "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveX11DeviceXI2Method "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveX11DeviceXI2Method "getSeat" o = Gdk.Device.DeviceGetSeatMethodInfo + ResolveX11DeviceXI2Method "getSource" o = Gdk.Device.DeviceGetSourceMethodInfo + ResolveX11DeviceXI2Method "getVendorId" o = Gdk.Device.DeviceGetVendorIdMethodInfo + ResolveX11DeviceXI2Method "getWindowAtPosition" o = Gdk.Device.DeviceGetWindowAtPositionMethodInfo + ResolveX11DeviceXI2Method "getWindowAtPositionDouble" o = Gdk.Device.DeviceGetWindowAtPositionDoubleMethodInfo + ResolveX11DeviceXI2Method "setAxisUse" o = Gdk.Device.DeviceSetAxisUseMethodInfo + ResolveX11DeviceXI2Method "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveX11DeviceXI2Method "setKey" o = Gdk.Device.DeviceSetKeyMethodInfo + ResolveX11DeviceXI2Method "setMode" o = Gdk.Device.DeviceSetModeMethodInfo + ResolveX11DeviceXI2Method "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveX11DeviceXI2Method l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveX11DeviceXI2Method t X11DeviceXI2, O.MethodInfo info X11DeviceXI2 p) => OL.IsLabel t (X11DeviceXI2 -> 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 "device-id" + -- Type: TBasicType TInt + -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] + -- Nullable: (Nothing,Nothing) + +{- | +Get the value of the “@device-id@” property. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Attributes.get' x11DeviceXI2 #deviceId +@ +-} +getX11DeviceXI2DeviceId :: (MonadIO m, IsX11DeviceXI2 o) => o -> m Int32 +getX11DeviceXI2DeviceId obj = liftIO $ B.Properties.getObjectPropertyInt32 obj "device-id" + +{- | +Construct a `GValueConstruct` with valid value for the “@device-id@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. +-} +constructX11DeviceXI2DeviceId :: (IsX11DeviceXI2 o) => Int32 -> IO (GValueConstruct o) +constructX11DeviceXI2DeviceId val = B.Properties.constructObjectPropertyInt32 "device-id" val + +#if ENABLE_OVERLOADING +data X11DeviceXI2DeviceIdPropertyInfo +instance AttrInfo X11DeviceXI2DeviceIdPropertyInfo where + type AttrAllowedOps X11DeviceXI2DeviceIdPropertyInfo = '[ 'AttrConstruct, 'AttrGet] + type AttrSetTypeConstraint X11DeviceXI2DeviceIdPropertyInfo = (~) Int32 + type AttrBaseTypeConstraint X11DeviceXI2DeviceIdPropertyInfo = IsX11DeviceXI2 + type AttrGetType X11DeviceXI2DeviceIdPropertyInfo = Int32 + type AttrLabel X11DeviceXI2DeviceIdPropertyInfo = "device-id" + type AttrOrigin X11DeviceXI2DeviceIdPropertyInfo = X11DeviceXI2 + attrGet _ = getX11DeviceXI2DeviceId + attrSet _ = undefined + attrConstruct _ = constructX11DeviceXI2DeviceId + attrClear _ = undefined +#endif + +#if ENABLE_OVERLOADING +instance O.HasAttributeList X11DeviceXI2 +type instance O.AttributeList X11DeviceXI2 = X11DeviceXI2AttributeList +type X11DeviceXI2AttributeList = ('[ '("associatedDevice", Gdk.Device.DeviceAssociatedDevicePropertyInfo), '("axes", Gdk.Device.DeviceAxesPropertyInfo), '("deviceId", X11DeviceXI2DeviceIdPropertyInfo), '("deviceManager", Gdk.Device.DeviceDeviceManagerPropertyInfo), '("display", Gdk.Device.DeviceDisplayPropertyInfo), '("hasCursor", Gdk.Device.DeviceHasCursorPropertyInfo), '("inputMode", Gdk.Device.DeviceInputModePropertyInfo), '("inputSource", Gdk.Device.DeviceInputSourcePropertyInfo), '("nAxes", Gdk.Device.DeviceNAxesPropertyInfo), '("name", Gdk.Device.DeviceNamePropertyInfo), '("numTouches", Gdk.Device.DeviceNumTouchesPropertyInfo), '("productId", Gdk.Device.DeviceProductIdPropertyInfo), '("seat", Gdk.Device.DeviceSeatPropertyInfo), '("tool", Gdk.Device.DeviceToolPropertyInfo), '("type", Gdk.Device.DeviceTypePropertyInfo), '("vendorId", Gdk.Device.DeviceVendorIdPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +x11DeviceXI2DeviceId :: AttrLabelProxy "deviceId" +x11DeviceXI2DeviceId = AttrLabelProxy + +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList X11DeviceXI2 = X11DeviceXI2SignalList +type X11DeviceXI2SignalList = ('[ '("changed", Gdk.Device.DeviceChangedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("toolChanged", Gdk.Device.DeviceToolChangedSignalInfo)] :: [(Symbol, *)]) + +#endif + + diff --git a/GI/GdkX11/Objects/X11DeviceXI2.hs-boot b/GI/GdkX11/Objects/X11DeviceXI2.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GdkX11/Objects/X11DeviceXI2.hs-boot @@ -0,0 +1,32 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GdkX11.Objects.X11DeviceXI2 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 + +newtype X11DeviceXI2 = X11DeviceXI2 (ManagedPtr X11DeviceXI2) +instance GObject X11DeviceXI2 where +class (GObject o, O.IsDescendantOf X11DeviceXI2 o) => IsX11DeviceXI2 o +instance (GObject o, O.IsDescendantOf X11DeviceXI2 o) => IsX11DeviceXI2 o +instance O.HasParentTypes X11DeviceXI2 +#if ENABLE_OVERLOADING +data X11DeviceXI2DeviceIdPropertyInfo +#endif diff --git a/GI/GdkX11/Objects/X11Display.hs b/GI/GdkX11/Objects/X11Display.hs new file mode 100644 --- /dev/null +++ b/GI/GdkX11/Objects/X11Display.hs @@ -0,0 +1,888 @@ + + +{- | +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.GdkX11.Objects.X11Display + ( +#if ENABLE_OVERLOADING + X11DisplayStringToCompoundTextMethodInfo, +#endif +#if ENABLE_OVERLOADING + X11DisplayUtf8ToCompoundTextMethodInfo , +#endif + +-- * Exported types + X11Display(..) , + IsX11Display , + toX11Display , + noX11Display , + + + -- * Methods +-- ** errorTrapPop #method:errorTrapPop# + +#if ENABLE_OVERLOADING + X11DisplayErrorTrapPopMethodInfo , +#endif + x11DisplayErrorTrapPop , + + +-- ** errorTrapPopIgnored #method:errorTrapPopIgnored# + +#if ENABLE_OVERLOADING + X11DisplayErrorTrapPopIgnoredMethodInfo , +#endif + x11DisplayErrorTrapPopIgnored , + + +-- ** errorTrapPush #method:errorTrapPush# + +#if ENABLE_OVERLOADING + X11DisplayErrorTrapPushMethodInfo , +#endif + x11DisplayErrorTrapPush , + + +-- ** getGlxVersion #method:getGlxVersion# + + x11DisplayGetGlxVersion , + + +-- ** getStartupNotificationId #method:getStartupNotificationId# + +#if ENABLE_OVERLOADING + X11DisplayGetStartupNotificationIdMethodInfo, +#endif + x11DisplayGetStartupNotificationId , + + +-- ** getUserTime #method:getUserTime# + +#if ENABLE_OVERLOADING + X11DisplayGetUserTimeMethodInfo , +#endif + x11DisplayGetUserTime , + + +-- ** getXdisplay #method:getXdisplay# + +#if ENABLE_OVERLOADING + X11DisplayGetXdisplayMethodInfo , +#endif + x11DisplayGetXdisplay , + + +-- ** grab #method:grab# + +#if ENABLE_OVERLOADING + X11DisplayGrabMethodInfo , +#endif + x11DisplayGrab , + + +-- ** setCursorTheme #method:setCursorTheme# + +#if ENABLE_OVERLOADING + X11DisplaySetCursorThemeMethodInfo , +#endif + x11DisplaySetCursorTheme , + + +-- ** setStartupNotificationId #method:setStartupNotificationId# + +#if ENABLE_OVERLOADING + X11DisplaySetStartupNotificationIdMethodInfo, +#endif + x11DisplaySetStartupNotificationId , + + +-- ** setWindowScale #method:setWindowScale# + +#if ENABLE_OVERLOADING + X11DisplaySetWindowScaleMethodInfo , +#endif + x11DisplaySetWindowScale , + + +-- ** textPropertyToTextList #method:textPropertyToTextList# + +#if ENABLE_OVERLOADING + X11DisplayTextPropertyToTextListMethodInfo, +#endif + x11DisplayTextPropertyToTextList , + + +-- ** ungrab #method:ungrab# + +#if ENABLE_OVERLOADING + X11DisplayUngrabMethodInfo , +#endif + x11DisplayUngrab , + + + + + ) 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 qualified GI.Gdk.Objects.Display as Gdk.Display +import qualified GI.Gdk.Structs.Atom as Gdk.Atom +import qualified GI.Xlib.Structs.Display as Xlib.Display + +-- | Memory-managed wrapper type. +newtype X11Display = X11Display (ManagedPtr X11Display) +foreign import ccall "gdk_x11_display_get_type" + c_gdk_x11_display_get_type :: IO GType + +instance GObject X11Display where + gobjectType = c_gdk_x11_display_get_type + + +-- | Type class for types which can be safely cast to `X11Display`, for instance with `toX11Display`. +class (GObject o, O.IsDescendantOf X11Display o) => IsX11Display o +instance (GObject o, O.IsDescendantOf X11Display o) => IsX11Display o + +instance O.HasParentTypes X11Display +type instance O.ParentTypes X11Display = '[Gdk.Display.Display, GObject.Object.Object] + +-- | Cast to `X11Display`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toX11Display :: (MonadIO m, IsX11Display o) => o -> m X11Display +toX11Display = liftIO . unsafeCastTo X11Display + +-- | A convenience alias for `Nothing` :: `Maybe` `X11Display`. +noX11Display :: Maybe X11Display +noX11Display = Nothing + +#if ENABLE_OVERLOADING +type family ResolveX11DisplayMethod (t :: Symbol) (o :: *) :: * where + ResolveX11DisplayMethod "beep" o = Gdk.Display.DisplayBeepMethodInfo + ResolveX11DisplayMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveX11DisplayMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveX11DisplayMethod "close" o = Gdk.Display.DisplayCloseMethodInfo + ResolveX11DisplayMethod "deviceIsGrabbed" o = Gdk.Display.DisplayDeviceIsGrabbedMethodInfo + ResolveX11DisplayMethod "errorTrapPop" o = X11DisplayErrorTrapPopMethodInfo + ResolveX11DisplayMethod "errorTrapPopIgnored" o = X11DisplayErrorTrapPopIgnoredMethodInfo + ResolveX11DisplayMethod "errorTrapPush" o = X11DisplayErrorTrapPushMethodInfo + ResolveX11DisplayMethod "flush" o = Gdk.Display.DisplayFlushMethodInfo + ResolveX11DisplayMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveX11DisplayMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveX11DisplayMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveX11DisplayMethod "grab" o = X11DisplayGrabMethodInfo + ResolveX11DisplayMethod "hasPending" o = Gdk.Display.DisplayHasPendingMethodInfo + ResolveX11DisplayMethod "isClosed" o = Gdk.Display.DisplayIsClosedMethodInfo + ResolveX11DisplayMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveX11DisplayMethod "keyboardUngrab" o = Gdk.Display.DisplayKeyboardUngrabMethodInfo + ResolveX11DisplayMethod "listDevices" o = Gdk.Display.DisplayListDevicesMethodInfo + ResolveX11DisplayMethod "listSeats" o = Gdk.Display.DisplayListSeatsMethodInfo + ResolveX11DisplayMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveX11DisplayMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveX11DisplayMethod "notifyStartupComplete" o = Gdk.Display.DisplayNotifyStartupCompleteMethodInfo + ResolveX11DisplayMethod "peekEvent" o = Gdk.Display.DisplayPeekEventMethodInfo + ResolveX11DisplayMethod "pointerIsGrabbed" o = Gdk.Display.DisplayPointerIsGrabbedMethodInfo + ResolveX11DisplayMethod "pointerUngrab" o = Gdk.Display.DisplayPointerUngrabMethodInfo + ResolveX11DisplayMethod "putEvent" o = Gdk.Display.DisplayPutEventMethodInfo + ResolveX11DisplayMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveX11DisplayMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveX11DisplayMethod "requestSelectionNotification" o = Gdk.Display.DisplayRequestSelectionNotificationMethodInfo + ResolveX11DisplayMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveX11DisplayMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveX11DisplayMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveX11DisplayMethod "storeClipboard" o = Gdk.Display.DisplayStoreClipboardMethodInfo + ResolveX11DisplayMethod "stringToCompoundText" o = X11DisplayStringToCompoundTextMethodInfo + ResolveX11DisplayMethod "supportsClipboardPersistence" o = Gdk.Display.DisplaySupportsClipboardPersistenceMethodInfo + ResolveX11DisplayMethod "supportsComposite" o = Gdk.Display.DisplaySupportsCompositeMethodInfo + ResolveX11DisplayMethod "supportsCursorAlpha" o = Gdk.Display.DisplaySupportsCursorAlphaMethodInfo + ResolveX11DisplayMethod "supportsCursorColor" o = Gdk.Display.DisplaySupportsCursorColorMethodInfo + ResolveX11DisplayMethod "supportsInputShapes" o = Gdk.Display.DisplaySupportsInputShapesMethodInfo + ResolveX11DisplayMethod "supportsSelectionNotification" o = Gdk.Display.DisplaySupportsSelectionNotificationMethodInfo + ResolveX11DisplayMethod "supportsShapes" o = Gdk.Display.DisplaySupportsShapesMethodInfo + ResolveX11DisplayMethod "sync" o = Gdk.Display.DisplaySyncMethodInfo + ResolveX11DisplayMethod "textPropertyToTextList" o = X11DisplayTextPropertyToTextListMethodInfo + ResolveX11DisplayMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveX11DisplayMethod "ungrab" o = X11DisplayUngrabMethodInfo + ResolveX11DisplayMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveX11DisplayMethod "utf8ToCompoundText" o = X11DisplayUtf8ToCompoundTextMethodInfo + ResolveX11DisplayMethod "warpPointer" o = Gdk.Display.DisplayWarpPointerMethodInfo + ResolveX11DisplayMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveX11DisplayMethod "getAppLaunchContext" o = Gdk.Display.DisplayGetAppLaunchContextMethodInfo + ResolveX11DisplayMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveX11DisplayMethod "getDefaultCursorSize" o = Gdk.Display.DisplayGetDefaultCursorSizeMethodInfo + ResolveX11DisplayMethod "getDefaultGroup" o = Gdk.Display.DisplayGetDefaultGroupMethodInfo + ResolveX11DisplayMethod "getDefaultScreen" o = Gdk.Display.DisplayGetDefaultScreenMethodInfo + ResolveX11DisplayMethod "getDefaultSeat" o = Gdk.Display.DisplayGetDefaultSeatMethodInfo + ResolveX11DisplayMethod "getDeviceManager" o = Gdk.Display.DisplayGetDeviceManagerMethodInfo + ResolveX11DisplayMethod "getEvent" o = Gdk.Display.DisplayGetEventMethodInfo + ResolveX11DisplayMethod "getMaximalCursorSize" o = Gdk.Display.DisplayGetMaximalCursorSizeMethodInfo + ResolveX11DisplayMethod "getMonitor" o = Gdk.Display.DisplayGetMonitorMethodInfo + ResolveX11DisplayMethod "getMonitorAtPoint" o = Gdk.Display.DisplayGetMonitorAtPointMethodInfo + ResolveX11DisplayMethod "getMonitorAtWindow" o = Gdk.Display.DisplayGetMonitorAtWindowMethodInfo + ResolveX11DisplayMethod "getNMonitors" o = Gdk.Display.DisplayGetNMonitorsMethodInfo + ResolveX11DisplayMethod "getNScreens" o = Gdk.Display.DisplayGetNScreensMethodInfo + ResolveX11DisplayMethod "getName" o = Gdk.Display.DisplayGetNameMethodInfo + ResolveX11DisplayMethod "getPointer" o = Gdk.Display.DisplayGetPointerMethodInfo + ResolveX11DisplayMethod "getPrimaryMonitor" o = Gdk.Display.DisplayGetPrimaryMonitorMethodInfo + ResolveX11DisplayMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveX11DisplayMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveX11DisplayMethod "getScreen" o = Gdk.Display.DisplayGetScreenMethodInfo + ResolveX11DisplayMethod "getStartupNotificationId" o = X11DisplayGetStartupNotificationIdMethodInfo + ResolveX11DisplayMethod "getUserTime" o = X11DisplayGetUserTimeMethodInfo + ResolveX11DisplayMethod "getWindowAtPointer" o = Gdk.Display.DisplayGetWindowAtPointerMethodInfo + ResolveX11DisplayMethod "getXdisplay" o = X11DisplayGetXdisplayMethodInfo + ResolveX11DisplayMethod "setCursorTheme" o = X11DisplaySetCursorThemeMethodInfo + ResolveX11DisplayMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveX11DisplayMethod "setDoubleClickDistance" o = Gdk.Display.DisplaySetDoubleClickDistanceMethodInfo + ResolveX11DisplayMethod "setDoubleClickTime" o = Gdk.Display.DisplaySetDoubleClickTimeMethodInfo + ResolveX11DisplayMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveX11DisplayMethod "setStartupNotificationId" o = X11DisplaySetStartupNotificationIdMethodInfo + ResolveX11DisplayMethod "setWindowScale" o = X11DisplaySetWindowScaleMethodInfo + ResolveX11DisplayMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveX11DisplayMethod t X11Display, O.MethodInfo info X11Display p) => OL.IsLabel t (X11Display -> 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 X11Display +type instance O.AttributeList X11Display = X11DisplayAttributeList +type X11DisplayAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList X11Display = X11DisplaySignalList +type X11DisplaySignalList = ('[ '("closed", Gdk.Display.DisplayClosedSignalInfo), '("monitorAdded", Gdk.Display.DisplayMonitorAddedSignalInfo), '("monitorRemoved", Gdk.Display.DisplayMonitorRemovedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("opened", Gdk.Display.DisplayOpenedSignalInfo), '("seatAdded", Gdk.Display.DisplaySeatAddedSignalInfo), '("seatRemoved", Gdk.Display.DisplaySeatRemovedSignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method X11Display::error_trap_pop +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "display", argType = TInterface (Name {namespace = "GdkX11", name = "X11Display"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the display", 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 "gdk_x11_display_error_trap_pop" gdk_x11_display_error_trap_pop :: + Ptr X11Display -> -- display : TInterface (Name {namespace = "GdkX11", name = "X11Display"}) + IO Int32 + +{- | +Pops the error trap pushed by 'GI.GdkX11.Objects.X11Display.x11DisplayErrorTrapPush'. +Will @/XSync()/@ if necessary and will always block until +the error is known to have occurred or not occurred, +so the error code can be returned. + +If you don’t need to use the return value, +'GI.GdkX11.Objects.X11Display.x11DisplayErrorTrapPopIgnored' would be more efficient. + +See 'GI.Gdk.Functions.errorTrapPop' for the all-displays-at-once +equivalent. + +/Since: 3.0/ +-} +x11DisplayErrorTrapPop :: + (B.CallStack.HasCallStack, MonadIO m, IsX11Display a) => + a + {- ^ /@display@/: the display -} + -> m Int32 + {- ^ __Returns:__ X error code or 0 on success -} +x11DisplayErrorTrapPop display = liftIO $ do + display' <- unsafeManagedPtrCastPtr display + result <- gdk_x11_display_error_trap_pop display' + touchManagedPtr display + return result + +#if ENABLE_OVERLOADING +data X11DisplayErrorTrapPopMethodInfo +instance (signature ~ (m Int32), MonadIO m, IsX11Display a) => O.MethodInfo X11DisplayErrorTrapPopMethodInfo a signature where + overloadedMethod _ = x11DisplayErrorTrapPop + +#endif + +-- method X11Display::error_trap_pop_ignored +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "display", argType = TInterface (Name {namespace = "GdkX11", name = "X11Display"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the display", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gdk_x11_display_error_trap_pop_ignored" gdk_x11_display_error_trap_pop_ignored :: + Ptr X11Display -> -- display : TInterface (Name {namespace = "GdkX11", name = "X11Display"}) + IO () + +{- | +Pops the error trap pushed by 'GI.GdkX11.Objects.X11Display.x11DisplayErrorTrapPush'. +Does not block to see if an error occurred; merely records the +range of requests to ignore errors for, and ignores those errors +if they arrive asynchronously. + +See 'GI.Gdk.Functions.errorTrapPopIgnored' for the all-displays-at-once +equivalent. + +/Since: 3.0/ +-} +x11DisplayErrorTrapPopIgnored :: + (B.CallStack.HasCallStack, MonadIO m, IsX11Display a) => + a + {- ^ /@display@/: the display -} + -> m () +x11DisplayErrorTrapPopIgnored display = liftIO $ do + display' <- unsafeManagedPtrCastPtr display + gdk_x11_display_error_trap_pop_ignored display' + touchManagedPtr display + return () + +#if ENABLE_OVERLOADING +data X11DisplayErrorTrapPopIgnoredMethodInfo +instance (signature ~ (m ()), MonadIO m, IsX11Display a) => O.MethodInfo X11DisplayErrorTrapPopIgnoredMethodInfo a signature where + overloadedMethod _ = x11DisplayErrorTrapPopIgnored + +#endif + +-- method X11Display::error_trap_push +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "display", argType = TInterface (Name {namespace = "GdkX11", name = "X11Display"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDisplay", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gdk_x11_display_error_trap_push" gdk_x11_display_error_trap_push :: + Ptr X11Display -> -- display : TInterface (Name {namespace = "GdkX11", name = "X11Display"}) + IO () + +{- | +Begins a range of X requests on /@display@/ for which X error events +will be ignored. Unignored errors (when no trap is pushed) will abort +the application. Use 'GI.GdkX11.Objects.X11Display.x11DisplayErrorTrapPop' or +'GI.GdkX11.Objects.X11Display.x11DisplayErrorTrapPopIgnored'to lift a trap pushed +with this function. + +See also 'GI.Gdk.Functions.errorTrapPush' to push a trap on all displays. + +/Since: 3.0/ +-} +x11DisplayErrorTrapPush :: + (B.CallStack.HasCallStack, MonadIO m, IsX11Display a) => + a + {- ^ /@display@/: a 'GI.Gdk.Objects.Display.Display' -} + -> m () +x11DisplayErrorTrapPush display = liftIO $ do + display' <- unsafeManagedPtrCastPtr display + gdk_x11_display_error_trap_push display' + touchManagedPtr display + return () + +#if ENABLE_OVERLOADING +data X11DisplayErrorTrapPushMethodInfo +instance (signature ~ (m ()), MonadIO m, IsX11Display a) => O.MethodInfo X11DisplayErrorTrapPushMethodInfo a signature where + overloadedMethod _ = x11DisplayErrorTrapPush + +#endif + +-- method X11Display::get_startup_notification_id +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "display", argType = TInterface (Name {namespace = "GdkX11", name = "X11Display"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDisplay", 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 "gdk_x11_display_get_startup_notification_id" gdk_x11_display_get_startup_notification_id :: + Ptr X11Display -> -- display : TInterface (Name {namespace = "GdkX11", name = "X11Display"}) + IO CString + +{- | +Gets the startup notification ID for a display. + +/Since: 2.12/ +-} +x11DisplayGetStartupNotificationId :: + (B.CallStack.HasCallStack, MonadIO m, IsX11Display a) => + a + {- ^ /@display@/: a 'GI.Gdk.Objects.Display.Display' -} + -> m T.Text + {- ^ __Returns:__ the startup notification ID for /@display@/ -} +x11DisplayGetStartupNotificationId display = liftIO $ do + display' <- unsafeManagedPtrCastPtr display + result <- gdk_x11_display_get_startup_notification_id display' + checkUnexpectedReturnNULL "x11DisplayGetStartupNotificationId" result + result' <- cstringToText result + touchManagedPtr display + return result' + +#if ENABLE_OVERLOADING +data X11DisplayGetStartupNotificationIdMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsX11Display a) => O.MethodInfo X11DisplayGetStartupNotificationIdMethodInfo a signature where + overloadedMethod _ = x11DisplayGetStartupNotificationId + +#endif + +-- method X11Display::get_user_time +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "display", argType = TInterface (Name {namespace = "GdkX11", name = "X11Display"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDisplay", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt32) +-- throws : False +-- Skip return : False + +foreign import ccall "gdk_x11_display_get_user_time" gdk_x11_display_get_user_time :: + Ptr X11Display -> -- display : TInterface (Name {namespace = "GdkX11", name = "X11Display"}) + IO Word32 + +{- | +Returns the timestamp of the last user interaction on +/@display@/. The timestamp is taken from events caused +by user interaction such as key presses or pointer +movements. See 'GI.GdkX11.Objects.X11Window.x11WindowSetUserTime'. + +/Since: 2.8/ +-} +x11DisplayGetUserTime :: + (B.CallStack.HasCallStack, MonadIO m, IsX11Display a) => + a + {- ^ /@display@/: a 'GI.Gdk.Objects.Display.Display' -} + -> m Word32 + {- ^ __Returns:__ the timestamp of the last user interaction -} +x11DisplayGetUserTime display = liftIO $ do + display' <- unsafeManagedPtrCastPtr display + result <- gdk_x11_display_get_user_time display' + touchManagedPtr display + return result + +#if ENABLE_OVERLOADING +data X11DisplayGetUserTimeMethodInfo +instance (signature ~ (m Word32), MonadIO m, IsX11Display a) => O.MethodInfo X11DisplayGetUserTimeMethodInfo a signature where + overloadedMethod _ = x11DisplayGetUserTime + +#endif + +-- method X11Display::get_xdisplay +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "display", argType = TInterface (Name {namespace = "GdkX11", name = "X11Display"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDisplay", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "xlib", name = "Display"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gdk_x11_display_get_xdisplay" gdk_x11_display_get_xdisplay :: + Ptr X11Display -> -- display : TInterface (Name {namespace = "GdkX11", name = "X11Display"}) + IO (Ptr Xlib.Display.Display) + +{- | +Returns the X display of a 'GI.Gdk.Objects.Display.Display'. + +/Since: 2.2/ +-} +x11DisplayGetXdisplay :: + (B.CallStack.HasCallStack, MonadIO m, IsX11Display a) => + a + {- ^ /@display@/: a 'GI.Gdk.Objects.Display.Display' -} + -> m Xlib.Display.Display + {- ^ __Returns:__ an X display -} +x11DisplayGetXdisplay display = liftIO $ do + display' <- unsafeManagedPtrCastPtr display + result <- gdk_x11_display_get_xdisplay display' + checkUnexpectedReturnNULL "x11DisplayGetXdisplay" result + result' <- (newPtr Xlib.Display.Display) result + touchManagedPtr display + return result' + +#if ENABLE_OVERLOADING +data X11DisplayGetXdisplayMethodInfo +instance (signature ~ (m Xlib.Display.Display), MonadIO m, IsX11Display a) => O.MethodInfo X11DisplayGetXdisplayMethodInfo a signature where + overloadedMethod _ = x11DisplayGetXdisplay + +#endif + +-- method X11Display::grab +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "display", argType = TInterface (Name {namespace = "GdkX11", name = "X11Display"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDisplay", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gdk_x11_display_grab" gdk_x11_display_grab :: + Ptr X11Display -> -- display : TInterface (Name {namespace = "GdkX11", name = "X11Display"}) + IO () + +{- | +Call @/XGrabServer()/@ on /@display@/. +To ungrab the display again, use 'GI.GdkX11.Objects.X11Display.x11DisplayUngrab'. + +'GI.GdkX11.Objects.X11Display.x11DisplayGrab'\/'GI.GdkX11.Objects.X11Display.x11DisplayUngrab' calls can be nested. + +/Since: 2.2/ +-} +x11DisplayGrab :: + (B.CallStack.HasCallStack, MonadIO m, IsX11Display a) => + a + {- ^ /@display@/: a 'GI.Gdk.Objects.Display.Display' -} + -> m () +x11DisplayGrab display = liftIO $ do + display' <- unsafeManagedPtrCastPtr display + gdk_x11_display_grab display' + touchManagedPtr display + return () + +#if ENABLE_OVERLOADING +data X11DisplayGrabMethodInfo +instance (signature ~ (m ()), MonadIO m, IsX11Display a) => O.MethodInfo X11DisplayGrabMethodInfo a signature where + overloadedMethod _ = x11DisplayGrab + +#endif + +-- method X11Display::set_cursor_theme +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "display", argType = TInterface (Name {namespace = "GdkX11", name = "X11Display"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDisplay", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "theme", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the name of the cursor theme to use, or %NULL to unset\n a previously set value", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the cursor size to use, or 0 to keep the previous size", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gdk_x11_display_set_cursor_theme" gdk_x11_display_set_cursor_theme :: + Ptr X11Display -> -- display : TInterface (Name {namespace = "GdkX11", name = "X11Display"}) + CString -> -- theme : TBasicType TUTF8 + Int32 -> -- size : TBasicType TInt + IO () + +{- | +Sets the cursor theme from which the images for cursor +should be taken. + +If the windowing system supports it, existing cursors created +with 'GI.Gdk.Objects.Cursor.cursorNew', 'GI.Gdk.Objects.Cursor.cursorNewForDisplay' and +'GI.Gdk.Objects.Cursor.cursorNewFromName' are updated to reflect the theme +change. Custom cursors constructed with +'GI.Gdk.Objects.Cursor.cursorNewFromPixbuf' will have to be handled +by the application (GTK+ applications can learn about +cursor theme changes by listening for change notification +for the corresponding @/GtkSetting/@). + +/Since: 2.8/ +-} +x11DisplaySetCursorTheme :: + (B.CallStack.HasCallStack, MonadIO m, IsX11Display a) => + a + {- ^ /@display@/: a 'GI.Gdk.Objects.Display.Display' -} + -> Maybe (T.Text) + {- ^ /@theme@/: the name of the cursor theme to use, or 'Nothing' to unset + a previously set value -} + -> Int32 + {- ^ /@size@/: the cursor size to use, or 0 to keep the previous size -} + -> m () +x11DisplaySetCursorTheme display theme size = liftIO $ do + display' <- unsafeManagedPtrCastPtr display + maybeTheme <- case theme of + Nothing -> return nullPtr + Just jTheme -> do + jTheme' <- textToCString jTheme + return jTheme' + gdk_x11_display_set_cursor_theme display' maybeTheme size + touchManagedPtr display + freeMem maybeTheme + return () + +#if ENABLE_OVERLOADING +data X11DisplaySetCursorThemeMethodInfo +instance (signature ~ (Maybe (T.Text) -> Int32 -> m ()), MonadIO m, IsX11Display a) => O.MethodInfo X11DisplaySetCursorThemeMethodInfo a signature where + overloadedMethod _ = x11DisplaySetCursorTheme + +#endif + +-- method X11Display::set_startup_notification_id +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "display", argType = TInterface (Name {namespace = "GdkX11", name = "X11Display"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDisplay", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "startup_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the startup notification ID (must be valid utf8)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gdk_x11_display_set_startup_notification_id" gdk_x11_display_set_startup_notification_id :: + Ptr X11Display -> -- display : TInterface (Name {namespace = "GdkX11", name = "X11Display"}) + CString -> -- startup_id : TBasicType TUTF8 + IO () + +{- | +Sets the startup notification ID for a display. + +This is usually taken from the value of the DESKTOP_STARTUP_ID +environment variable, but in some cases (such as the application not +being launched using @/exec()/@) it can come from other sources. + +If the ID contains the string \"_TIME\" then the portion following that +string is taken to be the X11 timestamp of the event that triggered +the application to be launched and the GDK current event time is set +accordingly. + +The startup ID is also what is used to signal that the startup is +complete (for example, when opening a window or when calling +'GI.Gdk.Functions.notifyStartupComplete'). + +/Since: 3.0/ +-} +x11DisplaySetStartupNotificationId :: + (B.CallStack.HasCallStack, MonadIO m, IsX11Display a) => + a + {- ^ /@display@/: a 'GI.Gdk.Objects.Display.Display' -} + -> T.Text + {- ^ /@startupId@/: the startup notification ID (must be valid utf8) -} + -> m () +x11DisplaySetStartupNotificationId display startupId = liftIO $ do + display' <- unsafeManagedPtrCastPtr display + startupId' <- textToCString startupId + gdk_x11_display_set_startup_notification_id display' startupId' + touchManagedPtr display + freeMem startupId' + return () + +#if ENABLE_OVERLOADING +data X11DisplaySetStartupNotificationIdMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m, IsX11Display a) => O.MethodInfo X11DisplaySetStartupNotificationIdMethodInfo a signature where + overloadedMethod _ = x11DisplaySetStartupNotificationId + +#endif + +-- method X11Display::set_window_scale +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "display", argType = TInterface (Name {namespace = "GdkX11", name = "X11Display"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the display", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "scale", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The new scale value", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gdk_x11_display_set_window_scale" gdk_x11_display_set_window_scale :: + Ptr X11Display -> -- display : TInterface (Name {namespace = "GdkX11", name = "X11Display"}) + Int32 -> -- scale : TBasicType TInt + IO () + +{- | +Forces a specific window scale for all windows on this display, +instead of using the default or user configured scale. This +is can be used to disable scaling support by setting /@scale@/ to +1, or to programmatically set the window scale. + +Once the scale is set by this call it will not change in response +to later user configuration changes. + +/Since: 3.10/ +-} +x11DisplaySetWindowScale :: + (B.CallStack.HasCallStack, MonadIO m, IsX11Display a) => + a + {- ^ /@display@/: the display -} + -> Int32 + {- ^ /@scale@/: The new scale value -} + -> m () +x11DisplaySetWindowScale display scale = liftIO $ do + display' <- unsafeManagedPtrCastPtr display + gdk_x11_display_set_window_scale display' scale + touchManagedPtr display + return () + +#if ENABLE_OVERLOADING +data X11DisplaySetWindowScaleMethodInfo +instance (signature ~ (Int32 -> m ()), MonadIO m, IsX11Display a) => O.MethodInfo X11DisplaySetWindowScaleMethodInfo a signature where + overloadedMethod _ = x11DisplaySetWindowScale + +#endif + +-- XXX Could not generate method X11Display::string_to_compound_text +-- Error was : Not implemented: "Don't know how to allocate \"encoding\" of type TInterface (Name {namespace = \"Gdk\", name = \"Atom\"})" +#if ENABLE_OVERLOADING +-- XXX: Dummy instance, since code generation failed. +-- Please file a bug at http://github.com/haskell-gi/haskell-gi. +data X11DisplayStringToCompoundTextMethodInfo +instance (p ~ (), o ~ O.MethodResolutionFailed "stringToCompoundText" X11Display) => O.MethodInfo X11DisplayStringToCompoundTextMethodInfo o p where + overloadedMethod _ = undefined +#endif + +-- method X11Display::text_property_to_text_list +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "display", argType = TInterface (Name {namespace = "GdkX11", name = "X11Display"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The #GdkDisplay where the encoding is defined", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "encoding", argType = TInterface (Name {namespace = "Gdk", name = "Atom"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an atom representing the encoding. The most\n common values for this are STRING, or COMPOUND_TEXT.\n This is value used as the type for the property", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the format of the property", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "text", argType = TBasicType TUInt8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The text data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "length", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The number of items to transform", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "list", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store an array of strings in\n the encoding of the current locale. This array should be\n freed using gdk_free_text_list().", 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 "gdk_x11_display_text_property_to_text_list" gdk_x11_display_text_property_to_text_list :: + Ptr X11Display -> -- display : TInterface (Name {namespace = "GdkX11", name = "X11Display"}) + Ptr Gdk.Atom.Atom -> -- encoding : TInterface (Name {namespace = "Gdk", name = "Atom"}) + Int32 -> -- format : TBasicType TInt + Word8 -> -- text : TBasicType TUInt8 + Int32 -> -- length : TBasicType TInt + CString -> -- list : TBasicType TUTF8 + IO Int32 + +{- | +Convert a text string from the encoding as it is stored +in a property into an array of strings in the encoding of +the current locale. (The elements of the array represent the +nul-separated elements of the original text string.) + +/Since: 2.24/ +-} +x11DisplayTextPropertyToTextList :: + (B.CallStack.HasCallStack, MonadIO m, IsX11Display a) => + a + {- ^ /@display@/: The 'GI.Gdk.Objects.Display.Display' where the encoding is defined -} + -> Gdk.Atom.Atom + {- ^ /@encoding@/: an atom representing the encoding. The most + common values for this are STRING, or COMPOUND_TEXT. + This is value used as the type for the property -} + -> Int32 + {- ^ /@format@/: the format of the property -} + -> Word8 + {- ^ /@text@/: The text data -} + -> Int32 + {- ^ /@length@/: The number of items to transform -} + -> T.Text + {- ^ /@list@/: location to store an array of strings in + the encoding of the current locale. This array should be + freed using @/gdk_free_text_list()/@. -} + -> m Int32 + {- ^ __Returns:__ the number of strings stored in list, or 0, + if the conversion failed -} +x11DisplayTextPropertyToTextList display encoding format text length_ list = liftIO $ do + display' <- unsafeManagedPtrCastPtr display + encoding' <- unsafeManagedPtrGetPtr encoding + list' <- textToCString list + result <- gdk_x11_display_text_property_to_text_list display' encoding' format text length_ list' + touchManagedPtr display + touchManagedPtr encoding + freeMem list' + return result + +#if ENABLE_OVERLOADING +data X11DisplayTextPropertyToTextListMethodInfo +instance (signature ~ (Gdk.Atom.Atom -> Int32 -> Word8 -> Int32 -> T.Text -> m Int32), MonadIO m, IsX11Display a) => O.MethodInfo X11DisplayTextPropertyToTextListMethodInfo a signature where + overloadedMethod _ = x11DisplayTextPropertyToTextList + +#endif + +-- method X11Display::ungrab +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "display", argType = TInterface (Name {namespace = "GdkX11", name = "X11Display"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDisplay", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gdk_x11_display_ungrab" gdk_x11_display_ungrab :: + Ptr X11Display -> -- display : TInterface (Name {namespace = "GdkX11", name = "X11Display"}) + IO () + +{- | +Ungrab /@display@/ after it has been grabbed with +'GI.GdkX11.Objects.X11Display.x11DisplayGrab'. + +/Since: 2.2/ +-} +x11DisplayUngrab :: + (B.CallStack.HasCallStack, MonadIO m, IsX11Display a) => + a + {- ^ /@display@/: a 'GI.Gdk.Objects.Display.Display' -} + -> m () +x11DisplayUngrab display = liftIO $ do + display' <- unsafeManagedPtrCastPtr display + gdk_x11_display_ungrab display' + touchManagedPtr display + return () + +#if ENABLE_OVERLOADING +data X11DisplayUngrabMethodInfo +instance (signature ~ (m ()), MonadIO m, IsX11Display a) => O.MethodInfo X11DisplayUngrabMethodInfo a signature where + overloadedMethod _ = x11DisplayUngrab + +#endif + +-- XXX Could not generate method X11Display::utf8_to_compound_text +-- Error was : Not implemented: "Don't know how to allocate \"encoding\" of type TInterface (Name {namespace = \"Gdk\", name = \"Atom\"})" +#if ENABLE_OVERLOADING +-- XXX: Dummy instance, since code generation failed. +-- Please file a bug at http://github.com/haskell-gi/haskell-gi. +data X11DisplayUtf8ToCompoundTextMethodInfo +instance (p ~ (), o ~ O.MethodResolutionFailed "utf8ToCompoundText" X11Display) => O.MethodInfo X11DisplayUtf8ToCompoundTextMethodInfo o p where + overloadedMethod _ = undefined +#endif + +-- method X11Display::get_glx_version +-- method type : MemberFunction +-- Args : [Arg {argCName = "display", argType = TInterface (Name {namespace = "Gdk", name = "Display"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkDisplay", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "major", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for the GLX major version", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "minor", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for the GLX minor version", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] +-- Lengths : [] +-- returnType : Just (TBasicType TBoolean) +-- throws : False +-- Skip return : False + +foreign import ccall "gdk_x11_display_get_glx_version" gdk_x11_display_get_glx_version :: + Ptr Gdk.Display.Display -> -- display : TInterface (Name {namespace = "Gdk", name = "Display"}) + Ptr Int32 -> -- major : TBasicType TInt + Ptr Int32 -> -- minor : TBasicType TInt + IO CInt + +{- | +Retrieves the version of the GLX implementation. + +/Since: 3.16/ +-} +x11DisplayGetGlxVersion :: + (B.CallStack.HasCallStack, MonadIO m, Gdk.Display.IsDisplay a) => + a + {- ^ /@display@/: a 'GI.Gdk.Objects.Display.Display' -} + -> m ((Bool, Int32, Int32)) + {- ^ __Returns:__ 'True' if GLX is available -} +x11DisplayGetGlxVersion display = liftIO $ do + display' <- unsafeManagedPtrCastPtr display + major <- allocMem :: IO (Ptr Int32) + minor <- allocMem :: IO (Ptr Int32) + result <- gdk_x11_display_get_glx_version display' major minor + let result' = (/= 0) result + major' <- peek major + minor' <- peek minor + touchManagedPtr display + freeMem major + freeMem minor + return (result', major', minor') + +#if ENABLE_OVERLOADING +#endif + + diff --git a/GI/GdkX11/Objects/X11Display.hs-boot b/GI/GdkX11/Objects/X11Display.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GdkX11/Objects/X11Display.hs-boot @@ -0,0 +1,71 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GdkX11.Objects.X11Display 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 + +newtype X11Display = X11Display (ManagedPtr X11Display) +instance GObject X11Display where +class (GObject o, O.IsDescendantOf X11Display o) => IsX11Display o +instance (GObject o, O.IsDescendantOf X11Display o) => IsX11Display o +instance O.HasParentTypes X11Display +#if ENABLE_OVERLOADING +data X11DisplayErrorTrapPopMethodInfo +#endif +#if ENABLE_OVERLOADING +data X11DisplayErrorTrapPopIgnoredMethodInfo +#endif +#if ENABLE_OVERLOADING +data X11DisplayErrorTrapPushMethodInfo +#endif +#if ENABLE_OVERLOADING +data X11DisplayGetStartupNotificationIdMethodInfo +#endif +#if ENABLE_OVERLOADING +data X11DisplayGetUserTimeMethodInfo +#endif +#if ENABLE_OVERLOADING +data X11DisplayGetXdisplayMethodInfo +#endif +#if ENABLE_OVERLOADING +data X11DisplayGrabMethodInfo +#endif +#if ENABLE_OVERLOADING +data X11DisplaySetCursorThemeMethodInfo +#endif +#if ENABLE_OVERLOADING +data X11DisplaySetStartupNotificationIdMethodInfo +#endif +#if ENABLE_OVERLOADING +data X11DisplaySetWindowScaleMethodInfo +#endif +#if ENABLE_OVERLOADING +data X11DisplayStringToCompoundTextMethodInfo +#endif +#if ENABLE_OVERLOADING +data X11DisplayTextPropertyToTextListMethodInfo +#endif +#if ENABLE_OVERLOADING +data X11DisplayUngrabMethodInfo +#endif +#if ENABLE_OVERLOADING +data X11DisplayUtf8ToCompoundTextMethodInfo +#endif diff --git a/GI/GdkX11/Objects/X11DisplayManager.hs b/GI/GdkX11/Objects/X11DisplayManager.hs new file mode 100644 --- /dev/null +++ b/GI/GdkX11/Objects/X11DisplayManager.hs @@ -0,0 +1,126 @@ + + +{- | +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.GdkX11.Objects.X11DisplayManager + ( + +-- * Exported types + X11DisplayManager(..) , + IsX11DisplayManager , + toX11DisplayManager , + noX11DisplayManager , + + + ) 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 qualified GI.Gdk.Objects.DisplayManager as Gdk.DisplayManager + +-- | Memory-managed wrapper type. +newtype X11DisplayManager = X11DisplayManager (ManagedPtr X11DisplayManager) +foreign import ccall "gdk_x11_display_manager_get_type" + c_gdk_x11_display_manager_get_type :: IO GType + +instance GObject X11DisplayManager where + gobjectType = c_gdk_x11_display_manager_get_type + + +-- | Type class for types which can be safely cast to `X11DisplayManager`, for instance with `toX11DisplayManager`. +class (GObject o, O.IsDescendantOf X11DisplayManager o) => IsX11DisplayManager o +instance (GObject o, O.IsDescendantOf X11DisplayManager o) => IsX11DisplayManager o + +instance O.HasParentTypes X11DisplayManager +type instance O.ParentTypes X11DisplayManager = '[Gdk.DisplayManager.DisplayManager, GObject.Object.Object] + +-- | Cast to `X11DisplayManager`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toX11DisplayManager :: (MonadIO m, IsX11DisplayManager o) => o -> m X11DisplayManager +toX11DisplayManager = liftIO . unsafeCastTo X11DisplayManager + +-- | A convenience alias for `Nothing` :: `Maybe` `X11DisplayManager`. +noX11DisplayManager :: Maybe X11DisplayManager +noX11DisplayManager = Nothing + +#if ENABLE_OVERLOADING +type family ResolveX11DisplayManagerMethod (t :: Symbol) (o :: *) :: * where + ResolveX11DisplayManagerMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveX11DisplayManagerMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveX11DisplayManagerMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveX11DisplayManagerMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveX11DisplayManagerMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveX11DisplayManagerMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveX11DisplayManagerMethod "listDisplays" o = Gdk.DisplayManager.DisplayManagerListDisplaysMethodInfo + ResolveX11DisplayManagerMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveX11DisplayManagerMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveX11DisplayManagerMethod "openDisplay" o = Gdk.DisplayManager.DisplayManagerOpenDisplayMethodInfo + ResolveX11DisplayManagerMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveX11DisplayManagerMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveX11DisplayManagerMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveX11DisplayManagerMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveX11DisplayManagerMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveX11DisplayManagerMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveX11DisplayManagerMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveX11DisplayManagerMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveX11DisplayManagerMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveX11DisplayManagerMethod "getDefaultDisplay" o = Gdk.DisplayManager.DisplayManagerGetDefaultDisplayMethodInfo + ResolveX11DisplayManagerMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveX11DisplayManagerMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveX11DisplayManagerMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveX11DisplayManagerMethod "setDefaultDisplay" o = Gdk.DisplayManager.DisplayManagerSetDefaultDisplayMethodInfo + ResolveX11DisplayManagerMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveX11DisplayManagerMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveX11DisplayManagerMethod t X11DisplayManager, O.MethodInfo info X11DisplayManager p) => OL.IsLabel t (X11DisplayManager -> 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 X11DisplayManager +type instance O.AttributeList X11DisplayManager = X11DisplayManagerAttributeList +type X11DisplayManagerAttributeList = ('[ '("defaultDisplay", Gdk.DisplayManager.DisplayManagerDefaultDisplayPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList X11DisplayManager = X11DisplayManagerSignalList +type X11DisplayManagerSignalList = ('[ '("displayOpened", Gdk.DisplayManager.DisplayManagerDisplayOpenedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + + diff --git a/GI/GdkX11/Objects/X11DisplayManager.hs-boot b/GI/GdkX11/Objects/X11DisplayManager.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GdkX11/Objects/X11DisplayManager.hs-boot @@ -0,0 +1,29 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GdkX11.Objects.X11DisplayManager 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 + +newtype X11DisplayManager = X11DisplayManager (ManagedPtr X11DisplayManager) +instance GObject X11DisplayManager where +class (GObject o, O.IsDescendantOf X11DisplayManager o) => IsX11DisplayManager o +instance (GObject o, O.IsDescendantOf X11DisplayManager o) => IsX11DisplayManager o +instance O.HasParentTypes X11DisplayManager diff --git a/GI/GdkX11/Objects/X11DragContext.hs b/GI/GdkX11/Objects/X11DragContext.hs new file mode 100644 --- /dev/null +++ b/GI/GdkX11/Objects/X11DragContext.hs @@ -0,0 +1,134 @@ + + +{- | +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.GdkX11.Objects.X11DragContext + ( + +-- * Exported types + X11DragContext(..) , + IsX11DragContext , + toX11DragContext , + noX11DragContext , + + + ) 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 qualified GI.Gdk.Objects.DragContext as Gdk.DragContext + +-- | Memory-managed wrapper type. +newtype X11DragContext = X11DragContext (ManagedPtr X11DragContext) +foreign import ccall "gdk_x11_drag_context_get_type" + c_gdk_x11_drag_context_get_type :: IO GType + +instance GObject X11DragContext where + gobjectType = c_gdk_x11_drag_context_get_type + + +-- | Type class for types which can be safely cast to `X11DragContext`, for instance with `toX11DragContext`. +class (GObject o, O.IsDescendantOf X11DragContext o) => IsX11DragContext o +instance (GObject o, O.IsDescendantOf X11DragContext o) => IsX11DragContext o + +instance O.HasParentTypes X11DragContext +type instance O.ParentTypes X11DragContext = '[Gdk.DragContext.DragContext, GObject.Object.Object] + +-- | Cast to `X11DragContext`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toX11DragContext :: (MonadIO m, IsX11DragContext o) => o -> m X11DragContext +toX11DragContext = liftIO . unsafeCastTo X11DragContext + +-- | A convenience alias for `Nothing` :: `Maybe` `X11DragContext`. +noX11DragContext :: Maybe X11DragContext +noX11DragContext = Nothing + +#if ENABLE_OVERLOADING +type family ResolveX11DragContextMethod (t :: Symbol) (o :: *) :: * where + ResolveX11DragContextMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveX11DragContextMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveX11DragContextMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveX11DragContextMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveX11DragContextMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveX11DragContextMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveX11DragContextMethod "listTargets" o = Gdk.DragContext.DragContextListTargetsMethodInfo + ResolveX11DragContextMethod "manageDnd" o = Gdk.DragContext.DragContextManageDndMethodInfo + ResolveX11DragContextMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveX11DragContextMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveX11DragContextMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveX11DragContextMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveX11DragContextMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveX11DragContextMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveX11DragContextMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveX11DragContextMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveX11DragContextMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveX11DragContextMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveX11DragContextMethod "getActions" o = Gdk.DragContext.DragContextGetActionsMethodInfo + ResolveX11DragContextMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveX11DragContextMethod "getDestWindow" o = Gdk.DragContext.DragContextGetDestWindowMethodInfo + ResolveX11DragContextMethod "getDevice" o = Gdk.DragContext.DragContextGetDeviceMethodInfo + ResolveX11DragContextMethod "getDragWindow" o = Gdk.DragContext.DragContextGetDragWindowMethodInfo + ResolveX11DragContextMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveX11DragContextMethod "getProtocol" o = Gdk.DragContext.DragContextGetProtocolMethodInfo + ResolveX11DragContextMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveX11DragContextMethod "getSelectedAction" o = Gdk.DragContext.DragContextGetSelectedActionMethodInfo + ResolveX11DragContextMethod "getSourceWindow" o = Gdk.DragContext.DragContextGetSourceWindowMethodInfo + ResolveX11DragContextMethod "getSuggestedAction" o = Gdk.DragContext.DragContextGetSuggestedActionMethodInfo + ResolveX11DragContextMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveX11DragContextMethod "setDevice" o = Gdk.DragContext.DragContextSetDeviceMethodInfo + ResolveX11DragContextMethod "setHotspot" o = Gdk.DragContext.DragContextSetHotspotMethodInfo + ResolveX11DragContextMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveX11DragContextMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveX11DragContextMethod t X11DragContext, O.MethodInfo info X11DragContext p) => OL.IsLabel t (X11DragContext -> 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 X11DragContext +type instance O.AttributeList X11DragContext = X11DragContextAttributeList +type X11DragContextAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList X11DragContext = X11DragContextSignalList +type X11DragContextSignalList = ('[ '("actionChanged", Gdk.DragContext.DragContextActionChangedSignalInfo), '("cancel", Gdk.DragContext.DragContextCancelSignalInfo), '("dndFinished", Gdk.DragContext.DragContextDndFinishedSignalInfo), '("dropPerformed", Gdk.DragContext.DragContextDropPerformedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + + diff --git a/GI/GdkX11/Objects/X11DragContext.hs-boot b/GI/GdkX11/Objects/X11DragContext.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GdkX11/Objects/X11DragContext.hs-boot @@ -0,0 +1,29 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GdkX11.Objects.X11DragContext 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 + +newtype X11DragContext = X11DragContext (ManagedPtr X11DragContext) +instance GObject X11DragContext where +class (GObject o, O.IsDescendantOf X11DragContext o) => IsX11DragContext o +instance (GObject o, O.IsDescendantOf X11DragContext o) => IsX11DragContext o +instance O.HasParentTypes X11DragContext diff --git a/GI/GdkX11/Objects/X11GLContext.hs b/GI/GdkX11/Objects/X11GLContext.hs new file mode 100644 --- /dev/null +++ b/GI/GdkX11/Objects/X11GLContext.hs @@ -0,0 +1,137 @@ + + +{- | +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.GdkX11.Objects.X11GLContext + ( + +-- * Exported types + X11GLContext(..) , + IsX11GLContext , + toX11GLContext , + noX11GLContext , + + + ) 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 qualified GI.Gdk.Objects.GLContext as Gdk.GLContext + +-- | Memory-managed wrapper type. +newtype X11GLContext = X11GLContext (ManagedPtr X11GLContext) +foreign import ccall "gdk_x11_gl_context_get_type" + c_gdk_x11_gl_context_get_type :: IO GType + +instance GObject X11GLContext where + gobjectType = c_gdk_x11_gl_context_get_type + + +-- | Type class for types which can be safely cast to `X11GLContext`, for instance with `toX11GLContext`. +class (GObject o, O.IsDescendantOf X11GLContext o) => IsX11GLContext o +instance (GObject o, O.IsDescendantOf X11GLContext o) => IsX11GLContext o + +instance O.HasParentTypes X11GLContext +type instance O.ParentTypes X11GLContext = '[Gdk.GLContext.GLContext, GObject.Object.Object] + +-- | Cast to `X11GLContext`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toX11GLContext :: (MonadIO m, IsX11GLContext o) => o -> m X11GLContext +toX11GLContext = liftIO . unsafeCastTo X11GLContext + +-- | A convenience alias for `Nothing` :: `Maybe` `X11GLContext`. +noX11GLContext :: Maybe X11GLContext +noX11GLContext = Nothing + +#if ENABLE_OVERLOADING +type family ResolveX11GLContextMethod (t :: Symbol) (o :: *) :: * where + ResolveX11GLContextMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveX11GLContextMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveX11GLContextMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveX11GLContextMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveX11GLContextMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveX11GLContextMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveX11GLContextMethod "isLegacy" o = Gdk.GLContext.GLContextIsLegacyMethodInfo + ResolveX11GLContextMethod "makeCurrent" o = Gdk.GLContext.GLContextMakeCurrentMethodInfo + ResolveX11GLContextMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveX11GLContextMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveX11GLContextMethod "realize" o = Gdk.GLContext.GLContextRealizeMethodInfo + ResolveX11GLContextMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveX11GLContextMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveX11GLContextMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveX11GLContextMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveX11GLContextMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveX11GLContextMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveX11GLContextMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveX11GLContextMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveX11GLContextMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveX11GLContextMethod "getDebugEnabled" o = Gdk.GLContext.GLContextGetDebugEnabledMethodInfo + ResolveX11GLContextMethod "getDisplay" o = Gdk.GLContext.GLContextGetDisplayMethodInfo + ResolveX11GLContextMethod "getForwardCompatible" o = Gdk.GLContext.GLContextGetForwardCompatibleMethodInfo + ResolveX11GLContextMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveX11GLContextMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveX11GLContextMethod "getRequiredVersion" o = Gdk.GLContext.GLContextGetRequiredVersionMethodInfo + ResolveX11GLContextMethod "getSharedContext" o = Gdk.GLContext.GLContextGetSharedContextMethodInfo + ResolveX11GLContextMethod "getUseEs" o = Gdk.GLContext.GLContextGetUseEsMethodInfo + ResolveX11GLContextMethod "getVersion" o = Gdk.GLContext.GLContextGetVersionMethodInfo + ResolveX11GLContextMethod "getWindow" o = Gdk.GLContext.GLContextGetWindowMethodInfo + ResolveX11GLContextMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveX11GLContextMethod "setDebugEnabled" o = Gdk.GLContext.GLContextSetDebugEnabledMethodInfo + ResolveX11GLContextMethod "setForwardCompatible" o = Gdk.GLContext.GLContextSetForwardCompatibleMethodInfo + ResolveX11GLContextMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveX11GLContextMethod "setRequiredVersion" o = Gdk.GLContext.GLContextSetRequiredVersionMethodInfo + ResolveX11GLContextMethod "setUseEs" o = Gdk.GLContext.GLContextSetUseEsMethodInfo + ResolveX11GLContextMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveX11GLContextMethod t X11GLContext, O.MethodInfo info X11GLContext p) => OL.IsLabel t (X11GLContext -> 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 X11GLContext +type instance O.AttributeList X11GLContext = X11GLContextAttributeList +type X11GLContextAttributeList = ('[ '("display", Gdk.GLContext.GLContextDisplayPropertyInfo), '("sharedContext", Gdk.GLContext.GLContextSharedContextPropertyInfo), '("window", Gdk.GLContext.GLContextWindowPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList X11GLContext = X11GLContextSignalList +type X11GLContextSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + + diff --git a/GI/GdkX11/Objects/X11GLContext.hs-boot b/GI/GdkX11/Objects/X11GLContext.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GdkX11/Objects/X11GLContext.hs-boot @@ -0,0 +1,29 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GdkX11.Objects.X11GLContext 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 + +newtype X11GLContext = X11GLContext (ManagedPtr X11GLContext) +instance GObject X11GLContext where +class (GObject o, O.IsDescendantOf X11GLContext o) => IsX11GLContext o +instance (GObject o, O.IsDescendantOf X11GLContext o) => IsX11GLContext o +instance O.HasParentTypes X11GLContext diff --git a/GI/GdkX11/Objects/X11Keymap.hs b/GI/GdkX11/Objects/X11Keymap.hs new file mode 100644 --- /dev/null +++ b/GI/GdkX11/Objects/X11Keymap.hs @@ -0,0 +1,242 @@ + + +{- | +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.GdkX11.Objects.X11Keymap + ( + +-- * Exported types + X11Keymap(..) , + IsX11Keymap , + toX11Keymap , + noX11Keymap , + + + -- * Methods +-- ** getGroupForState #method:getGroupForState# + +#if ENABLE_OVERLOADING + X11KeymapGetGroupForStateMethodInfo , +#endif + x11KeymapGetGroupForState , + + +-- ** keyIsModifier #method:keyIsModifier# + +#if ENABLE_OVERLOADING + X11KeymapKeyIsModifierMethodInfo , +#endif + x11KeymapKeyIsModifier , + + + + + ) 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 qualified GI.Gdk.Objects.Keymap as Gdk.Keymap + +-- | Memory-managed wrapper type. +newtype X11Keymap = X11Keymap (ManagedPtr X11Keymap) +foreign import ccall "gdk_x11_keymap_get_type" + c_gdk_x11_keymap_get_type :: IO GType + +instance GObject X11Keymap where + gobjectType = c_gdk_x11_keymap_get_type + + +-- | Type class for types which can be safely cast to `X11Keymap`, for instance with `toX11Keymap`. +class (GObject o, O.IsDescendantOf X11Keymap o) => IsX11Keymap o +instance (GObject o, O.IsDescendantOf X11Keymap o) => IsX11Keymap o + +instance O.HasParentTypes X11Keymap +type instance O.ParentTypes X11Keymap = '[Gdk.Keymap.Keymap, GObject.Object.Object] + +-- | Cast to `X11Keymap`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toX11Keymap :: (MonadIO m, IsX11Keymap o) => o -> m X11Keymap +toX11Keymap = liftIO . unsafeCastTo X11Keymap + +-- | A convenience alias for `Nothing` :: `Maybe` `X11Keymap`. +noX11Keymap :: Maybe X11Keymap +noX11Keymap = Nothing + +#if ENABLE_OVERLOADING +type family ResolveX11KeymapMethod (t :: Symbol) (o :: *) :: * where + ResolveX11KeymapMethod "addVirtualModifiers" o = Gdk.Keymap.KeymapAddVirtualModifiersMethodInfo + ResolveX11KeymapMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveX11KeymapMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveX11KeymapMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveX11KeymapMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveX11KeymapMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveX11KeymapMethod "haveBidiLayouts" o = Gdk.Keymap.KeymapHaveBidiLayoutsMethodInfo + ResolveX11KeymapMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveX11KeymapMethod "keyIsModifier" o = X11KeymapKeyIsModifierMethodInfo + ResolveX11KeymapMethod "lookupKey" o = Gdk.Keymap.KeymapLookupKeyMethodInfo + ResolveX11KeymapMethod "mapVirtualModifiers" o = Gdk.Keymap.KeymapMapVirtualModifiersMethodInfo + ResolveX11KeymapMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveX11KeymapMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveX11KeymapMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveX11KeymapMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveX11KeymapMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveX11KeymapMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveX11KeymapMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveX11KeymapMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveX11KeymapMethod "translateKeyboardState" o = Gdk.Keymap.KeymapTranslateKeyboardStateMethodInfo + ResolveX11KeymapMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveX11KeymapMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveX11KeymapMethod "getCapsLockState" o = Gdk.Keymap.KeymapGetCapsLockStateMethodInfo + ResolveX11KeymapMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveX11KeymapMethod "getDirection" o = Gdk.Keymap.KeymapGetDirectionMethodInfo + ResolveX11KeymapMethod "getEntriesForKeycode" o = Gdk.Keymap.KeymapGetEntriesForKeycodeMethodInfo + ResolveX11KeymapMethod "getEntriesForKeyval" o = Gdk.Keymap.KeymapGetEntriesForKeyvalMethodInfo + ResolveX11KeymapMethod "getGroupForState" o = X11KeymapGetGroupForStateMethodInfo + ResolveX11KeymapMethod "getModifierMask" o = Gdk.Keymap.KeymapGetModifierMaskMethodInfo + ResolveX11KeymapMethod "getModifierState" o = Gdk.Keymap.KeymapGetModifierStateMethodInfo + ResolveX11KeymapMethod "getNumLockState" o = Gdk.Keymap.KeymapGetNumLockStateMethodInfo + ResolveX11KeymapMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveX11KeymapMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveX11KeymapMethod "getScrollLockState" o = Gdk.Keymap.KeymapGetScrollLockStateMethodInfo + ResolveX11KeymapMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveX11KeymapMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveX11KeymapMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveX11KeymapMethod t X11Keymap, O.MethodInfo info X11Keymap p) => OL.IsLabel t (X11Keymap -> 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 X11Keymap +type instance O.AttributeList X11Keymap = X11KeymapAttributeList +type X11KeymapAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList X11Keymap = X11KeymapSignalList +type X11KeymapSignalList = ('[ '("directionChanged", Gdk.Keymap.KeymapDirectionChangedSignalInfo), '("keysChanged", Gdk.Keymap.KeymapKeysChangedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("stateChanged", Gdk.Keymap.KeymapStateChangedSignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method X11Keymap::get_group_for_state +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "keymap", argType = TInterface (Name {namespace = "GdkX11", name = "X11Keymap"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkX11Keymap", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "state", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "raw state returned from X", 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 "gdk_x11_keymap_get_group_for_state" gdk_x11_keymap_get_group_for_state :: + Ptr X11Keymap -> -- keymap : TInterface (Name {namespace = "GdkX11", name = "X11Keymap"}) + Word32 -> -- state : TBasicType TUInt + IO Int32 + +{- | +Extracts the group from the state field sent in an X Key event. +This is only needed for code processing raw X events, since 'GI.Gdk.Structs.EventKey.EventKey' +directly includes an is_modifier field. + +/Since: 3.6/ +-} +x11KeymapGetGroupForState :: + (B.CallStack.HasCallStack, MonadIO m, IsX11Keymap a) => + a + {- ^ /@keymap@/: a 'GI.GdkX11.Objects.X11Keymap.X11Keymap' -} + -> Word32 + {- ^ /@state@/: raw state returned from X -} + -> m Int32 + {- ^ __Returns:__ the index of the active keyboard group for the event -} +x11KeymapGetGroupForState keymap state = liftIO $ do + keymap' <- unsafeManagedPtrCastPtr keymap + result <- gdk_x11_keymap_get_group_for_state keymap' state + touchManagedPtr keymap + return result + +#if ENABLE_OVERLOADING +data X11KeymapGetGroupForStateMethodInfo +instance (signature ~ (Word32 -> m Int32), MonadIO m, IsX11Keymap a) => O.MethodInfo X11KeymapGetGroupForStateMethodInfo a signature where + overloadedMethod _ = x11KeymapGetGroupForState + +#endif + +-- method X11Keymap::key_is_modifier +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "keymap", argType = TInterface (Name {namespace = "GdkX11", name = "X11Keymap"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkX11Keymap", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "keycode", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the hardware keycode from a key event", 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 "gdk_x11_keymap_key_is_modifier" gdk_x11_keymap_key_is_modifier :: + Ptr X11Keymap -> -- keymap : TInterface (Name {namespace = "GdkX11", name = "X11Keymap"}) + Word32 -> -- keycode : TBasicType TUInt + IO CInt + +{- | +Determines whether a particular key code represents a key that +is a modifier. That is, it’s a key that normally just affects +the keyboard state and the behavior of other keys rather than +producing a direct effect itself. This is only needed for code +processing raw X events, since 'GI.Gdk.Structs.EventKey.EventKey' directly includes +an is_modifier field. + +/Since: 3.6/ +-} +x11KeymapKeyIsModifier :: + (B.CallStack.HasCallStack, MonadIO m, IsX11Keymap a) => + a + {- ^ /@keymap@/: a 'GI.GdkX11.Objects.X11Keymap.X11Keymap' -} + -> Word32 + {- ^ /@keycode@/: the hardware keycode from a key event -} + -> m Bool + {- ^ __Returns:__ 'True' if the hardware keycode is a modifier key -} +x11KeymapKeyIsModifier keymap keycode = liftIO $ do + keymap' <- unsafeManagedPtrCastPtr keymap + result <- gdk_x11_keymap_key_is_modifier keymap' keycode + let result' = (/= 0) result + touchManagedPtr keymap + return result' + +#if ENABLE_OVERLOADING +data X11KeymapKeyIsModifierMethodInfo +instance (signature ~ (Word32 -> m Bool), MonadIO m, IsX11Keymap a) => O.MethodInfo X11KeymapKeyIsModifierMethodInfo a signature where + overloadedMethod _ = x11KeymapKeyIsModifier + +#endif + + diff --git a/GI/GdkX11/Objects/X11Keymap.hs-boot b/GI/GdkX11/Objects/X11Keymap.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GdkX11/Objects/X11Keymap.hs-boot @@ -0,0 +1,35 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GdkX11.Objects.X11Keymap 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 + +newtype X11Keymap = X11Keymap (ManagedPtr X11Keymap) +instance GObject X11Keymap where +class (GObject o, O.IsDescendantOf X11Keymap o) => IsX11Keymap o +instance (GObject o, O.IsDescendantOf X11Keymap o) => IsX11Keymap o +instance O.HasParentTypes X11Keymap +#if ENABLE_OVERLOADING +data X11KeymapGetGroupForStateMethodInfo +#endif +#if ENABLE_OVERLOADING +data X11KeymapKeyIsModifierMethodInfo +#endif diff --git a/GI/GdkX11/Objects/X11Monitor.hs b/GI/GdkX11/Objects/X11Monitor.hs new file mode 100644 --- /dev/null +++ b/GI/GdkX11/Objects/X11Monitor.hs @@ -0,0 +1,169 @@ + + +{- | +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.GdkX11.Objects.X11Monitor + ( + +-- * Exported types + X11Monitor(..) , + IsX11Monitor , + toX11Monitor , + noX11Monitor , + + + -- * Methods +-- ** getOutput #method:getOutput# + + x11MonitorGetOutput , + + + + + ) 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 qualified GI.Gdk.Objects.Monitor as Gdk.Monitor + +-- | Memory-managed wrapper type. +newtype X11Monitor = X11Monitor (ManagedPtr X11Monitor) +foreign import ccall "gdk_x11_monitor_get_type" + c_gdk_x11_monitor_get_type :: IO GType + +instance GObject X11Monitor where + gobjectType = c_gdk_x11_monitor_get_type + + +-- | Type class for types which can be safely cast to `X11Monitor`, for instance with `toX11Monitor`. +class (GObject o, O.IsDescendantOf X11Monitor o) => IsX11Monitor o +instance (GObject o, O.IsDescendantOf X11Monitor o) => IsX11Monitor o + +instance O.HasParentTypes X11Monitor +type instance O.ParentTypes X11Monitor = '[Gdk.Monitor.Monitor, GObject.Object.Object] + +-- | Cast to `X11Monitor`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toX11Monitor :: (MonadIO m, IsX11Monitor o) => o -> m X11Monitor +toX11Monitor = liftIO . unsafeCastTo X11Monitor + +-- | A convenience alias for `Nothing` :: `Maybe` `X11Monitor`. +noX11Monitor :: Maybe X11Monitor +noX11Monitor = Nothing + +#if ENABLE_OVERLOADING +type family ResolveX11MonitorMethod (t :: Symbol) (o :: *) :: * where + ResolveX11MonitorMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveX11MonitorMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveX11MonitorMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveX11MonitorMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveX11MonitorMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveX11MonitorMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveX11MonitorMethod "isPrimary" o = Gdk.Monitor.MonitorIsPrimaryMethodInfo + ResolveX11MonitorMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveX11MonitorMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveX11MonitorMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveX11MonitorMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveX11MonitorMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveX11MonitorMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveX11MonitorMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveX11MonitorMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveX11MonitorMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveX11MonitorMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveX11MonitorMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveX11MonitorMethod "getDisplay" o = Gdk.Monitor.MonitorGetDisplayMethodInfo + ResolveX11MonitorMethod "getGeometry" o = Gdk.Monitor.MonitorGetGeometryMethodInfo + ResolveX11MonitorMethod "getHeightMm" o = Gdk.Monitor.MonitorGetHeightMmMethodInfo + ResolveX11MonitorMethod "getManufacturer" o = Gdk.Monitor.MonitorGetManufacturerMethodInfo + ResolveX11MonitorMethod "getModel" o = Gdk.Monitor.MonitorGetModelMethodInfo + ResolveX11MonitorMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveX11MonitorMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveX11MonitorMethod "getRefreshRate" o = Gdk.Monitor.MonitorGetRefreshRateMethodInfo + ResolveX11MonitorMethod "getScaleFactor" o = Gdk.Monitor.MonitorGetScaleFactorMethodInfo + ResolveX11MonitorMethod "getSubpixelLayout" o = Gdk.Monitor.MonitorGetSubpixelLayoutMethodInfo + ResolveX11MonitorMethod "getWidthMm" o = Gdk.Monitor.MonitorGetWidthMmMethodInfo + ResolveX11MonitorMethod "getWorkarea" o = Gdk.Monitor.MonitorGetWorkareaMethodInfo + ResolveX11MonitorMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveX11MonitorMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveX11MonitorMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveX11MonitorMethod t X11Monitor, O.MethodInfo info X11Monitor p) => OL.IsLabel t (X11Monitor -> 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 X11Monitor +type instance O.AttributeList X11Monitor = X11MonitorAttributeList +type X11MonitorAttributeList = ('[ '("display", Gdk.Monitor.MonitorDisplayPropertyInfo), '("geometry", Gdk.Monitor.MonitorGeometryPropertyInfo), '("heightMm", Gdk.Monitor.MonitorHeightMmPropertyInfo), '("manufacturer", Gdk.Monitor.MonitorManufacturerPropertyInfo), '("model", Gdk.Monitor.MonitorModelPropertyInfo), '("refreshRate", Gdk.Monitor.MonitorRefreshRatePropertyInfo), '("scaleFactor", Gdk.Monitor.MonitorScaleFactorPropertyInfo), '("subpixelLayout", Gdk.Monitor.MonitorSubpixelLayoutPropertyInfo), '("widthMm", Gdk.Monitor.MonitorWidthMmPropertyInfo), '("workarea", Gdk.Monitor.MonitorWorkareaPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList X11Monitor = X11MonitorSignalList +type X11MonitorSignalList = ('[ '("invalidate", Gdk.Monitor.MonitorInvalidateSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method X11Monitor::get_output +-- method type : MemberFunction +-- Args : [Arg {argCName = "monitor", argType = TInterface (Name {namespace = "Gdk", name = "Monitor"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TULong) +-- throws : False +-- Skip return : False + +foreign import ccall "gdk_x11_monitor_get_output" gdk_x11_monitor_get_output :: + Ptr Gdk.Monitor.Monitor -> -- monitor : TInterface (Name {namespace = "Gdk", name = "Monitor"}) + IO CULong + +{- | +/No description available in the introspection data./ +-} +x11MonitorGetOutput :: + (B.CallStack.HasCallStack, MonadIO m, Gdk.Monitor.IsMonitor a) => + a + -> m CULong +x11MonitorGetOutput monitor = liftIO $ do + monitor' <- unsafeManagedPtrCastPtr monitor + result <- gdk_x11_monitor_get_output monitor' + touchManagedPtr monitor + return result + +#if ENABLE_OVERLOADING +#endif + + diff --git a/GI/GdkX11/Objects/X11Monitor.hs-boot b/GI/GdkX11/Objects/X11Monitor.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GdkX11/Objects/X11Monitor.hs-boot @@ -0,0 +1,29 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GdkX11.Objects.X11Monitor 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 + +newtype X11Monitor = X11Monitor (ManagedPtr X11Monitor) +instance GObject X11Monitor where +class (GObject o, O.IsDescendantOf X11Monitor o) => IsX11Monitor o +instance (GObject o, O.IsDescendantOf X11Monitor o) => IsX11Monitor o +instance O.HasParentTypes X11Monitor diff --git a/GI/GdkX11/Objects/X11Screen.hs b/GI/GdkX11/Objects/X11Screen.hs new file mode 100644 --- /dev/null +++ b/GI/GdkX11/Objects/X11Screen.hs @@ -0,0 +1,650 @@ + + +{- | +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.GdkX11.Objects.X11Screen + ( + +-- * Exported types + X11Screen(..) , + IsX11Screen , + toX11Screen , + noX11Screen , + + + -- * Methods +-- ** getCurrentDesktop #method:getCurrentDesktop# + +#if ENABLE_OVERLOADING + X11ScreenGetCurrentDesktopMethodInfo , +#endif + x11ScreenGetCurrentDesktop , + + +-- ** getMonitorOutput #method:getMonitorOutput# + +#if ENABLE_OVERLOADING + X11ScreenGetMonitorOutputMethodInfo , +#endif + x11ScreenGetMonitorOutput , + + +-- ** getNumberOfDesktops #method:getNumberOfDesktops# + +#if ENABLE_OVERLOADING + X11ScreenGetNumberOfDesktopsMethodInfo , +#endif + x11ScreenGetNumberOfDesktops , + + +-- ** getScreenNumber #method:getScreenNumber# + +#if ENABLE_OVERLOADING + X11ScreenGetScreenNumberMethodInfo , +#endif + x11ScreenGetScreenNumber , + + +-- ** getWindowManagerName #method:getWindowManagerName# + +#if ENABLE_OVERLOADING + X11ScreenGetWindowManagerNameMethodInfo , +#endif + x11ScreenGetWindowManagerName , + + +-- ** getXscreen #method:getXscreen# + +#if ENABLE_OVERLOADING + X11ScreenGetXscreenMethodInfo , +#endif + x11ScreenGetXscreen , + + +-- ** lookupVisual #method:lookupVisual# + +#if ENABLE_OVERLOADING + X11ScreenLookupVisualMethodInfo , +#endif + x11ScreenLookupVisual , + + +-- ** supportsNetWmHint #method:supportsNetWmHint# + +#if ENABLE_OVERLOADING + X11ScreenSupportsNetWmHintMethodInfo , +#endif + x11ScreenSupportsNetWmHint , + + + + + -- * Signals +-- ** windowManagerChanged #signal:windowManagerChanged# + + C_X11ScreenWindowManagerChangedCallback , + X11ScreenWindowManagerChangedCallback , +#if ENABLE_OVERLOADING + X11ScreenWindowManagerChangedSignalInfo , +#endif + afterX11ScreenWindowManagerChanged , + genClosure_X11ScreenWindowManagerChanged, + mk_X11ScreenWindowManagerChangedCallback, + noX11ScreenWindowManagerChangedCallback , + onX11ScreenWindowManagerChanged , + wrap_X11ScreenWindowManagerChangedCallback, + + + + + ) 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 qualified GI.Gdk.Objects.Screen as Gdk.Screen +import qualified GI.Gdk.Structs.Atom as Gdk.Atom +import {-# SOURCE #-} qualified GI.GdkX11.Objects.X11Visual as GdkX11.X11Visual +import qualified GI.Xlib.Structs.Screen as Xlib.Screen + +-- | Memory-managed wrapper type. +newtype X11Screen = X11Screen (ManagedPtr X11Screen) +foreign import ccall "gdk_x11_screen_get_type" + c_gdk_x11_screen_get_type :: IO GType + +instance GObject X11Screen where + gobjectType = c_gdk_x11_screen_get_type + + +-- | Type class for types which can be safely cast to `X11Screen`, for instance with `toX11Screen`. +class (GObject o, O.IsDescendantOf X11Screen o) => IsX11Screen o +instance (GObject o, O.IsDescendantOf X11Screen o) => IsX11Screen o + +instance O.HasParentTypes X11Screen +type instance O.ParentTypes X11Screen = '[Gdk.Screen.Screen, GObject.Object.Object] + +-- | Cast to `X11Screen`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toX11Screen :: (MonadIO m, IsX11Screen o) => o -> m X11Screen +toX11Screen = liftIO . unsafeCastTo X11Screen + +-- | A convenience alias for `Nothing` :: `Maybe` `X11Screen`. +noX11Screen :: Maybe X11Screen +noX11Screen = Nothing + +#if ENABLE_OVERLOADING +type family ResolveX11ScreenMethod (t :: Symbol) (o :: *) :: * where + ResolveX11ScreenMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveX11ScreenMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveX11ScreenMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveX11ScreenMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveX11ScreenMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveX11ScreenMethod "isComposited" o = Gdk.Screen.ScreenIsCompositedMethodInfo + ResolveX11ScreenMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveX11ScreenMethod "listVisuals" o = Gdk.Screen.ScreenListVisualsMethodInfo + ResolveX11ScreenMethod "lookupVisual" o = X11ScreenLookupVisualMethodInfo + ResolveX11ScreenMethod "makeDisplayName" o = Gdk.Screen.ScreenMakeDisplayNameMethodInfo + ResolveX11ScreenMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveX11ScreenMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveX11ScreenMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveX11ScreenMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveX11ScreenMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveX11ScreenMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveX11ScreenMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveX11ScreenMethod "supportsNetWmHint" o = X11ScreenSupportsNetWmHintMethodInfo + ResolveX11ScreenMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveX11ScreenMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveX11ScreenMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveX11ScreenMethod "getActiveWindow" o = Gdk.Screen.ScreenGetActiveWindowMethodInfo + ResolveX11ScreenMethod "getCurrentDesktop" o = X11ScreenGetCurrentDesktopMethodInfo + ResolveX11ScreenMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveX11ScreenMethod "getDisplay" o = Gdk.Screen.ScreenGetDisplayMethodInfo + ResolveX11ScreenMethod "getFontOptions" o = Gdk.Screen.ScreenGetFontOptionsMethodInfo + ResolveX11ScreenMethod "getHeight" o = Gdk.Screen.ScreenGetHeightMethodInfo + ResolveX11ScreenMethod "getHeightMm" o = Gdk.Screen.ScreenGetHeightMmMethodInfo + ResolveX11ScreenMethod "getMonitorAtPoint" o = Gdk.Screen.ScreenGetMonitorAtPointMethodInfo + ResolveX11ScreenMethod "getMonitorAtWindow" o = Gdk.Screen.ScreenGetMonitorAtWindowMethodInfo + ResolveX11ScreenMethod "getMonitorGeometry" o = Gdk.Screen.ScreenGetMonitorGeometryMethodInfo + ResolveX11ScreenMethod "getMonitorHeightMm" o = Gdk.Screen.ScreenGetMonitorHeightMmMethodInfo + ResolveX11ScreenMethod "getMonitorOutput" o = X11ScreenGetMonitorOutputMethodInfo + ResolveX11ScreenMethod "getMonitorPlugName" o = Gdk.Screen.ScreenGetMonitorPlugNameMethodInfo + ResolveX11ScreenMethod "getMonitorScaleFactor" o = Gdk.Screen.ScreenGetMonitorScaleFactorMethodInfo + ResolveX11ScreenMethod "getMonitorWidthMm" o = Gdk.Screen.ScreenGetMonitorWidthMmMethodInfo + ResolveX11ScreenMethod "getMonitorWorkarea" o = Gdk.Screen.ScreenGetMonitorWorkareaMethodInfo + ResolveX11ScreenMethod "getNMonitors" o = Gdk.Screen.ScreenGetNMonitorsMethodInfo + ResolveX11ScreenMethod "getNumber" o = Gdk.Screen.ScreenGetNumberMethodInfo + ResolveX11ScreenMethod "getNumberOfDesktops" o = X11ScreenGetNumberOfDesktopsMethodInfo + ResolveX11ScreenMethod "getPrimaryMonitor" o = Gdk.Screen.ScreenGetPrimaryMonitorMethodInfo + ResolveX11ScreenMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveX11ScreenMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveX11ScreenMethod "getResolution" o = Gdk.Screen.ScreenGetResolutionMethodInfo + ResolveX11ScreenMethod "getRgbaVisual" o = Gdk.Screen.ScreenGetRgbaVisualMethodInfo + ResolveX11ScreenMethod "getRootWindow" o = Gdk.Screen.ScreenGetRootWindowMethodInfo + ResolveX11ScreenMethod "getScreenNumber" o = X11ScreenGetScreenNumberMethodInfo + ResolveX11ScreenMethod "getSetting" o = Gdk.Screen.ScreenGetSettingMethodInfo + ResolveX11ScreenMethod "getSystemVisual" o = Gdk.Screen.ScreenGetSystemVisualMethodInfo + ResolveX11ScreenMethod "getToplevelWindows" o = Gdk.Screen.ScreenGetToplevelWindowsMethodInfo + ResolveX11ScreenMethod "getWidth" o = Gdk.Screen.ScreenGetWidthMethodInfo + ResolveX11ScreenMethod "getWidthMm" o = Gdk.Screen.ScreenGetWidthMmMethodInfo + ResolveX11ScreenMethod "getWindowManagerName" o = X11ScreenGetWindowManagerNameMethodInfo + ResolveX11ScreenMethod "getWindowStack" o = Gdk.Screen.ScreenGetWindowStackMethodInfo + ResolveX11ScreenMethod "getXscreen" o = X11ScreenGetXscreenMethodInfo + ResolveX11ScreenMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveX11ScreenMethod "setFontOptions" o = Gdk.Screen.ScreenSetFontOptionsMethodInfo + ResolveX11ScreenMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveX11ScreenMethod "setResolution" o = Gdk.Screen.ScreenSetResolutionMethodInfo + ResolveX11ScreenMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveX11ScreenMethod t X11Screen, O.MethodInfo info X11Screen p) => OL.IsLabel t (X11Screen -> 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 + +-- signal X11Screen::window-manager-changed +{- | +/No description available in the introspection data./ +-} +type X11ScreenWindowManagerChangedCallback = + IO () + +-- | A convenience synonym for @`Nothing` :: `Maybe` `X11ScreenWindowManagerChangedCallback`@. +noX11ScreenWindowManagerChangedCallback :: Maybe X11ScreenWindowManagerChangedCallback +noX11ScreenWindowManagerChangedCallback = Nothing + +-- | Type for the callback on the (unwrapped) C side. +type C_X11ScreenWindowManagerChangedCallback = + Ptr () -> -- object + Ptr () -> -- user_data + IO () + +-- | Generate a function pointer callable from C code, from a `C_X11ScreenWindowManagerChangedCallback`. +foreign import ccall "wrapper" + mk_X11ScreenWindowManagerChangedCallback :: C_X11ScreenWindowManagerChangedCallback -> IO (FunPtr C_X11ScreenWindowManagerChangedCallback) + +-- | Wrap the callback into a `GClosure`. +genClosure_X11ScreenWindowManagerChanged :: MonadIO m => X11ScreenWindowManagerChangedCallback -> m (GClosure C_X11ScreenWindowManagerChangedCallback) +genClosure_X11ScreenWindowManagerChanged cb = liftIO $ do + let cb' = wrap_X11ScreenWindowManagerChangedCallback cb + mk_X11ScreenWindowManagerChangedCallback cb' >>= B.GClosure.newGClosure + + +-- | Wrap a `X11ScreenWindowManagerChangedCallback` into a `C_X11ScreenWindowManagerChangedCallback`. +wrap_X11ScreenWindowManagerChangedCallback :: + X11ScreenWindowManagerChangedCallback -> + C_X11ScreenWindowManagerChangedCallback +wrap_X11ScreenWindowManagerChangedCallback _cb _ _ = do + _cb + + +{- | +Connect a signal handler for the “@window-manager-changed@” signal, to be run before the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.on' x11Screen #windowManagerChanged callback +@ +-} +onX11ScreenWindowManagerChanged :: (IsX11Screen a, MonadIO m) => a -> X11ScreenWindowManagerChangedCallback -> m SignalHandlerId +onX11ScreenWindowManagerChanged obj cb = liftIO $ do + let cb' = wrap_X11ScreenWindowManagerChangedCallback cb + cb'' <- mk_X11ScreenWindowManagerChangedCallback cb' + connectSignalFunPtr obj "window-manager-changed" cb'' SignalConnectBefore + +{- | +Connect a signal handler for the “@window-manager-changed@” signal, to be run after the default handler. +When is enabled, this is equivalent to + +@ +'Data.GI.Base.Signals.after' x11Screen #windowManagerChanged callback +@ +-} +afterX11ScreenWindowManagerChanged :: (IsX11Screen a, MonadIO m) => a -> X11ScreenWindowManagerChangedCallback -> m SignalHandlerId +afterX11ScreenWindowManagerChanged obj cb = liftIO $ do + let cb' = wrap_X11ScreenWindowManagerChangedCallback cb + cb'' <- mk_X11ScreenWindowManagerChangedCallback cb' + connectSignalFunPtr obj "window-manager-changed" cb'' SignalConnectAfter + + +#if ENABLE_OVERLOADING +instance O.HasAttributeList X11Screen +type instance O.AttributeList X11Screen = X11ScreenAttributeList +type X11ScreenAttributeList = ('[ '("fontOptions", Gdk.Screen.ScreenFontOptionsPropertyInfo), '("resolution", Gdk.Screen.ScreenResolutionPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +data X11ScreenWindowManagerChangedSignalInfo +instance SignalInfo X11ScreenWindowManagerChangedSignalInfo where + type HaskellCallbackType X11ScreenWindowManagerChangedSignalInfo = X11ScreenWindowManagerChangedCallback + connectSignal _ obj cb connectMode = do + let cb' = wrap_X11ScreenWindowManagerChangedCallback cb + cb'' <- mk_X11ScreenWindowManagerChangedCallback cb' + connectSignalFunPtr obj "window-manager-changed" cb'' connectMode + +type instance O.SignalList X11Screen = X11ScreenSignalList +type X11ScreenSignalList = ('[ '("compositedChanged", Gdk.Screen.ScreenCompositedChangedSignalInfo), '("monitorsChanged", Gdk.Screen.ScreenMonitorsChangedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("sizeChanged", Gdk.Screen.ScreenSizeChangedSignalInfo), '("windowManagerChanged", X11ScreenWindowManagerChangedSignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method X11Screen::get_current_desktop +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "GdkX11", name = "X11Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkScreen", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt32) +-- throws : False +-- Skip return : False + +foreign import ccall "gdk_x11_screen_get_current_desktop" gdk_x11_screen_get_current_desktop :: + Ptr X11Screen -> -- screen : TInterface (Name {namespace = "GdkX11", name = "X11Screen"}) + IO Word32 + +{- | +Returns the current workspace for /@screen@/ when running under a +window manager that supports multiple workspaces, as described +in the + specification. + +/Since: 3.10/ +-} +x11ScreenGetCurrentDesktop :: + (B.CallStack.HasCallStack, MonadIO m, IsX11Screen a) => + a + {- ^ /@screen@/: a 'GI.Gdk.Objects.Screen.Screen' -} + -> m Word32 + {- ^ __Returns:__ the current workspace, or 0 if workspaces are not supported -} +x11ScreenGetCurrentDesktop screen = liftIO $ do + screen' <- unsafeManagedPtrCastPtr screen + result <- gdk_x11_screen_get_current_desktop screen' + touchManagedPtr screen + return result + +#if ENABLE_OVERLOADING +data X11ScreenGetCurrentDesktopMethodInfo +instance (signature ~ (m Word32), MonadIO m, IsX11Screen a) => O.MethodInfo X11ScreenGetCurrentDesktopMethodInfo a signature where + overloadedMethod _ = x11ScreenGetCurrentDesktop + +#endif + +-- method X11Screen::get_monitor_output +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "GdkX11", name = "X11Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkScreen", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "monitor_num", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "number of the monitor, between 0 and gdk_screen_get_n_monitors (screen)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TULong) +-- throws : False +-- Skip return : False + +foreign import ccall "gdk_x11_screen_get_monitor_output" gdk_x11_screen_get_monitor_output :: + Ptr X11Screen -> -- screen : TInterface (Name {namespace = "GdkX11", name = "X11Screen"}) + Int32 -> -- monitor_num : TBasicType TInt + IO CULong + +{- | +Gets the XID of the specified output\/monitor. +If the X server does not support version 1.2 of the RANDR +extension, 0 is returned. + +/Since: 2.14/ +-} +x11ScreenGetMonitorOutput :: + (B.CallStack.HasCallStack, MonadIO m, IsX11Screen a) => + a + {- ^ /@screen@/: a 'GI.Gdk.Objects.Screen.Screen' -} + -> Int32 + {- ^ /@monitorNum@/: number of the monitor, between 0 and gdk_screen_get_n_monitors (screen) -} + -> m CULong + {- ^ __Returns:__ the XID of the monitor -} +x11ScreenGetMonitorOutput screen monitorNum = liftIO $ do + screen' <- unsafeManagedPtrCastPtr screen + result <- gdk_x11_screen_get_monitor_output screen' monitorNum + touchManagedPtr screen + return result + +#if ENABLE_OVERLOADING +data X11ScreenGetMonitorOutputMethodInfo +instance (signature ~ (Int32 -> m CULong), MonadIO m, IsX11Screen a) => O.MethodInfo X11ScreenGetMonitorOutputMethodInfo a signature where + overloadedMethod _ = x11ScreenGetMonitorOutput + +#endif + +-- method X11Screen::get_number_of_desktops +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "GdkX11", name = "X11Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkScreen", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt32) +-- throws : False +-- Skip return : False + +foreign import ccall "gdk_x11_screen_get_number_of_desktops" gdk_x11_screen_get_number_of_desktops :: + Ptr X11Screen -> -- screen : TInterface (Name {namespace = "GdkX11", name = "X11Screen"}) + IO Word32 + +{- | +Returns the number of workspaces for /@screen@/ when running under a +window manager that supports multiple workspaces, as described +in the + specification. + +/Since: 3.10/ +-} +x11ScreenGetNumberOfDesktops :: + (B.CallStack.HasCallStack, MonadIO m, IsX11Screen a) => + a + {- ^ /@screen@/: a 'GI.Gdk.Objects.Screen.Screen' -} + -> m Word32 + {- ^ __Returns:__ the number of workspaces, or 0 if workspaces are not supported -} +x11ScreenGetNumberOfDesktops screen = liftIO $ do + screen' <- unsafeManagedPtrCastPtr screen + result <- gdk_x11_screen_get_number_of_desktops screen' + touchManagedPtr screen + return result + +#if ENABLE_OVERLOADING +data X11ScreenGetNumberOfDesktopsMethodInfo +instance (signature ~ (m Word32), MonadIO m, IsX11Screen a) => O.MethodInfo X11ScreenGetNumberOfDesktopsMethodInfo a signature where + overloadedMethod _ = x11ScreenGetNumberOfDesktops + +#endif + +-- method X11Screen::get_screen_number +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "GdkX11", name = "X11Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkScreen", 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 "gdk_x11_screen_get_screen_number" gdk_x11_screen_get_screen_number :: + Ptr X11Screen -> -- screen : TInterface (Name {namespace = "GdkX11", name = "X11Screen"}) + IO Int32 + +{- | +Returns the index of a 'GI.Gdk.Objects.Screen.Screen'. + +/Since: 2.2/ +-} +x11ScreenGetScreenNumber :: + (B.CallStack.HasCallStack, MonadIO m, IsX11Screen a) => + a + {- ^ /@screen@/: a 'GI.Gdk.Objects.Screen.Screen' -} + -> m Int32 + {- ^ __Returns:__ the position of /@screen@/ among the screens + of its display -} +x11ScreenGetScreenNumber screen = liftIO $ do + screen' <- unsafeManagedPtrCastPtr screen + result <- gdk_x11_screen_get_screen_number screen' + touchManagedPtr screen + return result + +#if ENABLE_OVERLOADING +data X11ScreenGetScreenNumberMethodInfo +instance (signature ~ (m Int32), MonadIO m, IsX11Screen a) => O.MethodInfo X11ScreenGetScreenNumberMethodInfo a signature where + overloadedMethod _ = x11ScreenGetScreenNumber + +#endif + +-- method X11Screen::get_window_manager_name +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "GdkX11", name = "X11Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkScreen", 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 "gdk_x11_screen_get_window_manager_name" gdk_x11_screen_get_window_manager_name :: + Ptr X11Screen -> -- screen : TInterface (Name {namespace = "GdkX11", name = "X11Screen"}) + IO CString + +{- | +Returns the name of the window manager for /@screen@/. + +/Since: 2.2/ +-} +x11ScreenGetWindowManagerName :: + (B.CallStack.HasCallStack, MonadIO m, IsX11Screen a) => + a + {- ^ /@screen@/: a 'GI.Gdk.Objects.Screen.Screen' -} + -> m T.Text + {- ^ __Returns:__ the name of the window manager screen /@screen@/, or +\"unknown\" if the window manager is unknown. The string is owned by GDK +and should not be freed. -} +x11ScreenGetWindowManagerName screen = liftIO $ do + screen' <- unsafeManagedPtrCastPtr screen + result <- gdk_x11_screen_get_window_manager_name screen' + checkUnexpectedReturnNULL "x11ScreenGetWindowManagerName" result + result' <- cstringToText result + touchManagedPtr screen + return result' + +#if ENABLE_OVERLOADING +data X11ScreenGetWindowManagerNameMethodInfo +instance (signature ~ (m T.Text), MonadIO m, IsX11Screen a) => O.MethodInfo X11ScreenGetWindowManagerNameMethodInfo a signature where + overloadedMethod _ = x11ScreenGetWindowManagerName + +#endif + +-- method X11Screen::get_xscreen +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "GdkX11", name = "X11Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkScreen", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "xlib", name = "Screen"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gdk_x11_screen_get_xscreen" gdk_x11_screen_get_xscreen :: + Ptr X11Screen -> -- screen : TInterface (Name {namespace = "GdkX11", name = "X11Screen"}) + IO (Ptr Xlib.Screen.Screen) + +{- | +Returns the screen of a 'GI.Gdk.Objects.Screen.Screen'. + +/Since: 2.2/ +-} +x11ScreenGetXscreen :: + (B.CallStack.HasCallStack, MonadIO m, IsX11Screen a) => + a + {- ^ /@screen@/: a 'GI.Gdk.Objects.Screen.Screen' -} + -> m Xlib.Screen.Screen + {- ^ __Returns:__ an Xlib Screen* -} +x11ScreenGetXscreen screen = liftIO $ do + screen' <- unsafeManagedPtrCastPtr screen + result <- gdk_x11_screen_get_xscreen screen' + checkUnexpectedReturnNULL "x11ScreenGetXscreen" result + result' <- (newPtr Xlib.Screen.Screen) result + touchManagedPtr screen + return result' + +#if ENABLE_OVERLOADING +data X11ScreenGetXscreenMethodInfo +instance (signature ~ (m Xlib.Screen.Screen), MonadIO m, IsX11Screen a) => O.MethodInfo X11ScreenGetXscreenMethodInfo a signature where + overloadedMethod _ = x11ScreenGetXscreen + +#endif + +-- method X11Screen::lookup_visual +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "GdkX11", name = "X11Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkScreen.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "xvisualid", argType = TBasicType TULong, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an X Visual ID.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GdkX11", name = "X11Visual"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gdk_x11_screen_lookup_visual" gdk_x11_screen_lookup_visual :: + Ptr X11Screen -> -- screen : TInterface (Name {namespace = "GdkX11", name = "X11Screen"}) + CULong -> -- xvisualid : TBasicType TULong + IO (Ptr GdkX11.X11Visual.X11Visual) + +{- | +Looks up the 'GI.Gdk.Objects.Visual.Visual' for a particular screen and X Visual ID. + +/Since: 2.2/ +-} +x11ScreenLookupVisual :: + (B.CallStack.HasCallStack, MonadIO m, IsX11Screen a) => + a + {- ^ /@screen@/: a 'GI.Gdk.Objects.Screen.Screen'. -} + -> CULong + {- ^ /@xvisualid@/: an X Visual ID. -} + -> m GdkX11.X11Visual.X11Visual + {- ^ __Returns:__ the 'GI.Gdk.Objects.Visual.Visual' (owned by the screen + object), or 'Nothing' if the visual ID wasn’t found. -} +x11ScreenLookupVisual screen xvisualid = liftIO $ do + screen' <- unsafeManagedPtrCastPtr screen + result <- gdk_x11_screen_lookup_visual screen' xvisualid + checkUnexpectedReturnNULL "x11ScreenLookupVisual" result + result' <- (newObject GdkX11.X11Visual.X11Visual) result + touchManagedPtr screen + return result' + +#if ENABLE_OVERLOADING +data X11ScreenLookupVisualMethodInfo +instance (signature ~ (CULong -> m GdkX11.X11Visual.X11Visual), MonadIO m, IsX11Screen a) => O.MethodInfo X11ScreenLookupVisualMethodInfo a signature where + overloadedMethod _ = x11ScreenLookupVisual + +#endif + +-- method X11Screen::supports_net_wm_hint +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "GdkX11", name = "X11Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the relevant #GdkScreen.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "property", argType = TInterface (Name {namespace = "Gdk", name = "Atom"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a property atom.", 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 "gdk_x11_screen_supports_net_wm_hint" gdk_x11_screen_supports_net_wm_hint :: + Ptr X11Screen -> -- screen : TInterface (Name {namespace = "GdkX11", name = "X11Screen"}) + Ptr Gdk.Atom.Atom -> -- property : TInterface (Name {namespace = "Gdk", name = "Atom"}) + IO CInt + +{- | +This function is specific to the X11 backend of GDK, and indicates +whether the window manager supports a certain hint from the + specification. + +When using this function, keep in mind that the window manager +can change over time; so you shouldn’t use this function in +a way that impacts persistent application state. A common bug +is that your application can start up before the window manager +does when the user logs in, and before the window manager starts +'GI.GdkX11.Objects.X11Screen.x11ScreenSupportsNetWmHint' will return 'False' for every property. +You can monitor the window_manager_changed signal on 'GI.Gdk.Objects.Screen.Screen' to detect +a window manager change. + +/Since: 2.2/ +-} +x11ScreenSupportsNetWmHint :: + (B.CallStack.HasCallStack, MonadIO m, IsX11Screen a) => + a + {- ^ /@screen@/: the relevant 'GI.Gdk.Objects.Screen.Screen'. -} + -> Gdk.Atom.Atom + {- ^ /@property@/: a property atom. -} + -> m Bool + {- ^ __Returns:__ 'True' if the window manager supports /@property@/ -} +x11ScreenSupportsNetWmHint screen property = liftIO $ do + screen' <- unsafeManagedPtrCastPtr screen + property' <- unsafeManagedPtrGetPtr property + result <- gdk_x11_screen_supports_net_wm_hint screen' property' + let result' = (/= 0) result + touchManagedPtr screen + touchManagedPtr property + return result' + +#if ENABLE_OVERLOADING +data X11ScreenSupportsNetWmHintMethodInfo +instance (signature ~ (Gdk.Atom.Atom -> m Bool), MonadIO m, IsX11Screen a) => O.MethodInfo X11ScreenSupportsNetWmHintMethodInfo a signature where + overloadedMethod _ = x11ScreenSupportsNetWmHint + +#endif + + diff --git a/GI/GdkX11/Objects/X11Screen.hs-boot b/GI/GdkX11/Objects/X11Screen.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GdkX11/Objects/X11Screen.hs-boot @@ -0,0 +1,56 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GdkX11.Objects.X11Screen 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 + +newtype X11Screen = X11Screen (ManagedPtr X11Screen) +instance GObject X11Screen where +class (GObject o, O.IsDescendantOf X11Screen o) => IsX11Screen o +instance (GObject o, O.IsDescendantOf X11Screen o) => IsX11Screen o +instance O.HasParentTypes X11Screen +#if ENABLE_OVERLOADING +data X11ScreenWindowManagerChangedSignalInfo +#endif +#if ENABLE_OVERLOADING +data X11ScreenGetCurrentDesktopMethodInfo +#endif +#if ENABLE_OVERLOADING +data X11ScreenGetMonitorOutputMethodInfo +#endif +#if ENABLE_OVERLOADING +data X11ScreenGetNumberOfDesktopsMethodInfo +#endif +#if ENABLE_OVERLOADING +data X11ScreenGetScreenNumberMethodInfo +#endif +#if ENABLE_OVERLOADING +data X11ScreenGetWindowManagerNameMethodInfo +#endif +#if ENABLE_OVERLOADING +data X11ScreenGetXscreenMethodInfo +#endif +#if ENABLE_OVERLOADING +data X11ScreenLookupVisualMethodInfo +#endif +#if ENABLE_OVERLOADING +data X11ScreenSupportsNetWmHintMethodInfo +#endif diff --git a/GI/GdkX11/Objects/X11Visual.hs b/GI/GdkX11/Objects/X11Visual.hs new file mode 100644 --- /dev/null +++ b/GI/GdkX11/Objects/X11Visual.hs @@ -0,0 +1,180 @@ + + +{- | +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.GdkX11.Objects.X11Visual + ( + +-- * Exported types + X11Visual(..) , + IsX11Visual , + toX11Visual , + noX11Visual , + + + -- * Methods +-- ** getXvisual #method:getXvisual# + +#if ENABLE_OVERLOADING + X11VisualGetXvisualMethodInfo , +#endif + x11VisualGetXvisual , + + + + + ) 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 qualified GI.Gdk.Objects.Visual as Gdk.Visual +import qualified GI.Xlib.Structs.Visual as Xlib.Visual + +-- | Memory-managed wrapper type. +newtype X11Visual = X11Visual (ManagedPtr X11Visual) +foreign import ccall "gdk_x11_visual_get_type" + c_gdk_x11_visual_get_type :: IO GType + +instance GObject X11Visual where + gobjectType = c_gdk_x11_visual_get_type + + +-- | Type class for types which can be safely cast to `X11Visual`, for instance with `toX11Visual`. +class (GObject o, O.IsDescendantOf X11Visual o) => IsX11Visual o +instance (GObject o, O.IsDescendantOf X11Visual o) => IsX11Visual o + +instance O.HasParentTypes X11Visual +type instance O.ParentTypes X11Visual = '[Gdk.Visual.Visual, GObject.Object.Object] + +-- | Cast to `X11Visual`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toX11Visual :: (MonadIO m, IsX11Visual o) => o -> m X11Visual +toX11Visual = liftIO . unsafeCastTo X11Visual + +-- | A convenience alias for `Nothing` :: `Maybe` `X11Visual`. +noX11Visual :: Maybe X11Visual +noX11Visual = Nothing + +#if ENABLE_OVERLOADING +type family ResolveX11VisualMethod (t :: Symbol) (o :: *) :: * where + ResolveX11VisualMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveX11VisualMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveX11VisualMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveX11VisualMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveX11VisualMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveX11VisualMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveX11VisualMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveX11VisualMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveX11VisualMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveX11VisualMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveX11VisualMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveX11VisualMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveX11VisualMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveX11VisualMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveX11VisualMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveX11VisualMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveX11VisualMethod "getBitsPerRgb" o = Gdk.Visual.VisualGetBitsPerRgbMethodInfo + ResolveX11VisualMethod "getBluePixelDetails" o = Gdk.Visual.VisualGetBluePixelDetailsMethodInfo + ResolveX11VisualMethod "getByteOrder" o = Gdk.Visual.VisualGetByteOrderMethodInfo + ResolveX11VisualMethod "getColormapSize" o = Gdk.Visual.VisualGetColormapSizeMethodInfo + ResolveX11VisualMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveX11VisualMethod "getDepth" o = Gdk.Visual.VisualGetDepthMethodInfo + ResolveX11VisualMethod "getGreenPixelDetails" o = Gdk.Visual.VisualGetGreenPixelDetailsMethodInfo + ResolveX11VisualMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveX11VisualMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveX11VisualMethod "getRedPixelDetails" o = Gdk.Visual.VisualGetRedPixelDetailsMethodInfo + ResolveX11VisualMethod "getScreen" o = Gdk.Visual.VisualGetScreenMethodInfo + ResolveX11VisualMethod "getVisualType" o = Gdk.Visual.VisualGetVisualTypeMethodInfo + ResolveX11VisualMethod "getXvisual" o = X11VisualGetXvisualMethodInfo + ResolveX11VisualMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveX11VisualMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveX11VisualMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveX11VisualMethod t X11Visual, O.MethodInfo info X11Visual p) => OL.IsLabel t (X11Visual -> 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 X11Visual +type instance O.AttributeList X11Visual = X11VisualAttributeList +type X11VisualAttributeList = ('[ ] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList X11Visual = X11VisualSignalList +type X11VisualSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method X11Visual::get_xvisual +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "visual", argType = TInterface (Name {namespace = "GdkX11", name = "X11Visual"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkVisual.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "xlib", name = "Visual"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gdk_x11_visual_get_xvisual" gdk_x11_visual_get_xvisual :: + Ptr X11Visual -> -- visual : TInterface (Name {namespace = "GdkX11", name = "X11Visual"}) + IO (Ptr Xlib.Visual.Visual) + +{- | +Returns the X visual belonging to a 'GI.Gdk.Objects.Visual.Visual'. +-} +x11VisualGetXvisual :: + (B.CallStack.HasCallStack, MonadIO m, IsX11Visual a) => + a + {- ^ /@visual@/: a 'GI.Gdk.Objects.Visual.Visual'. -} + -> m Xlib.Visual.Visual + {- ^ __Returns:__ an Xlib Visual*. -} +x11VisualGetXvisual visual = liftIO $ do + visual' <- unsafeManagedPtrCastPtr visual + result <- gdk_x11_visual_get_xvisual visual' + checkUnexpectedReturnNULL "x11VisualGetXvisual" result + result' <- (newPtr Xlib.Visual.Visual) result + touchManagedPtr visual + return result' + +#if ENABLE_OVERLOADING +data X11VisualGetXvisualMethodInfo +instance (signature ~ (m Xlib.Visual.Visual), MonadIO m, IsX11Visual a) => O.MethodInfo X11VisualGetXvisualMethodInfo a signature where + overloadedMethod _ = x11VisualGetXvisual + +#endif + + diff --git a/GI/GdkX11/Objects/X11Visual.hs-boot b/GI/GdkX11/Objects/X11Visual.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GdkX11/Objects/X11Visual.hs-boot @@ -0,0 +1,32 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GdkX11.Objects.X11Visual 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 + +newtype X11Visual = X11Visual (ManagedPtr X11Visual) +instance GObject X11Visual where +class (GObject o, O.IsDescendantOf X11Visual o) => IsX11Visual o +instance (GObject o, O.IsDescendantOf X11Visual o) => IsX11Visual o +instance O.HasParentTypes X11Visual +#if ENABLE_OVERLOADING +data X11VisualGetXvisualMethodInfo +#endif diff --git a/GI/GdkX11/Objects/X11Window.hs b/GI/GdkX11/Objects/X11Window.hs new file mode 100644 --- /dev/null +++ b/GI/GdkX11/Objects/X11Window.hs @@ -0,0 +1,898 @@ + + +{- | +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.GdkX11.Objects.X11Window + ( + +-- * Exported types + X11Window(..) , + IsX11Window , + toX11Window , + noX11Window , + + + -- * Methods +-- ** foreignNewForDisplay #method:foreignNewForDisplay# + + x11WindowForeignNewForDisplay , + + +-- ** getDesktop #method:getDesktop# + +#if ENABLE_OVERLOADING + X11WindowGetDesktopMethodInfo , +#endif + x11WindowGetDesktop , + + +-- ** getXid #method:getXid# + +#if ENABLE_OVERLOADING + X11WindowGetXidMethodInfo , +#endif + x11WindowGetXid , + + +-- ** lookupForDisplay #method:lookupForDisplay# + + x11WindowLookupForDisplay , + + +-- ** moveToCurrentDesktop #method:moveToCurrentDesktop# + +#if ENABLE_OVERLOADING + X11WindowMoveToCurrentDesktopMethodInfo , +#endif + x11WindowMoveToCurrentDesktop , + + +-- ** moveToDesktop #method:moveToDesktop# + +#if ENABLE_OVERLOADING + X11WindowMoveToDesktopMethodInfo , +#endif + x11WindowMoveToDesktop , + + +-- ** setFrameExtents #method:setFrameExtents# + +#if ENABLE_OVERLOADING + X11WindowSetFrameExtentsMethodInfo , +#endif + x11WindowSetFrameExtents , + + +-- ** setFrameSyncEnabled #method:setFrameSyncEnabled# + +#if ENABLE_OVERLOADING + X11WindowSetFrameSyncEnabledMethodInfo , +#endif + x11WindowSetFrameSyncEnabled , + + +-- ** setHideTitlebarWhenMaximized #method:setHideTitlebarWhenMaximized# + +#if ENABLE_OVERLOADING + X11WindowSetHideTitlebarWhenMaximizedMethodInfo, +#endif + x11WindowSetHideTitlebarWhenMaximized , + + +-- ** setThemeVariant #method:setThemeVariant# + +#if ENABLE_OVERLOADING + X11WindowSetThemeVariantMethodInfo , +#endif + x11WindowSetThemeVariant , + + +-- ** setUserTime #method:setUserTime# + +#if ENABLE_OVERLOADING + X11WindowSetUserTimeMethodInfo , +#endif + x11WindowSetUserTime , + + +-- ** setUtf8Property #method:setUtf8Property# + +#if ENABLE_OVERLOADING + X11WindowSetUtf8PropertyMethodInfo , +#endif + x11WindowSetUtf8Property , + + + + + ) 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 qualified GI.Gdk.Objects.Window as Gdk.Window +import {-# SOURCE #-} qualified GI.GdkX11.Objects.X11Display as GdkX11.X11Display + +-- | Memory-managed wrapper type. +newtype X11Window = X11Window (ManagedPtr X11Window) +foreign import ccall "gdk_x11_window_get_type" + c_gdk_x11_window_get_type :: IO GType + +instance GObject X11Window where + gobjectType = c_gdk_x11_window_get_type + + +-- | Type class for types which can be safely cast to `X11Window`, for instance with `toX11Window`. +class (GObject o, O.IsDescendantOf X11Window o) => IsX11Window o +instance (GObject o, O.IsDescendantOf X11Window o) => IsX11Window o + +instance O.HasParentTypes X11Window +type instance O.ParentTypes X11Window = '[Gdk.Window.Window, GObject.Object.Object] + +-- | Cast to `X11Window`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. +toX11Window :: (MonadIO m, IsX11Window o) => o -> m X11Window +toX11Window = liftIO . unsafeCastTo X11Window + +-- | A convenience alias for `Nothing` :: `Maybe` `X11Window`. +noX11Window :: Maybe X11Window +noX11Window = Nothing + +#if ENABLE_OVERLOADING +type family ResolveX11WindowMethod (t :: Symbol) (o :: *) :: * where + ResolveX11WindowMethod "beep" o = Gdk.Window.WindowBeepMethodInfo + ResolveX11WindowMethod "beginDrawFrame" o = Gdk.Window.WindowBeginDrawFrameMethodInfo + ResolveX11WindowMethod "beginMoveDrag" o = Gdk.Window.WindowBeginMoveDragMethodInfo + ResolveX11WindowMethod "beginMoveDragForDevice" o = Gdk.Window.WindowBeginMoveDragForDeviceMethodInfo + ResolveX11WindowMethod "beginPaintRect" o = Gdk.Window.WindowBeginPaintRectMethodInfo + ResolveX11WindowMethod "beginPaintRegion" o = Gdk.Window.WindowBeginPaintRegionMethodInfo + ResolveX11WindowMethod "beginResizeDrag" o = Gdk.Window.WindowBeginResizeDragMethodInfo + ResolveX11WindowMethod "beginResizeDragForDevice" o = Gdk.Window.WindowBeginResizeDragForDeviceMethodInfo + ResolveX11WindowMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo + ResolveX11WindowMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo + ResolveX11WindowMethod "configureFinished" o = Gdk.Window.WindowConfigureFinishedMethodInfo + ResolveX11WindowMethod "coordsFromParent" o = Gdk.Window.WindowCoordsFromParentMethodInfo + ResolveX11WindowMethod "coordsToParent" o = Gdk.Window.WindowCoordsToParentMethodInfo + ResolveX11WindowMethod "createGlContext" o = Gdk.Window.WindowCreateGlContextMethodInfo + ResolveX11WindowMethod "createSimilarImageSurface" o = Gdk.Window.WindowCreateSimilarImageSurfaceMethodInfo + ResolveX11WindowMethod "createSimilarSurface" o = Gdk.Window.WindowCreateSimilarSurfaceMethodInfo + ResolveX11WindowMethod "deiconify" o = Gdk.Window.WindowDeiconifyMethodInfo + ResolveX11WindowMethod "destroy" o = Gdk.Window.WindowDestroyMethodInfo + ResolveX11WindowMethod "destroyNotify" o = Gdk.Window.WindowDestroyNotifyMethodInfo + ResolveX11WindowMethod "enableSynchronizedConfigure" o = Gdk.Window.WindowEnableSynchronizedConfigureMethodInfo + ResolveX11WindowMethod "endDrawFrame" o = Gdk.Window.WindowEndDrawFrameMethodInfo + ResolveX11WindowMethod "endPaint" o = Gdk.Window.WindowEndPaintMethodInfo + ResolveX11WindowMethod "ensureNative" o = Gdk.Window.WindowEnsureNativeMethodInfo + ResolveX11WindowMethod "flush" o = Gdk.Window.WindowFlushMethodInfo + ResolveX11WindowMethod "focus" o = Gdk.Window.WindowFocusMethodInfo + ResolveX11WindowMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo + ResolveX11WindowMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo + ResolveX11WindowMethod "freezeToplevelUpdatesLibgtkOnly" o = Gdk.Window.WindowFreezeToplevelUpdatesLibgtkOnlyMethodInfo + ResolveX11WindowMethod "freezeUpdates" o = Gdk.Window.WindowFreezeUpdatesMethodInfo + ResolveX11WindowMethod "fullscreen" o = Gdk.Window.WindowFullscreenMethodInfo + ResolveX11WindowMethod "fullscreenOnMonitor" o = Gdk.Window.WindowFullscreenOnMonitorMethodInfo + ResolveX11WindowMethod "geometryChanged" o = Gdk.Window.WindowGeometryChangedMethodInfo + ResolveX11WindowMethod "getv" o = GObject.Object.ObjectGetvMethodInfo + ResolveX11WindowMethod "hasNative" o = Gdk.Window.WindowHasNativeMethodInfo + ResolveX11WindowMethod "hide" o = Gdk.Window.WindowHideMethodInfo + ResolveX11WindowMethod "iconify" o = Gdk.Window.WindowIconifyMethodInfo + ResolveX11WindowMethod "inputShapeCombineRegion" o = Gdk.Window.WindowInputShapeCombineRegionMethodInfo + ResolveX11WindowMethod "invalidateMaybeRecurse" o = Gdk.Window.WindowInvalidateMaybeRecurseMethodInfo + ResolveX11WindowMethod "invalidateRect" o = Gdk.Window.WindowInvalidateRectMethodInfo + ResolveX11WindowMethod "invalidateRegion" o = Gdk.Window.WindowInvalidateRegionMethodInfo + ResolveX11WindowMethod "isDestroyed" o = Gdk.Window.WindowIsDestroyedMethodInfo + ResolveX11WindowMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo + ResolveX11WindowMethod "isInputOnly" o = Gdk.Window.WindowIsInputOnlyMethodInfo + ResolveX11WindowMethod "isShaped" o = Gdk.Window.WindowIsShapedMethodInfo + ResolveX11WindowMethod "isViewable" o = Gdk.Window.WindowIsViewableMethodInfo + ResolveX11WindowMethod "isVisible" o = Gdk.Window.WindowIsVisibleMethodInfo + ResolveX11WindowMethod "lower" o = Gdk.Window.WindowLowerMethodInfo + ResolveX11WindowMethod "markPaintFromClip" o = Gdk.Window.WindowMarkPaintFromClipMethodInfo + ResolveX11WindowMethod "maximize" o = Gdk.Window.WindowMaximizeMethodInfo + ResolveX11WindowMethod "mergeChildInputShapes" o = Gdk.Window.WindowMergeChildInputShapesMethodInfo + ResolveX11WindowMethod "mergeChildShapes" o = Gdk.Window.WindowMergeChildShapesMethodInfo + ResolveX11WindowMethod "move" o = Gdk.Window.WindowMoveMethodInfo + ResolveX11WindowMethod "moveRegion" o = Gdk.Window.WindowMoveRegionMethodInfo + ResolveX11WindowMethod "moveResize" o = Gdk.Window.WindowMoveResizeMethodInfo + ResolveX11WindowMethod "moveToCurrentDesktop" o = X11WindowMoveToCurrentDesktopMethodInfo + ResolveX11WindowMethod "moveToDesktop" o = X11WindowMoveToDesktopMethodInfo + ResolveX11WindowMethod "moveToRect" o = Gdk.Window.WindowMoveToRectMethodInfo + ResolveX11WindowMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo + ResolveX11WindowMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo + ResolveX11WindowMethod "peekChildren" o = Gdk.Window.WindowPeekChildrenMethodInfo + ResolveX11WindowMethod "processUpdates" o = Gdk.Window.WindowProcessUpdatesMethodInfo + ResolveX11WindowMethod "raise" o = Gdk.Window.WindowRaiseMethodInfo + ResolveX11WindowMethod "ref" o = GObject.Object.ObjectRefMethodInfo + ResolveX11WindowMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo + ResolveX11WindowMethod "registerDnd" o = Gdk.Window.WindowRegisterDndMethodInfo + ResolveX11WindowMethod "reparent" o = Gdk.Window.WindowReparentMethodInfo + ResolveX11WindowMethod "resize" o = Gdk.Window.WindowResizeMethodInfo + ResolveX11WindowMethod "restack" o = Gdk.Window.WindowRestackMethodInfo + ResolveX11WindowMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo + ResolveX11WindowMethod "scroll" o = Gdk.Window.WindowScrollMethodInfo + ResolveX11WindowMethod "shapeCombineRegion" o = Gdk.Window.WindowShapeCombineRegionMethodInfo + ResolveX11WindowMethod "show" o = Gdk.Window.WindowShowMethodInfo + ResolveX11WindowMethod "showUnraised" o = Gdk.Window.WindowShowUnraisedMethodInfo + ResolveX11WindowMethod "showWindowMenu" o = Gdk.Window.WindowShowWindowMenuMethodInfo + ResolveX11WindowMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo + ResolveX11WindowMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo + ResolveX11WindowMethod "stick" o = Gdk.Window.WindowStickMethodInfo + ResolveX11WindowMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo + ResolveX11WindowMethod "thawToplevelUpdatesLibgtkOnly" o = Gdk.Window.WindowThawToplevelUpdatesLibgtkOnlyMethodInfo + ResolveX11WindowMethod "thawUpdates" o = Gdk.Window.WindowThawUpdatesMethodInfo + ResolveX11WindowMethod "unfullscreen" o = Gdk.Window.WindowUnfullscreenMethodInfo + ResolveX11WindowMethod "unmaximize" o = Gdk.Window.WindowUnmaximizeMethodInfo + ResolveX11WindowMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo + ResolveX11WindowMethod "unstick" o = Gdk.Window.WindowUnstickMethodInfo + ResolveX11WindowMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo + ResolveX11WindowMethod "withdraw" o = Gdk.Window.WindowWithdrawMethodInfo + ResolveX11WindowMethod "getAcceptFocus" o = Gdk.Window.WindowGetAcceptFocusMethodInfo + ResolveX11WindowMethod "getBackgroundPattern" o = Gdk.Window.WindowGetBackgroundPatternMethodInfo + ResolveX11WindowMethod "getChildren" o = Gdk.Window.WindowGetChildrenMethodInfo + ResolveX11WindowMethod "getChildrenWithUserData" o = Gdk.Window.WindowGetChildrenWithUserDataMethodInfo + ResolveX11WindowMethod "getClipRegion" o = Gdk.Window.WindowGetClipRegionMethodInfo + ResolveX11WindowMethod "getComposited" o = Gdk.Window.WindowGetCompositedMethodInfo + ResolveX11WindowMethod "getCursor" o = Gdk.Window.WindowGetCursorMethodInfo + ResolveX11WindowMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo + ResolveX11WindowMethod "getDecorations" o = Gdk.Window.WindowGetDecorationsMethodInfo + ResolveX11WindowMethod "getDesktop" o = X11WindowGetDesktopMethodInfo + ResolveX11WindowMethod "getDeviceCursor" o = Gdk.Window.WindowGetDeviceCursorMethodInfo + ResolveX11WindowMethod "getDeviceEvents" o = Gdk.Window.WindowGetDeviceEventsMethodInfo + ResolveX11WindowMethod "getDevicePosition" o = Gdk.Window.WindowGetDevicePositionMethodInfo + ResolveX11WindowMethod "getDevicePositionDouble" o = Gdk.Window.WindowGetDevicePositionDoubleMethodInfo + ResolveX11WindowMethod "getDisplay" o = Gdk.Window.WindowGetDisplayMethodInfo + ResolveX11WindowMethod "getDragProtocol" o = Gdk.Window.WindowGetDragProtocolMethodInfo + ResolveX11WindowMethod "getEffectiveParent" o = Gdk.Window.WindowGetEffectiveParentMethodInfo + ResolveX11WindowMethod "getEffectiveToplevel" o = Gdk.Window.WindowGetEffectiveToplevelMethodInfo + ResolveX11WindowMethod "getEventCompression" o = Gdk.Window.WindowGetEventCompressionMethodInfo + ResolveX11WindowMethod "getEvents" o = Gdk.Window.WindowGetEventsMethodInfo + ResolveX11WindowMethod "getFocusOnMap" o = Gdk.Window.WindowGetFocusOnMapMethodInfo + ResolveX11WindowMethod "getFrameClock" o = Gdk.Window.WindowGetFrameClockMethodInfo + ResolveX11WindowMethod "getFrameExtents" o = Gdk.Window.WindowGetFrameExtentsMethodInfo + ResolveX11WindowMethod "getFullscreenMode" o = Gdk.Window.WindowGetFullscreenModeMethodInfo + ResolveX11WindowMethod "getGeometry" o = Gdk.Window.WindowGetGeometryMethodInfo + ResolveX11WindowMethod "getGroup" o = Gdk.Window.WindowGetGroupMethodInfo + ResolveX11WindowMethod "getHeight" o = Gdk.Window.WindowGetHeightMethodInfo + ResolveX11WindowMethod "getModalHint" o = Gdk.Window.WindowGetModalHintMethodInfo + ResolveX11WindowMethod "getOrigin" o = Gdk.Window.WindowGetOriginMethodInfo + ResolveX11WindowMethod "getParent" o = Gdk.Window.WindowGetParentMethodInfo + ResolveX11WindowMethod "getPassThrough" o = Gdk.Window.WindowGetPassThroughMethodInfo + ResolveX11WindowMethod "getPointer" o = Gdk.Window.WindowGetPointerMethodInfo + ResolveX11WindowMethod "getPosition" o = Gdk.Window.WindowGetPositionMethodInfo + ResolveX11WindowMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo + ResolveX11WindowMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo + ResolveX11WindowMethod "getRootCoords" o = Gdk.Window.WindowGetRootCoordsMethodInfo + ResolveX11WindowMethod "getRootOrigin" o = Gdk.Window.WindowGetRootOriginMethodInfo + ResolveX11WindowMethod "getScaleFactor" o = Gdk.Window.WindowGetScaleFactorMethodInfo + ResolveX11WindowMethod "getScreen" o = Gdk.Window.WindowGetScreenMethodInfo + ResolveX11WindowMethod "getSourceEvents" o = Gdk.Window.WindowGetSourceEventsMethodInfo + ResolveX11WindowMethod "getState" o = Gdk.Window.WindowGetStateMethodInfo + ResolveX11WindowMethod "getSupportMultidevice" o = Gdk.Window.WindowGetSupportMultideviceMethodInfo + ResolveX11WindowMethod "getToplevel" o = Gdk.Window.WindowGetToplevelMethodInfo + ResolveX11WindowMethod "getTypeHint" o = Gdk.Window.WindowGetTypeHintMethodInfo + ResolveX11WindowMethod "getUpdateArea" o = Gdk.Window.WindowGetUpdateAreaMethodInfo + ResolveX11WindowMethod "getUserData" o = Gdk.Window.WindowGetUserDataMethodInfo + ResolveX11WindowMethod "getVisibleRegion" o = Gdk.Window.WindowGetVisibleRegionMethodInfo + ResolveX11WindowMethod "getVisual" o = Gdk.Window.WindowGetVisualMethodInfo + ResolveX11WindowMethod "getWidth" o = Gdk.Window.WindowGetWidthMethodInfo + ResolveX11WindowMethod "getWindowType" o = Gdk.Window.WindowGetWindowTypeMethodInfo + ResolveX11WindowMethod "getXid" o = X11WindowGetXidMethodInfo + ResolveX11WindowMethod "setAcceptFocus" o = Gdk.Window.WindowSetAcceptFocusMethodInfo + ResolveX11WindowMethod "setBackground" o = Gdk.Window.WindowSetBackgroundMethodInfo + ResolveX11WindowMethod "setBackgroundPattern" o = Gdk.Window.WindowSetBackgroundPatternMethodInfo + ResolveX11WindowMethod "setBackgroundRgba" o = Gdk.Window.WindowSetBackgroundRgbaMethodInfo + ResolveX11WindowMethod "setChildInputShapes" o = Gdk.Window.WindowSetChildInputShapesMethodInfo + ResolveX11WindowMethod "setChildShapes" o = Gdk.Window.WindowSetChildShapesMethodInfo + ResolveX11WindowMethod "setComposited" o = Gdk.Window.WindowSetCompositedMethodInfo + ResolveX11WindowMethod "setCursor" o = Gdk.Window.WindowSetCursorMethodInfo + ResolveX11WindowMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo + ResolveX11WindowMethod "setDecorations" o = Gdk.Window.WindowSetDecorationsMethodInfo + ResolveX11WindowMethod "setDeviceCursor" o = Gdk.Window.WindowSetDeviceCursorMethodInfo + ResolveX11WindowMethod "setDeviceEvents" o = Gdk.Window.WindowSetDeviceEventsMethodInfo + ResolveX11WindowMethod "setEventCompression" o = Gdk.Window.WindowSetEventCompressionMethodInfo + ResolveX11WindowMethod "setEvents" o = Gdk.Window.WindowSetEventsMethodInfo + ResolveX11WindowMethod "setFocusOnMap" o = Gdk.Window.WindowSetFocusOnMapMethodInfo + ResolveX11WindowMethod "setFrameExtents" o = X11WindowSetFrameExtentsMethodInfo + ResolveX11WindowMethod "setFrameSyncEnabled" o = X11WindowSetFrameSyncEnabledMethodInfo + ResolveX11WindowMethod "setFullscreenMode" o = Gdk.Window.WindowSetFullscreenModeMethodInfo + ResolveX11WindowMethod "setFunctions" o = Gdk.Window.WindowSetFunctionsMethodInfo + ResolveX11WindowMethod "setGeometryHints" o = Gdk.Window.WindowSetGeometryHintsMethodInfo + ResolveX11WindowMethod "setGroup" o = Gdk.Window.WindowSetGroupMethodInfo + ResolveX11WindowMethod "setHideTitlebarWhenMaximized" o = X11WindowSetHideTitlebarWhenMaximizedMethodInfo + ResolveX11WindowMethod "setIconList" o = Gdk.Window.WindowSetIconListMethodInfo + ResolveX11WindowMethod "setIconName" o = Gdk.Window.WindowSetIconNameMethodInfo + ResolveX11WindowMethod "setKeepAbove" o = Gdk.Window.WindowSetKeepAboveMethodInfo + ResolveX11WindowMethod "setKeepBelow" o = Gdk.Window.WindowSetKeepBelowMethodInfo + ResolveX11WindowMethod "setModalHint" o = Gdk.Window.WindowSetModalHintMethodInfo + ResolveX11WindowMethod "setOpacity" o = Gdk.Window.WindowSetOpacityMethodInfo + ResolveX11WindowMethod "setOpaqueRegion" o = Gdk.Window.WindowSetOpaqueRegionMethodInfo + ResolveX11WindowMethod "setOverrideRedirect" o = Gdk.Window.WindowSetOverrideRedirectMethodInfo + ResolveX11WindowMethod "setPassThrough" o = Gdk.Window.WindowSetPassThroughMethodInfo + ResolveX11WindowMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo + ResolveX11WindowMethod "setRole" o = Gdk.Window.WindowSetRoleMethodInfo + ResolveX11WindowMethod "setShadowWidth" o = Gdk.Window.WindowSetShadowWidthMethodInfo + ResolveX11WindowMethod "setSkipPagerHint" o = Gdk.Window.WindowSetSkipPagerHintMethodInfo + ResolveX11WindowMethod "setSkipTaskbarHint" o = Gdk.Window.WindowSetSkipTaskbarHintMethodInfo + ResolveX11WindowMethod "setSourceEvents" o = Gdk.Window.WindowSetSourceEventsMethodInfo + ResolveX11WindowMethod "setStartupId" o = Gdk.Window.WindowSetStartupIdMethodInfo + ResolveX11WindowMethod "setStaticGravities" o = Gdk.Window.WindowSetStaticGravitiesMethodInfo + ResolveX11WindowMethod "setSupportMultidevice" o = Gdk.Window.WindowSetSupportMultideviceMethodInfo + ResolveX11WindowMethod "setThemeVariant" o = X11WindowSetThemeVariantMethodInfo + ResolveX11WindowMethod "setTitle" o = Gdk.Window.WindowSetTitleMethodInfo + ResolveX11WindowMethod "setTransientFor" o = Gdk.Window.WindowSetTransientForMethodInfo + ResolveX11WindowMethod "setTypeHint" o = Gdk.Window.WindowSetTypeHintMethodInfo + ResolveX11WindowMethod "setUrgencyHint" o = Gdk.Window.WindowSetUrgencyHintMethodInfo + ResolveX11WindowMethod "setUserData" o = Gdk.Window.WindowSetUserDataMethodInfo + ResolveX11WindowMethod "setUserTime" o = X11WindowSetUserTimeMethodInfo + ResolveX11WindowMethod "setUtf8Property" o = X11WindowSetUtf8PropertyMethodInfo + ResolveX11WindowMethod l o = O.MethodResolutionFailed l o + +instance (info ~ ResolveX11WindowMethod t X11Window, O.MethodInfo info X11Window p) => OL.IsLabel t (X11Window -> 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 X11Window +type instance O.AttributeList X11Window = X11WindowAttributeList +type X11WindowAttributeList = ('[ '("cursor", Gdk.Window.WindowCursorPropertyInfo)] :: [(Symbol, *)]) +#endif + +#if ENABLE_OVERLOADING +#endif + +#if ENABLE_OVERLOADING +type instance O.SignalList X11Window = X11WindowSignalList +type X11WindowSignalList = ('[ '("createSurface", Gdk.Window.WindowCreateSurfaceSignalInfo), '("fromEmbedder", Gdk.Window.WindowFromEmbedderSignalInfo), '("movedToRect", Gdk.Window.WindowMovedToRectSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("pickEmbeddedChild", Gdk.Window.WindowPickEmbeddedChildSignalInfo), '("toEmbedder", Gdk.Window.WindowToEmbedderSignalInfo)] :: [(Symbol, *)]) + +#endif + +-- method X11Window::foreign_new_for_display +-- method type : Constructor +-- Args : [Arg {argCName = "display", argType = TInterface (Name {namespace = "GdkX11", name = "X11Display"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GdkDisplay where the window handle comes from.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "window", argType = TBasicType TULong, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an Xlib Window", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GdkX11", name = "X11Window"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gdk_x11_window_foreign_new_for_display" gdk_x11_window_foreign_new_for_display :: + Ptr GdkX11.X11Display.X11Display -> -- display : TInterface (Name {namespace = "GdkX11", name = "X11Display"}) + CULong -> -- window : TBasicType TULong + IO (Ptr X11Window) + +{- | +Wraps a native window in a 'GI.Gdk.Objects.Window.Window'. The function will try to +look up the window using 'GI.GdkX11.Objects.X11Window.x11WindowLookupForDisplay' first. +If it does not find it there, it will create a new window. + +This may fail if the window has been destroyed. If the window +was already known to GDK, a new reference to the existing +'GI.Gdk.Objects.Window.Window' is returned. + +/Since: 2.24/ +-} +x11WindowForeignNewForDisplay :: + (B.CallStack.HasCallStack, MonadIO m, GdkX11.X11Display.IsX11Display a) => + a + {- ^ /@display@/: the 'GI.Gdk.Objects.Display.Display' where the window handle comes from. -} + -> CULong + {- ^ /@window@/: an Xlib Window -} + -> m X11Window + {- ^ __Returns:__ a 'GI.Gdk.Objects.Window.Window' wrapper for the native + window, or 'Nothing' if the window has been destroyed. The wrapper + will be newly created, if one doesn’t exist already. -} +x11WindowForeignNewForDisplay display window = liftIO $ do + display' <- unsafeManagedPtrCastPtr display + result <- gdk_x11_window_foreign_new_for_display display' window + checkUnexpectedReturnNULL "x11WindowForeignNewForDisplay" result + result' <- (wrapObject X11Window) result + touchManagedPtr display + return result' + +#if ENABLE_OVERLOADING +#endif + +-- method X11Window::get_desktop +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "GdkX11", name = "X11Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkWindow", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TUInt32) +-- throws : False +-- Skip return : False + +foreign import ccall "gdk_x11_window_get_desktop" gdk_x11_window_get_desktop :: + Ptr X11Window -> -- window : TInterface (Name {namespace = "GdkX11", name = "X11Window"}) + IO Word32 + +{- | +Gets the number of the workspace /@window@/ is on. + +/Since: 3.10/ +-} +x11WindowGetDesktop :: + (B.CallStack.HasCallStack, MonadIO m, IsX11Window a) => + a + {- ^ /@window@/: a 'GI.Gdk.Objects.Window.Window' -} + -> m Word32 + {- ^ __Returns:__ the current workspace of /@window@/ -} +x11WindowGetDesktop window = liftIO $ do + window' <- unsafeManagedPtrCastPtr window + result <- gdk_x11_window_get_desktop window' + touchManagedPtr window + return result + +#if ENABLE_OVERLOADING +data X11WindowGetDesktopMethodInfo +instance (signature ~ (m Word32), MonadIO m, IsX11Window a) => O.MethodInfo X11WindowGetDesktopMethodInfo a signature where + overloadedMethod _ = x11WindowGetDesktop + +#endif + +-- method X11Window::get_xid +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "GdkX11", name = "X11Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a native #GdkWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TBasicType TULong) +-- throws : False +-- Skip return : False + +foreign import ccall "gdk_x11_window_get_xid" gdk_x11_window_get_xid :: + Ptr X11Window -> -- window : TInterface (Name {namespace = "GdkX11", name = "X11Window"}) + IO CULong + +{- | +Returns the X resource (window) belonging to a 'GI.Gdk.Objects.Window.Window'. +-} +x11WindowGetXid :: + (B.CallStack.HasCallStack, MonadIO m, IsX11Window a) => + a + {- ^ /@window@/: a native 'GI.Gdk.Objects.Window.Window'. -} + -> m CULong + {- ^ __Returns:__ the ID of /@drawable@/’s X resource. -} +x11WindowGetXid window = liftIO $ do + window' <- unsafeManagedPtrCastPtr window + result <- gdk_x11_window_get_xid window' + touchManagedPtr window + return result + +#if ENABLE_OVERLOADING +data X11WindowGetXidMethodInfo +instance (signature ~ (m CULong), MonadIO m, IsX11Window a) => O.MethodInfo X11WindowGetXidMethodInfo a signature where + overloadedMethod _ = x11WindowGetXid + +#endif + +-- method X11Window::move_to_current_desktop +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "GdkX11", name = "X11Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkWindow", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gdk_x11_window_move_to_current_desktop" gdk_x11_window_move_to_current_desktop :: + Ptr X11Window -> -- window : TInterface (Name {namespace = "GdkX11", name = "X11Window"}) + IO () + +{- | +Moves the window to the correct workspace when running under a +window manager that supports multiple workspaces, as described +in the specification. +Will not do anything if the window is already on all workspaces. + +/Since: 2.8/ +-} +x11WindowMoveToCurrentDesktop :: + (B.CallStack.HasCallStack, MonadIO m, IsX11Window a) => + a + {- ^ /@window@/: a 'GI.Gdk.Objects.Window.Window' -} + -> m () +x11WindowMoveToCurrentDesktop window = liftIO $ do + window' <- unsafeManagedPtrCastPtr window + gdk_x11_window_move_to_current_desktop window' + touchManagedPtr window + return () + +#if ENABLE_OVERLOADING +data X11WindowMoveToCurrentDesktopMethodInfo +instance (signature ~ (m ()), MonadIO m, IsX11Window a) => O.MethodInfo X11WindowMoveToCurrentDesktopMethodInfo a signature where + overloadedMethod _ = x11WindowMoveToCurrentDesktop + +#endif + +-- method X11Window::move_to_desktop +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "GdkX11", name = "X11Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkWindow", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "desktop", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of the workspace to move the window to", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gdk_x11_window_move_to_desktop" gdk_x11_window_move_to_desktop :: + Ptr X11Window -> -- window : TInterface (Name {namespace = "GdkX11", name = "X11Window"}) + Word32 -> -- desktop : TBasicType TUInt32 + IO () + +{- | +Moves the window to the given workspace when running unde a +window manager that supports multiple workspaces, as described +in the specification. + +/Since: 3.10/ +-} +x11WindowMoveToDesktop :: + (B.CallStack.HasCallStack, MonadIO m, IsX11Window a) => + a + {- ^ /@window@/: a 'GI.Gdk.Objects.Window.Window' -} + -> Word32 + {- ^ /@desktop@/: the number of the workspace to move the window to -} + -> m () +x11WindowMoveToDesktop window desktop = liftIO $ do + window' <- unsafeManagedPtrCastPtr window + gdk_x11_window_move_to_desktop window' desktop + touchManagedPtr window + return () + +#if ENABLE_OVERLOADING +data X11WindowMoveToDesktopMethodInfo +instance (signature ~ (Word32 -> m ()), MonadIO m, IsX11Window a) => O.MethodInfo X11WindowMoveToDesktopMethodInfo a signature where + overloadedMethod _ = x11WindowMoveToDesktop + +#endif + +-- method X11Window::set_frame_extents +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "GdkX11", name = "X11Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkWindow", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "left", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The left extent", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "right", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The right extent", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "top", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The top extent", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "bottom", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The bottom extent", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gdk_x11_window_set_frame_extents" gdk_x11_window_set_frame_extents :: + Ptr X11Window -> -- window : TInterface (Name {namespace = "GdkX11", name = "X11Window"}) + Int32 -> -- left : TBasicType TInt + Int32 -> -- right : TBasicType TInt + Int32 -> -- top : TBasicType TInt + Int32 -> -- bottom : TBasicType TInt + IO () + +{-# DEPRECATED x11WindowSetFrameExtents ["(Since version 3.12)","Use 'GI.Gdk.Objects.Window.windowSetShadowWidth' instead."] #-} +{- | +This is the same as 'GI.Gdk.Objects.Window.windowSetShadowWidth' but it only works +on GdkX11Window. + +/Since: 3.10/ +-} +x11WindowSetFrameExtents :: + (B.CallStack.HasCallStack, MonadIO m, IsX11Window a) => + a + {- ^ /@window@/: a 'GI.Gdk.Objects.Window.Window' -} + -> Int32 + {- ^ /@left@/: The left extent -} + -> Int32 + {- ^ /@right@/: The right extent -} + -> Int32 + {- ^ /@top@/: The top extent -} + -> Int32 + {- ^ /@bottom@/: The bottom extent -} + -> m () +x11WindowSetFrameExtents window left right top bottom = liftIO $ do + window' <- unsafeManagedPtrCastPtr window + gdk_x11_window_set_frame_extents window' left right top bottom + touchManagedPtr window + return () + +#if ENABLE_OVERLOADING +data X11WindowSetFrameExtentsMethodInfo +instance (signature ~ (Int32 -> Int32 -> Int32 -> Int32 -> m ()), MonadIO m, IsX11Window a) => O.MethodInfo X11WindowSetFrameExtentsMethodInfo a signature where + overloadedMethod _ = x11WindowSetFrameExtents + +#endif + +-- method X11Window::set_frame_sync_enabled +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "GdkX11", name = "X11Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a native #GdkWindow", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "frame_sync_enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether frame-synchronization should be enabled", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gdk_x11_window_set_frame_sync_enabled" gdk_x11_window_set_frame_sync_enabled :: + Ptr X11Window -> -- window : TInterface (Name {namespace = "GdkX11", name = "X11Window"}) + CInt -> -- frame_sync_enabled : TBasicType TBoolean + IO () + +{- | +This function can be used to disable frame synchronization for a window. +Normally frame synchronziation will be enabled or disabled based on whether +the system has a compositor that supports frame synchronization, but if +the window is not directly managed by the window manager, then frame +synchronziation may need to be disabled. This is the case for a window +embedded via the XEMBED protocol. + +/Since: 3.8/ +-} +x11WindowSetFrameSyncEnabled :: + (B.CallStack.HasCallStack, MonadIO m, IsX11Window a) => + a + {- ^ /@window@/: a native 'GI.Gdk.Objects.Window.Window' -} + -> Bool + {- ^ /@frameSyncEnabled@/: whether frame-synchronization should be enabled -} + -> m () +x11WindowSetFrameSyncEnabled window frameSyncEnabled = liftIO $ do + window' <- unsafeManagedPtrCastPtr window + let frameSyncEnabled' = (fromIntegral . fromEnum) frameSyncEnabled + gdk_x11_window_set_frame_sync_enabled window' frameSyncEnabled' + touchManagedPtr window + return () + +#if ENABLE_OVERLOADING +data X11WindowSetFrameSyncEnabledMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsX11Window a) => O.MethodInfo X11WindowSetFrameSyncEnabledMethodInfo a signature where + overloadedMethod _ = x11WindowSetFrameSyncEnabled + +#endif + +-- method X11Window::set_hide_titlebar_when_maximized +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "GdkX11", name = "X11Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkWindow", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "hide_titlebar_when_maximized", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether to hide the titlebar when\n maximized", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gdk_x11_window_set_hide_titlebar_when_maximized" gdk_x11_window_set_hide_titlebar_when_maximized :: + Ptr X11Window -> -- window : TInterface (Name {namespace = "GdkX11", name = "X11Window"}) + CInt -> -- hide_titlebar_when_maximized : TBasicType TBoolean + IO () + +{- | +Set a hint for the window manager, requesting that the titlebar +should be hidden when the window is maximized. + +Note that this property is automatically updated by GTK+, so this +function should only be used by applications which do not use GTK+ +to create toplevel windows. + +/Since: 3.4/ +-} +x11WindowSetHideTitlebarWhenMaximized :: + (B.CallStack.HasCallStack, MonadIO m, IsX11Window a) => + a + {- ^ /@window@/: a 'GI.Gdk.Objects.Window.Window' -} + -> Bool + {- ^ /@hideTitlebarWhenMaximized@/: whether to hide the titlebar when + maximized -} + -> m () +x11WindowSetHideTitlebarWhenMaximized window hideTitlebarWhenMaximized = liftIO $ do + window' <- unsafeManagedPtrCastPtr window + let hideTitlebarWhenMaximized' = (fromIntegral . fromEnum) hideTitlebarWhenMaximized + gdk_x11_window_set_hide_titlebar_when_maximized window' hideTitlebarWhenMaximized' + touchManagedPtr window + return () + +#if ENABLE_OVERLOADING +data X11WindowSetHideTitlebarWhenMaximizedMethodInfo +instance (signature ~ (Bool -> m ()), MonadIO m, IsX11Window a) => O.MethodInfo X11WindowSetHideTitlebarWhenMaximizedMethodInfo a signature where + overloadedMethod _ = x11WindowSetHideTitlebarWhenMaximized + +#endif + +-- method X11Window::set_theme_variant +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "GdkX11", name = "X11Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkWindow", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "variant", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the theme variant to export", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gdk_x11_window_set_theme_variant" gdk_x11_window_set_theme_variant :: + Ptr X11Window -> -- window : TInterface (Name {namespace = "GdkX11", name = "X11Window"}) + CString -> -- variant : TBasicType TUTF8 + IO () + +{- | +GTK+ applications can request a dark theme variant. In order to +make other applications - namely window managers using GTK+ for +themeing - aware of this choice, GTK+ uses this function to +export the requested theme variant as _GTK_THEME_VARIANT property +on toplevel windows. + +Note that this property is automatically updated by GTK+, so this +function should only be used by applications which do not use GTK+ +to create toplevel windows. + +/Since: 3.2/ +-} +x11WindowSetThemeVariant :: + (B.CallStack.HasCallStack, MonadIO m, IsX11Window a) => + a + {- ^ /@window@/: a 'GI.Gdk.Objects.Window.Window' -} + -> T.Text + {- ^ /@variant@/: the theme variant to export -} + -> m () +x11WindowSetThemeVariant window variant = liftIO $ do + window' <- unsafeManagedPtrCastPtr window + variant' <- textToCString variant + gdk_x11_window_set_theme_variant window' variant' + touchManagedPtr window + freeMem variant' + return () + +#if ENABLE_OVERLOADING +data X11WindowSetThemeVariantMethodInfo +instance (signature ~ (T.Text -> m ()), MonadIO m, IsX11Window a) => O.MethodInfo X11WindowSetThemeVariantMethodInfo a signature where + overloadedMethod _ = x11WindowSetThemeVariant + +#endif + +-- method X11Window::set_user_time +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "GdkX11", name = "X11Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A toplevel #GdkWindow", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "timestamp", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "An XServer timestamp to which the property should be set", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gdk_x11_window_set_user_time" gdk_x11_window_set_user_time :: + Ptr X11Window -> -- window : TInterface (Name {namespace = "GdkX11", name = "X11Window"}) + Word32 -> -- timestamp : TBasicType TUInt32 + IO () + +{- | +The application can use this call to update the _NET_WM_USER_TIME +property on a toplevel window. This property stores an Xserver +time which represents the time of the last user input event +received for this window. This property may be used by the window +manager to alter the focus, stacking, and\/or placement behavior of +windows when they are mapped depending on whether the new window +was created by a user action or is a \"pop-up\" window activated by a +timer or some other event. + +Note that this property is automatically updated by GDK, so this +function should only be used by applications which handle input +events bypassing GDK. + +/Since: 2.6/ +-} +x11WindowSetUserTime :: + (B.CallStack.HasCallStack, MonadIO m, IsX11Window a) => + a + {- ^ /@window@/: A toplevel 'GI.Gdk.Objects.Window.Window' -} + -> Word32 + {- ^ /@timestamp@/: An XServer timestamp to which the property should be set -} + -> m () +x11WindowSetUserTime window timestamp = liftIO $ do + window' <- unsafeManagedPtrCastPtr window + gdk_x11_window_set_user_time window' timestamp + touchManagedPtr window + return () + +#if ENABLE_OVERLOADING +data X11WindowSetUserTimeMethodInfo +instance (signature ~ (Word32 -> m ()), MonadIO m, IsX11Window a) => O.MethodInfo X11WindowSetUserTimeMethodInfo a signature where + overloadedMethod _ = x11WindowSetUserTime + +#endif + +-- method X11Window::set_utf8_property +-- method type : OrdinaryMethod +-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "GdkX11", name = "X11Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkWindow", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Property name, will be interned as an X atom", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "Property value, or %NULL to delete", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Nothing +-- throws : False +-- Skip return : False + +foreign import ccall "gdk_x11_window_set_utf8_property" gdk_x11_window_set_utf8_property :: + Ptr X11Window -> -- window : TInterface (Name {namespace = "GdkX11", name = "X11Window"}) + CString -> -- name : TBasicType TUTF8 + CString -> -- value : TBasicType TUTF8 + IO () + +{- | +This function modifies or removes an arbitrary X11 window +property of type UTF8_STRING. If the given /@window@/ is +not a toplevel window, it is ignored. + +/Since: 3.4/ +-} +x11WindowSetUtf8Property :: + (B.CallStack.HasCallStack, MonadIO m, IsX11Window a) => + a + {- ^ /@window@/: a 'GI.Gdk.Objects.Window.Window' -} + -> T.Text + {- ^ /@name@/: Property name, will be interned as an X atom -} + -> Maybe (T.Text) + {- ^ /@value@/: Property value, or 'Nothing' to delete -} + -> m () +x11WindowSetUtf8Property window name value = liftIO $ do + window' <- unsafeManagedPtrCastPtr window + name' <- textToCString name + maybeValue <- case value of + Nothing -> return nullPtr + Just jValue -> do + jValue' <- textToCString jValue + return jValue' + gdk_x11_window_set_utf8_property window' name' maybeValue + touchManagedPtr window + freeMem name' + freeMem maybeValue + return () + +#if ENABLE_OVERLOADING +data X11WindowSetUtf8PropertyMethodInfo +instance (signature ~ (T.Text -> Maybe (T.Text) -> m ()), MonadIO m, IsX11Window a) => O.MethodInfo X11WindowSetUtf8PropertyMethodInfo a signature where + overloadedMethod _ = x11WindowSetUtf8Property + +#endif + +-- method X11Window::lookup_for_display +-- method type : MemberFunction +-- Args : [Arg {argCName = "display", argType = TInterface (Name {namespace = "GdkX11", name = "X11Display"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GdkDisplay corresponding to the\n window handle", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "window", argType = TBasicType TULong, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an Xlib Window", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] +-- Lengths : [] +-- returnType : Just (TInterface (Name {namespace = "GdkX11", name = "X11Window"})) +-- throws : False +-- Skip return : False + +foreign import ccall "gdk_x11_window_lookup_for_display" gdk_x11_window_lookup_for_display :: + Ptr GdkX11.X11Display.X11Display -> -- display : TInterface (Name {namespace = "GdkX11", name = "X11Display"}) + CULong -> -- window : TBasicType TULong + IO (Ptr X11Window) + +{- | +Looks up the 'GI.Gdk.Objects.Window.Window' that wraps the given native window handle. + +/Since: 2.24/ +-} +x11WindowLookupForDisplay :: + (B.CallStack.HasCallStack, MonadIO m, GdkX11.X11Display.IsX11Display a) => + a + {- ^ /@display@/: the 'GI.Gdk.Objects.Display.Display' corresponding to the + window handle -} + -> CULong + {- ^ /@window@/: an Xlib Window -} + -> m X11Window + {- ^ __Returns:__ the 'GI.Gdk.Objects.Window.Window' wrapper for the native + window, or 'Nothing' if there is none. -} +x11WindowLookupForDisplay display window = liftIO $ do + display' <- unsafeManagedPtrCastPtr display + result <- gdk_x11_window_lookup_for_display display' window + checkUnexpectedReturnNULL "x11WindowLookupForDisplay" result + result' <- (newObject X11Window) result + touchManagedPtr display + return result' + +#if ENABLE_OVERLOADING +#endif + + diff --git a/GI/GdkX11/Objects/X11Window.hs-boot b/GI/GdkX11/Objects/X11Window.hs-boot new file mode 100644 --- /dev/null +++ b/GI/GdkX11/Objects/X11Window.hs-boot @@ -0,0 +1,59 @@ +#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ + && !defined(__HADDOCK_VERSION__)) +module GI.GdkX11.Objects.X11Window 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 + +newtype X11Window = X11Window (ManagedPtr X11Window) +instance GObject X11Window where +class (GObject o, O.IsDescendantOf X11Window o) => IsX11Window o +instance (GObject o, O.IsDescendantOf X11Window o) => IsX11Window o +instance O.HasParentTypes X11Window +#if ENABLE_OVERLOADING +data X11WindowGetDesktopMethodInfo +#endif +#if ENABLE_OVERLOADING +data X11WindowGetXidMethodInfo +#endif +#if ENABLE_OVERLOADING +data X11WindowMoveToCurrentDesktopMethodInfo +#endif +#if ENABLE_OVERLOADING +data X11WindowMoveToDesktopMethodInfo +#endif +#if ENABLE_OVERLOADING +data X11WindowSetFrameExtentsMethodInfo +#endif +#if ENABLE_OVERLOADING +data X11WindowSetFrameSyncEnabledMethodInfo +#endif +#if ENABLE_OVERLOADING +data X11WindowSetHideTitlebarWhenMaximizedMethodInfo +#endif +#if ENABLE_OVERLOADING +data X11WindowSetThemeVariantMethodInfo +#endif +#if ENABLE_OVERLOADING +data X11WindowSetUserTimeMethodInfo +#endif +#if ENABLE_OVERLOADING +data X11WindowSetUtf8PropertyMethodInfo +#endif diff --git a/README.md b/README.md --- a/README.md +++ b/README.md @@ -1,6 +1,6 @@ # Documentation Autogenerated documentation for this package can be found at -[https://hackage.haskell.org/package/gi-gdkx11-3.0.4/docs/GI-GdkX11.html](https://hackage.haskell.org/package/gi-gdkx11-3.0.4/docs/GI-GdkX11.html) +[https://hackage.haskell.org/package/gi-gdkx11-3.0.5/docs/GI-GdkX11.html](https://hackage.haskell.org/package/gi-gdkx11-3.0.5/docs/GI-GdkX11.html) For general documentation on using [haskell-gi](https://github.com/haskell-gi/haskell-gi) based bindings, see [the project page](https://github.com/haskell-gi/haskell-gi) or [the Wiki](https://github.com/haskell-gi/haskell-gi/wiki). diff --git a/gi-gdkx11.cabal b/gi-gdkx11.cabal --- a/gi-gdkx11.cabal +++ b/gi-gdkx11.cabal @@ -1,12 +1,12 @@ name: gi-gdkx11 -version: 3.0.4 +version: 3.0.5 synopsis: GdkX11 bindings description: Bindings for GdkX11, autogenerated by haskell-gi. homepage: https://github.com/haskell-gi/haskell-gi license: LGPL-2.1 license-file: LICENSE author: Will Thompson, Iñaki García Etxebarria and Jonas Platte -maintainer: Iñaki García Etxebarria (garetxe@gmail.com) +maintainer: Iñaki García Etxebarria (inaki@blueleaf.cc) category: Bindings build-type: Custom cabal-version: 1.24 @@ -14,20 +14,20 @@ extra-source-files: README.md ChangeLog.md stack.yaml GdkX11.overrides custom-setup - setup-depends: base >= 4.7 && < 5, + setup-depends: base >= 4.9 && < 5, Cabal >= 1.24, - haskell-gi >= 0.21.1 && < 0.22 + haskell-gi >= 0.21.0 && < 0.23 library default-language: Haskell2010 - default-extensions: NoImplicitPrelude, ScopedTypeVariables, CPP, OverloadedStrings, NegativeLiterals, ConstraintKinds, TypeFamilies, MultiParamTypeClasses, KindSignatures, FlexibleInstances, UndecidableInstances, DataKinds, FlexibleContexts + default-extensions: NoImplicitPrelude, ScopedTypeVariables, CPP, OverloadedStrings, NegativeLiterals, ConstraintKinds, TypeFamilies, MultiParamTypeClasses, KindSignatures, FlexibleInstances, UndecidableInstances, DataKinds, FlexibleContexts, UndecidableSuperClasses other-extensions: PatternSynonyms, ViewPatterns ghc-options: -fno-warn-unused-imports -fno-warn-warnings-deprecations - pkgconfig-depends: gdk-x11-3.0 >= 3.22 + pkgconfig-depends: gdk-x11-3.0 build-depends: base >= 4.7 && <5, - haskell-gi-base == 0.21.*, - haskell-gi >= 0.21.1 && < 0.22, + haskell-gi-base >= 0.21.0 && < 0.23, + haskell-gi >= 0.21.0 && < 0.23, haskell-gi-overloading < 1.1, gi-gobject == 2.0.*, gi-gdk == 3.0.*, @@ -43,3 +43,22 @@ -- see https://ghc.haskell.org/trac/ghc/ticket/14382 if impl(ghc == 8.2.*) build-depends: haskell-gi-overloading == 0.0 + + exposed-modules: GI.GdkX11, + GI.GdkX11.Functions, + GI.GdkX11.Objects, + GI.GdkX11.Objects.X11AppLaunchContext, + GI.GdkX11.Objects.X11Cursor, + GI.GdkX11.Objects.X11DeviceCore, + GI.GdkX11.Objects.X11DeviceManagerCore, + GI.GdkX11.Objects.X11DeviceManagerXI2, + GI.GdkX11.Objects.X11DeviceXI2, + GI.GdkX11.Objects.X11Display, + GI.GdkX11.Objects.X11DisplayManager, + GI.GdkX11.Objects.X11DragContext, + GI.GdkX11.Objects.X11GLContext, + GI.GdkX11.Objects.X11Keymap, + GI.GdkX11.Objects.X11Monitor, + GI.GdkX11.Objects.X11Screen, + GI.GdkX11.Objects.X11Visual, + GI.GdkX11.Objects.X11Window diff --git a/stack.yaml b/stack.yaml --- a/stack.yaml +++ b/stack.yaml @@ -1,3 +1,3 @@ packages: - '.' -resolver: lts-12.10 +resolver: lts-13.7