gi-gdk-3.0.18: GI/Gdk/Objects/Screen.hs
{- |
Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License : LGPL-2.1
Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)
'GI.Gdk.Objects.Screen.Screen' objects are the GDK representation of the screen on
which windows can be displayed and on which the pointer moves.
X originally identified screens with physical screens, but
nowadays it is more common to have a single 'GI.Gdk.Objects.Screen.Screen' which
combines several physical monitors (see 'GI.Gdk.Objects.Screen.screenGetNMonitors').
GdkScreen is used throughout GDK and GTK+ to specify which screen
the top level windows are to be displayed on. it is also used to
query the screen specification and default settings such as
the default visual ('GI.Gdk.Objects.Screen.screenGetSystemVisual'), the dimensions
of the physical monitors ('GI.Gdk.Objects.Screen.screenGetMonitorGeometry'), etc.
-}
#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
&& !defined(__HADDOCK_VERSION__))
module GI.Gdk.Objects.Screen
(
-- * Exported types
Screen(..) ,
IsScreen ,
toScreen ,
noScreen ,
-- * Methods
-- ** getActiveWindow #method:getActiveWindow#
#if ENABLE_OVERLOADING
ScreenGetActiveWindowMethodInfo ,
#endif
screenGetActiveWindow ,
-- ** getDefault #method:getDefault#
screenGetDefault ,
-- ** getDisplay #method:getDisplay#
#if ENABLE_OVERLOADING
ScreenGetDisplayMethodInfo ,
#endif
screenGetDisplay ,
-- ** getFontOptions #method:getFontOptions#
#if ENABLE_OVERLOADING
ScreenGetFontOptionsMethodInfo ,
#endif
screenGetFontOptions ,
-- ** getHeight #method:getHeight#
#if ENABLE_OVERLOADING
ScreenGetHeightMethodInfo ,
#endif
screenGetHeight ,
-- ** getHeightMm #method:getHeightMm#
#if ENABLE_OVERLOADING
ScreenGetHeightMmMethodInfo ,
#endif
screenGetHeightMm ,
-- ** getMonitorAtPoint #method:getMonitorAtPoint#
#if ENABLE_OVERLOADING
ScreenGetMonitorAtPointMethodInfo ,
#endif
screenGetMonitorAtPoint ,
-- ** getMonitorAtWindow #method:getMonitorAtWindow#
#if ENABLE_OVERLOADING
ScreenGetMonitorAtWindowMethodInfo ,
#endif
screenGetMonitorAtWindow ,
-- ** getMonitorGeometry #method:getMonitorGeometry#
#if ENABLE_OVERLOADING
ScreenGetMonitorGeometryMethodInfo ,
#endif
screenGetMonitorGeometry ,
-- ** getMonitorHeightMm #method:getMonitorHeightMm#
#if ENABLE_OVERLOADING
ScreenGetMonitorHeightMmMethodInfo ,
#endif
screenGetMonitorHeightMm ,
-- ** getMonitorPlugName #method:getMonitorPlugName#
#if ENABLE_OVERLOADING
ScreenGetMonitorPlugNameMethodInfo ,
#endif
screenGetMonitorPlugName ,
-- ** getMonitorScaleFactor #method:getMonitorScaleFactor#
#if ENABLE_OVERLOADING
ScreenGetMonitorScaleFactorMethodInfo ,
#endif
screenGetMonitorScaleFactor ,
-- ** getMonitorWidthMm #method:getMonitorWidthMm#
#if ENABLE_OVERLOADING
ScreenGetMonitorWidthMmMethodInfo ,
#endif
screenGetMonitorWidthMm ,
-- ** getMonitorWorkarea #method:getMonitorWorkarea#
#if ENABLE_OVERLOADING
ScreenGetMonitorWorkareaMethodInfo ,
#endif
screenGetMonitorWorkarea ,
-- ** getNMonitors #method:getNMonitors#
#if ENABLE_OVERLOADING
ScreenGetNMonitorsMethodInfo ,
#endif
screenGetNMonitors ,
-- ** getNumber #method:getNumber#
#if ENABLE_OVERLOADING
ScreenGetNumberMethodInfo ,
#endif
screenGetNumber ,
-- ** getPrimaryMonitor #method:getPrimaryMonitor#
#if ENABLE_OVERLOADING
ScreenGetPrimaryMonitorMethodInfo ,
#endif
screenGetPrimaryMonitor ,
-- ** getResolution #method:getResolution#
#if ENABLE_OVERLOADING
ScreenGetResolutionMethodInfo ,
#endif
screenGetResolution ,
-- ** getRgbaVisual #method:getRgbaVisual#
#if ENABLE_OVERLOADING
ScreenGetRgbaVisualMethodInfo ,
#endif
screenGetRgbaVisual ,
-- ** getRootWindow #method:getRootWindow#
#if ENABLE_OVERLOADING
ScreenGetRootWindowMethodInfo ,
#endif
screenGetRootWindow ,
-- ** getSetting #method:getSetting#
#if ENABLE_OVERLOADING
ScreenGetSettingMethodInfo ,
#endif
screenGetSetting ,
-- ** getSystemVisual #method:getSystemVisual#
#if ENABLE_OVERLOADING
ScreenGetSystemVisualMethodInfo ,
#endif
screenGetSystemVisual ,
-- ** getToplevelWindows #method:getToplevelWindows#
#if ENABLE_OVERLOADING
ScreenGetToplevelWindowsMethodInfo ,
#endif
screenGetToplevelWindows ,
-- ** getWidth #method:getWidth#
#if ENABLE_OVERLOADING
ScreenGetWidthMethodInfo ,
#endif
screenGetWidth ,
-- ** getWidthMm #method:getWidthMm#
#if ENABLE_OVERLOADING
ScreenGetWidthMmMethodInfo ,
#endif
screenGetWidthMm ,
-- ** getWindowStack #method:getWindowStack#
#if ENABLE_OVERLOADING
ScreenGetWindowStackMethodInfo ,
#endif
screenGetWindowStack ,
-- ** height #method:height#
screenHeight ,
-- ** heightMm #method:heightMm#
screenHeightMm ,
-- ** isComposited #method:isComposited#
#if ENABLE_OVERLOADING
ScreenIsCompositedMethodInfo ,
#endif
screenIsComposited ,
-- ** listVisuals #method:listVisuals#
#if ENABLE_OVERLOADING
ScreenListVisualsMethodInfo ,
#endif
screenListVisuals ,
-- ** makeDisplayName #method:makeDisplayName#
#if ENABLE_OVERLOADING
ScreenMakeDisplayNameMethodInfo ,
#endif
screenMakeDisplayName ,
-- ** setFontOptions #method:setFontOptions#
#if ENABLE_OVERLOADING
ScreenSetFontOptionsMethodInfo ,
#endif
screenSetFontOptions ,
-- ** setResolution #method:setResolution#
#if ENABLE_OVERLOADING
ScreenSetResolutionMethodInfo ,
#endif
screenSetResolution ,
-- ** width #method:width#
screenWidth ,
-- ** widthMm #method:widthMm#
screenWidthMm ,
-- * Properties
-- ** fontOptions #attr:fontOptions#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
ScreenFontOptionsPropertyInfo ,
#endif
constructScreenFontOptions ,
getScreenFontOptions ,
#if ENABLE_OVERLOADING
screenFontOptions ,
#endif
setScreenFontOptions ,
-- ** resolution #attr:resolution#
{- | /No description available in the introspection data./
-}
#if ENABLE_OVERLOADING
ScreenResolutionPropertyInfo ,
#endif
constructScreenResolution ,
getScreenResolution ,
#if ENABLE_OVERLOADING
screenResolution ,
#endif
setScreenResolution ,
-- * Signals
-- ** compositedChanged #signal:compositedChanged#
C_ScreenCompositedChangedCallback ,
ScreenCompositedChangedCallback ,
#if ENABLE_OVERLOADING
ScreenCompositedChangedSignalInfo ,
#endif
afterScreenCompositedChanged ,
genClosure_ScreenCompositedChanged ,
mk_ScreenCompositedChangedCallback ,
noScreenCompositedChangedCallback ,
onScreenCompositedChanged ,
wrap_ScreenCompositedChangedCallback ,
-- ** monitorsChanged #signal:monitorsChanged#
C_ScreenMonitorsChangedCallback ,
ScreenMonitorsChangedCallback ,
#if ENABLE_OVERLOADING
ScreenMonitorsChangedSignalInfo ,
#endif
afterScreenMonitorsChanged ,
genClosure_ScreenMonitorsChanged ,
mk_ScreenMonitorsChangedCallback ,
noScreenMonitorsChangedCallback ,
onScreenMonitorsChanged ,
wrap_ScreenMonitorsChangedCallback ,
-- ** sizeChanged #signal:sizeChanged#
C_ScreenSizeChangedCallback ,
ScreenSizeChangedCallback ,
#if ENABLE_OVERLOADING
ScreenSizeChangedSignalInfo ,
#endif
afterScreenSizeChanged ,
genClosure_ScreenSizeChanged ,
mk_ScreenSizeChangedCallback ,
noScreenSizeChangedCallback ,
onScreenSizeChanged ,
wrap_ScreenSizeChangedCallback ,
) 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.FontOptions as Cairo.FontOptions
import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Gdk.Objects.Display as Gdk.Display
import {-# SOURCE #-} qualified GI.Gdk.Objects.Visual as Gdk.Visual
import {-# SOURCE #-} qualified GI.Gdk.Objects.Window as Gdk.Window
import {-# SOURCE #-} qualified GI.Gdk.Structs.Rectangle as Gdk.Rectangle
-- | Memory-managed wrapper type.
newtype Screen = Screen (ManagedPtr Screen)
foreign import ccall "gdk_screen_get_type"
c_gdk_screen_get_type :: IO GType
instance GObject Screen where
gobjectType = c_gdk_screen_get_type
-- | Type class for types which can be safely cast to `Screen`, for instance with `toScreen`.
class (GObject o, O.IsDescendantOf Screen o) => IsScreen o
instance (GObject o, O.IsDescendantOf Screen o) => IsScreen o
instance O.HasParentTypes Screen
type instance O.ParentTypes Screen = '[GObject.Object.Object]
-- | Cast to `Screen`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toScreen :: (MonadIO m, IsScreen o) => o -> m Screen
toScreen = liftIO . unsafeCastTo Screen
-- | A convenience alias for `Nothing` :: `Maybe` `Screen`.
noScreen :: Maybe Screen
noScreen = Nothing
#if ENABLE_OVERLOADING
type family ResolveScreenMethod (t :: Symbol) (o :: *) :: * where
ResolveScreenMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveScreenMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveScreenMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveScreenMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveScreenMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveScreenMethod "isComposited" o = ScreenIsCompositedMethodInfo
ResolveScreenMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveScreenMethod "listVisuals" o = ScreenListVisualsMethodInfo
ResolveScreenMethod "makeDisplayName" o = ScreenMakeDisplayNameMethodInfo
ResolveScreenMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveScreenMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveScreenMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveScreenMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveScreenMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveScreenMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveScreenMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveScreenMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveScreenMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveScreenMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveScreenMethod "getActiveWindow" o = ScreenGetActiveWindowMethodInfo
ResolveScreenMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveScreenMethod "getDisplay" o = ScreenGetDisplayMethodInfo
ResolveScreenMethod "getFontOptions" o = ScreenGetFontOptionsMethodInfo
ResolveScreenMethod "getHeight" o = ScreenGetHeightMethodInfo
ResolveScreenMethod "getHeightMm" o = ScreenGetHeightMmMethodInfo
ResolveScreenMethod "getMonitorAtPoint" o = ScreenGetMonitorAtPointMethodInfo
ResolveScreenMethod "getMonitorAtWindow" o = ScreenGetMonitorAtWindowMethodInfo
ResolveScreenMethod "getMonitorGeometry" o = ScreenGetMonitorGeometryMethodInfo
ResolveScreenMethod "getMonitorHeightMm" o = ScreenGetMonitorHeightMmMethodInfo
ResolveScreenMethod "getMonitorPlugName" o = ScreenGetMonitorPlugNameMethodInfo
ResolveScreenMethod "getMonitorScaleFactor" o = ScreenGetMonitorScaleFactorMethodInfo
ResolveScreenMethod "getMonitorWidthMm" o = ScreenGetMonitorWidthMmMethodInfo
ResolveScreenMethod "getMonitorWorkarea" o = ScreenGetMonitorWorkareaMethodInfo
ResolveScreenMethod "getNMonitors" o = ScreenGetNMonitorsMethodInfo
ResolveScreenMethod "getNumber" o = ScreenGetNumberMethodInfo
ResolveScreenMethod "getPrimaryMonitor" o = ScreenGetPrimaryMonitorMethodInfo
ResolveScreenMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveScreenMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveScreenMethod "getResolution" o = ScreenGetResolutionMethodInfo
ResolveScreenMethod "getRgbaVisual" o = ScreenGetRgbaVisualMethodInfo
ResolveScreenMethod "getRootWindow" o = ScreenGetRootWindowMethodInfo
ResolveScreenMethod "getSetting" o = ScreenGetSettingMethodInfo
ResolveScreenMethod "getSystemVisual" o = ScreenGetSystemVisualMethodInfo
ResolveScreenMethod "getToplevelWindows" o = ScreenGetToplevelWindowsMethodInfo
ResolveScreenMethod "getWidth" o = ScreenGetWidthMethodInfo
ResolveScreenMethod "getWidthMm" o = ScreenGetWidthMmMethodInfo
ResolveScreenMethod "getWindowStack" o = ScreenGetWindowStackMethodInfo
ResolveScreenMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveScreenMethod "setFontOptions" o = ScreenSetFontOptionsMethodInfo
ResolveScreenMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveScreenMethod "setResolution" o = ScreenSetResolutionMethodInfo
ResolveScreenMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveScreenMethod t Screen, O.MethodInfo info Screen p) => OL.IsLabel t (Screen -> 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 Screen::composited-changed
{- |
The ::composited-changed signal is emitted when the composited
status of the screen changes
/Since: 2.10/
-}
type ScreenCompositedChangedCallback =
IO ()
-- | A convenience synonym for @`Nothing` :: `Maybe` `ScreenCompositedChangedCallback`@.
noScreenCompositedChangedCallback :: Maybe ScreenCompositedChangedCallback
noScreenCompositedChangedCallback = Nothing
-- | Type for the callback on the (unwrapped) C side.
type C_ScreenCompositedChangedCallback =
Ptr () -> -- object
Ptr () -> -- user_data
IO ()
-- | Generate a function pointer callable from C code, from a `C_ScreenCompositedChangedCallback`.
foreign import ccall "wrapper"
mk_ScreenCompositedChangedCallback :: C_ScreenCompositedChangedCallback -> IO (FunPtr C_ScreenCompositedChangedCallback)
-- | Wrap the callback into a `GClosure`.
genClosure_ScreenCompositedChanged :: MonadIO m => ScreenCompositedChangedCallback -> m (GClosure C_ScreenCompositedChangedCallback)
genClosure_ScreenCompositedChanged cb = liftIO $ do
let cb' = wrap_ScreenCompositedChangedCallback cb
mk_ScreenCompositedChangedCallback cb' >>= B.GClosure.newGClosure
-- | Wrap a `ScreenCompositedChangedCallback` into a `C_ScreenCompositedChangedCallback`.
wrap_ScreenCompositedChangedCallback ::
ScreenCompositedChangedCallback ->
C_ScreenCompositedChangedCallback
wrap_ScreenCompositedChangedCallback _cb _ _ = do
_cb
{- |
Connect a signal handler for the “@composited-changed@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
@
'Data.GI.Base.Signals.on' screen #compositedChanged callback
@
-}
onScreenCompositedChanged :: (IsScreen a, MonadIO m) => a -> ScreenCompositedChangedCallback -> m SignalHandlerId
onScreenCompositedChanged obj cb = liftIO $ do
let cb' = wrap_ScreenCompositedChangedCallback cb
cb'' <- mk_ScreenCompositedChangedCallback cb'
connectSignalFunPtr obj "composited-changed" cb'' SignalConnectBefore
{- |
Connect a signal handler for the “@composited-changed@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
@
'Data.GI.Base.Signals.after' screen #compositedChanged callback
@
-}
afterScreenCompositedChanged :: (IsScreen a, MonadIO m) => a -> ScreenCompositedChangedCallback -> m SignalHandlerId
afterScreenCompositedChanged obj cb = liftIO $ do
let cb' = wrap_ScreenCompositedChangedCallback cb
cb'' <- mk_ScreenCompositedChangedCallback cb'
connectSignalFunPtr obj "composited-changed" cb'' SignalConnectAfter
-- signal Screen::monitors-changed
{- |
The ::monitors-changed signal is emitted when the number, size
or position of the monitors attached to the screen change.
Only for X11 and OS X for now. A future implementation for Win32
may be a possibility.
/Since: 2.14/
-}
type ScreenMonitorsChangedCallback =
IO ()
-- | A convenience synonym for @`Nothing` :: `Maybe` `ScreenMonitorsChangedCallback`@.
noScreenMonitorsChangedCallback :: Maybe ScreenMonitorsChangedCallback
noScreenMonitorsChangedCallback = Nothing
-- | Type for the callback on the (unwrapped) C side.
type C_ScreenMonitorsChangedCallback =
Ptr () -> -- object
Ptr () -> -- user_data
IO ()
-- | Generate a function pointer callable from C code, from a `C_ScreenMonitorsChangedCallback`.
foreign import ccall "wrapper"
mk_ScreenMonitorsChangedCallback :: C_ScreenMonitorsChangedCallback -> IO (FunPtr C_ScreenMonitorsChangedCallback)
-- | Wrap the callback into a `GClosure`.
genClosure_ScreenMonitorsChanged :: MonadIO m => ScreenMonitorsChangedCallback -> m (GClosure C_ScreenMonitorsChangedCallback)
genClosure_ScreenMonitorsChanged cb = liftIO $ do
let cb' = wrap_ScreenMonitorsChangedCallback cb
mk_ScreenMonitorsChangedCallback cb' >>= B.GClosure.newGClosure
-- | Wrap a `ScreenMonitorsChangedCallback` into a `C_ScreenMonitorsChangedCallback`.
wrap_ScreenMonitorsChangedCallback ::
ScreenMonitorsChangedCallback ->
C_ScreenMonitorsChangedCallback
wrap_ScreenMonitorsChangedCallback _cb _ _ = do
_cb
{- |
Connect a signal handler for the “@monitors-changed@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
@
'Data.GI.Base.Signals.on' screen #monitorsChanged callback
@
-}
onScreenMonitorsChanged :: (IsScreen a, MonadIO m) => a -> ScreenMonitorsChangedCallback -> m SignalHandlerId
onScreenMonitorsChanged obj cb = liftIO $ do
let cb' = wrap_ScreenMonitorsChangedCallback cb
cb'' <- mk_ScreenMonitorsChangedCallback cb'
connectSignalFunPtr obj "monitors-changed" cb'' SignalConnectBefore
{- |
Connect a signal handler for the “@monitors-changed@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
@
'Data.GI.Base.Signals.after' screen #monitorsChanged callback
@
-}
afterScreenMonitorsChanged :: (IsScreen a, MonadIO m) => a -> ScreenMonitorsChangedCallback -> m SignalHandlerId
afterScreenMonitorsChanged obj cb = liftIO $ do
let cb' = wrap_ScreenMonitorsChangedCallback cb
cb'' <- mk_ScreenMonitorsChangedCallback cb'
connectSignalFunPtr obj "monitors-changed" cb'' SignalConnectAfter
-- signal Screen::size-changed
{- |
The ::size-changed signal is emitted when the pixel width or
height of a screen changes.
/Since: 2.2/
-}
type ScreenSizeChangedCallback =
IO ()
-- | A convenience synonym for @`Nothing` :: `Maybe` `ScreenSizeChangedCallback`@.
noScreenSizeChangedCallback :: Maybe ScreenSizeChangedCallback
noScreenSizeChangedCallback = Nothing
-- | Type for the callback on the (unwrapped) C side.
type C_ScreenSizeChangedCallback =
Ptr () -> -- object
Ptr () -> -- user_data
IO ()
-- | Generate a function pointer callable from C code, from a `C_ScreenSizeChangedCallback`.
foreign import ccall "wrapper"
mk_ScreenSizeChangedCallback :: C_ScreenSizeChangedCallback -> IO (FunPtr C_ScreenSizeChangedCallback)
-- | Wrap the callback into a `GClosure`.
genClosure_ScreenSizeChanged :: MonadIO m => ScreenSizeChangedCallback -> m (GClosure C_ScreenSizeChangedCallback)
genClosure_ScreenSizeChanged cb = liftIO $ do
let cb' = wrap_ScreenSizeChangedCallback cb
mk_ScreenSizeChangedCallback cb' >>= B.GClosure.newGClosure
-- | Wrap a `ScreenSizeChangedCallback` into a `C_ScreenSizeChangedCallback`.
wrap_ScreenSizeChangedCallback ::
ScreenSizeChangedCallback ->
C_ScreenSizeChangedCallback
wrap_ScreenSizeChangedCallback _cb _ _ = do
_cb
{- |
Connect a signal handler for the “@size-changed@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
@
'Data.GI.Base.Signals.on' screen #sizeChanged callback
@
-}
onScreenSizeChanged :: (IsScreen a, MonadIO m) => a -> ScreenSizeChangedCallback -> m SignalHandlerId
onScreenSizeChanged obj cb = liftIO $ do
let cb' = wrap_ScreenSizeChangedCallback cb
cb'' <- mk_ScreenSizeChangedCallback cb'
connectSignalFunPtr obj "size-changed" cb'' SignalConnectBefore
{- |
Connect a signal handler for the “@size-changed@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
@
'Data.GI.Base.Signals.after' screen #sizeChanged callback
@
-}
afterScreenSizeChanged :: (IsScreen a, MonadIO m) => a -> ScreenSizeChangedCallback -> m SignalHandlerId
afterScreenSizeChanged obj cb = liftIO $ do
let cb' = wrap_ScreenSizeChangedCallback cb
cb'' <- mk_ScreenSizeChangedCallback cb'
connectSignalFunPtr obj "size-changed" cb'' SignalConnectAfter
-- VVV Prop "font-options"
-- Type: TBasicType TPtr
-- Flags: [PropertyReadable,PropertyWritable]
-- Nullable: (Nothing,Nothing)
{- |
Get the value of the “@font-options@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
@
'Data.GI.Base.Attributes.get' screen #fontOptions
@
-}
getScreenFontOptions :: (MonadIO m, IsScreen o) => o -> m (Ptr ())
getScreenFontOptions obj = liftIO $ B.Properties.getObjectPropertyPtr obj "font-options"
{- |
Set the value of the “@font-options@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
@
'Data.GI.Base.Attributes.set' screen [ #fontOptions 'Data.GI.Base.Attributes.:=' value ]
@
-}
setScreenFontOptions :: (MonadIO m, IsScreen o) => o -> Ptr () -> m ()
setScreenFontOptions obj val = liftIO $ B.Properties.setObjectPropertyPtr obj "font-options" val
{- |
Construct a `GValueConstruct` with valid value for the “@font-options@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructScreenFontOptions :: (IsScreen o) => Ptr () -> IO (GValueConstruct o)
constructScreenFontOptions val = B.Properties.constructObjectPropertyPtr "font-options" val
#if ENABLE_OVERLOADING
data ScreenFontOptionsPropertyInfo
instance AttrInfo ScreenFontOptionsPropertyInfo where
type AttrAllowedOps ScreenFontOptionsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
type AttrSetTypeConstraint ScreenFontOptionsPropertyInfo = (~) (Ptr ())
type AttrBaseTypeConstraint ScreenFontOptionsPropertyInfo = IsScreen
type AttrGetType ScreenFontOptionsPropertyInfo = (Ptr ())
type AttrLabel ScreenFontOptionsPropertyInfo = "font-options"
type AttrOrigin ScreenFontOptionsPropertyInfo = Screen
attrGet _ = getScreenFontOptions
attrSet _ = setScreenFontOptions
attrConstruct _ = constructScreenFontOptions
attrClear _ = undefined
#endif
-- VVV Prop "resolution"
-- Type: TBasicType TDouble
-- Flags: [PropertyReadable,PropertyWritable]
-- Nullable: (Just False,Just False)
{- |
Get the value of the “@resolution@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
@
'Data.GI.Base.Attributes.get' screen #resolution
@
-}
getScreenResolution :: (MonadIO m, IsScreen o) => o -> m Double
getScreenResolution obj = liftIO $ B.Properties.getObjectPropertyDouble obj "resolution"
{- |
Set the value of the “@resolution@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
@
'Data.GI.Base.Attributes.set' screen [ #resolution 'Data.GI.Base.Attributes.:=' value ]
@
-}
setScreenResolution :: (MonadIO m, IsScreen o) => o -> Double -> m ()
setScreenResolution obj val = liftIO $ B.Properties.setObjectPropertyDouble obj "resolution" val
{- |
Construct a `GValueConstruct` with valid value for the “@resolution@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructScreenResolution :: (IsScreen o) => Double -> IO (GValueConstruct o)
constructScreenResolution val = B.Properties.constructObjectPropertyDouble "resolution" val
#if ENABLE_OVERLOADING
data ScreenResolutionPropertyInfo
instance AttrInfo ScreenResolutionPropertyInfo where
type AttrAllowedOps ScreenResolutionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
type AttrSetTypeConstraint ScreenResolutionPropertyInfo = (~) Double
type AttrBaseTypeConstraint ScreenResolutionPropertyInfo = IsScreen
type AttrGetType ScreenResolutionPropertyInfo = Double
type AttrLabel ScreenResolutionPropertyInfo = "resolution"
type AttrOrigin ScreenResolutionPropertyInfo = Screen
attrGet _ = getScreenResolution
attrSet _ = setScreenResolution
attrConstruct _ = constructScreenResolution
attrClear _ = undefined
#endif
#if ENABLE_OVERLOADING
instance O.HasAttributeList Screen
type instance O.AttributeList Screen = ScreenAttributeList
type ScreenAttributeList = ('[ '("fontOptions", ScreenFontOptionsPropertyInfo), '("resolution", ScreenResolutionPropertyInfo)] :: [(Symbol, *)])
#endif
#if ENABLE_OVERLOADING
screenFontOptions :: AttrLabelProxy "fontOptions"
screenFontOptions = AttrLabelProxy
screenResolution :: AttrLabelProxy "resolution"
screenResolution = AttrLabelProxy
#endif
#if ENABLE_OVERLOADING
data ScreenCompositedChangedSignalInfo
instance SignalInfo ScreenCompositedChangedSignalInfo where
type HaskellCallbackType ScreenCompositedChangedSignalInfo = ScreenCompositedChangedCallback
connectSignal _ obj cb connectMode = do
let cb' = wrap_ScreenCompositedChangedCallback cb
cb'' <- mk_ScreenCompositedChangedCallback cb'
connectSignalFunPtr obj "composited-changed" cb'' connectMode
data ScreenMonitorsChangedSignalInfo
instance SignalInfo ScreenMonitorsChangedSignalInfo where
type HaskellCallbackType ScreenMonitorsChangedSignalInfo = ScreenMonitorsChangedCallback
connectSignal _ obj cb connectMode = do
let cb' = wrap_ScreenMonitorsChangedCallback cb
cb'' <- mk_ScreenMonitorsChangedCallback cb'
connectSignalFunPtr obj "monitors-changed" cb'' connectMode
data ScreenSizeChangedSignalInfo
instance SignalInfo ScreenSizeChangedSignalInfo where
type HaskellCallbackType ScreenSizeChangedSignalInfo = ScreenSizeChangedCallback
connectSignal _ obj cb connectMode = do
let cb' = wrap_ScreenSizeChangedCallback cb
cb'' <- mk_ScreenSizeChangedCallback cb'
connectSignalFunPtr obj "size-changed" cb'' connectMode
type instance O.SignalList Screen = ScreenSignalList
type ScreenSignalList = ('[ '("compositedChanged", ScreenCompositedChangedSignalInfo), '("monitorsChanged", ScreenMonitorsChangedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("sizeChanged", ScreenSizeChangedSignalInfo)] :: [(Symbol, *)])
#endif
-- method Screen::get_active_window
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Gdk", name = "Screen"}), 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 = "Gdk", name = "Window"}))
-- throws : False
-- Skip return : False
foreign import ccall "gdk_screen_get_active_window" gdk_screen_get_active_window ::
Ptr Screen -> -- screen : TInterface (Name {namespace = "Gdk", name = "Screen"})
IO (Ptr Gdk.Window.Window)
{-# DEPRECATED screenGetActiveWindow ["(Since version 3.22)"] #-}
{- |
Returns the screen’s currently active window.
On X11, this is done by inspecting the _NET_ACTIVE_WINDOW property
on the root window, as described in the
<http://www.freedesktop.org/Standards/wm-spec Extended Window Manager Hints>.
If there is no currently currently active
window, or the window manager does not support the
_NET_ACTIVE_WINDOW hint, this function returns 'Nothing'.
On other platforms, this function may return 'Nothing', depending on whether
it is implementable on that platform.
The returned window should be unrefed using 'GI.GObject.Objects.Object.objectUnref' when
no longer needed.
/Since: 2.10/
-}
screenGetActiveWindow ::
(B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
a
{- ^ /@screen@/: a 'GI.Gdk.Objects.Screen.Screen' -}
-> m (Maybe Gdk.Window.Window)
{- ^ __Returns:__ the currently active window,
or 'Nothing'. -}
screenGetActiveWindow screen = liftIO $ do
screen' <- unsafeManagedPtrCastPtr screen
result <- gdk_screen_get_active_window screen'
maybeResult <- convertIfNonNull result $ \result' -> do
result'' <- (wrapObject Gdk.Window.Window) result'
return result''
touchManagedPtr screen
return maybeResult
#if ENABLE_OVERLOADING
data ScreenGetActiveWindowMethodInfo
instance (signature ~ (m (Maybe Gdk.Window.Window)), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetActiveWindowMethodInfo a signature where
overloadedMethod _ = screenGetActiveWindow
#endif
-- method Screen::get_display
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Gdk", name = "Screen"}), 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 = "Gdk", name = "Display"}))
-- throws : False
-- Skip return : False
foreign import ccall "gdk_screen_get_display" gdk_screen_get_display ::
Ptr Screen -> -- screen : TInterface (Name {namespace = "Gdk", name = "Screen"})
IO (Ptr Gdk.Display.Display)
{- |
Gets the display to which the /@screen@/ belongs.
/Since: 2.2/
-}
screenGetDisplay ::
(B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
a
{- ^ /@screen@/: a 'GI.Gdk.Objects.Screen.Screen' -}
-> m Gdk.Display.Display
{- ^ __Returns:__ the display to which /@screen@/ belongs -}
screenGetDisplay screen = liftIO $ do
screen' <- unsafeManagedPtrCastPtr screen
result <- gdk_screen_get_display screen'
checkUnexpectedReturnNULL "screenGetDisplay" result
result' <- (newObject Gdk.Display.Display) result
touchManagedPtr screen
return result'
#if ENABLE_OVERLOADING
data ScreenGetDisplayMethodInfo
instance (signature ~ (m Gdk.Display.Display), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetDisplayMethodInfo a signature where
overloadedMethod _ = screenGetDisplay
#endif
-- method Screen::get_font_options
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Gdk", name = "Screen"}), 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 = "cairo", name = "FontOptions"}))
-- throws : False
-- Skip return : False
foreign import ccall "gdk_screen_get_font_options" gdk_screen_get_font_options ::
Ptr Screen -> -- screen : TInterface (Name {namespace = "Gdk", name = "Screen"})
IO (Ptr Cairo.FontOptions.FontOptions)
{- |
Gets any options previously set with 'GI.Gdk.Objects.Screen.screenSetFontOptions'.
/Since: 2.10/
-}
screenGetFontOptions ::
(B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
a
{- ^ /@screen@/: a 'GI.Gdk.Objects.Screen.Screen' -}
-> m (Maybe Cairo.FontOptions.FontOptions)
{- ^ __Returns:__ the current font options, or 'Nothing' if no
default font options have been set. -}
screenGetFontOptions screen = liftIO $ do
screen' <- unsafeManagedPtrCastPtr screen
result <- gdk_screen_get_font_options screen'
maybeResult <- convertIfNonNull result $ \result' -> do
result'' <- (newBoxed Cairo.FontOptions.FontOptions) result'
return result''
touchManagedPtr screen
return maybeResult
#if ENABLE_OVERLOADING
data ScreenGetFontOptionsMethodInfo
instance (signature ~ (m (Maybe Cairo.FontOptions.FontOptions)), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetFontOptionsMethodInfo a signature where
overloadedMethod _ = screenGetFontOptions
#endif
-- method Screen::get_height
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Gdk", name = "Screen"}), 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_screen_get_height" gdk_screen_get_height ::
Ptr Screen -> -- screen : TInterface (Name {namespace = "Gdk", name = "Screen"})
IO Int32
{-# DEPRECATED screenGetHeight ["(Since version 3.22)","Use per-monitor information instead"] #-}
{- |
Gets the height of /@screen@/ in pixels. The returned size is in
”application pixels”, not in ”device pixels” (see
'GI.Gdk.Objects.Screen.screenGetMonitorScaleFactor').
/Since: 2.2/
-}
screenGetHeight ::
(B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
a
{- ^ /@screen@/: a 'GI.Gdk.Objects.Screen.Screen' -}
-> m Int32
{- ^ __Returns:__ the height of /@screen@/ in pixels. -}
screenGetHeight screen = liftIO $ do
screen' <- unsafeManagedPtrCastPtr screen
result <- gdk_screen_get_height screen'
touchManagedPtr screen
return result
#if ENABLE_OVERLOADING
data ScreenGetHeightMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetHeightMethodInfo a signature where
overloadedMethod _ = screenGetHeight
#endif
-- method Screen::get_height_mm
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Gdk", name = "Screen"}), 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_screen_get_height_mm" gdk_screen_get_height_mm ::
Ptr Screen -> -- screen : TInterface (Name {namespace = "Gdk", name = "Screen"})
IO Int32
{-# DEPRECATED screenGetHeightMm ["(Since version 3.22)","Use per-monitor information instead"] #-}
{- |
Returns the height of /@screen@/ in millimeters.
Note that this value is somewhat ill-defined when the screen
has multiple monitors of different resolution. It is recommended
to use the monitor dimensions instead.
/Since: 2.2/
-}
screenGetHeightMm ::
(B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
a
{- ^ /@screen@/: a 'GI.Gdk.Objects.Screen.Screen' -}
-> m Int32
{- ^ __Returns:__ the heigth of /@screen@/ in millimeters. -}
screenGetHeightMm screen = liftIO $ do
screen' <- unsafeManagedPtrCastPtr screen
result <- gdk_screen_get_height_mm screen'
touchManagedPtr screen
return result
#if ENABLE_OVERLOADING
data ScreenGetHeightMmMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetHeightMmMethodInfo a signature where
overloadedMethod _ = screenGetHeightMm
#endif
-- method Screen::get_monitor_at_point
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Gdk", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkScreen.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the x coordinate in the virtual screen.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "y", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the y coordinate in the virtual screen.", 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_screen_get_monitor_at_point" gdk_screen_get_monitor_at_point ::
Ptr Screen -> -- screen : TInterface (Name {namespace = "Gdk", name = "Screen"})
Int32 -> -- x : TBasicType TInt
Int32 -> -- y : TBasicType TInt
IO Int32
{-# DEPRECATED screenGetMonitorAtPoint ["(Since version 3.22)","Use 'GI.Gdk.Objects.Display.displayGetMonitorAtPoint' instead"] #-}
{- |
Returns the monitor number in which the point (/@x@/,/@y@/) is located.
/Since: 2.2/
-}
screenGetMonitorAtPoint ::
(B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
a
{- ^ /@screen@/: a 'GI.Gdk.Objects.Screen.Screen'. -}
-> Int32
{- ^ /@x@/: the x coordinate in the virtual screen. -}
-> Int32
{- ^ /@y@/: the y coordinate in the virtual screen. -}
-> m Int32
{- ^ __Returns:__ the monitor number in which the point (/@x@/,/@y@/) lies, or
a monitor close to (/@x@/,/@y@/) if the point is not in any monitor. -}
screenGetMonitorAtPoint screen x y = liftIO $ do
screen' <- unsafeManagedPtrCastPtr screen
result <- gdk_screen_get_monitor_at_point screen' x y
touchManagedPtr screen
return result
#if ENABLE_OVERLOADING
data ScreenGetMonitorAtPointMethodInfo
instance (signature ~ (Int32 -> Int32 -> m Int32), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetMonitorAtPointMethodInfo a signature where
overloadedMethod _ = screenGetMonitorAtPoint
#endif
-- method Screen::get_monitor_at_window
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Gdk", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkScreen.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "window", argType = TInterface (Name {namespace = "Gdk", name = "Window"}), 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 TInt)
-- throws : False
-- Skip return : False
foreign import ccall "gdk_screen_get_monitor_at_window" gdk_screen_get_monitor_at_window ::
Ptr Screen -> -- screen : TInterface (Name {namespace = "Gdk", name = "Screen"})
Ptr Gdk.Window.Window -> -- window : TInterface (Name {namespace = "Gdk", name = "Window"})
IO Int32
{-# DEPRECATED screenGetMonitorAtWindow ["(Since version 3.22)","Use 'GI.Gdk.Objects.Display.displayGetMonitorAtWindow' instead"] #-}
{- |
Returns the number of the monitor in which the largest area of the
bounding rectangle of /@window@/ resides.
/Since: 2.2/
-}
screenGetMonitorAtWindow ::
(B.CallStack.HasCallStack, MonadIO m, IsScreen a, Gdk.Window.IsWindow b) =>
a
{- ^ /@screen@/: a 'GI.Gdk.Objects.Screen.Screen'. -}
-> b
{- ^ /@window@/: a 'GI.Gdk.Objects.Window.Window' -}
-> m Int32
{- ^ __Returns:__ the monitor number in which most of /@window@/ is located,
or if /@window@/ does not intersect any monitors, a monitor,
close to /@window@/. -}
screenGetMonitorAtWindow screen window = liftIO $ do
screen' <- unsafeManagedPtrCastPtr screen
window' <- unsafeManagedPtrCastPtr window
result <- gdk_screen_get_monitor_at_window screen' window'
touchManagedPtr screen
touchManagedPtr window
return result
#if ENABLE_OVERLOADING
data ScreenGetMonitorAtWindowMethodInfo
instance (signature ~ (b -> m Int32), MonadIO m, IsScreen a, Gdk.Window.IsWindow b) => O.MethodInfo ScreenGetMonitorAtWindowMethodInfo a signature where
overloadedMethod _ = screenGetMonitorAtWindow
#endif
-- method Screen::get_monitor_geometry
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Gdk", name = "Screen"}), 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 "the monitor number", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest", argType = TInterface (Name {namespace = "Gdk", name = "Rectangle"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkRectangle to be filled with\n the monitor geometry", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False
foreign import ccall "gdk_screen_get_monitor_geometry" gdk_screen_get_monitor_geometry ::
Ptr Screen -> -- screen : TInterface (Name {namespace = "Gdk", name = "Screen"})
Int32 -> -- monitor_num : TBasicType TInt
Ptr Gdk.Rectangle.Rectangle -> -- dest : TInterface (Name {namespace = "Gdk", name = "Rectangle"})
IO ()
{-# DEPRECATED screenGetMonitorGeometry ["(Since version 3.22)","Use 'GI.Gdk.Objects.Monitor.monitorGetGeometry' instead"] #-}
{- |
Retrieves the 'GI.Gdk.Structs.Rectangle.Rectangle' representing the size and position of
the individual monitor within the entire screen area. The returned
geometry is in ”application pixels”, not in ”device pixels” (see
'GI.Gdk.Objects.Screen.screenGetMonitorScaleFactor').
Monitor numbers start at 0. To obtain the number of monitors of
/@screen@/, use 'GI.Gdk.Objects.Screen.screenGetNMonitors'.
Note that the size of the entire screen area can be retrieved via
'GI.Gdk.Objects.Screen.screenGetWidth' and 'GI.Gdk.Objects.Screen.screenGetHeight'.
/Since: 2.2/
-}
screenGetMonitorGeometry ::
(B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
a
{- ^ /@screen@/: a 'GI.Gdk.Objects.Screen.Screen' -}
-> Int32
{- ^ /@monitorNum@/: the monitor number -}
-> m (Gdk.Rectangle.Rectangle)
screenGetMonitorGeometry screen monitorNum = liftIO $ do
screen' <- unsafeManagedPtrCastPtr screen
dest <- callocBoxedBytes 16 :: IO (Ptr Gdk.Rectangle.Rectangle)
gdk_screen_get_monitor_geometry screen' monitorNum dest
dest' <- (wrapBoxed Gdk.Rectangle.Rectangle) dest
touchManagedPtr screen
return dest'
#if ENABLE_OVERLOADING
data ScreenGetMonitorGeometryMethodInfo
instance (signature ~ (Int32 -> m (Gdk.Rectangle.Rectangle)), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetMonitorGeometryMethodInfo a signature where
overloadedMethod _ = screenGetMonitorGeometry
#endif
-- method Screen::get_monitor_height_mm
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Gdk", name = "Screen"}), 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 TInt)
-- throws : False
-- Skip return : False
foreign import ccall "gdk_screen_get_monitor_height_mm" gdk_screen_get_monitor_height_mm ::
Ptr Screen -> -- screen : TInterface (Name {namespace = "Gdk", name = "Screen"})
Int32 -> -- monitor_num : TBasicType TInt
IO Int32
{-# DEPRECATED screenGetMonitorHeightMm ["(Since version 3.22)","Use 'GI.Gdk.Objects.Monitor.monitorGetHeightMm' instead"] #-}
{- |
Gets the height in millimeters of the specified monitor.
/Since: 2.14/
-}
screenGetMonitorHeightMm ::
(B.CallStack.HasCallStack, MonadIO m, IsScreen 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 Int32
{- ^ __Returns:__ the height of the monitor, or -1 if not available -}
screenGetMonitorHeightMm screen monitorNum = liftIO $ do
screen' <- unsafeManagedPtrCastPtr screen
result <- gdk_screen_get_monitor_height_mm screen' monitorNum
touchManagedPtr screen
return result
#if ENABLE_OVERLOADING
data ScreenGetMonitorHeightMmMethodInfo
instance (signature ~ (Int32 -> m Int32), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetMonitorHeightMmMethodInfo a signature where
overloadedMethod _ = screenGetMonitorHeightMm
#endif
-- method Screen::get_monitor_plug_name
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Gdk", name = "Screen"}), 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 TUTF8)
-- throws : False
-- Skip return : False
foreign import ccall "gdk_screen_get_monitor_plug_name" gdk_screen_get_monitor_plug_name ::
Ptr Screen -> -- screen : TInterface (Name {namespace = "Gdk", name = "Screen"})
Int32 -> -- monitor_num : TBasicType TInt
IO CString
{-# DEPRECATED screenGetMonitorPlugName ["(Since version 3.22)","Use 'GI.Gdk.Objects.Monitor.monitorGetModel' instead"] #-}
{- |
Returns the output name of the specified monitor.
Usually something like VGA, DVI, or TV, not the actual
product name of the display device.
/Since: 2.14/
-}
screenGetMonitorPlugName ::
(B.CallStack.HasCallStack, MonadIO m, IsScreen 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 (Maybe T.Text)
{- ^ __Returns:__ a newly-allocated string containing the name
of the monitor, or 'Nothing' if the name cannot be determined -}
screenGetMonitorPlugName screen monitorNum = liftIO $ do
screen' <- unsafeManagedPtrCastPtr screen
result <- gdk_screen_get_monitor_plug_name screen' monitorNum
maybeResult <- convertIfNonNull result $ \result' -> do
result'' <- cstringToText result'
freeMem result'
return result''
touchManagedPtr screen
return maybeResult
#if ENABLE_OVERLOADING
data ScreenGetMonitorPlugNameMethodInfo
instance (signature ~ (Int32 -> m (Maybe T.Text)), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetMonitorPlugNameMethodInfo a signature where
overloadedMethod _ = screenGetMonitorPlugName
#endif
-- method Screen::get_monitor_scale_factor
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Gdk", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "screen to get scale factor for", 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 TInt)
-- throws : False
-- Skip return : False
foreign import ccall "gdk_screen_get_monitor_scale_factor" gdk_screen_get_monitor_scale_factor ::
Ptr Screen -> -- screen : TInterface (Name {namespace = "Gdk", name = "Screen"})
Int32 -> -- monitor_num : TBasicType TInt
IO Int32
{-# DEPRECATED screenGetMonitorScaleFactor ["(Since version 3.22)","Use 'GI.Gdk.Objects.Monitor.monitorGetScaleFactor' instead"] #-}
{- |
Returns the internal scale factor that maps from monitor coordinates
to the actual device pixels. On traditional systems this is 1, but
on very high density outputs this can be a higher value (often 2).
This can be used if you want to create pixel based data for a
particular monitor, but most of the time you’re drawing to a window
where it is better to use 'GI.Gdk.Objects.Window.windowGetScaleFactor' instead.
/Since: 3.10/
-}
screenGetMonitorScaleFactor ::
(B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
a
{- ^ /@screen@/: screen to get scale factor for -}
-> Int32
{- ^ /@monitorNum@/: number of the monitor, between 0 and gdk_screen_get_n_monitors (screen) -}
-> m Int32
{- ^ __Returns:__ the scale factor -}
screenGetMonitorScaleFactor screen monitorNum = liftIO $ do
screen' <- unsafeManagedPtrCastPtr screen
result <- gdk_screen_get_monitor_scale_factor screen' monitorNum
touchManagedPtr screen
return result
#if ENABLE_OVERLOADING
data ScreenGetMonitorScaleFactorMethodInfo
instance (signature ~ (Int32 -> m Int32), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetMonitorScaleFactorMethodInfo a signature where
overloadedMethod _ = screenGetMonitorScaleFactor
#endif
-- method Screen::get_monitor_width_mm
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Gdk", name = "Screen"}), 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 TInt)
-- throws : False
-- Skip return : False
foreign import ccall "gdk_screen_get_monitor_width_mm" gdk_screen_get_monitor_width_mm ::
Ptr Screen -> -- screen : TInterface (Name {namespace = "Gdk", name = "Screen"})
Int32 -> -- monitor_num : TBasicType TInt
IO Int32
{-# DEPRECATED screenGetMonitorWidthMm ["(Since version 3.22)","Use 'GI.Gdk.Objects.Monitor.monitorGetWidthMm' instead"] #-}
{- |
Gets the width in millimeters of the specified monitor, if available.
/Since: 2.14/
-}
screenGetMonitorWidthMm ::
(B.CallStack.HasCallStack, MonadIO m, IsScreen 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 Int32
{- ^ __Returns:__ the width of the monitor, or -1 if not available -}
screenGetMonitorWidthMm screen monitorNum = liftIO $ do
screen' <- unsafeManagedPtrCastPtr screen
result <- gdk_screen_get_monitor_width_mm screen' monitorNum
touchManagedPtr screen
return result
#if ENABLE_OVERLOADING
data ScreenGetMonitorWidthMmMethodInfo
instance (signature ~ (Int32 -> m Int32), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetMonitorWidthMmMethodInfo a signature where
overloadedMethod _ = screenGetMonitorWidthMm
#endif
-- method Screen::get_monitor_workarea
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Gdk", name = "Screen"}), 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 "the monitor number", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest", argType = TInterface (Name {namespace = "Gdk", name = "Rectangle"}), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkRectangle to be filled with\n the monitor workarea", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False
foreign import ccall "gdk_screen_get_monitor_workarea" gdk_screen_get_monitor_workarea ::
Ptr Screen -> -- screen : TInterface (Name {namespace = "Gdk", name = "Screen"})
Int32 -> -- monitor_num : TBasicType TInt
Ptr Gdk.Rectangle.Rectangle -> -- dest : TInterface (Name {namespace = "Gdk", name = "Rectangle"})
IO ()
{-# DEPRECATED screenGetMonitorWorkarea ["(Since version 3.22)","Use 'GI.Gdk.Objects.Monitor.monitorGetWorkarea' instead"] #-}
{- |
Retrieves the 'GI.Gdk.Structs.Rectangle.Rectangle' representing the size and position of
the “work area” on a monitor within the entire screen area. The returned
geometry is in ”application pixels”, not in ”device pixels” (see
'GI.Gdk.Objects.Screen.screenGetMonitorScaleFactor').
The work area should be considered when positioning menus and
similar popups, to avoid placing them below panels, docks or other
desktop components.
Note that not all backends may have a concept of workarea. This
function will return the monitor geometry if a workarea is not
available, or does not apply.
Monitor numbers start at 0. To obtain the number of monitors of
/@screen@/, use 'GI.Gdk.Objects.Screen.screenGetNMonitors'.
/Since: 3.4/
-}
screenGetMonitorWorkarea ::
(B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
a
{- ^ /@screen@/: a 'GI.Gdk.Objects.Screen.Screen' -}
-> Int32
{- ^ /@monitorNum@/: the monitor number -}
-> m (Gdk.Rectangle.Rectangle)
screenGetMonitorWorkarea screen monitorNum = liftIO $ do
screen' <- unsafeManagedPtrCastPtr screen
dest <- callocBoxedBytes 16 :: IO (Ptr Gdk.Rectangle.Rectangle)
gdk_screen_get_monitor_workarea screen' monitorNum dest
dest' <- (wrapBoxed Gdk.Rectangle.Rectangle) dest
touchManagedPtr screen
return dest'
#if ENABLE_OVERLOADING
data ScreenGetMonitorWorkareaMethodInfo
instance (signature ~ (Int32 -> m (Gdk.Rectangle.Rectangle)), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetMonitorWorkareaMethodInfo a signature where
overloadedMethod _ = screenGetMonitorWorkarea
#endif
-- method Screen::get_n_monitors
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Gdk", name = "Screen"}), 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_screen_get_n_monitors" gdk_screen_get_n_monitors ::
Ptr Screen -> -- screen : TInterface (Name {namespace = "Gdk", name = "Screen"})
IO Int32
{-# DEPRECATED screenGetNMonitors ["(Since version 3.22)","Use 'GI.Gdk.Objects.Display.displayGetNMonitors' instead"] #-}
{- |
Returns the number of monitors which /@screen@/ consists of.
/Since: 2.2/
-}
screenGetNMonitors ::
(B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
a
{- ^ /@screen@/: a 'GI.Gdk.Objects.Screen.Screen' -}
-> m Int32
{- ^ __Returns:__ number of monitors which /@screen@/ consists of -}
screenGetNMonitors screen = liftIO $ do
screen' <- unsafeManagedPtrCastPtr screen
result <- gdk_screen_get_n_monitors screen'
touchManagedPtr screen
return result
#if ENABLE_OVERLOADING
data ScreenGetNMonitorsMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetNMonitorsMethodInfo a signature where
overloadedMethod _ = screenGetNMonitors
#endif
-- method Screen::get_number
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Gdk", name = "Screen"}), 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_screen_get_number" gdk_screen_get_number ::
Ptr Screen -> -- screen : TInterface (Name {namespace = "Gdk", name = "Screen"})
IO Int32
{-# DEPRECATED screenGetNumber ["(Since version 3.22)"] #-}
{- |
Gets the index of /@screen@/ among the screens in the display
to which it belongs. (See 'GI.Gdk.Objects.Screen.screenGetDisplay')
/Since: 2.2/
-}
screenGetNumber ::
(B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
a
{- ^ /@screen@/: a 'GI.Gdk.Objects.Screen.Screen' -}
-> m Int32
{- ^ __Returns:__ the index -}
screenGetNumber screen = liftIO $ do
screen' <- unsafeManagedPtrCastPtr screen
result <- gdk_screen_get_number screen'
touchManagedPtr screen
return result
#if ENABLE_OVERLOADING
data ScreenGetNumberMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetNumberMethodInfo a signature where
overloadedMethod _ = screenGetNumber
#endif
-- method Screen::get_primary_monitor
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Gdk", name = "Screen"}), 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_screen_get_primary_monitor" gdk_screen_get_primary_monitor ::
Ptr Screen -> -- screen : TInterface (Name {namespace = "Gdk", name = "Screen"})
IO Int32
{-# DEPRECATED screenGetPrimaryMonitor ["(Since version 3.22)","Use 'GI.Gdk.Objects.Display.displayGetPrimaryMonitor' instead"] #-}
{- |
Gets the primary monitor for /@screen@/. The primary monitor
is considered the monitor where the “main desktop” lives.
While normal application windows typically allow the window
manager to place the windows, specialized desktop applications
such as panels should place themselves on the primary monitor.
If no primary monitor is configured by the user, the return value
will be 0, defaulting to the first monitor.
/Since: 2.20/
-}
screenGetPrimaryMonitor ::
(B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
a
{- ^ /@screen@/: a 'GI.Gdk.Objects.Screen.Screen'. -}
-> m Int32
{- ^ __Returns:__ An integer index for the primary monitor, or 0 if none is configured. -}
screenGetPrimaryMonitor screen = liftIO $ do
screen' <- unsafeManagedPtrCastPtr screen
result <- gdk_screen_get_primary_monitor screen'
touchManagedPtr screen
return result
#if ENABLE_OVERLOADING
data ScreenGetPrimaryMonitorMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetPrimaryMonitorMethodInfo a signature where
overloadedMethod _ = screenGetPrimaryMonitor
#endif
-- method Screen::get_resolution
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Gdk", name = "Screen"}), 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 TDouble)
-- throws : False
-- Skip return : False
foreign import ccall "gdk_screen_get_resolution" gdk_screen_get_resolution ::
Ptr Screen -> -- screen : TInterface (Name {namespace = "Gdk", name = "Screen"})
IO CDouble
{- |
Gets the resolution for font handling on the screen; see
'GI.Gdk.Objects.Screen.screenSetResolution' for full details.
/Since: 2.10/
-}
screenGetResolution ::
(B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
a
{- ^ /@screen@/: a 'GI.Gdk.Objects.Screen.Screen' -}
-> m Double
{- ^ __Returns:__ the current resolution, or -1 if no resolution
has been set. -}
screenGetResolution screen = liftIO $ do
screen' <- unsafeManagedPtrCastPtr screen
result <- gdk_screen_get_resolution screen'
let result' = realToFrac result
touchManagedPtr screen
return result'
#if ENABLE_OVERLOADING
data ScreenGetResolutionMethodInfo
instance (signature ~ (m Double), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetResolutionMethodInfo a signature where
overloadedMethod _ = screenGetResolution
#endif
-- method Screen::get_rgba_visual
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Gdk", name = "Screen"}), 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 = "Gdk", name = "Visual"}))
-- throws : False
-- Skip return : False
foreign import ccall "gdk_screen_get_rgba_visual" gdk_screen_get_rgba_visual ::
Ptr Screen -> -- screen : TInterface (Name {namespace = "Gdk", name = "Screen"})
IO (Ptr Gdk.Visual.Visual)
{- |
Gets a visual to use for creating windows with an alpha channel.
The windowing system on which GTK+ is running
may not support this capability, in which case 'Nothing' will
be returned. Even if a non-'Nothing' value is returned, its
possible that the window’s alpha channel won’t be honored
when displaying the window on the screen: in particular, for
X an appropriate windowing manager and compositing manager
must be running to provide appropriate display.
This functionality is not implemented in the Windows backend.
For setting an overall opacity for a top-level window, see
'GI.Gdk.Objects.Window.windowSetOpacity'.
/Since: 2.8/
-}
screenGetRgbaVisual ::
(B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
a
{- ^ /@screen@/: a 'GI.Gdk.Objects.Screen.Screen' -}
-> m (Maybe Gdk.Visual.Visual)
{- ^ __Returns:__ a visual to use for windows
with an alpha channel or 'Nothing' if the capability is not
available. -}
screenGetRgbaVisual screen = liftIO $ do
screen' <- unsafeManagedPtrCastPtr screen
result <- gdk_screen_get_rgba_visual screen'
maybeResult <- convertIfNonNull result $ \result' -> do
result'' <- (newObject Gdk.Visual.Visual) result'
return result''
touchManagedPtr screen
return maybeResult
#if ENABLE_OVERLOADING
data ScreenGetRgbaVisualMethodInfo
instance (signature ~ (m (Maybe Gdk.Visual.Visual)), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetRgbaVisualMethodInfo a signature where
overloadedMethod _ = screenGetRgbaVisual
#endif
-- method Screen::get_root_window
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Gdk", name = "Screen"}), 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 = "Gdk", name = "Window"}))
-- throws : False
-- Skip return : False
foreign import ccall "gdk_screen_get_root_window" gdk_screen_get_root_window ::
Ptr Screen -> -- screen : TInterface (Name {namespace = "Gdk", name = "Screen"})
IO (Ptr Gdk.Window.Window)
{- |
Gets the root window of /@screen@/.
/Since: 2.2/
-}
screenGetRootWindow ::
(B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
a
{- ^ /@screen@/: a 'GI.Gdk.Objects.Screen.Screen' -}
-> m Gdk.Window.Window
{- ^ __Returns:__ the root window -}
screenGetRootWindow screen = liftIO $ do
screen' <- unsafeManagedPtrCastPtr screen
result <- gdk_screen_get_root_window screen'
checkUnexpectedReturnNULL "screenGetRootWindow" result
result' <- (newObject Gdk.Window.Window) result
touchManagedPtr screen
return result'
#if ENABLE_OVERLOADING
data ScreenGetRootWindowMethodInfo
instance (signature ~ (m Gdk.Window.Window), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetRootWindowMethodInfo a signature where
overloadedMethod _ = screenGetRootWindow
#endif
-- method Screen::get_setting
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Gdk", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GdkScreen where the setting is located", 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 "the name of the setting", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TInterface (Name {namespace = "GObject", name = "Value"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store the value of the setting", 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_screen_get_setting" gdk_screen_get_setting ::
Ptr Screen -> -- screen : TInterface (Name {namespace = "Gdk", name = "Screen"})
CString -> -- name : TBasicType TUTF8
Ptr GValue -> -- value : TInterface (Name {namespace = "GObject", name = "Value"})
IO CInt
{- |
Retrieves a desktop-wide setting such as double-click time
for the 'GI.Gdk.Objects.Screen.Screen' /@screen@/.
FIXME needs a list of valid settings here, or a link to
more information.
/Since: 2.2/
-}
screenGetSetting ::
(B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
a
{- ^ /@screen@/: the 'GI.Gdk.Objects.Screen.Screen' where the setting is located -}
-> T.Text
{- ^ /@name@/: the name of the setting -}
-> GValue
{- ^ /@value@/: location to store the value of the setting -}
-> m Bool
{- ^ __Returns:__ 'True' if the setting existed and a value was stored
in /@value@/, 'False' otherwise. -}
screenGetSetting screen name value = liftIO $ do
screen' <- unsafeManagedPtrCastPtr screen
name' <- textToCString name
value' <- unsafeManagedPtrGetPtr value
result <- gdk_screen_get_setting screen' name' value'
let result' = (/= 0) result
touchManagedPtr screen
touchManagedPtr value
freeMem name'
return result'
#if ENABLE_OVERLOADING
data ScreenGetSettingMethodInfo
instance (signature ~ (T.Text -> GValue -> m Bool), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetSettingMethodInfo a signature where
overloadedMethod _ = screenGetSetting
#endif
-- method Screen::get_system_visual
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Gdk", name = "Screen"}), 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 = "Gdk", name = "Visual"}))
-- throws : False
-- Skip return : False
foreign import ccall "gdk_screen_get_system_visual" gdk_screen_get_system_visual ::
Ptr Screen -> -- screen : TInterface (Name {namespace = "Gdk", name = "Screen"})
IO (Ptr Gdk.Visual.Visual)
{- |
Get the system’s default visual for /@screen@/.
This is the visual for the root window of the display.
The return value should not be freed.
/Since: 2.2/
-}
screenGetSystemVisual ::
(B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
a
{- ^ /@screen@/: a 'GI.Gdk.Objects.Screen.Screen'. -}
-> m Gdk.Visual.Visual
{- ^ __Returns:__ the system visual -}
screenGetSystemVisual screen = liftIO $ do
screen' <- unsafeManagedPtrCastPtr screen
result <- gdk_screen_get_system_visual screen'
checkUnexpectedReturnNULL "screenGetSystemVisual" result
result' <- (newObject Gdk.Visual.Visual) result
touchManagedPtr screen
return result'
#if ENABLE_OVERLOADING
data ScreenGetSystemVisualMethodInfo
instance (signature ~ (m Gdk.Visual.Visual), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetSystemVisualMethodInfo a signature where
overloadedMethod _ = screenGetSystemVisual
#endif
-- method Screen::get_toplevel_windows
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Gdk", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The #GdkScreen where the toplevels are located.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TGList (TInterface (Name {namespace = "Gdk", name = "Window"})))
-- throws : False
-- Skip return : False
foreign import ccall "gdk_screen_get_toplevel_windows" gdk_screen_get_toplevel_windows ::
Ptr Screen -> -- screen : TInterface (Name {namespace = "Gdk", name = "Screen"})
IO (Ptr (GList (Ptr Gdk.Window.Window)))
{- |
Obtains a list of all toplevel windows known to GDK on the screen /@screen@/.
A toplevel window is a child of the root window (see
'GI.Gdk.Functions.getDefaultRootWindow').
The returned list should be freed with @/g_list_free()/@, but
its elements need not be freed.
/Since: 2.2/
-}
screenGetToplevelWindows ::
(B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
a
{- ^ /@screen@/: The 'GI.Gdk.Objects.Screen.Screen' where the toplevels are located. -}
-> m [Gdk.Window.Window]
{- ^ __Returns:__
list of toplevel windows, free with @/g_list_free()/@ -}
screenGetToplevelWindows screen = liftIO $ do
screen' <- unsafeManagedPtrCastPtr screen
result <- gdk_screen_get_toplevel_windows screen'
result' <- unpackGList result
result'' <- mapM (newObject Gdk.Window.Window) result'
g_list_free result
touchManagedPtr screen
return result''
#if ENABLE_OVERLOADING
data ScreenGetToplevelWindowsMethodInfo
instance (signature ~ (m [Gdk.Window.Window]), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetToplevelWindowsMethodInfo a signature where
overloadedMethod _ = screenGetToplevelWindows
#endif
-- method Screen::get_width
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Gdk", name = "Screen"}), 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_screen_get_width" gdk_screen_get_width ::
Ptr Screen -> -- screen : TInterface (Name {namespace = "Gdk", name = "Screen"})
IO Int32
{-# DEPRECATED screenGetWidth ["(Since version 3.22)","Use per-monitor information instead"] #-}
{- |
Gets the width of /@screen@/ in pixels. The returned size is in
”application pixels”, not in ”device pixels” (see
'GI.Gdk.Objects.Screen.screenGetMonitorScaleFactor').
/Since: 2.2/
-}
screenGetWidth ::
(B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
a
{- ^ /@screen@/: a 'GI.Gdk.Objects.Screen.Screen' -}
-> m Int32
{- ^ __Returns:__ the width of /@screen@/ in pixels. -}
screenGetWidth screen = liftIO $ do
screen' <- unsafeManagedPtrCastPtr screen
result <- gdk_screen_get_width screen'
touchManagedPtr screen
return result
#if ENABLE_OVERLOADING
data ScreenGetWidthMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetWidthMethodInfo a signature where
overloadedMethod _ = screenGetWidth
#endif
-- method Screen::get_width_mm
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Gdk", name = "Screen"}), 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_screen_get_width_mm" gdk_screen_get_width_mm ::
Ptr Screen -> -- screen : TInterface (Name {namespace = "Gdk", name = "Screen"})
IO Int32
{-# DEPRECATED screenGetWidthMm ["(Since version 3.22)","Use per-monitor information instead"] #-}
{- |
Gets the width of /@screen@/ in millimeters.
Note that this value is somewhat ill-defined when the screen
has multiple monitors of different resolution. It is recommended
to use the monitor dimensions instead.
/Since: 2.2/
-}
screenGetWidthMm ::
(B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
a
{- ^ /@screen@/: a 'GI.Gdk.Objects.Screen.Screen' -}
-> m Int32
{- ^ __Returns:__ the width of /@screen@/ in millimeters. -}
screenGetWidthMm screen = liftIO $ do
screen' <- unsafeManagedPtrCastPtr screen
result <- gdk_screen_get_width_mm screen'
touchManagedPtr screen
return result
#if ENABLE_OVERLOADING
data ScreenGetWidthMmMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetWidthMmMethodInfo a signature where
overloadedMethod _ = screenGetWidthMm
#endif
-- method Screen::get_window_stack
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Gdk", name = "Screen"}), 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 (TGList (TInterface (Name {namespace = "Gdk", name = "Window"})))
-- throws : False
-- Skip return : False
foreign import ccall "gdk_screen_get_window_stack" gdk_screen_get_window_stack ::
Ptr Screen -> -- screen : TInterface (Name {namespace = "Gdk", name = "Screen"})
IO (Ptr (GList (Ptr Gdk.Window.Window)))
{- |
Returns a 'GI.GLib.Structs.List.List' of @/GdkWindows/@ representing the current
window stack.
On X11, this is done by inspecting the _NET_CLIENT_LIST_STACKING
property on the root window, as described in the
<http://www.freedesktop.org/Standards/wm-spec Extended Window Manager Hints>.
If the window manager does not support the
_NET_CLIENT_LIST_STACKING hint, this function returns 'Nothing'.
On other platforms, this function may return 'Nothing', depending on whether
it is implementable on that platform.
The returned list is newly allocated and owns references to the
windows it contains, so it should be freed using @/g_list_free()/@ and
its windows unrefed using 'GI.GObject.Objects.Object.objectUnref' when no longer needed.
/Since: 2.10/
-}
screenGetWindowStack ::
(B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
a
{- ^ /@screen@/: a 'GI.Gdk.Objects.Screen.Screen' -}
-> m [Gdk.Window.Window]
{- ^ __Returns:__ a
list of @/GdkWindows/@ for the current window stack, or 'Nothing'. -}
screenGetWindowStack screen = liftIO $ do
screen' <- unsafeManagedPtrCastPtr screen
result <- gdk_screen_get_window_stack screen'
result' <- unpackGList result
result'' <- mapM (wrapObject Gdk.Window.Window) result'
g_list_free result
touchManagedPtr screen
return result''
#if ENABLE_OVERLOADING
data ScreenGetWindowStackMethodInfo
instance (signature ~ (m [Gdk.Window.Window]), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetWindowStackMethodInfo a signature where
overloadedMethod _ = screenGetWindowStack
#endif
-- method Screen::is_composited
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Gdk", name = "Screen"}), 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 TBoolean)
-- throws : False
-- Skip return : False
foreign import ccall "gdk_screen_is_composited" gdk_screen_is_composited ::
Ptr Screen -> -- screen : TInterface (Name {namespace = "Gdk", name = "Screen"})
IO CInt
{- |
Returns whether windows with an RGBA visual can reasonably
be expected to have their alpha channel drawn correctly on
the screen.
On X11 this function returns whether a compositing manager is
compositing /@screen@/.
/Since: 2.10/
-}
screenIsComposited ::
(B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
a
{- ^ /@screen@/: a 'GI.Gdk.Objects.Screen.Screen' -}
-> m Bool
{- ^ __Returns:__ Whether windows with RGBA visuals can reasonably be
expected to have their alpha channels drawn correctly on the screen. -}
screenIsComposited screen = liftIO $ do
screen' <- unsafeManagedPtrCastPtr screen
result <- gdk_screen_is_composited screen'
let result' = (/= 0) result
touchManagedPtr screen
return result'
#if ENABLE_OVERLOADING
data ScreenIsCompositedMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsScreen a) => O.MethodInfo ScreenIsCompositedMethodInfo a signature where
overloadedMethod _ = screenIsComposited
#endif
-- method Screen::list_visuals
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Gdk", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the relevant #GdkScreen.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TGList (TInterface (Name {namespace = "Gdk", name = "Visual"})))
-- throws : False
-- Skip return : False
foreign import ccall "gdk_screen_list_visuals" gdk_screen_list_visuals ::
Ptr Screen -> -- screen : TInterface (Name {namespace = "Gdk", name = "Screen"})
IO (Ptr (GList (Ptr Gdk.Visual.Visual)))
{- |
Lists the available visuals for the specified /@screen@/.
A visual describes a hardware image data format.
For example, a visual might support 24-bit color, or 8-bit color,
and might expect pixels to be in a certain format.
Call @/g_list_free()/@ on the return value when you’re finished with it.
/Since: 2.2/
-}
screenListVisuals ::
(B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
a
{- ^ /@screen@/: the relevant 'GI.Gdk.Objects.Screen.Screen'. -}
-> m [Gdk.Visual.Visual]
{- ^ __Returns:__
a list of visuals; the list must be freed, but not its contents -}
screenListVisuals screen = liftIO $ do
screen' <- unsafeManagedPtrCastPtr screen
result <- gdk_screen_list_visuals screen'
result' <- unpackGList result
result'' <- mapM (newObject Gdk.Visual.Visual) result'
g_list_free result
touchManagedPtr screen
return result''
#if ENABLE_OVERLOADING
data ScreenListVisualsMethodInfo
instance (signature ~ (m [Gdk.Visual.Visual]), MonadIO m, IsScreen a) => O.MethodInfo ScreenListVisualsMethodInfo a signature where
overloadedMethod _ = screenListVisuals
#endif
-- method Screen::make_display_name
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Gdk", name = "Screen"}), 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_screen_make_display_name" gdk_screen_make_display_name ::
Ptr Screen -> -- screen : TInterface (Name {namespace = "Gdk", name = "Screen"})
IO CString
{-# DEPRECATED screenMakeDisplayName ["(Since version 3.22)"] #-}
{- |
Determines the name to pass to 'GI.Gdk.Objects.Display.displayOpen' to get
a 'GI.Gdk.Objects.Display.Display' with this screen as the default screen.
/Since: 2.2/
-}
screenMakeDisplayName ::
(B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
a
{- ^ /@screen@/: a 'GI.Gdk.Objects.Screen.Screen' -}
-> m T.Text
{- ^ __Returns:__ a newly allocated string, free with 'GI.GLib.Functions.free' -}
screenMakeDisplayName screen = liftIO $ do
screen' <- unsafeManagedPtrCastPtr screen
result <- gdk_screen_make_display_name screen'
checkUnexpectedReturnNULL "screenMakeDisplayName" result
result' <- cstringToText result
freeMem result
touchManagedPtr screen
return result'
#if ENABLE_OVERLOADING
data ScreenMakeDisplayNameMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsScreen a) => O.MethodInfo ScreenMakeDisplayNameMethodInfo a signature where
overloadedMethod _ = screenMakeDisplayName
#endif
-- method Screen::set_font_options
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Gdk", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkScreen", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "options", argType = TInterface (Name {namespace = "cairo", name = "FontOptions"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #cairo_font_options_t, or %NULL to unset any\n previously set default font options.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False
foreign import ccall "gdk_screen_set_font_options" gdk_screen_set_font_options ::
Ptr Screen -> -- screen : TInterface (Name {namespace = "Gdk", name = "Screen"})
Ptr Cairo.FontOptions.FontOptions -> -- options : TInterface (Name {namespace = "cairo", name = "FontOptions"})
IO ()
{- |
Sets the default font options for the screen. These
options will be set on any 'GI.Pango.Objects.Context.Context'’s newly created
with 'GI.Gdk.Functions.pangoContextGetForScreen'. Changing the
default set of font options does not affect contexts that
have already been created.
/Since: 2.10/
-}
screenSetFontOptions ::
(B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
a
{- ^ /@screen@/: a 'GI.Gdk.Objects.Screen.Screen' -}
-> Maybe (Cairo.FontOptions.FontOptions)
{- ^ /@options@/: a 'GI.Cairo.Structs.FontOptions.FontOptions', or 'Nothing' to unset any
previously set default font options. -}
-> m ()
screenSetFontOptions screen options = liftIO $ do
screen' <- unsafeManagedPtrCastPtr screen
maybeOptions <- case options of
Nothing -> return nullPtr
Just jOptions -> do
jOptions' <- unsafeManagedPtrGetPtr jOptions
return jOptions'
gdk_screen_set_font_options screen' maybeOptions
touchManagedPtr screen
whenJust options touchManagedPtr
return ()
#if ENABLE_OVERLOADING
data ScreenSetFontOptionsMethodInfo
instance (signature ~ (Maybe (Cairo.FontOptions.FontOptions) -> m ()), MonadIO m, IsScreen a) => O.MethodInfo ScreenSetFontOptionsMethodInfo a signature where
overloadedMethod _ = screenSetFontOptions
#endif
-- method Screen::set_resolution
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Gdk", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GdkScreen", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dpi", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the resolution in \8220dots per inch\8221. (Physical inches aren\8217t actually\n involved; the terminology is conventional.)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False
foreign import ccall "gdk_screen_set_resolution" gdk_screen_set_resolution ::
Ptr Screen -> -- screen : TInterface (Name {namespace = "Gdk", name = "Screen"})
CDouble -> -- dpi : TBasicType TDouble
IO ()
{- |
Sets the resolution for font handling on the screen. This is a
scale factor between points specified in a 'GI.Pango.Structs.FontDescription.FontDescription'
and cairo units. The default value is 96, meaning that a 10 point
font will be 13 units high. (10 * 96. \/ 72. = 13.3).
/Since: 2.10/
-}
screenSetResolution ::
(B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
a
{- ^ /@screen@/: a 'GI.Gdk.Objects.Screen.Screen' -}
-> Double
{- ^ /@dpi@/: the resolution in “dots per inch”. (Physical inches aren’t actually
involved; the terminology is conventional.) -}
-> m ()
screenSetResolution screen dpi = liftIO $ do
screen' <- unsafeManagedPtrCastPtr screen
let dpi' = realToFrac dpi
gdk_screen_set_resolution screen' dpi'
touchManagedPtr screen
return ()
#if ENABLE_OVERLOADING
data ScreenSetResolutionMethodInfo
instance (signature ~ (Double -> m ()), MonadIO m, IsScreen a) => O.MethodInfo ScreenSetResolutionMethodInfo a signature where
overloadedMethod _ = screenSetResolution
#endif
-- method Screen::get_default
-- method type : MemberFunction
-- Args : []
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gdk", name = "Screen"}))
-- throws : False
-- Skip return : False
foreign import ccall "gdk_screen_get_default" gdk_screen_get_default ::
IO (Ptr Screen)
{- |
Gets the default screen for the default display. (See
gdk_display_get_default ()).
/Since: 2.2/
-}
screenGetDefault ::
(B.CallStack.HasCallStack, MonadIO m) =>
m (Maybe Screen)
{- ^ __Returns:__ a 'GI.Gdk.Objects.Screen.Screen', or 'Nothing' if
there is no default display. -}
screenGetDefault = liftIO $ do
result <- gdk_screen_get_default
maybeResult <- convertIfNonNull result $ \result' -> do
result'' <- (newObject Screen) result'
return result''
return maybeResult
#if ENABLE_OVERLOADING
#endif
-- method Screen::height
-- method type : MemberFunction
-- Args : []
-- Lengths : []
-- returnType : Just (TBasicType TInt)
-- throws : False
-- Skip return : False
foreign import ccall "gdk_screen_height" gdk_screen_height ::
IO Int32
{-# DEPRECATED screenHeight ["(Since version 3.22)","Use per-monitor information"] #-}
{- |
Gets the height of the default screen in pixels. The returned
size is in ”application pixels”, not in ”device pixels” (see
'GI.Gdk.Objects.Screen.screenGetMonitorScaleFactor').
-}
screenHeight ::
(B.CallStack.HasCallStack, MonadIO m) =>
m Int32
{- ^ __Returns:__ the height of the default screen in pixels. -}
screenHeight = liftIO $ do
result <- gdk_screen_height
return result
#if ENABLE_OVERLOADING
#endif
-- method Screen::height_mm
-- method type : MemberFunction
-- Args : []
-- Lengths : []
-- returnType : Just (TBasicType TInt)
-- throws : False
-- Skip return : False
foreign import ccall "gdk_screen_height_mm" gdk_screen_height_mm ::
IO Int32
{-# DEPRECATED screenHeightMm ["(Since version 3.22)","Use per-monitor information"] #-}
{- |
Returns the height of the default screen in millimeters.
Note that on many X servers this value will not be correct.
-}
screenHeightMm ::
(B.CallStack.HasCallStack, MonadIO m) =>
m Int32
{- ^ __Returns:__ the height of the default screen in millimeters,
though it is not always correct. -}
screenHeightMm = liftIO $ do
result <- gdk_screen_height_mm
return result
#if ENABLE_OVERLOADING
#endif
-- method Screen::width
-- method type : MemberFunction
-- Args : []
-- Lengths : []
-- returnType : Just (TBasicType TInt)
-- throws : False
-- Skip return : False
foreign import ccall "gdk_screen_width" gdk_screen_width ::
IO Int32
{-# DEPRECATED screenWidth ["(Since version 3.22)","Use per-monitor information"] #-}
{- |
Gets the width of the default screen in pixels. The returned
size is in ”application pixels”, not in ”device pixels” (see
'GI.Gdk.Objects.Screen.screenGetMonitorScaleFactor').
-}
screenWidth ::
(B.CallStack.HasCallStack, MonadIO m) =>
m Int32
{- ^ __Returns:__ the width of the default screen in pixels. -}
screenWidth = liftIO $ do
result <- gdk_screen_width
return result
#if ENABLE_OVERLOADING
#endif
-- method Screen::width_mm
-- method type : MemberFunction
-- Args : []
-- Lengths : []
-- returnType : Just (TBasicType TInt)
-- throws : False
-- Skip return : False
foreign import ccall "gdk_screen_width_mm" gdk_screen_width_mm ::
IO Int32
{-# DEPRECATED screenWidthMm ["(Since version 3.22)","Use per-monitor information"] #-}
{- |
Returns the width of the default screen in millimeters.
Note that on many X servers this value will not be correct.
-}
screenWidthMm ::
(B.CallStack.HasCallStack, MonadIO m) =>
m Int32
{- ^ __Returns:__ the width of the default screen in millimeters,
though it is not always correct. -}
screenWidthMm = liftIO $ do
result <- gdk_screen_width_mm
return result
#if ENABLE_OVERLOADING
#endif