gi-gtk3-3.0.44: Gtk 3.x bindings

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

GI.Gtk.Objects.GLArea

Contents

- Exported types
- Methods
  - attachBuffers
  - getAutoRender
  - getContext
  - getError
  - getHasAlpha
  - getHasDepthBuffer
  - getHasStencilBuffer
  - getRequiredVersion
  - getUseEs
  - makeCurrent
  - new
  - queueRender
  - setAutoRender
  - setError
  - setHasAlpha
  - setHasDepthBuffer
  - setHasStencilBuffer
  - setRequiredVersion
  - setUseEs
- Properties
  - autoRender
  - context
  - hasAlpha
  - hasDepthBuffer
  - hasStencilBuffer
  - useEs
- Signals
  - createContext
  - render
  - resize

Description

`GLArea` is a widget that allows drawing with OpenGL.

`GLArea` sets up its own `GLContext` for the window it creates, and creates a custom GL framebuffer that the widget will do GL rendering onto. It also ensures that this framebuffer is the default GL rendering target when rendering.

In order to draw, you have to connect to the GLArea::render signal, or subclass `GLArea` and override the `gtkGLAreaClass`.`render()` virtual function.

The `GLArea` widget ensures that the `GLContext` is associated with the widget's drawing area, and it is kept updated when the size and position of the drawing area changes.

## Drawing with GtkGLArea

The simplest way to draw using OpenGL commands in a `GLArea` is to create a widget instance and connect to the GLArea::render signal:

### C code

     // create a GtkGLArea instance
     GtkWidget *gl_area = gtk_gl_area_new ();

     // connect to the "render" signal
     g_signal_connect (gl_area, "render", G_CALLBACK (render), NULL);

The `render()` function will be called when the `GLArea` is ready for you to draw its content:

### C code

     static gboolean
     render (GtkGLArea *area, GdkGLContext *context)
     {
       // inside this function it's safe to use GL; the given
       // #GdkGLContext has been made current to the drawable
       // surface used by the #GtkGLArea and the viewport has
       // already been set to be the size of the allocation

       // we can start by clearing the buffer
       glClearColor (0, 0, 0, 0);
       glClear (GL_COLOR_BUFFER_BIT);

       // draw your object
       draw_an_object ();

       // we completed our drawing; the draw commands will be
       // flushed at the end of the signal emission chain, and
       // the buffers will be drawn on the window
       return TRUE;
     }

If you need to initialize OpenGL state, e.g. buffer objects or shaders, you should use the Widget::realize signal; you can use the Widget::unrealize signal to clean up. Since the `GLContext` creation and initialization may fail, you will need to check for errors, using `gLAreaGetError`. An example of how to safely initialize the GL state is:

### C code

     static void
     on_realize (GtkGLarea *area)
     {
       // We need to make the context current if we want to
       // call GL API
       gtk_gl_area_make_current (area);

       // If there were errors during the initialization or
       // when trying to make the context current, this
       // function will return a #GError for you to catch
       if (gtk_gl_area_get_error (area) != NULL)
         return;

       // You can also use gtk_gl_area_set_error() in order
       // to show eventual initialization errors on the
       // GtkGLArea widget itself
       GError *internal_error = NULL;
       init_buffer_objects (&error);
       if (error != NULL)
         {
           gtk_gl_area_set_error (area, error);
           g_error_free (error);
           return;
         }

       init_shaders (&error);
       if (error != NULL)
         {
           gtk_gl_area_set_error (area, error);
           g_error_free (error);
           return;
         }
     }

If you need to change the options for creating the `GLContext` you should use the GLArea::createContext signal.

Since: 3.16

Synopsis

