gi-gdk-3.0.29: Gdk bindings

Copyright | Will Thompson and Iñaki García Etxebarria
License | LGPL-2.1
Maintainer | Iñaki García Etxebarria
Safe Haskell | Safe-Inferred
Language | Haskell2010

GI.Gdk.Objects.Window

Contents

- Exported types
- Methods
  - atPointer
  - beep
  - beginDrawFrame
  - beginMoveDrag
  - beginMoveDragForDevice
  - beginPaintRect
  - beginPaintRegion
  - beginResizeDrag
  - beginResizeDragForDevice
  - configureFinished
  - constrainSize
  - coordsFromParent
  - coordsToParent
  - createGlContext
  - createSimilarImageSurface
  - createSimilarSurface
  - deiconify
  - destroy
  - destroyNotify
  - enableSynchronizedConfigure
  - endDrawFrame
  - endPaint
  - ensureNative
  - flush
  - focus
  - freezeToplevelUpdatesLibgtkOnly
  - freezeUpdates
  - fullscreen
  - fullscreenOnMonitor
  - geometryChanged
  - getAcceptFocus
  - getBackgroundPattern
  - getChildren
  - getChildrenWithUserData
  - getClipRegion
  - getComposited
  - getCursor
  - getDecorations
  - getDeviceCursor
  - getDeviceEvents
  - getDevicePosition
  - getDevicePositionDouble
  - getDisplay
  - getDragProtocol
  - getEffectiveParent
  - getEffectiveToplevel
  - getEventCompression
  - getEvents
  - getFocusOnMap
  - getFrameClock
  - getFrameExtents
  - getFullscreenMode
  - getGeometry
  - getGroup
  - getHeight
  - getModalHint
  - getOrigin
  - getParent
  - getPassThrough
  - getPointer
  - getPosition
  - getRootCoords
  - getRootOrigin
  - getScaleFactor
  - getScreen
  - getSourceEvents
  - getState
  - getSupportMultidevice
  - getToplevel
  - getTypeHint
  - getUpdateArea
  - getUserData
  - getVisibleRegion
  - getVisual
  - getWidth
  - getWindowType
  - hasNative
  - hide
  - iconify
  - inputShapeCombineRegion
  - invalidateMaybeRecurse
  - invalidateRect
  - invalidateRegion
  - isDestroyed
  - isInputOnly
  - isShaped
  - isViewable
  - isVisible
  - lower
  - markPaintFromClip
  - maximize
  - mergeChildInputShapes
  - mergeChildShapes
  - move
  - moveRegion
  - moveResize
  - moveToRect
  - new
  - peekChildren
  - processAllUpdates
  - processUpdates
  - raise
  - registerDnd
  - reparent
  - resize
  - restack
  - scroll
  - setAcceptFocus
  - setBackground
  - setBackgroundPattern
  - setBackgroundRgba
  - setChildInputShapes
  - setChildShapes
  - setComposited
  - setCursor
  - setDebugUpdates
  - setDecorations
  - setDeviceCursor
  - setDeviceEvents
  - setEventCompression
  - setEvents
  - setFocusOnMap
  - setFullscreenMode
  - setFunctions
  - setGeometryHints
  - setGroup
  - setIconList
  - setIconName
  - setKeepAbove
  - setKeepBelow
  - setModalHint
  - setOpacity
  - setOpaqueRegion
  - setOverrideRedirect
  - setPassThrough
  - setRole
  - setShadowWidth
  - setSkipPagerHint
  - setSkipTaskbarHint
  - setSourceEvents
  - setStartupId
  - setStaticGravities
  - setSupportMultidevice
  - setTitle
  - setTransientFor
  - setTypeHint
  - setUrgencyHint
  - setUserData
  - shapeCombineRegion
  - show
  - showUnraised
  - showWindowMenu
  - stick
  - thawToplevelUpdatesLibgtkOnly
  - thawUpdates
  - unfullscreen
  - unmaximize
  - unstick
  - withdraw
- Properties
  - cursor
- Signals
  - createSurface
  - fromEmbedder
  - movedToRect
  - pickEmbeddedChild
  - toEmbedder

Description

No description available in the introspection data.

Synopsis

