read_loop now happens on its own thread, replace WlClient::new() with blocking run()

src/main.rs

@@ -6,7 +6,7 @@ use wayland::wl_client::WlClient;
 mod graphics;
 
 fn main() -> Result<(), Box<dyn Error>> {
-    let mut wl_client = WlClient::new()?;
+    let mut wl_client = WlClient::run()?;
 
     Ok(())
 }

src/wayland/layer_shell.rs

@@ -6,7 +6,7 @@ const OVERLAY: u32 = 3;
 const EXCLUSIVE: u32 = 0; // exclusize keyboard focus
 
 impl WlClient {
-    pub fn layer_shell_get_layer_surface(&mut self) -> Result<(), Box<dyn Error>> {
+    pub fn layer_shell_get_layer_surface(&self) -> Result<(), Box<dyn Error>> {
         // TODO: Make sure layer_surface_id isn't already set
         let object: u32 = self.layer_shell_id.load(Ordering::Relaxed);
         if object == 0 {
@@ -36,13 +36,13 @@ impl WlClient {
         request.write_u32(&OVERLAY, &mut offset);
         request.write_string(&NAMESPACE.to_string(), &mut offset);
 
-        self.socket.write(&request)?;
+        self.socket.lock().unwrap().write(&request)?;
         self.layer_surface_id.store(current_id, Ordering::Relaxed);
 
         Ok(())
     }
 
-    pub fn layer_surface_configure(&mut self, event: &Vec<u8>) -> Result<(), Box<dyn Error>> {
+    pub fn layer_surface_configure(&self, event: &Vec<u8>) -> Result<(), Box<dyn Error>> {
         let mut offset: usize = 0;
         let serial = event.read_u32(&mut offset);
         let width  = event.read_u32(&mut offset);
@@ -67,7 +67,7 @@ impl WlClient {
 
         request.write_u32(&serial, &mut offset);
 
-        self.socket.write(&request)?;
+        self.socket.lock().unwrap().write(&request)?;
 
         self.wl_surface_attach()?;
         self.wl_surface_commit()?;
@@ -75,7 +75,7 @@ impl WlClient {
         Ok(())
     }
 
-    pub fn layer_surface_set_size(&mut self, width: u32, height: u32) -> Result<(), Box<dyn Error>> {
+    pub fn layer_surface_set_size(&self, width: u32, height: u32) -> Result<(), Box<dyn Error>> {
         let object: u32 = self.layer_surface_id.load(Ordering::Relaxed);
         if object == 0 {
             return Err(UnsetErr("layer_surface_id".to_string()).into());
@@ -93,12 +93,12 @@ impl WlClient {
         request.write_u32(&width,    &mut offset);
         request.write_u32(&height,   &mut offset);
 
-        self.socket.write(&request)?;
+        self.socket.lock().unwrap().write(&request)?;
 
         Ok(())
     }
 
-    pub fn layer_surface_set_keyboard_interactivity(&mut self) -> Result<(), Box<dyn Error>> {
+    pub fn layer_surface_set_keyboard_interactivity(&self) -> Result<(), Box<dyn Error>> {
         let object: u32 = self.layer_surface_id.load(Ordering::Relaxed);
         if object == 0 {
             return Err(UnsetErr("layer_surface_id".to_string()).into());
@@ -115,7 +115,7 @@ impl WlClient {
 
         request.write_u32(&EXCLUSIVE, &mut offset);
 
-        self.socket.write(&request)?;
+        self.socket.lock().unwrap().write(&request)?;
 
         Ok(())
     }

src/wayland/surface.rs

@@ -15,7 +15,7 @@ impl fmt::Display for UnsetErr {
 }
 
 impl WlClient {
-    pub fn wl_compositor_create_surface(&mut self) -> Result<(), Box<dyn Error>> {
+    pub fn wl_compositor_create_surface(&self) -> Result<(), Box<dyn Error>> {
         let object = self.compositor_id.load(Ordering::Relaxed);
         if object == 0 {
             return Err(UnsetErr("compositor_id".to_string()).into());
@@ -33,14 +33,14 @@ impl WlClient {
         let current_id = self.current_id.fetch_add(1, Ordering::Relaxed) + 1;
         request.write_u32(&current_id, &mut offset);
 
-        self.socket.write(&request)?;
+        self.socket.lock().unwrap().write(&request)?;
 
         self.surface_id.store(current_id, Ordering::Relaxed);
 
         Ok(())
     }
 
-    pub fn wl_surface_attach(&mut self) -> Result<(), Box<dyn Error>> {
+    pub fn wl_surface_attach(&self) -> Result<(), Box<dyn Error>> {
         let object = self.surface_id.load(Ordering::Relaxed);
         if object == 0 {
             return Err(UnsetErr("surface_id".to_string()).into());
@@ -64,12 +64,12 @@ impl WlClient {
         request.write_u32(&X,	     &mut offset);
         request.write_u32(&Y,	     &mut offset);
 
-        self.socket.write(&request)?;
+        self.socket.lock().unwrap().write(&request)?;
 
         Ok(())
     }
 
-    pub fn wl_surface_commit(&mut self) -> Result<(), Box<dyn Error>> {
+    pub fn wl_surface_commit(&self) -> Result<(), Box<dyn Error>> {
         let object = self.surface_id.load(Ordering::Relaxed);
         if object == 0 {
             return Err(UnsetErr("surface_id".to_string()).into());
@@ -84,12 +84,12 @@ impl WlClient {
         request.write_u16(&OPCODE,   &mut offset);
         request.write_u16(&MSG_SIZE, &mut offset);
 
-        self.socket.write(&request)?;
+        self.socket.lock().unwrap().write(&request)?;
 
         Ok(())
     }
 
-    pub fn xdg_wm_base_pong(&mut self, event: &Vec<u8>) -> Result<(), Box<dyn Error>> {
+    pub fn xdg_wm_base_pong(&self, event: &Vec<u8>) -> Result<(), Box<dyn Error>> {
         let object = self.xdg_wm_base_id.load(Ordering::Relaxed);
         if object == 0 {
             return Err(UnsetErr("xdg_wm_base_id".to_string()).into());
@@ -106,7 +106,7 @@ impl WlClient {
         request.write_u16(&MSG_SIZE, &mut offset);
         request.write_u32(&serial,   &mut offset);
 
-        self.socket.write(&request)?;
+        self.socket.lock().unwrap().write(&request)?;
 
         Ok(())
     }

src/wayland/wl_client.rs

@@ -1,4 +1,4 @@
-use std::{env::var, error::Error, fmt::Debug, io::Read, os::unix::net::UnixStream, sync::{atomic::{AtomicU32, Ordering}, Arc, Mutex}, thread, u32};
+use std::{env::var, error::Error, fmt::Debug, io::Read, os::unix::net::UnixStream, sync::{atomic::{AtomicU32, Ordering}, Arc, Mutex}, thread::{self, JoinHandle}, u32};
 
 use crate::wayland::shm;
 
@@ -9,11 +9,11 @@ struct WlHeader {
 }
 
 pub struct WlClient {
-    pub socket:             UnixStream,
+    pub socket:             Mutex<UnixStream>,
     pub current_id:         AtomicU32,
     pub registry_id:        AtomicU32,
     pub shm_id:             AtomicU32,
-    pub shm_pool:           Arc<Mutex<Option<shm::ShmPool>>>,
+    pub shm_pool:           Mutex<Option<shm::ShmPool>>,
     pub buffer_id:          AtomicU32,
     pub compositor_id:      AtomicU32,
     pub surface_id:         AtomicU32,
@@ -23,49 +23,47 @@ pub struct WlClient {
 }
 
 impl WlClient {
-    pub fn new() -> Result<Self, Box<dyn Error>> {
+    pub fn run() -> Result<Arc<Self>, Box<dyn Error>> {
         let sock = UnixStream::connect(format!(
             "{}/{}",
             var("XDG_RUNTIME_DIR")?,
             var("WAYLAND_DISPLAY")?
         ))?;
 
-        let mut wl_client = WlClient {
+        let mut wl_client = Arc::new(WlClient {
-            socket:             sock,
+            socket:             Mutex::new(sock),
             current_id:         AtomicU32::from(1),
             registry_id:        AtomicU32::from(0),
             shm_id:             AtomicU32::from(0),
-            shm_pool:           Arc::new(Mutex::new(None)),
+            shm_pool:           Mutex::new(None),
             buffer_id:          AtomicU32::from(0),
             compositor_id:      AtomicU32::from(0),
             surface_id:         AtomicU32::from(0),
             xdg_wm_base_id:     AtomicU32::from(0),
             layer_shell_id:     AtomicU32::from(0),
             layer_surface_id:   AtomicU32::from(0),
-        };
+        });
 
-        let shm_pool = wl_client.shm_pool.clone();
+        let mut wl_client2 = wl_client.clone();
-        thread::spawn(move || {
-        }).join();
-
-        wl_client.wl_display_get_registry()?;
 
+        wl_client.wl_display_get_registry();
+        let readloop = thread::spawn(move || {
             loop {
-            wl_client.read_event()?;
+                wl_client2.read_event();
+            }
+        });
 
-            if false {
+        readloop.join();
-                break
-            }
-        }
 
         Ok(wl_client)
     }
 
-    pub fn read_event(&mut self) -> Result<(), Box<dyn Error>> {
+    pub fn read_event(&self) -> Result<(), Box<dyn Error>> {
         // TODO: Don't realloc header and event
 
         let mut header = vec![0u8; 8];
-        self.socket.read_exact(&mut header)?;
+        let mut socket = self.socket.lock().unwrap();
+        socket.read_exact(&mut header)?;
 
         let header = WlHeader {
             object: u32::from_ne_bytes(header[0..4].try_into()?),
@@ -74,8 +72,15 @@ impl WlClient {
         };
 
         let mut event = vec![0u8; header.size as usize - 8];
-        self.socket.read_exact(&mut event)?;
+        socket.read_exact(&mut event)?;
+        drop(socket);
 
+        println!(
+            "Received event:\n\tObject: {}\n\tOpcode: {}\n\tSize: {}",
+            header.object,
+            header.opcode,
+            header.size
+        );
         if header.object == self.registry_id.load(Ordering::Relaxed) && header.opcode == 0 { // wl_registry::global
             self.wl_registry_global(&event)?;
         }
@@ -97,15 +102,8 @@ impl WlClient {
         else if header.object == self.surface_id.load(Ordering::Relaxed) && header.opcode == 3 { // wl_surface::preferred_buffer_transform
             println!("Preferred buffer transform: {}", i32::from_ne_bytes(event[0..4].try_into().unwrap()));
         }
-        else {
-            println!(
-                "Received event:\n\tObject: {}\n\tOpcode: {}\n\tSize: {}",
-                header.object,
-                header.opcode,
-                header.size
-            );
-        }
 
         Ok(())
     }
 }
+

src/wayland/wl_registry.rs

@@ -2,7 +2,7 @@ use crate::wayland::{surface::UnsetErr, vec_utils::WlMessage, wl_client::WlClien
 use std::{error::Error, io::Write, sync::atomic::{AtomicU32, Ordering}};
 
 impl WlClient {
-    fn init_toplevel(&mut self) -> Result<(), Box<dyn Error>> {
+    fn init_toplevel(&self) -> Result<(), Box<dyn Error>> {
         if self.shm_id.load(Ordering::Relaxed) == 0 {
             return Err(Box::new(UnsetErr("shm_id".to_string())));
         }
@@ -29,7 +29,7 @@ impl WlClient {
         Ok(())
     }
 
-    pub fn wl_display_get_registry(&mut self) -> Result<(), Box<dyn Error>> {
+    pub fn wl_display_get_registry(&self) -> Result<(), Box<dyn Error>> {
         const OBJECT: u32 = 1;
         const OPCODE: u16 = 1;
         const MSG_SIZE: u16 = 12;
@@ -44,13 +44,13 @@ impl WlClient {
         let current_id = self.current_id.fetch_add(1, Ordering::Relaxed) + 1;
         request.write_u32(&current_id, &mut offset);
 
-        self.socket.write(&request)?;
+        self.socket.lock().unwrap().write(&request)?;
         self.registry_id.store(current_id, Ordering::Relaxed);
 
         Ok(())
     }
 
-    pub fn wl_registry_global(&mut self, event: &Vec<u8>) -> Result<(), Box<dyn Error>> {
+    pub fn wl_registry_global(&self, event: &Vec<u8>) -> Result<(), Box<dyn Error>> {
         let mut offset: usize = 0;
 
         let name        = event.read_u32(&mut offset);
@@ -118,7 +118,7 @@ impl WlClient {
     }
 
     pub fn wl_registry_bind(
-        &mut self,
+        &self,
         name: &u32,
         interface: &String,
         version: &u32,
@@ -143,7 +143,7 @@ impl WlClient {
         request.write_u32    (&version,   &mut offset);
         request.write_u32    (&id,        &mut offset);
 
-        self.socket.write(&request)?;
+        self.socket.lock().unwrap().write(&request)?;
 
         Ok(())
     }

src/wayland/wl_shm.rs

@@ -9,7 +9,7 @@ impl WlClient {
         println!("Received pixel format: {:x}", event.read_u32(&mut offset));
     }
 
-    pub fn wl_shm_create_pool(&mut self, width: usize, height: usize) -> Result<(), Box<dyn Error>> {
+    pub fn wl_shm_create_pool(&self, width: usize, height: usize) -> Result<(), Box<dyn Error>> {
         let mut shm_pool = self.shm_pool.lock().unwrap();
         let current_id = self.current_id.fetch_add(1, Ordering::Relaxed) + 1;
         *shm_pool = Some(shm::ShmPool::new(width, height, current_id)?);
@@ -50,13 +50,13 @@ impl WlClient {
             ).into());
         }
 
-        self.socket.send_vectored_with_ancillary(&[std::io::IoSlice::new(&request)], &mut ancillary)?;
+        self.socket.lock().unwrap().send_vectored_with_ancillary(&[std::io::IoSlice::new(&request)], &mut ancillary)?;
 
         Ok(())
     }
 
     pub fn wl_shm_pool_create_buffer(
-        &mut self,
+        &self,
         shm_offset: u32,
         width:      u32,
         height:     u32
@@ -84,7 +84,7 @@ impl WlClient {
         request.write_u32(&stride,      &mut offset);
         request.write_u32(&format,      &mut offset);
 
-        self.socket.write(&request)?;
+        self.socket.lock().unwrap().write(&request)?;
 
         self.buffer_id.store(current_id, Ordering::Relaxed);