- newtype GLArea = GLArea (ManagedPtr GLArea)
- class (GObject o, IsDescendantOf GLArea o) => IsGLArea o
- toGLArea :: (MonadIO m, IsGLArea o) => o -> m GLArea
- gLAreaAttachBuffers :: (HasCallStack, MonadIO m, IsGLArea a) => a -> m ()
- gLAreaGetAutoRender :: (HasCallStack, MonadIO m, IsGLArea a) => a -> m Bool
- gLAreaGetContext :: (HasCallStack, MonadIO m, IsGLArea a) => a -> m GLContext
- gLAreaGetError :: (HasCallStack, MonadIO m, IsGLArea a) => a -> m (Maybe GError)
- gLAreaGetHasAlpha :: (HasCallStack, MonadIO m, IsGLArea a) => a -> m Bool
- gLAreaGetHasDepthBuffer :: (HasCallStack, MonadIO m, IsGLArea a) => a -> m Bool
- gLAreaGetHasStencilBuffer :: (HasCallStack, MonadIO m, IsGLArea a) => a -> m Bool
- gLAreaGetRequiredVersion :: (HasCallStack, MonadIO m, IsGLArea a) => a -> m (Int32, Int32)
- gLAreaGetUseEs :: (HasCallStack, MonadIO m, IsGLArea a) => a -> m Bool
- gLAreaMakeCurrent :: (HasCallStack, MonadIO m, IsGLArea a) => a -> m ()
- gLAreaNew :: (HasCallStack, MonadIO m) => m GLArea
- gLAreaQueueRender :: (HasCallStack, MonadIO m, IsGLArea a) => a -> m ()
- gLAreaSetAutoRender :: (HasCallStack, MonadIO m, IsGLArea a) => a -> Bool -> m ()
- gLAreaSetError :: (HasCallStack, MonadIO m, IsGLArea a) => a -> Maybe GError -> m ()
- gLAreaSetHasAlpha :: (HasCallStack, MonadIO m, IsGLArea a) => a -> Bool -> m ()
- gLAreaSetHasDepthBuffer :: (HasCallStack, MonadIO m, IsGLArea a) => a -> Bool -> m ()
- gLAreaSetHasStencilBuffer :: (HasCallStack, MonadIO m, IsGLArea a) => a -> Bool -> m ()
- gLAreaSetRequiredVersion :: (HasCallStack, MonadIO m, IsGLArea a) => a -> Int32 -> Int32 -> m ()
- gLAreaSetUseEs :: (HasCallStack, MonadIO m, IsGLArea a) => a -> Bool -> m ()
- constructGLAreaAutoRender :: (IsGLArea o, MonadIO m) => Bool -> m (GValueConstruct o)
- getGLAreaAutoRender :: (MonadIO m, IsGLArea o) => o -> m Bool
- setGLAreaAutoRender :: (MonadIO m, IsGLArea o) => o -> Bool -> m ()
- getGLAreaContext :: (MonadIO m, IsGLArea o) => o -> m GLContext
- constructGLAreaHasAlpha :: (IsGLArea o, MonadIO m) => Bool -> m (GValueConstruct o)
- getGLAreaHasAlpha :: (MonadIO m, IsGLArea o) => o -> m Bool
- setGLAreaHasAlpha :: (MonadIO m, IsGLArea o) => o -> Bool -> m ()
- constructGLAreaHasDepthBuffer :: (IsGLArea o, MonadIO m) => Bool -> m (GValueConstruct o)
- getGLAreaHasDepthBuffer :: (MonadIO m, IsGLArea o) => o -> m Bool
- setGLAreaHasDepthBuffer :: (MonadIO m, IsGLArea o) => o -> Bool -> m ()
- constructGLAreaHasStencilBuffer :: (IsGLArea o, MonadIO m) => Bool -> m (GValueConstruct o)
- getGLAreaHasStencilBuffer :: (MonadIO m, IsGLArea o) => o -> m Bool
- setGLAreaHasStencilBuffer :: (MonadIO m, IsGLArea o) => o -> Bool -> m ()
- constructGLAreaUseEs :: (IsGLArea o, MonadIO m) => Bool -> m (GValueConstruct o)
- getGLAreaUseEs :: (MonadIO m, IsGLArea o) => o -> m Bool
- setGLAreaUseEs :: (MonadIO m, IsGLArea o) => o -> Bool -> m ()
- type GLAreaCreateContextCallback = IO GLContext
- afterGLAreaCreateContext :: (IsGLArea a, MonadIO m) => a -> ((?self :: a) => GLAreaCreateContextCallback) -> m SignalHandlerId
- onGLAreaCreateContext :: (IsGLArea a, MonadIO m) => a -> ((?self :: a) => GLAreaCreateContextCallback) -> m SignalHandlerId
- type GLAreaRenderCallback = GLContext -> IO Bool
- afterGLAreaRender :: (IsGLArea a, MonadIO m) => a -> ((?self :: a) => GLAreaRenderCallback) -> m SignalHandlerId
- onGLAreaRender :: (IsGLArea a, MonadIO m) => a -> ((?self :: a) => GLAreaRenderCallback) -> m SignalHandlerId
- type GLAreaResizeCallback = Int32 -> Int32 -> IO ()
- afterGLAreaResize :: (IsGLArea a, MonadIO m) => a -> ((?self :: a) => GLAreaResizeCallback) -> m SignalHandlerId
- onGLAreaResize :: (IsGLArea a, MonadIO m) => a -> ((?self :: a) => GLAreaResizeCallback) -> m SignalHandlerId