- newtype Window = Window (ManagedPtr Window)
- class (GObject o, IsDescendantOf Window o) => IsWindow o
- toWindow :: (MonadIO m, IsWindow o) => o -> m Window
- windowAtPointer :: (HasCallStack, MonadIO m) => m (Window, Int32, Int32)
- windowBeep :: (HasCallStack, MonadIO m, IsWindow a) => a -> m ()
- windowBeginDrawFrame :: (HasCallStack, MonadIO m, IsWindow a) => a -> Region -> m DrawingContext
- windowBeginMoveDrag :: (HasCallStack, MonadIO m, IsWindow a) => a -> Int32 -> Int32 -> Int32 -> Word32 -> m ()
- windowBeginMoveDragForDevice :: (HasCallStack, MonadIO m, IsWindow a, IsDevice b) => a -> b -> Int32 -> Int32 -> Int32 -> Word32 -> m ()
- windowBeginPaintRect :: (HasCallStack, MonadIO m, IsWindow a) => a -> Rectangle -> m ()
- windowBeginPaintRegion :: (HasCallStack, MonadIO m, IsWindow a) => a -> Region -> m ()
- windowBeginResizeDrag :: (HasCallStack, MonadIO m, IsWindow a) => a -> WindowEdge -> Int32 -> Int32 -> Int32 -> Word32 -> m ()
- windowBeginResizeDragForDevice :: (HasCallStack, MonadIO m, IsWindow a, IsDevice b) => a -> WindowEdge -> b -> Int32 -> Int32 -> Int32 -> Word32 -> m ()
- windowConfigureFinished :: (HasCallStack, MonadIO m, IsWindow a) => a -> m ()
- windowConstrainSize :: (HasCallStack, MonadIO m) => Geometry -> [WindowHints] -> Int32 -> Int32 -> m (Int32, Int32)
- windowCoordsFromParent :: (HasCallStack, MonadIO m, IsWindow a) => a -> Double -> Double -> m (Double, Double)
- windowCoordsToParent :: (HasCallStack, MonadIO m, IsWindow a) => a -> Double -> Double -> m (Double, Double)
- windowCreateGlContext :: (HasCallStack, MonadIO m, IsWindow a) => a -> m GLContext
- windowCreateSimilarImageSurface :: (HasCallStack, MonadIO m, IsWindow a) => Maybe a -> Format -> Int32 -> Int32 -> Int32 -> m Surface
- windowCreateSimilarSurface :: (HasCallStack, MonadIO m, IsWindow a) => a -> Content -> Int32 -> Int32 -> m Surface
- windowDeiconify :: (HasCallStack, MonadIO m, IsWindow a) => a -> m ()
- windowDestroy :: (HasCallStack, MonadIO m, IsWindow a) => a -> m ()
- windowDestroyNotify :: (HasCallStack, MonadIO m, IsWindow a) => a -> m ()
- windowEnableSynchronizedConfigure :: (HasCallStack, MonadIO m, IsWindow a) => a -> m ()
- windowEndDrawFrame :: (HasCallStack, MonadIO m, IsWindow a, IsDrawingContext b) => a -> b -> m ()
- windowEndPaint :: (HasCallStack, MonadIO m, IsWindow a) => a -> m ()
- windowEnsureNative :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Bool
- windowFlush :: (HasCallStack, MonadIO m, IsWindow a) => a -> m ()
- windowFocus :: (HasCallStack, MonadIO m, IsWindow a) => a -> Word32 -> m ()
- windowFreezeToplevelUpdatesLibgtkOnly :: (HasCallStack, MonadIO m, IsWindow a) => a -> m ()
- windowFreezeUpdates :: (HasCallStack, MonadIO m, IsWindow a) => a -> m ()
- windowFullscreen :: (HasCallStack, MonadIO m, IsWindow a) => a -> m ()
- windowFullscreenOnMonitor :: (HasCallStack, MonadIO m, IsWindow a) => a -> Int32 -> m ()
- windowGeometryChanged :: (HasCallStack, MonadIO m, IsWindow a) => a -> m ()
- windowGetAcceptFocus :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Bool
- windowGetBackgroundPattern :: (HasCallStack, MonadIO m, IsWindow a) => a -> m (Maybe Pattern)
- windowGetChildren :: (HasCallStack, MonadIO m, IsWindow a) => a -> m [Window]
- windowGetChildrenWithUserData :: (HasCallStack, MonadIO m, IsWindow a) => a -> Ptr () -> m [Window]
- windowGetClipRegion :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Region
- windowGetComposited :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Bool
- windowGetCursor :: (HasCallStack, MonadIO m, IsWindow a) => a -> m (Maybe Cursor)
- windowGetDecorations :: (HasCallStack, MonadIO m, IsWindow a) => a -> m (Bool, [WMDecoration])
- windowGetDeviceCursor :: (HasCallStack, MonadIO m, IsWindow a, IsDevice b) => a -> b -> m (Maybe Cursor)
- windowGetDeviceEvents :: (HasCallStack, MonadIO m, IsWindow a, IsDevice b) => a -> b -> m [EventMask]
- windowGetDevicePosition :: (HasCallStack, MonadIO m, IsWindow a, IsDevice b) => a -> b -> m (Maybe Window, Int32, Int32, [ModifierType])
- windowGetDevicePositionDouble :: (HasCallStack, MonadIO m, IsWindow a, IsDevice b) => a -> b -> m (Maybe Window, Double, Double, [ModifierType])
- windowGetDisplay :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Display
- windowGetDragProtocol :: (HasCallStack, MonadIO m, IsWindow a) => a -> m (DragProtocol, Window)
- windowGetEffectiveParent :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Window
- windowGetEffectiveToplevel :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Window
- windowGetEventCompression :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Bool
- windowGetEvents :: (HasCallStack, MonadIO m, IsWindow a) => a -> m [EventMask]
- windowGetFocusOnMap :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Bool
- windowGetFrameClock :: (HasCallStack, MonadIO m, IsWindow a) => a -> m FrameClock
- windowGetFrameExtents :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Rectangle
- windowGetFullscreenMode :: (HasCallStack, MonadIO m, IsWindow a) => a -> m FullscreenMode
- windowGetGeometry :: (HasCallStack, MonadIO m, IsWindow a) => a -> m (Int32, Int32, Int32, Int32)
- windowGetGroup :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Window
- windowGetHeight :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Int32
- windowGetModalHint :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Bool
- windowGetOrigin :: (HasCallStack, MonadIO m, IsWindow a) => a -> m (Int32, Int32, Int32)
- windowGetParent :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Window
- windowGetPassThrough :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Bool
- windowGetPointer :: (HasCallStack, MonadIO m, IsWindow a) => a -> m (Maybe Window, Int32, Int32, [ModifierType])
- windowGetPosition :: (HasCallStack, MonadIO m, IsWindow a) => a -> m (Int32, Int32)
- windowGetRootCoords :: (HasCallStack, MonadIO m, IsWindow a) => a -> Int32 -> Int32 -> m (Int32, Int32)
- windowGetRootOrigin :: (HasCallStack, MonadIO m, IsWindow a) => a -> m (Int32, Int32)
- windowGetScaleFactor :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Int32
- windowGetScreen :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Screen
- windowGetSourceEvents :: (HasCallStack, MonadIO m, IsWindow a) => a -> InputSource -> m [EventMask]
- windowGetState :: (HasCallStack, MonadIO m, IsWindow a) => a -> m [WindowState]
- windowGetSupportMultidevice :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Bool
- windowGetToplevel :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Window
- windowGetTypeHint :: (HasCallStack, MonadIO m, IsWindow a) => a -> m WindowTypeHint
- windowGetUpdateArea :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Region
- windowGetUserData :: (HasCallStack, MonadIO m, IsWindow a) => a -> m (Ptr ())
- windowGetVisibleRegion :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Region
- windowGetVisual :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Visual
- windowGetWidth :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Int32
- windowGetWindowType :: (HasCallStack, MonadIO m, IsWindow a) => a -> m WindowType
- windowHasNative :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Bool
- windowHide :: (HasCallStack, MonadIO m, IsWindow a) => a -> m ()
- windowIconify :: (HasCallStack, MonadIO m, IsWindow a) => a -> m ()
- windowInputShapeCombineRegion :: (HasCallStack, MonadIO m, IsWindow a) => a -> Region -> Int32 -> Int32 -> m ()
- windowInvalidateMaybeRecurse :: (HasCallStack, MonadIO m, IsWindow a) => a -> Region -> Maybe WindowChildFunc -> m ()
- windowInvalidateRect :: (HasCallStack, MonadIO m, IsWindow a) => a -> Maybe Rectangle -> Bool -> m ()
- windowInvalidateRegion :: (HasCallStack, MonadIO m, IsWindow a) => a -> Region -> Bool -> m ()
- windowIsDestroyed :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Bool
- windowIsInputOnly :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Bool
- windowIsShaped :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Bool
- windowIsViewable :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Bool
- windowIsVisible :: (HasCallStack, MonadIO m, IsWindow a) => a -> m Bool
- windowLower :: (HasCallStack, MonadIO m, IsWindow a) => a -> m ()
- windowMarkPaintFromClip :: (HasCallStack, MonadIO m, IsWindow a) => a -> Context -> m ()
- windowMaximize :: (HasCallStack, MonadIO m, IsWindow a) => a -> m ()
- windowMergeChildInputShapes :: (HasCallStack, MonadIO m, IsWindow a) => a -> m ()
- windowMergeChildShapes :: (HasCallStack, MonadIO m, IsWindow a) => a -> m ()
- windowMove :: (HasCallStack, MonadIO m, IsWindow a) => a -> Int32 -> Int32 -> m ()
- windowMoveRegion :: (HasCallStack, MonadIO m, IsWindow a) => a -> Region -> Int32 -> Int32 -> m ()
- windowMoveResize :: (HasCallStack, MonadIO m, IsWindow a) => a -> Int32 -> Int32 -> Int32 -> Int32 -> m ()
- windowMoveToRect :: (HasCallStack, MonadIO m, IsWindow a) => a -> Rectangle -> Gravity -> Gravity -> [AnchorHints] -> Int32 -> Int32 -> m ()
- windowNew :: (HasCallStack, MonadIO m, IsWindow a) => Maybe a -> WindowAttr -> [WindowAttributesType] -> m Window
- windowPeekChildren :: (HasCallStack, MonadIO m, IsWindow a) => a -> m [Window]
- windowProcessAllUpdates :: (HasCallStack, MonadIO m) => m ()
- windowProcessUpdates :: (HasCallStack, MonadIO m, IsWindow a) => a -> Bool -> m ()
- windowRaise :: (HasCallStack, MonadIO m, IsWindow a) => a -> m ()
- windowRegisterDnd :: (HasCallStack, MonadIO m, IsWindow a) => a -> m ()
- windowReparent :: (HasCallStack, MonadIO m, IsWindow a, IsWindow b) => a -> b -> Int32 -> Int32 -> m ()
- windowResize :: (HasCallStack, MonadIO m, IsWindow a) => a -> Int32 -> Int32 -> m ()
- windowRestack :: (HasCallStack, MonadIO m, IsWindow a, IsWindow b) => a -> Maybe b -> Bool -> m ()
- windowScroll :: (HasCallStack, MonadIO m, IsWindow a) => a -> Int32 -> Int32 -> m ()
- windowSetAcceptFocus :: (HasCallStack, MonadIO m, IsWindow a) => a -> Bool -> m ()
- windowSetBackground :: (HasCallStack, MonadIO m, IsWindow a) => a -> Color -> m ()
- windowSetBackgroundPattern :: (HasCallStack, MonadIO m, IsWindow a) => a -> Maybe Pattern -> m ()
- windowSetBackgroundRgba :: (HasCallStack, MonadIO m, IsWindow a) => a -> RGBA -> m ()
- windowSetChildInputShapes :: (HasCallStack, MonadIO m, IsWindow a) => a -> m ()
- windowSetChildShapes :: (HasCallStack, MonadIO m, IsWindow a) => a -> m ()
- windowSetComposited :: (HasCallStack, MonadIO m, IsWindow a) => a -> Bool -> m ()
- windowSetCursor :: (HasCallStack, MonadIO m, IsWindow a, IsCursor b) => a -> Maybe b -> m ()
- windowSetDebugUpdates :: (HasCallStack, MonadIO m) => Bool -> m ()
- windowSetDecorations :: (HasCallStack, MonadIO m, IsWindow a) => a -> [WMDecoration] -> m ()
- windowSetDeviceCursor :: (HasCallStack, MonadIO m, IsWindow a, IsDevice b, IsCursor c) => a -> b -> c -> m ()
- windowSetDeviceEvents :: (HasCallStack, MonadIO m, IsWindow a, IsDevice b) => a -> b -> [EventMask] -> m ()
- windowSetEventCompression :: (HasCallStack, MonadIO m, IsWindow a) => a -> Bool -> m ()
- windowSetEvents :: (HasCallStack, MonadIO m, IsWindow a) => a -> [EventMask] -> m ()
- windowSetFocusOnMap :: (HasCallStack, MonadIO m, IsWindow a) => a -> Bool -> m ()
- windowSetFullscreenMode :: (HasCallStack, MonadIO m, IsWindow a) => a -> FullscreenMode -> m ()
- windowSetFunctions :: (HasCallStack, MonadIO m, IsWindow a) => a -> [WMFunction] -> m ()
- windowSetGeometryHints :: (HasCallStack, MonadIO m, IsWindow a) => a -> Geometry -> [WindowHints] -> m ()
- windowSetGroup :: (HasCallStack, MonadIO m, IsWindow a, IsWindow b) => a -> Maybe b -> m ()
- windowSetIconList :: (HasCallStack, MonadIO m, IsWindow a, IsPixbuf b) => a -> [b] -> m ()
- windowSetIconName :: (HasCallStack, MonadIO m, IsWindow a) => a -> Maybe Text -> m ()
- windowSetKeepAbove :: (HasCallStack, MonadIO m, IsWindow a) => a -> Bool -> m ()
- windowSetKeepBelow :: (HasCallStack, MonadIO m, IsWindow a) => a -> Bool -> m ()
- windowSetModalHint :: (HasCallStack, MonadIO m, IsWindow a) => a -> Bool -> m ()
- windowSetOpacity :: (HasCallStack, MonadIO m, IsWindow a) => a -> Double -> m ()
- windowSetOpaqueRegion :: (HasCallStack, MonadIO m, IsWindow a) => a -> Maybe Region -> m ()
- windowSetOverrideRedirect :: (HasCallStack, MonadIO m, IsWindow a) => a -> Bool -> m ()
- windowSetPassThrough :: (HasCallStack, MonadIO m, IsWindow a) => a -> Bool -> m ()
- windowSetRole :: (HasCallStack, MonadIO m, IsWindow a) => a -> Text -> m ()
- windowSetShadowWidth :: (HasCallStack, MonadIO m, IsWindow a) => a -> Int32 -> Int32 -> Int32 -> Int32 -> m ()
- windowSetSkipPagerHint :: (HasCallStack, MonadIO m, IsWindow a) => a -> Bool -> m ()
- windowSetSkipTaskbarHint :: (HasCallStack, MonadIO m, IsWindow a) => a -> Bool -> m ()
- windowSetSourceEvents :: (HasCallStack, MonadIO m, IsWindow a) => a -> InputSource -> [EventMask] -> m ()
- windowSetStartupId :: (HasCallStack, MonadIO m, IsWindow a) => a -> Text -> m ()
- windowSetStaticGravities :: (HasCallStack, MonadIO m, IsWindow a) => a -> Bool -> m Bool
- windowSetSupportMultidevice :: (HasCallStack, MonadIO m, IsWindow a) => a -> Bool -> m ()
- windowSetTitle :: (HasCallStack, MonadIO m, IsWindow a) => a -> Text -> m ()
- windowSetTransientFor :: (HasCallStack, MonadIO m, IsWindow a, IsWindow b) => a -> b -> m ()
- windowSetTypeHint :: (HasCallStack, MonadIO m, IsWindow a) => a -> WindowTypeHint -> m ()
- windowSetUrgencyHint :: (HasCallStack, MonadIO m, IsWindow a) => a -> Bool -> m ()
- windowSetUserData :: (HasCallStack, MonadIO m, IsWindow a, IsObject b) => a -> Maybe b -> m ()
- windowShapeCombineRegion :: (HasCallStack, MonadIO m, IsWindow a) => a -> Maybe Region -> Int32 -> Int32 -> m ()
- windowShow :: (HasCallStack, MonadIO m, IsWindow a) => a -> m ()
- windowShowUnraised :: (HasCallStack, MonadIO m, IsWindow a) => a -> m ()
- windowShowWindowMenu :: (HasCallStack, MonadIO m, IsWindow a) => a -> Event -> m Bool
- windowStick :: (HasCallStack, MonadIO m, IsWindow a) => a -> m ()
- windowThawToplevelUpdatesLibgtkOnly :: (HasCallStack, MonadIO m, IsWindow a) => a -> m ()
- windowThawUpdates :: (HasCallStack, MonadIO m, IsWindow a) => a -> m ()
- windowUnfullscreen :: (HasCallStack, MonadIO m, IsWindow a) => a -> m ()
- windowUnmaximize :: (HasCallStack, MonadIO m, IsWindow a) => a -> m ()
- windowUnstick :: (HasCallStack, MonadIO m, IsWindow a) => a -> m ()
- windowWithdraw :: (HasCallStack, MonadIO m, IsWindow a) => a -> m ()
- clearWindowCursor :: (MonadIO m, IsWindow o) => o -> m ()
- constructWindowCursor :: (IsWindow o, MonadIO m, IsCursor a) => a -> m (GValueConstruct o)
- getWindowCursor :: (MonadIO m, IsWindow o) => o -> m (Maybe Cursor)
- setWindowCursor :: (MonadIO m, IsWindow o, IsCursor a) => o -> a -> m ()
- type WindowCreateSurfaceCallback = Int32 -> Int32 -> IO Surface
- afterWindowCreateSurface :: (IsWindow a, MonadIO m) => a -> ((?self :: a) => WindowCreateSurfaceCallback) -> m SignalHandlerId
- onWindowCreateSurface :: (IsWindow a, MonadIO m) => a -> ((?self :: a) => WindowCreateSurfaceCallback) -> m SignalHandlerId
- type WindowFromEmbedderCallback = Double -> Double -> IO (Double, Double)
- afterWindowFromEmbedder :: (IsWindow a, MonadIO m) => a -> ((?self :: a) => WindowFromEmbedderCallback) -> m SignalHandlerId
- onWindowFromEmbedder :: (IsWindow a, MonadIO m) => a -> ((?self :: a) => WindowFromEmbedderCallback) -> m SignalHandlerId
- type WindowMovedToRectCallback = Ptr () -> Ptr () -> Bool -> Bool -> IO ()
- afterWindowMovedToRect :: (IsWindow a, MonadIO m) => a -> ((?self :: a) => WindowMovedToRectCallback) -> m SignalHandlerId
- onWindowMovedToRect :: (IsWindow a, MonadIO m) => a -> ((?self :: a) => WindowMovedToRectCallback) -> m SignalHandlerId
- type WindowPickEmbeddedChildCallback = Double -> Double -> IO (Maybe Window)
- afterWindowPickEmbeddedChild :: (IsWindow a, MonadIO m) => a -> ((?self :: a) => WindowPickEmbeddedChildCallback) -> m SignalHandlerId
- onWindowPickEmbeddedChild :: (IsWindow a, MonadIO m) => a -> ((?self :: a) => WindowPickEmbeddedChildCallback) -> m SignalHandlerId
- type WindowToEmbedderCallback = Double -> Double -> IO (Double, Double)
- afterWindowToEmbedder :: (IsWindow a, MonadIO m) => a -> ((?self :: a) => WindowToEmbedderCallback) -> m SignalHandlerId
- onWindowToEmbedder :: (IsWindow a, MonadIO m) => a -> ((?self :: a) => WindowToEmbedderCallback) -> m SignalHandlerId

# Exported types

newtype Window Source #

Memory-managed wrapper type.

Constructors

Window (ManagedPtr Window) |

#### Instances

Instances details

Eq Window Source # |
Instance details Defined in GI.Gdk.Objects.Window Methods (==) :: Window -> Window -> Bool Source # (/=) :: Window -> Window -> Bool Source #
GObject Window Source # |
Instance details Defined in GI.Gdk.Objects.Window
ManagedPtrNewtype Window Source # |
Instance details Defined in GI.Gdk.Objects.Window Methods toManagedPtr :: Window -> ManagedPtr Window Source #
TypedObject Window Source # |
Instance details Defined in GI.Gdk.Objects.Window Methods glibType :: IO GType Source #
HasParentTypes Window Source # |
Instance details Defined in GI.Gdk.Objects.Window
IsGValue (Maybe Window) Source # | Convert `Window` to and from `GValue`. See `toGValue` and `fromGValue`.
Instance details Defined in GI.Gdk.Objects.Window Methods gvalueGType_ :: IO GType Source # gvalueSet_ :: Ptr GValue -> Maybe Window -> IO () Source # gvalueGet_ :: Ptr GValue -> IO (Maybe Window) Source #
type ParentTypes Window Source # |
Instance details Defined in GI.Gdk.Objects.Window type ParentTypes Window = '[Object]

class (GObject o, IsDescendantOf Window o) => IsWindow o Source #

Type class for types which can be safely cast to `Window`, for instance with `toWindow`.

#### Instances

Instances details

(GObject o, IsDescendantOf Window o) => IsWindow o Source # |
Instance details Defined in GI.Gdk.Objects.Window

toWindow :: (MonadIO m, IsWindow o) => o -> m Window Source #

Cast to `Window`, for types for which this is known to be safe. For general casts, use `castTo`.

# Methods

### Click to display all available methods, including inherited ones

Expand

#### Methods

