Glutin

https://docs.rs/glutin/latest/glutin/
Admin
Glutin is a library that provides an OpenGL context for various platforms, abstracting away...
Tokens:118,458
Snippets:1,204
Trust Score:9.7
Update:4 months ago
Show doc for...
Tokens:
Raw
### Box<T, A> From<T> Example

Source: https://docs.rs/glutin/latest/glutin/api/glx/type.XlibErrorHookRegistrar.html

Example demonstrating the conversion of a value into a Box<T> using Box::from.

```rust
let x = 5;
let boxed = Box::new(5);

assert_eq!(Box::from(x), boxed);
```

--------------------------------

### Box::new Example

Source: https://docs.rs/glutin/latest/glutin/api/glx/type.XlibErrorHookRegistrar.html

Demonstrates the basic usage of Box::new to allocate memory on the heap and place a value into it.

```rust
let five = Box::new(5);

```

--------------------------------

### Box::new_uninit Example

Source: https://docs.rs/glutin/latest/glutin/api/glx/type.XlibErrorHookRegistrar.html

Shows how to construct a Box with uninitialized contents, allowing for deferred initialization. This requires unsafe code to assume initialization.

```rust
let mut five = Box::<u32>::new_uninit();
// Deferred initialization:
five.write(5);
let five = unsafe { five.assume_init() };

assert_eq!(*five, 5)

```

--------------------------------

### Box::try_new_uninit Example (Nightly)

Source: https://docs.rs/glutin/latest/glutin/api/glx/type.XlibErrorHookRegistrar.html

Shows how to attempt to construct a Box with uninitialized contents on the heap, returning an error on allocation failure. This is an experimental API requiring the 'allocator_api' feature.

```rust
#![feature(allocator_api)]

let mut five = Box::<u32>::try_new_uninit()?;
// Deferred initialization:
five.write(5);
let five = unsafe { five.assume_init() };

assert_eq!(*five, 5);

```

--------------------------------

### Create a new ConfigTemplateBuilder

Source: https://docs.rs/glutin/latest/glutin/config/struct.ConfigTemplateBuilder.html

Initializes a new instance of ConfigTemplateBuilder. This is the starting point for defining a graphics configuration template.

```rust
pub fn new() -> Self
```

--------------------------------

### Box::new_zeroed Example (Nightly)

Source: https://docs.rs/glutin/latest/glutin/api/glx/type.XlibErrorHookRegistrar.html

Illustrates creating a Box with memory initialized to zero bytes. This is an experimental API and requires the 'new_zeroed_alloc' feature.

```rust
#![feature(new_zeroed_alloc)]

let zero = Box::<u32>::new_zeroed();
let zero = unsafe { zero.assume_init() };

assert_eq!(*zero, 0)

```

--------------------------------

### Box::try_new Example (Nightly)

Source: https://docs.rs/glutin/latest/glutin/api/glx/type.XlibErrorHookRegistrar.html

Demonstrates attempting to allocate memory on the heap and place a value into it, returning an error if the allocation fails. This is an experimental API requiring the 'allocator_api' feature.

```rust
#![feature(allocator_api)]

let five = Box::try_new(5)?;

```

--------------------------------

### Box::try_new_zeroed Example (Nightly)

Source: https://docs.rs/glutin/latest/glutin/api/glx/type.XlibErrorHookRegistrar.html

Illustrates attempting to create a Box with memory initialized to zero bytes on the heap, returning an error on allocation failure. This is an experimental API requiring the 'allocator_api' feature.

```rust
#![feature(allocator_api)]

let zero = Box::<u32>::try_new_zeroed()?;
let zero = unsafe { zero.assume_init() };

assert_eq!(*zero, 0);

```

--------------------------------

### Box::from_raw Example

Source: https://docs.rs/glutin/latest/glutin/api/glx/type.XlibErrorHookRegistrar.html

Demonstrates constructing a Box from a raw pointer. This is an unsafe operation that transfers ownership of the pointer to the Box.

```rust
let boxed_raw = Box::into_raw(Box::new(5));
let five = unsafe { Box::from_raw(boxed_raw) };

assert_eq!(*five, 5);

```

--------------------------------

### Getting Display Version String

Source: https://docs.rs/glutin/latest/glutin/display/trait.GlDisplay.html

Obtains information about the underlying display, primarily for logging and troubleshooting purposes.

```rust
fn version_string(&self) -> String;
```

--------------------------------

### Get Raw EGLDevice Handle

Source: https://docs.rs/glutin/latest/glutin/api/egl/device/struct.Device.html

Provides a raw handle to the underlying `EGLDeviceEXT`.

```rust
pub fn raw_device(&self) -> EGLDeviceEXT
```

--------------------------------

### Get GLX API reference

Source: https://docs.rs/glutin/latest/glutin/api/glx/display/struct.Display.html

Retrieves a static reference to the initialized GLX API associated with this display.

```rust
pub fn glx(&self) -> &'static Glx
```

--------------------------------

### X11VisualInfo Methods

Source: https://docs.rs/glutin/latest/glutin/platform/x11/struct.X11VisualInfo.html

Provides details on the methods available for the X11VisualInfo struct, including checking for transparency, getting the visual ID, and converting to a raw pointer.

```APIDOC
## X11VisualInfo

### Description
The X11 visual info. This must be used when building X11 window, so it’ll be compatible with the underlying Api.

### Methods

#### `supports_transparency(&self) -> bool`

Returns `true` if the visual has non-zero alpha mask.

#### `visual_id(&self) -> c_ulong`

Get XID of for this visual.

#### `into_raw(self) -> *const c_void`

Convert the visual to the raw pointer. You must clear it with `XFree` after the use.
```

--------------------------------

### Getting References with as_ref()

Source: https://docs.rs/glutin/latest/glutin/error/type.Result.html

Illustrates converting a reference to a Result into a Result of references, leaving the original Result unchanged.

```Rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.as_ref(), Ok(&2));

let x: Result<u32, &str> = Err("Error");
assert_eq!(x.as_ref(), Err(&"Error"));
```

--------------------------------

### Getting Supported Display Features

Source: https://docs.rs/glutin/latest/glutin/display/trait.GlDisplay.html

Retrieves the features supported by the display. This can be used for pre-checking support before attempting operations.

```rust
fn supported_features(&self) -> DisplayFeatures;
```

--------------------------------

### CreateWindow Method

Source: https://docs.rs/glutin/latest/glutin/api/glx/struct.Glx.html

Creates a GLX window. This unsafe function requires a Display pointer, an FBConfig pointer, a window identifier, and an attribute list.

