GPUI

https://docs.rs/gpui
Admin
GPUI is a hybrid immediate and retained mode, GPU accelerated UI framework for Rust designed to...
Tokens:4,934,041
Snippets:45,661
Trust Score:9.1
Update:1 week ago
Show doc for...
Tokens:
Raw
### Example: Reading and Parsing a Config File

Source: https://docs.rs/gpui/latest/gpui/type.Result.html?search=

Example of using anyhow::Result in main to read and parse a JSON config file, with error propagation via ?.

```rust
use anyhow::Result;

fn main() -> Result<()> {
    let config = std::fs::read_to_string("cluster.json")?;
    let map: ClusterMap = serde_json::from_str(&config)?;
    println!("cluster info: {:#?}", map);
    Ok(())
}
```

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

### expect example

Source: https://docs.rs/gpui/latest/gpui/type.Result.html?search=

Shows how to use expect to return the contained Ok value, panicking with a message if the result is Err. Includes a recommended message style example.

```rust
let x: Result<u32, &str> = Err("emergency failure");
x.expect("Testing expect"); // panics with `Testing expect: emergency failure`
```

```rust
let path = std::env::var("IMPORTANT_PATH")
    .expect("env variable `IMPORTANT_PATH` should be set by `wrapper_script.sh`");
```

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

### starts_with example: check if slice starts with a prefix

Source: https://docs.rs/gpui/latest/gpui/struct.GlobalElementId.html

Checks if a slice starts with a given prefix or equals the slice. Always returns true for an empty needle.

```rust
let v = [10, 40, 30];
assert!(v.starts_with(&[10]));
assert!(v.starts_with(&[10, 40]));
assert!(v.starts_with(&v));
assert!(!v.starts_with(&[50]));
assert!(!v.starts_with(&[10, 50]));
```

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

### Point::new example

Source: https://docs.rs/gpui/latest/gpui/struct.Point.html

Example of using the new constructor to create a Point and assert its coordinates.

```rust
use gpui::Point;
let p = Point::new(10, 20);
assert_eq!(p.x, 10);
assert_eq!(p.y, 20);
```

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

### Point struct example

Source: https://docs.rs/gpui/latest/gpui/struct.Point.html

Example of creating a Point with integer coordinates and printing it.

```rust
let point = Point { x: 10, y: 20 };
println!("{:?}", point); // Outputs: Point { x: 10, y: 20 }
```

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

### size function usage example

Source: https://docs.rs/gpui/latest/gpui/fn.size.html?search=

Example of using gpui::size to create a Size with width 10 and height 20, and asserting the resulting fields.

```rust
use gpui::size;
let my_size = size(10, 20);
assert_eq!(my_size.width, 10);
assert_eq!(my_size.height, 20);
```

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

### size function example

Source: https://docs.rs/gpui/latest/src/gpui/geometry.rs.html?search=

Demonstrates the size constructor function that creates a Size<T> from width and height values. The example shows creating a size and accessing its width and height fields.

```rust
/// # Examples
///
/// ```
/// use gpui::size;
/// let my_size = size(10, 20);
/// assert_eq!(my_size.width, 10);
/// assert_eq!(my_size.height, 20);
/// ```
```

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

### Start window resize operation

Source: https://docs.rs/gpui/latest/src/gpui/platform/linux/x11/window.rs.html?search=std%3A%3Avec

Starts a window resize by sending a move/resize event with the edge converted to a moveresize value.

```rust
fn start_window_resize(&self, edge: ResizeEdge) {
        self.send_moveresize(edge.to_moveresize()).log_err();
    }
```

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

### Initialize X11 client with XKB, event sources, and X11ClientState

Source: https://docs.rs/gpui/latest/src/gpui/platform/linux/x11/client.rs.html?search=std%3A%3Avec

Initializes the X11 client by setting up XKB input, GPU context, resource database, cursor, clipboard, XIM, and event sources. It selects XKB events, creates the XKB state, and composes the client state struct. Requires an existing event loop handle and xcb_connection. Ends with xcb_flush and returns an X11Client wrapped in Rc<RefCell<X11ClientState>>.

```rust
&xkb::SelectEventsAux::new(),
),
)?;

let xkb_context = xkbc::Context::new(xkbc::CONTEXT_NO_FLAGS);
let xkb_device_id = xkbc::x11::get_core_keyboard_device_id(&xcb_connection);
let xkb_state = {
    let xkb_keymap = xkbc::x11::keymap_new_from_device(
        &xkb_context,
        &xcb_connection,
        xkb_device_id,
        xkbc::KEYMAP_COMPILE_NO_FLAGS,
    );
    xkbc::x11::state_new_from_device(&xkb_keymap, &xcb_connection, xkb_device_id)
};
let compose_state = get_xkb_compose_state(&xkb_context);
let layout_idx = xkb_state.serialize_layout(STATE_LAYOUT_EFFECTIVE);
let layout_name = xkb_state
    .get_keymap()
    .layout_get_name(layout_idx)
    .to_string();
let keyboard_layout = LinuxKeyboardLayout::new(layout_name.into());

let gpu_context = BladeContext::new().context("Unable to init GPU context")?;

let resource_database = x11rb::resource_manager::new_from_default(&xcb_connection)
    .context("Failed to create resource database")?;
let scale_factor = get_scale_factor(&xcb_connection, &resource_database, x_root_index);
let cursor_handle = cursor::Handle::new(&xcb_connection, x_root_index, &resource_database)
    .context("Failed to initialize cursor theme handler")?
    .reply()
    .context("Failed to initialize cursor theme handler")?;

