autocommit 2022-02-06 23:54:46 CET

build/build.rs

@@ -1,7 +1,7 @@
 use std::fs::{File, OpenOptions};
-use std::{env, io};
 use std::io::BufWriter;
 use std::path::PathBuf;
+use std::{env, io};
 
 mod enums;
 mod wire;
@@ -18,7 +18,6 @@ fn open(s: &str) -> io::Result<BufWriter<File>> {
     ))
 }
 
-
 fn main() -> anyhow::Result<()> {
     wire::main()?;
 

build/enums.rs

@@ -1,8 +1,8 @@
-use std::env;
+use crate::open;
 use repc::layout::{Type, TypeVariant};
+use std::env;
 use std::fmt::Write as FmtWrite;
 use std::io::Write;
-use crate::open;
 
 #[allow(unused_macros)]
 #[macro_use]

build/wire.rs

@@ -1,9 +1,9 @@
-use std::fs::DirEntry;
-use std::os::unix::ffi::OsStrExt;
+use crate::open;
 use anyhow::{bail, Context, Result};
 use bstr::{BStr, BString, ByteSlice};
-use crate::open;
+use std::fs::DirEntry;
 use std::io::Write;
+use std::os::unix::ffi::OsStrExt;
 
 #[derive(Copy, Clone, Debug, Eq, PartialEq)]
 enum TreeDelim {
@@ -283,7 +283,7 @@ impl<'a> Parser<'a> {
                 pos: 0,
                 tokens: body,
             };
-            let mut fields = vec!();
+            let mut fields = vec![];
             while !parser.eof() {
                 fields.push(parser.parse_field()?);
             }
@@ -292,9 +292,12 @@ impl<'a> Parser<'a> {
                 val: Message {
                     name: name.to_owned(),
                     camel_name: to_camel(name),
-                    id: Lined { line: num_line, val, },
+                    id: Lined {
+                        line: num_line,
+                        val,
+                    },
                     fields,
-                }
+                },
             })
         })();
         res.with_context(|| format!("While parsing message starting at line {}", line))
@@ -313,7 +316,7 @@ impl<'a> Parser<'a> {
                 val: Field {
                     name: name.to_owned(),
                     ty,
-                }
+                },
             })
         })();
         res.with_context(|| format!("While parsing field starting at line {}", line))
@@ -325,7 +328,11 @@ impl<'a> Parser<'a> {
         self.pos += 1;
         match &token.kind {
             TokenKind::Ident(id) => Ok((token.line, *id)),
-            k => bail!("In line {}: Expected identifier, found {}", token.line, k.name()),
+            k => bail!(
+                "In line {}: Expected identifier, found {}",
+                token.line,
+                k.name()
+            ),
         }
     }
 
@@ -335,7 +342,11 @@ impl<'a> Parser<'a> {
         self.pos += 1;
         match &token.kind {
             TokenKind::Num(n) => Ok((token.line, *n)),
-            k => bail!("In line {}: Expected number, found {}", token.line, k.name()),
+            k => bail!(
+                "In line {}: Expected number, found {}",
+                token.line,
+                k.name()
+            ),
         }
     }
 
@@ -345,7 +356,12 @@ impl<'a> Parser<'a> {
         self.pos += 1;
         match &token.kind {
             TokenKind::Symbol(s) if *s == symbol => Ok(()),
-            k => bail!("In line {}: Expected {}, found {}", token.line, symbol.name(), k.name()),
+            k => bail!(
+                "In line {}: Expected {}, found {}",
+                token.line,
+                symbol.name(),
+                k.name()
+            ),
         }
     }
 
@@ -354,9 +370,7 @@ impl<'a> Parser<'a> {
         let token = &self.tokens[self.pos];
         self.pos += 1;
         match &token.kind {
-            TokenKind::Tree { delim, body } => {
-                Ok((token.line, *delim, body))
-            }
+            TokenKind::Tree { delim, body } => Ok((token.line, *delim, body)),
             k => bail!("In line {}: Expected tree, found {}", token.line, k.name()),
         }
     }
@@ -366,7 +380,12 @@ impl<'a> Parser<'a> {
         if delim == exp_delim {
             Ok((line, tokens))
         } else {
-            bail!("In line {}: Expected {:?}-delimited tree, found {:?}-delimited tree", line, exp_delim, delim.opening())
+            bail!(
+                "In line {}: Expected {:?}-delimited tree, found {:?}-delimited tree",
+                line,
+                exp_delim,
+                delim.opening()
+            )
         }
     }
 
@@ -407,7 +426,7 @@ impl<'a> Parser<'a> {
                     format!("While parsing pod element type starting in line {}", line)
                 })?;
                 Type::Pod(ty.val)
-            },
+            }
             b"u32" => Type::U32,
             b"i32" => Type::I32,
             b"str" => Type::Str,
@@ -455,13 +474,10 @@ impl<'a> Parser<'a> {
                     format!("While parsing identifier starting in line {}", line)
                 })?;
                 Type::Id(to_camel(ident))
-            },
+            }
             _ => bail!("Unknown type {}", ty),
         };
-        Ok(Lined {
-            line,
-            val: ty,
-        })
+        Ok(Lined { line, val: ty })
     }
 }
 