```rust
pub unsafe fn CreateWindow( &self, dpy: *mut Display, config: *const c_void, win: u64, attrib_list: *const i32, ) -> u64
```

--------------------------------

### Get Error Cause (Deprecated)

Source: https://docs.rs/glutin/latest/glutin/error/struct.Error.html

Deprecated method for getting the underlying cause of the error. Use Error::source instead.

```rust
fn cause(&self) -> Option<&dyn Error>
```

--------------------------------

### Get Error Description (Deprecated)

Source: https://docs.rs/glutin/latest/glutin/error/struct.Error.html

Deprecated method for getting a string description of the error. Use the Display implementation or to_string() instead.

```rust
fn description(&self) -> &str
```

--------------------------------

### type_id

Source: https://docs.rs/glutin/latest/glutin/api/glx/struct.Glx.html

Gets the TypeId of the Glx struct.

```APIDOC
## fn type_id(&self) -> TypeId

### Description
Gets the `TypeId` of `self`.

### Method
`type_id`

### Parameters
None

### Returns
`TypeId`
```

--------------------------------

### CreatePlatformWindowSurfaceEXT Method

Source: https://docs.rs/glutin/latest/glutin/api/egl/struct.Egl.html

Creates a platform-specific EGL window surface using the EXT extension. This unsafe function requires display, configuration, native window, and attribute list.

```rust
pub unsafe fn CreatePlatformWindowSurfaceEXT( &self, dpy: *const c_void, config: *const c_void, native_window: *mut c_void, attrib_list: *const i32, ) -> *const c_void
```

--------------------------------

### PossiblyCurrentContext::raw_context

Source: https://docs.rs/glutin/latest/glutin/api/glx/context/struct.PossiblyCurrentContext.html

Get the raw context handle.

```APIDOC
## PossiblyCurrentContext::raw_context

### Description
Get the raw context handle.

### Method
`raw_context`

### Parameters
None

### Returns
- `RawContext`: The raw context handle.
```

--------------------------------

### Initialize

Source: https://docs.rs/glutin/latest/glutin/api/egl/struct.Egl.html

Initializes the EGL client connection. This is an unsafe function.

```APIDOC
## Initialize

### Description
Initializes the EGL client connection. This function is unsafe and requires proper handling of display and version pointers.

### Method
(Not specified, likely a direct method call)

### Endpoint
(Not applicable, this is an SDK function)

### Parameters
- **dpy** (*const c_void*) - Description of the display pointer.
- **major** (*mut i32*) - A mutable pointer to store the major version number.
- **minor** (*mut i32*) - A mutable pointer to store the minor version number.

### Return Value
- **u32** - An unsigned 32-bit integer indicating the success or failure of the initialization.
```

--------------------------------

### PossiblyCurrentContext::priority

Source: https://docs.rs/glutin/latest/glutin/api/glx/context/struct.PossiblyCurrentContext.html

Get the `Priority` used by the context.

```APIDOC
## PossiblyCurrentContext::priority

### Description
Get the `Priority` used by the context.

### Method
`priority`

### Parameters
None

### Returns
- `Priority`: The context priority.
```

--------------------------------

### PossiblyCurrentContext::context_api

Source: https://docs.rs/glutin/latest/glutin/api/glx/context/struct.PossiblyCurrentContext.html

Get the `ContextApi` used by the context.

```APIDOC
## PossiblyCurrentContext::context_api

### Description
Get the `ContextApi` used by the context.

### Method
`context_api`

### Parameters
None

### Returns
- `ContextApi`: The context API.
```

--------------------------------

### Display::new

Source: https://docs.rs/glutin/latest/glutin/api/egl/display/struct.Display.html

Creates a new EGL display using the provided native display handle. It's unsafe because the `raw_display` must point to a valid system display.

```APIDOC
## pub unsafe fn new(raw_display: RawDisplayHandle) -> Result<Self>

Create EGL display with the native display.

##### §Safety
`raw_display` must point to a valid system display. Using zero or `std::ptr::null()` for the display will result in using `EGL_DEFAULT_DISPLAY`, which is not recommended or will work on a platform with a concept of native display, like Wayland.
```

--------------------------------

### Get Surface Height

Source: https://docs.rs/glutin/latest/glutin/api/egl/surface/struct.Surface.html

Retrieves the physical height of the underlying surface.

```rust
fn height(&self) -> Option<u32>
```

--------------------------------

### Get Surface Width

Source: https://docs.rs/glutin/latest/glutin/api/egl/surface/struct.Surface.html

Retrieves the physical width of the underlying surface.

```rust
fn width(&self) -> Option<u32>
```

--------------------------------

### AsRawSurface Trait

Source: https://docs.rs/glutin/latest/glutin/surface/trait.AsRawSurface.html

The AsRawSurface trait is used to get the raw handle to the surface.

```APIDOC
## Trait AsRawSurface

### Description
Trait for accessing the raw GL surface.

### Required Methods
#### fn raw_surface(&self) -> RawSurface
Get the raw handle to the surface.

### Implementors
- `impl<T: SurfaceTypeTrait> AsRawSurface for glutin::surface::Surface<T>`
- `impl<T: SurfaceTypeTrait> AsRawSurface for glutin::api::egl::surface::Surface<T>` (Available on `egl_backend` only)
- `impl<T: SurfaceTypeTrait> AsRawSurface for glutin::api::glx::surface::Surface<T>` (Available on `glx_backend` only)
```

--------------------------------

### Create EGL Display with RawDisplayHandle

Source: https://docs.rs/glutin/latest/glutin/api/egl/display/struct.Display.html

Creates an EGL display using a native display handle. Ensure the `raw_display` points to a valid system display. Using `EGL_DEFAULT_DISPLAY` is not recommended.

```rust
pub unsafe fn new(raw_display: RawDisplayHandle) -> Result<Self>
```

--------------------------------

### Get Error Source

Source: https://docs.rs/glutin/latest/glutin/error/struct.Error.html

Returns the lower-level source of this error, if any, for error chaining.

```rust
fn source(&self) -> Option<&(dyn Error + 'static)>
```

--------------------------------

### Get Underlying Error Kind

Source: https://docs.rs/glutin/latest/glutin/error/struct.Error.html

Retrieves the specific kind of error that occurred.

```rust
pub fn error_kind(&self) -> ErrorKind
```

--------------------------------

### CreateWindowSurface Method

Source: https://docs.rs/glutin/latest/glutin/api/egl/struct.Egl.html

Creates an EGL window surface. This unsafe function requires display, configuration, window handle, and attribute list.

```rust
pub unsafe fn CreateWindowSurface( &self, dpy: *const c_void, config: *const c_void, win: *const c_void, attrib_list: *const i32, ) -> *const c_void
```