let clipboard = Clipboard::new().context("Failed to initialize clipboard")?;

let xcb_connection = Rc::new(xcb_connection);

let ximc = X11rbClient::init(Rc::clone(&xcb_connection), x_root_index, None).ok();
let xim_handler = if ximc.is_some() {
    Some(XimHandler::new())
} else {
    None
};

// Safety: Safe if xcb::Connection always returns a valid fd
let fd = unsafe { FdWrapper::new(Rc::clone(&xcb_connection)) };

handle
    .insert_source(
        Generic::new_with_error::<EventHandlerError>(
            fd,
            calloop::Interest::READ,
            calloop::Mode::Level,
        ),
        {
            let xcb_connection = xcb_connection.clone();
            move |_readiness, _, client| {
                client.process_x11_events(&xcb_connection)?;
                Ok(calloop::PostAction::Continue)
            }
        },
    )
    .map_err(|err| anyhow!("Failed to initialize X11 event source: {err:?}"))?;

handle
    .insert_source(XDPEventSource::new(&common.background_executor), {
        move |event, _, client| match event {
            XDPEvent::WindowAppearance(appearance) => {
                client.with_common(|common| common.appearance = appearance);
                for window in client.0.borrow_mut().windows.values_mut() {
                    window.window.set_appearance(appearance);
                }
            }
            XDPEvent::CursorTheme(_) | XDPEvent::CursorSize(_) => {
                // noop, X11 manages this for us.
            }
        }
    })
    .map_err(|err| anyhow!("Failed to initialize XDP event source: {err:?}"))?;

xcb_flush(&xcb_connection);