@@ -476,7 +492,7 @@ fn parse_messages(s: &[u8]) -> Result<Vec<Lined<Message>>> {
 
 fn to_camel(s: &BStr) -> BString {
     let mut last_was_underscore = true;
-    let mut res = vec!();
+    let mut res = vec![];
     for mut b in s.as_bytes().iter().copied() {
         if b == b'_' {
             last_was_underscore = true;
@@ -504,7 +520,7 @@ fn write_type<W: Write>(f: &mut W, ty: &Type) -> Result<()> {
             write!(f, "&'a [")?;
             write_type(f, n)?;
             write!(f, "]")?;
-        },
+        }
         Type::Pod(p) => f.write_all(p.as_bytes())?,
     }
     Ok(())
@@ -517,7 +533,12 @@ fn write_field<W: Write>(f: &mut W, field: &Field) -> Result<()> {
     Ok(())
 }
 
-fn write_message_type<W: Write>(f: &mut W, obj: &BStr, message: &Message, needs_lifetime: bool) -> Result<()> {
+fn write_message_type<W: Write>(
+    f: &mut W,
+    obj: &BStr,
+    message: &Message,
+    needs_lifetime: bool,
+) -> Result<()> {
     let lifetime = if needs_lifetime { "<'a>" } else { "" };
     writeln!(f, "    pub struct {}{} {{", message.camel_name, lifetime)?;
     writeln!(f, "        pub self_id: {}Id,", obj)?;
@@ -525,8 +546,15 @@ fn write_message_type<W: Write>(f: &mut W, obj: &BStr, message: &Message, needs_
         write_field(f, &field.val)?;
     }
     writeln!(f, "    }}")?;
-    writeln!(f, "    impl{} std::fmt::Debug for {}{} {{", lifetime, message.camel_name, lifetime)?;
-    writeln!(f, "        fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {{")?;
+    writeln!(
+        f,
+        "    impl{} std::fmt::Debug for {}{} {{",
+        lifetime, message.camel_name, lifetime
+    )?;
+    writeln!(
+        f,
+        "        fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {{"
+    )?;
     write!(f, r#"            write!(fmt, "{}("#, message.name)?;
     for (i, field) in message.fields.iter().enumerate() {
         if i > 0 {
@@ -558,14 +586,22 @@ fn write_message<W: Write>(f: &mut W, obj: &BStr, message: &Message) -> Result<(
     writeln!(f)?;
     writeln!(f, "    pub const {}: u32 = {};", uppercase, message.id.val)?;
     write_message_type(f, obj, message, has_reference_type)?;
-    let lifetime = if has_reference_type { "<'a>"} else {""};
+    let lifetime = if has_reference_type { "<'a>" } else { "" };
     let parser = if message.fields.len() > 0 {
         "parser"
     } else {
         "_parser"
     };
-    writeln!(f, "    impl<'a> RequestParser<'a> for {}{} {{", message.camel_name, lifetime)?;
-    writeln!(f, "        fn parse({}: &mut MsgParser<'_, 'a>) -> Result<Self, MsgParserError> {{", parser)?;
+    writeln!(
+        f,
+        "    impl<'a> RequestParser<'a> for {}{} {{",
+        message.camel_name, lifetime
+    )?;
+    writeln!(
+        f,
+        "        fn parse({}: &mut MsgParser<'_, 'a>) -> Result<Self, MsgParserError> {{",
+        parser
+    )?;
     writeln!(f, "            Ok(Self {{")?;
     writeln!(f, "                self_id: {}Id::NONE,", obj)?;
     for field in &message.fields {
@@ -585,7 +621,11 @@ fn write_message<W: Write>(f: &mut W, obj: &BStr, message: &Message) -> Result<(
     writeln!(f, "            }})")?;
     writeln!(f, "        }}")?;
     writeln!(f, "    }}")?;
-    writeln!(f, "    impl{} EventFormatter for {}{} {{", lifetime, message.camel_name, lifetime)?;
+    writeln!(
+        f,
+        "    impl{} EventFormatter for {}{} {{",
+        lifetime, message.camel_name, lifetime
+    )?;
     writeln!(f, "        fn format(self, fmt: &mut MsgFormatter<'_>) {{")?;
     writeln!(f, "            fmt.header(self.self_id, {});", uppercase)?;
     fn write_fmt_expr<W: Write>(f: &mut W, prefix: &str, ty: &Type, access: &str) -> Result<()> {
@@ -607,13 +647,21 @@ fn write_message<W: Write>(f: &mut W, obj: &BStr, message: &Message) -> Result<(
         Ok(())
     }
     for field in &message.fields {
-        write_fmt_expr(f, "", &field.val.ty.val, &format!("self.{}", field.val.name))?;
+        write_fmt_expr(
+            f,
+            "",
+            &field.val.ty.val,
+            &format!("self.{}", field.val.name),
+        )?;
     }
     writeln!(f, "        }}")?;
     writeln!(f, "        fn id(&self) -> ObjectId {{")?;
     writeln!(f, "            self.self_id.into()")?;
     writeln!(f, "        }}")?;
-    writeln!(f, "        fn interface(&self) -> crate::object::Interface {{")?;
+    writeln!(
+        f,
+        "        fn interface(&self) -> crate::object::Interface {{"
+    )?;
     writeln!(f, "            crate::object::Interface::{}", obj)?;
     writeln!(f, "        }}")?;
     writeln!(f, "    }}")?;
@@ -651,15 +699,19 @@ pub fn main() -> Result<()> {
     writeln!(f, "use crate::fixed::Fixed;")?;
     writeln!(f, "use crate::client::{{EventFormatter, RequestParser}};")?;
     writeln!(f, "use crate::object::ObjectId;")?;
-    writeln!(f, "use crate::utils::buffd::{{MsgFormatter, MsgParser, MsgParserError}};")?;
+    writeln!(
+        f,
+        "use crate::utils::buffd::{{MsgFormatter, MsgParser, MsgParserError}};"
+    )?;
     println!("cargo:rerun-if-changed=wire");
-    let mut files = vec!();
+    let mut files = vec![];
     for file in std::fs::read_dir("wire")? {
         files.push(file?);
     }
     files.sort_by_key(|f| f.file_name());
     for file in files {
-        write_file(&mut f, &file).with_context(|| format!("While processing {}", file.path().display()))?;
+        write_file(&mut f, &file)
+            .with_context(|| format!("While processing {}", file.path().display()))?;
     }
     Ok(())
 }

src/client/error.rs

@@ -1,10 +1,10 @@
 use crate::client::ClientId;
 use crate::object::{Interface, ObjectId};
 use crate::utils::buffd::{BufFdError, MsgParserError};
+use crate::wire::WlDisplayId;
 use crate::AsyncError;
 use std::error::Error;
 use thiserror::Error;
-use crate::wire::WlDisplayId;
 
 #[derive(Debug, Error)]
 pub enum ClientError {

src/client/mod.rs

@@ -3,13 +3,15 @@ use crate::client::error::LookupError;
 use crate::client::objects::Objects;
 use crate::ifs::wl_callback::WlCallback;
 use crate::ifs::wl_display::WlDisplay;
-use crate::ifs::wl_registry::{WlRegistry};
+use crate::ifs::wl_registry::WlRegistry;
 use crate::object::{Interface, Object, ObjectId, WL_DISPLAY_ID};
 use crate::state::State;
+use crate::utils::asyncevent::AsyncEvent;
 use crate::utils::buffd::{MsgFormatter, MsgParser, MsgParserError, OutBufferSwapchain};
 use crate::utils::numcell::NumCell;
 use crate::utils::oneshot::{oneshot, OneshotTx};
 use crate::utils::queue::AsyncQueue;
+use crate::wire::WlRegistryId;
 use crate::ErrorFmt;
 use ahash::AHashMap;
 pub use error::{ClientError, ObjectError};
@@ -19,8 +21,6 @@ use std::fmt::{Debug, Display, Formatter};
 use std::mem;
 use std::rc::Rc;
 use uapi::{c, OwnedFd};
-use crate::utils::asyncevent::AsyncEvent;
-use crate::wire::WlRegistryId;
 
 mod error;
 mod objects;
@@ -199,7 +199,7 @@ impl Client {
             Ok(d) => {
                 d.send_invalid_request(obj, request);
                 self.state.clients.shutdown(self.id);
-            },
+            }
             Err(e) => {
                 log::error!(
                     "Could not retrieve display of client {}: {}",
@@ -246,7 +246,7 @@ impl Client {
             Ok(d) => {
                 d.send_implementation_error(msg);
                 self.state.clients.shutdown(self.id);
-            },
+            }
             Err(e) => {
                 log::error!(
                     "Could not retrieve display of client {}: {}",

src/client/objects.rs

@@ -1,27 +1,28 @@
 use crate::client::{Client, ClientError};
-use crate::ifs::wl_buffer::{WlBuffer};
-use crate::ifs::wl_data_source::{WlDataSource};
+use crate::ifs::wl_buffer::WlBuffer;
+use crate::ifs::wl_data_source::WlDataSource;
 use crate::ifs::wl_display::WlDisplay;
-use crate::ifs::wl_region::{WlRegion};
-use crate::ifs::wl_registry::{WlRegistry};
-use crate::ifs::wl_seat::{WlSeat};
-use crate::ifs::wl_surface::xdg_surface::xdg_toplevel::{XdgToplevel};
-use crate::ifs::wl_surface::xdg_surface::{XdgSurface};
-use crate::ifs::wl_surface::{WlSurface};
-use crate::ifs::xdg_positioner::{XdgPositioner};
-use crate::ifs::xdg_wm_base::{XdgWmBase};
-use crate::ifs::zwp_primary_selection_source_v1::{
-    ZwpPrimarySelectionSourceV1,
-};
+use crate::ifs::wl_region::WlRegion;
+use crate::ifs::wl_registry::WlRegistry;
+use crate::ifs::wl_seat::WlSeat;
+use crate::ifs::wl_surface::xdg_surface::xdg_toplevel::XdgToplevel;
+use crate::ifs::wl_surface::xdg_surface::XdgSurface;
+use crate::ifs::wl_surface::WlSurface;
+use crate::ifs::xdg_positioner::XdgPositioner;
+use crate::ifs::xdg_wm_base::XdgWmBase;
+use crate::ifs::zwp_primary_selection_source_v1::ZwpPrimarySelectionSourceV1;
 use crate::object::{Object, ObjectId};
 use crate::tree::Node;
 use crate::utils::clonecell::CloneCell;
 use crate::utils::copyhashmap::CopyHashMap;
+use crate::wire::{
+    WlBufferId, WlDataSourceId, WlRegionId, WlRegistryId, WlSeatId, WlSurfaceId, XdgPositionerId,
+    XdgSurfaceId, XdgToplevelId, XdgWmBaseId, ZwpPrimarySelectionSourceV1Id,
+};
 use ahash::AHashMap;
 use std::cell::{RefCell, RefMut};
 use std::mem;
 use std::rc::Rc;
-use crate::wire::{WlBufferId, WlDataSourceId, WlRegionId, WlRegistryId, WlSeatId, WlSurfaceId, XdgPositionerId, XdgSurfaceId, XdgToplevelId, XdgWmBaseId, ZwpPrimarySelectionSourceV1Id};
 
 pub struct Objects {
     pub display: CloneCell<Option<Rc<WlDisplay>>>,

src/client/tasks.rs

@@ -1,4 +1,3 @@
-use std::collections::VecDeque;
 use crate::client::{Client, ClientError};
 use crate::object::ObjectId;
 use crate::utils::buffd::{BufFdIn, BufFdOut, MsgParser};
@@ -6,6 +5,7 @@ use crate::utils::oneshot::OneshotRx;
 use crate::utils::vec_ext::VecExt;
 use crate::ErrorFmt;
 use futures::{select, FutureExt};
+use std::collections::VecDeque;
 use std::mem;
 use std::rc::Rc;
 

src/drm/dma.rs

@@ -1,5 +1,5 @@
-use std::rc::Rc;
 use crate::format::Format;
+use std::rc::Rc;
 use uapi::OwnedFd;
 
 pub struct DmaBufPlane {

src/globals.rs

@@ -1,4 +1,4 @@
-use crate::client::{Client};
+use crate::client::Client;
 use crate::ifs::org_kde_kwin_server_decoration_manager::OrgKdeKwinServerDecorationManagerGlobal;
 use crate::ifs::wl_drm::WlDrmGlobal;
 use crate::ifs::wl_output::WlOutputGlobal;

src/ifs/org_kde_kwin_server_decoration.rs

@@ -1,12 +1,12 @@
 use crate::client::{Client, ClientError};
 use crate::object::Object;
 use crate::utils::buffd::MsgParser;
+use crate::utils::buffd::MsgParserError;
+use crate::wire::org_kde_kwin_server_decoration::*;
+use crate::wire::OrgKdeKwinServerDecorationId;
 use std::cell::Cell;
 use std::rc::Rc;
 use thiserror::Error;
-use crate::wire::org_kde_kwin_server_decoration::*;
-use crate::utils::buffd::MsgParserError;
-use crate::wire::OrgKdeKwinServerDecorationId;
 
 #[allow(dead_code)]
 const NONE: u32 = 0;

src/ifs/org_kde_kwin_server_decoration_manager.rs

@@ -3,11 +3,11 @@ use crate::globals::{Global, GlobalName};
 use crate::ifs::org_kde_kwin_server_decoration::OrgKdeKwinServerDecoration;
 use crate::object::Object;
 use crate::utils::buffd::MsgParser;
+use crate::utils::buffd::MsgParserError;
+use crate::wire::org_kde_kwin_server_decoration_manager::*;
+use crate::wire::OrgKdeKwinServerDecorationManagerId;
 use std::rc::Rc;
 use thiserror::Error;
-use crate::wire::org_kde_kwin_server_decoration_manager::*;
-use crate::utils::buffd::MsgParserError;
-use crate::wire::OrgKdeKwinServerDecorationManagerId;
 
 #[allow(dead_code)]
 const NONE: u32 = 0;

src/ifs/wl_buffer.rs

@@ -5,14 +5,14 @@ use crate::object::Object;
 use crate::rect::Rect;
 use crate::render::{Image, Texture};
 use crate::utils::buffd::MsgParser;
+use crate::utils::buffd::MsgParserError;
 use crate::utils::clonecell::CloneCell;
+use crate::wire::wl_buffer::*;
+use crate::wire::WlBufferId;
+use crate::{ClientMemError, RenderError};
 use std::cell::Cell;
 use std::rc::Rc;
 use thiserror::Error;
-use crate::wire::wl_buffer::*;
-use crate::{ClientMemError, RenderError};
-use crate::utils::buffd::MsgParserError;
-use crate::wire::WlBufferId;
 
 pub enum WlBufferStorage {
     Shm { mem: ClientMemOffset, stride: i32 },

src/ifs/wl_callback.rs

@@ -1,9 +1,9 @@
-use crate::client::{Client};
+use crate::client::Client;
 use crate::object::Object;
-use std::rc::Rc;
-use thiserror::Error;
 use crate::wire::wl_callback::*;
 use crate::wire::WlCallbackId;
+use std::rc::Rc;
+use thiserror::Error;
 
 pub struct WlCallback {
     client: Rc<Client>,
@@ -12,11 +12,17 @@ pub struct WlCallback {
 
 impl WlCallback {
     pub fn new(id: WlCallbackId, client: &Rc<Client>) -> Self {
-        Self { client: client.clone(), id }
+        Self {
+            client: client.clone(),
+            id,
+        }
     }
 
     pub fn send_done(&self) {
-        self.client.event(Done { self_id: self.id, callback_data: 0 });
+        self.client.event(Done {
+            self_id: self.id,
+            callback_data: 0,
+        });
     }
 }
 

src/ifs/wl_compositor.rs

@@ -4,11 +4,11 @@ use crate::ifs::wl_region::WlRegion;
 use crate::ifs::wl_surface::WlSurface;
 use crate::object::Object;
 use crate::utils::buffd::MsgParser;
+use crate::utils::buffd::MsgParserError;
+use crate::wire::wl_compositor::*;
+use crate::wire::WlCompositorId;
 use std::rc::Rc;
 use thiserror::Error;
-use crate::wire::wl_compositor::*;
-use crate::utils::buffd::MsgParserError;
-use crate::wire::WlCompositorId;
 
 pub struct WlCompositorGlobal {
     name: GlobalName,

src/ifs/wl_data_device.rs

@@ -1,14 +1,14 @@
-use crate::client::{ClientError};
+use crate::client::ClientError;
 use crate::ifs::wl_data_device_manager::WlDataDeviceManager;
+use crate::ifs::wl_data_source::WlDataSourceError;
 use crate::ifs::wl_seat::WlSeat;
 use crate::object::Object;
 use crate::utils::buffd::MsgParser;
+use crate::utils::buffd::MsgParserError;
+use crate::wire::wl_data_device::*;
+use crate::wire::{WlDataDeviceId, WlDataOfferId};
 use std::rc::Rc;
 use thiserror::Error;
-use crate::ifs::wl_data_source::WlDataSourceError;
-use crate::wire::wl_data_device::*;
-use crate::utils::buffd::MsgParserError;
-use crate::wire::{WlDataDeviceId, WlDataOfferId};
 
 #[allow(dead_code)]
 const ROLE: u32 = 0;

src/ifs/wl_data_device_manager.rs

@@ -1,15 +1,14 @@
-
 use crate::client::{Client, ClientError};
 use crate::globals::{Global, GlobalName};
 use crate::ifs::wl_data_device::WlDataDevice;
 use crate::ifs::wl_data_source::WlDataSource;
 use crate::object::Object;
 use crate::utils::buffd::MsgParser;
+use crate::utils::buffd::MsgParserError;
+use crate::wire::wl_data_device_manager::*;
+use crate::wire::WlDataDeviceManagerId;
 use std::rc::Rc;
 use thiserror::Error;
-use crate::wire::wl_data_device_manager::*;
-use crate::utils::buffd::MsgParserError;
-use crate::wire::WlDataDeviceManagerId;
 
 #[allow(dead_code)]
 const DND_NONE: u32 = 0;

src/ifs/wl_data_offer.rs

@@ -1,16 +1,16 @@
-use std::mem;
 use crate::client::{Client, ClientError};
 use crate::ifs::wl_data_source::WlDataSource;
 use crate::ifs::wl_seat::WlSeatGlobal;
 use crate::object::Object;
 use crate::utils::buffd::MsgParser;
+use crate::utils::buffd::MsgParserError;
 use crate::utils::clonecell::CloneCell;
+use crate::wire::wl_data_offer::*;
+use crate::wire::WlDataOfferId;
+use std::mem;
 use std::ops::Deref;
 use std::rc::Rc;
 use thiserror::Error;
-use crate::wire::wl_data_offer::*;
-use crate::utils::buffd::MsgParserError;
-use crate::wire::WlDataOfferId;
 
 #[allow(dead_code)]
 const INVALID_FINISH: u32 = 0;

src/ifs/wl_data_source.rs

@@ -1,18 +1,17 @@
-
 use crate::client::{Client, ClientError};
 use crate::ifs::wl_data_offer::{DataOfferRole, WlDataOffer};
 use crate::ifs::wl_seat::WlSeatGlobal;
 use crate::object::Object;
 use crate::utils::buffd::MsgParser;
+use crate::utils::buffd::MsgParserError;
 use crate::utils::clonecell::{CloneCell, UnsafeCellCloneSafe};
+use crate::wire::wl_data_source::*;
+use crate::wire::WlDataSourceId;
 use ahash::AHashSet;
 use std::cell::RefCell;
 use std::rc::Rc;
 use thiserror::Error;
 use uapi::OwnedFd;
-use crate::wire::wl_data_source::*;
-use crate::utils::buffd::MsgParserError;
-use crate::wire::WlDataSourceId;
 
 #[allow(dead_code)]
 const INVALID_ACTION_MASK: u32 = 0;

src/ifs/wl_display.rs

@@ -1,15 +1,14 @@
-
 use crate::client::{Client, ClientError};
+use crate::globals::GlobalsError;
 use crate::ifs::wl_callback::WlCallback;
 use crate::ifs::wl_registry::WlRegistry;
 use crate::object::{Object, ObjectId, WL_DISPLAY_ID};
 use crate::utils::buffd::MsgParser;
+use crate::utils::buffd::MsgParserError;
+use crate::wire::wl_display::*;
+use crate::wire::WlDisplayId;
 use std::rc::Rc;
 use thiserror::Error;
-use crate::globals::GlobalsError;
-use crate::wire::wl_display::*;
-use crate::utils::buffd::MsgParserError;
-use crate::wire::WlDisplayId;
 
 const INVALID_OBJECT: u32 = 0;
 const INVALID_METHOD: u32 = 1;
@@ -43,19 +42,11 @@ impl WlDisplay {
         let gr: GetRegistry = self.client.parse(self, parser)?;
         let registry = Rc::new(WlRegistry::new(gr.registry, &self.client));
         self.client.add_client_obj(&registry)?;
-        self.client
-            .state
-            .globals
-            .notify_all(&registry);
+        self.client.state.globals.notify_all(&registry);
         Ok(())
     }
 
-    pub fn send_error<O: Into<ObjectId>>(
-        &self,
-        object_id: O,
-        code: u32,
-        message: &str,
-    ) {
+    pub fn send_error<O: Into<ObjectId>>(&self, object_id: O, code: u32, message: &str) {
         self.client.event(Error {
             self_id: self.id,
             object_id: object_id.into(),

src/ifs/wl_drm.rs

@@ -2,14 +2,13 @@ use crate::client::{Client, ClientError};
 use crate::globals::{Global, GlobalName};
 use crate::object::Object;
 use crate::utils::buffd::MsgParser;
+use crate::utils::buffd::MsgParserError;
+use crate::wire::wl_drm::*;
+use crate::wire::WlDrmId;
+use bstr::ByteSlice;
 use std::ffi::CString;
 use std::rc::Rc;
-use bstr::ByteSlice;
 use thiserror::Error;
-use crate::wire::wl_drm::*;
-use crate::utils::buffd::MsgParserError;
-use crate::wire::WlDrmId;
-
 
 const PRIME: u32 = 1;
 

src/ifs/wl_output.rs

@@ -1,17 +1,16 @@
-
 use crate::backend::Output;
 use crate::client::{Client, ClientError, ClientId};
 use crate::globals::{Global, GlobalName};
 use crate::object::Object;
 use crate::utils::buffd::MsgParser;
+use crate::utils::buffd::MsgParserError;
+use crate::wire::wl_output::*;
+use crate::wire::WlOutputId;
 use ahash::AHashMap;
 use std::cell::{Cell, RefCell};
 use std::collections::hash_map::Entry;
 use std::rc::Rc;
 use thiserror::Error;
-use crate::wire::wl_output::*;
-use crate::utils::buffd::MsgParserError;
-use crate::wire::WlOutputId;
 
 const SP_UNKNOWN: i32 = 0;
 #[allow(dead_code)]

src/ifs/wl_region.rs

@@ -1,14 +1,13 @@
-
 use crate::client::{Client, ClientError};
 use crate::object::Object;
 use crate::pixman::Region;
 use crate::utils::buffd::MsgParser;
+use crate::utils::buffd::MsgParserError;
+use crate::wire::wl_region::*;
+use crate::wire::WlRegionId;
 use std::cell::RefCell;
 use std::rc::Rc;
 use thiserror::Error;
-use crate::wire::wl_region::*;
-use crate::utils::buffd::MsgParserError;
-use crate::wire::WlRegionId;
 
 pub struct WlRegion {
     id: WlRegionId,

src/ifs/wl_registry.rs

@@ -1,13 +1,12 @@
-
-use crate::client::{Client};
+use crate::client::Client;
 use crate::globals::{Global, GlobalName, GlobalsError};
 use crate::object::{Interface, Object};
 use crate::utils::buffd::MsgParser;
+use crate::utils::buffd::MsgParserError;
+use crate::wire::wl_registry::*;
+use crate::wire::WlRegistryId;
 use std::rc::Rc;
 use thiserror::Error;
-use crate::wire::wl_registry::*;
-use crate::utils::buffd::MsgParserError;
-use crate::wire::WlRegistryId;
 
 pub struct WlRegistry {
     id: WlRegistryId,
@@ -40,7 +39,11 @@ impl WlRegistry {
 
     fn bind(&self, parser: MsgParser<'_, '_>) -> Result<(), BindError> {
         let bind: Bind = self.client.parse(self, parser)?;
-        let global = self.client.state.globals.get(GlobalName::from_raw(bind.name))?;
+        let global = self
+            .client
+            .state
+            .globals
+            .get(GlobalName::from_raw(bind.name))?;
         if global.interface().name() != bind.interface {
             return Err(BindError::InvalidInterface(InterfaceError {
                 name: global.name(),
@@ -111,4 +114,3 @@ pub struct VersionError {
     pub version: u32,
     pub actual: u32,
 }
-

src/ifs/wl_seat.rs

@@ -8,25 +8,31 @@ use crate::client::{Client, ClientError, ClientId};
 use crate::cursor::{Cursor, KnownCursor};
 use crate::fixed::Fixed;
 use crate::globals::{Global, GlobalName};
-use crate::ifs::wl_data_device::{WlDataDevice};
-use crate::ifs::wl_data_offer::{DataOfferRole};
+use crate::ifs::wl_data_device::WlDataDevice;
+use crate::ifs::wl_data_offer::DataOfferRole;
 use crate::ifs::wl_data_source::{WlDataSource, WlDataSourceError};
-use crate::ifs::wl_seat::wl_keyboard::{WlKeyboard, REPEAT_INFO_SINCE, WlKeyboardError};
-use crate::ifs::wl_seat::wl_pointer::{WlPointer};
+use crate::ifs::wl_seat::wl_keyboard::{WlKeyboard, WlKeyboardError, REPEAT_INFO_SINCE};
+use crate::ifs::wl_seat::wl_pointer::WlPointer;
 use crate::ifs::wl_seat::wl_touch::WlTouch;
 use crate::ifs::wl_surface::xdg_surface::xdg_toplevel::XdgToplevel;
-use crate::ifs::zwp_primary_selection_device_v1::{
-    ZwpPrimarySelectionDeviceV1,
+use crate::ifs::zwp_primary_selection_device_v1::ZwpPrimarySelectionDeviceV1;
+use crate::ifs::zwp_primary_selection_source_v1::{
+    ZwpPrimarySelectionSourceV1, ZwpPrimarySelectionSourceV1Error,
 };
-use crate::ifs::zwp_primary_selection_source_v1::{ZwpPrimarySelectionSourceV1, ZwpPrimarySelectionSourceV1Error};
 use crate::object::Object;
 use crate::tree::{FloatNode, FoundNode, Node};
 use crate::utils::asyncevent::AsyncEvent;
 use crate::utils::buffd::MsgParser;
+use crate::utils::buffd::MsgParserError;
 use crate::utils::clonecell::CloneCell;
 use crate::utils::copyhashmap::CopyHashMap;
 use crate::utils::linkedlist::LinkedList;
 use crate::utils::smallmap::SmallMap;
+use crate::wire::wl_seat::*;
+use crate::wire::{
+    WlDataDeviceId, WlDataOfferId, WlKeyboardId, WlPointerId, WlSeatId,
+    ZwpPrimarySelectionDeviceV1Id, ZwpPrimarySelectionOfferV1Id,
+};
 use crate::xkbcommon::{XkbContext, XkbState};
 use crate::{NumCell, State};
 use ahash::{AHashMap, AHashSet};
@@ -38,9 +44,6 @@ use std::io::Write;
 use std::rc::Rc;
 use thiserror::Error;
 use uapi::{c, OwnedFd};
-use crate::wire::wl_seat::*;
-use crate::utils::buffd::MsgParserError;
-use crate::wire::{WlDataDeviceId, WlDataOfferId, WlKeyboardId, WlPointerId, WlSeatId, ZwpPrimarySelectionDeviceV1Id, ZwpPrimarySelectionOfferV1Id};
 
 const POINTER: u32 = 1;
 const KEYBOARD: u32 = 2;

src/ifs/wl_seat/handling.rs

@@ -1,5 +1,5 @@
 use crate::backend::{KeyState, OutputId, ScrollAxis, SeatEvent, SeatId};
-use crate::client::{ClientId};
+use crate::client::ClientId;
 use crate::fixed::Fixed;
 use crate::ifs::wl_data_device::WlDataDevice;
 use crate::ifs::wl_seat::wl_keyboard::WlKeyboard;
@@ -14,10 +14,10 @@ use crate::ifs::wl_surface::WlSurface;
 use crate::ifs::zwp_primary_selection_device_v1::ZwpPrimarySelectionDeviceV1;
 use crate::tree::{FloatNode, FoundNode, Node};
 use crate::utils::smallmap::SmallMap;
+use crate::wire::{WlDataOfferId, ZwpPrimarySelectionOfferV1Id};
 use crate::xkbcommon::{ModifierState, XKB_KEY_DOWN, XKB_KEY_UP};
 use std::ops::{Deref, DerefMut};
 use std::rc::Rc;
-use crate::wire::{WlDataOfferId, ZwpPrimarySelectionOfferV1Id};
 
 #[derive(Default)]
 pub struct NodeSeatState {

src/ifs/wl_seat/wl_keyboard.rs

@@ -1,14 +1,13 @@
-
-use crate::client::{ClientError};
+use crate::client::ClientError;
 use crate::ifs::wl_seat::WlSeat;
 use crate::object::Object;
 use crate::utils::buffd::MsgParser;
+use crate::utils::buffd::MsgParserError;
+use crate::wire::wl_keyboard::*;
+use crate::wire::{WlKeyboardId, WlSurfaceId};
 use std::rc::Rc;
 use thiserror::Error;
 use uapi::{c, Errno, OwnedFd};
-use crate::wire::wl_keyboard::*;
-use crate::utils::buffd::MsgParserError;
-use crate::wire::{WlKeyboardId, WlSurfaceId};
 
 pub const REPEAT_INFO_SINCE: u32 = 4;
 
@@ -71,12 +70,7 @@ impl WlKeyboard {
         })
     }
 
-    pub fn send_enter(
-        self: &Rc<Self>,
-        serial: u32,
-        surface: WlSurfaceId,
-        keys: &[u32],
-    ) {
+    pub fn send_enter(self: &Rc<Self>, serial: u32, surface: WlSurfaceId, keys: &[u32]) {
         self.seat.client.event(Enter {
             self_id: self.id,
             serial,

src/ifs/wl_seat/wl_pointer.rs

@@ -1,16 +1,15 @@
-
-use crate::client::{ClientError};
+use crate::client::ClientError;
 use crate::cursor::Cursor;
 use crate::fixed::Fixed;
 use crate::ifs::wl_seat::WlSeat;
+use crate::ifs::wl_surface::WlSurfaceError;
 use crate::object::Object;
 use crate::utils::buffd::MsgParser;
+use crate::utils::buffd::MsgParserError;
+use crate::wire::wl_pointer::*;
+use crate::wire::{WlPointerId, WlSurfaceId};
 use std::rc::Rc;
 use thiserror::Error;
-use crate::ifs::wl_surface::WlSurfaceError;
-use crate::wire::wl_pointer::*;
-use crate::utils::buffd::MsgParserError;
-use crate::wire::{WlPointerId, WlSurfaceId};
 
 #[allow(dead_code)]
 const ROLE: u32 = 0;
@@ -45,13 +44,7 @@ impl WlPointer {
         }
     }
 
-    pub fn send_enter(
-        &self,
-        serial: u32,
-        surface: WlSurfaceId,
-        x: Fixed,
-        y: Fixed,
-    ) {
+    pub fn send_enter(&self, serial: u32, surface: WlSurfaceId, x: Fixed, y: Fixed) {
         self.seat.client.event(Enter {
             self_id: self.id,
             serial,
@@ -78,13 +71,7 @@ impl WlPointer {
         })
     }
 
-    pub fn send_button(
-        &self,
-        serial: u32,
-        time: u32,
-        button: u32,
-        state: u32,
-    ) {
+    pub fn send_button(&self, serial: u32, time: u32, button: u32, state: u32) {
         self.seat.client.event(Button {
             self_id: self.id,
             serial,

src/ifs/wl_seat/wl_touch.rs

@@ -1,13 +1,12 @@
-
+use crate::client::ClientError;
 use crate::ifs::wl_seat::WlSeat;
 use crate::object::Object;
 use crate::utils::buffd::MsgParser;
+use crate::utils::buffd::MsgParserError;
+use crate::wire::wl_touch::*;
+use crate::wire::WlTouchId;
 use std::rc::Rc;
 use thiserror::Error;
-use crate::client::ClientError;
-use crate::wire::wl_touch::*;
-use crate::utils::buffd::MsgParserError;
-use crate::wire::WlTouchId;
 
 #[allow(dead_code)]
 const DOWN: u32 = 0;

src/ifs/wl_shm.rs

@@ -1,15 +1,14 @@
-
 use crate::client::{Client, ClientError};
 use crate::format::FORMATS;
 use crate::globals::{Global, GlobalName};
 use crate::ifs::wl_shm_pool::{WlShmPool, WlShmPoolError};
 use crate::object::Object;
 use crate::utils::buffd::MsgParser;
+use crate::utils::buffd::MsgParserError;
+use crate::wire::wl_shm::*;
+use crate::wire::WlShmId;
 use std::rc::Rc;
 use thiserror::Error;
-use crate::wire::wl_shm::*;
-use crate::utils::buffd::MsgParserError;
-use crate::wire::WlShmId;
 
 pub struct WlShmGlobal {
     name: GlobalName,

src/ifs/wl_shm_pool.rs

@@ -1,18 +1,17 @@
-
 use crate::client::{Client, ClientError};
 use crate::clientmem::ClientMem;
 use crate::format::{formats, map_wayland_format_id};
 use crate::ifs::wl_buffer::{WlBuffer, WlBufferError};
 use crate::object::Object;
 use crate::utils::buffd::MsgParser;
+use crate::utils::buffd::MsgParserError;
 use crate::utils::clonecell::CloneCell;
+use crate::wire::wl_shm_pool::*;
+use crate::wire::WlShmPoolId;
+use crate::ClientMemError;
 use std::rc::Rc;
 use thiserror::Error;
 use uapi::OwnedFd;
-use crate::ClientMemError;
-use crate::wire::wl_shm_pool::*;
-use crate::utils::buffd::MsgParserError;
-use crate::wire::WlShmPoolId;
 
 pub struct WlShmPool {
     id: WlShmPoolId,

src/ifs/wl_subcompositor.rs

@@ -1,14 +1,13 @@
-
 use crate::client::{Client, ClientError};
 use crate::globals::{Global, GlobalName};
 use crate::ifs::wl_surface::wl_subsurface::{WlSubsurface, WlSubsurfaceError};
 use crate::object::Object;
 use crate::utils::buffd::MsgParser;
+use crate::utils::buffd::MsgParserError;
+use crate::wire::wl_subcompositor::*;
+use crate::wire::WlSubcompositorId;
 use std::rc::Rc;
 use thiserror::Error;
-use crate::wire::wl_subcompositor::*;
-use crate::utils::buffd::MsgParserError;
-use crate::wire::WlSubcompositorId;
 
 #[allow(dead_code)]
 const BAD_SURFACE: u32 = 0;

src/ifs/wl_surface.rs

@@ -20,6 +20,8 @@ use crate::utils::buffd::{MsgParser, MsgParserError};
 use crate::utils::clonecell::CloneCell;
 use crate::utils::linkedlist::LinkedList;
 use crate::utils::smallmap::SmallMap;
+use crate::wire::wl_surface::*;
+use crate::wire::{WlOutputId, WlSurfaceId};
 use crate::xkbcommon::ModifierState;
 use crate::NumCell;
 use ahash::AHashMap;
@@ -28,8 +30,6 @@ use std::mem;
 use std::ops::{Deref, DerefMut};
 use std::rc::Rc;
 use thiserror::Error;
-use crate::wire::wl_surface::*;
-use crate::wire::{WlOutputId, WlSurfaceId};
 
 #[allow(dead_code)]
 const INVALID_SCALE: u32 = 0;

src/ifs/wl_surface/wl_subsurface.rs

@@ -1,4 +1,4 @@
-
+use crate::client::ClientError;
 use crate::ifs::wl_surface::{
     CommitAction, CommitContext, StackElement, SurfaceExt, SurfaceRole, WlSurface, WlSurfaceError,
     WlSurfaceId,
@@ -6,16 +6,15 @@ use crate::ifs::wl_surface::{
 use crate::object::Object;
 use crate::rect::Rect;
 use crate::utils::buffd::MsgParser;
+use crate::utils::buffd::MsgParserError;
 use crate::utils::linkedlist::LinkedNode;
+use crate::wire::wl_subsurface::*;
+use crate::wire::WlSubsurfaceId;
 use crate::NumCell;
 use std::cell::{Cell, RefCell};
 use std::ops::Deref;
 use std::rc::Rc;
 use thiserror::Error;
-use crate::client::ClientError;
-use crate::wire::wl_subsurface::*;
-use crate::utils::buffd::MsgParserError;
-use crate::wire::WlSubsurfaceId;
 
 #[allow(dead_code)]
 const BAD_SURFACE: u32 = 0;

src/ifs/wl_surface/xdg_surface.rs

@@ -2,7 +2,7 @@ pub mod xdg_popup;
 pub mod xdg_toplevel;
 
 use crate::backend::SeatId;
-use crate::client::{ClientError};
+use crate::client::ClientError;
 use crate::ifs::wl_seat::{NodeSeatState, WlSeatGlobal};
 use crate::ifs::wl_surface::xdg_surface::xdg_popup::{XdgPopup, XdgPopupError};
 use crate::ifs::wl_surface::xdg_surface::xdg_toplevel::XdgToplevel;
@@ -14,16 +14,16 @@ use crate::object::Object;
 use crate::rect::Rect;
 use crate::tree::{FindTreeResult, FoundNode, Node, WorkspaceNode};
 use crate::utils::buffd::MsgParser;
+use crate::utils::buffd::MsgParserError;
 use crate::utils::clonecell::CloneCell;
 use crate::utils::copyhashmap::CopyHashMap;
 use crate::utils::smallmap::SmallMap;
+use crate::wire::xdg_surface::*;
+use crate::wire::{WlSurfaceId, XdgPopupId, XdgSurfaceId};
 use crate::NumCell;
 use std::cell::Cell;
 use std::rc::Rc;
 use thiserror::Error;
-use crate::wire::xdg_surface::*;
-use crate::utils::buffd::MsgParserError;
-use crate::wire::{WlSurfaceId, XdgPopupId, XdgSurfaceId};
 
 #[allow(dead_code)]
 const NOT_CONSTRUCTED: u32 = 1;

src/ifs/wl_surface/xdg_surface/xdg_popup.rs

@@ -1,4 +1,3 @@
-
 use crate::client::{Client, ClientError};
 use crate::cursor::KnownCursor;
 use crate::fixed::Fixed;
@@ -10,14 +9,14 @@ use crate::rect::Rect;
 use crate::render::Renderer;
 use crate::tree::{FindTreeResult, FoundNode, Node, NodeId, WorkspaceNode};
 use crate::utils::buffd::MsgParser;
+use crate::utils::buffd::MsgParserError;
 use crate::utils::clonecell::CloneCell;
 use crate::utils::linkedlist::LinkedNode;
+use crate::wire::xdg_popup::*;
+use crate::wire::XdgPopupId;
 use std::cell::{Cell, RefCell};
 use std::rc::Rc;
 use thiserror::Error;
-use crate::wire::xdg_popup::*;
-use crate::utils::buffd::MsgParserError;
-use crate::wire::XdgPopupId;
 
 #[allow(dead_code)]
 const INVALID_GRAB: u32 = 1;
@@ -76,7 +75,10 @@ impl XdgPopup {
     }
 
     fn send_popup_done(&self) {
-        self.xdg.surface.client.event(PopupDone { self_id: self.id })
+        self.xdg
+            .surface
+            .client
+            .event(PopupDone { self_id: self.id })
     }
 
     fn update_position(&self, parent: &XdgSurface) -> Result<(), XdgPopupError> {
@@ -206,12 +208,7 @@ impl XdgPopup {
             self.update_position(&parent)?;
             let rel = self.relative_position.get();
             self.send_repositioned(req.token);
-            self.send_configure(
-                rel.x1(),
-                rel.y1(),
-                rel.width(),
-                rel.height(),
-            );
+            self.send_configure(rel.x1(), rel.y1(), rel.width(), rel.height());
             self.xdg.do_send_configure();
         }
         Ok(())
@@ -303,12 +300,7 @@ impl XdgSurfaceExt for XdgPopup {
         if let Some(parent) = self.parent.get() {
             self.update_position(&parent)?;
             let rel = self.relative_position.get();
-            self.send_configure(
-                rel.x1(),
-                rel.y1(),
-                rel.width(),
-                rel.height(),
-            );
+            self.send_configure(rel.x1(), rel.y1(), rel.width(), rel.height());
         }
         Ok(())
     }

src/ifs/wl_surface/xdg_surface/xdg_toplevel.rs

@@ -1,4 +1,3 @@
-
 use crate::backend::SeatId;
 use crate::bugs::Bugs;
 use crate::client::{Client, ClientError};
@@ -12,9 +11,12 @@ use crate::render::Renderer;
 use crate::tree::{ContainerNode, FindTreeResult};
 use crate::tree::{FloatNode, FoundNode, Node, NodeId, ToplevelNodeId, WorkspaceNode};
 use crate::utils::buffd::MsgParser;
+use crate::utils::buffd::MsgParserError;
 use crate::utils::clonecell::CloneCell;
 use crate::utils::linkedlist::LinkedNode;
 use crate::utils::smallmap::SmallMap;
+use crate::wire::xdg_toplevel::*;
+use crate::wire::XdgToplevelId;
 use crate::{bugs, NumCell};
 use ahash::{AHashMap, AHashSet};
 use num_derive::FromPrimitive;
@@ -22,9 +24,6 @@ use std::cell::{Cell, RefCell};
 use std::mem;
 use std::rc::Rc;
 use thiserror::Error;
-use crate::wire::xdg_toplevel::*;
-use crate::utils::buffd::MsgParserError;
-use crate::wire::XdgToplevelId;
 
 #[derive(Copy, Clone, Debug, FromPrimitive)]
 pub enum ResizeEdge {

src/ifs/xdg_positioner.rs

@@ -1,16 +1,15 @@
-
 use crate::client::{Client, ClientError};
 use crate::ifs::xdg_wm_base::XdgWmBase;
 use crate::object::Object;
 use crate::rect::Rect;
 use crate::utils::buffd::MsgParser;
+use crate::utils::buffd::MsgParserError;
+use crate::wire::xdg_positioner::*;
+use crate::wire::XdgPositionerId;
 use bitflags::bitflags;
 use std::cell::RefCell;
 use std::rc::Rc;
 use thiserror::Error;
-use crate::wire::xdg_positioner::*;
-use crate::utils::buffd::MsgParserError;
-use crate::wire::XdgPositionerId;
 
 const INVALID_INPUT: u32 = 0;
 

src/ifs/xdg_wm_base.rs

@@ -1,16 +1,15 @@
-
 use crate::client::{Client, ClientError};
 use crate::globals::{Global, GlobalName};
 use crate::ifs::wl_surface::xdg_surface::{XdgSurface, XdgSurfaceError};
 use crate::ifs::xdg_positioner::XdgPositioner;
 use crate::object::Object;
 use crate::utils::buffd::MsgParser;
+use crate::utils::buffd::MsgParserError;
 use crate::utils::copyhashmap::CopyHashMap;
+use crate::wire::xdg_wm_base::*;
+use crate::wire::{XdgSurfaceId, XdgWmBaseId};
 use std::rc::Rc;
 use thiserror::Error;
-use crate::wire::xdg_wm_base::*;
-use crate::utils::buffd::MsgParserError;
-use crate::wire::{XdgSurfaceId, XdgWmBaseId};
 
 #[allow(dead_code)]
 const ROLE: u32 = 0;

src/ifs/zwp_linux_buffer_params_v1.rs

@@ -1,19 +1,18 @@
-use crate::client::{ClientError};
+use crate::client::ClientError;
 use crate::drm::dma::{DmaBuf, DmaBufPlane};
 use crate::drm::INVALID_MODIFIER;
-use crate::ifs::wl_buffer::{WlBuffer};
+use crate::ifs::wl_buffer::WlBuffer;
 use crate::ifs::zwp_linux_dmabuf_v1::ZwpLinuxDmabufV1;
 use crate::object::Object;
 use crate::utils::buffd::MsgParser;
+use crate::utils::buffd::MsgParserError;
+use crate::wire::zwp_linux_buffer_params_v1::*;
+use crate::wire::{WlBufferId, ZwpLinuxBufferParamsV1Id};
 use crate::{ErrorFmt, RenderError};
 use ahash::AHashMap;
 use std::cell::{Cell, RefCell};
 use std::rc::Rc;
 use thiserror::Error;
-use crate::wire::zwp_linux_buffer_params_v1::*;
-use crate::utils::buffd::MsgParserError;
-use crate::wire::{WlBufferId, ZwpLinuxBufferParamsV1Id};
-
 
 #[allow(dead_code)]
 const Y_INVERT: u32 = 1;

src/ifs/zwp_linux_dmabuf_v1.rs

@@ -4,12 +4,11 @@ use crate::globals::{Global, GlobalName};
 use crate::ifs::zwp_linux_buffer_params_v1::ZwpLinuxBufferParamsV1;
 use crate::object::Object;
 use crate::utils::buffd::MsgParser;
+use crate::utils::buffd::MsgParserError;
+use crate::wire::zwp_linux_dmabuf_v1::*;
+use crate::wire::ZwpLinuxDmabufV1Id;
 use std::rc::Rc;
 use thiserror::Error;
-use crate::wire::zwp_linux_dmabuf_v1::*;
-use crate::utils::buffd::MsgParserError;
-use crate::wire::ZwpLinuxDmabufV1Id;
-
 
 pub struct ZwpLinuxDmabufV1Global {
     name: GlobalName,

src/ifs/zwp_primary_selection_device_manager_v1.rs

@@ -1,15 +1,14 @@
-
 use crate::client::{Client, ClientError};
 use crate::globals::{Global, GlobalName};
 use crate::ifs::zwp_primary_selection_device_v1::ZwpPrimarySelectionDeviceV1;
 use crate::ifs::zwp_primary_selection_source_v1::ZwpPrimarySelectionSourceV1;
 use crate::object::Object;
 use crate::utils::buffd::MsgParser;
+use crate::utils::buffd::MsgParserError;
+use crate::wire::zwp_primary_selection_device_manager_v1::*;
+use crate::wire::ZwpPrimarySelectionDeviceManagerV1Id;
 use std::rc::Rc;
 use thiserror::Error;
-use crate::wire::zwp_primary_selection_device_manager_v1::*;
-use crate::utils::buffd::MsgParserError;
-use crate::wire::ZwpPrimarySelectionDeviceManagerV1Id;
 
 pub struct ZwpPrimarySelectionDeviceManagerV1Global {
     name: GlobalName,

src/ifs/zwp_primary_selection_device_v1.rs

@@ -1,14 +1,13 @@
-
-use crate::client::{ClientError};
+use crate::client::ClientError;
 use crate::ifs::wl_seat::WlSeat;
 use crate::ifs::zwp_primary_selection_device_manager_v1::ZwpPrimarySelectionDeviceManagerV1;
+use crate::ifs::zwp_primary_selection_source_v1::ZwpPrimarySelectionSourceV1Error;
 use crate::object::Object;
 use crate::utils::buffd::{MsgParser, MsgParserError};
-use std::rc::Rc;
-use thiserror::Error;
-use crate::ifs::zwp_primary_selection_source_v1::ZwpPrimarySelectionSourceV1Error;
 use crate::wire::zwp_primary_selection_device_v1::*;
 use crate::wire::{ZwpPrimarySelectionDeviceV1Id, ZwpPrimarySelectionOfferV1Id};
+use std::rc::Rc;
+use thiserror::Error;
 
 pub struct ZwpPrimarySelectionDeviceV1 {
     pub id: ZwpPrimarySelectionDeviceV1Id,

src/ifs/zwp_primary_selection_offer_v1.rs

@@ -1,15 +1,15 @@
-use std::mem;
 use crate::client::{Client, ClientError};
 use crate::ifs::wl_seat::WlSeatGlobal;
 use crate::ifs::zwp_primary_selection_source_v1::ZwpPrimarySelectionSourceV1;
 use crate::object::Object;
 use crate::utils::buffd::{MsgParser, MsgParserError};
 use crate::utils::clonecell::CloneCell;
+use crate::wire::zwp_primary_selection_offer_v1::*;
+use crate::wire::ZwpPrimarySelectionOfferV1Id;
+use std::mem;
 use std::ops::Deref;
 use std::rc::Rc;
 use thiserror::Error;
-use crate::wire::zwp_primary_selection_offer_v1::*;
-use crate::wire::ZwpPrimarySelectionOfferV1Id;
 
 pub struct ZwpPrimarySelectionOfferV1 {
     pub id: ZwpPrimarySelectionOfferV1Id,

src/ifs/zwp_primary_selection_source_v1.rs

@@ -1,17 +1,16 @@
-
 use crate::client::{Client, ClientError};
 use crate::ifs::wl_seat::WlSeatGlobal;
 use crate::ifs::zwp_primary_selection_offer_v1::ZwpPrimarySelectionOfferV1;
 use crate::object::Object;
 use crate::utils::buffd::{MsgParser, MsgParserError};
 use crate::utils::clonecell::CloneCell;
+use crate::wire::zwp_primary_selection_source_v1::*;
+use crate::wire::ZwpPrimarySelectionSourceV1Id;
 use ahash::AHashSet;
 use std::cell::RefCell;
 use std::rc::Rc;
 use thiserror::Error;
 use uapi::OwnedFd;
-use crate::wire::zwp_primary_selection_source_v1::*;
-use crate::wire::ZwpPrimarySelectionSourceV1Id;
 
 pub struct ZwpPrimarySelectionSourceV1 {
     pub id: ZwpPrimarySelectionSourceV1Id,

src/ifs/zxdg_decoration_manager_v1.rs

@@ -3,11 +3,10 @@ use crate::globals::{Global, GlobalName};
 use crate::ifs::zxdg_toplevel_decoration_v1::ZxdgToplevelDecorationV1;
 use crate::object::Object;
 use crate::utils::buffd::{MsgParser, MsgParserError};
-use std::rc::Rc;
-use thiserror::Error;
 use crate::wire::zxdg_decoration_manager_v1::*;
 use crate::wire::ZxdgDecorationManagerV1Id;
-
+use std::rc::Rc;
+use thiserror::Error;
 
 pub struct ZxdgDecorationManagerV1Global {
     name: GlobalName,

src/ifs/zxdg_toplevel_decoration_v1.rs

@@ -1,12 +1,11 @@
-
 use crate::client::{Client, ClientError};
 use crate::ifs::wl_surface::xdg_surface::xdg_toplevel::{Decoration, XdgToplevel};
 use crate::object::Object;
 use crate::utils::buffd::{MsgParser, MsgParserError};
-use std::rc::Rc;
-use thiserror::Error;
 use crate::wire::zxdg_toplevel_decoration_v1::*;
 use crate::wire::ZxdgToplevelDecorationV1Id;
+use std::rc::Rc;
+use thiserror::Error;
 
 const CLIENT_SIDE: u32 = 1;
 const SERVER_SIDE: u32 = 2;

src/main.rs

@@ -67,8 +67,8 @@ mod time;
 mod tree;
 mod utils;
 mod wheel;
-mod xkbcommon;
 mod wire;
+mod xkbcommon;
 
 fn main() {
     env_logger::builder()

src/object.rs

@@ -1,8 +1,8 @@
 use crate::client::ClientError;
 use crate::utils::buffd::MsgParser;
+use crate::wire::WlDisplayId;
 use std::fmt::{Display, Formatter};
 use std::rc::Rc;
-use crate::wire::WlDisplayId;
 
 pub const WL_DISPLAY_ID: WlDisplayId = WlDisplayId::from_raw(1);
 

src/utils/buffd/buf_out.rs

@@ -1,11 +1,11 @@
 use crate::async_engine::{AsyncFd, Timeout};
 use crate::utils::buffd::{BufFdError, BUF_SIZE, CMSG_BUF_SIZE};
+use futures::future::Fuse;
 use futures::{select, FutureExt};
 use std::collections::VecDeque;
 use std::mem::MaybeUninit;
 use std::rc::Rc;
 use std::{mem, slice};
-use futures::future::Fuse;
 use uapi::{c, Errno, OwnedFd};
 
 pub(super) const OUT_BUF_SIZE: usize = 2 * BUF_SIZE;
@@ -90,7 +90,11 @@ impl BufFdOut {
         }
     }
 
-    pub async fn flush(&mut self, buf: &mut OutBuffer, timeout: &mut Option<Fuse<Timeout>>) -> Result<(), BufFdError> {
+    pub async fn flush(
+        &mut self,
+        buf: &mut OutBuffer,
+        timeout: &mut Option<Fuse<Timeout>>,
+    ) -> Result<(), BufFdError> {
         while buf.read_pos < buf.write_pos {
             if self.flush_sync(buf)? {
                 self.fd.writable().await?;

src/utils/buffd/formatter.rs

@@ -73,7 +73,8 @@ impl<'a> MsgFormatter<'a> {
             f(&mut fmt);
             let len = self.buf.write_pos - pos - 4;
             let none = [MaybeUninit::new(0); 4];
-            self.buf.write(&none[..self.buf.write_pos.wrapping_neg() & 3]);
+            self.buf
+                .write(&none[..self.buf.write_pos.wrapping_neg() & 3]);
             len as u32
         };
         unsafe {
@@ -86,7 +87,8 @@ impl<'a> MsgFormatter<'a> {
         self.uint(mem::size_of_val(t) as u32);
         self.buf.write(uapi::as_maybe_uninit_bytes(t));
         let none = [MaybeUninit::new(0); 4];
-        self.buf.write(&none[..self.buf.write_pos.wrapping_neg() & 3]);
+        self.buf
+            .write(&none[..self.buf.write_pos.wrapping_neg() & 3]);
         self
     }
 

src/utils/buffd/parser.rs

@@ -1,10 +1,10 @@
-use std::{mem, ptr};
-use std::rc::Rc;
 use crate::fixed::Fixed;
 use crate::globals::GlobalName;
 use crate::object::ObjectId;
 use crate::utils::buffd::BufFdIn;
 use bstr::{BStr, ByteSlice};
+use std::rc::Rc;
+use std::{mem, ptr};
 use thiserror::Error;
 use uapi::{OwnedFd, Pod};
 
@@ -76,7 +76,7 @@ impl<'a, 'b> MsgParser<'a, 'b> {
         if s.len() == 0 {
             return Err(MsgParserError::EmptyString);
         }
-        Ok(s[..s.len()-1].as_bstr())
+        Ok(s[..s.len() - 1].as_bstr())
     }
 
     pub fn str(&mut self) -> Result<&'b str, MsgParserError> {
@@ -120,9 +120,7 @@ impl<'a, 'b> MsgParser<'a, 'b> {
         if array.len() > mem::size_of::<T>() {
             return Err(MsgParserError::BinaryArrayTooLarge);
         }
-        unsafe {
-            Ok(ptr::read_unaligned(array.as_ptr() as _))
-        }
+        unsafe { Ok(ptr::read_unaligned(array.as_ptr() as _)) }
     }
 
     pub fn binary_array<T: Pod>(&mut self) -> Result<&'b [T], MsgParserError> {
@@ -137,7 +135,10 @@ impl<'a, 'b> MsgParser<'a, 'b> {
             return Err(MsgParserError::BinaryArraySize);
         }
         unsafe {
-            Ok(std::slice::from_raw_parts(array.as_ptr() as _, array.len() / mem::size_of::<T>()))
+            Ok(std::slice::from_raw_parts(
+                array.as_ptr() as _,
+                array.len() / mem::size_of::<T>(),
+            ))
         }
     }
 }