--------------------------------

### Get GL Config for PossiblyCurrentContext

Source: https://docs.rs/glutin/latest/glutin/context/enum.PossiblyCurrentContext.html

Retrieves the GL configuration associated with a PossiblyCurrentContext.

```rust
fn config(&self) -> Self::Target
```

--------------------------------

### Box::new_uninit_in

Source: https://docs.rs/glutin/latest/glutin/api/glx/type.XlibErrorHookRegistrar.html

Constructs a new box with uninitialized contents in the provided allocator. This is a nightly-only experimental API.

```APIDOC
## Box::new_uninit_in

### Description
Constructs a new box with uninitialized contents in the provided allocator.

### Method
Associated Function

### Endpoint
N/A (Associated Function)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```rust
#![feature(allocator_api)]
use std::alloc::System;
let mut five = Box::<u32, _>::new_uninit_in(System);
five.write(5);
let five = unsafe { five.assume_init() };
assert_eq!(*five, 5);
```

### Response
#### Success Response
- **Box<MaybeUninit<T>, A>** - A Box with uninitialized contents allocated in the specified allocator.

#### Response Example
None (returns a Box)
```

--------------------------------

### AsRawSurface Trait Implementation

Source: https://docs.rs/glutin/latest/glutin/api/glx/surface/struct.Surface.html

Provides a method to get the raw handle to the surface.

```APIDOC
## impl<T: SurfaceTypeTrait> AsRawSurface for Surface<T>

### raw_surface

Get the raw handle to the surface.

#### Returns

- `RawSurface`: The raw handle to the surface.
```

--------------------------------

### Get Raw EGLDevice Handle

Source: https://docs.rs/glutin/latest/glutin/api/egl/device/struct.Device.html

Retrieves a raw handle to the underlying `EGLDevice`.

```APIDOC
## `raw_device()`

Get a raw handle to the `EGLDevice`.

### Method

```rust
pub fn raw_device(&self) -> EGLDeviceEXT
```
```

--------------------------------

### DisplayFeatures Initialization Methods

Source: https://docs.rs/glutin/latest/glutin/display/struct.DisplayFeatures.html

Provides methods to create DisplayFeatures instances, including an empty set, a set with all known features, and conversion from raw bit values.

```rust
pub const fn empty() -> Self
```

```rust
pub const fn all() -> Self
```

```rust
pub const fn from_bits(bits: u32) -> Option<Self>
```

```rust
pub const fn from_bits_truncate(bits: u32) -> Self
```

```rust
pub const fn from_bits_retain(bits: u32) -> Self
```

--------------------------------

### Get GL Config for Surface

Source: https://docs.rs/glutin/latest/glutin/api/egl/surface/struct.Surface.html

Retrieves the GL configuration associated with the surface.

```rust
type Target = Config
fn config(&self) -> Self::Target
```

--------------------------------

### X11 Visual Info for Config

Source: https://docs.rs/glutin/latest/glutin/api/glx/config/struct.Config.html

Retrieves the X11VisualInfo for the GLX configuration, required for initializing Xlib windows. Available only on the x11_platform.

```rust
fn x11_visual(&self) -> Option<X11VisualInfo>
```

--------------------------------

### CreatePlatformWindowSurface Method

Source: https://docs.rs/glutin/latest/glutin/api/egl/struct.Egl.html

Creates a platform-specific EGL window surface. This unsafe function requires display, configuration, native window, and attribute list.

```rust
pub unsafe fn CreatePlatformWindowSurface( &self, dpy: *const c_void, config: *const c_void, native_window: *mut c_void, attrib_list: *const isize, ) -> *const c_void
```

--------------------------------

### Get Raw Surface Handle

Source: https://docs.rs/glutin/latest/glutin/api/egl/surface/struct.Surface.html

Retrieves the raw handle of the EGL surface.

```rust
fn raw_surface(&self) -> RawSurface
```

--------------------------------

### Api Flags Manipulation: Get Bits

Source: https://docs.rs/glutin/latest/glutin/config/struct.Api.html

Retrieves the underlying bits value of the flags.

```rust
pub const fn bits(&self) -> u8
```

--------------------------------

### Creating a Window Surface

Source: https://docs.rs/glutin/latest/glutin/display/trait.GlDisplay.html

Creates a surface suitable for rendering into a native window. The RawWindowHandle must point to a valid object.

```rust
unsafe fn create_window_surface(
        &self,
        config: &Self::Config,
        surface_attributes: &SurfaceAttributes<WindowSurface>,
    ) -> Result<Self::WindowSurface>;
```

--------------------------------

### PossiblyCurrentContext::config

Source: https://docs.rs/glutin/latest/glutin/api/glx/context/struct.PossiblyCurrentContext.html

Get the GL config used to create a particular GL object.

```APIDOC
## PossiblyCurrentContext::config

### Description
Get the GL config used to create a particular GL object.

### Method
`config`

### Parameters
None

### Returns
- `Self::Target` (which is `Config`): The GL config.
```

--------------------------------

### Create Box from raw pointer using system allocator

Source: https://docs.rs/glutin/latest/glutin/api/glx/type.XlibErrorHookRegistrar.html

Manually creates a Box from scratch using the system allocator. This nightly-only API requires `allocator_api` and `slice_ptr_get` features. The pointer must be allocated by the system allocator.

```rust
#![feature(allocator_api, slice_ptr_get)]

use std::alloc::{Allocator, Layout, System};

unsafe {
    let ptr = System.allocate(Layout::new::<i32>())?.as_mut_ptr() as *mut i32;
    // In general .write is required to avoid attempting to destruct
    // the (uninitialized) previous contents of `ptr`, though for this
    // simple example `*ptr = 5` would have worked as well.
    ptr.write(5);
    let x = Box::from_raw_in(ptr, System);
}
```

--------------------------------

### Compare Versions

Source: https://docs.rs/glutin/latest/glutin/context/struct.Version.html

Compares two Version instances to determine their ordering.

```rust
fn cmp(&self, other: &Version) -> Ordering
```

--------------------------------

### Get Type ID

Source: https://docs.rs/glutin/latest/glutin/api/egl/surface/struct.Surface.html

Retrieves the `TypeId` of the surface, used for runtime type identification.

```rust
fn type_id(&self) -> TypeId
```

--------------------------------

### Get Device Extensions

Source: https://docs.rs/glutin/latest/glutin/api/egl/device/struct.Device.html

Retrieves the set of device extensions supported by this EGL device.