# Exported types

newtype GLArea Source #

Memory-managed wrapper type.

Constructors

GLArea (ManagedPtr GLArea) |

#### Instances

Instances details

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

class (GObject o, IsDescendantOf GLArea o) => IsGLArea o Source #

Type class for types which can be safely cast to `GLArea`, for instance with `toGLArea`.

#### Instances

Instances details

(GObject o, IsDescendantOf GLArea o) => IsGLArea o Source # |
Instance details Defined in GI.Gtk.Objects.GLArea

toGLArea :: (MonadIO m, IsGLArea o) => o -> m GLArea Source #

Cast to `GLArea`, 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

activate, addAccelerator, addChild, addDeviceEvents, addEvents, addMnemonicLabel, addTickCallback, attachBuffers, bindProperty, bindPropertyFull, canActivateAccel, childFocus, childNotify, classPath, computeExpand, constructChild, createPangoContext, createPangoLayout, customFinished, customTagEnd, customTagStart, destroy, destroyed, deviceIsShadowed, dragBegin, dragBeginWithCoordinates, dragCheckThreshold, dragDestAddImageTargets, dragDestAddTextTargets, dragDestAddUriTargets, dragDestFindTarget, dragDestGetTargetList, dragDestGetTrackMotion, dragDestSet, dragDestSetProxy, dragDestSetTargetList, dragDestSetTrackMotion, dragDestUnset, dragGetData, dragHighlight, dragSourceAddImageTargets, dragSourceAddTextTargets, dragSourceAddUriTargets, dragSourceGetTargetList, dragSourceSet, dragSourceSetIconGicon, dragSourceSetIconName, dragSourceSetIconPixbuf, dragSourceSetIconStock, dragSourceSetTargetList, dragSourceUnset, dragUnhighlight, draw, ensureStyle, errorBell, event, forceFloating, freezeChildNotify, freezeNotify, getv, grabAdd, grabDefault, grabFocus, grabRemove, hasDefault, hasFocus, hasGrab, hasRcStyle, hasScreen, hasVisibleFocus, hide, hideOnDelete, inDestruction, initTemplate, inputShapeCombineRegion, insertActionGroup, intersect, isAncestor, isComposited, isDrawable, isFloating, isFocus, isSensitive, isToplevel, isVisible, keynavFailed, listAccelClosures, listActionPrefixes, listMnemonicLabels, makeCurrent, map, mnemonicActivate, modifyBase, modifyBg, modifyCursor, modifyFg, modifyFont, modifyStyle, modifyText, notify, notifyByPspec, overrideBackgroundColor, overrideColor, overrideCursor, overrideFont, overrideSymbolicColor, parserFinished, path, queueAllocate, queueComputeExpand, queueDraw, queueDrawArea, queueDrawRegion, queueRender, queueResize, queueResizeNoRedraw, realize, ref, refSink, regionIntersect, registerWindow, removeAccelerator, removeMnemonicLabel, removeTickCallback, renderIcon, renderIconPixbuf, reparent, resetRcStyles, resetStyle, runDispose, sendExpose, sendFocusChange, shapeCombineRegion, show, showAll, showNow, sizeAllocate, sizeAllocateWithBaseline, sizeRequest, stealData, stealQdata, styleAttach, styleGetProperty, thawChildNotify, thawNotify, translateCoordinates, triggerTooltipQuery, unmap, unparent, unrealize, unref, unregisterWindow, unsetStateFlags, watchClosure.