beep, beginDrawFrame, beginMoveDrag, beginMoveDragForDevice, beginPaintRect, beginPaintRegion, beginResizeDrag, beginResizeDragForDevice, bindProperty, bindPropertyFull, configureFinished, coordsFromParent, coordsToParent, createGlContext, createSimilarImageSurface, createSimilarSurface, deiconify, destroy, destroyNotify, enableSynchronizedConfigure, endDrawFrame, endPaint, ensureNative, flush, focus, forceFloating, freezeNotify, freezeToplevelUpdatesLibgtkOnly, freezeUpdates, fullscreen, fullscreenOnMonitor, geometryChanged, getv, hasNative, hide, iconify, inputShapeCombineRegion, invalidateMaybeRecurse, invalidateRect, invalidateRegion, isDestroyed, isFloating, isInputOnly, isShaped, isViewable, isVisible, lower, markPaintFromClip, maximize, mergeChildInputShapes, mergeChildShapes, move, moveRegion, moveResize, moveToRect, notify, notifyByPspec, peekChildren, processUpdates, raise, ref, refSink, registerDnd, reparent, resize, restack, runDispose, scroll, shapeCombineRegion, show, showUnraised, showWindowMenu, stealData, stealQdata, stick, thawNotify, thawToplevelUpdatesLibgtkOnly, thawUpdates, unfullscreen, unmaximize, unref, unstick, watchClosure, withdraw.

#### Getters

getAcceptFocus, getBackgroundPattern, getChildren, getChildrenWithUserData, getClipRegion, getComposited, getCursor, getData, getDecorations, getDeviceCursor, getDeviceEvents, getDevicePosition, getDevicePositionDouble, getDisplay, getDragProtocol, getEffectiveParent, getEffectiveToplevel, getEventCompression, getEvents, getFocusOnMap, getFrameClock, getFrameExtents, getFullscreenMode, getGeometry, getGroup, getHeight, getModalHint, getOrigin, getParent, getPassThrough, getPointer, getPosition, getProperty, getQdata, getRootCoords, getRootOrigin, getScaleFactor, getScreen, getSourceEvents, getState, getSupportMultidevice, getToplevel, getTypeHint, getUpdateArea, getUserData, getVisibleRegion, getVisual, getWidth, getWindowType.

#### Setters

setAcceptFocus, setBackground, setBackgroundPattern, setBackgroundRgba, setChildInputShapes, setChildShapes, setComposited, setCursor, setData, setDataFull, setDecorations, setDeviceCursor, setDeviceEvents, setEventCompression, setEvents, setFocusOnMap, setFullscreenMode, setFunctions, setGeometryHints, setGroup, setIconList, setIconName, setKeepAbove, setKeepBelow, setModalHint, setOpacity, setOpaqueRegion, setOverrideRedirect, setPassThrough, setProperty, setRole, setShadowWidth, setSkipPagerHint, setSkipTaskbarHint, setSourceEvents, setStartupId, setStaticGravities, setSupportMultidevice, setTitle, setTransientFor, setTypeHint, setUrgencyHint, setUserData.

## atPointer

windowAtPointer Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> m (Window, Int32, Int32) | Returns: window under the mouse pointer

Deprecated: (Since version 3.0)Use `deviceGetWindowAtPosition` instead.

Obtains the window underneath the mouse pointer, returning the location of that window in `winX`, `winY`. Returns `Nothing` if the window under the mouse pointer is not known to GDK (if the window belongs to another application and a `Window` hasn’t been created for it with `gdk_window_foreign_new()`)

NOTE: For multihead-aware widgets or applications use `displayGetWindowAtPointer` instead.

## beep

windowBeep Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a toplevel `Window`
-> m () |

Emits a short beep associated to `window` in the appropriate display, if supported. Otherwise, emits a short beep on the display just as `displayBeep`.

Since: 2.12

## beginDrawFrame

windowBeginDrawFrame Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> Region | `region`: a Cairo region
-> m DrawingContext | Returns: a `DrawingContext` context that should be used to draw the contents of the window; the returned context is owned by GDK.

Indicates that you are beginning the process of redrawing `region` on `window`, and provides you with a `DrawingContext`.

If `window` is a top level `Window`, backed by a native window implementation, a backing store (offscreen buffer) large enough to contain `region` will be created. The backing store will be initialized with the background color or background surface for `window`. Then, all drawing operations performed on `window` will be diverted to the backing store. When you call `gdk_window_end_frame()`, the contents of the backing store will be copied to `window`, making it visible on screen. Only the part of `window` contained in `region` will be modified; that is, drawing operations are clipped to `region`.

The net result of all this is to remove flicker, because the user sees the finished product appear all at once when you call `windowEndDrawFrame`. If you draw to `window` directly without calling `windowBeginDrawFrame`, the user may see flicker as individual drawing operations are performed in sequence.

When using GTK+, the widget system automatically places calls to `windowBeginDrawFrame` and `windowEndDrawFrame` around emissions of the `GtkWidget::draw` signal. That is, if you’re drawing the contents of the widget yourself, you can assume that the widget has a cleared background, is already set as the clip region, and already has a backing store. Therefore in most cases, application code in GTK does not need to call `windowBeginDrawFrame` explicitly.

Since: 3.22

## beginMoveDrag

windowBeginMoveDrag Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a toplevel `Window`
-> Int32 | `button`: the button being used to drag, or 0 for a keyboard-initiated drag
-> Int32 | `rootX`: root window X coordinate of mouse click that began the drag
-> Int32 | `rootY`: root window Y coordinate of mouse click that began the drag
-> Word32 | `timestamp`: timestamp of mouse click that began the drag
-> m () |

Begins a window move operation (for a toplevel window).

This function assumes that the drag is controlled by the client pointer device, use `windowBeginMoveDragForDevice` to begin a drag with a different device.

## beginMoveDragForDevice

windowBeginMoveDragForDevice Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a, IsDevice b) |
=> a | `window`: a toplevel `Window`
-> b | `device`: the device used for the operation
-> Int32 | `button`: the button being used to drag, or 0 for a keyboard-initiated drag
-> Int32 | `rootX`: root window X coordinate of mouse click that began the drag
-> Int32 | `rootY`: root window Y coordinate of mouse click that began the drag
-> Word32 | `timestamp`: timestamp of mouse click that began the drag
-> m () |

Begins a window move operation (for a toplevel window). You might use this function to implement a “window move grip,” for example. The function works best with window managers that support the Extended Window Manager Hints but has a fallback implementation for other window managers.

Since: 3.4

## beginPaintRect

windowBeginPaintRect Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> Rectangle | `rectangle`: rectangle you intend to draw to
-> m () |

Deprecated: (Since version 3.22)Use `windowBeginDrawFrame` instead

A convenience wrapper around `windowBeginPaintRegion` which creates a rectangular region for you. See `windowBeginPaintRegion` for details.

## beginPaintRegion

windowBeginPaintRegion Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> Region | `region`: region you intend to draw to
-> m () |

Deprecated: (Since version 3.22)Use `windowBeginDrawFrame` instead

Indicates that you are beginning the process of redrawing `region`. A backing store (offscreen buffer) large enough to contain `region` will be created. The backing store will be initialized with the background color or background surface for `window`. Then, all drawing operations performed on `window` will be diverted to the backing store. When you call `windowEndPaint`, the backing store will be copied to `window`, making it visible onscreen. Only the part of `window` contained in `region` will be modified; that is, drawing operations are clipped to `region`.

The net result of all this is to remove flicker, because the user sees the finished product appear all at once when you call `windowEndPaint`. If you draw to `window` directly without calling `windowBeginPaintRegion`, the user may see flicker as individual drawing operations are performed in sequence. The clipping and background-initializing features of `windowBeginPaintRegion` are conveniences for the programmer, so you can avoid doing that work yourself.

When using GTK+, the widget system automatically places calls to `windowBeginPaintRegion` and `windowEndPaint` around emissions of the expose_event signal. That is, if you’re writing an expose event handler, you can assume that the exposed area in `EventExpose` has already been cleared to the window background, is already set as the clip region, and already has a backing store. Therefore in most cases, application code need not call `windowBeginPaintRegion`. (You can disable the automatic calls around expose events on a widget-by-widget basis by calling `gtk_widget_set_double_buffered()`.)

If you call this function multiple times before calling the matching `windowEndPaint`, the backing stores are pushed onto a stack. `windowEndPaint` copies the topmost backing store onscreen, subtracts the topmost region from all other regions in the stack, and pops the stack. All drawing operations affect only the topmost backing store in the stack. One matching call to `windowEndPaint` is required for each call to `windowBeginPaintRegion`.

## beginResizeDrag

windowBeginResizeDrag Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a toplevel `Window`
-> WindowEdge | `edge`: the edge or corner from which the drag is started
-> Int32 | `button`: the button being used to drag, or 0 for a keyboard-initiated drag
-> Int32 | `rootX`: root window X coordinate of mouse click that began the drag
-> Int32 | `rootY`: root window Y coordinate of mouse click that began the drag
-> Word32 | `timestamp`: timestamp of mouse click that began the drag (use `eventGetTime`)
-> m () |

Begins a window resize operation (for a toplevel window).

This function assumes that the drag is controlled by the client pointer device, use `windowBeginResizeDragForDevice` to begin a drag with a different device.

## beginResizeDragForDevice

windowBeginResizeDragForDevice Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a, IsDevice b) |
=> a | `window`: a toplevel `Window`
-> WindowEdge | `edge`: the edge or corner from which the drag is started
-> b | `device`: the device used for the operation
-> Int32 | `button`: the button being used to drag, or 0 for a keyboard-initiated drag
-> Int32 | `rootX`: root window X coordinate of mouse click that began the drag
-> Int32 | `rootY`: root window Y coordinate of mouse click that began the drag
-> Word32 | `timestamp`: timestamp of mouse click that began the drag (use `eventGetTime`)
-> m () |

Begins a window resize operation (for a toplevel window). You might use this function to implement a “window resize grip,” for example; in fact `GtkStatusbar` uses it. The function works best with window managers that support the Extended Window Manager Hints but has a fallback implementation for other window managers.

Since: 3.4

## configureFinished

windowConfigureFinished Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a toplevel `Window`
-> m () |

Deprecated: (Since version 3.8)this function is no longer needed

Does nothing, present only for compatiblity.

Since: 2.6

## constrainSize

windowConstrainSize Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> Geometry | `geometry`: a `Geometry` structure
-> [WindowHints] | `flags`: a mask indicating what portions of `geometry` are set
-> Int32 | `width`: desired width of window
-> Int32 | `height`: desired height of the window
-> m (Int32, Int32) |

Constrains a desired width and height according to a set of geometry hints (such as minimum and maximum size).

## coordsFromParent

windowCoordsFromParent Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a child window
-> Double | `parentX`: X coordinate in parent’s coordinate system
-> Double | `parentY`: Y coordinate in parent’s coordinate system
-> m (Double, Double) |

Transforms window coordinates from a parent window to a child window, where the parent window is the normal parent as returned by `windowGetParent` for normal windows, and the window's embedder as returned by `offscreenWindowGetEmbedder` for offscreen windows.

For normal windows, calling this function is equivalent to subtracting the return values of `windowGetPosition` from the parent coordinates. For offscreen windows however (which can be arbitrarily transformed), this function calls the GdkWindowfromEmbedder: signal to translate the coordinates.

You should always use this function when writing generic code that walks down a window hierarchy.

See also: `windowCoordsToParent`

Since: 2.22

## coordsToParent

windowCoordsToParent Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a child window
-> Double | `x`: X coordinate in child’s coordinate system
-> Double | `y`: Y coordinate in child’s coordinate system
-> m (Double, Double) |

Transforms window coordinates from a child window to its parent window, where the parent window is the normal parent as returned by `windowGetParent` for normal windows, and the window's embedder as returned by `offscreenWindowGetEmbedder` for offscreen windows.

For normal windows, calling this function is equivalent to adding the return values of `windowGetPosition` to the child coordinates. For offscreen windows however (which can be arbitrarily transformed), this function calls the GdkWindowtoEmbedder: signal to translate the coordinates.

You should always use this function when writing generic code that walks up a window hierarchy.

See also: `windowCoordsFromParent`

Since: 2.22

## createGlContext

windowCreateGlContext Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> m GLContext | Returns: the newly created `GLContext`, or `Nothing` on error (Can throw `GError`)

Creates a new `GLContext` matching the framebuffer format to the visual of the `Window`. The context is disconnected from any particular window or surface.

If the creation of the `GLContext` failed, `error` will be set.

Before using the returned `GLContext`, you will need to call `gLContextMakeCurrent` or `gLContextRealize`.

Since: 3.16

## createSimilarImageSurface

windowCreateSimilarImageSurface Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> Maybe a | `window`: window to make new surface similar to, or `Nothing` if none
-> Format | `format`: the format for the new surface
-> Int32 | `width`: width of the new surface
-> Int32 | `height`: height of the new surface
-> Int32 | `scale`: the scale of the new surface, or 0 to use same as `window`
-> m Surface | Returns: a pointer to the newly allocated surface. The caller owns the surface and should call `cairo_surface_destroy()` when done with it. This function always returns a valid pointer, but it will return a pointer to a “nil” surface if `other` is already in an error state or any other error occurs.