Ok(X11Client(Rc::new(RefCell::new(X11ClientState {
    modifiers: Modifiers::default(),
    capslock: Capslock::default(),
    last_modifiers_changed_event: Modifiers::default(),
    last_capslock_changed_event: Capslock::default(),
    event_loop: Some(event_loop),
    loop_handle: handle,
    common,
    last_click: Instant::now(),
    last_mouse_button: None,
    last_location: Point::new(px(0.0), px(0.0)),
    current_count: 0,
    gpu_context,
    scale_factor,

    xkb_context,
    xcb_connection,
    xkb_device_id,
    client_side_decorations_supported,
    x_root_index,
    _resource_database: resource_database,
    atoms,
    windows: HashMap::default(),
    mouse_focused_window: None,
    keyboard_focused_window: None,
    xkb: xkb_state,
    keyboard_layout,
    ximc,
    xim_handler,

    compose_state,
    pre_edit_text: None,
    pre_key_char_down: None,
    composing: false,

```

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

### Timer::interval_at - periodic timer starting at instant example

Source: https://docs.rs/gpui/latest/gpui/struct.Timer.html

Creates a timer that emits events periodically, starting at the given start instant. The example creates a one-second interval starting now and awaits the next event.

```rust
use async_io::Timer;
use futures_lite::StreamExt;
use std::time::{Duration, Instant};

let start = Instant::now();
let period = Duration::from_secs(1);
Timer::interval_at(start, period).next().await;
```

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

### Initialize WaylandClient with globals binding and event loop setup

Source: https://docs.rs/gpui/latest/src/gpui/platform/linux/wayland/client.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Connects to the Wayland environment, initializes the registry queue, binds wl_seat and wl_output globals with version clamping, sets up the event loop with a channel source, creates a BladeContext, and initializes data device and primary selection.

```rust
impl WaylandClient {
    pub(crate) fn new() -> Self {
        let conn = Connection::connect_to_env().unwrap();

        let (globals, mut event_queue) =
            registry_queue_init::<WaylandClientStatePtr>(&conn).unwrap();
        let qh = event_queue.handle();

        let mut seat: Option<wl_seat::WlSeat> = None;
        #[allow(clippy::mutable_key_type)]
        let mut in_progress_outputs = HashMap::default();
        globals.contents().with_list(|list| {
            for global in list {
                match &global.interface[..] {
                    "wl_seat" => {
                        seat = Some(globals.registry().bind::<wl_seat::WlSeat, _, _>(
                            global.name,
                            wl_seat_version(global.version),
                            &qh,
                            (),
                        ));
                    }
                    "wl_output" => {
                        let output = globals.registry().bind::<wl_output::WlOutput, _, _>(
                            global.name,
                            wl_output_version(global.version),
                            &qh,
                            (),
                        );
                        in_progress_outputs.insert(output.id(), InProgressOutput::default());
                    }
                    _ => {}
                }
            }
        });

        let event_loop = EventLoop::<WaylandClientStatePtr>::try_new().unwrap();

        let (common, main_receiver) = LinuxCommon::new(event_loop.get_signal());

        let handle = event_loop.handle();
        handle
            .insert_source(main_receiver, {
                let handle = handle.clone();
                move |event, _, _: &mut WaylandClientStatePtr| {
                    if let calloop::channel::Event::Msg(runnable) = event {
                        handle.insert_idle(|_| {
                            runnable.run();
                        });
                    }
                }
            })
            .unwrap();

        let gpu_context = BladeContext::new().expect("Unable to init GPU context");

        let seat = seat.unwrap();
        let globals = Globals::new(
            globals,
            common.foreground_executor.clone(),
            qh.clone(),
            seat.clone(),
        );

        let data_device = globals
            .data_device_manager
            .as_ref()
            .map(|data_device_manager| data_device_manager.get_data_device(&seat, &qh, ()));

        let primary_selection = globals
        
```

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

### setup

Source: https://docs.rs/gpui/latest/gpui/type.InspectorRenderer.html

Gets the setup information sent by the X11 server.

```APIDOC
## setup

### Description
Gets the setup information sent by the X11 server.

### Method
setup

### Signature
fn setup(&self) -> &Setup

### Parameters
None

### Returns
- **&Setup** - A reference to the setup information.

```

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

### init(cx: &mut App)

Source: https://docs.rs/gpui/latest/gpui/struct.SystemWindowTabController.html?search=u32+-%3E+bool

Initializes the global window tab controller.

```APIDOC
## init(cx: &mut App)

### Description
Initializes the global window tab controller.

### Method
init

### Signature
pub fn init(cx: &mut App)

### Parameters
- **cx** (&mut App) - Required - The application context.
```

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

### Point::min example

Source: https://docs.rs/gpui/latest/gpui/struct.Point.html

Example of using the min method to get a point with the minimum coordinates from two points.

```rust
let p1 = Point { x: 3, y: 7 };
let p2 = Point { x: 5, y: 2 };
let min_point = p1.min(&p2);
assert_eq!(min_point, Point { x: 3, y: 2 });
```

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

### expect example (recommended message style)

Source: https://docs.rs/gpui/latest/gpui/type.Result.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Recommended expect message style: describe the reason you expect the Result to be Ok. The example uses a message with 'should'.

```rust
let path = std::env::var("IMPORTANT_PATH")
    .expect("env variable `IMPORTANT_PATH` should be set by `wrapper_script.sh`");
```

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

### Box::take example

Source: https://docs.rs/gpui/latest/gpui/type.InspectorRenderer.html

Example of using Box::take to consume a box without deallocating, then reusing the allocation with Box::write.

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

let c = Box::new(5);

// take the value out of the box
let (value, uninit) = Box::take(c);
assert_eq!(value, 5);

// reuse the box for a second value
let c = Box::write(uninit, 6);
assert_eq!(*c, 6);
```

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

### Point::max example

Source: https://docs.rs/gpui/latest/gpui/struct.Point.html

Example of using the max method to get a point with the maximum coordinates from two points.

```rust
let p1 = Point { x: 3, y: 7 };
let p2 = Point { x: 5, y: 2 };
let max_point = p1.max(&p2);
assert_eq!(max_point, Point { x: 5, y: 7 });
```

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

### X11Client::new() initialization with event loop and XCB setup

Source: https://docs.rs/gpui/latest/src/gpui/platform/linux/x11/client.rs.html?search=u32+-%3E+bool

Initializes the X11Client by creating an event loop, inserting a source for the main receiver, connecting to the X server, prefetching extension information, querying XInput version, checking compositor and GTK frame extents support, and initializing XKB. Requires XInput version >= 2 and XKB support.

```rust
pub(crate) fn new() -> anyhow::Result<Self> {
    let event_loop = EventLoop::try_new()?;

    let (common, main_receiver) = LinuxCommon::new(event_loop.get_signal());

    let handle = event_loop.handle();

    handle
        .insert_source(main_receiver, {
            let handle = handle.clone();
            move |event, _, _: &mut X11Client| {
                if let calloop::channel::Event::Msg(runnable) = event {
                    // Insert the runnables as idle callbacks, so we make sure that user-input and X11
                    // events have higher priority and runnables are only worked off after the event
                    // callbacks.
                    handle.insert_idle(|_| {
                        runnable.run();
                    });
                }
            }
        })
        .map_err(|err| {
            anyhow!("Failed to initialize event loop handling of foreground tasks: {err:?}")
        })?;

    let (xcb_connection, x_root_index) = XCBConnection::connect(None)?;
    xcb_connection.prefetch_extension_information(xkb::X11_EXTENSION_NAME)?;
    xcb_connection.prefetch_extension_information(randr::X11_EXTENSION_NAME)?;
    xcb_connection.prefetch_extension_information(render::X11_EXTENSION_NAME)?;
    xcb_connection.prefetch_extension_information(xinput::X11_EXTENSION_NAME)?;

    // Announce to X server that XInput up to 2.1 is supported. To increase this to 2.2 and
    // beyond, support for touch events would need to be added.
    let xinput_version = get_reply(
        || "XInput XiQueryVersion failed",
        xcb_connection.xinput_xi_query_version(2, 1),
    )?;
    assert!(
        xinput_version.major_version >= 2,
        "XInput version >= 2 required."
    );

    let pointer_device_states =
        current_pointer_device_states(&xcb_connection, &BTreeMap::new()).unwrap_or_default();

    let atoms = XcbAtoms::new(&xcb_connection)
        .context("Failed to get XCB atoms")?
        .reply()
        .context("Failed to get XCB atoms")?;

    let root = xcb_connection.setup().roots[0].root;
    let compositor_present = check_compositor_present(&xcb_connection, root);
    let gtk_frame_extents_supported =
        check_gtk_frame_extents_supported(&xcb_connection, &atoms, root);
    let client_side_decorations_supported = compositor_present && gtk_frame_extents_supported;
    log::info!(
        "x11: compositor present: {}, gtk_frame_extents_supported: {}",
        compositor_present,
        gtk_frame_extents_supported
    );

    let xkb = get_reply(
        || "Failed to initialize XKB extension",
        xcb_connection
            .xkb_use_extension(XKB_X11_MIN_MAJOR_XKB_VERSION, XKB_X11_MIN_MINOR_XKB_VERSION),
    )?;
    assert!(xkb.supported);

    let events = xkb::EventType::STATE_NOTIFY
        | xkb::EventType::MAP_NOTIFY
        | xkb::EventType::NEW_KEYBOARD_NOTIFY;
    let map_notify_parts = xkb::MapPart::KEY_TYPES
        | xkb::MapPart::KEY_SYMS
        | xkb::MapPart::MODIFIER_MAP
        | xkb::MapPart::EXPLICIT_COMPONENTS
        | xkb::MapPart::KEY_ACTIONS
        | xkb::MapPart::KEY_BEHAVIORS
        | xkb::MapPart::VIRTUAL_MODS
        | xkb::MapPart::VIRTUAL_MOD_MAP;
    check_reply(
        || "Failed to select XKB events",
        xcb_connection.xkb_select_events(
            xkb::ID::USE_CORE_KBD.into(),
            0u8.into(),
            events,
            map_notify_parts,
            map_notify_parts,
        ),
    )?;
}
```

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

### Timer::set_interval_at - reset timer to periodic starting at instant example

Source: https://docs.rs/gpui/latest/gpui/struct.Timer.html

Sets the timer to emit events periodically, starting at the given start instant. Note that resetting does not remove the waker associated with the polling task.

```rust
use async_io::Timer;
use futures_lite::StreamExt;
use std::time::{Duration, Instant};

let mut t = Timer::after(Duration::from_secs(1));

let start = Instant::now();
let period = Duration::from_secs(2);
t.set_interval_at(start, period);
```

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

### Size map method example

Source: https://docs.rs/gpui/latest/src/gpui/geometry.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Shows how to use Size::map to convert a Size<T> to Size<U> by applying a closure to each dimension, with an example converting integers to floats.

```rust
/// ```
/// # use gpui::Size;
/// let my_size = Size { width: 10, height: 20 };
/// let my_new_size = my_size.map(|dimension| dimension as f32 * 1.5);
/// assert_eq!(my_new_size, Size { width: 15.0, height: 30.0 });
/// ```
```

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

### X11 Client Initialization with XKB, GPU, and Event Sources

Source: https://docs.rs/gpui/latest/src/gpui/platform/linux/x11/client.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Initializes the X11 client by setting up XKB keyboard state, GPU context, resource database, cursor handle, clipboard, XIM handler, and registering event sources for X11 and XDP events. Requires an existing xcb_connection and x_root_index. The XDP event source handles window appearance and cursor theme changes, with cursor theme changes being no-ops on X11.

```rust
                &xkb::SelectEventsAux::new(),
            ),
        )?;

        let xkb_context = xkbc::Context::new(xkbc::CONTEXT_NO_FLAGS);
        let xkb_device_id = xkbc::x11::get_core_keyboard_device_id(&xcb_connection);
        let xkb_state = {
            let xkb_keymap = xkbc::x11::keymap_new_from_device(
                &xkb_context,
                &xcb_connection,
                xkb_device_id,
                xkbc::KEYMAP_COMPILE_NO_FLAGS,
            );
            xkbc::x11::state_new_from_device(&xkb_keymap, &xcb_connection, xkb_device_id)
        };
        let compose_state = get_xkb_compose_state(&xkb_context);
        let layout_idx = xkb_state.serialize_layout(STATE_LAYOUT_EFFECTIVE);
        let layout_name = xkb_state
            .get_keymap()
            .layout_get_name(layout_idx)
            .to_string();
        let keyboard_layout = LinuxKeyboardLayout::new(layout_name.into());

        let gpu_context = BladeContext::new().context("Unable to init GPU context")?;

        let resource_database = x11rb::resource_manager::new_from_default(&xcb_connection)
            .context("Failed to create resource database")?;
        let scale_factor = get_scale_factor(&xcb_connection, &resource_database, x_root_index);
        let cursor_handle = cursor::Handle::new(&xcb_connection, x_root_index, &resource_database)
            .context("Failed to initialize cursor theme handler")?
            .reply()
            .context("Failed to initialize cursor theme handler")?;

        let clipboard = Clipboard::new().context("Failed to initialize clipboard")?;

        let xcb_connection = Rc::new(xcb_connection);

        let ximc = X11rbClient::init(Rc::clone(&xcb_connection), x_root_index, None).ok();
        let xim_handler = if ximc.is_some() {
            Some(XimHandler::new())
        } else {
            None
        };

        // Safety: Safe if xcb::Connection always returns a valid fd
        let fd = unsafe { FdWrapper::new(Rc::clone(&xcb_connection)) };

        handle
            .insert_source(
                Generic::new_with_error::<EventHandlerError>(
                    fd,
                    calloop::Interest::READ,
                    calloop::Mode::Level,
                ),
                {
                    let xcb_connection = xcb_connection.clone();
                    move |_readiness, _, client| {
                        client.process_x11_events(&xcb_connection)?;
                        Ok(calloop::PostAction::Continue)
                    }
                },
            )
            .map_err(|err| anyhow!("Failed to initialize X11 event source: {err:?}"))?;

        handle
            .insert_source(XDPEventSource::new(&common.background_executor), {
                move |event, _, client| match event {
                    XDPEvent::WindowAppearance(appearance) => {
                        client.with_common(|common| common.appearance = appearance);
                        for window in client.0.borrow_mut().windows.values_mut() {
                            window.window.set_appearance(appearance);
                        }
                    }
                    XDPEvent::CursorTheme(_) | XDPEvent::CursorSize(_) => {
                        // noop, X11 manages this for us.
                    }
                }
            })
            .map_err(|err| anyhow!("Failed to initialize XDP event source: {err:?}"))?;

        xcb_flush(&xcb_connection);

        Ok(X11Client(Rc::new(RefCell::new(X11ClientState {
            modifiers: Modifiers::default(),
            capslock: Capslock::default(),
            last_modifiers_changed_event: Modifiers::default(),
            last_capslock_changed_event: Capslock::default(),
            event_loop: Some(event_loop),
            loop_handle: handle,
            common,
            last_click: Instant::now(),
            last_mouse_button: None,
            last_location: Point::new(px(0.0), px(0.0)),
            current_count: 0,
            gpu_context,
            scale_factor,

            xkb_context,
            xcb_connection,
            xkb_device_id,
            client_side_decorations_supported,
            x_root_index,
            _resource_database: resource_database,
            atoms,
            windows: HashMap::default(),
            mouse_focused_window: None,
            keyboard_focused_window: None,
            xkb: xkb_state,
            keyboard_layout,
            ximc,
            xim_handler,

            compose_state,
            pre_edit_text: None,
            pre_key_char_down: None,
            composing: false,

```

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

### as_chunks example

Source: https://docs.rs/gpui/latest/gpui/struct.GlobalElementId.html?search=u32+-%3E+bool

Splits a slice into N-element arrays from the start, returning a remainder slice. The example shows a slice of length 5 with N=2, yielding chunks and a remainder.

```rust
let slice = ['l', 'o', 'r', 'e', 'm'];
let (chunks, remainder) = slice.as_chunks();
assert_eq!(chunks, &[['l', 'o'], ['r', 'e']]);
assert_eq!(remainder, &['m']);
```

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

### bottom_left() example

Source: https://docs.rs/gpui/latest/gpui/struct.Bounds.html

Creates a Bounds and calls bottom_left() to get the bottom-left corner point.

```rust
let bounds = Bounds {
    origin: Point { x: 0, y: 0 },
    size: Size { width: 10, height: 20 },
};
let bottom_left = bounds.bottom_left();
assert_eq!(bottom_left, Point { x: 0, y: 20 });
```

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

### App initialization with internal state and platform callbacks

Source: https://docs.rs/gpui/latest/src/gpui/app.rs.html?search=std%3A%3Avec

Initializes the App context with all internal fields, sets up platform callbacks for keyboard layout changes and quit, and initializes app menus and system window tab controller.

```rust
globals_by_type: FxHashMap::default(),
entities,
new_entity_observers: SubscriberSet::new(),
windows: SlotMap::with_key(),
window_update_stack: Vec::new(),
window_handles: FxHashMap::default(),
focus_handles: Arc::new(RwLock::new(SlotMap::with_key())),
keymap: Rc::new(RefCell::new(Keymap::default())),
keyboard_layout,
keyboard_mapper,
global_action_listeners: FxHashMap::default(),
pending_effects: VecDeque::new(),
pending_notifications: FxHashSet::default(),
pending_global_notifications: FxHashSet::default(),
observers: SubscriberSet::new(),
tracked_entities: FxHashMap::default(),
window_invalidators_by_entity: FxHashMap::default(),
event_listeners: SubscriberSet::new(),
release_listeners: SubscriberSet::new(),
keystroke_observers: SubscriberSet::new(),
keystroke_interceptors: SubscriberSet::new(),
keyboard_layout_observers: SubscriberSet::new(),
global_observers: SubscriberSet::new(),
quit_observers: SubscriberSet::new(),
restart_observers: SubscriberSet::new(),
restart_path: None,
window_closed_observers: SubscriberSet::new(),
layout_id_buffer: Default::default(),
propagate_event: true,
prompt_builder: Some(PromptBuilder::Default),
#[cfg(any(feature = "inspector", debug_assertions))]
inspector_renderer: None,
#[cfg(any(feature = "inspector", debug_assertions))]
inspector_element_registry: InspectorElementRegistry::default(),
quitting: false,

#[cfg(any(test, feature = "test-support", debug_assertions))]
name: None,
}),
});

init_app_menus(platform.as_ref(), &app.borrow());
SystemWindowTabController::init(&mut app.borrow_mut());

platform.on_keyboard_layout_change(Box::new({
    let app = Rc::downgrade(&app);
    move || {
        if let Some(app) = app.upgrade() {
            let cx = &mut app.borrow_mut();
            cx.keyboard_layout = cx.platform.keyboard_layout();
            cx.keyboard_mapper = cx.platform.keyboard_mapper();
            cx.keyboard_layout_observers
                .clone()
                .retain(&(), move |callback| (callback)(cx));
        }
    }
}));

platform.on_quit(Box::new({
    let cx = app.clone();
    move || {
        cx.borrow_mut().shutdown();
    }
}));

app
```

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

### bottom_right() example

Source: https://docs.rs/gpui/latest/gpui/struct.Bounds.html

Creates a Bounds and calls bottom_right() to get the bottom-right corner point.

```rust
let bounds = Bounds {
    origin: Point { x: 0, y: 0 },
    size: Size { width: 10, height: 20 },
};
let bottom_right = bounds.bottom_right();
assert_eq!(bottom_right, Point { x: 10, y: 20 });
```

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

### Example: Creating and scaling Pixels

Source: https://docs.rs/gpui/latest/gpui/struct.Pixels.html

Shows how to create a Pixels value from 10.0 and scale it by 2.0, resulting in ScaledPixels::from(20.0).

```rust
use gpui::{Pixels, ScaledPixels};

// Define a length of 10 pixels
let length = Pixels::from(10.0);

// Define a length and scale it by a factor of 2
let scaled_length = length.scale(2.0);
assert_eq!(scaled_length, ScaledPixels::from(20.0));
```

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

### Initialize X11Client with event loop and X server

Source: https://docs.rs/gpui/latest/src/gpui/platform/linux/x11/client.rs.html?search=std%3A%3Avec

Initializes the X11 client by setting up the event loop, connecting to the X server, prefetching X11 extension information, querying XInput version, retrieving atoms, checking compositor and GTK frame extents support, initializing XKB, and selecting XKB events. Includes a comment that XInput version 2.2 and beyond would require touch event support.

```rust
impl X11Client {
    pub(crate) fn new() -> anyhow::Result<Self> {
        let event_loop = EventLoop::try_new()?;

        let (common, main_receiver) = LinuxCommon::new(event_loop.get_signal());

        let handle = event_loop.handle();

        handle
            .insert_source(main_receiver, {
                let handle = handle.clone();
                move |event, _, _: &mut X11Client| {
                    if let calloop::channel::Event::Msg(runnable) = event {
                        // Insert the runnables as idle callbacks, so we make sure that user-input and X11
                        // events have higher priority and runnables are only worked off after the event
                        // callbacks.
                        handle.insert_idle(|_| {
                            runnable.run();
                        });
                    }
                }
            })
            .map_err(|err| {
                anyhow!("Failed to initialize event loop handling of foreground tasks: {err:?}")
            })?;

        let (xcb_connection, x_root_index) = XCBConnection::connect(None)?;
        xcb_connection.prefetch_extension_information(xkb::X11_EXTENSION_NAME)?;
        xcb_connection.prefetch_extension_information(randr::X11_EXTENSION_NAME)?;
        xcb_connection.prefetch_extension_information(render::X11_EXTENSION_NAME)?;
        xcb_connection.prefetch_extension_information(xinput::X11_EXTENSION_NAME)?;

        // Announce to X server that XInput up to 2.1 is supported. To increase this to 2.2 and
        // beyond, support for touch events would need to be added.
        let xinput_version = get_reply(
            || "XInput XiQueryVersion failed",
            xcb_connection.xinput_xi_query_version(2, 1),
        )?;
        assert!(
            xinput_version.major_version >= 2,
            "XInput version >= 2 required."
        );

        let pointer_device_states =
            current_pointer_device_states(&xcb_connection, &BTreeMap::new()).unwrap_or_default();

        let atoms = XcbAtoms::new(&xcb_connection)
            .context("Failed to get XCB atoms")?
            .reply()
            .context("Failed to get XCB atoms")?;

        let root = xcb_connection.setup().roots[0].root;
        let compositor_present = check_compositor_present(&xcb_connection, root);
        let gtk_frame_extents_supported =
            check_gtk_frame_extents_supported(&xcb_connection, &atoms, root);
        let client_side_decorations_supported = compositor_present && gtk_frame_extents_supported;
        log::info!(
            "x11: compositor present: {}, gtk_frame_extents_supported: {}",
            compositor_present,
            gtk_frame_extents_supported
        );

        let xkb = get_reply(
            || "Failed to initialize XKB extension",
            xcb_connection
                .xkb_use_extension(XKB_X11_MIN_MAJOR_XKB_VERSION, XKB_X11_MIN_MINOR_XKB_VERSION),
        )?;
        assert!(xkb.supported);

        let events = xkb::EventType::STATE_NOTIFY
            | xkb::EventType::MAP_NOTIFY
            | xkb::EventType::NEW_KEYBOARD_NOTIFY;
        let map_notify_parts = xkb::MapPart::KEY_TYPES
            | xkb::MapPart::KEY_SYMS
            | xkb::MapPart::MODIFIER_MAP
            | xkb::MapPart::EXPLICIT_COMPONENTS
            | xkb::MapPart::KEY_ACTIONS
            | xkb::MapPart::KEY_BEHAVIORS
            | xkb::MapPart::VIRTUAL_MODS
            | xkb::MapPart::VIRTUAL_MOD_MAP;
        check_reply(
            || "Failed to select XKB events",
            xcb_connection.xkb_select_events(
                xkb::ID::USE_CORE_KBD.into(),
                0u8.into(),
                events,
                map_notify_parts,
                map_notify_parts,
            ),
        )?;
    }
}
```

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

### top_right() example

Source: https://docs.rs/gpui/latest/gpui/struct.Bounds.html

Creates a Bounds and calls top_right() to get the top-right corner point.

```rust
let bounds = Bounds {
    origin: Point { x: 0, y: 0 },
    size: Size { width: 10, height: 20 },
};
let top_right = bounds.top_right();
assert_eq!(top_right, Point { x: 10, y: 0 });
```

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

### Wayland window creation with surface and toplevel setup

Source: https://docs.rs/gpui/latest/src/gpui/platform/linux/wayland/window.rs.html?search=

Creates a Wayland surface, XDG surface, and toplevel, sets parent for floating windows, applies minimum size, requests fractional scale, sets up decorations and viewport, and commits the surface.

```rust
    ) -> anyhow::Result<(Self, ObjectId)> {
        let surface = globals.compositor.create_surface(&globals.qh, ());
        let xdg_surface = globals
            .wm_base
            .get_xdg_surface(&surface, &globals.qh, surface.id());
        let toplevel = xdg_surface.get_toplevel(&globals.qh, surface.id());

        if params.kind == WindowKind::Floating {
            toplevel.set_parent(parent.as_ref());
        }

        if let Some(size) = params.window_min_size {
            toplevel.set_min_size(size.width.0 as i32, size.height.0 as i32);
        }

        if let Some(fractional_scale_manager) = globals.fractional_scale_manager.as_ref() {
            fractional_scale_manager.get_fractional_scale(&surface, &globals.qh, surface.id());
        }

        // Attempt to set up window decorations based on the requested configuration
        let decoration = globals
            .decoration_manager
            .as_ref()
            .map(|decoration_manager| {
                decoration_manager.get_toplevel_decoration(&toplevel, &globals.qh, surface.id())
            });

        let viewport = globals
            .viewporter
            .as_ref()
            .map(|viewporter| viewporter.get_viewport(&surface, &globals.qh, ()));

        let this = Self(WaylandWindowStatePtr {
            state: Rc::new(RefCell::new(WaylandWindowState::new(
                handle,
                surface.clone(),
                xdg_surface,
                toplevel,
                decoration,
                appearance,
                viewport,
                client,
                globals,
                gpu_context,
                params,
            )?)),
            callbacks: Rc::new(RefCell::new(Callbacks::default())),
        });

        // Kick things off
        surface.commit();

        Ok((this, surface.id()))
    }
}
```

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

### opposite_corner example

Source: https://docs.rs/gpui/latest/gpui/enum.Corner.html?search=

Shows how to use the opposite_corner method to get the directly opposite corner.

```rust
assert_eq!(Corner::TopLeft.opposite_corner(), Corner::BottomRight);
```

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

### App::new

Source: https://docs.rs/gpui/latest/src/gpui/app.rs.html

Creates a new App instance in normal mode, allowing windows to be opened.

```APIDOC
## App::new

### Description
Creates a new App instance in normal mode, allowing windows to be opened.

### Method
`App::new() -> Self`

### Parameters
None.

### Returns
- `Self` - A new App instance.

```

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

### rchunks_exact example

Source: https://docs.rs/gpui/latest/gpui/struct.GlobalElementId.html

Iterates over exact chunks from the end, omitting the remainder. Panics if chunk_size is zero. The example shows chunks of size 2 and uses remainder() to get the leftover element.

```rust
let slice = ['l', 'o', 'r', 'e', 'm'];
let mut iter = slice.rchunks_exact(2);
assert_eq!(iter.next().unwrap(), &['e', 'm']);
assert_eq!(iter.next().unwrap(), &['o', 'r']);
assert!(iter.next().is_none());
assert_eq!(iter.remainder(), &['l']);
```

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

### Example: top_right() usage

Source: https://docs.rs/gpui/latest/src/gpui/geometry.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Shows how to create a Bounds and call top_right() to get the top-right corner point.

```rust
# use gpui::{Bounds, Point, Size};
let bounds = Bounds {
    origin: Point { x: 0, y: 0 },
    size: Size { width: 10, height: 20 },
};
let top_right = bounds.top_right();
assert_eq!(top_right, Point { x: 10, y: 0 });
```

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

### WaylandClient::new() initialization

Source: https://docs.rs/gpui/latest/src/gpui/platform/linux/wayland/client.rs.html?search=

Sets up the Wayland client state, including event sources for window appearance, cursor theme, and cursor size, and initializes the WaylandClientState struct with all necessary fields.

```rust
        let mut cursor = Cursor::new(&conn, &globals, 24);

        handle
            .insert_source(XDPEventSource::new(&common.background_executor), {
                move |event, _, client| match event {
                    XDPEvent::WindowAppearance(appearance) => {
                        if let Some(client) = client.0.upgrade() {
                            let mut client = client.borrow_mut();

                            client.common.appearance = appearance;

                            for window in client.windows.values_mut() {
                                window.set_appearance(appearance);
                            }
                        }
                    }
                    XDPEvent::CursorTheme(theme) => {
                        if let Some(client) = client.0.upgrade() {
                            let mut client = client.borrow_mut();
                            client.cursor.set_theme(theme);
                        }
                    }
                    XDPEvent::CursorSize(size) => {
                        if let Some(client) = client.0.upgrade() {
                            let mut client = client.borrow_mut();
                            client.cursor.set_size(size);
                        }
                    }
                }
            })
            .unwrap();

        let mut state = Rc::new(RefCell::new(WaylandClientState {
            serial_tracker: SerialTracker::new(),
            globals,
            gpu_context,
            wl_seat: seat,
            wl_pointer: None,
            wl_keyboard: None,
            cursor_shape_device: None,
            data_device,
            primary_selection,
            text_input: None,
            pre_edit_text: None,
            ime_pre_edit: None,
            composing: false,
            outputs: HashMap::default(),
            in_progress_outputs,
            windows: HashMap::default(),
            common,
            keyboard_layout: LinuxKeyboardLayout::new(UNKNOWN_KEYBOARD_LAYOUT_NAME),
            keymap_state: None,
            compose_state: None,
            drag: DragState {
                data_offer: None,
                window: None,
                position: Point::default(),
            },
            click: ClickState {
                last_click: Instant::now(),
                last_mouse_button: None,
                last_location: Point::default(),
                current_count: 0,
            },
            repeat: KeyRepeat {
                characters_per_second: 16,
                delay: Duration::from_millis(500),
                current_id: 0,
                current_keycode: None,
            },
            modifiers: Modifiers {
                shift: false,
                control: false,
                alt: false,
                function: false,
                platform: false,
            },
            capslock: Capslock { on: false },
            scroll_event_received: false,
            axis_source: AxisSource::Wheel,
            mouse_location: None,
            continuous_scroll_delta: None,
            discrete_scroll_delta: None,
            vertical_modifier: -1.0,
            horizontal_modifier: -1.0,
            button_pressed: None,
            mouse_focused_window: None,
            keyboard_focused_window: None,
            loop_handle: handle.clone(),
            enter_token: None,
            cursor_style: None,
            clipboard: Clipboard::new(conn.clone(), handle.clone()),
            data_offers: Vec::new(),
            primary_data_offer: None,
            cursor,
            pending_activation: None,
            event_loop: Some(event_loop),
        }));

        WaylandSource::new(conn, event_queue)
            .insert(handle)
            .unwrap();

        Self(state)
```

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

### AsyncApp::open_window

Source: https://docs.rs/gpui/latest/gpui/struct.AsyncApp.html?search=

Opens a new window with the given options and root view.

```APIDOC
## AsyncApp::open_window

### Description
Open a window with the given options based on the root view returned by the given function.

### Method
`pub fn open_window<V>(&self, options: WindowOptions, build_root_view: impl FnOnce(&mut Window, &mut App) -> Entity<V>) -> Result<WindowHandle<V>>`

### Parameters
- `options` (`WindowOptions`) - Required - The options for the new window.
- `build_root_view` (closure) - Required - A closure that builds the root view, taking a mutable reference to `Window` and `App`, and returning an `Entity<V>`.

### Type Constraints
- `V: 'static + Render`

### Returns
- `Result<WindowHandle<V>>` - A handle to the new window, or an error if the App has been dropped.
```

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

### get() example

Source: https://docs.rs/gpui/latest/gpui/struct.GlobalElementId.html

Returns a reference to an element or subslice depending on the type of index. Returns None if out of bounds.

```rust
let v = [10, 40, 30];
assert_eq!(Some(&40), v.get(1));
assert_eq!(Some(&[10, 40][..]), v.get(0..2));
assert_eq!(None, v.get(3));
assert_eq!(None, v.get(0..4));
```

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

### other_side_corner_along example

Source: https://docs.rs/gpui/latest/gpui/enum.Corner.html?search=

Shows how to use the other_side_corner_along method with an Axis to get the corner across along that axis.

```rust
let result = Corner::TopLeft.other_side_corner_along(Axis::Horizontal);
assert_eq!(result, Corner::TopRight);
```

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

### init

Source: https://docs.rs/gpui/latest/gpui/struct.SystemWindowTabController.html?search=

Initializes the global window tab controller.

```APIDOC
## init

### Description
Initializes the global window tab controller.

### Method
`pub fn init(cx: &mut App)`

### Parameters
- `cx` (`&mut App`) - The application context.

### Returns
None.
```

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

### Using AvailableSpace::min_size()

Source: https://docs.rs/gpui/latest/gpui/enum.AvailableSpace.html

Example showing how to create a Size with both dimensions set to AvailableSpace::MinContent using the min_size method.

```rust
use gpui::AvailableSpace;
let min_content_size = AvailableSpace::min_size();
assert_eq!(min_content_size.width, AvailableSpace::MinContent);
assert_eq!(min_content_size.height, AvailableSpace::MinContent);
```

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

### corner() example

Source: https://docs.rs/gpui/latest/gpui/struct.Bounds.html

Imports gpui types and calls corner(Corner::BottomLeft) to get the requested corner point.

```rust
use gpui::{Bounds, Corner, Point, Size};
let bounds = Bounds {
    origin: Point { x: 0, y: 0 },
    size: Size { width: 10, height: 20 },
};
let bottom_left = bounds.corner(Corner::BottomLeft);
assert_eq!(bottom_left, Point { x: 0, y: 20 });
```

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

### Get IME area bounds

Source: https://docs.rs/gpui/latest/src/gpui/platform/linux/wayland/window.rs.html?search=std%3A%3Avec

Retrieves the bounds for the IME area based on the marked text range selection start.

```rust
pub fn get_ime_area(&self) -> Option<Bounds<Pixels>> {
    let mut state = self.state.borrow_mut();
    let mut bounds: Option<Bounds<Pixels>> = None;
    if let Some(mut input_handler) = state.input_handler.take() {
        drop(state);
        if let Some(selection) = input_handler.marked_text_range() {
            bounds = input_handler.bounds_for_range(selection.start..selection.start);
        }
        self.state.borrow_mut().input_handler = Some(input_handler);
    }
    bounds
}
```

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

### point function constructor example

Source: https://docs.rs/gpui/latest/src/gpui/geometry.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Shows how to use the `point` function to create a Point with given x and y coordinates, and verifies the values with assertions.

```rust
/// Constructs a new `Point<T>` with the given x and y coordinates.
///
/// # Arguments
///
/// * `x` - The x coordinate of the point.
/// * `y` - The y coordinate of the point.
///
/// # Returns
///
/// Returns a `Point<T>` with the specified coordinates.
///
/// # Examples
///
/// ```
/// use gpui::point;
/// let p = point(10, 20);
/// assert_eq!(p.x, 10);
/// assert_eq!(p.y, 20);
/// ```
pub const fn point<T: Clone + Debug + Default + PartialEq>(x: T, y: T) -> Point<T> {
    Point { x, y }
}
```

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

### into_err() Example

Source: https://docs.rs/gpui/latest/gpui/type.Result.html?search=

Shows how to use into_err() on a Result with an infallible Ok type (!) to get the Err value without panicking.

```rust
fn only_bad_news() -> Result<!, String> {
    Err("Oops, it failed".into())
}

let error: String = only_bad_news().into_err();
println!("{error}");
```

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

### KeyContext::new_with_defaults

Source: https://docs.rs/gpui/latest/gpui/struct.KeyContext.html?search=

Initializes a new KeyContext with an 'os' key set to the current operating system identifier.

```APIDOC
## KeyContext::new_with_defaults

### Description
Initializes a new `KeyContext` that contains an `os` key set to either `macos`, `linux`, `windows` or `unknown`.

### Method
`pub fn new_with_defaults() -> Self`

### Parameters
None

### Returns
- `Self` - A new `KeyContext` instance with the `os` key set.
```
Tokens:
Raw