```APIDOC
## `extensions()`

Get the device extensions supported by this device.

These extensions are distinct from the display extensions and should not be used interchangeably.

### Method

```rust
pub fn extensions(&self) -> &HashSet<&'static str>
```
```

--------------------------------

### QueryExtensionsString Method

Source: https://docs.rs/glutin/latest/glutin/api/glx/struct.Glx.html

Retrieves a string listing all supported GLX extensions for a given screen. This unsafe function requires a Display pointer and screen number.

```rust
pub unsafe fn QueryExtensionsString( &self, dpy: *mut Display, screen: i32, ) -> *const i8
```

--------------------------------

### Display::new

Source: https://docs.rs/glutin/latest/glutin/api/glx/display/struct.Display.html

Creates a new GLX display. This is an unsafe function that requires a valid Xlib display handle and a registered error hook.

```APIDOC
## `unsafe fn new(display: RawDisplayHandle, error_hook_registrar: XlibErrorHookRegistrar) -> Result<Self>`

### Description

Create GLX display.

### Safety

The `display` must point to the valid Xlib display and `error_hook_registrar` must be registered in your Xlib error handling callback.
```

--------------------------------

### Get GL Display for Surface

Source: https://docs.rs/glutin/latest/glutin/api/egl/surface/struct.Surface.html

Obtains the GL display used to create the surface.

```rust
type Target = Display
fn display(&self) -> Self::Target
```

--------------------------------

### Get Context Priority

Source: https://docs.rs/glutin/latest/glutin/api/egl/context/struct.PossiblyCurrentContext.html

Returns the `Priority` of this context. This is part of the `GlContext` trait implementation.

```rust
fn priority(&self) -> Priority
```

--------------------------------

### CreatePlatformPixmapSurfaceEXT Method

Source: https://docs.rs/glutin/latest/glutin/api/egl/struct.Egl.html

Creates a platform-specific EGL pixmap surface using the EXT extension. This unsafe function requires display, configuration, native pixmap, and attribute list.

```rust
pub unsafe fn CreatePlatformPixmapSurfaceEXT( &self, dpy: *const c_void, config: *const c_void, native_pixmap: *mut c_void, attrib_list: *const i32, ) -> *const c_void
```

--------------------------------

### Get Device Vendor

Source: https://docs.rs/glutin/latest/glutin/api/egl/device/struct.Device.html

Retrieves the vendor of the EGL device. This requires the `EGL_EXT_device_query_name` extension.

```rust
pub fn vendor(&self) -> Option<&'static str>
```

--------------------------------

### Request config compatible with native window

Source: https://docs.rs/glutin/latest/glutin/config/struct.ConfigTemplateBuilder.html

Requests a configuration that can render to a specific native window. This is platform-specific and improves reliability, especially with WGL and GLX.

```rust
pub fn compatible_with_native_window( self, native_window: RawWindowHandle, ) -> Self
```

--------------------------------

### Finding OpenGL Configurations

Source: https://docs.rs/glutin/latest/glutin/display/trait.GlDisplay.html

Use this method to discover available OpenGL configurations that match a given template. Ensure that any RawWindowHandle used in the template points to a valid object for platform-specific config selection.

```rust
unsafe fn find_configs(
        &self,
        template: ConfigTemplate,
    ) -> Result<Box<dyn Iterator<Item = Self::Config> + '_>>;
```

--------------------------------

### Get Device Name

Source: https://docs.rs/glutin/latest/glutin/api/egl/device/struct.Device.html

Retrieves the name of the EGL device. This requires the `EGL_EXT_device_query_name` extension.

```rust
pub fn name(&self) -> Option<&'static str>
```

--------------------------------

### Get Context API

Source: https://docs.rs/glutin/latest/glutin/api/egl/context/struct.PossiblyCurrentContext.html

Returns the `ContextApi` used by this context. This is part of the `GlContext` trait implementation.

```rust
fn context_api(&self) -> ContextApi
```

--------------------------------

### Import Glutin Prelude

Source: https://docs.rs/glutin/latest/glutin/prelude/index.html

Use this import statement to bring all common glutin prelude items into scope for convenient access.

```rust
use glutin::prelude::*;
```

--------------------------------

### Getting Mutable References with as_mut()

Source: https://docs.rs/glutin/latest/glutin/error/type.Result.html

Shows how to convert a mutable reference to a Result into a Result of mutable references.

```Rust
fn mutate(r: &mut Result<i32, i32>) {
    match r.as_mut() {
        Ok(v) => *v = 42,
        Err(e) => *e = 0,
    }
}

let mut x: Result<i32, i32> = Ok(2);
mutate(&mut x);
assert_eq!(x.unwrap(), 42);

let mut x: Result<i32, i32> = Err(13);
mutate(&mut x);
assert_eq!(x.unwrap_err(), 0);
```

--------------------------------

### PartialEq Implementation for RawConfig

Source: https://docs.rs/glutin/latest/glutin/config/enum.RawConfig.html

Allows comparison of two RawConfig values for equality. This is essential for checking if two configurations are identical.

```rust
fn eq(&self, other: &RawConfig) -> bool
```

--------------------------------

### Box::from_raw_in

Source: https://docs.rs/glutin/latest/glutin/api/glx/type.XlibErrorHookRegistrar.html

Constructs a Box from a raw pointer using a specified allocator. This is a nightly-only experimental API.

```APIDOC
## pub unsafe fn from_raw_in(raw: *mut T, alloc: A) -> Box<T, A>

### Description
Constructs a box from a raw pointer in the given allocator. After calling this function, the raw pointer is owned by the resulting `Box`. Specifically, the `Box` destructor will call the destructor of `T` and free the allocated memory. For this to be safe, the memory must have been allocated in accordance with the memory layout used by `Box` .

### Safety
This function is unsafe because improper use may lead to memory problems. For example, a double-free may occur if the function is called twice on the same raw pointer.
The raw pointer must point to a block of memory allocated by `alloc`.

### Examples
Recreate a `Box` which was previously converted to a raw pointer using `Box::into_raw_with_allocator`:
```rust
#![feature(allocator_api)]

use std::alloc::System;

let x = Box::new_in(5, System);
let (ptr, alloc) = Box::into_raw_with_allocator(x);
let x = unsafe { Box::from_raw_in(ptr, alloc) };
```

Manually create a `Box` from scratch by using the system allocator:
```rust
#![feature(allocator_api, slice_ptr_get)]

use std::alloc::{Allocator, Layout, System};

unsafe {
    let ptr = System.allocate(Layout::new::<i32>())?.as_mut_ptr() as *mut i32;
    // In general .write is required to avoid attempting to destruct
    // the (uninitialized) previous contents of `ptr`, though for this
    // simple example `*ptr = 5` would have worked as well.
    ptr.write(5);
    let x = Box::from_raw_in(ptr, System);
}
```
```