Create a new image surface that is efficient to draw on the given `window`.

Initially the surface contents are all 0 (transparent if contents have transparency, black otherwise.)

The `width` and `height` of the new surface are not affected by the scaling factor of the `window`, or by the `scale` argument; they are the size of the surface in device pixels. If you wish to create an image surface capable of holding the contents of `window` you can use:

### C code

     int scale = gdk_window_get_scale_factor (window);
     int width = gdk_window_get_width (window) * scale;
     int height = gdk_window_get_height (window) * scale;

     // format is set elsewhere
     cairo_surface_t *surface =
       gdk_window_create_similar_image_surface (window,
                                                format,
                                                width, height,
                                                scale);

Note that unlike `cairo_surface_create_similar_image()`, the new surface's device scale is set to `scale`, or to the scale factor of `window` if `scale` is 0.

Since: 3.10

## createSimilarSurface

windowCreateSimilarSurface Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: window to make new surface similar to
-> Content | `content`: the content for the new surface
-> Int32 | `width`: width of the new surface
-> Int32 | `height`: height of the new surface
-> m Surface | Returns: a pointer to the newly allocated surface. The caller owns the surface and should call `cairo_surface_destroy()` when done with it. This function always returns a valid pointer, but it will return a pointer to a “nil” surface if `other` is already in an error state or any other error occurs.

Create a new surface that is as compatible as possible with the given `window`. For example the new surface will have the same fallback resolution and font options as `window`. Generally, the new surface will also use the same backend as `window`, unless that is not possible for some reason. The type of the returned surface may be examined with `cairo_surface_get_type()`.

Initially the surface contents are all 0 (transparent if contents have transparency, black otherwise.)

Since: 2.22

## deiconify

windowDeiconify Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a toplevel `Window`
-> m () |

Attempt to deiconify (unminimize) `window`. On X11 the window manager may choose to ignore the request to deiconify. When using GTK+, use `gtk_window_deiconify()` instead of the `Window` variant. Or better yet, you probably want to use `gtk_window_present_with_time()`, which raises the window, focuses it, unminimizes it, and puts it on the current desktop.

## destroy

windowDestroy Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> m () |

Destroys the window system resources associated with `window` and decrements `window`'s reference count. The window system resources for all children of `window` are also destroyed, but the children’s reference counts are not decremented.

Note that a window will not be destroyed automatically when its reference count reaches zero. You must call this function yourself before that happens.

## destroyNotify

windowDestroyNotify :: (HasCallStack, MonadIO m, IsWindow a) => a -> m () Source #

No description available in the introspection data.

## enableSynchronizedConfigure

windowEnableSynchronizedConfigure Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a toplevel `Window`
-> m () |

Deprecated: (Since version 3.8)this function is no longer needed

Does nothing, present only for compatiblity.

Since: 2.6

## endDrawFrame

windowEndDrawFrame Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a, IsDrawingContext b) |
=> a | `window`: a `Window`
-> b | `context`: the `DrawingContext` created by `windowBeginDrawFrame`
-> m () |

Indicates that the drawing of the contents of `window` started with `gdk_window_begin_frame()` has been completed.

This function will take care of destroying the `DrawingContext`.

It is an error to call this function without a matching `gdk_window_begin_frame()` first.

Since: 3.22

## endPaint

windowEndPaint Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> m () |

Indicates that the backing store created by the most recent call to `windowBeginPaintRegion` should be copied onscreen and deleted, leaving the next-most-recent backing store or no backing store at all as the active paint region. See `windowBeginPaintRegion` for full details.

It is an error to call this function without a matching `windowBeginPaintRegion` first.

## ensureNative

windowEnsureNative Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> m Bool | Returns: `True` if the window has a native window, `False` otherwise

Tries to ensure that there is a window-system native window for this GdkWindow. This may fail in some situations, returning `False`.

Offscreen window and children of them can never have native windows.

Some backends may not support native child windows.

Since: 2.18

## flush

windowFlush Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> m () |

Deprecated: (Since version 3.14)

This function does nothing.

Since: 2.18

## focus

windowFocus Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> Word32 | `timestamp`: timestamp of the event triggering the window focus
-> m () |

Sets keyboard focus to `window`. In most cases, `gtk_window_present_with_time()` should be used on a `GtkWindow`, rather than calling this function.

## freezeToplevelUpdatesLibgtkOnly

windowFreezeToplevelUpdatesLibgtkOnly Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> m () |

Deprecated: (Since version 3.16)This symbol was never meant to be used outside of GTK+

Temporarily freezes a window and all its descendants such that it won't receive expose events. The window will begin receiving expose events again when `windowThawToplevelUpdatesLibgtkOnly` is called. If `windowFreezeToplevelUpdatesLibgtkOnly` has been called more than once, `windowThawToplevelUpdatesLibgtkOnly` must be called an equal number of times to begin processing exposes.

This function is not part of the GDK public API and is only for use by GTK+.

## freezeUpdates

windowFreezeUpdates Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> m () |

Temporarily freezes a window such that it won’t receive expose events. The window will begin receiving expose events again when `windowThawUpdates` is called. If `windowFreezeUpdates` has been called more than once, `windowThawUpdates` must be called an equal number of times to begin processing exposes.

## fullscreen

windowFullscreen Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a toplevel `Window`
-> m () |

Moves the window into fullscreen mode. This means the window covers the entire screen and is above any panels or task bars.

If the window was already fullscreen, then this function does nothing.

On X11, asks the window manager to put `window` in a fullscreen state, if the window manager supports this operation. Not all window managers support this, and some deliberately ignore it or don’t have a concept of “fullscreen”; so you can’t rely on the fullscreenification actually happening. But it will happen with most standard window managers, and GDK makes a best effort to get it to happen.

Since: 2.2

## fullscreenOnMonitor

windowFullscreenOnMonitor Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a toplevel `Window`
-> Int32 | `monitor`: Which monitor to display fullscreen on.
-> m () |

Moves the window into fullscreen mode on the given monitor. This means the window covers the entire screen and is above any panels or task bars.

If the window was already fullscreen, then this function does nothing.

## geometryChanged

windowGeometryChanged Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: an embedded offscreen `Window`
-> m () |

This function informs GDK that the geometry of an embedded offscreen window has changed. This is necessary for GDK to keep track of which offscreen window the pointer is in.

Since: 2.18

## getAcceptFocus

windowGetAcceptFocus Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a toplevel `Window`.
-> m Bool | Returns: whether or not the window should receive input focus.

Determines whether or not the desktop environment shuld be hinted that the window does not want to receive input focus.

Since: 2.22

## getBackgroundPattern

windowGetBackgroundPattern Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a window
-> m (Maybe Pattern) | Returns: The pattern to use for the background or `Nothing` if there is no background.

Deprecated: (Since version 3.22)Don't use this function

Gets the pattern used to clear the background on `window`.

Since: 2.22

## getChildren

windowGetChildren Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> m [Window] | Returns: list of child windows inside `window`

Gets the list of children of `window` known to GDK. This function only returns children created via GDK, so for example it’s useless when used with the root window; it only returns windows an application created itself.

The returned list must be freed, but the elements in the list need not be.

## getChildrenWithUserData

windowGetChildrenWithUserData Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> Ptr () | `userData`: user data to look for
-> m [Window] | Returns: list of child windows inside `window`

Gets the list of children of `window` known to GDK with a particular `userData` set on it.

The returned list must be freed, but the elements in the list need not be.

The list is returned in (relative) stacking order, i.e. the lowest window is first.

Since: 3.10

## getClipRegion

windowGetClipRegion Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> m Region | Returns: a `Region`. This must be freed with `cairo_region_destroy()` when you are done.

Computes the region of a window that potentially can be written to by drawing primitives. This region may not take into account other factors such as if the window is obscured by other windows, but no area outside of this region will be affected by drawing primitives.

## getComposited

windowGetComposited Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> m Bool | Returns: `True` if the window is composited.

Deprecated: (Since version 3.16)Compositing is an outdated technology that only ever worked on X11.

Determines whether `window` is composited.

See `windowSetComposited`.

Since: 2.22

## getCursor

windowGetCursor Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> m (Maybe Cursor) | Returns: a `Cursor`, or `Nothing`. The returned object is owned by the `Window` and should not be unreferenced directly. Use `windowSetCursor` to unset the cursor of the window

Retrieves a `Cursor` pointer for the cursor currently set on the specified `Window`, or `Nothing`. If the return value is `Nothing` then there is no custom cursor set on the specified window, and it is using the cursor for its parent window.

Since: 2.18

## getDecorations

windowGetDecorations Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: The toplevel `Window` to get the decorations from
-> m (Bool, [WMDecoration]) | Returns: `True` if the window has decorations set, `False` otherwise.

Returns the decorations set on the GdkWindow with `windowSetDecorations`.

## getDeviceCursor

windowGetDeviceCursor Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a, IsDevice b) |
=> a | `window`: a `Window`.
-> b | `device`: a master, pointer `Device`.
-> m (Maybe Cursor) | Returns: a `Cursor`, or `Nothing`. The returned object is owned by the `Window` and should not be unreferenced directly. Use `windowSetCursor` to unset the cursor of the window

Retrieves a `Cursor` pointer for the `device` currently set on the specified `Window`, or `Nothing`. If the return value is `Nothing` then there is no custom cursor set on the specified window, and it is using the cursor for its parent window.

Since: 3.0

## getDeviceEvents

windowGetDeviceEvents Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a, IsDevice b) |
=> a | `window`: a `Window`.
-> b | `device`: a `Device`.
-> m [EventMask] | Returns: device event mask for `window`

Returns the event mask for `window` corresponding to an specific device.

Since: 3.0

## getDevicePosition

windowGetDevicePosition Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a, IsDevice b) |
=> a | `window`: a `Window`.
-> b | `device`: pointer `Device` to query to.
-> m (Maybe Window, Int32, Int32, [ModifierType]) | Returns: The window underneath `device` (as with `deviceGetWindowAtPosition`), or `Nothing` if the window is not known to GDK.

Obtains the current device position and modifier state. The position is given in coordinates relative to the upper left corner of `window`.

Use `windowGetDevicePositionDouble` if you need subpixel precision.

Since: 3.0

## getDevicePositionDouble

windowGetDevicePositionDouble Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a, IsDevice b) |
=> a | `window`: a `Window`.
-> b | `device`: pointer `Device` to query to.
-> m (Maybe Window, Double, Double, [ModifierType]) | Returns: The window underneath `device` (as with `deviceGetWindowAtPosition`), or `Nothing` if the window is not known to GDK.

Obtains the current device position in doubles and modifier state. The position is given in coordinates relative to the upper left corner of `window`.

Since: 3.10

## getDisplay

windowGetDisplay Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> m Display | Returns: the `Display` associated with `window`

Gets the `Display` associated with a `Window`.

Since: 2.24

## getDragProtocol

windowGetDragProtocol Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: the destination window
-> m (DragProtocol, Window) | Returns: the supported DND protocol.

Finds out the DND protocol supported by a window.

Since: 3.0

## getEffectiveParent

windowGetEffectiveParent Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> m Window | Returns: effective parent of `window`

Obtains the parent of `window`, as known to GDK. Works like `windowGetParent` for normal windows, but returns the window’s embedder for offscreen windows.

See also: `offscreenWindowGetEmbedder`

Since: 2.22

## getEffectiveToplevel

windowGetEffectiveToplevel Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> m Window | Returns: the effective toplevel window containing `window`

Gets the toplevel window that’s an ancestor of `window`.

Works like `windowGetToplevel`, but treats an offscreen window's embedder as its parent, using `windowGetEffectiveParent`.

See also: `offscreenWindowGetEmbedder`

Since: 2.22

## getEventCompression

windowGetEventCompression Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> m Bool | Returns: `True` if motion events will be compressed

Get the current event compression setting for this window.

Since: 3.12

## getEvents

windowGetEvents Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> m [EventMask] | Returns: event mask for `window`

Gets the event mask for `window` for all master input devices. See `windowSetEvents`.

## getFocusOnMap

windowGetFocusOnMap Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a toplevel `Window`.
-> m Bool | Returns: whether or not the window wants to receive input focus when it is mapped.

Determines whether or not the desktop environment should be hinted that the window does not want to receive input focus when it is mapped.

Since: 2.22

## getFrameClock

windowGetFrameClock Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: window to get frame clock for
-> m FrameClock | Returns: the frame clock

Gets the frame clock for the window. The frame clock for a window never changes unless the window is reparented to a new toplevel window.

Since: 3.8

## getFrameExtents

windowGetFrameExtents Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a toplevel `Window`
-> m Rectangle |

Obtains the bounding box of the window, including window manager titlebar/borders if any. The frame position is given in root window coordinates. To get the position of the window itself (rather than the frame) in root window coordinates, use `windowGetOrigin`.

## getFullscreenMode

windowGetFullscreenMode Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a toplevel `Window`
-> m FullscreenMode | Returns: The `FullscreenMode` applied to the window when fullscreen.

Obtains the `FullscreenMode` of the `window`.

Since: 3.8

## getGeometry

windowGetGeometry Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> m (Int32, Int32, Int32, Int32) |

Any of the return location arguments to this function may be `Nothing`, if you aren’t interested in getting the value of that field.