#### Getters

getAccessible, getActionGroup, getAllocatedBaseline, getAllocatedHeight, getAllocatedSize, getAllocatedWidth, getAllocation, getAncestor, getAppPaintable, getAutoRender, getCanDefault, getCanFocus, getChildRequisition, getChildVisible, getClip, getClipboard, getCompositeName, getContext, getData, getDeviceEnabled, getDeviceEvents, getDirection, getDisplay, getDoubleBuffered, getError, getEvents, getFocusOnClick, getFontMap, getFontOptions, getFrameClock, getHalign, getHasAlpha, getHasDepthBuffer, getHasStencilBuffer, getHasTooltip, getHasWindow, getHexpand, getHexpandSet, getInternalChild, getMapped, getMarginBottom, getMarginEnd, getMarginLeft, getMarginRight, getMarginStart, getMarginTop, getModifierMask, getModifierStyle, getName, getNoShowAll, getOpacity, getPangoContext, getParent, getParentWindow, getPath, getPointer, getPreferredHeight, getPreferredHeightAndBaselineForWidth, getPreferredHeightForWidth, getPreferredSize, getPreferredWidth, getPreferredWidthForHeight, getProperty, getQdata, getRealized, getReceivesDefault, getRequestMode, getRequiredVersion, getRequisition, getRootWindow, getScaleFactor, getScreen, getSensitive, getSettings, getSizeRequest, getState, getStateFlags, getStyle, getStyleContext, getSupportMultidevice, getTemplateChild, getTooltipMarkup, getTooltipText, getTooltipWindow, getToplevel, getUseEs, getValign, getValignWithBaseline, getVexpand, getVexpandSet, getVisible, getVisual, getWindow.

#### Setters

setAccelPath, setAllocation, setAppPaintable, setAutoRender, setBuildableProperty, setCanDefault, setCanFocus, setChildVisible, setClip, setCompositeName, setData, setDataFull, setDeviceEnabled, setDeviceEvents, setDirection, setDoubleBuffered, setError, setEvents, setFocusOnClick, setFontMap, setFontOptions, setHalign, setHasAlpha, setHasDepthBuffer, setHasStencilBuffer, setHasTooltip, setHasWindow, setHexpand, setHexpandSet, setMapped, setMarginBottom, setMarginEnd, setMarginLeft, setMarginRight, setMarginStart, setMarginTop, setName, setNoShowAll, setOpacity, setParent, setParentWindow, setProperty, setRealized, setReceivesDefault, setRedrawOnAllocate, setRequiredVersion, setSensitive, setSizeRequest, setState, setStateFlags, setStyle, setSupportMultidevice, setTooltipMarkup, setTooltipText, setTooltipWindow, setUseEs, setValign, setVexpand, setVexpandSet, setVisible, setVisual, setWindow.

## attachBuffers

gLAreaAttachBuffers Source #

Arguments

:: (HasCallStack, MonadIO m, IsGLArea a) |
=> a | `area`: a `GLArea`
-> m () |

Ensures that the `area` framebuffer object is made the current draw and read target, and that all the required buffers for the `area` are created and bound to the frambuffer.

This function is automatically called before emitting the GLArea::render signal, and doesn't normally need to be called by application code.

Since: 3.16

## getAutoRender

gLAreaGetAutoRender Source #

Arguments

:: (HasCallStack, MonadIO m, IsGLArea a) |
=> a | `area`: a `GLArea`
-> m Bool | Returns: `True` if the `area` is auto rendering, `False` otherwise

Returns whether the area is in auto render mode or not.

Since: 3.16

## getContext

gLAreaGetContext Source #

Arguments

:: (HasCallStack, MonadIO m, IsGLArea a) |
=> a | `area`: a `GLArea`
-> m GLContext | Returns: the `GLContext`

Retrieves the `GLContext` used by `area`.

Since: 3.16

## getError

gLAreaGetError Source #

Arguments

:: (HasCallStack, MonadIO m, IsGLArea a) |
=> a | `area`: a `GLArea`
-> m (Maybe GError) | Returns: the `GError` or `Nothing`

Gets the current error set on the `area`.

Since: 3.16

## getHasAlpha

gLAreaGetHasAlpha Source #

Arguments

