Move wl::{display, error}, wl_registry::{global, bind} from main.rs to wl_registry.rs

src/main.rs

@@ -1,8 +1,9 @@
 #![feature(unix_socket_ancillary_data)]
-use std::{env, error::Error, io::{Read, Write}, os::unix::net::{UnixStream, SocketAncillary}, u32};
+use std::{env::var, error::Error, io::Read, os::unix::net::UnixStream, u32};
 
 mod shm;
 mod wl_shm;
+mod wl_registry;
 mod vec_utils;
 pub use vec_utils::WlMessage;
 
@@ -22,7 +23,11 @@ struct WlClient {
 
 impl WlClient {
     fn new() -> Result<Self, Box<dyn Error>> {
-        let sock = WlClient::connect()?;
+        let sock = UnixStream::connect(format!(
+            "{}/{}",
+            var("XDG_RUNTIME_DIR")?,
+            var("WAYLAND_DISPLAY")?
+        ))?;
 
         let res = WlClient {
             socket:      sock,
@@ -70,116 +75,6 @@ impl WlClient {
 
         Ok(())
     }
-
-    fn connect() -> Result<UnixStream, Box<dyn Error>> {
-        let wl_sock_path: String = format!(
-            "{}/{}",
-            env::var("XDG_RUNTIME_DIR")?,
-            env::var("WAYLAND_DISPLAY")?
-        );
-        let sock = UnixStream::connect(wl_sock_path)?;
-
-        Ok(sock)
-    }
-
-    fn wl_display_error(event: &Vec<u8>) {
-        let mut offset: usize = 0;
-        eprintln!(
-            "Received error:\n\tObject: {}\n\tCode: {}\n\tMessage: {}",
-            event.read_u32(&mut offset),
-            event.read_u32(&mut offset),
-            event.read_string(&mut offset)
-        );
-    }
-
-    fn wl_display_get_registry(&mut self) -> Result<(), Box<dyn Error>> {
-        const OBJECT: u32 = 1;
-        const OPCODE: u16 = 1;
-        const MSG_SIZE: u16 = 12;
-
-        let mut request = [0u8; MSG_SIZE as usize];
-        request[0..4].copy_from_slice(&OBJECT.to_ne_bytes());
-        request[4..6].copy_from_slice(&OPCODE.to_ne_bytes());
-        request[6..8].copy_from_slice(&MSG_SIZE.to_ne_bytes());
-
-        self.current_id += 1;
-        request[8..12].copy_from_slice(&self.current_id.to_ne_bytes());
-        self.registry_id = Some(self.current_id);
-
-        let written = self.socket.write(&request)?;
-        assert!(written == MSG_SIZE.into());
-
-        Ok(())
-    }
-
-    fn wl_registry_bind(
-        &mut self,
-        name: &u32,
-        interface: &String,
-        version: &u32,
-        id: &u32
-    ) -> Result<(), String> {
-        let object: u32 = match self.registry_id {
-            Some(id) => id,
-            None => return Err(String::from("wl_registry_bind failed: wl_state.registry_id not set!"))
-        };
-        const OPCODE: u16 = 0;
-
-        let req_size: u16 = 24 + ((interface.len() as u16+3) & (u16::MAX-3));
-        let mut request = vec![0u8; req_size as usize];
-        let mut offset: usize = 0;
-
-        request.write_u32    (&object,    &mut offset);
-        request.write_u16    (&OPCODE,    &mut offset);
-        request.write_u16    (&req_size,  &mut offset);
-
-        request.write_u32    (&name,      &mut offset);
-        request.write_string (&interface, &mut offset);
-        request.write_u32    (&version,   &mut offset);
-        request.write_u32    (&id,        &mut offset);
-
-        match self.socket.write(&request) {
-            Ok(bytes) => {
-                assert!(bytes == req_size as usize)
-            }
-            Err(err) => {
-                return Err(err.to_string());
-            }
-        };
-
-        Ok(())
-    }
-
-    fn wl_registry_global(&mut self, event: &Vec<u8>) -> Result<(), Box<dyn Error>> {
-        let mut offset: usize = 0;
-
-        let name        = event.read_u32(&mut offset);
-        let interface   = event.read_string(&mut offset);
-        let version     = event.read_u32(&mut offset);
-
-        println!(
-            "Received global:\n\tName: {}\n\tInterface: {}\n\tVersion: {}",
-            name,
-            interface,
-            version,
-        );
-
-        if interface == "wl_shm" {
-            self.current_id += 1;
-            self.wl_registry_bind(
-                &name,
-                &interface,
-                &version,
-                &self.current_id.clone()
-            )?;
-            self.shm_id = Some(self.current_id);
-
-            self.wl_shm_create_pool()?;
-            self.wl_shm_pool_create_buffer(0, 200, 200)?;
-        }
-
-        Ok(())
-    }
 }
 
 fn main() -> Result<(), Box<dyn Error>> {

src/wl_registry.rs

@@ -0,0 +1,105 @@
+use crate::{WlClient, vec_utils::WlMessage};
+use std::{io::Write, error::Error};
+
+impl WlClient {
+    pub fn wl_display_get_registry(&mut self) -> Result<(), Box<dyn Error>> {
+        const OBJECT: u32 = 1;
+        const OPCODE: u16 = 1;
+        const MSG_SIZE: u16 = 12;
+
+        let mut request = vec![0u8; MSG_SIZE as usize];
+        let mut offset: usize = 0;
+
+        request.write_u32(&OBJECT,   &mut offset);
+        request.write_u16(&OPCODE,   &mut offset);
+        request.write_u16(&MSG_SIZE, &mut offset);
+
+        self.current_id += 1;
+        request.write_u32(&self.current_id, &mut offset);
+        self.registry_id = Some(self.current_id);
+
+        let written = self.socket.write(&request)?;
+        assert!(written == MSG_SIZE.into());
+
+        Ok(())
+    }
+
+    pub fn wl_registry_global(&mut self, event: &Vec<u8>) -> Result<(), Box<dyn Error>> {
+        let mut offset: usize = 0;
+
+        let name        = event.read_u32(&mut offset);
+        let interface   = event.read_string(&mut offset);
+        let version     = event.read_u32(&mut offset);
+
+        println!(
+            "Received global:\n\tName: {}\n\tInterface: {}\n\tVersion: {}",
+            name,
+            interface,
+            version,
+        );
+
+        if interface == "wl_shm" {
+            self.current_id += 1;
+            self.wl_registry_bind(
+                &name,
+                &interface,
+                &version,
+                &self.current_id.clone()
+            )?;
+            self.shm_id = Some(self.current_id);
+
+            self.wl_shm_create_pool()?;
+            self.wl_shm_pool_create_buffer(0, 200, 200)?;
+        }
+
+        Ok(())
+    }
+
+    pub fn wl_registry_bind(
+        &mut self,
+        name: &u32,
+        interface: &String,
+        version: &u32,
+        id: &u32
+    ) -> Result<(), String> {
+        let object: u32 = match self.registry_id {
+            Some(id) => id,
+            None => return Err(String::from("wl_registry_bind failed: wl_state.registry_id not set!"))
+        };
+        const OPCODE: u16 = 0;
+
+        let req_size: u16 = 24 + ((interface.len() as u16+3) & (u16::MAX-3));
+        let mut request = vec![0u8; req_size as usize];
+        let mut offset: usize = 0;
+
+        request.write_u32    (&object,    &mut offset);
+        request.write_u16    (&OPCODE,    &mut offset);
+        request.write_u16    (&req_size,  &mut offset);
+
+        request.write_u32    (&name,      &mut offset);
+        request.write_string (&interface, &mut offset);
+        request.write_u32    (&version,   &mut offset);
+        request.write_u32    (&id,        &mut offset);
+
+        match self.socket.write(&request) {
+            Ok(bytes) => {
+                assert!(bytes == req_size as usize)
+            }
+            Err(err) => {
+                return Err(err.to_string());
+            }
+        };
+
+        Ok(())
+    }
+
+    pub fn wl_display_error(event: &Vec<u8>) {
+        let mut offset: usize = 0;
+        eprintln!(
+            "Received error:\n\tObject: {}\n\tCode: {}\n\tMessage: {}",
+            event.read_u32(&mut offset),
+            event.read_u32(&mut offset),
+            event.read_string(&mut offset)
+        );
+    }
+}

src/wl_shm.rs

@@ -75,6 +75,7 @@ impl WlClient {
 
         let mut offset: usize = 0;
         let mut request = vec![0u8; REQ_SIZE as usize];
+
         request.write_u32(&object, &mut offset);
         request.write_u16(&OPCODE, &mut offset);
         request.write_u16(&REQ_SIZE, &mut offset);