The X and Y coordinates returned are relative to the parent window of `window`, which for toplevels usually means relative to the window decorations (titlebar, etc.) rather than relative to the root window (screen-size background window).

On the X11 platform, the geometry is obtained from the X server, so reflects the latest position of `window`; this may be out-of-sync with the position of `window` delivered in the most-recently-processed `EventConfigure`. `windowGetPosition` in contrast gets the position from the most recent configure event.

Note: If `window` is not a toplevel, it is much better to call `windowGetPosition`, `windowGetWidth` and `windowGetHeight` instead, because it avoids the roundtrip to the X server and because these functions support the full 32-bit coordinate space, whereas `windowGetGeometry` is restricted to the 16-bit coordinates of X11.

## getGroup

windowGetGroup Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a toplevel `Window`
-> m Window | Returns: the group leader window for `window`

Returns the group leader window for `window`. See `windowSetGroup`.

Since: 2.4

## getHeight

windowGetHeight Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> m Int32 | Returns: The height of `window`

Returns the height of the given `window`.

On the X11 platform the returned size is the size reported in the most-recently-processed configure event, rather than the current size on the X server.

Since: 2.24

## getModalHint

windowGetModalHint Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: A toplevel `Window`.
-> m Bool | Returns: whether or not the window has the modal hint set.

Determines whether or not the window manager is hinted that `window` has modal behaviour.

Since: 2.22

## getOrigin

windowGetOrigin Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> m (Int32, Int32, Int32) | Returns: not meaningful, ignore

Obtains the position of a window in root window coordinates. (Compare with `windowGetPosition` and `windowGetGeometry` which return the position of a window relative to its parent window.)

## getParent

windowGetParent Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> m Window | Returns: parent of `window`

Obtains the parent of `window`, as known to GDK. Does not query the X server; thus this returns the parent as passed to `windowNew`, not the actual parent. This should never matter unless you’re using Xlib calls mixed with GDK calls on the X11 platform. It may also matter for toplevel windows, because the window manager may choose to reparent them.

Note that you should use `windowGetEffectiveParent` when writing generic code that walks up a window hierarchy, because `windowGetParent` will most likely not do what you expect if there are offscreen windows in the hierarchy.

## getPassThrough

windowGetPassThrough Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> m Bool |

Returns whether input to the window is passed through to the window below.

See `windowSetPassThrough` for details

Since: 3.18

## getPointer

windowGetPointer Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> m (Maybe Window, Int32, Int32, [ModifierType]) | Returns: the window containing the pointer (as with `windowAtPointer`), or `Nothing` if the window containing the pointer isn’t known to GDK

Deprecated: (Since version 3.0)Use `windowGetDevicePosition` instead.

Obtains the current pointer position and modifier state. The position is given in coordinates relative to the upper left corner of `window`.

## getPosition

windowGetPosition Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> m (Int32, Int32) |

Obtains the position of the window as reported in the most-recently-processed `EventConfigure`. Contrast with `windowGetGeometry` which queries the X server for the current window position, regardless of which events have been received or processed.

The position coordinates are relative to the window’s parent window.

## getRootCoords

windowGetRootCoords Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> Int32 | `x`: X coordinate in window
-> Int32 | `y`: Y coordinate in window
-> m (Int32, Int32) |

Obtains the position of a window position in root window coordinates. This is similar to `windowGetOrigin` but allows you to pass in any position in the window, not just the origin.

Since: 2.18

## getRootOrigin

windowGetRootOrigin Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a toplevel `Window`
-> m (Int32, Int32) |

Obtains the top-left corner of the window manager frame in root window coordinates.

## getScaleFactor

windowGetScaleFactor Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: window to get scale factor for
-> m Int32 | Returns: the scale factor

Returns the internal scale factor that maps from window coordiantes 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).

A higher value means that drawing is automatically scaled up to a higher resolution, so any code doing drawing will automatically look nicer. However, if you are supplying pixel-based data the scale value can be used to determine whether to use a pixel resource with higher resolution data.

The scale of a window may change during runtime, if this happens a configure event will be sent to the toplevel window.

Since: 3.10

## getScreen

windowGetScreen Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> m Screen | Returns: the `Screen` associated with `window`

Gets the `Screen` associated with a `Window`.

Since: 2.24

## getSourceEvents

windowGetSourceEvents Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> InputSource | `source`: a `InputSource` to define the source class.
-> m [EventMask] | Returns: source event mask for `window`

Returns the event mask for `window` corresponding to the device class specified by `source`.

## getState

windowGetState Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> m [WindowState] | Returns: window state bitfield

Gets the bitwise OR of the currently active window state flags, from the `WindowState` enumeration.

## getSupportMultidevice

windowGetSupportMultidevice Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`.
-> m Bool | Returns: `True` if the window handles multidevice features.

Returns `True` if the window is aware of the existence of multiple devices.

Since: 3.0

## getToplevel

windowGetToplevel Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> m Window | Returns: the toplevel window containing `window`

Gets the toplevel window that’s an ancestor of `window`.

Any window type but `WindowTypeChild` is considered a toplevel window, as is a `WindowTypeChild` window that has a root window as parent.

Note that you should use `windowGetEffectiveToplevel` when you want to get to a window’s toplevel as seen on screen, because `windowGetToplevel` will most likely not do what you expect if there are offscreen windows in the hierarchy.

## getTypeHint

windowGetTypeHint Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: A toplevel `Window`
-> m WindowTypeHint | Returns: The type hint set for `window`

This function returns the type hint set for a window.

Since: 2.10

## getUpdateArea

windowGetUpdateArea Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> m Region | Returns: the update area for `window`

Transfers ownership of the update area from `window` to the caller of the function. That is, after calling this function, `window` will no longer have an invalid/dirty region; the update area is removed from `window` and handed to you. If a window has no update area, `windowGetUpdateArea` returns `Nothing`. You are responsible for calling `cairo_region_destroy()` on the returned region if it’s non-`Nothing`.

## getUserData

windowGetUserData Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> m (Ptr ()) |

Retrieves the user data for `window`, which is normally the widget that `window` belongs to. See `windowSetUserData`.

## getVisibleRegion

windowGetVisibleRegion Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> m Region | Returns: a `Region`. This must be freed with `cairo_region_destroy()` when you are done.

Computes the region of the `window` that is potentially visible. This does not necessarily take into account if the window is obscured by other windows, but no area outside of this region is visible.

## getVisual

windowGetVisual Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> m Visual | Returns: a `Visual`

Gets the `Visual` describing the pixel format of `window`.

Since: 2.24

## getWidth

windowGetWidth Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> m Int32 | Returns: The width of `window`

Returns the width of the given `window`.

On the X11 platform the returned size is the size reported in the most-recently-processed configure event, rather than the current size on the X server.

Since: 2.24

## getWindowType

windowGetWindowType Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> m WindowType | Returns: type of window

Gets the type of the window. See `WindowType`.

## hasNative

windowHasNative Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> m Bool | Returns: `True` if the `window` has a native window, `False` otherwise.

Checks whether the window has a native window or not. Note that you can use `windowEnsureNative` if a native window is needed.

Since: 2.22

## hide

windowHide Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> m () |

For toplevel windows, withdraws them, so they will no longer be known to the window manager; for all windows, unmaps them, so they won’t be displayed. Normally done automatically as part of `gtk_widget_hide()`.

## iconify

windowIconify Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a toplevel `Window`
-> m () |

Asks to iconify (minimize) `window`. The window manager may choose to ignore the request, but normally will honor it. Using `gtk_window_iconify()` is preferred, if you have a `GtkWindow` widget.

This function only makes sense when `window` is a toplevel window.

## inputShapeCombineRegion

windowInputShapeCombineRegion Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> Region | `shapeRegion`: region of window to be non-transparent
-> Int32 | `offsetX`: X position of `shapeRegion` in `window` coordinates
-> Int32 | `offsetY`: Y position of `shapeRegion` in `window` coordinates
-> m () |

Like `windowShapeCombineRegion`, but the shape applies only to event handling. Mouse events which happen while the pointer position corresponds to an unset bit in the mask will be passed on the window below `window`.

An input shape is typically used with RGBA windows. The alpha channel of the window defines which pixels are invisible and allows for nicely antialiased borders, and the input shape controls where the window is “clickable”.

On the X11 platform, this requires version 1.1 of the shape extension.

On the Win32 platform, this functionality is not present and the function does nothing.

Since: 2.10

## invalidateMaybeRecurse

windowInvalidateMaybeRecurse Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> Region | `region`: a `Region`
-> Maybe WindowChildFunc | `childFunc`: function to use to decide if to recurse to a child, `Nothing` means never recurse.
-> m () |

Adds `region` to the update area for `window`. The update area is the region that needs to be redrawn, or “dirty region.” The call `windowProcessUpdates` sends one or more expose events to the window, which together cover the entire update area. An application would normally redraw the contents of `window` in response to those expose events.

GDK will call `windowProcessAllUpdates` on your behalf whenever your program returns to the main loop and becomes idle, so normally there’s no need to do that manually, you just need to invalidate regions that you know should be redrawn.

The `childFunc` parameter controls whether the region of each child window that intersects `region` will also be invalidated. Only children for which `childFunc` returns `TRUE` will have the area invalidated.

## invalidateRect

windowInvalidateRect Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> Maybe Rectangle | `rect`: rectangle to invalidate or `Nothing` to invalidate the whole window
-> Bool | `invalidateChildren`: whether to also invalidate child windows
-> m () |

A convenience wrapper around `windowInvalidateRegion` which invalidates a rectangular region. See `windowInvalidateRegion` for details.

## invalidateRegion

windowInvalidateRegion Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> Region | `region`: a `Region`
-> Bool | `invalidateChildren`: `True` to also invalidate child windows
-> m () |

Adds `region` to the update area for `window`. The update area is the region that needs to be redrawn, or “dirty region.” The call `windowProcessUpdates` sends one or more expose events to the window, which together cover the entire update area. An application would normally redraw the contents of `window` in response to those expose events.

GDK will call `windowProcessAllUpdates` on your behalf whenever your program returns to the main loop and becomes idle, so normally there’s no need to do that manually, you just need to invalidate regions that you know should be redrawn.

The `invalidateChildren` parameter controls whether the region of each child window that intersects `region` will also be invalidated. If `False`, then the update area for child windows will remain unaffected. See gdk_window_invalidate_maybe_recurse if you need fine grained control over which children are invalidated.

## isDestroyed

windowIsDestroyed Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> m Bool | Returns: `True` if the window is destroyed

Check to see if a window is destroyed..

Since: 2.18

## isInputOnly

windowIsInputOnly Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a toplevel `Window`
-> m Bool | Returns: `True` if `window` is input only

Determines whether or not the window is an input only window.

Since: 2.22

## isShaped

windowIsShaped Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a toplevel `Window`
-> m Bool | Returns: `True` if `window` is shaped

Determines whether or not the window is shaped.

Since: 2.22

## isViewable

windowIsViewable Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> m Bool | Returns: `True` if the window is viewable

Check if the window and all ancestors of the window are mapped. (This is not necessarily "viewable" in the X sense, since we only check as far as we have GDK window parents, not to the root window.)

## isVisible

windowIsVisible Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> m Bool | Returns: `True` if the window is mapped

Checks whether the window has been mapped (with `windowShow` or `windowShowUnraised`).

## lower

windowLower Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> m () |

Lowers `window` to the bottom of the Z-order (stacking order), so that other windows with the same parent window appear above `window`. This is true whether or not the other windows are visible.

If `window` is a toplevel, the window manager may choose to deny the request to move the window in the Z-order, `windowLower` only requests the restack, does not guarantee it.

Note that `windowShow` raises the window again, so don’t call this function before `windowShow`. (Try `windowShowUnraised`.)

## markPaintFromClip

windowMarkPaintFromClip Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> Context | `cr`: a `Context`
-> m () |

If you call this during a paint (e.g. between `windowBeginPaintRegion` and `windowEndPaint` then GDK will mark the current clip region of the window as being drawn. This is required when mixing GL rendering via `cairoDrawFromGl` and cairo rendering, as otherwise GDK has no way of knowing when something paints over the GL-drawn regions.

This is typically called automatically by GTK+ and you don't need to care about this.

Since: 3.16

## maximize

windowMaximize Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a toplevel `Window`
-> m () |

Maximizes the window. If the window was already maximized, then this function does nothing.

On X11, asks the window manager to maximize `window`, if the window manager supports this operation. Not all window managers support this, and some deliberately ignore it or don’t have a concept of “maximized”; so you can’t rely on the maximization actually happening. But it will happen with most standard window managers, and GDK makes a best effort to get it to happen.

On Windows, reliably maximizes the window.

## mergeChildInputShapes

windowMergeChildInputShapes Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> m () |

Merges the input shape masks for any child windows into the input shape mask for `window`. i.e. the union of all input masks for `window` and its children will become the new input mask for `window`. See `windowInputShapeCombineRegion`.

This function is distinct from `windowSetChildInputShapes` because it includes `window`’s input shape mask in the set of shapes to be merged.

Since: 2.10

## mergeChildShapes

windowMergeChildShapes Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> m () |

Merges the shape masks for any child windows into the shape mask for `window`. i.e. the union of all masks for `window` and its children will become the new mask for `window`. See `windowShapeCombineRegion`.

This function is distinct from `windowSetChildShapes` because it includes `window`’s shape mask in the set of shapes to be merged.

## move

windowMove Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> Int32 | `x`: X coordinate relative to window’s parent
-> Int32 | `y`: Y coordinate relative to window’s parent
-> m () |

Repositions a window relative to its parent window. For toplevel windows, window managers may ignore or modify the move; you should probably use `gtk_window_move()` on a `GtkWindow` widget anyway, instead of using GDK functions. For child windows, the move will reliably succeed.

If you’re also planning to resize the window, use `windowMoveResize` to both move and resize simultaneously, for a nicer visual effect.

## moveRegion

windowMoveRegion Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> Region | `region`: The `Region` to move
-> Int32 | `dx`: Amount to move in the X direction
-> Int32 | `dy`: Amount to move in the Y direction
-> m () |

Move the part of `window` indicated by `region` by `dy` pixels in the Y direction and `dx` pixels in the X direction. The portions of `region` that not covered by the new position of `region` are invalidated.

Child windows are not moved.

Since: 2.8

## moveResize

windowMoveResize Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> Int32 | `x`: new X position relative to window’s parent
-> Int32 | `y`: new Y position relative to window’s parent
-> Int32 | `width`: new width
-> Int32 | `height`: new height
-> m () |

Equivalent to calling `windowMove` and `windowResize`, except that both operations are performed at once, avoiding strange visual effects. (i.e. the user may be able to see the window first move, then resize, if you don’t use `windowMoveResize`.)

## moveToRect

windowMoveToRect Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: the `Window` to move
-> Rectangle | `rect`: the destination `Rectangle` to align `window` with
-> Gravity | `rectAnchor`: the point on `rect` to align with `window`'s anchor point
-> Gravity | `windowAnchor`: the point on `window` to align with `rect`'s anchor point
-> [AnchorHints] | `anchorHints`: positioning hints to use when limited on space
-> Int32 | `rectAnchorDx`: horizontal offset to shift `window`, i.e. `rect`'s anchor point
-> Int32 | `rectAnchorDy`: vertical offset to shift `window`, i.e. `rect`'s anchor point
-> m () |

Moves `window` to `rect`, aligning their anchor points.

`rect` is relative to the top-left corner of the window that `window` is transient for. `rectAnchor` and `windowAnchor` determine anchor points on `rect` and `window` to pin together. `rect`'s anchor point can optionally be offset by `rectAnchorDx` and `rectAnchorDy`, which is equivalent to offsetting the position of `window`.

`anchorHints` determines how `window` will be moved if the anchor points cause it to move off-screen. For example, `AnchorHintsFlipX` will replace `GravityNorthWest` with `GravityNorthEast` and vice versa if `window` extends beyond the left or right edges of the monitor.

Connect to the Window::movedToRect signal to find out how it was actually positioned.

Since: 3.24

## new

windowNew Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> Maybe a | `parent`: a `Window`, or `Nothing` to create the window as a child of the default root window for the default display.
-> WindowAttr | `attributes`: attributes of the new window
-> [WindowAttributesType] | `attributesMask`: mask indicating which fields in `attributes` are valid
-> m Window | Returns: the new `Window`

Creates a new `Window` using the attributes from `attributes`. See `WindowAttr` and `WindowAttributesType` for more details. Note: to use this on displays other than the default display, `parent` must be specified.

## peekChildren

windowPeekChildren Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> m [Window] | Returns: a reference to the list of child windows in `window`

Like `windowGetChildren`, but does not copy the list of children, so the list does not need to be freed.

## processAllUpdates

windowProcessAllUpdates :: (HasCallStack, MonadIO m) => m () Source #

Deprecated: (Since version 3.22)

Calls `windowProcessUpdates` for all windows (see `Window`) in the application.

## processUpdates

windowProcessUpdates Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> Bool | `updateChildren`: whether to also process updates for child windows
-> m () |

Deprecated: (Since version 3.22)

Sends one or more expose events to `window`. The areas in each expose event will cover the entire update area for the window (see `windowInvalidateRegion` for details). Normally GDK calls `windowProcessAllUpdates` on your behalf, so there’s no need to call this function unless you want to force expose events to be delivered immediately and synchronously (vs. the usual case, where GDK delivers them in an idle handler). Occasionally this is useful to produce nicer scrolling behavior, for example.

## raise

windowRaise Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> m () |

Raises `window` to the top of the Z-order (stacking order), so that other windows with the same parent window appear below `window`. This is true whether or not the windows are visible.

If `window` is a toplevel, the window manager may choose to deny the request to move the window in the Z-order, `windowRaise` only requests the restack, does not guarantee it.

## registerDnd

windowRegisterDnd Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`.
-> m () |