--------------------------------

### Api Flags Conversion: From Name

Source: https://docs.rs/glutin/latest/glutin/config/struct.Api.html

Gets a flags value with the bits of a flag with the given name set.

```rust
pub fn from_name(name: &str) -> Option<Self>
```

--------------------------------

### Create EGL Display with Device

Source: https://docs.rs/glutin/latest/glutin/api/egl/display/struct.Display.html

Creates an EGL display using a specified device. Prefer `Display::new()` unless off-screen rendering or extensions like EGLStreams are needed. The `raw_display` argument is currently ignored but may be used in the future. If `raw_display` is `Some`, it must be a `RawDisplayHandle::Drm`.

```rust
pub unsafe fn with_device( device: &Device, raw_display: Option<RawDisplayHandle>, ) -> Result<Self>
```

--------------------------------

### QueryServerString Method

Source: https://docs.rs/glutin/latest/glutin/api/glx/struct.Glx.html

Retrieves a string describing the GLX server. This unsafe function requires a Display pointer, screen number, and a name identifier.

```rust
pub unsafe fn QueryServerString( &self, dpy: *mut Display, screen: i32, name: i32, ) -> *const i8
```

--------------------------------

### Get Native Visual Identifier

Source: https://docs.rs/glutin/latest/glutin/api/egl/config/struct.Config.html

Retrieves the native visual identifier for the EGL configuration. The interpretation is platform-dependent.

```rust
pub fn native_visual(&self) -> u32
```

--------------------------------

### CreateContext Method

Source: https://docs.rs/glutin/latest/glutin/api/glx/struct.Glx.html

Creates a new GLX rendering context. This unsafe function requires a Display pointer, a pointer to an XVisualInfo, a share list, and a direct rendering flag.

```rust
pub unsafe fn CreateContext( &self, dpy: *mut Display, vis: *mut XVisualInfo, shareList: *const c_void, direct: i32, ) -> *const c_void
```

--------------------------------

### Get Device Vendor

Source: https://docs.rs/glutin/latest/glutin/api/egl/device/struct.Device.html

Retrieves the vendor of the EGL device. Returns `None` if the `EGL_EXT_device_query_name` extension is not available.

```APIDOC
## `vendor()`

Get the vendor of the device.

This function will return `None` if the `EGL_EXT_device_query_name` device extension is not available.

### Method

```rust
pub fn vendor(&self) -> Option<&'static str>
```
```

--------------------------------

### Get Device Name

Source: https://docs.rs/glutin/latest/glutin/api/egl/device/struct.Device.html

Retrieves the name of the EGL device. Returns `None` if the `EGL_EXT_device_query_name` extension is not available.

```APIDOC
## `name()`

Get the name of the device.

This function will return `None` if the `EGL_EXT_device_query_name` device extension is not available.

### Method

```rust
pub fn name(&self) -> Option<&'static str>
```
```

--------------------------------

### Create GLX display

Source: https://docs.rs/glutin/latest/glutin/api/glx/display/struct.Display.html

Creates a new GLX display instance. The `display` must point to a valid Xlib display, and the `error_hook_registrar` must be registered in your Xlib error handling callback. This function is unsafe due to the requirements on the provided handles.

```rust
pub unsafe fn new( display: RawDisplayHandle, error_hook_registrar: XlibErrorHookRegistrar, ) -> Result<Self>
```

--------------------------------

### Converting Result to Option with ok()

Source: https://docs.rs/glutin/latest/glutin/error/type.Result.html

Shows how to convert a Result into an Option, consuming the Result and discarding any error value.

```Rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.ok(), Some(2));

let x: Result<u32, &str> = Err("Nothing here");
assert_eq!(x.ok(), None);
```

--------------------------------

### GetConfigs Method

Source: https://docs.rs/glutin/latest/glutin/api/egl/struct.Egl.html

Retrieves a list of EGL frame buffer configurations. This unsafe function requires display, pointers to store configurations, and buffer size.

```rust
pub unsafe fn GetConfigs( &self, dpy: *const c_void, configs: *mut *const c_void, config_size: i32, num_config: *mut i32, ) -> u32
```

--------------------------------

### From and Into Trait Implementations

Source: https://docs.rs/glutin/latest/glutin/config/struct.ConfigTemplate.html

Illustrates the blanket implementations of the From and Into traits, enabling conversions between types where a From implementation exists.

```rust
fn from(t: T) -> T
```

```rust
fn into(self) -> U
```

--------------------------------

### Build Surface Attributes for Window Surface

Source: https://docs.rs/glutin/latest/glutin/surface/struct.SurfaceAttributesBuilder.html

Build the surface attributes required for creating a window surface, providing the window handle and dimensions.

```rust
pub fn build( self, raw_window_handle: RawWindowHandle, width: NonZeroU32, height: NonZeroU32, ) -> SurfaceAttributes<WindowSurface>
```

--------------------------------

### Get Device Extensions

Source: https://docs.rs/glutin/latest/glutin/api/egl/device/struct.Device.html

Retrieves the set of EGL extensions supported by this specific device. These are distinct from display extensions.

```rust
pub fn extensions(&self) -> &HashSet<&'static str>
```

--------------------------------

### Writing Prefixes and Strings to Hasher (Nightly)

Source: https://docs.rs/glutin/latest/glutin/api/glx/type.XlibErrorHookRegistrar.html

Experimental methods for writing length prefixes and string data into a hasher, useful for prefix-free hashing.

```APIDOC
## fn write_length_prefix(&mut self, len: usize)

Writes a length prefix into this hasher, as part of being prefix-free.

### Note
This is a nightly-only experimental API. (`hasher_prefixfree_extras`)

### Method
`write_length_prefix`

### Parameters
- **len** (usize) - Description: The length prefix to write.

## fn write_str(&mut self, s: &str)

Writes a single `str` into this hasher.

### Note
This is a nightly-only experimental API. (`hasher_prefixfree_extras`)

### Method
`write_str`

### Parameters
- **s** (&str) - Description: The string slice to write.
```

--------------------------------

### Partial Comparison for Version

Source: https://docs.rs/glutin/latest/glutin/context/struct.Version.html

Provides an optional ordering between two Version instances.

```rust
fn partial_cmp(&self, other: &Version) -> Option<Ordering>
```

--------------------------------

### Api Flags Manipulation: Empty and All

Source: https://docs.rs/glutin/latest/glutin/config/struct.Api.html

Methods to get flags values representing no bits set or all known bits set.

```rust
pub const fn empty() -> Self
```

