Vendor things

third-party/vendor/wayland-client/examples/dynamic_globals.rs

@@ -0,0 +1,110 @@
+#[macro_use]
+extern crate wayland_client;
+
+use wayland_client::{Display, GlobalManager, Main};
+
+use wayland_client::protocol::{wl_output, wl_seat};
+
+// An example showcasing the capability of GlobalManager to handle
+// dynamically created globals like wl_seat or wl_output, which can
+// exist with multiplicity and created at any time
+
+fn main() {
+    let display = Display::connect_to_env().unwrap();
+
+    let mut event_queue = display.create_event_queue();
+
+    let attached_display = (*display).clone().attach(event_queue.token());
+
+    // We create a GlobalManager with a callback, that will be
+    // advertised of any global creation or deletion
+    let _globals = GlobalManager::new_with_cb(
+        &attached_display,
+        // This macro generates a callback for auto-creating the globals
+        // that interest us and calling our provided callbacks
+        global_filter!(
+            // Here we ask that all seats be automatically instantiated
+            // with version 1 when advertised, and provide a callback that
+            // will handle the created wl_seat to implement them
+            //
+            // NOTE: the type annotations are necessary because rustc's
+            // inference is apparently not smart enough
+            [wl_seat::WlSeat, 1, |seat: Main<wl_seat::WlSeat>, _: DispatchData| {
+                let mut seat_name = None;
+                let mut caps = None;
+                seat.quick_assign(move |_, event, _| {
+                    use wayland_client::protocol::wl_seat::Event;
+                    match event {
+                        Event::Name { name } => {
+                            seat_name = Some(name);
+                        }
+                        Event::Capabilities { capabilities } => {
+                            // We *should* have received the "name" event first
+                            caps = Some(capabilities);
+                        }
+                        _ => {}
+                    }
+                    if let (Some(ref name), Some(caps)) = (&seat_name, caps) {
+                        println!("Seat '{}' with caps: {:x}", name, caps);
+                    }
+                })
+            }],
+            // Same thing with wl_output, but we require version 2
+            [wl_output::WlOutput, 2, |output: Main<wl_output::WlOutput>, _: DispatchData| {
+                let mut name = "<unknown>".to_owned();
+                let mut modes = vec![];
+                let mut scale = 1;
+                output.quick_assign(move |_, event, _| {
+                    use wayland_client::protocol::wl_output::Event;
+                    match event {
+                        Event::Geometry {
+                            x,
+                            y,
+                            physical_width,
+                            physical_height,
+                            subpixel,
+                            make,
+                            model,
+                            transform,
+                        } => {
+                            println!("New output: \"{} ({})\"", make, model);
+                            println!(
+                                " -> physical dimensions {}x{}",
+                                physical_width, physical_height
+                            );
+                            println!(" -> location in the compositor space: ({}, {})", x, y);
+                            println!(" -> transform: {:?}", transform);
+                            println!(" -> subpixel orientation: {:?}", subpixel);
+                            name = format!("{} ({})", make, model);
+                        }
+                        Event::Mode { flags, width, height, refresh } => {
+                            modes.push((flags, width, height, refresh));
+                        }
+                        Event::Scale { factor } => {
+                            scale = factor;
+                        }
+                        Event::Done => {
+                            println!("Modesetting information for output \"{}\"", name);
+                            println!(" -> scaling factor: {}", scale);
+                            println!(" -> mode list:");
+                            for &(f, w, h, r) in &modes {
+                                println!(
+                                    "   -> {}x{} @{}Hz (flags: [ {:?} ])",
+                                    w,
+                                    h,
+                                    (r as f32) / 1000.0,
+                                    f
+                                );
+                            }
+                        }
+                        _ => unreachable!(),
+                    }
+                })
+            }]
+        ),
+    );
+
+    event_queue.sync_roundtrip(&mut (), |_, _, _| unreachable!()).unwrap();
+    event_queue.sync_roundtrip(&mut (), |_, _, _| unreachable!()).unwrap();
+    event_queue.sync_roundtrip(&mut (), |_, _, _| unreachable!()).unwrap();
+}