Registers a window as a potential drop destination.

## reparent

windowReparent Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a, IsWindow b) |
=> a | `window`: a `Window`
-> b | `newParent`: new parent to move `window` into
-> Int32 | `x`: X location inside the new parent
-> Int32 | `y`: Y location inside the new parent
-> m () |

Reparents `window` into the given `newParent`. The window being reparented will be unmapped as a side effect.

## resize

windowResize Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> Int32 | `width`: new width of the window
-> Int32 | `height`: new height of the window
-> m () |

Resizes `window`; for toplevel windows, asks the window manager to resize the window. The window manager may not allow the resize. When using GTK+, use `gtk_window_resize()` instead of this low-level GDK function.

Windows may not be resized below 1x1.

If you’re also planning to move the window, use `windowMoveResize` to both move and resize simultaneously, for a nicer visual effect.

## restack

windowRestack Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a, IsWindow b) |
=> a | `window`: a `Window`
-> Maybe b | `sibling`: a `Window` that is a sibling of `window`, or `Nothing`
-> Bool | `above`: a boolean
-> m () |

Changes the position of `window` in the Z-order (stacking order), so that it is above `sibling` (if `above` is `True`) or below `sibling` (if `above` is `False`).

If `sibling` is `Nothing`, then this either raises (if `above` is `True`) or lowers the window.

If `window` is a toplevel, the window manager may choose to deny the request to move the window in the Z-order, `windowRestack` only requests the restack, does not guarantee it.

Since: 2.18

## scroll

windowScroll Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> Int32 | `dx`: Amount to scroll in the X direction
-> Int32 | `dy`: Amount to scroll in the Y direction
-> m () |

Scroll the contents of `window`, both pixels and children, by the given amount. `window` itself does not move. Portions of the window that the scroll operation brings in from offscreen areas are invalidated. The invalidated region may be bigger than what would strictly be necessary.

For X11, a minimum area will be invalidated if the window has no subwindows, or if the edges of the window’s parent do not extend beyond the edges of the window. In other cases, a multi-step process is used to scroll the window which may produce temporary visual artifacts and unnecessary invalidations.

## setAcceptFocus

windowSetAcceptFocus Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a toplevel `Window`
-> Bool | `acceptFocus`: `True` if the window should receive input focus
-> m () |

Setting `acceptFocus` to `False` hints the desktop environment that the window doesn’t want to receive input focus.

On X, it is the responsibility of the window manager to interpret this hint. ICCCM-compliant window manager usually respect it.

Since: 2.4

## setBackground

windowSetBackground Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> Color | `color`: a `Color`
-> m () |

Deprecated: (Since version 3.4)Don't use this function

Sets the background color of `window`.

However, when using GTK+, influence the background of a widget using a style class or CSS — if you’re an application — or with `gtk_style_context_set_background()` — if you're implementing a custom widget.

## setBackgroundPattern

windowSetBackgroundPattern Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> Maybe Pattern | `pattern`: a pattern to use, or `Nothing`
-> m () |

Deprecated: (Since version 3.22)Don't use this function

Sets the background of `window`.

A background of `Nothing` means that the window won't have any background. On the X11 backend it's also possible to inherit the background from the parent window using `gdk_x11_get_parent_relative_pattern()`.

The windowing system will normally fill a window with its background when the window is obscured then exposed.

## setBackgroundRgba

windowSetBackgroundRgba Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> RGBA | `rgba`: a `RGBA` color
-> m () |

Deprecated: (Since version 3.22)Don't use this function

Sets the background color of `window`.

See also `windowSetBackgroundPattern`.

## setChildInputShapes

windowSetChildInputShapes Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> m () |

Sets the input shape mask of `window` to the union of input shape masks for all children of `window`, ignoring the input shape mask of `window` itself. Contrast with `windowMergeChildInputShapes` which includes the input shape mask of `window` in the masks to be merged.

Since: 2.10

## setChildShapes

windowSetChildShapes Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> m () |

Sets the shape mask of `window` to the union of shape masks for all children of `window`, ignoring the shape mask of `window` itself. Contrast with `windowMergeChildShapes` which includes the shape mask of `window` in the masks to be merged.

## setComposited

windowSetComposited Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> Bool | `composited`: `True` to set the window as composited
-> m () |

Deprecated: (Since version 3.16)Compositing is an outdated technology that only ever worked on X11.

Sets a `Window` as composited, or unsets it. Composited windows do not automatically have their contents drawn to the screen. Drawing is redirected to an offscreen buffer and an expose event is emitted on the parent of the composited window. It is the responsibility of the parent’s expose handler to manually merge the off-screen content onto the screen in whatever way it sees fit.

It only makes sense for child windows to be composited; see `windowSetOpacity` if you need translucent toplevel windows.

An additional effect of this call is that the area of this window is no longer clipped from regions marked for invalidation on its parent. Draws done on the parent window are also no longer clipped by the child.

This call is only supported on some systems (currently, only X11 with new enough Xcomposite and Xdamage extensions). You must call `displaySupportsComposite` to check if setting a window as composited is supported before attempting to do so.

Since: 2.12

## setCursor

windowSetCursor Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a, IsCursor b) |
=> a | `window`: a `Window`
-> Maybe b | `cursor`: a cursor
-> m () |

Sets the default mouse pointer for a `Window`.

Note that `cursor` must be for the same display as `window`.

Use `cursorNewForDisplay` or `cursorNewFromPixbuf` to create the cursor. To make the cursor invisible, use `CursorTypeBlankCursor`. Passing `Nothing` for the `cursor` argument to `windowSetCursor` means that `window` will use the cursor of its parent window. Most windows should use this default.

## setDebugUpdates

windowSetDebugUpdates Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> Bool | `setting`: `True` to turn on update debugging
-> m () |

Deprecated: (Since version 3.22)

With update debugging enabled, calls to `windowInvalidateRegion` clear the invalidated region of the screen to a noticeable color, and GDK pauses for a short time before sending exposes to windows during `windowProcessUpdates`. The net effect is that you can see the invalid region for each window and watch redraws as they occur. This allows you to diagnose inefficiencies in your application.

In essence, because the GDK rendering model prevents all flicker, if you are redrawing the same region 400 times you may never notice, aside from noticing a speed problem. Enabling update debugging causes GTK to flicker slowly and noticeably, so you can see exactly what’s being redrawn when, in what order.

The --gtk-debug=updates command line option passed to GTK+ programs enables this debug option at application startup time. That's usually more useful than calling `windowSetDebugUpdates` yourself, though you might want to use this function to enable updates sometime after application startup time.

## setDecorations

windowSetDecorations Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a toplevel `Window`
-> [WMDecoration] | `decorations`: decoration hint mask
-> m () |

“Decorations” are the features the window manager adds to a toplevel `Window`. This function sets the traditional Motif window manager hints that tell the window manager which decorations you would like your window to have. Usually you should use `gtk_window_set_decorated()` on a `GtkWindow` instead of using the GDK function directly.

The `decorations` argument is the logical OR of the fields in the `WMDecoration` enumeration. If `GDK_DECOR_ALL` is included in the mask, the other bits indicate which decorations should be turned off. If `GDK_DECOR_ALL` is not included, then the other bits indicate which decorations should be turned on.

Most window managers honor a decorations hint of 0 to disable all decorations, but very few honor all possible combinations of bits.

## setDeviceCursor

windowSetDeviceCursor Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a, IsDevice b, IsCursor c) |
=> a | `window`: a `Window`
-> b | `device`: a master, pointer `Device`
-> c | `cursor`: a `Cursor`
-> m () |

Sets a specific `Cursor` for a given device when it gets inside `window`. Use `cursorNewForDisplay` or `cursorNewFromPixbuf` to create the cursor. To make the cursor invisible, use `CursorTypeBlankCursor`. Passing `Nothing` for the `cursor` argument to `windowSetCursor` means that `window` will use the cursor of its parent window. Most windows should use this default.

Since: 3.0

## setDeviceEvents

windowSetDeviceEvents Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a, IsDevice b) |
=> a | `window`: a `Window`
-> b | `device`: `Device` to enable events for.
-> [EventMask] | `eventMask`: event mask for `window`
-> m () |

Sets the event mask for a given device (Normally a floating device, not attached to any visible pointer) to `window`. For example, an event mask including `GDK_BUTTON_PRESS_MASK` means the window should report button press events. The event mask is the bitwise OR of values from the `EventMask` enumeration.

See the [input handling overview][event-masks] for details.