```rust
pub const fn all() -> Self
```

--------------------------------

### Configure Single Buffer for Window Surface

Source: https://docs.rs/glutin/latest/glutin/surface/struct.SurfaceAttributesBuilder.html

Specify whether to use single buffering instead of double buffering for a window surface. The actual usage can be verified by querying the created surface. Defaults to double buffering.

```rust
pub fn with_single_buffer(self, single_buffer: bool) -> Self
```

--------------------------------

### Box::try_new_uninit_in

Source: https://docs.rs/glutin/latest/glutin/api/glx/type.XlibErrorHookRegistrar.html

Constructs a new box with uninitialized contents in the provided allocator, returning an error if the allocation fails. This is a nightly-only experimental API.

```APIDOC
## Box::try_new_uninit_in

### Description
Constructs a new box with uninitialized contents in the provided allocator, returning an error if the allocation fails.

### Method
Associated Function

### Endpoint
N/A (Associated Function)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```rust
#![feature(allocator_api)]
use std::alloc::System;
let mut five = Box::<u32, _>::try_new_uninit_in(System)?;
five.write(5);
let five = unsafe { five.assume_init() };
assert_eq!(*five, 5);
```

### Response
#### Success Response
- **Result<Box<MaybeUninit<T>, A>, AllocError>** - A Result containing a Box with uninitialized contents or an AllocError.

#### Response Example
None (returns a Result)
```

--------------------------------

### Get EGL API Reference

Source: https://docs.rs/glutin/latest/glutin/api/egl/display/struct.Display.html

Provides a static reference to the initialized EGL API, allowing access to EGL functions.

```rust
pub fn egl(&self) -> &'static Egl
```

--------------------------------

### Get GL Display from Config

Source: https://docs.rs/glutin/latest/glutin/api/glx/config/struct.Config.html

Retrieves the GL display associated with the Config object. This is part of the GetGlDisplay trait implementation.

```rust
fn display(&self) -> Self::Target
```

--------------------------------

### Enable transparency support

Source: https://docs.rs/glutin/latest/glutin/config/struct.ConfigTemplateBuilder.html

Configures whether the graphics configuration should support transparency. Defaults to false. Note: EGL on X11 may not support transparent surfaces; use GLX instead.

```rust
pub fn with_transparency(self, transparency: bool) -> Self
```

--------------------------------

### Get Raw Context Handle

Source: https://docs.rs/glutin/latest/glutin/api/egl/context/struct.PossiblyCurrentContext.html

Retrieves the underlying raw EGL context handle. This is part of the `AsRawContext` trait implementation.

```rust
fn raw_context(&self) -> RawContext
```

--------------------------------

### PartialEq Implementation for RawDisplay

Source: https://docs.rs/glutin/latest/glutin/display/enum.RawDisplay.html

Enables comparison of RawDisplay instances for equality.

```APIDOC
### impl PartialEq for RawDisplay

#### fn eq(&self, other: &RawDisplay) -> bool
Tests for `self` and `other` values to be equal, and is used by `==`.
```

--------------------------------

### Get Raw Error Code

Source: https://docs.rs/glutin/latest/glutin/error/struct.Error.html

Retrieves the raw error code as an i64, if available. Returns None if no raw code is associated.

```rust
pub fn raw_code(&self) -> Option<i64>
```

--------------------------------

### Create New Version

Source: https://docs.rs/glutin/latest/glutin/context/struct.Version.html

Constructs a new Version instance with specified major and minor version numbers.

```rust
pub const fn new(major: u8, minor: u8) -> Self
```

--------------------------------

### GlDisplay Implementation - Get Proc Address

Source: https://docs.rs/glutin/latest/glutin/api/egl/display/struct.Display.html

Returns the address of an OpenGL function. This is a common utility for accessing OpenGL entry points.

```rust
fn get_proc_address(&self, addr: &CStr) -> *const c_void
```

--------------------------------

### Get Display Device

Source: https://docs.rs/glutin/latest/glutin/api/egl/display/struct.Display.html

Retrieves the `Device` associated with the EGL display. This function returns an error if `EGL_EXT_device_query` or `EGL_EXT_device_base` extensions are not available.

```rust
pub fn device(&self) -> Result<Device>
```

--------------------------------

### try_new_zeroed_in

Source: https://docs.rs/glutin/latest/glutin/api/glx/type.XlibErrorHookRegistrar.html

Constructs a new Box with uninitialized contents, filling the memory with 0 bytes using the provided allocator. Returns an error if allocation fails. This is a nightly-only experimental API.

```APIDOC
## pub fn try_new_zeroed_in<T, A>(alloc: A) -> Result<Box<MaybeUninit<T>, A>, AllocError>

### Description
Constructs a new `Box` with uninitialized contents, with the memory being filled with `0` bytes in the provided allocator, returning an error if the allocation fails.

### Parameters
#### Path Parameters
- **alloc** (A) - Required - The allocator to use for memory allocation.

### Returns
- `Result<Box<MaybeUninit<T>, A>, AllocError>` - A `Box` with zeroed uninitialized contents or an `AllocError` if allocation fails.

### Examples
```rust
#![feature(allocator_api)]

use std::alloc::System;

let zero = Box::<u32, _>::try_new_zeroed_in(System)?;
let zero = unsafe { zero.assume_init() };

assert_eq!(*zero, 0);
```
```

--------------------------------

### GetFBConfigs Method

Source: https://docs.rs/glutin/latest/glutin/api/glx/struct.Glx.html

Retrieves a list of available FBConfigs for a given screen. This unsafe function requires a Display pointer, screen number, and a pointer to store the number of elements.

```rust
pub unsafe fn GetFBConfigs( &self, dpy: *mut Display, screen: i32, nelements: *mut i32, ) -> *mut *const c_void
```

--------------------------------

### QueryDevicesEXT

Source: https://docs.rs/glutin/latest/glutin/api/egl/struct.Egl.html

Queries available devices using the EXT extension. This is an unsafe function.

```APIDOC
## QueryDevicesEXT

### Description
Queries the available devices on the system using the EXT extension. This function is unsafe and requires careful management of output buffers.

### Method
(Not specified, likely a direct method call)

### Endpoint
(Not applicable, this is an SDK function)

### Parameters
- **max_devices** (*i32*) - The maximum number of devices to query.
- **devices** (*mut *const c_void*) - A mutable pointer to an array of device pointers.
- **num_devices** (*mut i32*) - A mutable pointer to store the number of devices found.

### Return Value
- **u32** - An unsigned 32-bit integer indicating the success or failure of the operation.
```

--------------------------------

### by_ref