:: (HasCallStack, MonadIO m, IsGLArea a) |
=> a | `area`: a `GLArea`
-> m Bool | Returns: `True` if the `area` has an alpha component, `False` otherwise

Returns whether the area has an alpha component.

Since: 3.16

## getHasDepthBuffer

gLAreaGetHasDepthBuffer Source #

Arguments

:: (HasCallStack, MonadIO m, IsGLArea a) |
=> a | `area`: a `GLArea`
-> m Bool | Returns: `True` if the `area` has a depth buffer, `False` otherwise

Returns whether the area has a depth buffer.

Since: 3.16

## getHasStencilBuffer

gLAreaGetHasStencilBuffer Source #

Arguments

:: (HasCallStack, MonadIO m, IsGLArea a) |
=> a | `area`: a `GLArea`
-> m Bool | Returns: `True` if the `area` has a stencil buffer, `False` otherwise

Returns whether the area has a stencil buffer.

Since: 3.16

## getRequiredVersion

gLAreaGetRequiredVersion Source #

Arguments

:: (HasCallStack, MonadIO m, IsGLArea a) |
=> a | `area`: a `GLArea`
-> m (Int32, Int32) |

Retrieves the required version of OpenGL set using `gLAreaSetRequiredVersion`.

Since: 3.16

## getUseEs

gLAreaGetUseEs Source #

Arguments

:: (HasCallStack, MonadIO m, IsGLArea a) |
=> a | `area`: a `GLArea`
-> m Bool | Returns: `True` if the `GLArea` should create an OpenGL ES context and `False` otherwise

Retrieves the value set by `gLAreaSetUseEs`.

Since: 3.22

## makeCurrent

gLAreaMakeCurrent Source #

Arguments

:: (HasCallStack, MonadIO m, IsGLArea a) |
=> a | `area`: a `GLArea`
-> m () |

Ensures that the `GLContext` used by `area` is associated with the `GLArea`.

This function is automatically called before emitting the GLArea::render signal, and doesn't normally need to be called by application code.

Since: 3.16

## new

gLAreaNew Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> m GLArea | Returns: a new `GLArea`

Creates a new `GLArea` widget.

Since: 3.16

## queueRender

gLAreaQueueRender Source #

Arguments

:: (HasCallStack, MonadIO m, IsGLArea a) |
=> a | `area`: a `GLArea`
-> m () |

Marks the currently rendered data (if any) as invalid, and queues a redraw of the widget, ensuring that the GLArea::render signal is emitted during the draw.

This is only needed when the `gLAreaSetAutoRender` has been called with a `False` value. The default behaviour is to emit GLArea::render on each draw.

Since: 3.16

## setAutoRender

gLAreaSetAutoRender Source #

Arguments

:: (HasCallStack, MonadIO m, IsGLArea a) |
=> a | `area`: a `GLArea`
-> Bool | `autoRender`: a boolean
-> m () |

If `autoRender` is `True` the GLArea::render signal will be emitted every time the widget draws. This is the default and is useful if drawing the widget is faster.

If `autoRender` is `False` the data from previous rendering is kept around and will be used for drawing the widget the next time, unless the window is resized. In order to force a rendering `gLAreaQueueRender` must be called. This mode is useful when the scene changes seldomly, but takes a long time to redraw.

Since: 3.16

## setError

gLAreaSetError Source #

Arguments

:: (HasCallStack, MonadIO m, IsGLArea a) |
=> a | `area`: a `GLArea`
-> Maybe GError | `error`: a new `GError`, or `Nothing` to unset the error
-> m () |

Sets an error on the area which will be shown instead of the GL rendering. This is useful in the GLArea::createContext signal if GL context creation fails.

Since: 3.16

## setHasAlpha

gLAreaSetHasAlpha Source #

Arguments

:: (HasCallStack, MonadIO m, IsGLArea a) |
=> a | `area`: a `GLArea`
-> Bool | `hasAlpha`: `True` to add an alpha component
-> m () |

If `hasAlpha` is `True` the buffer allocated by the widget will have an alpha channel component, and when rendering to the window the result will be composited over whatever is below the widget.

If `hasAlpha` is `False` there will be no alpha channel, and the buffer will fully replace anything below the widget.

Since: 3.16