Since: 3.0

## setEventCompression

windowSetEventCompression Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> Bool | `eventCompression`: `True` if motion events should be compressed
-> m () |

Determines whether or not extra unprocessed motion events in the event queue can be discarded. If `True` only the most recent event will be delivered.

Some types of applications, e.g. paint programs, need to see all motion events and will benefit from turning off event compression.

By default, event compression is enabled.

Since: 3.12

## setEvents

windowSetEvents Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> [EventMask] | `eventMask`: event mask for `window`
-> m () |

The event mask for a window determines which events will be reported for that window from all master input devices. For example, an event mask including `GDK_BUTTON_PRESS_MASK` means the window should report button press events. The event mask is the bitwise OR of values from the `EventMask` enumeration.

See the [input handling overview][event-masks] for details.

## setFocusOnMap

windowSetFocusOnMap Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a toplevel `Window`
-> Bool | `focusOnMap`: `True` if the window should receive input focus when mapped
-> m () |

Setting `focusOnMap` to `False` hints the desktop environment that the window doesn’t want to receive input focus when it is mapped. focus_on_map should be turned off for windows that aren’t triggered interactively (such as popups from network activity).

On X, it is the responsibility of the window manager to interpret this hint. Window managers following the freedesktop.org window manager extension specification should respect it.

Since: 2.6

## setFullscreenMode

windowSetFullscreenMode Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a toplevel `Window`
-> FullscreenMode | `mode`: fullscreen mode
-> m () |

Specifies whether the `window` should span over all monitors (in a multi-head setup) or only the current monitor when in fullscreen mode.

The `mode` argument is from the `FullscreenMode` enumeration. If `GDK_FULLSCREEN_ON_ALL_MONITORS` is specified, the fullscreen `window` will span over all monitors from the `Screen`.

On X11, searches through the list of monitors from the `Screen` the ones which delimit the 4 edges of the entire `Screen` and will ask the window manager to span the `window` over these monitors.

If the XINERAMA extension is not available or not usable, this function has no effect.

Not all window managers support this, so you can’t rely on the fullscreen window to span over the multiple monitors when `GDK_FULLSCREEN_ON_ALL_MONITORS` is specified.

Since: 3.8

## setFunctions

windowSetFunctions Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a toplevel `Window`
-> [WMFunction] | `functions`: bitmask of operations to allow on `window`
-> m () |

Sets hints about the window management functions to make available via buttons on the window frame.

On the X backend, this function sets the traditional Motif window manager hint for this purpose. However, few window managers do anything reliable or interesting with this hint. Many ignore it entirely.

The `functions` argument is the logical OR of values from the `WMFunction` enumeration. If the bitmask includes `GDK_FUNC_ALL`, then the other bits indicate which functions to disable; if it doesn’t include `GDK_FUNC_ALL`, it indicates which functions to enable.

## setGeometryHints

windowSetGeometryHints Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a toplevel `Window`
-> Geometry | `geometry`: geometry hints
-> [WindowHints] | `geomMask`: bitmask indicating fields of `geometry` to pay attention to
-> m () |

Sets the geometry hints for `window`. Hints flagged in `geomMask` are set, hints not flagged in `geomMask` are unset. To unset all hints, use a `geomMask` of 0 and a `geometry` of `Nothing`.

This function provides hints to the windowing system about acceptable sizes for a toplevel window. The purpose of this is to constrain user resizing, but the windowing system will typically (but is not required to) also constrain the current size of the window to the provided values and constrain programatic resizing via `windowResize` or `windowMoveResize`.

Note that on X11, this effect has no effect on windows of type `WindowTypeTemp` or windows where override redirect has been turned on via `windowSetOverrideRedirect` since these windows are not resizable by the user.

Since you can’t count on the windowing system doing the constraints for programmatic resizes, you should generally call `windowConstrainSize` yourself to determine appropriate sizes.

## setGroup

windowSetGroup Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a, IsWindow b) |
=> a | `window`: a toplevel `Window`
-> Maybe b | `leader`: group leader window, or `Nothing` to restore the default group leader window
-> m () |

Sets the group leader window for `window`. By default, GDK sets the group leader for all toplevel windows to a global window implicitly created by GDK. With this function you can override this default.

The group leader window allows the window manager to distinguish all windows that belong to a single application. It may for example allow users to minimize/unminimize all windows belonging to an application at once. You should only set a non-default group window if your application pretends to be multiple applications.

## setIconList

windowSetIconList Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a, IsPixbuf b) |
=> a | `window`: The `Window` toplevel window to set the icon of.
-> [b] | `pixbufs`: A list of pixbufs, of different sizes.
-> m () |

Sets a list of icons for the window. One of these will be used to represent the window when it has been iconified. The icon is usually shown in an icon box or some sort of task bar. Which icon size is shown depends on the window manager. The window manager can scale the icon but setting several size icons can give better image quality since the window manager may only need to scale the icon by a small amount or not at all.

Note that some platforms don't support window icons.

## setIconName

windowSetIconName Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a toplevel `Window`
-> Maybe Text | `name`: name of window while iconified (minimized)
-> m () |

Windows may have a name used while minimized, distinct from the name they display in their titlebar. Most of the time this is a bad idea from a user interface standpoint. But you can set such a name with this function, if you like.

After calling this with a non-`Nothing` `name`, calls to `windowSetTitle` will not update the icon title.

Using `Nothing` for `name` unsets the icon title; further calls to `windowSetTitle` will again update the icon title as well.

Note that some platforms don't support window icons.

## setKeepAbove

windowSetKeepAbove Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a toplevel `Window`
-> Bool | `setting`: whether to keep `window` above other windows
-> m () |

Set if `window` must be kept above other windows. If the window was already above, then this function does nothing.

On X11, asks the window manager to keep `window` above, if the window manager supports this operation. Not all window managers support this, and some deliberately ignore it or don’t have a concept of “keep above”; so you can’t rely on the window being kept above. But it will happen with most standard window managers, and GDK makes a best effort to get it to happen.

Since: 2.4

## setKeepBelow

windowSetKeepBelow Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a toplevel `Window`
-> Bool | `setting`: whether to keep `window` below other windows
-> m () |

Set if `window` must be kept below other windows. If the window was already below, then this function does nothing.

On X11, asks the window manager to keep `window` below, if the window manager supports this operation. Not all window managers support this, and some deliberately ignore it or don’t have a concept of “keep below”; so you can’t rely on the window being kept below. But it will happen with most standard window managers, and GDK makes a best effort to get it to happen.

Since: 2.4

## setModalHint

windowSetModalHint Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: A toplevel `Window`
-> Bool | `modal`: `True` if the window is modal, `False` otherwise.
-> m () |

The application can use this hint to tell the window manager that a certain window has modal behaviour. The window manager can use this information to handle modal windows in a special way.

You should only use this on windows for which you have previously called `windowSetTransientFor`

## setOpacity

windowSetOpacity Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a top-level or non-native `Window`
-> Double | `opacity`: opacity
-> m () |

Set `window` to render as partially transparent, with opacity 0 being fully transparent and 1 fully opaque. (Values of the opacity parameter are clamped to the [0,1] range.)

For toplevel windows this depends on support from the windowing system that may not always be there. For instance, On X11, this works only on X screens with a compositing manager running. On Wayland, there is no per-window opacity value that the compositor would apply. Instead, use `gdk_window_set_opaque_region (window, NULL)` to tell the compositor that the entire window is (potentially) non-opaque, and draw your content with alpha, or use `gtk_widget_set_opacity()` to set an overall opacity for your widgets.

For child windows this function only works for non-native windows.

For setting up per-pixel alpha topelevels, see `screenGetRgbaVisual`, and for non-toplevels, see `windowSetComposited`.

Support for non-toplevel windows was added in 3.8.

Since: 2.12

## setOpaqueRegion

windowSetOpaqueRegion Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a top-level or non-native `Window`
-> Maybe Region | `region`: a region, or `Nothing`
-> m () |

For optimisation purposes, compositing window managers may like to not draw obscured regions of windows, or turn off blending during for these regions. With RGB windows with no transparency, this is just the shape of the window, but with ARGB32 windows, the compositor does not know what regions of the window are transparent or not.

This function only works for toplevel windows.

GTK+ will update this property automatically if the `window` background is opaque, as we know where the opaque regions are. If your window background is not opaque, please update this property in your `GtkWidget::style-updated` handler.

Since: 3.10

## setOverrideRedirect

windowSetOverrideRedirect Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a toplevel `Window`
-> Bool | `overrideRedirect`: `True` if window should be override redirect
-> m () |

An override redirect window is not under the control of the window manager. This means it won’t have a titlebar, won’t be minimizable, etc. - it will be entirely under the control of the application. The window manager can’t see the override redirect window at all.

Override redirect should only be used for short-lived temporary windows, such as popup menus. `GtkMenu` uses an override redirect window in its implementation, for example.

## setPassThrough

windowSetPassThrough Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> Bool | `passThrough`: a boolean
-> m () |

Sets whether input to the window is passed through to the window below.

The default value of this is `False`, which means that pointer events that happen inside the window are send first to the window, but if the event is not selected by the event mask then the event is sent to the parent window, and so on up the hierarchy.

If `passThrough` is `True` then such pointer events happen as if the window wasn't there at all, and thus will be sent first to any windows below `window`. This is useful if the window is used in a transparent fashion. In the terminology of the web this would be called "pointer-events: none".

Note that a window with `passThrough` `True` can still have a subwindow without pass through, so you can get events on a subset of a window. And in that cases you would get the in-between related events such as the pointer enter/leave events on its way to the destination window.

Since: 3.18

## setRole

windowSetRole Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a toplevel `Window`
-> Text | `role`: a string indicating its role
-> m () |

When using GTK+, typically you should use `gtk_window_set_role()` instead of this low-level function.

The window manager and session manager use a window’s role to distinguish it from other kinds of window in the same application. When an application is restarted after being saved in a previous session, all windows with the same title and role are treated as interchangeable. So if you have two windows with the same title that should be distinguished for session management purposes, you should set the role on those windows. It doesn’t matter what string you use for the role, as long as you have a different role for each non-interchangeable kind of window.

## setShadowWidth

windowSetShadowWidth Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> Int32 | `left`: The left extent
-> Int32 | `right`: The right extent
-> Int32 | `top`: The top extent
-> Int32 | `bottom`: The bottom extent
-> m () |

Newer GTK+ windows using client-side decorations use extra geometry around their frames for effects like shadows and invisible borders. Window managers that want to maximize windows or snap to edges need to know where the extents of the actual frame lie, so that users don’t feel like windows are snapping against random invisible edges.

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.12

## setSkipPagerHint

windowSetSkipPagerHint Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a toplevel `Window`
-> Bool | `skipsPager`: `True` to skip the pager
-> m () |

Toggles whether a window should appear in a pager (workspace switcher, or other desktop utility program that displays a small thumbnail representation of the windows on the desktop). If a window’s semantic type as specified with `windowSetTypeHint` already fully describes the window, this function should not be called in addition, instead you should allow the window to be treated according to standard policy for its semantic type.

Since: 2.2

## setSkipTaskbarHint

windowSetSkipTaskbarHint Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a toplevel `Window`
-> Bool | `skipsTaskbar`: `True` to skip the taskbar
-> m () |

Toggles whether a window should appear in a task list or window list. If a window’s semantic type as specified with `windowSetTypeHint` already fully describes the window, this function should not be called in addition, instead you should allow the window to be treated according to standard policy for its semantic type.

Since: 2.2

## setSourceEvents

windowSetSourceEvents Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> InputSource | `source`: a `InputSource` to define the source class.
-> [EventMask] | `eventMask`: event mask for `window`
-> m () |

Sets the event mask for any floating device (i.e. not attached to any visible pointer) that has the source defined as `source`. This event mask will be applied both to currently existing, newly added devices after this call, and devices being attached/detached.

Since: 3.0

## setStartupId

windowSetStartupId Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a toplevel `Window`
-> Text | `startupId`: a string with startup-notification identifier
-> m () |

When using GTK+, typically you should use `gtk_window_set_startup_id()` instead of this low-level function.

Since: 2.12

## setStaticGravities

windowSetStaticGravities Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> Bool | `useStatic`: `True` to turn on static gravity
-> m Bool | Returns: `False`

Deprecated: (Since version 3.16)static gravities haven't worked on anything but X11 for a long time.

Used to set the bit gravity of the given window to static, and flag it so all children get static subwindow gravity. This is used if you are implementing scary features that involve deep knowledge of the windowing system. Don’t worry about it.

## setSupportMultidevice