Source: https://docs.rs/glutin/latest/glutin/api/glx/type.XlibErrorHookRegistrar.html

Creates a “by reference” adapter for this instance of `Write`.

```APIDOC
## fn by_ref(&mut self) -> &mut Self

### Description
Creates a “by reference” adapter for this instance of `Write`.

### Signature
`fn by_ref(&mut self) -> &mut Self`
```

--------------------------------

### Get DRM Render Device Node Path

Source: https://docs.rs/glutin/latest/glutin/api/egl/device/struct.Device.html

Retrieves the DRM render device node path for this EGLDeviceEXT. Requires the `EGL_EXT_device_drm_render_node` extension.

```APIDOC
## `drm_render_device_node_path()`

Get the DRM render device node path for this `EGLDeviceEXT`.

Requires the `EGL_EXT_device_drm_render_node` extension.
If the `EGL_EXT_device_drm` extension is supported in addition to `EGL_EXT_device_drm_render_node`, consult `Self::drm_device_node_path()` to retrieve the **primary** device node path.

### Method

```rust
pub fn drm_render_device_node_path(&self) -> Option<&'static Path>
```
```

--------------------------------

### Get DRM Device Node Path

Source: https://docs.rs/glutin/latest/glutin/api/egl/device/struct.Device.html

Retrieves the DRM primary or render device node path for this EGLDeviceEXT. Requires the `EGL_EXT_device_drm` extension.

```APIDOC
## `drm_device_node_path()`

Get the DRM primary or render device node path for this `EGLDeviceEXT`.

Requires the `EGL_EXT_device_drm` extension.
If the `EGL_EXT_device_drm_render_node` extension is supported, this is guaranteed to return the **primary** device node path, or `None`. Consult `Self::drm_render_device_node_path()` to retrieve the **render** device node path.

### Method

```rust
pub fn drm_device_node_path(&self) -> Option<&'static Path>
```
```

--------------------------------

### ConfigTemplateBuilder Methods

Source: https://docs.rs/glutin/latest/glutin/config/struct.ConfigTemplateBuilder.html

Methods for building a ConfigTemplate, allowing customization of various display attributes.

```APIDOC
## pub fn new()

### Description
Create a new configuration template builder.

### Method
`new()`

### Returns
`Self` (a new ConfigTemplateBuilder instance)
```

```APIDOC
## pub fn with_alpha_size(self, alpha_size: u8) -> Self

### Description
Sets the number of alpha bits in the color buffer. By default, 8 bits are requested.

### Method
`with_alpha_size(alpha_size: u8)`

### Parameters
* **alpha_size** (u8) - The desired number of alpha bits.
```

```APIDOC
## pub fn with_float_pixels(self, float_pixels: bool) -> Self

### Description
Specifies whether floating-point pixel formats should be used. Defaults to false.

### Method
`with_float_pixels(float_pixels: bool)`

### Parameters
* **float_pixels** (bool) - Set to true to request floating-point pixel formats.
```

```APIDOC
## pub fn with_stencil_size(self, stencil_size: u8) -> Self

### Description
Sets the number of bits in the stencil buffer. Defaults to 0.

### Method
`with_stencil_size(stencil_size: u8)`

### Parameters
* **stencil_size** (u8) - The desired number of stencil bits.
```

```APIDOC
## pub fn with_depth_size(self, depth_size: u8) -> Self

### Description
Sets the number of bits in the depth buffer. Defaults to 0.

### Method
`with_depth_size(depth_size: u8)`

### Parameters
* **depth_size** (u8) - The desired number of depth bits.
```

```APIDOC
## pub fn with_multisampling(self, num_samples: u8) -> Self

### Description
Enables multisampling configurations. The `num_samples` must be a power of two. By default, multisampling is not specified.

### Method
`with_multisampling(num_samples: u8)`

### Parameters
* **num_samples** (u8) - The number of samples for multisampling (must be a power of two).
```

```APIDOC
## pub fn with_surface_type(self, config_surface_types: ConfigSurfaceTypes) -> Self

### Description
Specifies the types of surfaces that must be supported by the configuration. By default, only the `WINDOW` bit is set.

### Method
`with_surface_type(config_surface_types: ConfigSurfaceTypes)`

### Parameters
* **config_surface_types** (ConfigSurfaceTypes) - The required surface types.
```

```APIDOC
## pub fn with_buffer_type(self, color_buffer_type: ColorBufferType) -> Self

### Description
Sets the type of the color buffer. By default, an `RGB` buffer with all component sizes of 8 is requested.

### Method
`with_buffer_type(color_buffer_type: ColorBufferType)`

### Parameters
* **color_buffer_type** (ColorBufferType) - The desired color buffer type.
```

```APIDOC
## pub fn with_api(self, api: Api) -> Self

### Description
Specifies the set of APIs that are supported by this configuration. The default `Api` depends on the used graphics platform interface. If you want to do config filtering based on the `Api` yourself, use `Api::empty`.

### Method
`with_api(api: Api)`

### Parameters
* **api** (Api) - The set of supported APIs.
```

```APIDOC
## pub fn with_stereoscopy(self, stereoscopy: Option<bool>) -> Self

### Description
Specifies whether stereo pairs should be present. By default, it is not specified.

### Method
`with_stereoscopy(stereoscopy: Option<bool>)`

### Parameters
* **stereoscopy** (Option<bool>) - Set to `Some(true)` for stereo, `Some(false)` to disable, or `None` to leave unspecified.
```

```APIDOC
## pub fn with_single_buffering(self, single_buffering: bool) -> Self

### Description
Requests the use of single buffering. Defaults to false.

### Method
`with_single_buffering(single_buffering: bool)`

### Parameters
* **single_buffering** (bool) - Set to true to request single buffering.
```

```APIDOC
## pub fn with_transparency(self, transparency: bool) -> Self

### Description
Requests that the configuration support transparency. The default is false. Note: EGL on X11 may not support transparent surfaces; use GLX for transparency in such cases.

### Method
`with_transparency(transparency: bool)`

### Parameters
* **transparency** (bool) - Set to true to request transparency support.
```

```APIDOC
## pub fn with_pbuffer_sizes(self, width: NonZeroU32, height: NonZeroU32) -> Self

### Description
Sets the maximum dimensions for a pbuffer (pixel buffer).

### Method
`with_pbuffer_sizes(width: NonZeroU32, height: NonZeroU32)`

### Parameters
* **width** (NonZeroU32) - The maximum width of the pbuffer.
* **height** (NonZeroU32) - The maximum height of the pbuffer.
```