## setHasDepthBuffer

gLAreaSetHasDepthBuffer Source #

Arguments

:: (HasCallStack, MonadIO m, IsGLArea a) |
=> a | `area`: a `GLArea`
-> Bool | `hasDepthBuffer`: `True` to add a depth buffer
-> m () |

If `hasDepthBuffer` is `True` the widget will allocate and enable a depth buffer for the target framebuffer. Otherwise there will be none.

Since: 3.16

## setHasStencilBuffer

gLAreaSetHasStencilBuffer Source #

Arguments

:: (HasCallStack, MonadIO m, IsGLArea a) |
=> a | `area`: a `GLArea`
-> Bool | `hasStencilBuffer`: `True` to add a stencil buffer
-> m () |

If `hasStencilBuffer` is `True` the widget will allocate and enable a stencil buffer for the target framebuffer. Otherwise there will be none.

Since: 3.16

## setRequiredVersion

gLAreaSetRequiredVersion Source #

Arguments

:: (HasCallStack, MonadIO m, IsGLArea a) |
=> a | `area`: a `GLArea`
-> Int32 | `major`: the major version
-> Int32 | `minor`: the minor version
-> m () |

Sets the required version of OpenGL to be used when creating the context for the widget.

This function must be called before the area has been realized.

Since: 3.16

## setUseEs

gLAreaSetUseEs Source #

Arguments

:: (HasCallStack, MonadIO m, IsGLArea a) |
=> a | `area`: a `GLArea`
-> Bool | `useEs`: whether to use OpenGL or OpenGL ES
-> m () |

Sets whether the `area` should create an OpenGL or an OpenGL ES context.

You should check the capabilities of the `GLContext` before drawing with either API.

Since: 3.22

# Properties

## autoRender

If set to `True` the GLArea::render signal will be emitted every time the widget draws. This is the default and is useful if drawing the widget is faster.

If set to `False` the data from previous rendering is kept around and will be used for drawing the widget the next time, unless the window is resized. In order to force a rendering `gLAreaQueueRender` must be called. This mode is useful when the scene changes seldomly, but takes a long time to redraw.

Since: 3.16

constructGLAreaAutoRender :: (IsGLArea o, MonadIO m) => Bool -> m (GValueConstruct o) Source #

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

getGLAreaAutoRender :: (MonadIO m, IsGLArea o) => o -> m Bool Source #

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

    get gLArea #autoRender