windowSetSupportMultidevice Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`.
-> Bool | `supportMultidevice`: `True` to enable multidevice support in `window`.
-> m () |

This function will enable multidevice features in `window`.

Multidevice aware windows will need to handle properly multiple, per device enter/leave events, device grabs and grab ownerships.

Since: 3.0

## setTitle

windowSetTitle Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a toplevel `Window`
-> Text | `title`: title of `window`
-> m () |

Sets the title of a toplevel window, to be displayed in the titlebar. If you haven’t explicitly set the icon name for the window (using `windowSetIconName`), the icon name will be set to `title` as well. `title` must be in UTF-8 encoding (as with all user-readable strings in GDK/GTK+). `title` may not be `Nothing`.

## setTransientFor

windowSetTransientFor Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a, IsWindow b) |
=> a | `window`: a toplevel `Window`
-> b | `parent`: another toplevel `Window`
-> m () |

Indicates to the window manager that `window` is a transient dialog associated with the application window `parent`. This allows the window manager to do things like center `window` on `parent` and keep `window` above `parent`.

See `gtk_window_set_transient_for()` if you’re using `GtkWindow` or `GtkDialog`.

## setTypeHint

windowSetTypeHint Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: A toplevel `Window`
-> WindowTypeHint | `hint`: A hint of the function this window will have
-> m () |

The application can use this call to provide a hint to the window manager about the functionality of a window. The window manager can use this information when determining the decoration and behaviour of the window.

The hint must be set before the window is mapped.

## setUrgencyHint

windowSetUrgencyHint Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a toplevel `Window`
-> Bool | `urgent`: `True` if the window is urgent
-> m () |

Toggles whether a window needs the user's urgent attention.

Since: 2.8

## setUserData

windowSetUserData Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a, IsObject b) |
=> a | `window`: a `Window`
-> Maybe b | `userData`: user data
-> m () |

For most purposes this function is deprecated in favor of `objectSetData`. However, for historical reasons GTK+ stores the `GtkWidget` that owns a `Window` as user data on the `Window`. So, custom widget implementations should use this function for that. If GTK+ receives an event for a `Window`, and the user data for the window is non-`Nothing`, GTK+ will assume the user data is a `GtkWidget`, and forward the event to that widget.

## shapeCombineRegion

windowShapeCombineRegion Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> Maybe Region | `shapeRegion`: region of window to be non-transparent
-> Int32 | `offsetX`: X position of `shapeRegion` in `window` coordinates
-> Int32 | `offsetY`: Y position of `shapeRegion` in `window` coordinates
-> m () |

Makes pixels in `window` outside `shapeRegion` be transparent, so that the window may be nonrectangular.

If `shapeRegion` is `Nothing`, the shape will be unset, so the whole window will be opaque again. `offsetX` and `offsetY` are ignored if `shapeRegion` is `Nothing`.

On the X11 platform, this uses an X server extension which is widely available on most common platforms, but not available on very old X servers, and occasionally the implementation will be buggy. On servers without the shape extension, this function will do nothing.

This function works on both toplevel and child windows.

## show

windowShow Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> m () |

Like `windowShowUnraised`, but also raises the window to the top of the window stack (moves the window to the front of the Z-order).

This function maps a window so it’s visible onscreen. Its opposite is `windowHide`.

When implementing a `GtkWidget`, you should call this function on the widget's `Window` as part of the “map” method.

## showUnraised

windowShowUnraised Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> m () |

Shows a `Window` onscreen, but does not modify its stacking order. In contrast, `windowShow` will raise the window to the top of the window stack.

On the X11 platform, in Xlib terms, this function calls `XMapWindow()` (it also updates some internal GDK state, which means that you can’t really use `XMapWindow()` directly on a GDK window).

## showWindowMenu

windowShowWindowMenu Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> Event | `event`: a `Event` to show the menu for
-> m Bool | Returns: `True` if the window menu was shown and `False` otherwise.

Asks the windowing system to show the window menu. The window menu is the menu shown when right-clicking the titlebar on traditional windows managed by the window manager. This is useful for windows using client-side decorations, activating it with a right-click on the window decorations.

Since: 3.14

## stick

windowStick Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a toplevel `Window`
-> m () |

“Pins” a window such that it’s on all workspaces and does not scroll with viewports, for window managers that have scrollable viewports. (When using `GtkWindow`, `gtk_window_stick()` may be more useful.)

On the X11 platform, this function depends on window manager support, so may have no effect with many window managers. However, GDK will do the best it can to convince the window manager to stick the window. For window managers that don’t support this operation, there’s nothing you can do to force it to happen.

## thawToplevelUpdatesLibgtkOnly

windowThawToplevelUpdatesLibgtkOnly Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> m () |

Deprecated: (Since version 3.16)This symbol was never meant to be used outside of GTK+

Thaws a window frozen with `windowFreezeToplevelUpdatesLibgtkOnly`.

This function is not part of the GDK public API and is only for use by GTK+.

## thawUpdates

windowThawUpdates Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a `Window`
-> m () |

Thaws a window frozen with `windowFreezeUpdates`.

## unfullscreen

windowUnfullscreen Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a toplevel `Window`
-> m () |

Moves the window out of fullscreen mode. If the window was not fullscreen, does nothing.

On X11, asks the window manager to move `window` out of the fullscreen state, if the window manager supports this operation. Not all window managers support this, and some deliberately ignore it or don’t have a concept of “fullscreen”; so you can’t rely on the unfullscreenification actually happening. But it will happen with most standard window managers, and GDK makes a best effort to get it to happen.

Since: 2.2

## unmaximize

windowUnmaximize Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a toplevel `Window`
-> m () |

Unmaximizes the window. If the window wasn’t maximized, then this function does nothing.

On X11, asks the window manager to unmaximize `window`, if the window manager supports this operation. Not all window managers support this, and some deliberately ignore it or don’t have a concept of “maximized”; so you can’t rely on the unmaximization actually happening. But it will happen with most standard window managers, and GDK makes a best effort to get it to happen.

On Windows, reliably unmaximizes the window.

## unstick

windowUnstick Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a toplevel `Window`
-> m () |

Reverse operation for `windowStick`; see `windowStick`, and `gtk_window_unstick()`.

## withdraw

windowWithdraw Source #

Arguments

:: (HasCallStack, MonadIO m, IsWindow a) |
=> a | `window`: a toplevel `Window`
-> m () |

Withdraws a window (unmaps it and asks the window manager to forget about it). This function is not really useful as `windowHide` automatically withdraws toplevel windows before hiding them.

# Properties

## cursor

The mouse pointer for a `Window`. See `windowSetCursor` and `windowGetCursor` for details.

Since: 2.18

clearWindowCursor :: (MonadIO m, IsWindow o) => o -> m () Source #

Set the value of the “`cursor`” property to `Nothing`. When overloading is enabled, this is equivalent to

    clear #cursor

constructWindowCursor :: (IsWindow o, MonadIO m, IsCursor a) => a -> m (GValueConstruct o) Source #

Construct a `GValueConstruct` with valid value for the “`cursor`” property. This is rarely needed directly, but it is used by `new`.

getWindowCursor :: (MonadIO m, IsWindow o) => o -> m (Maybe Cursor) Source #

Get the value of the “`cursor`” property. When overloading is enabled, this is equivalent to

    get window #cursor

setWindowCursor :: (MonadIO m, IsWindow o, IsCursor a) => o -> a -> m () Source #

Set the value of the “`cursor`” property. When overloading is enabled, this is equivalent to

    set window [ #cursor := value ]

# Signals

## createSurface

type WindowCreateSurfaceCallback Source #

Arguments

= Int32 | `width`: the width of the offscreen surface to create
-> Int32 | `height`: the height of the offscreen surface to create
-> IO Surface | Returns: the newly created `Surface` for the offscreen window

The createSurface signal is emitted when an offscreen window needs its surface (re)created, which happens either when the window is first drawn to, or when the window is being resized. The first signal handler that returns a non-`Nothing` surface will stop any further signal emission, and its surface will be used.

Note that it is not possible to access the window's previous surface from within any callback of this signal. Calling `offscreenWindowGetSurface` will lead to a crash.

Since: 3.0

afterWindowCreateSurface :: (IsWindow a, MonadIO m) => a -> ((?self :: a) => WindowCreateSurfaceCallback) -> m SignalHandlerId Source #

Connect a signal handler for the createSurface signal, to be run after the default handler. When overloading is enabled, this is equivalent to

    after window #createSurface callback

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit `?self` parameter. Note that this requires activating the `ImplicitParams` GHC extension.

onWindowCreateSurface :: (IsWindow a, MonadIO m) => a -> ((?self :: a) => WindowCreateSurfaceCallback) -> m SignalHandlerId Source #

Connect a signal handler for the createSurface signal, to be run before the default handler. When overloading is enabled, this is equivalent to

    on window #createSurface callback

## fromEmbedder

type WindowFromEmbedderCallback Source #

Arguments

= Double | `embedderX`: x coordinate in the embedder window
-> Double | `embedderY`: y coordinate in the embedder window
-> IO (Double, Double) |

The fromEmbedder signal is emitted to translate coordinates in the embedder of an offscreen window to the offscreen window.

See also Window::toEmbedder.

Since: 2.18

afterWindowFromEmbedder :: (IsWindow a, MonadIO m) => a -> ((?self :: a) => WindowFromEmbedderCallback) -> m SignalHandlerId Source #

Connect a signal handler for the fromEmbedder signal, to be run after the default handler. When overloading is enabled, this is equivalent to

    after window #fromEmbedder callback

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit `?self` parameter. Note that this requires activating the `ImplicitParams` GHC extension.

onWindowFromEmbedder :: (IsWindow a, MonadIO m) => a -> ((?self :: a) => WindowFromEmbedderCallback) -> m SignalHandlerId Source #

Connect a signal handler for the fromEmbedder signal, to be run before the default handler. When overloading is enabled, this is equivalent to

    on window #fromEmbedder callback

## movedToRect

type WindowMovedToRectCallback Source #

Arguments

= Ptr () | `flippedRect`: the position of `window` after any possible flipping or `Nothing` if the backend can't obtain it
-> Ptr () | `finalRect`: the final position of `window` or `Nothing` if the backend can't obtain it
-> Bool | `flippedX`: `True` if the anchors were flipped horizontally
-> Bool | `flippedY`: `True` if the anchors were flipped vertically
-> IO () |

Emitted when the position of `window` is finalized after being moved to a destination rectangle.

`window` might be flipped over the destination rectangle in order to keep it on-screen, in which case `flippedX` and `flippedY` will be set to `True` accordingly.

`flippedRect` is the ideal position of `window` after any possible flipping, but before any possible sliding. `finalRect` is `flippedRect`, but possibly translated in the case that flipping is still ineffective in keeping `window` on-screen.

Since: 3.22

afterWindowMovedToRect :: (IsWindow a, MonadIO m) => a -> ((?self :: a) => WindowMovedToRectCallback) -> m SignalHandlerId Source #

Connect a signal handler for the movedToRect signal, to be run after the default handler. When overloading is enabled, this is equivalent to

    after window #movedToRect callback

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit `?self` parameter. Note that this requires activating the `ImplicitParams` GHC extension.

onWindowMovedToRect :: (IsWindow a, MonadIO m) => a -> ((?self :: a) => WindowMovedToRectCallback) -> m SignalHandlerId Source #

Connect a signal handler for the movedToRect signal, to be run before the default handler. When overloading is enabled, this is equivalent to

    on window #movedToRect callback

## pickEmbeddedChild

type WindowPickEmbeddedChildCallback Source #

Arguments

= Double | `x`: x coordinate in the window
-> Double | `y`: y coordinate in the window
-> IO (Maybe Window) | Returns: the `Window` of the embedded child at `x`, `y`, or `Nothing`

The pickEmbeddedChild signal is emitted to find an embedded child at the given position.

Since: 2.18

afterWindowPickEmbeddedChild :: (IsWindow a, MonadIO m) => a -> ((?self :: a) => WindowPickEmbeddedChildCallback) -> m SignalHandlerId Source #

Connect a signal handler for the pickEmbeddedChild signal, to be run after the default handler. When overloading is enabled, this is equivalent to

    after window #pickEmbeddedChild callback

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit `?self` parameter. Note that this requires activating the `ImplicitParams` GHC extension.

onWindowPickEmbeddedChild :: (IsWindow a, MonadIO m) => a -> ((?self :: a) => WindowPickEmbeddedChildCallback) -> m SignalHandlerId Source #

Connect a signal handler for the pickEmbeddedChild signal, to be run before the default handler. When overloading is enabled, this is equivalent to

    on window #pickEmbeddedChild callback

## toEmbedder

type WindowToEmbedderCallback Source #

Arguments

= Double | `offscreenX`: x coordinate in the offscreen window
-> Double | `offscreenY`: y coordinate in the offscreen window
-> IO (Double, Double) |

The toEmbedder signal is emitted to translate coordinates in an offscreen window to its embedder.

See also Window::fromEmbedder.

Since: 2.18

afterWindowToEmbedder :: (IsWindow a, MonadIO m) => a -> ((?self :: a) => WindowToEmbedderCallback) -> m SignalHandlerId Source #

Connect a signal handler for the toEmbedder signal, to be run after the default handler. When overloading is enabled, this is equivalent to

    after window #toEmbedder callback

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit `?self` parameter. Note that this requires activating the `ImplicitParams` GHC extension.

onWindowToEmbedder :: (IsWindow a, MonadIO m) => a -> ((?self :: a) => WindowToEmbedderCallback) -> m SignalHandlerId Source #

Connect a signal handler for the toEmbedder signal, to be run before the default handler. When overloading is enabled, this is equivalent to

    on window #toEmbedder callback