```APIDOC
## pub fn prefer_hardware_accelerated(self, hardware_accelerated: Option<bool>) -> Self

### Description
Specifies whether to prefer hardware-accelerated formats. By default, hardware acceleration preference is not requested.

### Method
`prefer_hardware_accelerated(hardware_accelerated: Option<bool>)`

### Parameters
* **hardware_accelerated** (Option<bool>) - Set to `Some(true)` to prefer hardware acceleration, `Some(false)` to prefer software, or `None` to leave unspecified.
```

```APIDOC
## pub fn compatible_with_native_window(self, native_window: RawWindowHandle) -> Self

### Description
Requests a configuration that is compatible with a specific native window. This is particularly useful for ensuring the best configuration for rendering to that window, especially with WGL and GLX.

### Method
`compatible_with_native_window(native_window: RawWindowHandle)`

### Parameters
* **native_window** (RawWindowHandle) - The handle of the native window.
```

```APIDOC
## pub fn with_swap_interval(self, min_swap_interval: Option<u16>, max_swap_interval: Option<u16>) -> Self

### Description
Sets the supported swap interval range. This is only supported with EGL. By default, the value is not specified.

### Method
`with_swap_interval(min_swap_interval: Option<u16>, max_swap_interval: Option<u16>)`

### Parameters
* **min_swap_interval** (Option<u16>) - The minimum supported swap interval.
* **max_swap_interval** (Option<u16>) - The maximum supported swap interval.
```

```APIDOC
## pub fn build(self) -> ConfigTemplate

### Description
Builds the `ConfigTemplate` based on the configured options, which can then be used to match against available configurations.

### Method
`build()`

### Returns
`ConfigTemplate` - The constructed configuration template.
```

--------------------------------

### Box::new_in

Source: https://docs.rs/glutin/latest/glutin/api/glx/type.XlibErrorHookRegistrar.html

Allocates memory in the given allocator then places x into it. This is a nightly-only experimental API.

```APIDOC
## Box::new_in

### Description
Allocates memory in the given allocator then places `x` into it.

### Method
Associated Function

### Endpoint
N/A (Associated Function)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```rust
#![feature(allocator_api)]
use std::alloc::System;
let five = Box::new_in(5, System);
```

### Response
#### Success Response
- **Box<T, A>** - A Box allocated in the specified allocator.

#### Response Example
None (returns a Box)
```

--------------------------------

### Default Implementation for SurfaceAttributes

Source: https://docs.rs/glutin/latest/glutin/surface/struct.SurfaceAttributes.html

Provides a default set of attributes for creating a surface. This simplifies surface creation by offering a sensible starting point.

```rust
impl<T: Default + SurfaceTypeTrait> Default for SurfaceAttributes<T>
fn default() -> SurfaceAttributes<T>
```

--------------------------------

### ChooseConfig Method

Source: https://docs.rs/glutin/latest/glutin/api/egl/struct.Egl.html

Chooses an EGL frame buffer configuration. This unsafe function takes a display, attribute list, and pointers to store the resulting configurations.

```rust
pub unsafe fn ChooseConfig( &self, dpy: *const c_void, attrib_list: *const i32, configs: *mut *const c_void, config_size: i32, num_config: *mut i32, ) -> u32
```

--------------------------------

### Get DRM Render Device Node Path

Source: https://docs.rs/glutin/latest/glutin/api/egl/device/struct.Device.html

Retrieves the DRM render device node path for the EGL device. Requires the `EGL_EXT_device_drm_render_node` extension.

```rust
pub fn drm_render_device_node_path(&self) -> Option<&'static Path>
```

--------------------------------

### CreateContext Method

Source: https://docs.rs/glutin/latest/glutin/api/egl/struct.Egl.html

Creates an EGL rendering context. This unsafe function requires a display, configuration, share context, and attribute list.

```rust
pub unsafe fn CreateContext( &self, dpy: *const c_void, config: *const c_void, share_context: *const c_void, attrib_list: *const i32, ) -> *const c_void
```

--------------------------------

### display

Source: https://docs.rs/glutin/latest/glutin/api/egl/context/struct.PossiblyCurrentContext.html

Obtains the `Display` used to create this GL object.

```APIDOC
## display

### Description
Obtain the GL display used to create a particular GL object.

### Method
`&self` (This indicates it operates on an instance without consuming it)

### Parameters
None.

### Return Value
- `Self::Target` (which is `Display`): The GL display associated with this object.
```

--------------------------------

### Get DRM Device Node Path

Source: https://docs.rs/glutin/latest/glutin/api/egl/device/struct.Device.html

Retrieves the DRM primary or render device node path for the EGL device. Requires the `EGL_EXT_device_drm` extension.

```rust
pub fn drm_device_node_path(&self) -> Option<&'static Path>
```

--------------------------------

### From Implementation

Source: https://docs.rs/glutin/latest/glutin/api/glx/type.XlibErrorHookRegistrar.html

Static method to create a Box<T> from a value.

```APIDOC
## fn from(t: T) -> Box<T>

Converts a `T` into a `Box<T>`.

The conversion allocates on the heap and moves `t` from the stack into it.

### Examples
```
let x = 5;
let boxed = Box::new(5);

assert_eq!(Box::from(x), boxed);
```
```

--------------------------------

### Getting OpenGL Function Address

Source: https://docs.rs/glutin/latest/glutin/display/trait.GlDisplay.html

Retrieves the address of an OpenGL function. For WGL, a current context is required to load all functions; otherwise, only a limited set will be available.

```rust
fn get_proc_address(&self, addr: &CStr) -> *const c_void;
```

--------------------------------

### Get Surface Buffer Age

Source: https://docs.rs/glutin/latest/glutin/api/egl/surface/struct.Surface.html

Returns the age of the back buffer. A value of 0 indicates a new buffer or a failure to retrieve age, requiring a full redraw.

```rust
fn buffer_age(&self) -> u32
```

--------------------------------

### Equivalent Manual Cleanup using Box::from_raw

Source: https://docs.rs/glutin/latest/glutin/api/glx/type.XlibErrorHookRegistrar.html

Shows an alternative manual cleanup method by converting the raw pointer back to a Box and then explicitly dropping that Box, which handles both value destruction and memory deallocation.

```rust
let x = Box::new(String::from("Hello"));
let ptr = Box::into_raw(x);
unsafe {
    drop(Box::from_raw(ptr));
}
```

--------------------------------

### PartialEq Implementation for Config

Source: https://docs.rs/glutin/latest/glutin/config/enum.Config.html

Enables equality comparison between Config objects. This allows checking if two configurations are identical.

```rust
fn eq(&self, other: &Config) -> bool
```

```rust
const fn ne(&self, other: &Rhs) -> bool
```
Tokens:
Raw