setGLAreaAutoRender :: (MonadIO m, IsGLArea o) => o -> Bool -> m () Source #

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

    set gLArea [ #autoRender := value ]

## context

The `GLContext` used by the `GLArea` widget.

The `GLArea` widget is responsible for creating the `GLContext` instance. If you need to render with other kinds of buffers (stencil, depth, etc), use render buffers.

Since: 3.16

getGLAreaContext :: (MonadIO m, IsGLArea o) => o -> m GLContext Source #

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

    get gLArea #context

## hasAlpha

If set to `True` the buffer allocated by the widget will have an alpha channel component, and when rendering to the window the result will be composited over whatever is below the widget.

If set to `False` there will be no alpha channel, and the buffer will fully replace anything below the widget.

Since: 3.16

constructGLAreaHasAlpha :: (IsGLArea o, MonadIO m) => Bool -> m (GValueConstruct o) Source #

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

getGLAreaHasAlpha :: (MonadIO m, IsGLArea o) => o -> m Bool Source #

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

    get gLArea #hasAlpha

setGLAreaHasAlpha :: (MonadIO m, IsGLArea o) => o -> Bool -> m () Source #

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

    set gLArea [ #hasAlpha := value ]

## hasDepthBuffer

If set to `True` the widget will allocate and enable a depth buffer for the target framebuffer.

Since: 3.16

constructGLAreaHasDepthBuffer :: (IsGLArea o, MonadIO m) => Bool -> m (GValueConstruct o) Source #

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

getGLAreaHasDepthBuffer :: (MonadIO m, IsGLArea o) => o -> m Bool Source #

Get the value of the “`has-depth-buffer`” property. When overloading is enabled, this is equivalent to

    get gLArea #hasDepthBuffer

setGLAreaHasDepthBuffer :: (MonadIO m, IsGLArea o) => o -> Bool -> m () Source #

Set the value of the “`has-depth-buffer`” property. When overloading is enabled, this is equivalent to

    set gLArea [ #hasDepthBuffer := value ]

## hasStencilBuffer

If set to `True` the widget will allocate and enable a stencil buffer for the target framebuffer.

Since: 3.16

constructGLAreaHasStencilBuffer :: (IsGLArea o, MonadIO m) => Bool -> m (GValueConstruct o) Source #

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

getGLAreaHasStencilBuffer :: (MonadIO m, IsGLArea o) => o -> m Bool Source #

Get the value of the “`has-stencil-buffer`” property. When overloading is enabled, this is equivalent to

    get gLArea #hasStencilBuffer

setGLAreaHasStencilBuffer :: (MonadIO m, IsGLArea o) => o -> Bool -> m () Source #

Set the value of the “`has-stencil-buffer`” property. When overloading is enabled, this is equivalent to

    set gLArea [ #hasStencilBuffer := value ]

## useEs

If set to `True` the widget will try to create a `GLContext` using OpenGL ES instead of OpenGL.

See also: `gLContextSetUseEs`

Since: 3.22

constructGLAreaUseEs :: (IsGLArea o, MonadIO m) => Bool -> m (GValueConstruct o) Source #

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

getGLAreaUseEs :: (MonadIO m, IsGLArea o) => o -> m Bool Source #

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

    get gLArea #useEs

setGLAreaUseEs :: (MonadIO m, IsGLArea o) => o -> Bool -> m () Source #

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

    set gLArea [ #useEs := value ]

# Signals

## createContext

type GLAreaCreateContextCallback Source #

Arguments

= IO GLContext | Returns: a newly created `GLContext`; the `GLArea` widget will take ownership of the returned value.

The createContext signal is emitted when the widget is being realized, and allows you to override how the GL context is created. This is useful when you want to reuse an existing GL context, or if you want to try creating different kinds of GL options.

If context creation fails then the signal handler can use `gLAreaSetError` to register a more detailed error of how the construction failed.

Since: 3.16

afterGLAreaCreateContext :: (IsGLArea a, MonadIO m) => a -> ((?self :: a) => GLAreaCreateContextCallback) -> m SignalHandlerId Source #

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

    after gLArea #createContext 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.

onGLAreaCreateContext :: (IsGLArea a, MonadIO m) => a -> ((?self :: a) => GLAreaCreateContextCallback) -> m SignalHandlerId Source #

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

    on gLArea #createContext callback

## render

type GLAreaRenderCallback Source #

Arguments

= GLContext | `context`: the `GLContext` used by `area`
-> IO Bool | Returns: `True` to stop other handlers from being invoked for the event. `False` to propagate the event further.

The render signal is emitted every time the contents of the `GLArea` should be redrawn.

The `context` is bound to the `area` prior to emitting this function, and the buffers are painted to the window once the emission terminates.

Since: 3.16

afterGLAreaRender :: (IsGLArea a, MonadIO m) => a -> ((?self :: a) => GLAreaRenderCallback) -> m SignalHandlerId Source #

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

    after gLArea #render 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.

onGLAreaRender :: (IsGLArea a, MonadIO m) => a -> ((?self :: a) => GLAreaRenderCallback) -> m SignalHandlerId Source #

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

    on gLArea #render callback

## resize

type GLAreaResizeCallback Source #

Arguments

= Int32 | `width`: the width of the viewport
-> Int32 | `height`: the height of the viewport
-> IO () |

The resize signal is emitted once when the widget is realized, and then each time the widget is changed while realized. This is useful in order to keep GL state up to date with the widget size, like for instance camera properties which may depend on the width/height ratio.

The GL context for the area is guaranteed to be current when this signal is emitted.

The default handler sets up the GL viewport.

Since: 3.16

afterGLAreaResize :: (IsGLArea a, MonadIO m) => a -> ((?self :: a) => GLAreaResizeCallback) -> m SignalHandlerId Source #

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

    after gLArea #resize 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.

onGLAreaResize :: (IsGLArea a, MonadIO m) => a -> ((?self :: a) => GLAreaResizeCallback) -> m SignalHandlerId Source #

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

    on gLArea #resize callback